From: Dru Moore Date: Thu, 18 Nov 2010 00:01:44 +0000 (+0000) Subject: Initial commit X-Git-Url: http://git.maemo.org/git/?p=fillmore;a=commitdiff_plain;h=a712cd772f4f3db8bed7037bb95c4de94767b230 Initial commit new file: AUTHORS new file: COPYING new file: INSTALL new file: MAINTAINERS new file: Makefile new file: NEWS new file: README new file: THANKS new file: configure new file: configure.mk new file: libfill.so new file: marina.mk new file: minver new file: misc/fillmore.desktop new file: misc/fillmore.xml new file: misc/lombard.desktop new file: misc/lombard.xml new file: resources/dot.png new file: resources/fillmore.glade new file: resources/fillmore.rc new file: resources/fillmore.svg new file: resources/fillmore_icon.png new file: resources/lombard.svg new file: resources/lombard_icon.png new file: resources/max_speaker.png new file: resources/min_speaker.png new file: src/fillmore/FillmoreClassFactory.vala new file: src/fillmore/Makefile new file: src/fillmore/ProjectProperties.vala new file: src/fillmore/VolumeAndPanPopUp.vala new file: src/fillmore/audio_project.vala new file: src/fillmore/fillmore.vala new file: src/fillmore/fillmore/.stamp new file: src/fillmore/fillmore/FillmoreClassFactory.c new file: src/fillmore/fillmore/FillmoreClassFactory.o new file: src/fillmore/fillmore/ProjectProperties.c new file: src/fillmore/fillmore/ProjectProperties.o new file: src/fillmore/fillmore/VolumeAndPanPopUp.c new file: src/fillmore/fillmore/VolumeAndPanPopUp.o new file: src/fillmore/fillmore/audio_project.c new file: src/fillmore/fillmore/audio_project.o new file: src/fillmore/fillmore/fillmore.c new file: src/fillmore/fillmore/fillmore.o new file: src/fillmore/fillmore/header_area.c new file: src/fillmore/fillmore/header_area.o new file: src/fillmore/fillmore/trackinformation.c new file: src/fillmore/fillmore/trackinformation.o new file: src/fillmore/header_area.vala new file: src/fillmore/sources.mk new file: src/fillmore/trackinformation.vala new file: src/lombard/Makefile new file: src/lombard/lombard.vala new file: src/lombard/lombard/.stamp new file: src/lombard/lombard/lombard.c new file: src/lombard/lombard/lombard.o new file: src/lombard/lombard/video_project.c new file: src/lombard/lombard/video_project.o new file: src/lombard/sources.mk new file: src/lombard/video_project.vala new file: src/marina/AppDirs.vala new file: src/marina/AudioMeter.vala new file: src/marina/ClassFactory.vala new file: src/marina/ClipLibraryView.vala new file: src/marina/DialogUtils.vala new file: src/marina/Logging.vala new file: src/marina/Makefile new file: src/marina/MediaEngine.vala new file: src/marina/MultiFileProgress.vala new file: src/marina/ProjectLoader.vala new file: src/marina/Ruler.vala new file: src/marina/StatusBar.vala new file: src/marina/TimeSystem.vala new file: src/marina/TrackView.vala new file: src/marina/TransportDelegate.vala new file: src/marina/UndoManager.vala new file: src/marina/clip.vala new file: src/marina/command.vala new file: src/marina/import.vala new file: src/marina/libmarina.a new file: src/marina/marina.h new file: src/marina/marina/.stamp new file: src/marina/marina/AppDirs.c new file: src/marina/marina/AppDirs.o new file: src/marina/marina/AudioMeter.c new file: src/marina/marina/AudioMeter.o new file: src/marina/marina/ClassFactory.c new file: src/marina/marina/ClassFactory.o new file: src/marina/marina/ClipLibraryView.c new file: src/marina/marina/ClipLibraryView.o new file: src/marina/marina/DialogUtils.c new file: src/marina/marina/DialogUtils.o new file: src/marina/marina/Logging.c new file: src/marina/marina/Logging.o new file: src/marina/marina/MediaEngine.c new file: src/marina/marina/MediaEngine.o new file: src/marina/marina/MultiFileProgress.c new file: src/marina/marina/MultiFileProgress.o new file: src/marina/marina/ProjectLoader.c new file: src/marina/marina/ProjectLoader.o new file: src/marina/marina/Ruler.c new file: src/marina/marina/Ruler.o new file: src/marina/marina/StatusBar.c new file: src/marina/marina/StatusBar.o new file: src/marina/marina/TimeSystem.c new file: src/marina/marina/TimeSystem.o new file: src/marina/marina/TrackView.c new file: src/marina/marina/TrackView.o new file: src/marina/marina/TransportDelegate.c new file: src/marina/marina/TransportDelegate.o new file: src/marina/marina/UndoManager.c new file: src/marina/marina/UndoManager.o new file: src/marina/marina/clip.c new file: src/marina/marina/clip.o new file: src/marina/marina/command.c new file: src/marina/marina/command.o new file: src/marina/marina/import.c new file: src/marina/marina/import.o new file: src/marina/marina/marina.vapi new file: src/marina/marina/project.c new file: src/marina/marina/project.o new file: src/marina/marina/singledecodebin.c new file: src/marina/marina/singledecodebin.o new file: src/marina/marina/thumbnailsink.c new file: src/marina/marina/thumbnailsink.o new file: src/marina/marina/timeline.c new file: src/marina/marina/timeline.o new file: src/marina/marina/track.c new file: src/marina/marina/track.o new file: src/marina/marina/ui_clip.c new file: src/marina/marina/ui_clip.o new file: src/marina/marina/util.c new file: src/marina/marina/util.o new file: src/marina/marina/video_track.c new file: src/marina/marina/video_track.o new file: src/marina/project.vala new file: src/marina/singledecodebin.vala new file: src/marina/sources.mk new file: src/marina/thumbnailsink.vala new file: src/marina/timeline.vala new file: src/marina/track.vala new file: src/marina/ui_clip.vala new file: src/marina/util.vala new file: src/marina/video_track.vala new file: src/test/Makefile new file: src/test/debug/.stamp new file: src/test/debug/Logging.c new file: src/test/debug/Logging.o new file: src/test/debug/ProjectLoader.c new file: src/test/debug/ProjectLoader.o new file: src/test/debug/ProjectLoading.c new file: src/test/debug/ProjectLoading.o new file: src/test/debug/test.c new file: src/test/debug/test.o new file: src/test/debug/util.c new file: src/test/debug/util.o new file: src/test/marina/ProjectLoading.vala new file: src/test/sources.mk new file: src/test/test.vala new file: www/index.html --- diff --git a/AUTHORS b/AUTHORS new file mode 100644 index 0000000..82070f4 --- /dev/null +++ b/AUTHORS @@ -0,0 +1,5 @@ +Robert Powell +Adam Dingle +Andrew O'Mahony +Dru Moore + diff --git a/COPYING b/COPYING new file mode 100644 index 0000000..3b575d1 --- /dev/null +++ b/COPYING @@ -0,0 +1,465 @@ +This program 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. + + + 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 + diff --git a/INSTALL b/INSTALL new file mode 100644 index 0000000..c6caad9 --- /dev/null +++ b/INSTALL @@ -0,0 +1,50 @@ + + Fillmore Installation + --------------------- + + To build and install Fillmore, type the following commands: + + $ ./configure + $ make fillmore + $ make install-fillmore + + * By default, Fillmore will install under /usr/local. The configure script + can customize the prefix directory. Run ./configure --help for + instructions and other installation options. + + * You may need to execute "make install" as root (i.e. sudo make install) + if installing to system directories. + + * If you wish to try Fillmore before installing it, you may execute it + directly from its build directory. Note that certain desktop integration + (such as being listed in an application menu) requires full installation. + + Once installed, Fillmore will be available on your desktop Applications + menu under Sound & Video. + + + Lombard Installation + -------------------- + + To build and install Lombard, type the following commands: + + $ ./configure + $ make lombard + $ make install-lombard + + * By default, Lombard will install under /usr/local. The configure script + can customize the prefix directory. Run ./configure --help for + instructions and other installation options. + + * You may need to execute "make install" as root (i.e. sudo make install) + if installing to system directories. + + * If you wish to try Lombard before installing it, you may execute it + directly from its build directory. Note that certain desktop integration + (such as being listed in an application menu) requires full installation. + + Once installed, Lombard will be available on your desktop Applications + menu under Sound & Video. + + Copyright 2009-2010 Yorba Foundation + diff --git a/MAINTAINERS b/MAINTAINERS new file mode 100644 index 0000000..d86078f --- /dev/null +++ b/MAINTAINERS @@ -0,0 +1,3 @@ +Robert Powell +email: rob@yorba.org + diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..ff366b5 --- /dev/null +++ b/Makefile @@ -0,0 +1,116 @@ +default: all + +BUILD_ROOT = 1 + +VERSION = 0.1.0 +FILLMORE = fillmore +LOMBARD = lombard +MEDIA_TEST = media_test + +SRC_PREFIX=MARINA_ +-include src/marina/sources.mk +DIST_SRC_FILES = $(foreach src,$(MARINA_SRC_FILES), src/marina/$(src)) + +SRC_PREFIX=LOMBARD_ +-include src/lombard/sources.mk +DIST_SRC_FILES += $(foreach src, $(LOMBARD_SRC_FILES), src/lombard/$(src)) + +SRC_PREFIX=FILLMORE_ +-include src/fillmore/sources.mk +DIST_SRC_FILES += $(foreach src, $(FILLMORE_SRC_FILES), src/fillmore/$(src)) + +SRC_PREFIX=TEST_ +-include src/test/sources.mk +DIST_SRC_FILES += $(foreach src, $(TEST_SRC_FILES), src/test/$(src)) + +TEXT_FILES = \ + AUTHORS \ + COPYING \ + INSTALL \ + MAINTAINERS \ + NEWS \ + README \ + THANKS + +DIST_MAKEFILES = \ + Makefile \ + marina.mk \ + src/marina/Makefile \ + src/marina/sources.mk \ + src/fillmore/Makefile \ + src/fillmore/sources.mk \ + src/lombard/Makefile \ + src/lombard/sources.mk \ + src/test/Makefile \ + src/test/sources.mk + +DIST_NAME = media +DIST_FILES = $(DIST_MAKEFILES) configure minver $(DIST_SRC_FILES) $(EXPANDED_VAPI_FILES) \ + $(EXPANDED_SRC_HEADER_FILES) $(EXPANDED_RESOURCE_FILES) $(TEXT_FILES) resources/* misc/* + +DIST_TAR = $(DIST_NAME)-$(VERSION).tar +DIST_TAR_BZ2 = $(DIST_TAR).bz2 +DIST_TAR_GZ = $(DIST_TAR).gz +PACKAGE_ORIG_GZ = $(DIST_NAME)_`parsechangelog | grep Version | sed 's/.*: //'`.orig.tar.gz + +MARINA = marina/libmarina.a +.PHONY: $(FILLMORE) +.PHONY: $(LOMBARD) +.PHONY: $(MEDIA_TEST) +.PHONY: $(MARINA) + +$(MARINA): + export VERSION=$(VERSION); $(MAKE) --directory=src/marina + +$(FILLMORE): $(MARINA) + export PROGRAM_NAME=$(FILLMORE); $(MAKE) --directory=src/fillmore + +install: install-$(FILLMORE) install-$(LOMBARD) + + +uninstall: uninstall-$(FILLMORE) uninstall-$(LOMBARD) + + +install-$(FILLMORE): $(FILLMORE) + export PROGRAM_NAME=$(FILLMORE); \ + $(MAKE) --directory=src/fillmore install; \ + +uninstall-$(FILLMORE): + export PROGRAM_NAME=$(FILLMORE); \ + $(MAKE) --directory=src/fillmore uninstall; \ + +$(LOMBARD): $(MARINA) + export PROGRAM_NAME=$(LOMBARD); \ + $(MAKE) --directory=src/lombard; \ + +install-$(LOMBARD): $(LOMBARD) + export PROGRAM_NAME=$(LOMBARD); \ + $(MAKE) --directory=src/lombard install; \ + +uninstall-$(LOMBARD): + export PROGRAM_NAME=$(LOMBARD); \ + $(MAKE) --directory=src/lombard uninstall; \ + +$(MEDIA_TEST): + export PROGRAM_NAME=$(MEDIA_TEST); \ + $(MAKE) --directory=src/test; + +all: $(FILLMORE) $(LOMBARD) $(MEDIA_TEST) + + +clean: + $(MAKE) --directory=src/marina clean + export PROGRAM_NAME=$(FILLMORE); $(MAKE) --directory=src/fillmore clean + export PROGRAM_NAME=$(LOMBARD); $(MAKE) --directory=src/lombard clean + export PROGRAM_NAME=$(MEDIA_TEST); $(MAKE) --directory=src/test clean + +dist: $(DIST_FILES) + mkdir -p $(DIST_NAME)-$(VERSION) + cp --parents $(DIST_FILES) $(DIST_NAME)-$(VERSION) + tar --bzip2 -cvf $(DIST_TAR_BZ2) $(DIST_NAME)-$(VERSION) + tar --gzip -cvf $(DIST_TAR_GZ) $(DIST_NAME)-$(VERSION) + rm -rf $(DIST_NAME)-$(VERSION) + +distclean: clean + rm -f configure.mk + diff --git a/NEWS b/NEWS new file mode 100644 index 0000000..14931a9 --- /dev/null +++ b/NEWS @@ -0,0 +1,19 @@ +Fillmore 0.1.0 - +----------------------------- + + * Initial release. Features include: + - Recording from an input device. + - Support of source audio of a number of formats. + - Playback from multiple tracks. + - Positioning audio in stereo image. + - Optional metronome while playing or recording. + - Exporting project to OggVorbis format files. + - Desktop integration with Applications menu. + +Lombard 0.1.0 - +----------------------------- + + * Initial release. Features include: + - Source video and audio of a number of formats. + - Exporting project to OggTheora format files. + - Desktop integration with Applications menu. diff --git a/README b/README new file mode 100644 index 0000000..1f531c9 --- /dev/null +++ b/README @@ -0,0 +1,84 @@ + + Fillmore and Lombard Audio and Video editors + -------------------------------------------- + + * Introduction + + Fillmore is an audio editor designed for the GNOME desktop environment. + It allows you to record audio, place audio on multiple tracks, adjust + the position of the track in the stereo track and export your project + as a single stereo file. + + Visit http://www.yorba.org/fillmore to read about the current state of + Fillmore's development and to make sure you're running the latest version. + + Lombard is a video editor designed for the GNOME desktop environment. + It allows you to manipulate multiple video and audio clips and export + your project as a single video file. + + * Installation & Licensing + Please consult the INSTALL and COPYING files for more information. + + * Quick Start + +Fillmore + When you first run Fillmore, you will be presented with a window with three + sections: Track Header on the left, Timeline in the middle and Library on + on the left. The first task you will want to do is adjust the project + properties. + + From the File menu, select Settings. This displays the Project Properties + dialog. If you are recording music and want a metronome, select your time + signature and tempo. If you do not want a metronome, deselect the checkbox + "During record." + + Next, you will want to add audio. You can add audio to your project in two + different ways. + + * Drag audio: Drag audio files from the file manager either to a track on + the timeline or into the library. You will only hear audio for clips that + are on a track. + + * Record audio: Before launching Fillmore, plug a device for sound input + into your computer. In the Sound Preferences dialog, select this device + as the default input device. Launch Fillmore. Press the big red + button to record. To select which track is active for recording, select + the desired track by clicking in the track header area next to the track. + You can also click on the ruler to choose the time to start recording. + + Next, may want to position the audio on the timeline. You can change the + duration and location of the clips by dragging the clips. + + Once you have created your source material and are happy with it, you may + want to export your project. From the File menu, select Export. + +Lombard + When you first run Lombard, you will be presented with a window with three + sections: Library window on the left, Output window on the right and timeline + on the bottom. + + First, you will want to get video and audio into the project. From the file + manager, drag your video or audio into the library or the timeline. + + Next, you will want to position your clips. You can change the duration and + location of the clips by dragging the clips. + + Once you have arranged your material and are happy with it, you may want + to export your project. From the File menu, select Export. + + * Contacting Yorba + + Yorba: http://www.yorba.org + Fillmore project page: http://www.yorba.org/fillmore + Fillmore documentation: http://trac.yorba.org/wiki/UsingFillmore0.1 + Lombard project page: http://www.yorba.org/lombard + Lombard documentation http://www.yorba.org/wiki/UsingLombard0.1 + + We also encourage you to join the Fillmore and Lombard mailing lists. Send an email + with a subject: line of "subscribe" (no quotes) to + fillmore-request@lists.yorba.org + lombard-request@lists.yorba.org + + + Copyright 2009-2010 Yorba Foundation + diff --git a/THANKS b/THANKS new file mode 100644 index 0000000..ca61fe8 --- /dev/null +++ b/THANKS @@ -0,0 +1,4 @@ +We'd like to thank the following contributors: + +Matt Jones + diff --git a/configure b/configure new file mode 100755 index 0000000..e440cfd --- /dev/null +++ b/configure @@ -0,0 +1,84 @@ +#! /bin/bash +# +# Copyright 2009 Yorba Foundation +# +# This software is licensed under the GNU LGPL (version 2.1 or later). +# See the COPYING file in this distribution. + +CONFIG_IN=configure.mk + +configure_help() { + printf "\nUsage:\n" + printf "\t./configure [OPTIONS]...\n" + printf "\n" + printf "Options:\n" + printf "\t-h, --help\t\tPrint this help and exit.\n" + printf "\t--assume-pkgs\t\tTurn off package version checking.\n" + printf "\t--build=DIR\t\tBuild secondary files in DIR.\n" + printf "\t--debug | --release\tBuild executable for debugging or release.\n" + printf "\t\t\t\t[--release]\n" + printf "\t--define=SYMBOL\t\tDefine a symbol for the Vala compiler.\n" + printf "\n" +} + +abort() { + printf "%s: Invalid argument %s\n" $0 $1 + configure_help + exit 1 +} + +while [ $# != 0 ] +do + option=`echo $1 | sed 's/=.*//'` + if [ `echo $1 | grep '='` ] + then + value=`echo $1 | sed 's/.*=//'` + fi + + case $option in + -h | --help) configure_help + exit 0 + ;; + + --assume-pkgs) variables="${variables}ASSUME_PKGS=1\n" + ;; + + --build) if [ ! $value ] + then + abort $1 + fi + + variables="${variables}BUILD_DIR=$value\n" + variables="${variables}MARINA_VAPI=../marina/$value/marina.vapi\n" + ;; + + --debug) variables="${variables}BUILD_RELEASE=\nBUILD_DEBUG=1\n" + ;; + + --release) variables="${variables}BUILD_DEBUG=\nBUILD_RELEASE=1\n" + ;; + + --define) variables="${variables}USER_VALAFLAGS+=--define=$value\n" + ;; + + + *) if [ ! $value ] + then + abort $1 + fi + + variables="${variables}${option}=${value}\n" + ;; + esac + + shift +done + +rm -f $CONFIG_IN +if [ $variables ] +then + echo -e -n $variables > $CONFIG_IN +fi +echo "CONFIG_IN=../../${CONFIG_IN}" >> $CONFIG_IN + +printf "Configured. Type 'make' to build\n" diff --git a/configure.mk b/configure.mk new file mode 100644 index 0000000..086447a --- /dev/null +++ b/configure.mk @@ -0,0 +1 @@ +CONFIG_IN=../../configure.mk diff --git a/libfill.so b/libfill.so new file mode 100755 index 0000000..41e5874 Binary files /dev/null and b/libfill.so differ diff --git a/marina.mk b/marina.mk new file mode 100644 index 0000000..1320f7d --- /dev/null +++ b/marina.mk @@ -0,0 +1,176 @@ +VALAC = valac +MIN_VALAC_VERSION = 0.9.1 +# defaults that may be overridden by configure.mk +PREFIX=/usr/local + +INSTALL_PROGRAM = install +INSTALL_DATA = install -m 644 + +ifndef MARINA_VAPI +MARINA_VAPI = ../marina/marina/marina.vapi +endif + +ifdef USE_MARINA_VAPI +TEMP_MARINA_VAPI = $(MARINA_VAPI) +endif + +VAPI_DIRS = \ + ../../vapi + +HEADER_DIRS = \ + ../../vapi + +EXT_PKGS = \ + gee-1.0 \ + gdk-x11-2.0 \ + gstreamer-0.10 \ + gstreamer-base-0.10 \ + gstreamer-controller-0.10 \ + gstreamer-interfaces-0.10 \ + gstreamer-pbutils-0.10 \ + gtk+-2.0 \ + hildon-1 \ + hildon-fm-2 + + +EXT_PKG_VERSIONS = \ + gtk+-2.0 >= 2.14.0 \ + gee-1.0 >= 0.5.0 \ + gdk-x11-2.0 >= 2.14.7 \ + gstreamer-0.10 >= 0.10.25 \ + gstreamer-base-0.10 >= 0.10.25 \ + gstreamer-controller-0.10 >= 0.10.25 \ + gstreamer-interfaces-0.10 >= 0.10.25 \ + gstreamer-pbutils-0.10 >= 0.10.25 + +PKGS = $(EXT_PKGS) $(LOCAL_PKGS) + +EXPANDED_SRC_FILES = $(foreach src,$(SRC_FILES),./$(src)) +EXPANDED_C_FILES = $(foreach src,$(SRC_FILES),$(BUILD_DIR)/$(notdir $(src:.vala=.c))) +EXPANDED_SAVE_TEMPS_FILES = $(foreach src,$(SRC_FILES),$(BUILD_DIR)/$(notdir $(src:.vala=.vala.c))) +EXPANDED_OBJ_FILES = $(foreach src,$(SRC_FILES),$(BUILD_DIR)/$(notdir $(src:.vala=.o))) + +EXPANDED_VAPI_FILES = $(foreach vapi,$(VAPI_FILES),vapi/$(vapi)) +EXPANDED_SRC_HEADER_FILES = $(foreach header,$(SRC_HEADER_FILES),vapi/$(header)) +EXPANDED_RESOURCE_FILES = $(foreach res,$(RESOURCE_FILES),ui/$(res)) +VALA_STAMP = $(BUILD_DIR)/.stamp + +ifdef PROGRAM +DEFINES = _PROGRAM_NAME='"$(PROGRAM_NAME)"' +endif + +ifdef LIBRARY +DEFINES = _VERSION='"$(VERSION)"' _PREFIX='"$(PREFIX)"' +endif + +VALA_CFLAGS = `pkg-config --cflags $(EXT_PKGS)` $(foreach hdir,$(HEADER_DIRS),-I$(hdir)) \ + $(foreach def,$(DEFINES),-D$(def)) + +# setting CFLAGS in configure.mk overrides build type +ifndef CFLAGS +ifdef BUILD_DEBUG +CFLAGS = -O0 -g -pipe -fPIC +else +CFLAGS = -O2 -g -pipe -fPIC +endif +endif + +VALAFLAGS = -g --enable-checking --thread $(USER_VALAFLAGS) + +# We touch the C file so that we have a better chance of a valid executable. Bug #1778 +$(EXPANDED_C_FILES): $(VALA_STAMP) + touch $@ + +$(EXPANDED_OBJ_FILES): %.o: %.c $(CONFIG_IN) Makefile + $(CC) -c $(VALA_CFLAGS) $(CFLAGS) -o $@ $< + +install: + mkdir -p $(DESTDIR)$(PREFIX)/bin + $(INSTALL_PROGRAM) $(PROGRAM) $(DESTDIR)$(PREFIX)/bin + mkdir -p $(DESTDIR)$(PREFIX)/share/$(PROGRAM_NAME)/resources + $(INSTALL_DATA) ../../resources/* $(DESTDIR)$(PREFIX)/share/$(PROGRAM_NAME)/resources + mkdir -p $(DESTDIR)$(PREFIX)/share/icons/hicolor/scalable/apps + $(INSTALL_DATA) ../../resources/$(PROGRAM_NAME).svg $(DESTDIR)$(PREFIX)/share/icons/hicolor/scalable/apps +ifndef DISABLE_ICON_UPDATE + -gtk-update-icon-cache -f -t $(DESTDIR)$(PREFIX)/share/icons/hicolor || : +endif + mkdir -p $(DESTDIR)$(PREFIX)/share/applications + $(INSTALL_DATA) ../../misc/$(PROGRAM_NAME).desktop $(DESTDIR)$(PREFIX)/share/applications +ifndef DISABLE_DESKTOP_UPDATE + -update-desktop-database || : +endif + mkdir -p $(DESTDIR)$(PREFIX)/share/mime/packages + $(INSTALL_DATA) ../../misc/$(PROGRAM_NAME).xml $(DESTDIR)$(PREFIX)/share/mime/packages + -update-mime-database $(DESTDIR)$(PREFIX)/share/mime + +uninstall: + rm -f $(DESTDIR)$(PREFIX)/bin/$(PROGRAM_NAME) + rm -fr $(DESTDIR)$(PREFIX)/share/$(PROGRAM_NAME) + rm -fr $(DESTDIR)$(PREFIX)/share/icons/hicolor/scalable/apps/$(PROGRAM_NAME).svg + rm -f $(DESTDIR)$(PREFIX)/share/applications/$(PROGRAM_NAME).desktop + rm -f $(DESTDIR)$(PREFIX)/share/mime/packages/$(PROGRAM_NAME).xml + -update-mime-database $(DESTDIR)$(PREFIX)/share/mime + +$(VALA_STAMP): $(EXPANDED_SRC_FILES) $(EXPANDED_VAPI_FILES) $(EXPANDED_SRC_HEADER_FILES) Makefile \ + $(CONFIG_IN) $(TEMP_MARINA_VAPI) +ifndef PROGRAM +ifndef LIBRARY + @echo 'You must define either PROGRAM or LIBRARY in makefile'; exit 1 +endif +endif +ifdef PROGRAM +ifdef LIBRARY + @echo 'Both program and library are defined. This is invalid.'; exit 1 +endif +endif + @ ../../minver `valac --version | awk '{print $$2}'` $(MIN_VALAC_VERSION) || ( echo '$(PROGRAM)$(LIBRARY) requires Vala compiler $(MIN_VALAC_VERSION) or greater. You are running' `valac --version` '\b.'; exit 1 ) +ifndef ASSUME_PKGS +ifdef EXT_PKG_VERSIONS + pkg-config --print-errors --exists '$(EXT_PKG_VERSIONS)' +else ifdef EXT_PKGS + pkg-config --print-errors --exists $(EXT_PKGS) +endif +endif + mkdir -p $(BUILD_DIR) + $(VALAC) $(LIBRARY_NAME) --ccode --directory=$(BUILD_DIR) --basedir=src $(VALAFLAGS) \ + $(foreach header,$(HEADER_FILES), -H $(header)) \ + $(foreach pkg,$(PKGS),--pkg=$(pkg)) \ + $(foreach vapidir,$(VAPI_DIRS),--vapidir=$(vapidir)) \ + $(foreach def,$(DEFINES),-X -D$(def)) \ + $(foreach hdir,$(HEADER_DIRS),-X -I$(hdir)) \ + $(VAPI_FILES) \ + $(VALA_DEFINES) \ + $(TEMP_MARINA_VAPI) \ + $(EXPANDED_SRC_FILES) + touch $@ + +ifdef LIBRARY +$(LIBRARY): $(EXPANDED_OBJ_FILES) $(RESOURCES) + $(AR) $(ARFLAGS) $@ $? +endif + +ifdef PROGRAM +$(PROGRAM): $(EXPANDED_OBJ_FILES) $(MARINA_DEPEND) + $(CC) $(EXPANDED_OBJ_FILES) -lm $(CFLAGS) $(VALA_LDFLAGS) -export-dynamic -o $@ +ifdef GLADE_NAME + $(CC) $(EXPANDED_OBJ_FILES) -lm $(CFLAGS) $(VALA_LDFLAGS) -export-dynamic -shared -o $(GLADE_NAME) +endif +clean: + rm -f $(EXPANDED_C_FILES) + rm -f $(EXPANDED_SAVE_TEMPS_FILES) + rm -f $(EXPANDED_OBJ_FILES) + rm -f $(VALA_STAMP) + rm -rf $(PROGRAM)-$(VERSION) + rm -f $(PROGRAM) +ifdef GLADE_NAME + rm -f $(GLADE_NAME) +endif +endif + + +cleantemps: + rm -f $(EXPANDED_C_FILES) + rm -f $(EXPANDED_SAVE_TEMPS_FILES) + rm -f $(EXPANDED_OBJ_FILES) + rm -f $(VALA_STAMP) + diff --git a/minver b/minver new file mode 100755 index 0000000..dac8545 --- /dev/null +++ b/minver @@ -0,0 +1,86 @@ +#! /bin/bash +# +# Copyright 2009-2010 Yorba Foundation +# +# This software is licensed under the GNU LGPL (version 2.1 or later). +# See the COPYING file in this distribution. + +# vercmp +# +# Returns 0 if queried version is greater than or equal to second, 1 otherwise. +# Set VERBOSE environment variable for somewhat useful output. +# +# NOTE: +# This is an ultra-naive implementation with just enough error-checking. + +usage() { + echo 'usage: vercmp ' +} + +abort() { + usage + exit 1 +} + +verify_cardinal() { + while [ $# != 0 ] + do + if [ $1 ] && [ $1 -eq $1 2> /dev/null ] && [ $1 -ge 0 ] + then + : + else + abort + fi + + shift + done +} + +# check_range name number min-number +check_range() { + if [ $2 -gt $3 ] + then + verbose $1 large enough. + exit 0 + elif [ $2 -lt $3 ] + then + verbose $1 not large enough + exit 1 + fi +} + +verbose() { + if [ $VERBOSE ] + then + echo $* + fi +} + +# Check number of arguments +if [ $# -lt 2 ] +then + abort +fi + +# Parse arguments into integers +major=`echo $1 | awk -F. '{print $1}'` +minor=`echo $1 | awk -F. '{print $2}'` +revision=`echo $1 | awk -F. '{print $3}'` + +min_major=`echo $2 | awk -F. '{print $1}'` +min_minor=`echo $2 | awk -F. '{print $2}'` +min_revision=`echo $2 | awk -F. '{print $3}'` + +# Verify they're all positive integers +verify_cardinal "$major" "$minor" "$revision" "$min_major" "$min_minor" "$min_revision" + +verbose Comparing $major.$minor.$revision against $min_major.$min_minor.$min_revision + +# check version numbers in order of importance +check_range "Major" $major $min_major +check_range "Minor" $minor $min_minor +check_range "Revision" $revision $min_revision + +verbose Same version. +exit 0 + diff --git a/misc/fillmore.desktop b/misc/fillmore.desktop new file mode 100644 index 0000000..dfa8db8 --- /dev/null +++ b/misc/fillmore.desktop @@ -0,0 +1,13 @@ + +[Desktop Entry] +Version=1.0 +Name=Fillmore Audio Editor +GenericName=Audio Editor +Comment=Record and edit multitrack audio +Exec=fillmore %U +Icon=fillmore +MimeType=application/fillmore;text/yorba-media +Terminal=false +Type=Application +Categories=AudioVideo;GNOME;GTK; +X-GIO-NoFuse=true diff --git a/misc/fillmore.xml b/misc/fillmore.xml new file mode 100644 index 0000000..d3fc2b8 --- /dev/null +++ b/misc/fillmore.xml @@ -0,0 +1,15 @@ + + + + + + Fillmore Project File + + + + + + Yorba Media Project File + + + diff --git a/misc/lombard.desktop b/misc/lombard.desktop new file mode 100644 index 0000000..68e0525 --- /dev/null +++ b/misc/lombard.desktop @@ -0,0 +1,14 @@ + +[Desktop Entry] +Version=1.0 +Name=Lombard Video Editor +GenericName=Video Editor +Comment=Create and edit movies +Exec=lombard %U +Icon=lombard +MimeType=application/lombard;text/yorba-media +Terminal=false +Type=Application +Categories=AudioVideo;GNOME;GTK; +X-GIO-NoFuse=true + diff --git a/misc/lombard.xml b/misc/lombard.xml new file mode 100644 index 0000000..030d4fc --- /dev/null +++ b/misc/lombard.xml @@ -0,0 +1,16 @@ + + + + + + + Lombard Project File + + + + + Yorba Media Project File + + + + diff --git a/resources/dot.png b/resources/dot.png new file mode 100644 index 0000000..870fb34 Binary files /dev/null and b/resources/dot.png differ diff --git a/resources/fillmore.glade b/resources/fillmore.glade new file mode 100644 index 0000000..f14a832 --- /dev/null +++ b/resources/fillmore.glade @@ -0,0 +1,310 @@ + + + + + + + 5 + Project Settings + True + center-always + dialog + True + True + False + + + True + vertical + 2 + + + True + vertical + 6 + + + True + 0 + General + + + + + + 0 + + + + + True + 2 + 2 + 6 + + + True + 0 + Time _signature: + True + timesignature_combo + + + GTK_FILL + 6 + + + + + True + 0 + Tem_po: + True + tempo_scrollbar + + + 1 + 2 + GTK_FILL + 6 + + + + + True + + + 160 + True + True + tempo_adjustment + 0 + left + + + 6 + 0 + + + + + _Tap + True + True + True + True + + + + False + 6 + 1 + + + + + 1 + 2 + 1 + 2 + + + + + True + timesignatures + 0 + + + + 0 + + + + + 1 + 2 + + + + + 1 + + + + + True + 0 + Metronome + + + + + + 2 + + + + + True + 3 + 2 + 6 + + + True + True + volume_adjustment + + + 1 + 2 + + + + + True + 0 + _Volume: + True + volumeslider1 + + + GTK_FILL + 6 + + + + + During _playback + True + True + False + True + 0 + True + + + 1 + 2 + GTK_FILL + 6 + + + + + During _record + True + True + False + True + 0 + True + + + 2 + 3 + GTK_FILL + GTK_FILL + 6 + + + + + + + + + + + 3 + + + + + 1 + + + + + True + end + + + gtk-cancel + True + True + True + True + + + False + False + 0 + + + + + gtk-ok + True + True + True + True + True + True + + + False + False + 1 + + + + + False + end + 0 + + + + + + button1 + button2 + + + + 40 + 30 + 130 + 1 + 10 + 10 + + + + + + + + + 2/4 + + + 3/4 + + + 4/4 + + + 6/8 + + + + + 1 + 0.01 + 0.10000000000000001 + 0.10000000000000001 + + diff --git a/resources/fillmore.rc b/resources/fillmore.rc new file mode 100644 index 0000000..85d92d9 --- /dev/null +++ b/resources/fillmore.rc @@ -0,0 +1,22 @@ +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +style "pan" { + GtkHScrollbar::fixed-slider-length = 1 + GtkHScrollbar::min-slider-length = 12 + GtkHScrollbar::has-forward-stepper = 0 + GtkHScrollbar::has-backward-stepper = 0 + fg[SELECTED] = "tan" + fg[NORMAL] = "dark slate grey" +} + +style "hseparator" { + bg[NORMAL] = "#666" +} + +class "PanSlider" style "pan" +class "VolumeSlider" style "pan" +class "TrackSeparator" style "hseparator" diff --git a/resources/fillmore.svg b/resources/fillmore.svg new file mode 100644 index 0000000..1a403f0 --- /dev/null +++ b/resources/fillmore.svg @@ -0,0 +1,162 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/fillmore_icon.png b/resources/fillmore_icon.png new file mode 100644 index 0000000..15c6d63 Binary files /dev/null and b/resources/fillmore_icon.png differ diff --git a/resources/lombard.svg b/resources/lombard.svg new file mode 100644 index 0000000..20bb8d6 --- /dev/null +++ b/resources/lombard.svg @@ -0,0 +1,516 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/lombard_icon.png b/resources/lombard_icon.png new file mode 100644 index 0000000..6d04d3a Binary files /dev/null and b/resources/lombard_icon.png differ diff --git a/resources/max_speaker.png b/resources/max_speaker.png new file mode 100644 index 0000000..7c294bc Binary files /dev/null and b/resources/max_speaker.png differ diff --git a/resources/min_speaker.png b/resources/min_speaker.png new file mode 100644 index 0000000..70c4446 Binary files /dev/null and b/resources/min_speaker.png differ diff --git a/src/fillmore/FillmoreClassFactory.vala b/src/fillmore/FillmoreClassFactory.vala new file mode 100644 index 0000000..9fd2d07 --- /dev/null +++ b/src/fillmore/FillmoreClassFactory.vala @@ -0,0 +1,56 @@ +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +class TrackSeparator : Gtk.HSeparator { +//this class is referenced in the resource file +} + +class FillmoreTrackView : Gtk.VBox, TrackView { + TrackView track_view; + public FillmoreTrackView(TrackView track_view) { + this.track_view = track_view; + track_view.clip_view_added.connect(on_clip_view_added); + + pack_start(track_view, true, true, 0); + pack_start(new TrackSeparator(), false, false, 0); + can_focus = false; + } + + public void move_to_top(ClipView clip_view) { + track_view.move_to_top(clip_view); + } + + public void resize() { + track_view.resize(); + } + + public Model.Track get_track() { + return track_view.get_track(); + } + + public int get_track_height() { + return track_view.get_track_height(); + } + + void on_clip_view_added(ClipView clip_view) { + clip_view_added(clip_view); + } + + Gtk.Widget? find_child(double x, double y) { + return track_view.find_child(x, y); + } + + void select_all() { + track_view.select_all(); + } +} + +public class FillmoreClassFactory : ClassFactory { + public override TrackView get_track_view(Model.Track track, TimeLine timeline) { + TrackView track_view = base.get_track_view(track, timeline); + return new FillmoreTrackView(track_view); + } +} diff --git a/src/fillmore/Makefile b/src/fillmore/Makefile new file mode 100644 index 0000000..d96a73a --- /dev/null +++ b/src/fillmore/Makefile @@ -0,0 +1,21 @@ +PROGRAM = ../../$(PROGRAM_NAME) +GLADE_NAME = ../../libfill.so + +all: $(PROGRAM) + +USE_MARINA_VAPI=1 +-include ../../configure.mk + +VALA_LDFLAGS = -lmarina -L../marina +VALA_LDFLAGS += `pkg-config --libs $(EXT_PKGS)` +MARINA_DEPEND = ../marina/libmarina.a + +-include sources.mk + +ifndef BUILD_DIR +BUILD_DIR=fillmore +endif + +-include ../../marina.mk +HEADER_DIRS += ../marina + diff --git a/src/fillmore/ProjectProperties.vala b/src/fillmore/ProjectProperties.vala new file mode 100644 index 0000000..1caff22 --- /dev/null +++ b/src/fillmore/ProjectProperties.vala @@ -0,0 +1,125 @@ +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +public class ProjectProperties : Gtk.Dialog { + const int NUMBER_OF_SAMPLES = 4; + const long G_USEC_PER_SEC = 1000000; + + TimeVal[] tap_time = new TimeVal[NUMBER_OF_SAMPLES]; + int tap_index = 0; + bool sample_full = false; + Gtk.Adjustment tempo_adjustment; + Gtk.Adjustment volume_adjustment; + Gtk.ComboBox timesignature_combo; + Gtk.ToggleButton click_during_play; + Gtk.ToggleButton click_during_record; + + public void setup(Model.Project project, Gtk.Builder builder) { + tempo_adjustment = (Gtk.Adjustment) builder.get_object("tempo_adjustment"); + volume_adjustment = (Gtk.Adjustment) builder.get_object("volume_adjustment"); + timesignature_combo = (Gtk.ComboBox) builder.get_object("timesignature_combo"); + click_during_play = (Gtk.ToggleButton) builder.get_object("playback"); + click_during_record = (Gtk.ToggleButton) builder.get_object("record"); + set_tempo(project.get_bpm()); + set_volume(project.click_volume); + set_during_play(project.click_during_play); + set_during_record(project.click_during_record); + set_time_signature(project.get_time_signature()); + } + + public void set_tempo(int tempo) { + tempo_adjustment.set_value(tempo); + } + + public int get_tempo() { + return (int) tempo_adjustment.get_value(); + } + + public void set_volume(double volume) { + volume_adjustment.set_value(volume); + } + + public double get_click_volume() { + return volume_adjustment.get_value(); + } + + public Fraction get_time_signature() { + return Fraction.from_string(timesignature_combo.get_active_text()); + } + + void set_time_signature(Fraction time_signature) { + string sig = time_signature.to_string(); + + Gtk.TreeIter iter; + if (timesignature_combo.model.get_iter_first(out iter)) { + do { + string s; + timesignature_combo.model.get(iter, 0, out s, -1); + if (s == sig) { + timesignature_combo.set_active_iter(iter); + return; + } + } while (timesignature_combo.model.iter_next(ref iter)); + } + } + + void set_during_play(bool active) { + click_during_play.active = active; + } + + public bool during_play() { + return click_during_play.active; + } + + void set_during_record(bool active) { + click_during_record.active = active; + } + + public bool during_record() { + return click_during_record.active; + } + + public void on_tap() { + TimeVal time_val = TimeVal(); + time_val.get_current_time(); + tap_time[tap_index] = time_val; + ++tap_index; + if (tap_index == NUMBER_OF_SAMPLES) { + sample_full = true; + tap_index = 0; + } + calculate_bpm(); + } + + void calculate_bpm() { + int number_of_samples = sample_full ? NUMBER_OF_SAMPLES : tap_index; + if (number_of_samples < 2) { + return; + } + + int start_index = sample_full ? tap_index : 0; + + double delta_sum = 0; + for (int i = 0; i < number_of_samples - 1; ++i) { + int current_index = (i + start_index) % NUMBER_OF_SAMPLES; + int next_index = (current_index + 1) % NUMBER_OF_SAMPLES; + long difference = + (tap_time[next_index].tv_sec - tap_time[current_index].tv_sec) * G_USEC_PER_SEC + + tap_time[next_index].tv_usec - tap_time[current_index].tv_usec; + + if (difference > 5 * G_USEC_PER_SEC) { + // User waited too long. Save the time and start over + tap_time[0] = tap_time[tap_index - 1]; + sample_full = false; + tap_index = 1; + return; + } + delta_sum += difference; + } + double average = delta_sum/(number_of_samples - 1)/G_USEC_PER_SEC; + tempo_adjustment.set_value((int)(60.0/average)); + } +} diff --git a/src/fillmore/VolumeAndPanPopUp.vala b/src/fillmore/VolumeAndPanPopUp.vala new file mode 100644 index 0000000..2d07a4e --- /dev/null +++ b/src/fillmore/VolumeAndPanPopUp.vala @@ -0,0 +1,68 @@ +/* Demo Recorder for MAEMO 5 +* Copyright (C) 2010 Dru Moore +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2, +* or (at your option) any later version, as published by the Free +* Software Foundation +* +* This program 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 General Public License for more details +* +* You should have received a copy of the GNU General Public +* License along with this program; if not, write to the +* Free Software Foundation, Inc., +* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +*/ +namespace IdWorks { + +public class VolumeAndPanPopUp : Hildon.Dialog { + + Gtk.HScale volume_slider; + Gtk.HScale panorama_slider; + + public signal void volume_updated(double volume); + public signal void panorama_updated(double panorama); + + public VolumeAndPanPopUp(Gtk.Widget parent, string title) { + this.set_title(title); + this.set_parent(parent); + + this.set_default_response(Gtk.ResponseType.ACCEPT); + this.add_button(Gtk.STOCK_CLOSE, Gtk.ResponseType.ACCEPT); + + Gtk.VBox control_area = (Gtk.VBox)this.get_content_area(); + + Gtk.HBox volume_bar = new Gtk.HBox(false, 2); + Gtk.Label volume_label = new Gtk.Label("Volume"); + volume_bar.pack_start(volume_label, false, false , 2); + volume_slider = new Gtk.HScale.with_range(0.0, 10.0, 0.05); + volume_slider.set_value_pos(Gtk.PositionType.LEFT); + volume_slider.value_changed.connect((s) => {volume_updated(s.get_value());}); + volume_bar.pack_start(volume_slider, true, true , 2); + + Gtk.HBox panorama_bar = new Gtk.HBox(false, 2); + Gtk.Label panorama_label = new Gtk.Label("Pan"); + panorama_bar.pack_start(panorama_label, false, false , 2); + panorama_slider = new Gtk.HScale.with_range(-1.0, 1.0, 0.05); + panorama_slider.set_value_pos(Gtk.PositionType.LEFT); + panorama_slider.value_changed.connect((s) => {panorama_updated(s.get_value());}); + panorama_bar.pack_start(panorama_slider, true, true , 2); + + control_area.pack_start(volume_bar, true, true , 2); + control_area.pack_start(panorama_bar, true, true , 2); + this.show_all(); + } + + public void set_volume(double volume) { + volume_slider.set_value(volume); + } + + public void set_panorama(double panorama) { + panorama_slider.set_value(panorama); + } + +} + +} diff --git a/src/fillmore/audio_project.vala b/src/fillmore/audio_project.vala new file mode 100644 index 0000000..ac567ca --- /dev/null +++ b/src/fillmore/audio_project.vala @@ -0,0 +1,153 @@ +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +using Logging; +namespace Model { + +class RecordFetcherCompletion : FetcherCompletion { + Track track; + Project project; + int64 position; + + public RecordFetcherCompletion(Project project, Track track, int64 position) { + base(); + this.track = track; + this.project = project; + this.position = position; + } + + public override void complete(Fetcher fetch) { + base.complete(fetch); + Clip the_clip = new Clip(fetch.clipfile, MediaType.AUDIO, + isolate_filename(fetch.clipfile.filename), 0, 0, fetch.clipfile.length, false); + project.undo_manager.start_transaction("Record"); + track.append_at_time(the_clip, position, true); + project.undo_manager.end_transaction("Record"); + } +} + +class AudioProject : Project { + bool has_been_saved; + + public AudioProject(string? filename) throws Error { + base(filename, false); + // TODO: When vala supports throwing from base, remove this check + if (this != null) { + has_been_saved = filename != null; + if (!has_been_saved) { + project_file = generate_filename(); + } + media_engine.callback_pulse.connect(media_engine.on_callback_pulse); + media_engine.record_completed.connect(on_record_completed); + } + } + + public override TimeCode get_clip_time(ClipFile f) { + TimeCode t = {}; + + t.get_from_length(f.length); + return t; + } + + public override string? get_project_file() { + if (!has_been_saved) { + return null; + } else { + return base.get_project_file(); + } + } + + string generate_filename() { + Time now = Time.local(time_t()); + string timestring = now.to_string(); + timestring = timestring.replace(":", "_"); + string pathname = Path.build_filename(GLib.Environment.get_home_dir(), ".fillmore", + timestring); + GLib.DirUtils.create(pathname, 0777); + string filename = "%s.%s".printf(timestring, "fill"); + return Path.build_filename(pathname, filename); + } + + public override string get_app_name() { + return Recorder.NAME; + } + + public override void add_track(Track track) { + if (track.media_type() == MediaType.VIDEO) { + track.hide(); + inactive_tracks.add(track); + return; + } + + base.add_track(track); + } + + public void record(AudioTrack track) { + media_engine.record(track); + } + + public void on_record_completed() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_record_completed"); + try { + create_clip_fetcher(new Model.RecordFetcherCompletion(this, media_engine.record_track, + media_engine.record_region.start), media_engine.record_region.clipfile.filename); + } catch (Error e) { + error_occurred("Could not complete recording", e.message); + } + } + + public override void load(string? filename) { + has_been_saved = filename != null; + if (!has_been_saved) { + project_file = generate_filename(); + } + base.load(filename); + } + + public override void save(string? filename) { + if (!has_been_saved && filename != null) { + move_audio_files(filename); + GLib.FileUtils.remove(project_file); + GLib.DirUtils.remove(Path.get_dirname(project_file)); + } + + base.save(filename); + has_been_saved = true; + } + + void move_audio_files(string filename) { + string audio_path = get_audio_path(); + string destination_path = Path.build_filename(Path.get_dirname(filename), "audio files"); + GLib.DirUtils.create(destination_path, 0777); + GLib.Dir dir; + try { + dir = Dir.open(audio_path); + } catch (FileError e) { + return; + } + + // First, move all of the files over, even if they aren't currently in the project + weak string? base_name = null; + do { + base_name = dir.read_name(); + string destination = Path.build_filename(destination_path, base_name); + FileUtils.rename(Path.build_filename(audio_path, base_name), destination); + } while (base_name != null); + + // Next, update the model so that the project file is saved properly + foreach (ClipFile clip_file in clipfiles) { + if (Path.get_dirname(clip_file.filename) == audio_path) { + string file_name = Path.get_basename(clip_file.filename); + string destination = Path.build_filename(destination_path, file_name); + clip_file.filename = destination; + } + } + + GLib.DirUtils.remove(audio_path); + } + +} +} diff --git a/src/fillmore/fillmore.vala b/src/fillmore/fillmore.vala new file mode 100644 index 0000000..3c38b80 --- /dev/null +++ b/src/fillmore/fillmore.vala @@ -0,0 +1,1407 @@ +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +using Logging; + +extern const string _PROGRAM_NAME; +bool do_print_graph = false; +int debug_level; + +const OptionEntry[] options = { + { "print-graph", 0, 0, OptionArg.NONE, &do_print_graph, + "Show Print Graph in help menu", null }, + { "debug-level", 0, 0, OptionArg.INT, &debug_level, + "Control amount of diagnostic information", + "[0 (minimal),5 (maximum)]" }, + { null } +}; + +class Recorder : Gtk.Window, TransportDelegate { + public Model.AudioProject project; + public TimeLine timeline; + View.ClickTrack click_track; + HeaderArea header_area; + ClipLibraryView library; + Model.TimeSystem provider; + Gtk.Adjustment h_adjustment; + Gtk.HPaned timeline_library_pane; + Gtk.ScrolledWindow library_scrolled; + Gtk.ScrolledWindow timeline_scrolled; + int cursor_pos = -1; + int64 center_time = -1; + bool loading; + const int scroll_speed = 8; + + Gtk.ActionGroup main_group; + + Gtk.ToggleButton play_button; + Gtk.ToggleButton record_button; + Gtk.Button addnew_button; + Gtk.Button rewind_button; + Gtk.Button forward_button; + Gtk.Button zoomin_button; + Gtk.Button zoomout_button; + Gtk.Button volume_button; + + Hildon.PannableArea scrollwin; + int scrollwin_pos_y = 0; + + Gtk.UIManager manager; + // TODO: Have a MediaExportConnector that extends MediaConnector rather than concrete type. + View.OggVorbisExport audio_export; + View.AudioOutput audio_output; + Gee.ArrayList load_errors; + + public const string NAME = "Fillmore"; + const Gtk.ActionEntry[] entries = { + { "Project", null, "_Project", null, null, null }, + { "Open", Gtk.STOCK_OPEN, "_Open...", null, "Open a project", on_project_open }, + { "NewProject", Gtk.STOCK_NEW, "_New", null, "Create new project", on_project_new }, + { "Save", Gtk.STOCK_SAVE, "_Save", "S", "Save project", on_project_save }, + { "SaveAs", Gtk.STOCK_SAVE_AS, "Save _As...", "S", + "Save project with new name", on_project_save_as }, + { "Export", Gtk.STOCK_JUMP_TO, "_Export...", "E", null, on_export }, + { "Settings", Gtk.STOCK_PROPERTIES, "Se_ttings", "Return", null, on_properties }, + { "Quit", Gtk.STOCK_QUIT, null, null, null, on_quit }, + + { "Edit", null, "_Edit", null, null, null }, + { "Undo", Gtk.STOCK_UNDO, null, "Z", null, on_undo }, + { "Cut", Gtk.STOCK_CUT, null, null, null, on_cut }, + { "Copy", Gtk.STOCK_COPY, null, null, null, on_copy }, + { "Paste", Gtk.STOCK_PASTE, null, null, null, on_paste }, + { "Delete", Gtk.STOCK_DELETE, null, "Delete", null, on_delete }, + { "SelectAll", Gtk.STOCK_SELECT_ALL, null, "A", null, on_select_all }, + { "SplitAtPlayhead", null, "_Split at Playhead", "P", null, on_split_at_playhead }, + { "TrimToPlayhead", null, "Trim to Play_head", "H", null, on_trim_to_playhead }, + { "ClipProperties", Gtk.STOCK_PROPERTIES, "Properti_es", "Return", + null, on_clip_properties }, + + { "View", null, "_View", null, null, null }, + { "ZoomIn", Gtk.STOCK_ZOOM_IN, "Zoom _In", "plus", null, on_zoom_in }, + { "ZoomOut", Gtk.STOCK_ZOOM_OUT, "Zoom _Out", "minus", null, on_zoom_out }, + { "ZoomProject", null, "Fit to _Window", "Z", null, on_zoom_to_project }, + + { "Track", null, "_Track", null, null, null }, + { "NewTrack", Gtk.STOCK_ADD, "_New...", "N", + "Create new track", on_track_new }, + { "Rename", null, "_Rename...", null, "Rename Track", on_track_rename }, + { "DeleteTrack", null, "_Delete", "Delete", + "Delete track", on_track_remove }, + { "MoveTrackUp", null, "Move Track Up", "Up", null, on_track_move_up }, + { "MoveTrackDown", null, "Move Track Down", "Down", null, on_track_move_down }, + { "ScrollTracksUp", null, "Scroll Tracks Up", "Up", null, on_tracks_scroll_up }, + { "ScrollTracksDown", null, "Scroll Tracks Down", "Down", null, on_tracks_scroll_down }, + + + { "Help", null, "_Help", null, null, null }, + { "Contents", Gtk.STOCK_HELP, "_Contents", "F1", + "More information on Fillmore", on_help_contents}, + { "About", Gtk.STOCK_ABOUT, null, null, null, on_about }, + { "SaveGraph", null, "Save _Graph", null, "Save graph", on_save_graph }, + + { "Rewind", Gtk.STOCK_MEDIA_PREVIOUS, "Rewind", "Home", "Go to beginning", on_rewind }, + { "End", Gtk.STOCK_MEDIA_NEXT, "End", "End", "Go to end", on_end } + }; + + const Gtk.ToggleActionEntry[] toggle_entries = { + { "Play", Gtk.STOCK_MEDIA_PLAY, null, "space", "Play", on_play }, + { "Record", Gtk.STOCK_MEDIA_RECORD, null, "r", "Record", on_record }, + { "Library", null, "_Library", "F9", null, on_view_library, false }, + { "Snap", null, "_Snap to Clip Edges", null, null, on_snap, false } + }; + + const string ui = """ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +"""; + + const DialogUtils.filter_description_struct[] filters = { + { "Fillmore Project Files", Model.Project.FILLMORE_FILE_EXTENSION }, + { "Lombard Project Files", Model.Project.LOMBARD_FILE_EXTENSION } + }; + + const DialogUtils.filter_description_struct[] export_filters = { + { "Ogg Files", "ogg" } + }; + + public signal void finished_closing(bool project_did_close); + + public Recorder(string? project_file) throws Error { + ClassFactory.set_transport_delegate(this); + GLib.DirUtils.create(get_fillmore_directory(), 0777); + load_errors = new Gee.ArrayList(); + try { + set_icon_from_file( + AppDirs.get_resources_dir().get_child("fillmore_icon.png").get_path()); + } catch (GLib.Error e) { + warning("Could not load application icon: %s", e.message); + } + + + project = new Model.AudioProject(project_file); + project.snap_to_clip = false; + provider = new Model.BarBeatTimeSystem(project); + + project.media_engine.callback_pulse.connect(on_callback_pulse); + project.media_engine.post_export.connect(on_post_export); + project.media_engine.position_changed.connect(on_position_changed); + + project.load_error.connect(on_load_error); + project.name_changed.connect(on_name_changed); + project.undo_manager.dirty_changed.connect(on_dirty_changed); + project.undo_manager.undo_changed.connect(on_undo_changed); + project.error_occurred.connect(on_error_occurred); + project.playstate_changed.connect(on_playstate_changed); + project.track_added.connect(on_track_added); + project.track_removed.connect(on_track_removed); + project.load_complete.connect(on_load_complete); + project.closed.connect(on_project_close); + + audio_output = new View.AudioOutput(project.media_engine.get_project_audio_caps()); + project.media_engine.connect_output(audio_output); + click_track = new View.ClickTrack(project.media_engine, project); + set_position(Gtk.WindowPosition.CENTER); + title = "Fillmore"; + set_default_size(800, 1200); + + main_group = new Gtk.ActionGroup("main"); + main_group.add_actions(entries, this); + main_group.add_toggle_actions(toggle_entries, this); + + manager = new Gtk.UIManager(); + manager.insert_action_group(main_group, 0); + try { + manager.add_ui_from_string(ui, -1); + } catch (Error e) { error("%s", e.message); } + + Gtk.MenuBar menubar = (Gtk.MenuBar) get_widget(manager, "/MenuBar"); + Gtk.Toolbar toolbar = (Gtk.Toolbar) get_widget(manager, "/Toolbar"); + //play_button = (Gtk.ToggleToolButton) get_widget(manager, "/Toolbar/Play"); + //record_button = (Gtk.ToggleToolButton) get_widget(manager, "/Toolbar/Record"); + //rewind_button = (Gtk.ToolButton) get_widget(manager, "/Toolbar/Rewind"); + //forward_button = (Gtk.ToolButton) get_widget(manager, "/Toolbar/End"); + //addnew_button = (Gtk.ToolButton) get_widget(manager, "/Toolbar/New"); + on_undo_changed(false); + + library = new ClipLibraryView(project, provider, null, Gdk.DragAction.COPY); + library.selection_changed.connect(on_library_selection_changed); + library.drag_data_received.connect(on_drag_data_received); + + timeline = new TimeLine(project, provider, Gdk.DragAction.COPY); + timeline.track_changed.connect(on_track_changed); + timeline.drag_data_received.connect(on_drag_data_received); + timeline.size_allocate.connect(on_timeline_size_allocate); + timeline.selection_changed.connect(on_timeline_selection_changed); + + ClipView.context_menu = (Gtk.Menu) manager.get_widget("/ClipContextMenu"); + ClipLibraryView.context_menu = (Gtk.Menu) manager.get_widget("/LibraryContextMenu"); + update_menu(); + + library_scrolled = new Gtk.ScrolledWindow(null, null); + library_scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC); + library_scrolled.add_with_viewport(library); + + Gtk.HBox hbox = new Gtk.HBox(false, 0); + header_area = new HeaderArea(this, provider, TimeLine.RULER_HEIGHT); + hbox.pack_start(header_area, false, false, 0); + + + timeline_scrolled = new Gtk.ScrolledWindow(null, null); + timeline_scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.NEVER); + timeline_scrolled.add_with_viewport(timeline); + hbox.pack_start(timeline_scrolled, true, true, 0); + h_adjustment = timeline_scrolled.get_hadjustment(); + + + + Gtk.HButtonBox buttons = new Gtk.HButtonBox(); + addnew_button = new Gtk.Button(); //.with_label("Pl"); + addnew_button.set_image(new Gtk.Image.from_icon_name("general_add", Gtk.IconSize.BUTTON)); + addnew_button.clicked.connect(on_track_new); + buttons.add(addnew_button); + play_button = new Gtk.ToggleButton(); //.with_label("Pl"); + play_button.set_image(new Gtk.Image.from_icon_name("camera_playback", Gtk.IconSize.BUTTON)); + play_button.toggled.connect(on_play); + buttons.add(play_button); + record_button = new Gtk.ToggleButton(); //.with_label("Re"); + record_button.set_image(new Gtk.Image.from_icon_name("camera_video_recording", Gtk.IconSize.BUTTON)); + record_button.toggled.connect(on_record); + buttons.add(record_button); + rewind_button = new Gtk.Button(); //.with_label("Re"); + rewind_button.set_image(new Gtk.Image.from_icon_name("pdf_viewer_first_page", Gtk.IconSize.BUTTON)); + rewind_button.clicked.connect(on_rewind); + buttons.add(rewind_button); + forward_button = new Gtk.Button(); //.with_label("Re"); + forward_button.set_image(new Gtk.Image.from_icon_name("pdf_viewer_last_page", Gtk.IconSize.BUTTON)); + forward_button.clicked.connect(on_end); + buttons.add(forward_button); + zoomin_button = new Gtk.Button(); //.with_label("Re"); + zoomin_button.set_image(new Gtk.Image.from_icon_name("pdf_zoomin", Gtk.IconSize.BUTTON)); + zoomin_button.clicked.connect(on_zoom_in); + buttons.add(zoomin_button); + zoomout_button = new Gtk.Button(); //.with_label("Re"); + zoomout_button.set_image(new Gtk.Image.from_icon_name("pdf_zoomout", Gtk.IconSize.BUTTON)); + zoomout_button.clicked.connect(on_zoom_out); + buttons.add(zoomout_button); + volume_button = new Gtk.Button(); //.with_label("Re"); + volume_button.set_image(new Gtk.Image.from_icon_name("statusarea_volumelevel4", Gtk.IconSize.BUTTON)); + volume_button.clicked.connect(on_volume); + buttons.add(volume_button); + + + Gtk.VBox vbox = new Gtk.VBox(false, 0); + vbox.pack_start(menubar, false, false, 0); + //vbox.pack_start(toolbar, false, false, 0); + vbox.pack_start(buttons, false, false, 0); + + Gtk.VBox main_view = new Gtk.VBox(false, 0); + + timeline_library_pane = new Gtk.HPaned(); + timeline_library_pane.set_position(project.library_width); + timeline_library_pane.add1(hbox); + timeline_library_pane.child1_resize = 1; + timeline_library_pane.add2(library_scrolled); + timeline_library_pane.child2_resize = 0; + timeline_library_pane.child1.size_allocate.connect(on_library_size_allocate); + + + main_view.pack_start(timeline_library_pane, true, true, 0); + + + scrollwin = new Hildon.PannableArea(); + scrollwin.add_with_viewport(main_view); + vbox.add(scrollwin); + + add(vbox); + // toggle the library pane off. + on_view_library(); + + Gtk.MenuItem? save_graph = (Gtk.MenuItem?) + get_widget(manager, "/MenuBar/HelpMenu/SaveGraph"); + + if (!do_print_graph && save_graph != null) { + save_graph.destroy(); + } + + add_accel_group(manager.get_accel_group()); + timeline.grab_focus(); + delete_event.connect(on_delete_event); + loading = true; + project.load(project_file); + if (project_file == null) { + default_track_set(); + loading = false; + } + project.media_engine.pipeline.set_state(Gst.State.PAUSED); + } + + void default_track_set() { + project.add_track(new Model.AudioTrack(project, get_default_track_name())); + project.tracks[0].set_selected(true); + } + + static int default_track_number_compare(void *a, void *b) { + string* s1 = (string *) a; + string* s2 = (string *) b; + int i = -1; + int j = -1; + s1->scanf("track %d", &i); + s2->scanf("track %d", &j); + assert(i > 0); + assert(j > 0); + if (i == j) { + return 0; + } else if (i < j) { + return -1; + } else { + return 1; + } + } + + public string get_default_track_name() { + List default_track_names = new List(); + foreach(Model.Track track in project.tracks) { + if (track.display_name.has_prefix("track ")) { + default_track_names.append(track.display_name); + } + } + default_track_names.sort(default_track_number_compare); + + int i = 1; + foreach(string s in default_track_names) { + string track_name = "track %d".printf(i); + if (s != track_name) { + return track_name; + } + ++i; + } + return "track %d".printf(i); + } + + Gtk.Widget get_widget(Gtk.UIManager manager, string name) { + Gtk.Widget widget = manager.get_widget(name); + if (widget == null) + error("can't find widget"); + return widget; + } + + void on_track_move_up() { + int index = -1; + int position = 0; + int track_ct = project.tracks.size; + if (0 < track_ct) { + foreach(Model.Track track in project.tracks) { + ++index; + if (selected_track() == track) { + position = index; + } + } + if (0 < position) { + Model.AudioTrack track = selected_track() as Model.AudioTrack; + project.tracks.remove(track); + project.tracks.insert(position - 1, track); + } + } + } + void on_track_move_down() { + // if current track < position last + int index = -1; + int position = 0; + int track_ct = project.tracks.size; + if (0 < track_ct) { + foreach(Model.Track track in project.tracks) { + ++index; + if (selected_track() == track) { + position = index; + } + } + if (track_ct - 1 > position) { + Model.AudioTrack audio_track = selected_track() as Model.AudioTrack; + project.tracks.remove(audio_track); + project.tracks.insert(position + 1, audio_track); + } + } + } + void on_tracks_scroll_up() { + // if track count > 4 = Visible tracks + /*int track_ct = project.tracks.size; + if (4 < track_ct) { + // take bottom track and move to start + Model.AudioTrack track = project.tracks.get(track_ct - 1) as Model.AudioTrack; + project.tracks.remove(track); + project.tracks.insert(0, track); + }*/ + scrollwin_pos_y -= scrollwin_pos_y < 4 ? 0 : 64; + scrollwin.scroll_to(0, scrollwin_pos_y); + } + void on_tracks_scroll_down() { + // if track count > 4 = visible tracks + /*int track_ct = project.tracks.size; + if (4 < track_ct) { + // take top track and move to end + Model.AudioTrack track = project.tracks.get(0) as Model.AudioTrack; + project.tracks.remove(track); + project.tracks.add(track); + }*/ + scrollwin_pos_y += 64; + scrollwin.scroll_to(0, scrollwin_pos_y); + } + + void set_sensitive_group(Gtk.ActionGroup group, string group_path, bool sensitive) { + Gtk.Action action = group.get_action(group_path); + action.set_sensitive(sensitive); + } + + void on_track_changed() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_track_changed"); + update_menu(); + } + + void on_position_changed() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_position_changed"); + update_menu(); + } + + void on_track_added(Model.Track track) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_track_added"); + update_menu(); + track.clip_added.connect(on_clip_added); + track.clip_removed.connect(on_clip_removed); + track.track_selection_changed.connect(on_track_selection_changed); + } + + void on_track_removed(Model.Track unused) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_track_removed"); + update_menu(); + } + + void on_clip_added(Model.Clip clip) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_added"); + clip.moved.connect(on_clip_moved); + update_menu(); + } + + void on_clip_removed(Model.Clip clip) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_removed"); + clip.moved.disconnect(on_clip_moved); + update_menu(); + } + + void on_track_selection_changed(Model.Track track) { + if (track.get_is_selected()) { + foreach (Model.Track t in project.tracks) { + if (t != track) { + t.set_selected(false); + } + } + } + } + + void on_clip_moved(Model.Clip clip) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_moved"); + update_menu(); + } + + void on_drag_data_received(Gtk.Widget w, Gdk.DragContext context, int x, int y, + Gtk.SelectionData selection_data, uint drag_info, uint time) { + present(); + } + + void update_menu() { + bool library_selected = library.has_selection(); + bool selected = timeline.is_clip_selected(); + bool playhead_on_clip = project.playhead_on_clip(); + int number_of_tracks = project.tracks.size; + bool is_stopped = is_stopped(); + bool one_selected = false; + if (library_selected) { + one_selected = library.get_selected_files().size == 1; + } else if (selected) { + one_selected = timeline.selected_clips.size == 1; + } + + // File menu + set_sensitive_group(main_group, "NewProject", is_stopped); + set_sensitive_group(main_group, "Open", is_stopped); + set_sensitive_group(main_group, "Save", is_stopped); + set_sensitive_group(main_group, "SaveAs", is_stopped); + set_sensitive_group(main_group, "Settings", is_stopped); + set_sensitive_group(main_group, "Export", project.can_export()); + set_sensitive_group(main_group, "Quit", !project.transport_is_recording()); + + // Edit menu + set_sensitive_group(main_group, "Undo", is_stopped && project.undo_manager.can_undo); + set_sensitive_group(main_group, "Copy", is_stopped && selected); + set_sensitive_group(main_group, "Cut", is_stopped && selected); + set_sensitive_group(main_group, "Paste", timeline.clipboard.clips.size != 0 && is_stopped); + set_sensitive_group(main_group, "Delete", (selected || library_selected) && is_stopped); + set_sensitive_group(main_group, "SplitAtPlayhead", + selected && playhead_on_clip && is_stopped); + set_sensitive_group(main_group, "TrimToPlayhead", + selected && playhead_on_clip && is_stopped); + set_sensitive_group(main_group, "ClipProperties", one_selected); + + // View menu + set_sensitive_group(main_group, "ZoomProject", project.get_length() != 0); + + // Track menu + set_sensitive_group(main_group, "Rename", number_of_tracks > 0 && is_stopped); + set_sensitive_group(main_group, "DeleteTrack", number_of_tracks > 0 && is_stopped); + set_sensitive_group(main_group, "NewTrack", is_stopped); + + // toolbar + set_sensitive_group(main_group, "Play", true); + set_sensitive_group(main_group, "Record", number_of_tracks > 0 && is_stopped); + } + + public Model.Track? selected_track() { + foreach (Model.Track track in project.tracks) { + if (track.get_is_selected()) { + return track; + } + } + error("can't find selected track"); + return null; + } + + public void scroll_to_beginning() { + h_adjustment.set_value(0.0); + } + + public void page_to_time(int64 time) { + double location_in_window = timeline.provider.time_to_xpos(time) - h_adjustment.get_value(); + int window_width = timeline.parent.allocation.width; + if (location_in_window > 0.9 * window_width || + location_in_window < 0.1 * window_width) { + scroll_to_time(time); + } + } + + public void scroll_to_time(int64 time) { + int new_adjustment = timeline.provider.time_to_xpos(time); + int window_width = timeline.parent.allocation.width; + if (new_adjustment < timeline.parent.allocation.width) { + new_adjustment = 0; + } else { + new_adjustment = new_adjustment - window_width / 2; + } + + int max_value = (int)(h_adjustment.upper - timeline_scrolled.allocation.width); + if (new_adjustment > max_value) { + new_adjustment = max_value; + } + + h_adjustment.set_value(new_adjustment); + } + + public void scroll_to_end() { + scroll_to_time(project.get_length()); + } + + static int sgn(int x) { + if (x == 0) + return 0; + return x < 0 ? -1 : 1; + } + + public void scroll_toward_center(int xpos) { + if (cursor_pos == -1) { + cursor_pos = xpos - (int) h_adjustment.value; + } + // Move the cursor position toward the center of the window. We compute + // the remaining distance and move by its square root; this results in + // a smooth decelerating motion. + int page_size = (int) h_adjustment.page_size; + int diff = page_size / 2 - cursor_pos; + int d = sgn(diff) * (int) Math.sqrt(diff.abs()); + cursor_pos += d; + int x = int.max(0, xpos - cursor_pos); + int max_value = (int)(h_adjustment.upper - timeline_scrolled.allocation.width); + if (x > max_value) { + x = max_value; + } + h_adjustment.set_value(x); + } + + public override bool key_press_event(Gdk.EventKey event) { + switch (event.keyval) { + case KeySyms.KP_Enter: + case KeySyms.Return: + if (project.transport_is_recording()) { + break; + } + if ((event.state & GDK_SHIFT_ALT_CONTROL_MASK) != 0) + return base.key_press_event(event); + on_rewind(); + break; + case KeySyms.Left: + if (project.transport_is_recording()) { + break; + } + if ((event.state & Gdk.ModifierType.CONTROL_MASK) != 0) { + project.go_previous(); + } else { + project.media_engine.go(project.transport_get_position() - Gst.SECOND); + } + page_to_time(project.transport_get_position()); + break; + case KeySyms.Right: + if (project.transport_is_recording()) { + break; + } + if ((event.state & Gdk.ModifierType.CONTROL_MASK) != 0) { + project.go_next(); + } else { + project.media_engine.go(project.transport_get_position() + Gst.SECOND); + } + page_to_time(project.transport_get_position()); + break; + case KeySyms.KP_Add: + case KeySyms.equal: + case KeySyms.plus: + on_zoom_in(); + break; + case KeySyms.KP_Subtract: + case KeySyms.minus: + case KeySyms.underscore: + on_zoom_out(); + break; + default: + return base.key_press_event(event); + } + return true; + } + + // File menu + void on_export() { + string filename = null; + if (DialogUtils.save(this, "Export", false, export_filters, ref filename)) { + try { + new MultiFileProgress(this, 1, "Export", project.media_engine); + project.media_engine.disconnect_output(audio_output); + audio_export = new View.OggVorbisExport(View.MediaConnector.MediaTypes.Audio, + filename, project.media_engine.get_project_audio_export_caps()); + project.media_engine.connect_output(audio_export); + project.media_engine.start_export(filename); + } catch (Error e) { + do_error_dialog("Could not export file", e.message); + } + } + } + + void on_post_export(bool canceled) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_post_export"); + project.media_engine.disconnect_output(audio_export); + project.media_engine.connect_output(audio_output); + + if (canceled) { + GLib.FileUtils.remove(audio_export.get_filename()); + } + + audio_export = null; + } + + void on_project_new_finished_closing(bool project_did_close) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_project_new_finished_closing"); + project.closed.disconnect(on_project_close); + finished_closing.disconnect(on_project_new_finished_closing); + if (project_did_close) { + project.media_engine.set_play_state(PlayState.LOADING); + project.load(null); + default_track_set(); + project.media_engine.pipeline.set_state(Gst.State.PAUSED); + project.undo_manager.reset(); + } + } + + void on_project_new() { + load_errors.clear(); + project.closed.connect(on_project_close); + finished_closing.connect(on_project_new_finished_closing); + project.close(); + } + + void on_project_open_finished_closing(bool project_did_close) { + project.closed.disconnect(on_project_close); + finished_closing.disconnect(on_project_open_finished_closing); + if (project_did_close) { + GLib.SList filenames; + if (DialogUtils.open(this, filters, false, false, out filenames)) { + loading = true; + project.load(filenames.data); + } + } + } + + void on_project_open() { + load_errors.clear(); + project.closed.connect(on_project_close); + finished_closing.connect(on_project_open_finished_closing); + project.close(); + } + + void on_project_save_as() { + save_dialog(); + } + + void on_project_save() { + do_save(); + } + + void on_save_new_file_finished_closing(bool did_close) { + project.closed.disconnect(on_project_close); + finished_closing.disconnect(on_save_new_file_finished_closing); + project.load(project.get_project_file()); + } + + bool do_save() { + if (project.get_project_file() != null) { + project.save(null); + return true; + } + else { + return save_dialog(); + } + } + + bool save_dialog() { + bool saving_new_file = project.get_project_file() == null; + + string filename = project.get_project_file(); + bool create_directory = project.get_project_file() == null; + if (DialogUtils.save(this, "Save Project", create_directory, filters, ref filename)) { + project.save(filename); + if (saving_new_file && project.get_project_file() != null) { + project.closed.connect(on_project_close); + finished_closing.connect(on_save_new_file_finished_closing); + project.close(); + } + return true; + } + return false; + } + + void on_properties() { + Gtk.Builder builder = new Gtk.Builder(); + try { + builder.add_from_file(AppDirs.get_exec_dir().get_path() + "/resources/fillmore.glade"); + //"/home/developer/Fillmore/resources/fillmore.glade"); + //AppDirs.get_resources_dir().get_child("fillmore.glade").get_path()); + } catch(GLib.Error e) { + stdout.printf("%s\n", e.message); + return; + } + builder.connect_signals(null); + ProjectProperties properties = (ProjectProperties)builder.get_object("projectproperties1"); + properties.setup(project, builder); + + int response = properties.run(); + if (response == Gtk.ResponseType.APPLY) { + string description = "Set Project Properties"; + project.undo_manager.start_transaction(description); + project.set_bpm(properties.get_tempo()); + project.set_time_signature(properties.get_time_signature()); + project.click_during_record = properties.during_record(); + project.click_during_play = properties.during_play(); + project.click_volume = properties.get_click_volume(); + project.undo_manager.end_transaction(description); + } + properties.destroy(); + } + + void on_quit_finished_closing(bool project_did_close) { + project.closed.disconnect(on_project_close); + finished_closing.disconnect(on_quit_finished_closing); + if (project_did_close) { + Gtk.main_quit(); + } + } + + void on_quit() { + if (!project.transport_is_recording()) { + project.closed.connect(on_project_close); + finished_closing.connect(on_quit_finished_closing); + project.close(); + } + } + + bool on_delete_event() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_delete_event"); + on_quit(); + return true; + } + + void on_project_close() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_project_close"); + if (project.undo_manager.is_dirty) { + switch(DialogUtils.save_close_cancel(this, null, "Save changes before closing?")) { + case Gtk.ResponseType.ACCEPT: + if (!do_save()) { + finished_closing(false); + return; + } + break; + case Gtk.ResponseType.NO: + // if the user has never saved the file but quits anyway, save in .fillmore + if (project.get_project_file() == null) { + project.save(null); + } + break; + case Gtk.ResponseType.DELETE_EVENT: // when user presses escape. + case Gtk.ResponseType.CANCEL: + finished_closing(false); + return; + default: + assert(false); + break; + } + } + finished_closing(true); + } + + // Edit menu + void on_cut() { + timeline.do_cut(); + } + + void on_copy() { + timeline.do_copy(); + } + + void on_paste() { + timeline.paste(); + } + + void on_undo() { + project.undo(); + } + + void on_delete() { + if (library.has_selection()) { + library.delete_selection(); + } else { + timeline.delete_selection(); + } + } + + void on_select_all() { + if (library.has_selection()) { + library.select_all(); + } else { + timeline.select_all(); + } + } + + public void on_split_at_playhead() { + project.split_at_playhead(); + } + + public void on_trim_to_playhead() { + project.trim_to_playhead(); + } + + public void on_clip_properties() { + if (library.has_selection()) { + Gee.ArrayList files = library.get_selected_files(); + if (files.size == 1) { + string file_name = files.get(0); + Model.ClipFile? clip_file = project.find_clipfile(file_name); + DialogUtils.show_clip_properties(this, null, clip_file, null); + } + } else { + Gee.ArrayList clips = timeline.selected_clips; + if (clips.size == 1) { + ClipView clip_view = clips.get(0); + DialogUtils.show_clip_properties(this, clip_view, null, null); + } + } + } + + // Track menu + + void on_track_new() { + UI.TrackInformation dialog = new UI.TrackInformation(); + dialog.set_track_name(get_default_track_name()); + if (track_name_dialog(dialog, null)) { + project.add_track(new Model.AudioTrack(project, dialog.get_track_name())); + } + dialog.destroy(); + } + + void on_track_rename() { + UI.TrackInformation dialog = new UI.TrackInformation(); + Model.Track track = selected_track(); + dialog.set_title("Rename Track"); + dialog.set_track_name(selected_track().display_name); + if (track_name_dialog(dialog, track)) { + track.set_display_name(dialog.get_track_name()); + } + dialog.destroy(); + } + + bool track_name_dialog(UI.TrackInformation dialog, Model.Track? track) { + Gtk.ResponseType result = Gtk.ResponseType.OK; + bool is_ok = true; + do { + result = (Gtk.ResponseType) dialog.run(); + string new_name = dialog.get_track_name(); + + if (result == Gtk.ResponseType.OK) { + if (new_name == "") { + is_ok = false; + DialogUtils.error("Invalid track name.", "The track name cannot be empty."); + } else { + is_ok = !project.is_duplicate_track_name(track, new_name); + if (!is_ok) { + DialogUtils.error("Duplicate track name.", + "A track with this name already exists."); + } + } + } + } while (result == Gtk.ResponseType.OK && !is_ok); + return result == Gtk.ResponseType.OK && is_ok; + } + + void on_track_remove() { + project.remove_track(selected_track()); + } + + // View menu + void on_zoom_in() { + do_zoom(0.1f); + } + + void on_zoom_out() { + do_zoom(-0.1f); + } + + void on_zoom_to_project() { + timeline.zoom_to_project(h_adjustment.page_size); + } + + void on_snap() { + project.snap_to_clip = !project.snap_to_clip; + } + + void on_view_library() { + if (timeline_library_pane.child2 == library_scrolled) { + timeline_library_pane.remove(library_scrolled); + project.library_visible = false; + } else { + timeline_library_pane.add2(library_scrolled); + timeline_library_pane.show_all(); + project.library_visible = true; + } + } + + void on_library_size_allocate(Gdk.Rectangle rectangle) { + if (!loading && timeline_library_pane.child2 == library_scrolled) { + project.library_width = rectangle.width; + } + } + + // Help menu + + void on_help_contents() { + try { + Gtk.show_uri(null, "http://trac.yorba.org/wiki/UsingFillmore0.1", 0); + } catch (GLib.Error e) { + } + } + + void on_about() { + Gtk.show_about_dialog(this, + "version", project.get_version(), + "comments", "An audio editor and recorder", + "copyright", "Copyright 2009-2010 Yorba Foundation", + "website", "http://www.yorba.org", + "license", project.get_license(), + "website-label", "Visit the Yorba web site", + "authors", project.authors + ); + } + + void on_save_graph() { + project.print_graph(project.media_engine.pipeline, "save_graph"); + } + + // toolbar + + void on_volume() { + /// TODO + } + + void on_rewind() { + project.media_engine.go(0); + scroll_to_beginning(); + } + + void on_end() { + project.go_end(); + scroll_to_end(); + } + + void on_play() { + if (project.transport_is_recording()) { + set_sensitive_group(main_group, "Record", true); + record_button.set_active(false); + play_button.set_active(false); + project.media_engine.pause(); + } else if (play_button.get_active()) + project.media_engine.do_play(PlayState.PLAYING); + else + project.media_engine.pause(); + } + + void on_record() { + if (record_button.get_active()) { + Model.AudioTrack audio_track = selected_track() as Model.AudioTrack; + int number_of_channels; + if (audio_track.get_num_channels(out number_of_channels)) { + if (number_of_channels > CHANNELS_PER_TRACK_RECORD) { + record_button.set_active(false); + on_error_occurred("Can not record onto a stereo track", null); + return; + } + } + set_sensitive_group(main_group, "Record", false); + set_sensitive_group(main_group, "Play", false); + project.record(audio_track); + } + else { + on_play(); + } + } + + void on_callback_pulse() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_callback_pulse"); + if (project.transport_is_playing()) { + scroll_toward_center(provider.time_to_xpos(project.media_engine.position)); + } + timeline.queue_draw(); + } + + int64 get_zoom_center_time() { + return project.transport_get_position(); + } + + void do_zoom(float increment) { + center_time = get_zoom_center_time(); + timeline.zoom(increment); + } + + void on_timeline_size_allocate(Gdk.Rectangle rectangle) { + if (center_time != -1) { + int new_center_pixel = provider.time_to_xpos(center_time); + int page_size = (int)(h_adjustment.get_page_size() / 2); + h_adjustment.clamp_page(new_center_pixel - page_size, new_center_pixel + page_size); + center_time = -1; + } + } + + void on_timeline_selection_changed(bool selected) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_timeline_selection_changed"); + if (selected) { + library.unselect_all(); + } + update_menu(); + } + + public void on_library_selection_changed(bool selected) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_library_selection_changed"); + if (selected) { + timeline.deselect_all_clips(); + timeline.queue_draw(); + } + update_menu(); + } + + // main + + /*static void main(string[] args) { + Hildon.gtk_init(ref args); + debug_level = -1; + OptionContext context = new OptionContext( + " [project file] - Record and edit multitrack audio"); + context.add_main_entries(options, null); + context.add_group(Gst.init_get_option_group()); + + try { + context.parse(ref args); + } catch (GLib.Error arg_error) { + stderr.printf("%s\nRun 'fillmore --help' for a full list of available command line options.", + arg_error.message); + return; + } + Gtk.init(ref args); + try { + GLib.Environment.set_application_name("Fillmore"); + if (debug_level > -1) { + set_logging_level((Logging.Level)debug_level); + } + + AppDirs.init(args[0], _PROGRAM_NAME); + string rc_file = AppDirs.get_resources_dir().get_child("fillmore.rc").get_path(); + + Gtk.rc_parse(rc_file); + Gst.init(ref args); + + string? project_file = null; + if (args.length > 1) { + project_file = args[1]; + try { + project_file = GLib.Filename.from_uri(project_file); + } catch (GLib.Error e) { } + } + + ClassFactory.set_class_factory(new FillmoreClassFactory()); + View.MediaEngine.can_run(); + + Recorder recorder = new Recorder(project_file); + recorder.show_all(); + Gtk.main(); + } catch (Error e) { + do_error_dialog("Could not start application.",e.message); + } + }*/ + + public static void do_error_dialog(string major_message, string? minor_message) { + DialogUtils.error(major_message, minor_message); + } + + public void on_load_error(string message) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_load_error"); + load_errors.add(message); + } + + public void on_load_complete() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_load_complete"); + project.media_engine.pipeline.set_state(Gst.State.PAUSED); + timeline_library_pane.set_position(project.library_width); + + Gtk.ToggleAction action = main_group.get_action("Library") as Gtk.ToggleAction; + if (action.get_active() != project.library_visible) { + action.set_active(project.library_visible); + } + + action = main_group.get_action("Snap") as Gtk.ToggleAction; + if (action.get_active() != project.snap_to_clip) { + action.set_active(project.snap_to_clip); + } + + if (project.library_visible) { + if (timeline_library_pane.child2 != library_scrolled) { + timeline_library_pane.add2(library_scrolled); + } + } else { + if (timeline_library_pane.child2 == library_scrolled) { + timeline_library_pane.remove(library_scrolled); + } + } + + if (load_errors.size > 0) { + string message = ""; + foreach (string s in load_errors) { + message = message + s + "\n"; + } + do_error_dialog("An error occurred loading the project.", message); + } + + loading = false; + } + + void on_name_changed() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_name_changed"); + set_title(project.get_file_display_name()); + } + + void on_dirty_changed(bool isDirty) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_dirty_changed"); + Gtk.MenuItem? file_save = (Gtk.MenuItem?) get_widget(manager, "/MenuBar/ProjectMenu/Save"); + assert(file_save != null); + file_save.set_sensitive(isDirty); + } + + void on_undo_changed(bool can_undo) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_undo_changed"); + Gtk.MenuItem? undo = (Gtk.MenuItem?) get_widget(manager, "/MenuBar/EditMenu/EditUndo"); + assert(undo != null); + //undo.set_label("_Undo " + project.undo_manager.get_undo_title()); + set_sensitive_group(main_group, "Undo", is_stopped() && project.undo_manager.can_undo); + } + + void on_playstate_changed(PlayState playstate) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_playstate_changed"); + if (playstate == PlayState.STOPPED) { + cursor_pos = -1; + play_button.set_active(false); + set_sensitive_group(main_group, "Export", project.can_export()); + update_menu(); + } + } + + void on_error_occurred(string major_message, string? minor_message) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_error_occurred"); + DialogUtils.error(major_message, minor_message); + } + + string get_fillmore_directory() { + return Path.build_filename(GLib.Environment.get_home_dir(), ".fillmore"); + } + + // TransportDelegate methods + bool is_playing() { + return project.transport_is_playing(); + } + + bool is_recording() { + return project.transport_is_recording(); + } + + bool is_stopped() { + return !(is_playing() || is_recording()); + } +} + +public class Fillmore : Hildon.Program { + construct { } + + public void run(string[] args) { + debug_level = -1; + OptionContext context = new OptionContext( + " [project file] - Record and edit multitrack audio"); + context.add_main_entries(options, null); + context.add_group(Gst.init_get_option_group()); + + try { + context.parse(ref args); + } catch (GLib.Error arg_error) { + stderr.printf("%s\nRun 'fillmore --help' for a full list of available command line options.", + arg_error.message); + return; + } + //Gtk.init(ref args); + try { + GLib.Environment.set_application_name("Fillmore"); + if (debug_level > -1) { + set_logging_level((Logging.Level)debug_level); + } + + AppDirs.init(args[0], _PROGRAM_NAME); + string rc_file = AppDirs.get_resources_dir().get_child("fillmore.rc").get_path(); + + Gtk.rc_parse(rc_file); + //Gst.init(ref args); + + string? project_file = null; + if (args.length > 1) { + project_file = args[1]; + try { + project_file = GLib.Filename.from_uri(project_file); + } catch (GLib.Error e) { } + } + + ClassFactory.set_class_factory(new FillmoreClassFactory()); + View.MediaEngine.can_run(); + + Recorder recorder = new Recorder(project_file); + recorder.show_all(); + Gtk.main(); + } catch (Error e) { + Recorder.do_error_dialog("Could not start application.",e.message); + } + } +} + +public static int main(string[] args) { + Gtk.init(ref args); + Gst.init(ref args); + Fillmore fillmore = new Fillmore(); + fillmore.run(args); + return 0; +} + +static void NO_main(string[] args) { + Hildon.gtk_init(ref args); + debug_level = -1; + OptionContext context = new OptionContext( + " [project file] - Record and edit multitrack audio"); + context.add_main_entries(options, null); + context.add_group(Gst.init_get_option_group()); + + try { + context.parse(ref args); + } catch (GLib.Error arg_error) { + stderr.printf("%s\nRun 'fillmore --help' for a full list of available command line options.", + arg_error.message); + return; + } + Gtk.init(ref args); + try { + GLib.Environment.set_application_name("Fillmore"); + if (debug_level > -1) { + set_logging_level((Logging.Level)debug_level); + } + + AppDirs.init(args[0], _PROGRAM_NAME); + string rc_file = AppDirs.get_resources_dir().get_child("fillmore.rc").get_path(); + + Gtk.rc_parse(rc_file); + Gst.init(ref args); + + string? project_file = null; + if (args.length > 1) { + project_file = args[1]; + try { + project_file = GLib.Filename.from_uri(project_file); + } catch (GLib.Error e) { } + } + + ClassFactory.set_class_factory(new FillmoreClassFactory()); + View.MediaEngine.can_run(); + + Recorder recorder = new Recorder(project_file); + recorder.show_all(); + Gtk.main(); + } catch (Error e) { + Recorder.do_error_dialog("Could not start application.",e.message); + } +} diff --git a/src/fillmore/fillmore/.stamp b/src/fillmore/fillmore/.stamp new file mode 100644 index 0000000..e69de29 diff --git a/src/fillmore/fillmore/FillmoreClassFactory.c b/src/fillmore/fillmore/FillmoreClassFactory.c new file mode 100644 index 0000000..32a4c30 --- /dev/null +++ b/src/fillmore/fillmore/FillmoreClassFactory.c @@ -0,0 +1,401 @@ +/* FillmoreClassFactory.c generated by valac, the Vala compiler + * generated from FillmoreClassFactory.vala, do not modify */ + +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include + + +#define TYPE_TRACK_SEPARATOR (track_separator_get_type ()) +#define TRACK_SEPARATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRACK_SEPARATOR, TrackSeparator)) +#define TRACK_SEPARATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TRACK_SEPARATOR, TrackSeparatorClass)) +#define IS_TRACK_SEPARATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRACK_SEPARATOR)) +#define IS_TRACK_SEPARATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TRACK_SEPARATOR)) +#define TRACK_SEPARATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TRACK_SEPARATOR, TrackSeparatorClass)) + +typedef struct _TrackSeparator TrackSeparator; +typedef struct _TrackSeparatorClass TrackSeparatorClass; +typedef struct _TrackSeparatorPrivate TrackSeparatorPrivate; + +#define TYPE_FILLMORE_TRACK_VIEW (fillmore_track_view_get_type ()) +#define FILLMORE_TRACK_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_FILLMORE_TRACK_VIEW, FillmoreTrackView)) +#define FILLMORE_TRACK_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_FILLMORE_TRACK_VIEW, FillmoreTrackViewClass)) +#define IS_FILLMORE_TRACK_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_FILLMORE_TRACK_VIEW)) +#define IS_FILLMORE_TRACK_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_FILLMORE_TRACK_VIEW)) +#define FILLMORE_TRACK_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_FILLMORE_TRACK_VIEW, FillmoreTrackViewClass)) + +typedef struct _FillmoreTrackView FillmoreTrackView; +typedef struct _FillmoreTrackViewClass FillmoreTrackViewClass; +typedef struct _FillmoreTrackViewPrivate FillmoreTrackViewPrivate; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) + +#define TYPE_FILLMORE_CLASS_FACTORY (fillmore_class_factory_get_type ()) +#define FILLMORE_CLASS_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_FILLMORE_CLASS_FACTORY, FillmoreClassFactory)) +#define FILLMORE_CLASS_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_FILLMORE_CLASS_FACTORY, FillmoreClassFactoryClass)) +#define IS_FILLMORE_CLASS_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_FILLMORE_CLASS_FACTORY)) +#define IS_FILLMORE_CLASS_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_FILLMORE_CLASS_FACTORY)) +#define FILLMORE_CLASS_FACTORY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_FILLMORE_CLASS_FACTORY, FillmoreClassFactoryClass)) + +typedef struct _FillmoreClassFactory FillmoreClassFactory; +typedef struct _FillmoreClassFactoryClass FillmoreClassFactoryClass; +typedef struct _FillmoreClassFactoryPrivate FillmoreClassFactoryPrivate; + +struct _TrackSeparator { + GtkHSeparator parent_instance; + TrackSeparatorPrivate * priv; +}; + +struct _TrackSeparatorClass { + GtkHSeparatorClass parent_class; +}; + +struct _FillmoreTrackView { + GtkVBox parent_instance; + FillmoreTrackViewPrivate * priv; +}; + +struct _FillmoreTrackViewClass { + GtkVBoxClass parent_class; +}; + +struct _FillmoreTrackViewPrivate { + TrackView* track_view; +}; + +struct _FillmoreClassFactory { + ClassFactory parent_instance; + FillmoreClassFactoryPrivate * priv; +}; + +struct _FillmoreClassFactoryClass { + ClassFactoryClass parent_class; +}; + + +static gpointer track_separator_parent_class = NULL; +static gpointer fillmore_track_view_parent_class = NULL; +static TrackViewIface* fillmore_track_view_track_view_parent_iface = NULL; +static gpointer fillmore_class_factory_parent_class = NULL; + +GType track_separator_get_type (void); +enum { + TRACK_SEPARATOR_DUMMY_PROPERTY +}; +TrackSeparator* track_separator_new (void); +TrackSeparator* track_separator_construct (GType object_type); +GType fillmore_track_view_get_type (void); +#define FILLMORE_TRACK_VIEW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_FILLMORE_TRACK_VIEW, FillmoreTrackViewPrivate)) +enum { + FILLMORE_TRACK_VIEW_DUMMY_PROPERTY +}; +static void fillmore_track_view_on_clip_view_added (FillmoreTrackView* self, ClipView* clip_view); +static void _fillmore_track_view_on_clip_view_added_track_view_clip_view_added (TrackView* _sender, ClipView* clip_view, gpointer self); +FillmoreTrackView* fillmore_track_view_new (TrackView* track_view); +FillmoreTrackView* fillmore_track_view_construct (GType object_type, TrackView* track_view); +static void fillmore_track_view_real_move_to_top (TrackView* base, ClipView* clip_view); +static void fillmore_track_view_real_resize (TrackView* base); +static ModelTrack* fillmore_track_view_real_get_track (TrackView* base); +static gint fillmore_track_view_real_get_track_height (TrackView* base); +static GtkWidget* fillmore_track_view_real_find_child (TrackView* base, double x, double y); +static void fillmore_track_view_real_select_all (TrackView* base); +static void fillmore_track_view_finalize (GObject* obj); +GType fillmore_class_factory_get_type (void); +enum { + FILLMORE_CLASS_FACTORY_DUMMY_PROPERTY +}; +static TrackView* fillmore_class_factory_real_get_track_view (ClassFactory* base, ModelTrack* track, TimeLine* timeline); +FillmoreClassFactory* fillmore_class_factory_new (void); +FillmoreClassFactory* fillmore_class_factory_construct (GType object_type); + + + +#line 7 "FillmoreClassFactory.vala" +TrackSeparator* track_separator_construct (GType object_type) { +#line 124 "FillmoreClassFactory.c" + TrackSeparator * self; + self = g_object_newv (object_type, 0, NULL); + return self; +} + + +#line 7 "FillmoreClassFactory.vala" +TrackSeparator* track_separator_new (void) { +#line 7 "FillmoreClassFactory.vala" + return track_separator_construct (TYPE_TRACK_SEPARATOR); +#line 135 "FillmoreClassFactory.c" +} + + +static void track_separator_class_init (TrackSeparatorClass * klass) { + track_separator_parent_class = g_type_class_peek_parent (klass); +} + + +static void track_separator_instance_init (TrackSeparator * self) { +} + + +GType track_separator_get_type (void) { + static volatile gsize track_separator_type_id__volatile = 0; + if (g_once_init_enter (&track_separator_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (TrackSeparatorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) track_separator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (TrackSeparator), 0, (GInstanceInitFunc) track_separator_instance_init, NULL }; + GType track_separator_type_id; + track_separator_type_id = g_type_register_static (GTK_TYPE_HSEPARATOR, "TrackSeparator", &g_define_type_info, 0); + g_once_init_leave (&track_separator_type_id__volatile, track_separator_type_id); + } + return track_separator_type_id__volatile; +} + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 38 "FillmoreClassFactory.vala" +static void _fillmore_track_view_on_clip_view_added_track_view_clip_view_added (TrackView* _sender, ClipView* clip_view, gpointer self) { +#line 167 "FillmoreClassFactory.c" + fillmore_track_view_on_clip_view_added (self, clip_view); +} + + +#line 13 "FillmoreClassFactory.vala" +FillmoreTrackView* fillmore_track_view_construct (GType object_type, TrackView* track_view) { +#line 174 "FillmoreClassFactory.c" + FillmoreTrackView * self; + TrackView* _tmp0_; + TrackSeparator* _tmp1_; +#line 13 "FillmoreClassFactory.vala" + g_return_val_if_fail (IS_TRACK_VIEW (track_view), NULL); +#line 180 "FillmoreClassFactory.c" + self = g_object_newv (object_type, 0, NULL); +#line 14 "FillmoreClassFactory.vala" + self->priv->track_view = (_tmp0_ = _g_object_ref0 (track_view), _g_object_unref0 (self->priv->track_view), _tmp0_); +#line 15 "FillmoreClassFactory.vala" + g_signal_connect_object (track_view, "clip-view-added", (GCallback) _fillmore_track_view_on_clip_view_added_track_view_clip_view_added, self, 0); +#line 17 "FillmoreClassFactory.vala" + gtk_box_pack_start (GTK_BOX (self), GTK_WIDGET (track_view), TRUE, TRUE, (guint) 0); +#line 18 "FillmoreClassFactory.vala" + gtk_box_pack_start (GTK_BOX (self), GTK_WIDGET (_tmp1_ = g_object_ref_sink (track_separator_new ())), FALSE, FALSE, (guint) 0); +#line 190 "FillmoreClassFactory.c" + _g_object_unref0 (_tmp1_); +#line 19 "FillmoreClassFactory.vala" + g_object_set (GTK_WIDGET (self), "can-focus", FALSE, NULL); +#line 194 "FillmoreClassFactory.c" + return self; +} + + +#line 13 "FillmoreClassFactory.vala" +FillmoreTrackView* fillmore_track_view_new (TrackView* track_view) { +#line 13 "FillmoreClassFactory.vala" + return fillmore_track_view_construct (TYPE_FILLMORE_TRACK_VIEW, track_view); +#line 203 "FillmoreClassFactory.c" +} + + +#line 22 "FillmoreClassFactory.vala" +static void fillmore_track_view_real_move_to_top (TrackView* base, ClipView* clip_view) { +#line 209 "FillmoreClassFactory.c" + FillmoreTrackView * self; + self = FILLMORE_TRACK_VIEW (base); +#line 22 "FillmoreClassFactory.vala" + g_return_if_fail (IS_CLIP_VIEW (clip_view)); +#line 23 "FillmoreClassFactory.vala" + track_view_move_to_top (self->priv->track_view, clip_view); +#line 216 "FillmoreClassFactory.c" +} + + +#line 26 "FillmoreClassFactory.vala" +static void fillmore_track_view_real_resize (TrackView* base) { +#line 222 "FillmoreClassFactory.c" + FillmoreTrackView * self; + self = FILLMORE_TRACK_VIEW (base); +#line 27 "FillmoreClassFactory.vala" + track_view_resize (self->priv->track_view); +#line 227 "FillmoreClassFactory.c" +} + + +#line 30 "FillmoreClassFactory.vala" +static ModelTrack* fillmore_track_view_real_get_track (TrackView* base) { +#line 233 "FillmoreClassFactory.c" + FillmoreTrackView * self; + ModelTrack* result = NULL; + self = FILLMORE_TRACK_VIEW (base); + result = track_view_get_track (self->priv->track_view); +#line 31 "FillmoreClassFactory.vala" + return result; +#line 240 "FillmoreClassFactory.c" +} + + +#line 34 "FillmoreClassFactory.vala" +static gint fillmore_track_view_real_get_track_height (TrackView* base) { +#line 246 "FillmoreClassFactory.c" + FillmoreTrackView * self; + gint result = 0; + self = FILLMORE_TRACK_VIEW (base); + result = track_view_get_track_height (self->priv->track_view); +#line 35 "FillmoreClassFactory.vala" + return result; +#line 253 "FillmoreClassFactory.c" +} + + +#line 38 "FillmoreClassFactory.vala" +static void fillmore_track_view_on_clip_view_added (FillmoreTrackView* self, ClipView* clip_view) { +#line 38 "FillmoreClassFactory.vala" + g_return_if_fail (IS_FILLMORE_TRACK_VIEW (self)); +#line 38 "FillmoreClassFactory.vala" + g_return_if_fail (IS_CLIP_VIEW (clip_view)); +#line 39 "FillmoreClassFactory.vala" + g_signal_emit_by_name (TRACK_VIEW (self), "clip-view-added", clip_view); +#line 265 "FillmoreClassFactory.c" +} + + +#line 42 "FillmoreClassFactory.vala" +static GtkWidget* fillmore_track_view_real_find_child (TrackView* base, double x, double y) { +#line 271 "FillmoreClassFactory.c" + FillmoreTrackView * self; + GtkWidget* result = NULL; + self = FILLMORE_TRACK_VIEW (base); + result = track_view_find_child (self->priv->track_view, x, y); +#line 43 "FillmoreClassFactory.vala" + return result; +#line 278 "FillmoreClassFactory.c" +} + + +#line 46 "FillmoreClassFactory.vala" +static void fillmore_track_view_real_select_all (TrackView* base) { +#line 284 "FillmoreClassFactory.c" + FillmoreTrackView * self; + self = FILLMORE_TRACK_VIEW (base); +#line 47 "FillmoreClassFactory.vala" + track_view_select_all (self->priv->track_view); +#line 289 "FillmoreClassFactory.c" +} + + +static void fillmore_track_view_class_init (FillmoreTrackViewClass * klass) { + fillmore_track_view_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (FillmoreTrackViewPrivate)); + G_OBJECT_CLASS (klass)->finalize = fillmore_track_view_finalize; +} + + +static void fillmore_track_view_track_view_interface_init (TrackViewIface * iface) { + fillmore_track_view_track_view_parent_iface = g_type_interface_peek_parent (iface); + iface->move_to_top = fillmore_track_view_real_move_to_top; + iface->resize = fillmore_track_view_real_resize; + iface->get_track = fillmore_track_view_real_get_track; + iface->get_track_height = fillmore_track_view_real_get_track_height; + iface->find_child = fillmore_track_view_real_find_child; + iface->select_all = fillmore_track_view_real_select_all; +} + + +static void fillmore_track_view_instance_init (FillmoreTrackView * self) { + self->priv = FILLMORE_TRACK_VIEW_GET_PRIVATE (self); +} + + +static void fillmore_track_view_finalize (GObject* obj) { + FillmoreTrackView * self; + self = FILLMORE_TRACK_VIEW (obj); + _g_object_unref0 (self->priv->track_view); + G_OBJECT_CLASS (fillmore_track_view_parent_class)->finalize (obj); +} + + +GType fillmore_track_view_get_type (void) { + static volatile gsize fillmore_track_view_type_id__volatile = 0; + if (g_once_init_enter (&fillmore_track_view_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (FillmoreTrackViewClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) fillmore_track_view_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (FillmoreTrackView), 0, (GInstanceInitFunc) fillmore_track_view_instance_init, NULL }; + static const GInterfaceInfo track_view_info = { (GInterfaceInitFunc) fillmore_track_view_track_view_interface_init, (GInterfaceFinalizeFunc) NULL, NULL}; + GType fillmore_track_view_type_id; + fillmore_track_view_type_id = g_type_register_static (GTK_TYPE_VBOX, "FillmoreTrackView", &g_define_type_info, 0); + g_type_add_interface_static (fillmore_track_view_type_id, TYPE_TRACK_VIEW, &track_view_info); + g_once_init_leave (&fillmore_track_view_type_id__volatile, fillmore_track_view_type_id); + } + return fillmore_track_view_type_id__volatile; +} + + +#line 52 "FillmoreClassFactory.vala" +static TrackView* fillmore_class_factory_real_get_track_view (ClassFactory* base, ModelTrack* track, TimeLine* timeline) { +#line 340 "FillmoreClassFactory.c" + FillmoreClassFactory * self; + TrackView* result = NULL; + TrackView* track_view; + self = FILLMORE_CLASS_FACTORY (base); +#line 52 "FillmoreClassFactory.vala" + g_return_val_if_fail (MODEL_IS_TRACK (track), NULL); +#line 52 "FillmoreClassFactory.vala" + g_return_val_if_fail (IS_TIME_LINE (timeline), NULL); +#line 53 "FillmoreClassFactory.vala" + track_view = CLASS_FACTORY_CLASS (fillmore_class_factory_parent_class)->get_track_view (CLASS_FACTORY (self), track, timeline); +#line 351 "FillmoreClassFactory.c" + result = TRACK_VIEW (g_object_ref_sink (fillmore_track_view_new (track_view))); + _g_object_unref0 (track_view); +#line 54 "FillmoreClassFactory.vala" + return result; +#line 356 "FillmoreClassFactory.c" +} + + +#line 51 "FillmoreClassFactory.vala" +FillmoreClassFactory* fillmore_class_factory_construct (GType object_type) { +#line 362 "FillmoreClassFactory.c" + FillmoreClassFactory* self; +#line 51 "FillmoreClassFactory.vala" + self = (FillmoreClassFactory*) class_factory_construct (object_type); +#line 366 "FillmoreClassFactory.c" + return self; +} + + +#line 51 "FillmoreClassFactory.vala" +FillmoreClassFactory* fillmore_class_factory_new (void) { +#line 51 "FillmoreClassFactory.vala" + return fillmore_class_factory_construct (TYPE_FILLMORE_CLASS_FACTORY); +#line 375 "FillmoreClassFactory.c" +} + + +static void fillmore_class_factory_class_init (FillmoreClassFactoryClass * klass) { + fillmore_class_factory_parent_class = g_type_class_peek_parent (klass); + CLASS_FACTORY_CLASS (klass)->get_track_view = fillmore_class_factory_real_get_track_view; +} + + +static void fillmore_class_factory_instance_init (FillmoreClassFactory * self) { +} + + +GType fillmore_class_factory_get_type (void) { + static volatile gsize fillmore_class_factory_type_id__volatile = 0; + if (g_once_init_enter (&fillmore_class_factory_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (FillmoreClassFactoryClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) fillmore_class_factory_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (FillmoreClassFactory), 0, (GInstanceInitFunc) fillmore_class_factory_instance_init, NULL }; + GType fillmore_class_factory_type_id; + fillmore_class_factory_type_id = g_type_register_static (TYPE_CLASS_FACTORY, "FillmoreClassFactory", &g_define_type_info, 0); + g_once_init_leave (&fillmore_class_factory_type_id__volatile, fillmore_class_factory_type_id); + } + return fillmore_class_factory_type_id__volatile; +} + + + + diff --git a/src/fillmore/fillmore/FillmoreClassFactory.o b/src/fillmore/fillmore/FillmoreClassFactory.o new file mode 100644 index 0000000..c0d427b Binary files /dev/null and b/src/fillmore/fillmore/FillmoreClassFactory.o differ diff --git a/src/fillmore/fillmore/ProjectProperties.c b/src/fillmore/fillmore/ProjectProperties.c new file mode 100644 index 0000000..3088fe0 --- /dev/null +++ b/src/fillmore/fillmore/ProjectProperties.c @@ -0,0 +1,498 @@ +/* ProjectProperties.c generated by valac, the Vala compiler + * generated from ProjectProperties.vala, do not modify */ + +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + + +#define TYPE_PROJECT_PROPERTIES (project_properties_get_type ()) +#define PROJECT_PROPERTIES(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_PROJECT_PROPERTIES, ProjectProperties)) +#define PROJECT_PROPERTIES_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_PROJECT_PROPERTIES, ProjectPropertiesClass)) +#define IS_PROJECT_PROPERTIES(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_PROJECT_PROPERTIES)) +#define IS_PROJECT_PROPERTIES_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_PROJECT_PROPERTIES)) +#define PROJECT_PROPERTIES_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_PROJECT_PROPERTIES, ProjectPropertiesClass)) + +typedef struct _ProjectProperties ProjectProperties; +typedef struct _ProjectPropertiesClass ProjectPropertiesClass; +typedef struct _ProjectPropertiesPrivate ProjectPropertiesPrivate; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +#define _g_free0(var) (var = (g_free (var), NULL)) + +struct _ProjectProperties { + GtkDialog parent_instance; + ProjectPropertiesPrivate * priv; +}; + +struct _ProjectPropertiesClass { + GtkDialogClass parent_class; +}; + +struct _ProjectPropertiesPrivate { + GTimeVal* tap_time; + gint tap_time_length1; + gint _tap_time_size_; + gint tap_index; + gboolean sample_full; + GtkAdjustment* tempo_adjustment; + GtkAdjustment* volume_adjustment; + GtkComboBox* timesignature_combo; + GtkToggleButton* click_during_play; + GtkToggleButton* click_during_record; +}; + + +static gpointer project_properties_parent_class = NULL; + +GType project_properties_get_type (void); +#define PROJECT_PROPERTIES_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_PROJECT_PROPERTIES, ProjectPropertiesPrivate)) +enum { + PROJECT_PROPERTIES_DUMMY_PROPERTY +}; +#define PROJECT_PROPERTIES_NUMBER_OF_SAMPLES 4 +#define PROJECT_PROPERTIES_G_USEC_PER_SEC ((glong) 1000000) +void project_properties_set_tempo (ProjectProperties* self, gint tempo); +void project_properties_set_volume (ProjectProperties* self, double volume); +static void project_properties_set_during_play (ProjectProperties* self, gboolean active); +static void project_properties_set_during_record (ProjectProperties* self, gboolean active); +static void project_properties_set_time_signature (ProjectProperties* self, Fraction* time_signature); +void project_properties_setup (ProjectProperties* self, ModelProject* project, GtkBuilder* builder); +gint project_properties_get_tempo (ProjectProperties* self); +double project_properties_get_click_volume (ProjectProperties* self); +void project_properties_get_time_signature (ProjectProperties* self, Fraction* result); +gboolean project_properties_during_play (ProjectProperties* self); +gboolean project_properties_during_record (ProjectProperties* self); +static void project_properties_calculate_bpm (ProjectProperties* self); +void project_properties_on_tap (ProjectProperties* self); +ProjectProperties* project_properties_new (void); +ProjectProperties* project_properties_construct (GType object_type); +static void project_properties_finalize (GObject* obj); +static int _vala_strcmp0 (const char * str1, const char * str2); + + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 20 "ProjectProperties.vala" +void project_properties_setup (ProjectProperties* self, ModelProject* project, GtkBuilder* builder) { +#line 93 "ProjectProperties.c" + GtkAdjustment* _tmp0_; + GtkAdjustment* _tmp1_; + GtkComboBox* _tmp2_; + GtkToggleButton* _tmp3_; + GtkToggleButton* _tmp4_; + Fraction _tmp6_; + Fraction _tmp5_ = {0}; +#line 20 "ProjectProperties.vala" + g_return_if_fail (IS_PROJECT_PROPERTIES (self)); +#line 20 "ProjectProperties.vala" + g_return_if_fail (MODEL_IS_PROJECT (project)); +#line 20 "ProjectProperties.vala" + g_return_if_fail (GTK_IS_BUILDER (builder)); +#line 21 "ProjectProperties.vala" + self->priv->tempo_adjustment = (_tmp0_ = _g_object_ref0 (GTK_ADJUSTMENT (gtk_builder_get_object (builder, "tempo_adjustment"))), _g_object_unref0 (self->priv->tempo_adjustment), _tmp0_); +#line 22 "ProjectProperties.vala" + self->priv->volume_adjustment = (_tmp1_ = _g_object_ref0 (GTK_ADJUSTMENT (gtk_builder_get_object (builder, "volume_adjustment"))), _g_object_unref0 (self->priv->volume_adjustment), _tmp1_); +#line 23 "ProjectProperties.vala" + self->priv->timesignature_combo = (_tmp2_ = _g_object_ref0 (GTK_COMBO_BOX (gtk_builder_get_object (builder, "timesignature_combo"))), _g_object_unref0 (self->priv->timesignature_combo), _tmp2_); +#line 24 "ProjectProperties.vala" + self->priv->click_during_play = (_tmp3_ = _g_object_ref0 (GTK_TOGGLE_BUTTON (gtk_builder_get_object (builder, "playback"))), _g_object_unref0 (self->priv->click_during_play), _tmp3_); +#line 25 "ProjectProperties.vala" + self->priv->click_during_record = (_tmp4_ = _g_object_ref0 (GTK_TOGGLE_BUTTON (gtk_builder_get_object (builder, "record"))), _g_object_unref0 (self->priv->click_during_record), _tmp4_); +#line 26 "ProjectProperties.vala" + project_properties_set_tempo (self, model_tempo_information_get_bpm (MODEL_TEMPO_INFORMATION (project))); +#line 27 "ProjectProperties.vala" + project_properties_set_volume (self, project->click_volume); +#line 28 "ProjectProperties.vala" + project_properties_set_during_play (self, project->click_during_play); +#line 29 "ProjectProperties.vala" + project_properties_set_during_record (self, project->click_during_record); +#line 30 "ProjectProperties.vala" + project_properties_set_time_signature (self, (_tmp6_ = (model_tempo_information_get_time_signature (MODEL_TEMPO_INFORMATION (project), &_tmp5_), _tmp5_), &_tmp6_)); +#line 127 "ProjectProperties.c" +} + + +#line 33 "ProjectProperties.vala" +void project_properties_set_tempo (ProjectProperties* self, gint tempo) { +#line 33 "ProjectProperties.vala" + g_return_if_fail (IS_PROJECT_PROPERTIES (self)); +#line 34 "ProjectProperties.vala" + gtk_adjustment_set_value (self->priv->tempo_adjustment, (double) tempo); +#line 137 "ProjectProperties.c" +} + + +#line 37 "ProjectProperties.vala" +gint project_properties_get_tempo (ProjectProperties* self) { +#line 143 "ProjectProperties.c" + gint result = 0; +#line 37 "ProjectProperties.vala" + g_return_val_if_fail (IS_PROJECT_PROPERTIES (self), 0); +#line 147 "ProjectProperties.c" + result = (gint) gtk_adjustment_get_value (self->priv->tempo_adjustment); +#line 38 "ProjectProperties.vala" + return result; +#line 151 "ProjectProperties.c" +} + + +#line 41 "ProjectProperties.vala" +void project_properties_set_volume (ProjectProperties* self, double volume) { +#line 41 "ProjectProperties.vala" + g_return_if_fail (IS_PROJECT_PROPERTIES (self)); +#line 42 "ProjectProperties.vala" + gtk_adjustment_set_value (self->priv->volume_adjustment, volume); +#line 161 "ProjectProperties.c" +} + + +#line 45 "ProjectProperties.vala" +double project_properties_get_click_volume (ProjectProperties* self) { +#line 167 "ProjectProperties.c" + double result = 0.0; +#line 45 "ProjectProperties.vala" + g_return_val_if_fail (IS_PROJECT_PROPERTIES (self), 0.0); +#line 171 "ProjectProperties.c" + result = gtk_adjustment_get_value (self->priv->volume_adjustment); +#line 46 "ProjectProperties.vala" + return result; +#line 175 "ProjectProperties.c" +} + + +#line 49 "ProjectProperties.vala" +void project_properties_get_time_signature (ProjectProperties* self, Fraction* result) { +#line 181 "ProjectProperties.c" + Fraction _tmp0_ = {0}; +#line 49 "ProjectProperties.vala" + g_return_if_fail (IS_PROJECT_PROPERTIES (self)); +#line 185 "ProjectProperties.c" + *result = (fraction_init_from_string (&_tmp0_, gtk_combo_box_get_active_text (self->priv->timesignature_combo)), _tmp0_); +#line 50 "ProjectProperties.vala" + return; +#line 189 "ProjectProperties.c" +} + + +#line 53 "ProjectProperties.vala" +static void project_properties_set_time_signature (ProjectProperties* self, Fraction* time_signature) { +#line 195 "ProjectProperties.c" + char* sig; + GtkTreeIter iter = {0}; +#line 53 "ProjectProperties.vala" + g_return_if_fail (IS_PROJECT_PROPERTIES (self)); +#line 54 "ProjectProperties.vala" + sig = fraction_to_string (time_signature); +#line 57 "ProjectProperties.vala" + if (gtk_tree_model_get_iter_first (gtk_combo_box_get_model (self->priv->timesignature_combo), &iter)) { +#line 204 "ProjectProperties.c" + { + gboolean _tmp0_; +#line 58 "ProjectProperties.vala" + _tmp0_ = TRUE; +#line 58 "ProjectProperties.vala" + while (TRUE) { +#line 211 "ProjectProperties.c" + char* s; +#line 58 "ProjectProperties.vala" + if (!_tmp0_) { +#line 65 "ProjectProperties.vala" + if (!gtk_tree_model_iter_next (gtk_combo_box_get_model (self->priv->timesignature_combo), &iter)) { +#line 65 "ProjectProperties.vala" + break; +#line 219 "ProjectProperties.c" + } + } +#line 58 "ProjectProperties.vala" + _tmp0_ = FALSE; +#line 224 "ProjectProperties.c" + s = NULL; +#line 60 "ProjectProperties.vala" + gtk_tree_model_get (gtk_combo_box_get_model (self->priv->timesignature_combo), &iter, 0, &s, -1, -1); +#line 61 "ProjectProperties.vala" + if (_vala_strcmp0 (s, sig) == 0) { +#line 62 "ProjectProperties.vala" + gtk_combo_box_set_active_iter (self->priv->timesignature_combo, &iter); +#line 232 "ProjectProperties.c" + _g_free0 (s); + _g_free0 (sig); +#line 63 "ProjectProperties.vala" + return; +#line 237 "ProjectProperties.c" + } + _g_free0 (s); + } + } + } + _g_free0 (sig); +} + + +#line 69 "ProjectProperties.vala" +static void project_properties_set_during_play (ProjectProperties* self, gboolean active) { +#line 69 "ProjectProperties.vala" + g_return_if_fail (IS_PROJECT_PROPERTIES (self)); +#line 70 "ProjectProperties.vala" + gtk_toggle_button_set_active (self->priv->click_during_play, active); +#line 253 "ProjectProperties.c" +} + + +#line 73 "ProjectProperties.vala" +gboolean project_properties_during_play (ProjectProperties* self) { +#line 259 "ProjectProperties.c" + gboolean result = FALSE; +#line 73 "ProjectProperties.vala" + g_return_val_if_fail (IS_PROJECT_PROPERTIES (self), FALSE); +#line 263 "ProjectProperties.c" + result = gtk_toggle_button_get_active (self->priv->click_during_play); +#line 74 "ProjectProperties.vala" + return result; +#line 267 "ProjectProperties.c" +} + + +#line 77 "ProjectProperties.vala" +static void project_properties_set_during_record (ProjectProperties* self, gboolean active) { +#line 77 "ProjectProperties.vala" + g_return_if_fail (IS_PROJECT_PROPERTIES (self)); +#line 78 "ProjectProperties.vala" + gtk_toggle_button_set_active (self->priv->click_during_record, active); +#line 277 "ProjectProperties.c" +} + + +#line 81 "ProjectProperties.vala" +gboolean project_properties_during_record (ProjectProperties* self) { +#line 283 "ProjectProperties.c" + gboolean result = FALSE; +#line 81 "ProjectProperties.vala" + g_return_val_if_fail (IS_PROJECT_PROPERTIES (self), FALSE); +#line 287 "ProjectProperties.c" + result = gtk_toggle_button_get_active (self->priv->click_during_record); +#line 82 "ProjectProperties.vala" + return result; +#line 291 "ProjectProperties.c" +} + + +#line 85 "ProjectProperties.vala" +void project_properties_on_tap (ProjectProperties* self) { +#line 297 "ProjectProperties.c" + GTimeVal time_val = {0}; +#line 85 "ProjectProperties.vala" + g_return_if_fail (IS_PROJECT_PROPERTIES (self)); +#line 301 "ProjectProperties.c" + g_get_current_time (&time_val); +#line 87 "ProjectProperties.vala" + g_get_current_time (&time_val); +#line 88 "ProjectProperties.vala" + self->priv->tap_time[self->priv->tap_index] = time_val; +#line 89 "ProjectProperties.vala" + self->priv->tap_index = self->priv->tap_index + 1; +#line 90 "ProjectProperties.vala" + if (self->priv->tap_index == PROJECT_PROPERTIES_NUMBER_OF_SAMPLES) { +#line 91 "ProjectProperties.vala" + self->priv->sample_full = TRUE; +#line 92 "ProjectProperties.vala" + self->priv->tap_index = 0; +#line 315 "ProjectProperties.c" + } +#line 94 "ProjectProperties.vala" + project_properties_calculate_bpm (self); +#line 319 "ProjectProperties.c" +} + + +#line 97 "ProjectProperties.vala" +static void project_properties_calculate_bpm (ProjectProperties* self) { +#line 325 "ProjectProperties.c" + gint _tmp0_ = 0; + gint number_of_samples; + gint _tmp1_ = 0; + gint start_index; + double delta_sum; + double average; +#line 97 "ProjectProperties.vala" + g_return_if_fail (IS_PROJECT_PROPERTIES (self)); +#line 98 "ProjectProperties.vala" + if (self->priv->sample_full) { +#line 98 "ProjectProperties.vala" + _tmp0_ = PROJECT_PROPERTIES_NUMBER_OF_SAMPLES; +#line 338 "ProjectProperties.c" + } else { +#line 98 "ProjectProperties.vala" + _tmp0_ = self->priv->tap_index; +#line 342 "ProjectProperties.c" + } +#line 98 "ProjectProperties.vala" + number_of_samples = _tmp0_; +#line 99 "ProjectProperties.vala" + if (number_of_samples < 2) { +#line 100 "ProjectProperties.vala" + return; +#line 350 "ProjectProperties.c" + } +#line 103 "ProjectProperties.vala" + if (self->priv->sample_full) { +#line 103 "ProjectProperties.vala" + _tmp1_ = self->priv->tap_index; +#line 356 "ProjectProperties.c" + } else { +#line 103 "ProjectProperties.vala" + _tmp1_ = 0; +#line 360 "ProjectProperties.c" + } +#line 103 "ProjectProperties.vala" + start_index = _tmp1_; +#line 105 "ProjectProperties.vala" + delta_sum = (double) 0; +#line 366 "ProjectProperties.c" + { + gint i; +#line 106 "ProjectProperties.vala" + i = 0; +#line 371 "ProjectProperties.c" + { + gboolean _tmp2_; +#line 106 "ProjectProperties.vala" + _tmp2_ = TRUE; +#line 106 "ProjectProperties.vala" + while (TRUE) { +#line 378 "ProjectProperties.c" + gint current_index; + gint next_index; + glong difference; +#line 106 "ProjectProperties.vala" + if (!_tmp2_) { +#line 106 "ProjectProperties.vala" + i = i + 1; +#line 386 "ProjectProperties.c" + } +#line 106 "ProjectProperties.vala" + _tmp2_ = FALSE; +#line 106 "ProjectProperties.vala" + if (!(i < (number_of_samples - 1))) { +#line 106 "ProjectProperties.vala" + break; +#line 394 "ProjectProperties.c" + } +#line 107 "ProjectProperties.vala" + current_index = (i + start_index) % PROJECT_PROPERTIES_NUMBER_OF_SAMPLES; +#line 108 "ProjectProperties.vala" + next_index = (current_index + 1) % PROJECT_PROPERTIES_NUMBER_OF_SAMPLES; +#line 110 "ProjectProperties.vala" + difference = (((self->priv->tap_time[next_index].tv_sec - self->priv->tap_time[current_index].tv_sec) * PROJECT_PROPERTIES_G_USEC_PER_SEC) + self->priv->tap_time[next_index].tv_usec) - self->priv->tap_time[current_index].tv_usec; +#line 113 "ProjectProperties.vala" + if (difference > (5 * PROJECT_PROPERTIES_G_USEC_PER_SEC)) { +#line 115 "ProjectProperties.vala" + self->priv->tap_time[0] = self->priv->tap_time[self->priv->tap_index - 1]; +#line 116 "ProjectProperties.vala" + self->priv->sample_full = FALSE; +#line 117 "ProjectProperties.vala" + self->priv->tap_index = 1; +#line 118 "ProjectProperties.vala" + return; +#line 412 "ProjectProperties.c" + } +#line 120 "ProjectProperties.vala" + delta_sum = delta_sum + ((double) difference); +#line 416 "ProjectProperties.c" + } + } + } +#line 122 "ProjectProperties.vala" + average = (delta_sum / (number_of_samples - 1)) / PROJECT_PROPERTIES_G_USEC_PER_SEC; +#line 123 "ProjectProperties.vala" + gtk_adjustment_set_value (self->priv->tempo_adjustment, (double) ((gint) (60.0 / average))); +#line 424 "ProjectProperties.c" +} + + +#line 7 "ProjectProperties.vala" +ProjectProperties* project_properties_construct (GType object_type) { +#line 430 "ProjectProperties.c" + ProjectProperties * self; + self = g_object_newv (object_type, 0, NULL); + return self; +} + + +#line 7 "ProjectProperties.vala" +ProjectProperties* project_properties_new (void) { +#line 7 "ProjectProperties.vala" + return project_properties_construct (TYPE_PROJECT_PROPERTIES); +#line 441 "ProjectProperties.c" +} + + +static void project_properties_class_init (ProjectPropertiesClass * klass) { + project_properties_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ProjectPropertiesPrivate)); + G_OBJECT_CLASS (klass)->finalize = project_properties_finalize; +} + + +static void project_properties_instance_init (ProjectProperties * self) { + self->priv = PROJECT_PROPERTIES_GET_PRIVATE (self); + self->priv->tap_time = g_new0 (GTimeVal, PROJECT_PROPERTIES_NUMBER_OF_SAMPLES); + self->priv->tap_time_length1 = PROJECT_PROPERTIES_NUMBER_OF_SAMPLES; + self->priv->_tap_time_size_ = self->priv->tap_time_length1; + self->priv->tap_index = 0; + self->priv->sample_full = FALSE; +} + + +static void project_properties_finalize (GObject* obj) { + ProjectProperties * self; + self = PROJECT_PROPERTIES (obj); + self->priv->tap_time = (g_free (self->priv->tap_time), NULL); + _g_object_unref0 (self->priv->tempo_adjustment); + _g_object_unref0 (self->priv->volume_adjustment); + _g_object_unref0 (self->priv->timesignature_combo); + _g_object_unref0 (self->priv->click_during_play); + _g_object_unref0 (self->priv->click_during_record); + G_OBJECT_CLASS (project_properties_parent_class)->finalize (obj); +} + + +GType project_properties_get_type (void) { + static volatile gsize project_properties_type_id__volatile = 0; + if (g_once_init_enter (&project_properties_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ProjectPropertiesClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) project_properties_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ProjectProperties), 0, (GInstanceInitFunc) project_properties_instance_init, NULL }; + GType project_properties_type_id; + project_properties_type_id = g_type_register_static (GTK_TYPE_DIALOG, "ProjectProperties", &g_define_type_info, 0); + g_once_init_leave (&project_properties_type_id__volatile, project_properties_type_id); + } + return project_properties_type_id__volatile; +} + + +static int _vala_strcmp0 (const char * str1, const char * str2) { + if (str1 == NULL) { + return -(str1 != str2); + } + if (str2 == NULL) { + return str1 != str2; + } + return strcmp (str1, str2); +} + + + + diff --git a/src/fillmore/fillmore/ProjectProperties.o b/src/fillmore/fillmore/ProjectProperties.o new file mode 100644 index 0000000..daf1cd9 Binary files /dev/null and b/src/fillmore/fillmore/ProjectProperties.o differ diff --git a/src/fillmore/fillmore/VolumeAndPanPopUp.c b/src/fillmore/fillmore/VolumeAndPanPopUp.c new file mode 100644 index 0000000..0d6d1b9 --- /dev/null +++ b/src/fillmore/fillmore/VolumeAndPanPopUp.c @@ -0,0 +1,252 @@ +/* VolumeAndPanPopUp.c generated by valac, the Vala compiler + * generated from VolumeAndPanPopUp.vala, do not modify */ + +/* Demo Recorder for MAEMO 5 +* Copyright (C) 2010 Dru Moore +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2, +* or (at your option) any later version, as published by the Free +* Software Foundation +* +* This program 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 General Public License for more details +* +* You should have received a copy of the GNU General Public +* License along with this program; if not, write to the +* Free Software Foundation, Inc., +* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +*/ + +#include +#include +#include +#include +#include +#include +#include +#include + + +#define ID_WORKS_TYPE_VOLUME_AND_PAN_POP_UP (id_works_volume_and_pan_pop_up_get_type ()) +#define ID_WORKS_VOLUME_AND_PAN_POP_UP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), ID_WORKS_TYPE_VOLUME_AND_PAN_POP_UP, IdWorksVolumeAndPanPopUp)) +#define ID_WORKS_VOLUME_AND_PAN_POP_UP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ID_WORKS_TYPE_VOLUME_AND_PAN_POP_UP, IdWorksVolumeAndPanPopUpClass)) +#define ID_WORKS_IS_VOLUME_AND_PAN_POP_UP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ID_WORKS_TYPE_VOLUME_AND_PAN_POP_UP)) +#define ID_WORKS_IS_VOLUME_AND_PAN_POP_UP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ID_WORKS_TYPE_VOLUME_AND_PAN_POP_UP)) +#define ID_WORKS_VOLUME_AND_PAN_POP_UP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ID_WORKS_TYPE_VOLUME_AND_PAN_POP_UP, IdWorksVolumeAndPanPopUpClass)) + +typedef struct _IdWorksVolumeAndPanPopUp IdWorksVolumeAndPanPopUp; +typedef struct _IdWorksVolumeAndPanPopUpClass IdWorksVolumeAndPanPopUpClass; +typedef struct _IdWorksVolumeAndPanPopUpPrivate IdWorksVolumeAndPanPopUpPrivate; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) + +struct _IdWorksVolumeAndPanPopUp { + HildonDialog parent_instance; + IdWorksVolumeAndPanPopUpPrivate * priv; +}; + +struct _IdWorksVolumeAndPanPopUpClass { + HildonDialogClass parent_class; +}; + +struct _IdWorksVolumeAndPanPopUpPrivate { + GtkHScale* volume_slider; + GtkHScale* panorama_slider; +}; + + +static gpointer id_works_volume_and_pan_pop_up_parent_class = NULL; + +GType id_works_volume_and_pan_pop_up_get_type (void); +#define ID_WORKS_VOLUME_AND_PAN_POP_UP_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), ID_WORKS_TYPE_VOLUME_AND_PAN_POP_UP, IdWorksVolumeAndPanPopUpPrivate)) +enum { + ID_WORKS_VOLUME_AND_PAN_POP_UP_DUMMY_PROPERTY +}; +static void _lambda0_ (GtkRange* s, IdWorksVolumeAndPanPopUp* self); +static void __lambda0__gtk_range_value_changed (GtkRange* _sender, gpointer self); +static void _lambda1_ (GtkRange* s, IdWorksVolumeAndPanPopUp* self); +static void __lambda1__gtk_range_value_changed (GtkRange* _sender, gpointer self); +IdWorksVolumeAndPanPopUp* id_works_volume_and_pan_pop_up_new (GtkWidget* parent, const char* title); +IdWorksVolumeAndPanPopUp* id_works_volume_and_pan_pop_up_construct (GType object_type, GtkWidget* parent, const char* title); +void id_works_volume_and_pan_pop_up_set_volume (IdWorksVolumeAndPanPopUp* self, double volume); +void id_works_volume_and_pan_pop_up_set_panorama (IdWorksVolumeAndPanPopUp* self, double panorama); +static void id_works_volume_and_pan_pop_up_finalize (GObject* obj); + + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 42 "VolumeAndPanPopUp.vala" +static void _lambda0_ (GtkRange* s, IdWorksVolumeAndPanPopUp* self) { +#line 42 "VolumeAndPanPopUp.vala" + g_return_if_fail (GTK_IS_RANGE (s)); +#line 42 "VolumeAndPanPopUp.vala" + g_signal_emit_by_name (self, "volume-updated", gtk_range_get_value (s)); +#line 90 "VolumeAndPanPopUp.c" +} + + +#line 42 "VolumeAndPanPopUp.vala" +static void __lambda0__gtk_range_value_changed (GtkRange* _sender, gpointer self) { +#line 96 "VolumeAndPanPopUp.c" + _lambda0_ (_sender, self); +} + + +#line 50 "VolumeAndPanPopUp.vala" +static void _lambda1_ (GtkRange* s, IdWorksVolumeAndPanPopUp* self) { +#line 50 "VolumeAndPanPopUp.vala" + g_return_if_fail (GTK_IS_RANGE (s)); +#line 50 "VolumeAndPanPopUp.vala" + g_signal_emit_by_name (self, "panorama-updated", gtk_range_get_value (s)); +#line 107 "VolumeAndPanPopUp.c" +} + + +#line 50 "VolumeAndPanPopUp.vala" +static void __lambda1__gtk_range_value_changed (GtkRange* _sender, gpointer self) { +#line 113 "VolumeAndPanPopUp.c" + _lambda1_ (_sender, self); +} + + +#line 28 "VolumeAndPanPopUp.vala" +IdWorksVolumeAndPanPopUp* id_works_volume_and_pan_pop_up_construct (GType object_type, GtkWidget* parent, const char* title) { +#line 120 "VolumeAndPanPopUp.c" + IdWorksVolumeAndPanPopUp * self; + GtkVBox* control_area; + GtkHBox* volume_bar; + GtkLabel* volume_label; + GtkHScale* _tmp0_; + GtkHBox* panorama_bar; + GtkLabel* panorama_label; + GtkHScale* _tmp1_; +#line 28 "VolumeAndPanPopUp.vala" + g_return_val_if_fail (GTK_IS_WIDGET (parent), NULL); +#line 28 "VolumeAndPanPopUp.vala" + g_return_val_if_fail (title != NULL, NULL); +#line 133 "VolumeAndPanPopUp.c" + self = g_object_newv (object_type, 0, NULL); +#line 29 "VolumeAndPanPopUp.vala" + gtk_window_set_title (GTK_WINDOW (self), title); +#line 30 "VolumeAndPanPopUp.vala" + gtk_widget_set_parent (GTK_WIDGET (self), parent); +#line 32 "VolumeAndPanPopUp.vala" + gtk_dialog_set_default_response (GTK_DIALOG (self), (gint) GTK_RESPONSE_ACCEPT); +#line 33 "VolumeAndPanPopUp.vala" + hildon_dialog_add_button (HILDON_DIALOG (self), GTK_STOCK_CLOSE, (gint) GTK_RESPONSE_ACCEPT); +#line 35 "VolumeAndPanPopUp.vala" + control_area = _g_object_ref0 (GTK_VBOX (gtk_dialog_get_content_area (GTK_DIALOG (self)))); +#line 37 "VolumeAndPanPopUp.vala" + volume_bar = g_object_ref_sink ((GtkHBox*) gtk_hbox_new (FALSE, 2)); +#line 38 "VolumeAndPanPopUp.vala" + volume_label = g_object_ref_sink ((GtkLabel*) gtk_label_new ("Volume")); +#line 39 "VolumeAndPanPopUp.vala" + gtk_box_pack_start (GTK_BOX (volume_bar), GTK_WIDGET (volume_label), FALSE, FALSE, (guint) 2); +#line 40 "VolumeAndPanPopUp.vala" + self->priv->volume_slider = (_tmp0_ = g_object_ref_sink ((GtkHScale*) gtk_hscale_new_with_range (0.0, 10.0, 0.05)), _g_object_unref0 (self->priv->volume_slider), _tmp0_); +#line 41 "VolumeAndPanPopUp.vala" + gtk_scale_set_value_pos (GTK_SCALE (self->priv->volume_slider), GTK_POS_LEFT); +#line 42 "VolumeAndPanPopUp.vala" + g_signal_connect_object (GTK_RANGE (self->priv->volume_slider), "value-changed", (GCallback) __lambda0__gtk_range_value_changed, self, 0); +#line 43 "VolumeAndPanPopUp.vala" + gtk_box_pack_start (GTK_BOX (volume_bar), GTK_WIDGET (self->priv->volume_slider), TRUE, TRUE, (guint) 2); +#line 45 "VolumeAndPanPopUp.vala" + panorama_bar = g_object_ref_sink ((GtkHBox*) gtk_hbox_new (FALSE, 2)); +#line 46 "VolumeAndPanPopUp.vala" + panorama_label = g_object_ref_sink ((GtkLabel*) gtk_label_new ("Pan")); +#line 47 "VolumeAndPanPopUp.vala" + gtk_box_pack_start (GTK_BOX (panorama_bar), GTK_WIDGET (panorama_label), FALSE, FALSE, (guint) 2); +#line 48 "VolumeAndPanPopUp.vala" + self->priv->panorama_slider = (_tmp1_ = g_object_ref_sink ((GtkHScale*) gtk_hscale_new_with_range (-1.0, 1.0, 0.05)), _g_object_unref0 (self->priv->panorama_slider), _tmp1_); +#line 49 "VolumeAndPanPopUp.vala" + gtk_scale_set_value_pos (GTK_SCALE (self->priv->panorama_slider), GTK_POS_LEFT); +#line 50 "VolumeAndPanPopUp.vala" + g_signal_connect_object (GTK_RANGE (self->priv->panorama_slider), "value-changed", (GCallback) __lambda1__gtk_range_value_changed, self, 0); +#line 51 "VolumeAndPanPopUp.vala" + gtk_box_pack_start (GTK_BOX (panorama_bar), GTK_WIDGET (self->priv->panorama_slider), TRUE, TRUE, (guint) 2); +#line 53 "VolumeAndPanPopUp.vala" + gtk_box_pack_start (GTK_BOX (control_area), GTK_WIDGET (volume_bar), TRUE, TRUE, (guint) 2); +#line 54 "VolumeAndPanPopUp.vala" + gtk_box_pack_start (GTK_BOX (control_area), GTK_WIDGET (panorama_bar), TRUE, TRUE, (guint) 2); +#line 55 "VolumeAndPanPopUp.vala" + gtk_widget_show_all (GTK_WIDGET (self)); +#line 179 "VolumeAndPanPopUp.c" + _g_object_unref0 (control_area); + _g_object_unref0 (volume_bar); + _g_object_unref0 (volume_label); + _g_object_unref0 (panorama_bar); + _g_object_unref0 (panorama_label); + return self; +} + + +#line 28 "VolumeAndPanPopUp.vala" +IdWorksVolumeAndPanPopUp* id_works_volume_and_pan_pop_up_new (GtkWidget* parent, const char* title) { +#line 28 "VolumeAndPanPopUp.vala" + return id_works_volume_and_pan_pop_up_construct (ID_WORKS_TYPE_VOLUME_AND_PAN_POP_UP, parent, title); +#line 193 "VolumeAndPanPopUp.c" +} + + +#line 58 "VolumeAndPanPopUp.vala" +void id_works_volume_and_pan_pop_up_set_volume (IdWorksVolumeAndPanPopUp* self, double volume) { +#line 58 "VolumeAndPanPopUp.vala" + g_return_if_fail (ID_WORKS_IS_VOLUME_AND_PAN_POP_UP (self)); +#line 59 "VolumeAndPanPopUp.vala" + gtk_range_set_value (GTK_RANGE (self->priv->volume_slider), volume); +#line 203 "VolumeAndPanPopUp.c" +} + + +#line 62 "VolumeAndPanPopUp.vala" +void id_works_volume_and_pan_pop_up_set_panorama (IdWorksVolumeAndPanPopUp* self, double panorama) { +#line 62 "VolumeAndPanPopUp.vala" + g_return_if_fail (ID_WORKS_IS_VOLUME_AND_PAN_POP_UP (self)); +#line 63 "VolumeAndPanPopUp.vala" + gtk_range_set_value (GTK_RANGE (self->priv->panorama_slider), panorama); +#line 213 "VolumeAndPanPopUp.c" +} + + +static void id_works_volume_and_pan_pop_up_class_init (IdWorksVolumeAndPanPopUpClass * klass) { + id_works_volume_and_pan_pop_up_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (IdWorksVolumeAndPanPopUpPrivate)); + G_OBJECT_CLASS (klass)->finalize = id_works_volume_and_pan_pop_up_finalize; + g_signal_new ("volume_updated", ID_WORKS_TYPE_VOLUME_AND_PAN_POP_UP, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__DOUBLE, G_TYPE_NONE, 1, G_TYPE_DOUBLE); + g_signal_new ("panorama_updated", ID_WORKS_TYPE_VOLUME_AND_PAN_POP_UP, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__DOUBLE, G_TYPE_NONE, 1, G_TYPE_DOUBLE); +} + + +static void id_works_volume_and_pan_pop_up_instance_init (IdWorksVolumeAndPanPopUp * self) { + self->priv = ID_WORKS_VOLUME_AND_PAN_POP_UP_GET_PRIVATE (self); +} + + +static void id_works_volume_and_pan_pop_up_finalize (GObject* obj) { + IdWorksVolumeAndPanPopUp * self; + self = ID_WORKS_VOLUME_AND_PAN_POP_UP (obj); + _g_object_unref0 (self->priv->volume_slider); + _g_object_unref0 (self->priv->panorama_slider); + G_OBJECT_CLASS (id_works_volume_and_pan_pop_up_parent_class)->finalize (obj); +} + + +GType id_works_volume_and_pan_pop_up_get_type (void) { + static volatile gsize id_works_volume_and_pan_pop_up_type_id__volatile = 0; + if (g_once_init_enter (&id_works_volume_and_pan_pop_up_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (IdWorksVolumeAndPanPopUpClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) id_works_volume_and_pan_pop_up_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (IdWorksVolumeAndPanPopUp), 0, (GInstanceInitFunc) id_works_volume_and_pan_pop_up_instance_init, NULL }; + GType id_works_volume_and_pan_pop_up_type_id; + id_works_volume_and_pan_pop_up_type_id = g_type_register_static (HILDON_TYPE_DIALOG, "IdWorksVolumeAndPanPopUp", &g_define_type_info, 0); + g_once_init_leave (&id_works_volume_and_pan_pop_up_type_id__volatile, id_works_volume_and_pan_pop_up_type_id); + } + return id_works_volume_and_pan_pop_up_type_id__volatile; +} + + + + diff --git a/src/fillmore/fillmore/VolumeAndPanPopUp.o b/src/fillmore/fillmore/VolumeAndPanPopUp.o new file mode 100644 index 0000000..34ff786 Binary files /dev/null and b/src/fillmore/fillmore/VolumeAndPanPopUp.o differ diff --git a/src/fillmore/fillmore/audio_project.c b/src/fillmore/fillmore/audio_project.c new file mode 100644 index 0000000..6f8dd49 --- /dev/null +++ b/src/fillmore/fillmore/audio_project.c @@ -0,0 +1,786 @@ +/* audio_project.c generated by valac, the Vala compiler + * generated from audio_project.vala, do not modify */ + +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + + +#define MODEL_TYPE_RECORD_FETCHER_COMPLETION (model_record_fetcher_completion_get_type ()) +#define MODEL_RECORD_FETCHER_COMPLETION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_RECORD_FETCHER_COMPLETION, ModelRecordFetcherCompletion)) +#define MODEL_RECORD_FETCHER_COMPLETION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_RECORD_FETCHER_COMPLETION, ModelRecordFetcherCompletionClass)) +#define MODEL_IS_RECORD_FETCHER_COMPLETION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_RECORD_FETCHER_COMPLETION)) +#define MODEL_IS_RECORD_FETCHER_COMPLETION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_RECORD_FETCHER_COMPLETION)) +#define MODEL_RECORD_FETCHER_COMPLETION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_RECORD_FETCHER_COMPLETION, ModelRecordFetcherCompletionClass)) + +typedef struct _ModelRecordFetcherCompletion ModelRecordFetcherCompletion; +typedef struct _ModelRecordFetcherCompletionClass ModelRecordFetcherCompletionClass; +typedef struct _ModelRecordFetcherCompletionPrivate ModelRecordFetcherCompletionPrivate; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +#define _g_free0(var) (var = (g_free (var), NULL)) + +#define MODEL_TYPE_AUDIO_PROJECT (model_audio_project_get_type ()) +#define MODEL_AUDIO_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_AUDIO_PROJECT, ModelAudioProject)) +#define MODEL_AUDIO_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_AUDIO_PROJECT, ModelAudioProjectClass)) +#define MODEL_IS_AUDIO_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_AUDIO_PROJECT)) +#define MODEL_IS_AUDIO_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_AUDIO_PROJECT)) +#define MODEL_AUDIO_PROJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_AUDIO_PROJECT, ModelAudioProjectClass)) + +typedef struct _ModelAudioProject ModelAudioProject; +typedef struct _ModelAudioProjectClass ModelAudioProjectClass; +typedef struct _ModelAudioProjectPrivate ModelAudioProjectPrivate; +#define _g_regex_unref0(var) ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL))) +#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL))) +#define _model_fetcher_completion_unref0(var) ((var == NULL) ? NULL : (var = (model_fetcher_completion_unref (var), NULL))) +#define _g_dir_close0(var) ((var == NULL) ? NULL : (var = (g_dir_close (var), NULL))) + +struct _ModelRecordFetcherCompletion { + ModelFetcherCompletion parent_instance; + ModelRecordFetcherCompletionPrivate * priv; +}; + +struct _ModelRecordFetcherCompletionClass { + ModelFetcherCompletionClass parent_class; +}; + +struct _ModelRecordFetcherCompletionPrivate { + ModelTrack* track; + ModelProject* project; + gint64 position; +}; + +struct _ModelAudioProject { + ModelProject parent_instance; + ModelAudioProjectPrivate * priv; +}; + +struct _ModelAudioProjectClass { + ModelProjectClass parent_class; +}; + +struct _ModelAudioProjectPrivate { + gboolean has_been_saved; +}; + + +static gpointer model_record_fetcher_completion_parent_class = NULL; +static gpointer model_audio_project_parent_class = NULL; + +GType model_record_fetcher_completion_get_type (void); +#define MODEL_RECORD_FETCHER_COMPLETION_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_RECORD_FETCHER_COMPLETION, ModelRecordFetcherCompletionPrivate)) +enum { + MODEL_RECORD_FETCHER_COMPLETION_DUMMY_PROPERTY +}; +ModelRecordFetcherCompletion* model_record_fetcher_completion_new (ModelProject* project, ModelTrack* track, gint64 position); +ModelRecordFetcherCompletion* model_record_fetcher_completion_construct (GType object_type, ModelProject* project, ModelTrack* track, gint64 position); +static void model_record_fetcher_completion_real_complete (ModelFetcherCompletion* base, ModelFetcher* fetch); +static void model_record_fetcher_completion_finalize (ModelFetcherCompletion* obj); +GType model_audio_project_get_type (void); +#define MODEL_AUDIO_PROJECT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_AUDIO_PROJECT, ModelAudioProjectPrivate)) +enum { + MODEL_AUDIO_PROJECT_DUMMY_PROPERTY +}; +static char* model_audio_project_generate_filename (ModelAudioProject* self); +static void _view_media_engine_on_callback_pulse_view_media_engine_callback_pulse (ViewMediaEngine* _sender, gpointer self); +void model_audio_project_on_record_completed (ModelAudioProject* self); +static void _model_audio_project_on_record_completed_view_media_engine_record_completed (ViewMediaEngine* _sender, gpointer self); +ModelAudioProject* model_audio_project_new (const char* filename, GError** error); +ModelAudioProject* model_audio_project_construct (GType object_type, const char* filename, GError** error); +static void model_audio_project_real_get_clip_time (ModelProject* base, ModelClipFile* f, TimeCode* result); +static char* model_audio_project_real_get_project_file (ModelProject* base); +#define RECORDER_NAME "Fillmore" +static char* model_audio_project_real_get_app_name (ModelProject* base); +static void model_audio_project_real_add_track (ModelProject* base, ModelTrack* track); +void model_audio_project_record (ModelAudioProject* self, ModelAudioTrack* track); +static void model_audio_project_real_load (ModelProject* base, const char* filename); +static void model_audio_project_move_audio_files (ModelAudioProject* self, const char* filename); +static void model_audio_project_real_save (ModelProject* base, const char* filename); +static void model_audio_project_finalize (GObject* obj); +static int _vala_strcmp0 (const char * str1, const char * str2); + + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 15 "audio_project.vala" +ModelRecordFetcherCompletion* model_record_fetcher_completion_construct (GType object_type, ModelProject* project, ModelTrack* track, gint64 position) { +#line 122 "audio_project.c" + ModelRecordFetcherCompletion* self; + ModelTrack* _tmp0_; + ModelProject* _tmp1_; +#line 15 "audio_project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (project), NULL); +#line 15 "audio_project.vala" + g_return_val_if_fail (MODEL_IS_TRACK (track), NULL); +#line 16 "audio_project.vala" + self = (ModelRecordFetcherCompletion*) model_fetcher_completion_construct (object_type); +#line 17 "audio_project.vala" + self->priv->track = (_tmp0_ = _g_object_ref0 (track), _g_object_unref0 (self->priv->track), _tmp0_); +#line 18 "audio_project.vala" + self->priv->project = (_tmp1_ = _g_object_ref0 (project), _g_object_unref0 (self->priv->project), _tmp1_); +#line 19 "audio_project.vala" + self->priv->position = position; +#line 138 "audio_project.c" + return self; +} + + +#line 15 "audio_project.vala" +ModelRecordFetcherCompletion* model_record_fetcher_completion_new (ModelProject* project, ModelTrack* track, gint64 position) { +#line 15 "audio_project.vala" + return model_record_fetcher_completion_construct (MODEL_TYPE_RECORD_FETCHER_COMPLETION, project, track, position); +#line 147 "audio_project.c" +} + + +#line 22 "audio_project.vala" +static void model_record_fetcher_completion_real_complete (ModelFetcherCompletion* base, ModelFetcher* fetch) { +#line 153 "audio_project.c" + ModelRecordFetcherCompletion * self; + char* _tmp0_; + ModelClip* _tmp1_; + ModelClip* the_clip; + self = MODEL_RECORD_FETCHER_COMPLETION (base); +#line 22 "audio_project.vala" + g_return_if_fail (MODEL_IS_FETCHER (fetch)); +#line 23 "audio_project.vala" + MODEL_FETCHER_COMPLETION_CLASS (model_record_fetcher_completion_parent_class)->complete (MODEL_FETCHER_COMPLETION (self), fetch); +#line 24 "audio_project.vala" + the_clip = (_tmp1_ = model_clip_new (fetch->clipfile, MODEL_MEDIA_TYPE_AUDIO, _tmp0_ = isolate_filename (fetch->clipfile->filename), (gint64) 0, (gint64) 0, model_clip_file_get_length (fetch->clipfile), FALSE), _g_free0 (_tmp0_), _tmp1_); +#line 26 "audio_project.vala" + model_undo_manager_start_transaction (self->priv->project->undo_manager, "Record"); +#line 27 "audio_project.vala" + model_track_append_at_time (self->priv->track, the_clip, self->priv->position, TRUE); +#line 28 "audio_project.vala" + model_undo_manager_end_transaction (self->priv->project->undo_manager, "Record"); +#line 171 "audio_project.c" + _g_object_unref0 (the_clip); +} + + +static void model_record_fetcher_completion_class_init (ModelRecordFetcherCompletionClass * klass) { + model_record_fetcher_completion_parent_class = g_type_class_peek_parent (klass); + MODEL_FETCHER_COMPLETION_CLASS (klass)->finalize = model_record_fetcher_completion_finalize; + g_type_class_add_private (klass, sizeof (ModelRecordFetcherCompletionPrivate)); + MODEL_FETCHER_COMPLETION_CLASS (klass)->complete = model_record_fetcher_completion_real_complete; +} + + +static void model_record_fetcher_completion_instance_init (ModelRecordFetcherCompletion * self) { + self->priv = MODEL_RECORD_FETCHER_COMPLETION_GET_PRIVATE (self); +} + + +static void model_record_fetcher_completion_finalize (ModelFetcherCompletion* obj) { + ModelRecordFetcherCompletion * self; + self = MODEL_RECORD_FETCHER_COMPLETION (obj); + _g_object_unref0 (self->priv->track); + _g_object_unref0 (self->priv->project); + MODEL_FETCHER_COMPLETION_CLASS (model_record_fetcher_completion_parent_class)->finalize (obj); +} + + +GType model_record_fetcher_completion_get_type (void) { + static volatile gsize model_record_fetcher_completion_type_id__volatile = 0; + if (g_once_init_enter (&model_record_fetcher_completion_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelRecordFetcherCompletionClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_record_fetcher_completion_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelRecordFetcherCompletion), 0, (GInstanceInitFunc) model_record_fetcher_completion_instance_init, NULL }; + GType model_record_fetcher_completion_type_id; + model_record_fetcher_completion_type_id = g_type_register_static (MODEL_TYPE_FETCHER_COMPLETION, "ModelRecordFetcherCompletion", &g_define_type_info, 0); + g_once_init_leave (&model_record_fetcher_completion_type_id__volatile, model_record_fetcher_completion_type_id); + } + return model_record_fetcher_completion_type_id__volatile; +} + + +#line 75 "marina.vapi" +static void _view_media_engine_on_callback_pulse_view_media_engine_callback_pulse (ViewMediaEngine* _sender, gpointer self) { +#line 212 "audio_project.c" + view_media_engine_on_callback_pulse (self); +} + + +#line 92 "audio_project.vala" +static void _model_audio_project_on_record_completed_view_media_engine_record_completed (ViewMediaEngine* _sender, gpointer self) { +#line 219 "audio_project.c" + model_audio_project_on_record_completed (self); +} + + +#line 35 "audio_project.vala" +ModelAudioProject* model_audio_project_construct (GType object_type, const char* filename, GError** error) { +#line 226 "audio_project.c" + ModelAudioProject * self; +#line 36 "audio_project.vala" + self = (ModelAudioProject*) model_project_construct (object_type, filename, FALSE, error); +#line 38 "audio_project.vala" + if (self != NULL) { +#line 39 "audio_project.vala" + self->priv->has_been_saved = filename != NULL; +#line 40 "audio_project.vala" + if (!self->priv->has_been_saved) { +#line 236 "audio_project.c" + char* _tmp1_; + char* *_tmp0_; +#line 41 "audio_project.vala" + _tmp0_ = &MODEL_PROJECT (self)->project_file; +#line 41 "audio_project.vala" + (*_tmp0_) = (_tmp1_ = model_audio_project_generate_filename (self), _g_free0 ((*_tmp0_)), _tmp1_); +#line 243 "audio_project.c" + } +#line 43 "audio_project.vala" + g_signal_connect_object (MODEL_PROJECT (self)->media_engine, "callback-pulse", (GCallback) _view_media_engine_on_callback_pulse_view_media_engine_callback_pulse, MODEL_PROJECT (self)->media_engine, 0); +#line 44 "audio_project.vala" + g_signal_connect_object (MODEL_PROJECT (self)->media_engine, "record-completed", (GCallback) _model_audio_project_on_record_completed_view_media_engine_record_completed, self, 0); +#line 249 "audio_project.c" + } + return self; +} + + +#line 35 "audio_project.vala" +ModelAudioProject* model_audio_project_new (const char* filename, GError** error) { +#line 35 "audio_project.vala" + return model_audio_project_construct (MODEL_TYPE_AUDIO_PROJECT, filename, error); +#line 259 "audio_project.c" +} + + +#line 48 "audio_project.vala" +static void model_audio_project_real_get_clip_time (ModelProject* base, ModelClipFile* f, TimeCode* result) { +#line 265 "audio_project.c" + ModelAudioProject * self; + TimeCode _tmp0_ = {0}; + TimeCode t; + self = MODEL_AUDIO_PROJECT (base); +#line 48 "audio_project.vala" + g_return_if_fail (MODEL_IS_CLIP_FILE (f)); +#line 49 "audio_project.vala" + t = (_tmp0_); +#line 51 "audio_project.vala" + time_code_get_from_length (&t, model_clip_file_get_length (f)); +#line 276 "audio_project.c" + *result = t; +#line 52 "audio_project.vala" + return; +#line 280 "audio_project.c" +} + + +#line 55 "audio_project.vala" +static char* model_audio_project_real_get_project_file (ModelProject* base) { +#line 286 "audio_project.c" + ModelAudioProject * self; + char* result = NULL; + self = MODEL_AUDIO_PROJECT (base); +#line 56 "audio_project.vala" + if (!self->priv->has_been_saved) { +#line 292 "audio_project.c" + result = NULL; +#line 57 "audio_project.vala" + return result; +#line 296 "audio_project.c" + } else { + result = MODEL_PROJECT_CLASS (model_audio_project_parent_class)->get_project_file (MODEL_PROJECT (self)); +#line 59 "audio_project.vala" + return result; +#line 301 "audio_project.c" + } +} + + +#line 2153 "glib-2.0.vapi" +static void g_time_local (time_t time, struct tm* result) { +#line 308 "audio_project.c" + struct tm _result_ = {0}; +#line 2155 "glib-2.0.vapi" + localtime_r (&time, &_result_); +#line 312 "audio_project.c" + *result = _result_; +#line 2156 "glib-2.0.vapi" + return; +#line 316 "audio_project.c" +} + + +#line 2159 "glib-2.0.vapi" +static char* g_time_to_string (struct tm *self) { +#line 322 "audio_project.c" + char* result = NULL; + result = g_strdup_printf ("%04d-%02d-%02d %02d:%02d:%02d", (*self).tm_year + 1900, (*self).tm_mon + 1, (*self).tm_mday, (*self).tm_hour, (*self).tm_min, (*self).tm_sec); +#line 2160 "glib-2.0.vapi" + return result; +#line 327 "audio_project.c" +} + + +#line 1148 "glib-2.0.vapi" +static char* string_replace (const char* self, const char* old, const char* replacement) { +#line 333 "audio_project.c" + char* result = NULL; + GError * _inner_error_; +#line 1148 "glib-2.0.vapi" + g_return_val_if_fail (self != NULL, NULL); +#line 1148 "glib-2.0.vapi" + g_return_val_if_fail (old != NULL, NULL); +#line 1148 "glib-2.0.vapi" + g_return_val_if_fail (replacement != NULL, NULL); +#line 342 "audio_project.c" + _inner_error_ = NULL; + { + char* _tmp0_; + GRegex* _tmp1_; + GRegex* regex; + char* _tmp2_; +#line 1150 "glib-2.0.vapi" + regex = (_tmp1_ = g_regex_new (_tmp0_ = g_regex_escape_string (old, -1), 0, 0, &_inner_error_), _g_free0 (_tmp0_), _tmp1_); +#line 351 "audio_project.c" + if (_inner_error_ != NULL) { + if (_inner_error_->domain == G_REGEX_ERROR) { + goto __catch0_g_regex_error; + } + g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return NULL; + } +#line 1151 "glib-2.0.vapi" + _tmp2_ = g_regex_replace_literal (regex, self, (gssize) (-1), 0, replacement, 0, &_inner_error_); +#line 362 "audio_project.c" + if (_inner_error_ != NULL) { + _g_regex_unref0 (regex); + if (_inner_error_->domain == G_REGEX_ERROR) { + goto __catch0_g_regex_error; + } + _g_regex_unref0 (regex); + g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return NULL; + } + result = _tmp2_; + _g_regex_unref0 (regex); +#line 1151 "glib-2.0.vapi" + return result; +#line 377 "audio_project.c" + } + goto __finally0; + __catch0_g_regex_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { +#line 1153 "glib-2.0.vapi" + g_assert_not_reached (); +#line 388 "audio_project.c" + _g_error_free0 (e); + } + } + __finally0: + if (_inner_error_ != NULL) { + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return NULL; + } +} + + +#line 63 "audio_project.vala" +static char* model_audio_project_generate_filename (ModelAudioProject* self) { +#line 403 "audio_project.c" + char* result = NULL; + struct tm _tmp0_ = {0}; + struct tm now; + char* timestring; + char* _tmp1_; + char* pathname; + char* filename; +#line 63 "audio_project.vala" + g_return_val_if_fail (MODEL_IS_AUDIO_PROJECT (self), NULL); +#line 64 "audio_project.vala" + now = (g_time_local (time (NULL), &_tmp0_), _tmp0_); +#line 65 "audio_project.vala" + timestring = g_time_to_string (&now); +#line 66 "audio_project.vala" + timestring = (_tmp1_ = string_replace (timestring, ":", "_"), _g_free0 (timestring), _tmp1_); +#line 67 "audio_project.vala" + pathname = g_build_filename (g_get_home_dir (), ".fillmore", timestring, NULL); +#line 69 "audio_project.vala" + g_mkdir (pathname, 0777); +#line 70 "audio_project.vala" + filename = g_strdup_printf ("%s.%s", timestring, "fill"); +#line 425 "audio_project.c" + result = g_build_filename (pathname, filename, NULL); + _g_free0 (timestring); + _g_free0 (pathname); + _g_free0 (filename); +#line 71 "audio_project.vala" + return result; +#line 432 "audio_project.c" +} + + +#line 74 "audio_project.vala" +static char* model_audio_project_real_get_app_name (ModelProject* base) { +#line 438 "audio_project.c" + ModelAudioProject * self; + char* result = NULL; + self = MODEL_AUDIO_PROJECT (base); + result = g_strdup (RECORDER_NAME); +#line 75 "audio_project.vala" + return result; +#line 445 "audio_project.c" +} + + +#line 78 "audio_project.vala" +static void model_audio_project_real_add_track (ModelProject* base, ModelTrack* track) { +#line 451 "audio_project.c" + ModelAudioProject * self; + self = MODEL_AUDIO_PROJECT (base); +#line 78 "audio_project.vala" + g_return_if_fail (MODEL_IS_TRACK (track)); +#line 79 "audio_project.vala" + if (model_track_media_type (track) == MODEL_MEDIA_TYPE_VIDEO) { +#line 80 "audio_project.vala" + model_track_hide (track); +#line 81 "audio_project.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (MODEL_PROJECT (self)->inactive_tracks), track); +#line 82 "audio_project.vala" + return; +#line 464 "audio_project.c" + } +#line 85 "audio_project.vala" + MODEL_PROJECT_CLASS (model_audio_project_parent_class)->add_track (MODEL_PROJECT (self), track); +#line 468 "audio_project.c" +} + + +#line 88 "audio_project.vala" +void model_audio_project_record (ModelAudioProject* self, ModelAudioTrack* track) { +#line 88 "audio_project.vala" + g_return_if_fail (MODEL_IS_AUDIO_PROJECT (self)); +#line 88 "audio_project.vala" + g_return_if_fail (MODEL_IS_AUDIO_TRACK (track)); +#line 89 "audio_project.vala" + view_media_engine_record (MODEL_PROJECT (self)->media_engine, track); +#line 480 "audio_project.c" +} + + +#line 92 "audio_project.vala" +void model_audio_project_on_record_completed (ModelAudioProject* self) { +#line 486 "audio_project.c" + GError * _inner_error_; +#line 92 "audio_project.vala" + g_return_if_fail (MODEL_IS_AUDIO_PROJECT (self)); +#line 490 "audio_project.c" + _inner_error_ = NULL; +#line 93 "audio_project.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_record_completed"); +#line 494 "audio_project.c" + { + ModelRecordFetcherCompletion* _tmp0_; +#line 95 "audio_project.vala" + model_project_create_clip_fetcher (MODEL_PROJECT (self), MODEL_FETCHER_COMPLETION (_tmp0_ = model_record_fetcher_completion_new (MODEL_PROJECT (self), MODEL_TRACK (MODEL_PROJECT (self)->media_engine->record_track), model_clip_get_start (MODEL_PROJECT (self)->media_engine->record_region))), MODEL_PROJECT (self)->media_engine->record_region->clipfile->filename, &_inner_error_); +#line 499 "audio_project.c" + _model_fetcher_completion_unref0 (_tmp0_); + if (_inner_error_ != NULL) { + goto __catch1_g_error; + } + } + goto __finally1; + __catch1_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { +#line 98 "audio_project.vala" + g_signal_emit_by_name (MODEL_PROJECT (self), "error-occurred", "Could not complete recording", e->message); +#line 514 "audio_project.c" + _g_error_free0 (e); + } + } + __finally1: + if (_inner_error_ != NULL) { + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } +} + + +#line 102 "audio_project.vala" +static void model_audio_project_real_load (ModelProject* base, const char* filename) { +#line 529 "audio_project.c" + ModelAudioProject * self; + self = MODEL_AUDIO_PROJECT (base); +#line 103 "audio_project.vala" + self->priv->has_been_saved = filename != NULL; +#line 104 "audio_project.vala" + if (!self->priv->has_been_saved) { +#line 536 "audio_project.c" + char* _tmp1_; + char* *_tmp0_; +#line 105 "audio_project.vala" + _tmp0_ = &MODEL_PROJECT (self)->project_file; +#line 105 "audio_project.vala" + (*_tmp0_) = (_tmp1_ = model_audio_project_generate_filename (self), _g_free0 ((*_tmp0_)), _tmp1_); +#line 543 "audio_project.c" + } +#line 107 "audio_project.vala" + MODEL_PROJECT_CLASS (model_audio_project_parent_class)->load (MODEL_PROJECT (self), filename); +#line 547 "audio_project.c" +} + + +#line 110 "audio_project.vala" +static void model_audio_project_real_save (ModelProject* base, const char* filename) { +#line 553 "audio_project.c" + ModelAudioProject * self; + gboolean _tmp0_ = FALSE; + self = MODEL_AUDIO_PROJECT (base); +#line 111 "audio_project.vala" + if (!self->priv->has_been_saved) { +#line 111 "audio_project.vala" + _tmp0_ = filename != NULL; +#line 561 "audio_project.c" + } else { +#line 111 "audio_project.vala" + _tmp0_ = FALSE; +#line 565 "audio_project.c" + } +#line 111 "audio_project.vala" + if (_tmp0_) { +#line 569 "audio_project.c" + char* _tmp1_; +#line 112 "audio_project.vala" + model_audio_project_move_audio_files (self, filename); +#line 113 "audio_project.vala" + g_remove (MODEL_PROJECT (self)->project_file); +#line 114 "audio_project.vala" + g_rmdir (_tmp1_ = g_path_get_dirname (MODEL_PROJECT (self)->project_file)); +#line 577 "audio_project.c" + _g_free0 (_tmp1_); + } +#line 117 "audio_project.vala" + MODEL_PROJECT_CLASS (model_audio_project_parent_class)->save (MODEL_PROJECT (self), filename); +#line 118 "audio_project.vala" + self->priv->has_been_saved = TRUE; +#line 584 "audio_project.c" +} + + +#line 121 "audio_project.vala" +static void model_audio_project_move_audio_files (ModelAudioProject* self, const char* filename) { +#line 590 "audio_project.c" + GError * _inner_error_; + char* audio_path; + char* _tmp0_; + char* _tmp1_; + char* destination_path; + GDir* dir; + const char* base_name; +#line 121 "audio_project.vala" + g_return_if_fail (MODEL_IS_AUDIO_PROJECT (self)); +#line 121 "audio_project.vala" + g_return_if_fail (filename != NULL); +#line 602 "audio_project.c" + _inner_error_ = NULL; +#line 122 "audio_project.vala" + audio_path = model_project_get_audio_path (MODEL_PROJECT (self)); +#line 123 "audio_project.vala" + destination_path = (_tmp1_ = g_build_filename (_tmp0_ = g_path_get_dirname (filename), "audio files", NULL), _g_free0 (_tmp0_), _tmp1_); +#line 124 "audio_project.vala" + g_mkdir (destination_path, 0777); +#line 610 "audio_project.c" + dir = NULL; + { + GDir* _tmp2_; + GDir* _tmp3_; +#line 127 "audio_project.vala" + _tmp2_ = g_dir_open (audio_path, 0, &_inner_error_); +#line 617 "audio_project.c" + if (_inner_error_ != NULL) { + if (_inner_error_->domain == G_FILE_ERROR) { + goto __catch2_g_file_error; + } + _g_free0 (audio_path); + _g_free0 (destination_path); + _g_dir_close0 (dir); + g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } +#line 127 "audio_project.vala" + dir = (_tmp3_ = _tmp2_, _g_dir_close0 (dir), _tmp3_); +#line 631 "audio_project.c" + } + goto __finally2; + __catch2_g_file_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { + _g_error_free0 (e); + _g_free0 (audio_path); + _g_free0 (destination_path); + _g_dir_close0 (dir); +#line 129 "audio_project.vala" + return; +#line 646 "audio_project.c" + } + } + __finally2: + if (_inner_error_ != NULL) { + _g_free0 (audio_path); + _g_free0 (destination_path); + _g_dir_close0 (dir); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } +#line 133 "audio_project.vala" + base_name = NULL; +#line 660 "audio_project.c" + { + gboolean _tmp4_; +#line 134 "audio_project.vala" + _tmp4_ = TRUE; +#line 134 "audio_project.vala" + while (TRUE) { +#line 667 "audio_project.c" + char* destination; + char* _tmp5_; +#line 134 "audio_project.vala" + if (!_tmp4_) { +#line 138 "audio_project.vala" + if (!(base_name != NULL)) { +#line 138 "audio_project.vala" + break; +#line 676 "audio_project.c" + } + } +#line 134 "audio_project.vala" + _tmp4_ = FALSE; +#line 135 "audio_project.vala" + base_name = g_dir_read_name (dir); +#line 136 "audio_project.vala" + destination = g_build_filename (destination_path, base_name, NULL); +#line 137 "audio_project.vala" + g_rename (_tmp5_ = g_build_filename (audio_path, base_name, NULL), destination); +#line 687 "audio_project.c" + _g_free0 (_tmp5_); + _g_free0 (destination); + } + } + { + GeeIterator* _clip_file_it; + _clip_file_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (MODEL_PROJECT (self)->clipfiles)); +#line 141 "audio_project.vala" + while (TRUE) { +#line 697 "audio_project.c" + ModelClipFile* clip_file; + char* _tmp6_; + gboolean _tmp7_; +#line 141 "audio_project.vala" + if (!gee_iterator_next (_clip_file_it)) { +#line 141 "audio_project.vala" + break; +#line 705 "audio_project.c" + } +#line 141 "audio_project.vala" + clip_file = (ModelClipFile*) gee_iterator_get (_clip_file_it); +#line 142 "audio_project.vala" + if ((_tmp7_ = _vala_strcmp0 (_tmp6_ = g_path_get_dirname (clip_file->filename), audio_path) == 0, _g_free0 (_tmp6_), _tmp7_)) { +#line 711 "audio_project.c" + char* file_name; + char* destination; + char* _tmp8_; +#line 143 "audio_project.vala" + file_name = g_path_get_basename (clip_file->filename); +#line 144 "audio_project.vala" + destination = g_build_filename (destination_path, file_name, NULL); +#line 145 "audio_project.vala" + clip_file->filename = (_tmp8_ = g_strdup (destination), _g_free0 (clip_file->filename), _tmp8_); +#line 721 "audio_project.c" + _g_free0 (file_name); + _g_free0 (destination); + } + _g_object_unref0 (clip_file); + } + _g_object_unref0 (_clip_file_it); + } +#line 149 "audio_project.vala" + g_rmdir (audio_path); +#line 731 "audio_project.c" + _g_free0 (audio_path); + _g_free0 (destination_path); + _g_dir_close0 (dir); +} + + +static void model_audio_project_class_init (ModelAudioProjectClass * klass) { + model_audio_project_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ModelAudioProjectPrivate)); + MODEL_PROJECT_CLASS (klass)->get_clip_time = model_audio_project_real_get_clip_time; + MODEL_PROJECT_CLASS (klass)->get_project_file = model_audio_project_real_get_project_file; + MODEL_PROJECT_CLASS (klass)->get_app_name = model_audio_project_real_get_app_name; + MODEL_PROJECT_CLASS (klass)->add_track = model_audio_project_real_add_track; + MODEL_PROJECT_CLASS (klass)->load = model_audio_project_real_load; + MODEL_PROJECT_CLASS (klass)->save = model_audio_project_real_save; + G_OBJECT_CLASS (klass)->finalize = model_audio_project_finalize; +} + + +static void model_audio_project_instance_init (ModelAudioProject * self) { + self->priv = MODEL_AUDIO_PROJECT_GET_PRIVATE (self); +} + + +static void model_audio_project_finalize (GObject* obj) { + ModelAudioProject * self; + self = MODEL_AUDIO_PROJECT (obj); + G_OBJECT_CLASS (model_audio_project_parent_class)->finalize (obj); +} + + +GType model_audio_project_get_type (void) { + static volatile gsize model_audio_project_type_id__volatile = 0; + if (g_once_init_enter (&model_audio_project_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelAudioProjectClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_audio_project_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelAudioProject), 0, (GInstanceInitFunc) model_audio_project_instance_init, NULL }; + GType model_audio_project_type_id; + model_audio_project_type_id = g_type_register_static (MODEL_TYPE_PROJECT, "ModelAudioProject", &g_define_type_info, 0); + g_once_init_leave (&model_audio_project_type_id__volatile, model_audio_project_type_id); + } + return model_audio_project_type_id__volatile; +} + + +static int _vala_strcmp0 (const char * str1, const char * str2) { + if (str1 == NULL) { + return -(str1 != str2); + } + if (str2 == NULL) { + return str1 != str2; + } + return strcmp (str1, str2); +} + + + + diff --git a/src/fillmore/fillmore/audio_project.o b/src/fillmore/fillmore/audio_project.o new file mode 100644 index 0000000..620992c Binary files /dev/null and b/src/fillmore/fillmore/audio_project.o differ diff --git a/src/fillmore/fillmore/fillmore.c b/src/fillmore/fillmore/fillmore.c new file mode 100644 index 0000000..1a52adf --- /dev/null +++ b/src/fillmore/fillmore/fillmore.c @@ -0,0 +1,4473 @@ +/* fillmore.c generated by valac, the Vala compiler + * generated from fillmore.vala, do not modify */ + +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#define TYPE_RECORDER (recorder_get_type ()) +#define RECORDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_RECORDER, Recorder)) +#define RECORDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_RECORDER, RecorderClass)) +#define IS_RECORDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_RECORDER)) +#define IS_RECORDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_RECORDER)) +#define RECORDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_RECORDER, RecorderClass)) + +typedef struct _Recorder Recorder; +typedef struct _RecorderClass RecorderClass; +typedef struct _RecorderPrivate RecorderPrivate; + +#define MODEL_TYPE_AUDIO_PROJECT (model_audio_project_get_type ()) +#define MODEL_AUDIO_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_AUDIO_PROJECT, ModelAudioProject)) +#define MODEL_AUDIO_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_AUDIO_PROJECT, ModelAudioProjectClass)) +#define MODEL_IS_AUDIO_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_AUDIO_PROJECT)) +#define MODEL_IS_AUDIO_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_AUDIO_PROJECT)) +#define MODEL_AUDIO_PROJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_AUDIO_PROJECT, ModelAudioProjectClass)) + +typedef struct _ModelAudioProject ModelAudioProject; +typedef struct _ModelAudioProjectClass ModelAudioProjectClass; + +#define TYPE_HEADER_AREA (header_area_get_type ()) +#define HEADER_AREA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_HEADER_AREA, HeaderArea)) +#define HEADER_AREA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_HEADER_AREA, HeaderAreaClass)) +#define IS_HEADER_AREA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_HEADER_AREA)) +#define IS_HEADER_AREA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_HEADER_AREA)) +#define HEADER_AREA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_HEADER_AREA, HeaderAreaClass)) + +typedef struct _HeaderArea HeaderArea; +typedef struct _HeaderAreaClass HeaderAreaClass; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +#define _g_free0(var) (var = (g_free (var), NULL)) +#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL))) +#define _gst_caps_unref0(var) ((var == NULL) ? NULL : (var = (gst_caps_unref (var), NULL))) +#define __g_list_free_g_free0(var) ((var == NULL) ? NULL : (var = (_g_list_free_g_free (var), NULL))) +#define __g_slist_free_g_free0(var) ((var == NULL) ? NULL : (var = (_g_slist_free_g_free (var), NULL))) + +#define TYPE_PROJECT_PROPERTIES (project_properties_get_type ()) +#define PROJECT_PROPERTIES(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_PROJECT_PROPERTIES, ProjectProperties)) +#define PROJECT_PROPERTIES_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_PROJECT_PROPERTIES, ProjectPropertiesClass)) +#define IS_PROJECT_PROPERTIES(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_PROJECT_PROPERTIES)) +#define IS_PROJECT_PROPERTIES_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_PROJECT_PROPERTIES)) +#define PROJECT_PROPERTIES_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_PROJECT_PROPERTIES, ProjectPropertiesClass)) + +typedef struct _ProjectProperties ProjectProperties; +typedef struct _ProjectPropertiesClass ProjectPropertiesClass; + +#define UI_TYPE_TRACK_INFORMATION (ui_track_information_get_type ()) +#define UI_TRACK_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UI_TYPE_TRACK_INFORMATION, UITrackInformation)) +#define UI_TRACK_INFORMATION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), UI_TYPE_TRACK_INFORMATION, UITrackInformationClass)) +#define UI_IS_TRACK_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UI_TYPE_TRACK_INFORMATION)) +#define UI_IS_TRACK_INFORMATION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), UI_TYPE_TRACK_INFORMATION)) +#define UI_TRACK_INFORMATION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), UI_TYPE_TRACK_INFORMATION, UITrackInformationClass)) + +typedef struct _UITrackInformation UITrackInformation; +typedef struct _UITrackInformationClass UITrackInformationClass; + +#define TYPE_FILLMORE (fillmore_get_type ()) +#define FILLMORE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_FILLMORE, Fillmore)) +#define FILLMORE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_FILLMORE, FillmoreClass)) +#define IS_FILLMORE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_FILLMORE)) +#define IS_FILLMORE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_FILLMORE)) +#define FILLMORE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_FILLMORE, FillmoreClass)) + +typedef struct _Fillmore Fillmore; +typedef struct _FillmoreClass FillmoreClass; +typedef struct _FillmorePrivate FillmorePrivate; +#define _g_option_context_free0(var) ((var == NULL) ? NULL : (var = (g_option_context_free (var), NULL))) + +#define TYPE_FILLMORE_CLASS_FACTORY (fillmore_class_factory_get_type ()) +#define FILLMORE_CLASS_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_FILLMORE_CLASS_FACTORY, FillmoreClassFactory)) +#define FILLMORE_CLASS_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_FILLMORE_CLASS_FACTORY, FillmoreClassFactoryClass)) +#define IS_FILLMORE_CLASS_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_FILLMORE_CLASS_FACTORY)) +#define IS_FILLMORE_CLASS_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_FILLMORE_CLASS_FACTORY)) +#define FILLMORE_CLASS_FACTORY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_FILLMORE_CLASS_FACTORY, FillmoreClassFactoryClass)) + +typedef struct _FillmoreClassFactory FillmoreClassFactory; +typedef struct _FillmoreClassFactoryClass FillmoreClassFactoryClass; +#define _class_factory_unref0(var) ((var == NULL) ? NULL : (var = (class_factory_unref (var), NULL))) + +struct _Recorder { + GtkWindow parent_instance; + RecorderPrivate * priv; + ModelAudioProject* project; + TimeLine* timeline; +}; + +struct _RecorderClass { + GtkWindowClass parent_class; +}; + +struct _RecorderPrivate { + ViewClickTrack* click_track; + HeaderArea* header_area; + ClipLibraryView* library; + ModelTimeSystem* provider; + GtkAdjustment* h_adjustment; + GtkHPaned* timeline_library_pane; + GtkScrolledWindow* library_scrolled; + GtkScrolledWindow* timeline_scrolled; + gint cursor_pos; + gint64 center_time; + gboolean loading; + GtkActionGroup* main_group; + GtkToggleButton* play_button; + GtkToggleButton* record_button; + GtkButton* addnew_button; + GtkButton* rewind_button; + GtkButton* forward_button; + GtkButton* zoomin_button; + GtkButton* zoomout_button; + GtkButton* volume_button; + HildonPannableArea* scrollwin; + gint scrollwin_pos_y; + GtkUIManager* manager; + ViewOggVorbisExport* audio_export; + ViewAudioOutput* audio_output; + GeeArrayList* load_errors; +}; + +struct _Fillmore { + HildonProgram parent_instance; + FillmorePrivate * priv; +}; + +struct _FillmoreClass { + HildonProgramClass parent_class; +}; + + +extern gboolean do_print_graph; +gboolean do_print_graph = FALSE; +extern gint debug_level; +gint debug_level = 0; +static gpointer recorder_parent_class = NULL; +static TransportDelegateIface* recorder_transport_delegate_parent_iface = NULL; +static gpointer fillmore_parent_class = NULL; + +GType recorder_get_type (void); +GType model_audio_project_get_type (void); +GType header_area_get_type (void); +#define RECORDER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_RECORDER, RecorderPrivate)) +enum { + RECORDER_DUMMY_PROPERTY +}; +#define RECORDER_scroll_speed 8 +#define RECORDER_NAME "Fillmore" +static void recorder_on_project_open (Recorder* self); +static void _recorder_on_project_open_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_project_new (Recorder* self); +static void _recorder_on_project_new_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_project_save (Recorder* self); +static void _recorder_on_project_save_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_project_save_as (Recorder* self); +static void _recorder_on_project_save_as_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_export (Recorder* self); +static void _recorder_on_export_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_properties (Recorder* self); +static void _recorder_on_properties_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_quit (Recorder* self); +static void _recorder_on_quit_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_undo (Recorder* self); +static void _recorder_on_undo_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_cut (Recorder* self); +static void _recorder_on_cut_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_copy (Recorder* self); +static void _recorder_on_copy_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_paste (Recorder* self); +static void _recorder_on_paste_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_delete (Recorder* self); +static void _recorder_on_delete_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_select_all (Recorder* self); +static void _recorder_on_select_all_gtk_action_callback (GtkAction* action, gpointer self); +void recorder_on_split_at_playhead (Recorder* self); +static void _recorder_on_split_at_playhead_gtk_action_callback (GtkAction* action, gpointer self); +void recorder_on_trim_to_playhead (Recorder* self); +static void _recorder_on_trim_to_playhead_gtk_action_callback (GtkAction* action, gpointer self); +void recorder_on_clip_properties (Recorder* self); +static void _recorder_on_clip_properties_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_zoom_in (Recorder* self); +static void _recorder_on_zoom_in_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_zoom_out (Recorder* self); +static void _recorder_on_zoom_out_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_zoom_to_project (Recorder* self); +static void _recorder_on_zoom_to_project_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_track_new (Recorder* self); +static void _recorder_on_track_new_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_track_rename (Recorder* self); +static void _recorder_on_track_rename_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_track_remove (Recorder* self); +static void _recorder_on_track_remove_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_track_move_up (Recorder* self); +static void _recorder_on_track_move_up_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_track_move_down (Recorder* self); +static void _recorder_on_track_move_down_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_tracks_scroll_up (Recorder* self); +static void _recorder_on_tracks_scroll_up_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_tracks_scroll_down (Recorder* self); +static void _recorder_on_tracks_scroll_down_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_help_contents (Recorder* self); +static void _recorder_on_help_contents_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_about (Recorder* self); +static void _recorder_on_about_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_save_graph (Recorder* self); +static void _recorder_on_save_graph_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_rewind (Recorder* self); +static void _recorder_on_rewind_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_end (Recorder* self); +static void _recorder_on_end_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_play (Recorder* self); +static void _recorder_on_play_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_record (Recorder* self); +static void _recorder_on_record_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_view_library (Recorder* self); +static void _recorder_on_view_library_gtk_action_callback (GtkAction* action, gpointer self); +static void recorder_on_snap (Recorder* self); +static void _recorder_on_snap_gtk_action_callback (GtkAction* action, gpointer self); +#define RECORDER_ui "\n" \ +"\n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" " \ +"\n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +"\n" +static char* recorder_get_fillmore_directory (Recorder* self); +ModelAudioProject* model_audio_project_new (const char* filename, GError** error); +ModelAudioProject* model_audio_project_construct (GType object_type, const char* filename, GError** error); +static void recorder_on_callback_pulse (Recorder* self); +static void _recorder_on_callback_pulse_view_media_engine_callback_pulse (ViewMediaEngine* _sender, gpointer self); +static void recorder_on_post_export (Recorder* self, gboolean canceled); +static void _recorder_on_post_export_view_media_engine_post_export (ViewMediaEngine* _sender, gboolean canceled, gpointer self); +static void recorder_on_position_changed (Recorder* self); +static void _recorder_on_position_changed_view_media_engine_position_changed (ViewMediaEngine* _sender, gint64 position, gpointer self); +void recorder_on_load_error (Recorder* self, const char* message); +static void _recorder_on_load_error_model_project_load_error (ModelProject* _sender, const char* _error_, gpointer self); +static void recorder_on_name_changed (Recorder* self); +static void _recorder_on_name_changed_model_project_name_changed (ModelProject* _sender, const char* project_file, gpointer self); +static void recorder_on_dirty_changed (Recorder* self, gboolean isDirty); +static void _recorder_on_dirty_changed_model_undo_manager_dirty_changed (ModelUndoManager* _sender, gboolean is_dirty, gpointer self); +static void recorder_on_undo_changed (Recorder* self, gboolean can_undo); +static void _recorder_on_undo_changed_model_undo_manager_undo_changed (ModelUndoManager* _sender, gboolean can_undo, gpointer self); +static void recorder_on_error_occurred (Recorder* self, const char* major_message, const char* minor_message); +static void _recorder_on_error_occurred_model_project_error_occurred (ModelProject* _sender, const char* major_message, const char* minor_message, gpointer self); +static void recorder_on_playstate_changed (Recorder* self, PlayState playstate); +static void _recorder_on_playstate_changed_model_project_playstate_changed (ModelProject* _sender, PlayState playstate, gpointer self); +static void recorder_on_track_added (Recorder* self, ModelTrack* track); +static void _recorder_on_track_added_model_project_track_added (ModelProject* _sender, ModelTrack* track, gpointer self); +static void recorder_on_track_removed (Recorder* self, ModelTrack* unused); +static void _recorder_on_track_removed_model_project_track_removed (ModelProject* _sender, ModelTrack* track, gpointer self); +void recorder_on_load_complete (Recorder* self); +static void _recorder_on_load_complete_model_project_load_complete (ModelProject* _sender, gpointer self); +static void recorder_on_project_close (Recorder* self); +static void _recorder_on_project_close_model_project_closed (ModelProject* _sender, gpointer self); +static GtkWidget* recorder_get_widget (Recorder* self, GtkUIManager* manager, const char* name); +void recorder_on_library_selection_changed (Recorder* self, gboolean selected); +static void _recorder_on_library_selection_changed_clip_library_view_selection_changed (ClipLibraryView* _sender, gboolean selected, gpointer self); +static void recorder_on_drag_data_received (Recorder* self, GtkWidget* w, GdkDragContext* context, gint x, gint y, GtkSelectionData* selection_data, guint drag_info, guint time); +static void _recorder_on_drag_data_received_gtk_widget_drag_data_received (GtkWidget* _sender, GdkDragContext* context, gint x, gint y, GtkSelectionData* selection_data, guint info, guint time_, gpointer self); +static void recorder_on_track_changed (Recorder* self); +static void _recorder_on_track_changed_time_line_track_changed (TimeLine* _sender, gpointer self); +static void recorder_on_timeline_size_allocate (Recorder* self, GdkRectangle* rectangle); +static void _recorder_on_timeline_size_allocate_gtk_widget_size_allocate (GtkWidget* _sender, GdkRectangle* allocation, gpointer self); +static void recorder_on_timeline_selection_changed (Recorder* self, gboolean selected); +static void _recorder_on_timeline_selection_changed_time_line_selection_changed (TimeLine* _sender, gboolean selected, gpointer self); +static void recorder_update_menu (Recorder* self); +HeaderArea* header_area_new (Recorder* recorder, ModelTimeSystem* provider, gint height); +HeaderArea* header_area_construct (GType object_type, Recorder* recorder, ModelTimeSystem* provider, gint height); +static void _recorder_on_track_new_gtk_button_clicked (GtkButton* _sender, gpointer self); +static void _recorder_on_play_gtk_toggle_button_toggled (GtkToggleButton* _sender, gpointer self); +static void _recorder_on_record_gtk_toggle_button_toggled (GtkToggleButton* _sender, gpointer self); +static void _recorder_on_rewind_gtk_button_clicked (GtkButton* _sender, gpointer self); +static void _recorder_on_end_gtk_button_clicked (GtkButton* _sender, gpointer self); +static void _recorder_on_zoom_in_gtk_button_clicked (GtkButton* _sender, gpointer self); +static void _recorder_on_zoom_out_gtk_button_clicked (GtkButton* _sender, gpointer self); +static void recorder_on_volume (Recorder* self); +static void _recorder_on_volume_gtk_button_clicked (GtkButton* _sender, gpointer self); +static void recorder_on_library_size_allocate (Recorder* self, GdkRectangle* rectangle); +static void _recorder_on_library_size_allocate_gtk_widget_size_allocate (GtkWidget* _sender, GdkRectangle* allocation, gpointer self); +static gboolean recorder_on_delete_event (Recorder* self); +static gboolean _recorder_on_delete_event_gtk_widget_delete_event (GtkWidget* _sender, GdkEvent* event, gpointer self); +static void recorder_default_track_set (Recorder* self); +Recorder* recorder_new (const char* project_file, GError** error); +Recorder* recorder_construct (GType object_type, const char* project_file, GError** error); +char* recorder_get_default_track_name (Recorder* self); +static gint recorder_default_track_number_compare (void* a, void* b); +static gint _recorder_default_track_number_compare_gcompare_func (void* a, void* b); +static void _g_list_free_g_free (GList* self); +ModelTrack* recorder_selected_track (Recorder* self); +static void recorder_set_sensitive_group (Recorder* self, GtkActionGroup* group, const char* group_path, gboolean sensitive); +static void recorder_on_clip_added (Recorder* self, ModelClip* clip); +static void _recorder_on_clip_added_model_track_clip_added (ModelTrack* _sender, ModelClip* clip, gboolean select, gpointer self); +static void recorder_on_clip_removed (Recorder* self, ModelClip* clip); +static void _recorder_on_clip_removed_model_track_clip_removed (ModelTrack* _sender, ModelClip* clip, gpointer self); +static void recorder_on_track_selection_changed (Recorder* self, ModelTrack* track); +static void _recorder_on_track_selection_changed_model_track_track_selection_changed (ModelTrack* _sender, ModelTrack* track, gpointer self); +static void recorder_on_clip_moved (Recorder* self, ModelClip* clip); +static void _recorder_on_clip_moved_model_clip_moved (ModelClip* _sender, ModelClip* clip, gpointer self); +void recorder_scroll_to_beginning (Recorder* self); +void recorder_scroll_to_time (Recorder* self, gint64 time); +void recorder_page_to_time (Recorder* self, gint64 time); +void recorder_scroll_to_end (Recorder* self); +static gint recorder_sgn (gint x); +void recorder_scroll_toward_center (Recorder* self, gint xpos); +static gboolean recorder_real_key_press_event (GtkWidget* base, GdkEventKey* event); +void recorder_do_error_dialog (const char* major_message, const char* minor_message); +static void recorder_on_project_new_finished_closing (Recorder* self, gboolean project_did_close); +static void _recorder_on_project_new_finished_closing_recorder_finished_closing (Recorder* _sender, gboolean project_did_close, gpointer self); +static void recorder_on_project_open_finished_closing (Recorder* self, gboolean project_did_close); +static void _recorder_on_project_open_finished_closing_recorder_finished_closing (Recorder* _sender, gboolean project_did_close, gpointer self); +static void _g_slist_free_g_free (GSList* self); +static gboolean recorder_save_dialog (Recorder* self); +static gboolean recorder_do_save (Recorder* self); +static void recorder_on_save_new_file_finished_closing (Recorder* self, gboolean did_close); +static void _recorder_on_save_new_file_finished_closing_recorder_finished_closing (Recorder* _sender, gboolean project_did_close, gpointer self); +GType project_properties_get_type (void); +void project_properties_setup (ProjectProperties* self, ModelProject* project, GtkBuilder* builder); +gint project_properties_get_tempo (ProjectProperties* self); +void project_properties_get_time_signature (ProjectProperties* self, Fraction* result); +gboolean project_properties_during_record (ProjectProperties* self); +gboolean project_properties_during_play (ProjectProperties* self); +double project_properties_get_click_volume (ProjectProperties* self); +static void recorder_on_quit_finished_closing (Recorder* self, gboolean project_did_close); +static void _recorder_on_quit_finished_closing_recorder_finished_closing (Recorder* _sender, gboolean project_did_close, gpointer self); +UITrackInformation* ui_track_information_new (void); +UITrackInformation* ui_track_information_construct (GType object_type); +GType ui_track_information_get_type (void); +void ui_track_information_set_track_name (UITrackInformation* self, const char* new_name); +static gboolean recorder_track_name_dialog (Recorder* self, UITrackInformation* dialog, ModelTrack* track); +char* ui_track_information_get_track_name (UITrackInformation* self); +static void recorder_do_zoom (Recorder* self, float increment); +void model_audio_project_record (ModelAudioProject* self, ModelAudioTrack* track); +static gint64 recorder_get_zoom_center_time (Recorder* self); +static gboolean recorder_real_is_playing (TransportDelegate* base); +static gboolean recorder_real_is_recording (TransportDelegate* base); +static gboolean recorder_real_is_stopped (TransportDelegate* base); +static void recorder_finalize (GObject* obj); +GType fillmore_get_type (void); +enum { + FILLMORE_DUMMY_PROPERTY +}; +FillmoreClassFactory* fillmore_class_factory_new (void); +FillmoreClassFactory* fillmore_class_factory_construct (GType object_type); +GType fillmore_class_factory_get_type (void); +void fillmore_run (Fillmore* self, char** args, int args_length1); +Fillmore* fillmore_new (void); +Fillmore* fillmore_construct (GType object_type); +static GObject * fillmore_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties); +gint _vala_main (char** args, int args_length1); +void NO_main (char** args, int args_length1); +static int _vala_strcmp0 (const char * str1, const char * str2); + +const GOptionEntry options[3] = {{"print-graph", (gchar) 0, 0, G_OPTION_ARG_NONE, &do_print_graph, "Show Print Graph in help menu", NULL}, {"debug-level", (gchar) 0, 0, G_OPTION_ARG_INT, &debug_level, "Control amount of diagnostic information", "[0 (minimal),5 (maximum)]"}, {NULL}}; +static const GtkActionEntry RECORDER_entries[36] = {{"Project", NULL, "_Project", NULL, NULL, (GCallback) NULL}, {"Open", GTK_STOCK_OPEN, "_Open...", NULL, "Open a project", (GCallback) _recorder_on_project_open_gtk_action_callback}, {"NewProject", GTK_STOCK_NEW, "_New", NULL, "Create new project", (GCallback) _recorder_on_project_new_gtk_action_callback}, {"Save", GTK_STOCK_SAVE, "_Save", "S", "Save project", (GCallback) _recorder_on_project_save_gtk_action_callback}, {"SaveAs", GTK_STOCK_SAVE_AS, "Save _As...", "S", "Save project with new name", (GCallback) _recorder_on_project_save_as_gtk_action_callback}, {"Export", GTK_STOCK_JUMP_TO, "_Export...", "E", NULL, (GCallback) _recorder_on_export_gtk_action_callback}, {"Settings", GTK_STOCK_PROPERTIES, "Se_ttings", "Return", NULL, (GCallback) _recorder_on_properties_gtk_action_callback}, {"Quit", GTK_STOCK_QUIT, NULL, NULL, NULL, (GCallback) _recorder_on_quit_gtk_action_callback}, {"Edit", NULL, "_Edit", NULL, NULL, (GCallback) NULL}, {"Undo", GTK_STOCK_UNDO, NULL, "Z", NULL, (GCallback) _recorder_on_undo_gtk_action_callback}, {"Cut", GTK_STOCK_CUT, NULL, NULL, NULL, (GCallback) _recorder_on_cut_gtk_action_callback}, {"Copy", GTK_STOCK_COPY, NULL, NULL, NULL, (GCallback) _recorder_on_copy_gtk_action_callback}, {"Paste", GTK_STOCK_PASTE, NULL, NULL, NULL, (GCallback) _recorder_on_paste_gtk_action_callback}, {"Delete", GTK_STOCK_DELETE, NULL, "Delete", NULL, (GCallback) _recorder_on_delete_gtk_action_callback}, {"SelectAll", GTK_STOCK_SELECT_ALL, NULL, "A", NULL, (GCallback) _recorder_on_select_all_gtk_action_callback}, {"SplitAtPlayhead", NULL, "_Split at Playhead", "P", NULL, (GCallback) _recorder_on_split_at_playhead_gtk_action_callback}, {"TrimToPlayhead", NULL, "Trim to Play_head", "H", NULL, (GCallback) _recorder_on_trim_to_playhead_gtk_action_callback}, {"ClipProperties", GTK_STOCK_PROPERTIES, "Properti_es", "Return", NULL, (GCallback) _recorder_on_clip_properties_gtk_action_callback}, {"View", NULL, "_View", NULL, NULL, (GCallback) NULL}, {"ZoomIn", GTK_STOCK_ZOOM_IN, "Zoom _In", "plus", NULL, (GCallback) _recorder_on_zoom_in_gtk_action_callback}, {"ZoomOut", GTK_STOCK_ZOOM_OUT, "Zoom _Out", "minus", NULL, (GCallback) _recorder_on_zoom_out_gtk_action_callback}, {"ZoomProject", NULL, "Fit to _Window", "Z", NULL, (GCallback) _recorder_on_zoom_to_project_gtk_action_callback}, {"Track", NULL, "_Track", NULL, NULL, (GCallback) NULL}, {"NewTrack", GTK_STOCK_ADD, "_New...", "N", "Create new track", (GCallback) _recorder_on_track_new_gtk_action_callback}, {"Rename", NULL, "_Rename...", NULL, "Rename Track", (GCallback) _recorder_on_track_rename_gtk_action_callback}, {"DeleteTrack", NULL, "_Delete", "Delete", "Delete track", (GCallback) _recorder_on_track_remove_gtk_action_callback}, {"MoveTrackUp", NULL, "Move Track Up", "Up", NULL, (GCallback) _recorder_on_track_move_up_gtk_action_callback}, {"MoveTrackDown", NULL, "Move Track Down", "Down", NULL, (GCallback) _recorder_on_track_move_down_gtk_action_callback}, {"ScrollTracksUp", NULL, "Scroll Tracks Up", "Up", NULL, (GCallback) _recorder_on_tracks_scroll_up_gtk_action_callback}, {"ScrollTracksDown", NULL, "Scroll Tracks Down", "Down", NULL, (GCallback) _recorder_on_tracks_scroll_down_gtk_action_callback}, {"Help", NULL, "_Help", NULL, NULL, (GCallback) NULL}, {"Contents", GTK_STOCK_HELP, "_Contents", "F1", "More information on Fillmore", (GCallback) _recorder_on_help_contents_gtk_action_callback}, {"About", GTK_STOCK_ABOUT, NULL, NULL, NULL, (GCallback) _recorder_on_about_gtk_action_callback}, {"SaveGraph", NULL, "Save _Graph", NULL, "Save graph", (GCallback) _recorder_on_save_graph_gtk_action_callback}, {"Rewind", GTK_STOCK_MEDIA_PREVIOUS, "Rewind", "Home", "Go to beginning", (GCallback) _recorder_on_rewind_gtk_action_callback}, {"End", GTK_STOCK_MEDIA_NEXT, "End", "End", "Go to end", (GCallback) _recorder_on_end_gtk_action_callback}}; +static const GtkToggleActionEntry RECORDER_toggle_entries[4] = {{"Play", GTK_STOCK_MEDIA_PLAY, NULL, "space", "Play", (GCallback) _recorder_on_play_gtk_action_callback}, {"Record", GTK_STOCK_MEDIA_RECORD, NULL, "r", "Record", (GCallback) _recorder_on_record_gtk_action_callback}, {"Library", NULL, "_Library", "F9", NULL, (GCallback) _recorder_on_view_library_gtk_action_callback, FALSE}, {"Snap", NULL, "_Snap to Clip Edges", NULL, NULL, (GCallback) _recorder_on_snap_gtk_action_callback, FALSE}}; +static const DialogUtilsfilter_description_struct RECORDER_filters[2] = {{"Fillmore Project Files", MODEL_PROJECT_FILLMORE_FILE_EXTENSION}, {"Lombard Project Files", MODEL_PROJECT_LOMBARD_FILE_EXTENSION}}; +static const DialogUtilsfilter_description_struct RECORDER_export_filters[1] = {{"Ogg Files", "ogg"}}; + + +#line 774 "fillmore.vala" +static void _recorder_on_project_open_gtk_action_callback (GtkAction* action, gpointer self) { +#line 383 "fillmore.c" + recorder_on_project_open (self); +} + + +#line 755 "fillmore.vala" +static void _recorder_on_project_new_gtk_action_callback (GtkAction* action, gpointer self) { +#line 390 "fillmore.c" + recorder_on_project_new (self); +} + + +#line 785 "fillmore.vala" +static void _recorder_on_project_save_gtk_action_callback (GtkAction* action, gpointer self) { +#line 397 "fillmore.c" + recorder_on_project_save (self); +} + + +#line 781 "fillmore.vala" +static void _recorder_on_project_save_as_gtk_action_callback (GtkAction* action, gpointer self) { +#line 404 "fillmore.c" + recorder_on_project_save_as (self); +} + + +#line 714 "fillmore.vala" +static void _recorder_on_export_gtk_action_callback (GtkAction* action, gpointer self) { +#line 411 "fillmore.c" + recorder_on_export (self); +} + + +#line 822 "fillmore.vala" +static void _recorder_on_properties_gtk_action_callback (GtkAction* action, gpointer self) { +#line 418 "fillmore.c" + recorder_on_properties (self); +} + + +#line 858 "fillmore.vala" +static void _recorder_on_quit_gtk_action_callback (GtkAction* action, gpointer self) { +#line 425 "fillmore.c" + recorder_on_quit (self); +} + + +#line 913 "fillmore.vala" +static void _recorder_on_undo_gtk_action_callback (GtkAction* action, gpointer self) { +#line 432 "fillmore.c" + recorder_on_undo (self); +} + + +#line 901 "fillmore.vala" +static void _recorder_on_cut_gtk_action_callback (GtkAction* action, gpointer self) { +#line 439 "fillmore.c" + recorder_on_cut (self); +} + + +#line 905 "fillmore.vala" +static void _recorder_on_copy_gtk_action_callback (GtkAction* action, gpointer self) { +#line 446 "fillmore.c" + recorder_on_copy (self); +} + + +#line 909 "fillmore.vala" +static void _recorder_on_paste_gtk_action_callback (GtkAction* action, gpointer self) { +#line 453 "fillmore.c" + recorder_on_paste (self); +} + + +#line 917 "fillmore.vala" +static void _recorder_on_delete_gtk_action_callback (GtkAction* action, gpointer self) { +#line 460 "fillmore.c" + recorder_on_delete (self); +} + + +#line 925 "fillmore.vala" +static void _recorder_on_select_all_gtk_action_callback (GtkAction* action, gpointer self) { +#line 467 "fillmore.c" + recorder_on_select_all (self); +} + + +#line 933 "fillmore.vala" +static void _recorder_on_split_at_playhead_gtk_action_callback (GtkAction* action, gpointer self) { +#line 474 "fillmore.c" + recorder_on_split_at_playhead (self); +} + + +#line 937 "fillmore.vala" +static void _recorder_on_trim_to_playhead_gtk_action_callback (GtkAction* action, gpointer self) { +#line 481 "fillmore.c" + recorder_on_trim_to_playhead (self); +} + + +#line 941 "fillmore.vala" +static void _recorder_on_clip_properties_gtk_action_callback (GtkAction* action, gpointer self) { +#line 488 "fillmore.c" + recorder_on_clip_properties (self); +} + + +#line 1008 "fillmore.vala" +static void _recorder_on_zoom_in_gtk_action_callback (GtkAction* action, gpointer self) { +#line 495 "fillmore.c" + recorder_on_zoom_in (self); +} + + +#line 1012 "fillmore.vala" +static void _recorder_on_zoom_out_gtk_action_callback (GtkAction* action, gpointer self) { +#line 502 "fillmore.c" + recorder_on_zoom_out (self); +} + + +#line 1016 "fillmore.vala" +static void _recorder_on_zoom_to_project_gtk_action_callback (GtkAction* action, gpointer self) { +#line 509 "fillmore.c" + recorder_on_zoom_to_project (self); +} + + +#line 960 "fillmore.vala" +static void _recorder_on_track_new_gtk_action_callback (GtkAction* action, gpointer self) { +#line 516 "fillmore.c" + recorder_on_track_new (self); +} + + +#line 969 "fillmore.vala" +static void _recorder_on_track_rename_gtk_action_callback (GtkAction* action, gpointer self) { +#line 523 "fillmore.c" + recorder_on_track_rename (self); +} + + +#line 1003 "fillmore.vala" +static void _recorder_on_track_remove_gtk_action_callback (GtkAction* action, gpointer self) { +#line 530 "fillmore.c" + recorder_on_track_remove (self); +} + + +#line 426 "fillmore.vala" +static void _recorder_on_track_move_up_gtk_action_callback (GtkAction* action, gpointer self) { +#line 537 "fillmore.c" + recorder_on_track_move_up (self); +} + + +#line 444 "fillmore.vala" +static void _recorder_on_track_move_down_gtk_action_callback (GtkAction* action, gpointer self) { +#line 544 "fillmore.c" + recorder_on_track_move_down (self); +} + + +#line 463 "fillmore.vala" +static void _recorder_on_tracks_scroll_up_gtk_action_callback (GtkAction* action, gpointer self) { +#line 551 "fillmore.c" + recorder_on_tracks_scroll_up (self); +} + + +#line 475 "fillmore.vala" +static void _recorder_on_tracks_scroll_down_gtk_action_callback (GtkAction* action, gpointer self) { +#line 558 "fillmore.c" + recorder_on_tracks_scroll_down (self); +} + + +#line 1043 "fillmore.vala" +static void _recorder_on_help_contents_gtk_action_callback (GtkAction* action, gpointer self) { +#line 565 "fillmore.c" + recorder_on_help_contents (self); +} + + +#line 1050 "fillmore.vala" +static void _recorder_on_about_gtk_action_callback (GtkAction* action, gpointer self) { +#line 572 "fillmore.c" + recorder_on_about (self); +} + + +#line 1062 "fillmore.vala" +static void _recorder_on_save_graph_gtk_action_callback (GtkAction* action, gpointer self) { +#line 579 "fillmore.c" + recorder_on_save_graph (self); +} + + +#line 1072 "fillmore.vala" +static void _recorder_on_rewind_gtk_action_callback (GtkAction* action, gpointer self) { +#line 586 "fillmore.c" + recorder_on_rewind (self); +} + + +#line 1077 "fillmore.vala" +static void _recorder_on_end_gtk_action_callback (GtkAction* action, gpointer self) { +#line 593 "fillmore.c" + recorder_on_end (self); +} + + +#line 1082 "fillmore.vala" +static void _recorder_on_play_gtk_action_callback (GtkAction* action, gpointer self) { +#line 600 "fillmore.c" + recorder_on_play (self); +} + + +#line 1094 "fillmore.vala" +static void _recorder_on_record_gtk_action_callback (GtkAction* action, gpointer self) { +#line 607 "fillmore.c" + recorder_on_record (self); +} + + +#line 1024 "fillmore.vala" +static void _recorder_on_view_library_gtk_action_callback (GtkAction* action, gpointer self) { +#line 614 "fillmore.c" + recorder_on_view_library (self); +} + + +#line 1020 "fillmore.vala" +static void _recorder_on_snap_gtk_action_callback (GtkAction* action, gpointer self) { +#line 621 "fillmore.c" + recorder_on_snap (self); +} + + +#line 1114 "fillmore.vala" +static void _recorder_on_callback_pulse_view_media_engine_callback_pulse (ViewMediaEngine* _sender, gpointer self) { +#line 628 "fillmore.c" + recorder_on_callback_pulse (self); +} + + +#line 730 "fillmore.vala" +static void _recorder_on_post_export_view_media_engine_post_export (ViewMediaEngine* _sender, gboolean canceled, gpointer self) { +#line 635 "fillmore.c" + recorder_on_post_export (self, canceled); +} + + +#line 498 "fillmore.vala" +static void _recorder_on_position_changed_view_media_engine_position_changed (ViewMediaEngine* _sender, gint64 position, gpointer self) { +#line 642 "fillmore.c" + recorder_on_position_changed (self); +} + + +#line 1210 "fillmore.vala" +static void _recorder_on_load_error_model_project_load_error (ModelProject* _sender, const char* _error_, gpointer self) { +#line 649 "fillmore.c" + recorder_on_load_error (self, _error_); +} + + +#line 1251 "fillmore.vala" +static void _recorder_on_name_changed_model_project_name_changed (ModelProject* _sender, const char* project_file, gpointer self) { +#line 656 "fillmore.c" + recorder_on_name_changed (self); +} + + +#line 1256 "fillmore.vala" +static void _recorder_on_dirty_changed_model_undo_manager_dirty_changed (ModelUndoManager* _sender, gboolean is_dirty, gpointer self) { +#line 663 "fillmore.c" + recorder_on_dirty_changed (self, is_dirty); +} + + +#line 1263 "fillmore.vala" +static void _recorder_on_undo_changed_model_undo_manager_undo_changed (ModelUndoManager* _sender, gboolean can_undo, gpointer self) { +#line 670 "fillmore.c" + recorder_on_undo_changed (self, can_undo); +} + + +#line 1281 "fillmore.vala" +static void _recorder_on_error_occurred_model_project_error_occurred (ModelProject* _sender, const char* major_message, const char* minor_message, gpointer self) { +#line 677 "fillmore.c" + recorder_on_error_occurred (self, major_message, minor_message); +} + + +#line 1271 "fillmore.vala" +static void _recorder_on_playstate_changed_model_project_playstate_changed (ModelProject* _sender, PlayState playstate, gpointer self) { +#line 684 "fillmore.c" + recorder_on_playstate_changed (self, playstate); +} + + +#line 503 "fillmore.vala" +static void _recorder_on_track_added_model_project_track_added (ModelProject* _sender, ModelTrack* track, gpointer self) { +#line 691 "fillmore.c" + recorder_on_track_added (self, track); +} + + +#line 511 "fillmore.vala" +static void _recorder_on_track_removed_model_project_track_removed (ModelProject* _sender, ModelTrack* track, gpointer self) { +#line 698 "fillmore.c" + recorder_on_track_removed (self, track); +} + + +#line 1215 "fillmore.vala" +static void _recorder_on_load_complete_model_project_load_complete (ModelProject* _sender, gpointer self) { +#line 705 "fillmore.c" + recorder_on_load_complete (self); +} + + +#line 872 "fillmore.vala" +static void _recorder_on_project_close_model_project_closed (ModelProject* _sender, gpointer self) { +#line 712 "fillmore.c" + recorder_on_project_close (self); +} + + +#line 1148 "fillmore.vala" +static void _recorder_on_library_selection_changed_clip_library_view_selection_changed (ClipLibraryView* _sender, gboolean selected, gpointer self) { +#line 719 "fillmore.c" + recorder_on_library_selection_changed (self, selected); +} + + +#line 543 "fillmore.vala" +static void _recorder_on_drag_data_received_gtk_widget_drag_data_received (GtkWidget* _sender, GdkDragContext* context, gint x, gint y, GtkSelectionData* selection_data, guint info, guint time_, gpointer self) { +#line 726 "fillmore.c" + recorder_on_drag_data_received (self, _sender, context, x, y, selection_data, info, time_); +} + + +#line 493 "fillmore.vala" +static void _recorder_on_track_changed_time_line_track_changed (TimeLine* _sender, gpointer self) { +#line 733 "fillmore.c" + recorder_on_track_changed (self); +} + + +#line 1131 "fillmore.vala" +static void _recorder_on_timeline_size_allocate_gtk_widget_size_allocate (GtkWidget* _sender, GdkRectangle* allocation, gpointer self) { +#line 740 "fillmore.c" + recorder_on_timeline_size_allocate (self, allocation); +} + + +#line 1140 "fillmore.vala" +static void _recorder_on_timeline_selection_changed_time_line_selection_changed (TimeLine* _sender, gboolean selected, gpointer self) { +#line 747 "fillmore.c" + recorder_on_timeline_selection_changed (self, selected); +} + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 960 "fillmore.vala" +static void _recorder_on_track_new_gtk_button_clicked (GtkButton* _sender, gpointer self) { +#line 759 "fillmore.c" + recorder_on_track_new (self); +} + + +#line 1082 "fillmore.vala" +static void _recorder_on_play_gtk_toggle_button_toggled (GtkToggleButton* _sender, gpointer self) { +#line 766 "fillmore.c" + recorder_on_play (self); +} + + +#line 1094 "fillmore.vala" +static void _recorder_on_record_gtk_toggle_button_toggled (GtkToggleButton* _sender, gpointer self) { +#line 773 "fillmore.c" + recorder_on_record (self); +} + + +#line 1072 "fillmore.vala" +static void _recorder_on_rewind_gtk_button_clicked (GtkButton* _sender, gpointer self) { +#line 780 "fillmore.c" + recorder_on_rewind (self); +} + + +#line 1077 "fillmore.vala" +static void _recorder_on_end_gtk_button_clicked (GtkButton* _sender, gpointer self) { +#line 787 "fillmore.c" + recorder_on_end (self); +} + + +#line 1008 "fillmore.vala" +static void _recorder_on_zoom_in_gtk_button_clicked (GtkButton* _sender, gpointer self) { +#line 794 "fillmore.c" + recorder_on_zoom_in (self); +} + + +#line 1012 "fillmore.vala" +static void _recorder_on_zoom_out_gtk_button_clicked (GtkButton* _sender, gpointer self) { +#line 801 "fillmore.c" + recorder_on_zoom_out (self); +} + + +#line 1068 "fillmore.vala" +static void _recorder_on_volume_gtk_button_clicked (GtkButton* _sender, gpointer self) { +#line 808 "fillmore.c" + recorder_on_volume (self); +} + + +#line 1035 "fillmore.vala" +static void _recorder_on_library_size_allocate_gtk_widget_size_allocate (GtkWidget* _sender, GdkRectangle* allocation, gpointer self) { +#line 815 "fillmore.c" + recorder_on_library_size_allocate (self, allocation); +} + + +#line 866 "fillmore.vala" +static gboolean _recorder_on_delete_event_gtk_widget_delete_event (GtkWidget* _sender, GdkEvent* event, gpointer self) { +#line 822 "fillmore.c" + gboolean result; + result = recorder_on_delete_event (self); + return result; +} + + +#line 207 "fillmore.vala" +Recorder* recorder_construct (GType object_type, const char* project_file, GError** error) { +#line 831 "fillmore.c" + GError * _inner_error_; + Recorder * self; + char* _tmp0_; + GeeArrayList* _tmp1_; + ModelAudioProject* _tmp5_; + ModelAudioProject* _tmp6_; + ModelTimeSystem* _tmp7_; + GstCaps* _tmp8_; + ViewAudioOutput* _tmp9_; + ViewAudioOutput* _tmp10_; + ViewAudioOutput* _tmp11_; + ViewClickTrack* _tmp12_; + ViewClickTrack* _tmp13_; + GtkActionGroup* _tmp14_; + GtkUIManager* _tmp15_; + GtkMenuBar* menubar; + GtkToolbar* toolbar; + ClipLibraryView* _tmp16_; + TimeLine* _tmp17_; + GtkMenu* _tmp18_; + GtkMenu* _tmp19_; + GtkScrolledWindow* _tmp20_; + GtkHBox* hbox; + HeaderArea* _tmp21_; + GtkScrolledWindow* _tmp22_; + GtkAdjustment* _tmp23_; + GtkHButtonBox* buttons; + GtkButton* _tmp24_; + GtkImage* _tmp25_; + GtkToggleButton* _tmp26_; + GtkImage* _tmp27_; + GtkToggleButton* _tmp28_; + GtkImage* _tmp29_; + GtkButton* _tmp30_; + GtkImage* _tmp31_; + GtkButton* _tmp32_; + GtkImage* _tmp33_; + GtkButton* _tmp34_; + GtkImage* _tmp35_; + GtkButton* _tmp36_; + GtkImage* _tmp37_; + GtkButton* _tmp38_; + GtkImage* _tmp39_; + GtkVBox* vbox; + GtkVBox* main_view; + GtkHPaned* _tmp40_; + HildonPannableArea* _tmp41_; + GtkMenuItem* save_graph; + gboolean _tmp42_ = FALSE; + _inner_error_ = NULL; + self = g_object_newv (object_type, 0, NULL); +#line 208 "fillmore.vala" + class_factory_set_transport_delegate (TRANSPORT_DELEGATE (self)); +#line 209 "fillmore.vala" + g_mkdir (_tmp0_ = recorder_get_fillmore_directory (self), 0777); +#line 887 "fillmore.c" + _g_free0 (_tmp0_); +#line 210 "fillmore.vala" + self->priv->load_errors = (_tmp1_ = gee_array_list_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL), _g_object_unref0 (self->priv->load_errors), _tmp1_); +#line 891 "fillmore.c" + { + char* _tmp4_; + GFile* _tmp3_; + GFile* _tmp2_; +#line 212 "fillmore.vala" + gtk_window_set_icon_from_file (GTK_WINDOW (self), _tmp4_ = g_file_get_path (_tmp3_ = g_file_get_child (_tmp2_ = app_dirs_get_resources_dir (), "fillmore_icon.png")), &_inner_error_); +#line 898 "fillmore.c" + _g_free0 (_tmp4_); + _g_object_unref0 (_tmp3_); + _g_object_unref0 (_tmp2_); + if (_inner_error_ != NULL) { + goto __catch3_g_error; + } + } + goto __finally3; + __catch3_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { +#line 215 "fillmore.vala" + g_warning ("fillmore.vala:215: Could not load application icon: %s", e->message); +#line 915 "fillmore.c" + _g_error_free0 (e); + } + } + __finally3: + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 219 "fillmore.vala" + _tmp5_ = model_audio_project_new (project_file, &_inner_error_); +#line 927 "fillmore.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 219 "fillmore.vala" + self->project = (_tmp6_ = _tmp5_, _g_object_unref0 (self->project), _tmp6_); +#line 220 "fillmore.vala" + MODEL_PROJECT (self->project)->snap_to_clip = FALSE; +#line 221 "fillmore.vala" + self->priv->provider = (_tmp7_ = MODEL_TIME_SYSTEM (model_bar_beat_time_system_new (MODEL_TEMPO_INFORMATION (self->project))), _g_object_unref0 (self->priv->provider), _tmp7_); +#line 223 "fillmore.vala" + g_signal_connect_object (MODEL_PROJECT (self->project)->media_engine, "callback-pulse", (GCallback) _recorder_on_callback_pulse_view_media_engine_callback_pulse, self, 0); +#line 224 "fillmore.vala" + g_signal_connect_object (MODEL_PROJECT (self->project)->media_engine, "post-export", (GCallback) _recorder_on_post_export_view_media_engine_post_export, self, 0); +#line 225 "fillmore.vala" + g_signal_connect_object (MODEL_PROJECT (self->project)->media_engine, "position-changed", (GCallback) _recorder_on_position_changed_view_media_engine_position_changed, self, 0); +#line 227 "fillmore.vala" + g_signal_connect_object (MODEL_PROJECT (self->project), "load-error", (GCallback) _recorder_on_load_error_model_project_load_error, self, 0); +#line 228 "fillmore.vala" + g_signal_connect_object (MODEL_PROJECT (self->project), "name-changed", (GCallback) _recorder_on_name_changed_model_project_name_changed, self, 0); +#line 229 "fillmore.vala" + g_signal_connect_object (MODEL_PROJECT (self->project)->undo_manager, "dirty-changed", (GCallback) _recorder_on_dirty_changed_model_undo_manager_dirty_changed, self, 0); +#line 230 "fillmore.vala" + g_signal_connect_object (MODEL_PROJECT (self->project)->undo_manager, "undo-changed", (GCallback) _recorder_on_undo_changed_model_undo_manager_undo_changed, self, 0); +#line 231 "fillmore.vala" + g_signal_connect_object (MODEL_PROJECT (self->project), "error-occurred", (GCallback) _recorder_on_error_occurred_model_project_error_occurred, self, 0); +#line 232 "fillmore.vala" + g_signal_connect_object (MODEL_PROJECT (self->project), "playstate-changed", (GCallback) _recorder_on_playstate_changed_model_project_playstate_changed, self, 0); +#line 233 "fillmore.vala" + g_signal_connect_object (MODEL_PROJECT (self->project), "track-added", (GCallback) _recorder_on_track_added_model_project_track_added, self, 0); +#line 234 "fillmore.vala" + g_signal_connect_object (MODEL_PROJECT (self->project), "track-removed", (GCallback) _recorder_on_track_removed_model_project_track_removed, self, 0); +#line 235 "fillmore.vala" + g_signal_connect_object (MODEL_PROJECT (self->project), "load-complete", (GCallback) _recorder_on_load_complete_model_project_load_complete, self, 0); +#line 236 "fillmore.vala" + g_signal_connect_object (MODEL_PROJECT (self->project), "closed", (GCallback) _recorder_on_project_close_model_project_closed, self, 0); +#line 238 "fillmore.vala" + _tmp10_ = (_tmp9_ = view_audio_output_new (_tmp8_ = view_media_engine_get_project_audio_caps (MODEL_PROJECT (self->project)->media_engine), &_inner_error_), _gst_caps_unref0 (_tmp8_), _tmp9_); +#line 967 "fillmore.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 238 "fillmore.vala" + self->priv->audio_output = (_tmp11_ = _tmp10_, _g_object_unref0 (self->priv->audio_output), _tmp11_); +#line 239 "fillmore.vala" + view_media_engine_connect_output (MODEL_PROJECT (self->project)->media_engine, VIEW_MEDIA_CONNECTOR (self->priv->audio_output)); +#line 240 "fillmore.vala" + _tmp12_ = view_click_track_new (MODEL_PROJECT (self->project)->media_engine, MODEL_PROJECT (self->project), &_inner_error_); +#line 979 "fillmore.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 240 "fillmore.vala" + self->priv->click_track = (_tmp13_ = _tmp12_, _g_object_unref0 (self->priv->click_track), _tmp13_); +#line 241 "fillmore.vala" + gtk_window_set_position (GTK_WINDOW (self), GTK_WIN_POS_CENTER); +#line 242 "fillmore.vala" + gtk_window_set_title (GTK_WINDOW (self), "Fillmore"); +#line 243 "fillmore.vala" + gtk_window_set_default_size (GTK_WINDOW (self), 800, 1200); +#line 245 "fillmore.vala" + self->priv->main_group = (_tmp14_ = gtk_action_group_new ("main"), _g_object_unref0 (self->priv->main_group), _tmp14_); +#line 246 "fillmore.vala" + gtk_action_group_add_actions (self->priv->main_group, RECORDER_entries, G_N_ELEMENTS (RECORDER_entries), self); +#line 247 "fillmore.vala" + gtk_action_group_add_toggle_actions (self->priv->main_group, RECORDER_toggle_entries, G_N_ELEMENTS (RECORDER_toggle_entries), self); +#line 249 "fillmore.vala" + self->priv->manager = (_tmp15_ = gtk_ui_manager_new (), _g_object_unref0 (self->priv->manager), _tmp15_); +#line 250 "fillmore.vala" + gtk_ui_manager_insert_action_group (self->priv->manager, self->priv->main_group, 0); +#line 1003 "fillmore.c" + { +#line 252 "fillmore.vala" + gtk_ui_manager_add_ui_from_string (self->priv->manager, RECORDER_ui, (gssize) (-1), &_inner_error_); +#line 1007 "fillmore.c" + if (_inner_error_ != NULL) { + goto __catch4_g_error; + } + } + goto __finally4; + __catch4_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { +#line 253 "fillmore.vala" + g_error ("fillmore.vala:253: %s", e->message); +#line 1021 "fillmore.c" + _g_error_free0 (e); + } + } + __finally4: + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 255 "fillmore.vala" + menubar = GTK_MENU_BAR (recorder_get_widget (self, self->priv->manager, "/MenuBar")); +#line 256 "fillmore.vala" + toolbar = GTK_TOOLBAR (recorder_get_widget (self, self->priv->manager, "/Toolbar")); +#line 262 "fillmore.vala" + recorder_on_undo_changed (self, FALSE); +#line 264 "fillmore.vala" + self->priv->library = (_tmp16_ = g_object_ref_sink (clip_library_view_new (MODEL_PROJECT (self->project), self->priv->provider, NULL, GDK_ACTION_COPY)), _g_object_unref0 (self->priv->library), _tmp16_); +#line 265 "fillmore.vala" + g_signal_connect_object (self->priv->library, "selection-changed", (GCallback) _recorder_on_library_selection_changed_clip_library_view_selection_changed, self, 0); +#line 266 "fillmore.vala" + g_signal_connect_object (GTK_WIDGET (self->priv->library), "drag-data-received", (GCallback) _recorder_on_drag_data_received_gtk_widget_drag_data_received, self, 0); +#line 268 "fillmore.vala" + self->timeline = (_tmp17_ = g_object_ref_sink (time_line_new (MODEL_PROJECT (self->project), self->priv->provider, GDK_ACTION_COPY)), _g_object_unref0 (self->timeline), _tmp17_); +#line 269 "fillmore.vala" + g_signal_connect_object (self->timeline, "track-changed", (GCallback) _recorder_on_track_changed_time_line_track_changed, self, 0); +#line 270 "fillmore.vala" + g_signal_connect_object (GTK_WIDGET (self->timeline), "drag-data-received", (GCallback) _recorder_on_drag_data_received_gtk_widget_drag_data_received, self, 0); +#line 271 "fillmore.vala" + g_signal_connect_object (GTK_WIDGET (self->timeline), "size-allocate", (GCallback) _recorder_on_timeline_size_allocate_gtk_widget_size_allocate, self, 0); +#line 272 "fillmore.vala" + g_signal_connect_object (self->timeline, "selection-changed", (GCallback) _recorder_on_timeline_selection_changed_time_line_selection_changed, self, 0); +#line 274 "fillmore.vala" + clip_view_context_menu = (_tmp18_ = _g_object_ref0 (GTK_MENU (gtk_ui_manager_get_widget (self->priv->manager, "/ClipContextMenu"))), _g_object_unref0 (clip_view_context_menu), _tmp18_); +#line 275 "fillmore.vala" + clip_library_view_context_menu = (_tmp19_ = _g_object_ref0 (GTK_MENU (gtk_ui_manager_get_widget (self->priv->manager, "/LibraryContextMenu"))), _g_object_unref0 (clip_library_view_context_menu), _tmp19_); +#line 276 "fillmore.vala" + recorder_update_menu (self); +#line 278 "fillmore.vala" + self->priv->library_scrolled = (_tmp20_ = g_object_ref_sink ((GtkScrolledWindow*) gtk_scrolled_window_new (NULL, NULL)), _g_object_unref0 (self->priv->library_scrolled), _tmp20_); +#line 279 "fillmore.vala" + gtk_scrolled_window_set_policy (self->priv->library_scrolled, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); +#line 280 "fillmore.vala" + gtk_scrolled_window_add_with_viewport (self->priv->library_scrolled, GTK_WIDGET (self->priv->library)); +#line 282 "fillmore.vala" + hbox = g_object_ref_sink ((GtkHBox*) gtk_hbox_new (FALSE, 0)); +#line 283 "fillmore.vala" + self->priv->header_area = (_tmp21_ = g_object_ref_sink (header_area_new (self, self->priv->provider, TIME_LINE_RULER_HEIGHT)), _g_object_unref0 (self->priv->header_area), _tmp21_); +#line 284 "fillmore.vala" + gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (self->priv->header_area), FALSE, FALSE, (guint) 0); +#line 287 "fillmore.vala" + self->priv->timeline_scrolled = (_tmp22_ = g_object_ref_sink ((GtkScrolledWindow*) gtk_scrolled_window_new (NULL, NULL)), _g_object_unref0 (self->priv->timeline_scrolled), _tmp22_); +#line 288 "fillmore.vala" + gtk_scrolled_window_set_policy (self->priv->timeline_scrolled, GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER); +#line 289 "fillmore.vala" + gtk_scrolled_window_add_with_viewport (self->priv->timeline_scrolled, GTK_WIDGET (self->timeline)); +#line 290 "fillmore.vala" + gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (self->priv->timeline_scrolled), TRUE, TRUE, (guint) 0); +#line 291 "fillmore.vala" + self->priv->h_adjustment = (_tmp23_ = _g_object_ref0 (gtk_scrolled_window_get_hadjustment (self->priv->timeline_scrolled)), _g_object_unref0 (self->priv->h_adjustment), _tmp23_); +#line 295 "fillmore.vala" + buttons = g_object_ref_sink ((GtkHButtonBox*) gtk_hbutton_box_new ()); +#line 296 "fillmore.vala" + self->priv->addnew_button = (_tmp24_ = g_object_ref_sink ((GtkButton*) gtk_button_new ()), _g_object_unref0 (self->priv->addnew_button), _tmp24_); +#line 297 "fillmore.vala" + gtk_button_set_image (self->priv->addnew_button, GTK_WIDGET (_tmp25_ = g_object_ref_sink ((GtkImage*) gtk_image_new_from_icon_name ("general_add", GTK_ICON_SIZE_BUTTON)))); +#line 1087 "fillmore.c" + _g_object_unref0 (_tmp25_); +#line 298 "fillmore.vala" + g_signal_connect_object (self->priv->addnew_button, "clicked", (GCallback) _recorder_on_track_new_gtk_button_clicked, self, 0); +#line 299 "fillmore.vala" + gtk_container_add (GTK_CONTAINER (buttons), GTK_WIDGET (self->priv->addnew_button)); +#line 300 "fillmore.vala" + self->priv->play_button = (_tmp26_ = g_object_ref_sink ((GtkToggleButton*) gtk_toggle_button_new ()), _g_object_unref0 (self->priv->play_button), _tmp26_); +#line 301 "fillmore.vala" + gtk_button_set_image (GTK_BUTTON (self->priv->play_button), GTK_WIDGET (_tmp27_ = g_object_ref_sink ((GtkImage*) gtk_image_new_from_icon_name ("camera_playback", GTK_ICON_SIZE_BUTTON)))); +#line 1097 "fillmore.c" + _g_object_unref0 (_tmp27_); +#line 302 "fillmore.vala" + g_signal_connect_object (self->priv->play_button, "toggled", (GCallback) _recorder_on_play_gtk_toggle_button_toggled, self, 0); +#line 303 "fillmore.vala" + gtk_container_add (GTK_CONTAINER (buttons), GTK_WIDGET (self->priv->play_button)); +#line 304 "fillmore.vala" + self->priv->record_button = (_tmp28_ = g_object_ref_sink ((GtkToggleButton*) gtk_toggle_button_new ()), _g_object_unref0 (self->priv->record_button), _tmp28_); +#line 305 "fillmore.vala" + gtk_button_set_image (GTK_BUTTON (self->priv->record_button), GTK_WIDGET (_tmp29_ = g_object_ref_sink ((GtkImage*) gtk_image_new_from_icon_name ("camera_video_recording", GTK_ICON_SIZE_BUTTON)))); +#line 1107 "fillmore.c" + _g_object_unref0 (_tmp29_); +#line 306 "fillmore.vala" + g_signal_connect_object (self->priv->record_button, "toggled", (GCallback) _recorder_on_record_gtk_toggle_button_toggled, self, 0); +#line 307 "fillmore.vala" + gtk_container_add (GTK_CONTAINER (buttons), GTK_WIDGET (self->priv->record_button)); +#line 308 "fillmore.vala" + self->priv->rewind_button = (_tmp30_ = g_object_ref_sink ((GtkButton*) gtk_button_new ()), _g_object_unref0 (self->priv->rewind_button), _tmp30_); +#line 309 "fillmore.vala" + gtk_button_set_image (self->priv->rewind_button, GTK_WIDGET (_tmp31_ = g_object_ref_sink ((GtkImage*) gtk_image_new_from_icon_name ("pdf_viewer_first_page", GTK_ICON_SIZE_BUTTON)))); +#line 1117 "fillmore.c" + _g_object_unref0 (_tmp31_); +#line 310 "fillmore.vala" + g_signal_connect_object (self->priv->rewind_button, "clicked", (GCallback) _recorder_on_rewind_gtk_button_clicked, self, 0); +#line 311 "fillmore.vala" + gtk_container_add (GTK_CONTAINER (buttons), GTK_WIDGET (self->priv->rewind_button)); +#line 312 "fillmore.vala" + self->priv->forward_button = (_tmp32_ = g_object_ref_sink ((GtkButton*) gtk_button_new ()), _g_object_unref0 (self->priv->forward_button), _tmp32_); +#line 313 "fillmore.vala" + gtk_button_set_image (self->priv->forward_button, GTK_WIDGET (_tmp33_ = g_object_ref_sink ((GtkImage*) gtk_image_new_from_icon_name ("pdf_viewer_last_page", GTK_ICON_SIZE_BUTTON)))); +#line 1127 "fillmore.c" + _g_object_unref0 (_tmp33_); +#line 314 "fillmore.vala" + g_signal_connect_object (self->priv->forward_button, "clicked", (GCallback) _recorder_on_end_gtk_button_clicked, self, 0); +#line 315 "fillmore.vala" + gtk_container_add (GTK_CONTAINER (buttons), GTK_WIDGET (self->priv->forward_button)); +#line 316 "fillmore.vala" + self->priv->zoomin_button = (_tmp34_ = g_object_ref_sink ((GtkButton*) gtk_button_new ()), _g_object_unref0 (self->priv->zoomin_button), _tmp34_); +#line 317 "fillmore.vala" + gtk_button_set_image (self->priv->zoomin_button, GTK_WIDGET (_tmp35_ = g_object_ref_sink ((GtkImage*) gtk_image_new_from_icon_name ("pdf_zoomin", GTK_ICON_SIZE_BUTTON)))); +#line 1137 "fillmore.c" + _g_object_unref0 (_tmp35_); +#line 318 "fillmore.vala" + g_signal_connect_object (self->priv->zoomin_button, "clicked", (GCallback) _recorder_on_zoom_in_gtk_button_clicked, self, 0); +#line 319 "fillmore.vala" + gtk_container_add (GTK_CONTAINER (buttons), GTK_WIDGET (self->priv->zoomin_button)); +#line 320 "fillmore.vala" + self->priv->zoomout_button = (_tmp36_ = g_object_ref_sink ((GtkButton*) gtk_button_new ()), _g_object_unref0 (self->priv->zoomout_button), _tmp36_); +#line 321 "fillmore.vala" + gtk_button_set_image (self->priv->zoomout_button, GTK_WIDGET (_tmp37_ = g_object_ref_sink ((GtkImage*) gtk_image_new_from_icon_name ("pdf_zoomout", GTK_ICON_SIZE_BUTTON)))); +#line 1147 "fillmore.c" + _g_object_unref0 (_tmp37_); +#line 322 "fillmore.vala" + g_signal_connect_object (self->priv->zoomout_button, "clicked", (GCallback) _recorder_on_zoom_out_gtk_button_clicked, self, 0); +#line 323 "fillmore.vala" + gtk_container_add (GTK_CONTAINER (buttons), GTK_WIDGET (self->priv->zoomout_button)); +#line 324 "fillmore.vala" + self->priv->volume_button = (_tmp38_ = g_object_ref_sink ((GtkButton*) gtk_button_new ()), _g_object_unref0 (self->priv->volume_button), _tmp38_); +#line 325 "fillmore.vala" + gtk_button_set_image (self->priv->volume_button, GTK_WIDGET (_tmp39_ = g_object_ref_sink ((GtkImage*) gtk_image_new_from_icon_name ("statusarea_volumelevel4", GTK_ICON_SIZE_BUTTON)))); +#line 1157 "fillmore.c" + _g_object_unref0 (_tmp39_); +#line 326 "fillmore.vala" + g_signal_connect_object (self->priv->volume_button, "clicked", (GCallback) _recorder_on_volume_gtk_button_clicked, self, 0); +#line 327 "fillmore.vala" + gtk_container_add (GTK_CONTAINER (buttons), GTK_WIDGET (self->priv->volume_button)); +#line 330 "fillmore.vala" + vbox = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (FALSE, 0)); +#line 331 "fillmore.vala" + gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (menubar), FALSE, FALSE, (guint) 0); +#line 333 "fillmore.vala" + gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (buttons), FALSE, FALSE, (guint) 0); +#line 335 "fillmore.vala" + main_view = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (FALSE, 0)); +#line 337 "fillmore.vala" + self->priv->timeline_library_pane = (_tmp40_ = g_object_ref_sink ((GtkHPaned*) gtk_hpaned_new ()), _g_object_unref0 (self->priv->timeline_library_pane), _tmp40_); +#line 338 "fillmore.vala" + gtk_paned_set_position (GTK_PANED (self->priv->timeline_library_pane), MODEL_PROJECT (self->project)->library_width); +#line 339 "fillmore.vala" + gtk_paned_add1 (GTK_PANED (self->priv->timeline_library_pane), GTK_WIDGET (hbox)); +#line 340 "fillmore.vala" + GTK_PANED (self->priv->timeline_library_pane)->child1_resize = (guint) 1; +#line 341 "fillmore.vala" + gtk_paned_add2 (GTK_PANED (self->priv->timeline_library_pane), GTK_WIDGET (self->priv->library_scrolled)); +#line 342 "fillmore.vala" + GTK_PANED (self->priv->timeline_library_pane)->child2_resize = (guint) 0; +#line 343 "fillmore.vala" + g_signal_connect_object (GTK_PANED (self->priv->timeline_library_pane)->child1, "size-allocate", (GCallback) _recorder_on_library_size_allocate_gtk_widget_size_allocate, self, 0); +#line 346 "fillmore.vala" + gtk_box_pack_start (GTK_BOX (main_view), GTK_WIDGET (self->priv->timeline_library_pane), TRUE, TRUE, (guint) 0); +#line 349 "fillmore.vala" + self->priv->scrollwin = (_tmp41_ = g_object_ref_sink ((HildonPannableArea*) hildon_pannable_area_new ()), _g_object_unref0 (self->priv->scrollwin), _tmp41_); +#line 350 "fillmore.vala" + hildon_pannable_area_add_with_viewport (self->priv->scrollwin, GTK_WIDGET (main_view)); +#line 351 "fillmore.vala" + gtk_container_add (GTK_CONTAINER (vbox), GTK_WIDGET (self->priv->scrollwin)); +#line 353 "fillmore.vala" + gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (vbox)); +#line 355 "fillmore.vala" + recorder_on_view_library (self); +#line 357 "fillmore.vala" + save_graph = GTK_MENU_ITEM (recorder_get_widget (self, self->priv->manager, "/MenuBar/HelpMenu/SaveGraph")); +#line 360 "fillmore.vala" + if (!do_print_graph) { +#line 360 "fillmore.vala" + _tmp42_ = save_graph != NULL; +#line 1203 "fillmore.c" + } else { +#line 360 "fillmore.vala" + _tmp42_ = FALSE; +#line 1207 "fillmore.c" + } +#line 360 "fillmore.vala" + if (_tmp42_) { +#line 361 "fillmore.vala" + gtk_object_destroy (GTK_OBJECT (save_graph)); +#line 1213 "fillmore.c" + } +#line 364 "fillmore.vala" + gtk_window_add_accel_group (GTK_WINDOW (self), gtk_ui_manager_get_accel_group (self->priv->manager)); +#line 365 "fillmore.vala" + gtk_widget_grab_focus (GTK_WIDGET (self->timeline)); +#line 366 "fillmore.vala" + g_signal_connect_object (GTK_WIDGET (self), "delete-event", (GCallback) _recorder_on_delete_event_gtk_widget_delete_event, self, 0); +#line 367 "fillmore.vala" + self->priv->loading = TRUE; +#line 368 "fillmore.vala" + model_project_load (MODEL_PROJECT (self->project), project_file); +#line 369 "fillmore.vala" + if (project_file == NULL) { +#line 370 "fillmore.vala" + recorder_default_track_set (self); +#line 371 "fillmore.vala" + self->priv->loading = FALSE; +#line 1231 "fillmore.c" + } +#line 373 "fillmore.vala" + gst_element_set_state (GST_ELEMENT (MODEL_PROJECT (self->project)->media_engine->pipeline), GST_STATE_PAUSED); +#line 1235 "fillmore.c" + _g_object_unref0 (menubar); + _g_object_unref0 (toolbar); + _g_object_unref0 (hbox); + _g_object_unref0 (buttons); + _g_object_unref0 (vbox); + _g_object_unref0 (main_view); + _g_object_unref0 (save_graph); + return self; +} + + +#line 207 "fillmore.vala" +Recorder* recorder_new (const char* project_file, GError** error) { +#line 207 "fillmore.vala" + return recorder_construct (TYPE_RECORDER, project_file, error); +#line 1251 "fillmore.c" +} + + +#line 376 "fillmore.vala" +static void recorder_default_track_set (Recorder* self) { +#line 1257 "fillmore.c" + ModelAudioTrack* _tmp1_; + char* _tmp0_; + ModelTrack* _tmp2_; +#line 376 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 377 "fillmore.vala" + model_project_add_track (MODEL_PROJECT (self->project), MODEL_TRACK (_tmp1_ = model_audio_track_new (MODEL_PROJECT (self->project), _tmp0_ = recorder_get_default_track_name (self)))); +#line 1265 "fillmore.c" + _g_object_unref0 (_tmp1_); + _g_free0 (_tmp0_); +#line 378 "fillmore.vala" + model_track_set_selected (_tmp2_ = (ModelTrack*) gee_abstract_list_get (GEE_ABSTRACT_LIST (MODEL_PROJECT (self->project)->tracks), 0), TRUE); +#line 1270 "fillmore.c" + _g_object_unref0 (_tmp2_); +} + + +#line 381 "fillmore.vala" +static gint recorder_default_track_number_compare (void* a, void* b) { +#line 1277 "fillmore.c" + gint result = 0; + const char* s1; + const char* s2; + gint i; + gint j; +#line 382 "fillmore.vala" + s1 = (const char*) a; +#line 383 "fillmore.vala" + s2 = (const char*) b; +#line 384 "fillmore.vala" + i = -1; +#line 385 "fillmore.vala" + j = -1; +#line 386 "fillmore.vala" + sscanf (s1, "track %d", &i); +#line 387 "fillmore.vala" + sscanf (s2, "track %d", &j); +#line 388 "fillmore.vala" + g_assert (i > 0); +#line 389 "fillmore.vala" + g_assert (j > 0); +#line 390 "fillmore.vala" + if (i == j) { +#line 1301 "fillmore.c" + result = 0; +#line 391 "fillmore.vala" + return result; +#line 1305 "fillmore.c" + } else { +#line 392 "fillmore.vala" + if (i < j) { +#line 1309 "fillmore.c" + result = -1; +#line 393 "fillmore.vala" + return result; +#line 1313 "fillmore.c" + } else { + result = 1; +#line 395 "fillmore.vala" + return result; +#line 1318 "fillmore.c" + } + } +} + + +#line 381 "fillmore.vala" +static gint _recorder_default_track_number_compare_gcompare_func (void* a, void* b) { +#line 1326 "fillmore.c" + gint result; + result = recorder_default_track_number_compare (a, b); + return result; +} + + +static void _g_list_free_g_free (GList* self) { + g_list_foreach (self, (GFunc) g_free, NULL); + g_list_free (self); +} + + +#line 399 "fillmore.vala" +char* recorder_get_default_track_name (Recorder* self) { +#line 1341 "fillmore.c" + char* result = NULL; + GList* default_track_names; + gint i; +#line 399 "fillmore.vala" + g_return_val_if_fail (IS_RECORDER (self), NULL); +#line 400 "fillmore.vala" + default_track_names = NULL; +#line 1349 "fillmore.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (MODEL_PROJECT (self->project)->tracks)); +#line 401 "fillmore.vala" + while (TRUE) { +#line 1355 "fillmore.c" + ModelTrack* track; +#line 401 "fillmore.vala" + if (!gee_iterator_next (_track_it)) { +#line 401 "fillmore.vala" + break; +#line 1361 "fillmore.c" + } +#line 401 "fillmore.vala" + track = (ModelTrack*) gee_iterator_get (_track_it); +#line 402 "fillmore.vala" + if (g_str_has_prefix (track->display_name, "track ")) { +#line 403 "fillmore.vala" + default_track_names = g_list_append (default_track_names, g_strdup (track->display_name)); +#line 1369 "fillmore.c" + } + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } +#line 406 "fillmore.vala" + default_track_names = g_list_sort (default_track_names, _recorder_default_track_number_compare_gcompare_func); +#line 408 "fillmore.vala" + i = 1; +#line 1379 "fillmore.c" + { + GList* s_collection; + GList* s_it; +#line 409 "fillmore.vala" + s_collection = default_track_names; +#line 1385 "fillmore.c" + for (s_it = s_collection; s_it != NULL; s_it = s_it->next) { + char* s; +#line 409 "fillmore.vala" + s = g_strdup ((const char*) s_it->data); +#line 1390 "fillmore.c" + { + char* track_name; +#line 410 "fillmore.vala" + track_name = g_strdup_printf ("track %d", i); +#line 411 "fillmore.vala" + if (_vala_strcmp0 (s, track_name) != 0) { +#line 1397 "fillmore.c" + result = track_name; + _g_free0 (s); + __g_list_free_g_free0 (default_track_names); +#line 412 "fillmore.vala" + return result; +#line 1403 "fillmore.c" + } +#line 414 "fillmore.vala" + i = i + 1; +#line 1407 "fillmore.c" + _g_free0 (s); + _g_free0 (track_name); + } + } + } + result = g_strdup_printf ("track %d", i); + __g_list_free_g_free0 (default_track_names); +#line 416 "fillmore.vala" + return result; +#line 1417 "fillmore.c" +} + + +#line 419 "fillmore.vala" +static GtkWidget* recorder_get_widget (Recorder* self, GtkUIManager* manager, const char* name) { +#line 1423 "fillmore.c" + GtkWidget* result = NULL; + GtkWidget* widget; +#line 419 "fillmore.vala" + g_return_val_if_fail (IS_RECORDER (self), NULL); +#line 419 "fillmore.vala" + g_return_val_if_fail (GTK_IS_UI_MANAGER (manager), NULL); +#line 419 "fillmore.vala" + g_return_val_if_fail (name != NULL, NULL); +#line 420 "fillmore.vala" + widget = _g_object_ref0 (gtk_ui_manager_get_widget (manager, name)); +#line 421 "fillmore.vala" + if (widget == NULL) { +#line 422 "fillmore.vala" + g_error ("fillmore.vala:422: can't find widget"); +#line 1438 "fillmore.c" + } + result = widget; +#line 423 "fillmore.vala" + return result; +#line 1443 "fillmore.c" +} + + +#line 426 "fillmore.vala" +static void recorder_on_track_move_up (Recorder* self) { +#line 1449 "fillmore.c" + gint index; + gint position; + gint track_ct; +#line 426 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 427 "fillmore.vala" + index = -1; +#line 428 "fillmore.vala" + position = 0; +#line 429 "fillmore.vala" + track_ct = gee_collection_get_size (GEE_COLLECTION (MODEL_PROJECT (self->project)->tracks)); +#line 430 "fillmore.vala" + if (0 < track_ct) { +#line 1463 "fillmore.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (MODEL_PROJECT (self->project)->tracks)); +#line 431 "fillmore.vala" + while (TRUE) { +#line 1469 "fillmore.c" + ModelTrack* track; + ModelTrack* _tmp0_; + gboolean _tmp1_; +#line 431 "fillmore.vala" + if (!gee_iterator_next (_track_it)) { +#line 431 "fillmore.vala" + break; +#line 1477 "fillmore.c" + } +#line 431 "fillmore.vala" + track = (ModelTrack*) gee_iterator_get (_track_it); +#line 432 "fillmore.vala" + index = index + 1; +#line 433 "fillmore.vala" + if ((_tmp1_ = (_tmp0_ = recorder_selected_track (self)) == track, _g_object_unref0 (_tmp0_), _tmp1_)) { +#line 434 "fillmore.vala" + position = index; +#line 1487 "fillmore.c" + } + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } +#line 437 "fillmore.vala" + if (0 < position) { +#line 1495 "fillmore.c" + ModelTrack* _tmp2_; + ModelAudioTrack* track; +#line 438 "fillmore.vala" + track = (_tmp2_ = recorder_selected_track (self), MODEL_IS_AUDIO_TRACK (_tmp2_) ? ((ModelAudioTrack*) _tmp2_) : NULL); +#line 439 "fillmore.vala" + gee_abstract_collection_remove (GEE_ABSTRACT_COLLECTION (MODEL_PROJECT (self->project)->tracks), MODEL_TRACK (track)); +#line 440 "fillmore.vala" + gee_abstract_list_insert (GEE_ABSTRACT_LIST (MODEL_PROJECT (self->project)->tracks), position - 1, MODEL_TRACK (track)); +#line 1504 "fillmore.c" + _g_object_unref0 (track); + } + } +} + + +#line 444 "fillmore.vala" +static void recorder_on_track_move_down (Recorder* self) { +#line 1513 "fillmore.c" + gint index; + gint position; + gint track_ct; +#line 444 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 446 "fillmore.vala" + index = -1; +#line 447 "fillmore.vala" + position = 0; +#line 448 "fillmore.vala" + track_ct = gee_collection_get_size (GEE_COLLECTION (MODEL_PROJECT (self->project)->tracks)); +#line 449 "fillmore.vala" + if (0 < track_ct) { +#line 1527 "fillmore.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (MODEL_PROJECT (self->project)->tracks)); +#line 450 "fillmore.vala" + while (TRUE) { +#line 1533 "fillmore.c" + ModelTrack* track; + ModelTrack* _tmp0_; + gboolean _tmp1_; +#line 450 "fillmore.vala" + if (!gee_iterator_next (_track_it)) { +#line 450 "fillmore.vala" + break; +#line 1541 "fillmore.c" + } +#line 450 "fillmore.vala" + track = (ModelTrack*) gee_iterator_get (_track_it); +#line 451 "fillmore.vala" + index = index + 1; +#line 452 "fillmore.vala" + if ((_tmp1_ = (_tmp0_ = recorder_selected_track (self)) == track, _g_object_unref0 (_tmp0_), _tmp1_)) { +#line 453 "fillmore.vala" + position = index; +#line 1551 "fillmore.c" + } + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } +#line 456 "fillmore.vala" + if ((track_ct - 1) > position) { +#line 1559 "fillmore.c" + ModelTrack* _tmp2_; + ModelAudioTrack* audio_track; +#line 457 "fillmore.vala" + audio_track = (_tmp2_ = recorder_selected_track (self), MODEL_IS_AUDIO_TRACK (_tmp2_) ? ((ModelAudioTrack*) _tmp2_) : NULL); +#line 458 "fillmore.vala" + gee_abstract_collection_remove (GEE_ABSTRACT_COLLECTION (MODEL_PROJECT (self->project)->tracks), MODEL_TRACK (audio_track)); +#line 459 "fillmore.vala" + gee_abstract_list_insert (GEE_ABSTRACT_LIST (MODEL_PROJECT (self->project)->tracks), position + 1, MODEL_TRACK (audio_track)); +#line 1568 "fillmore.c" + _g_object_unref0 (audio_track); + } + } +} + + +#line 463 "fillmore.vala" +static void recorder_on_tracks_scroll_up (Recorder* self) { +#line 1577 "fillmore.c" + gint _tmp0_ = 0; +#line 463 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 472 "fillmore.vala" + if (self->priv->scrollwin_pos_y < 4) { +#line 472 "fillmore.vala" + _tmp0_ = 0; +#line 1585 "fillmore.c" + } else { +#line 472 "fillmore.vala" + _tmp0_ = 64; +#line 1589 "fillmore.c" + } +#line 472 "fillmore.vala" + self->priv->scrollwin_pos_y = self->priv->scrollwin_pos_y - _tmp0_; +#line 473 "fillmore.vala" + hildon_pannable_area_scroll_to (self->priv->scrollwin, 0, self->priv->scrollwin_pos_y); +#line 1595 "fillmore.c" +} + + +#line 475 "fillmore.vala" +static void recorder_on_tracks_scroll_down (Recorder* self) { +#line 475 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 484 "fillmore.vala" + self->priv->scrollwin_pos_y = self->priv->scrollwin_pos_y + 64; +#line 485 "fillmore.vala" + hildon_pannable_area_scroll_to (self->priv->scrollwin, 0, self->priv->scrollwin_pos_y); +#line 1607 "fillmore.c" +} + + +#line 488 "fillmore.vala" +static void recorder_set_sensitive_group (Recorder* self, GtkActionGroup* group, const char* group_path, gboolean sensitive) { +#line 1613 "fillmore.c" + GtkAction* action; +#line 488 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 488 "fillmore.vala" + g_return_if_fail (GTK_IS_ACTION_GROUP (group)); +#line 488 "fillmore.vala" + g_return_if_fail (group_path != NULL); +#line 489 "fillmore.vala" + action = _g_object_ref0 (gtk_action_group_get_action (group, group_path)); +#line 490 "fillmore.vala" + gtk_action_set_sensitive (action, sensitive); +#line 1625 "fillmore.c" + _g_object_unref0 (action); +} + + +#line 493 "fillmore.vala" +static void recorder_on_track_changed (Recorder* self) { +#line 493 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 494 "fillmore.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_track_changed"); +#line 495 "fillmore.vala" + recorder_update_menu (self); +#line 1638 "fillmore.c" +} + + +#line 498 "fillmore.vala" +static void recorder_on_position_changed (Recorder* self) { +#line 498 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 499 "fillmore.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_position_changed"); +#line 500 "fillmore.vala" + recorder_update_menu (self); +#line 1650 "fillmore.c" +} + + +#line 516 "fillmore.vala" +static void _recorder_on_clip_added_model_track_clip_added (ModelTrack* _sender, ModelClip* clip, gboolean select, gpointer self) { +#line 1656 "fillmore.c" + recorder_on_clip_added (self, clip); +} + + +#line 522 "fillmore.vala" +static void _recorder_on_clip_removed_model_track_clip_removed (ModelTrack* _sender, ModelClip* clip, gpointer self) { +#line 1663 "fillmore.c" + recorder_on_clip_removed (self, clip); +} + + +#line 528 "fillmore.vala" +static void _recorder_on_track_selection_changed_model_track_track_selection_changed (ModelTrack* _sender, ModelTrack* track, gpointer self) { +#line 1670 "fillmore.c" + recorder_on_track_selection_changed (self, track); +} + + +#line 503 "fillmore.vala" +static void recorder_on_track_added (Recorder* self, ModelTrack* track) { +#line 503 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 503 "fillmore.vala" + g_return_if_fail (MODEL_IS_TRACK (track)); +#line 504 "fillmore.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_track_added"); +#line 505 "fillmore.vala" + recorder_update_menu (self); +#line 506 "fillmore.vala" + g_signal_connect_object (track, "clip-added", (GCallback) _recorder_on_clip_added_model_track_clip_added, self, 0); +#line 507 "fillmore.vala" + g_signal_connect_object (track, "clip-removed", (GCallback) _recorder_on_clip_removed_model_track_clip_removed, self, 0); +#line 508 "fillmore.vala" + g_signal_connect_object (track, "track-selection-changed", (GCallback) _recorder_on_track_selection_changed_model_track_track_selection_changed, self, 0); +#line 1691 "fillmore.c" +} + + +#line 511 "fillmore.vala" +static void recorder_on_track_removed (Recorder* self, ModelTrack* unused) { +#line 511 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 511 "fillmore.vala" + g_return_if_fail (MODEL_IS_TRACK (unused)); +#line 512 "fillmore.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_track_removed"); +#line 513 "fillmore.vala" + recorder_update_menu (self); +#line 1705 "fillmore.c" +} + + +#line 538 "fillmore.vala" +static void _recorder_on_clip_moved_model_clip_moved (ModelClip* _sender, ModelClip* clip, gpointer self) { +#line 1711 "fillmore.c" + recorder_on_clip_moved (self, clip); +} + + +#line 516 "fillmore.vala" +static void recorder_on_clip_added (Recorder* self, ModelClip* clip) { +#line 516 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 516 "fillmore.vala" + g_return_if_fail (MODEL_IS_CLIP (clip)); +#line 517 "fillmore.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_added"); +#line 518 "fillmore.vala" + g_signal_connect_object (clip, "moved", (GCallback) _recorder_on_clip_moved_model_clip_moved, self, 0); +#line 519 "fillmore.vala" + recorder_update_menu (self); +#line 1728 "fillmore.c" +} + + +#line 522 "fillmore.vala" +static void recorder_on_clip_removed (Recorder* self, ModelClip* clip) { +#line 1734 "fillmore.c" + guint _tmp0_; +#line 522 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 522 "fillmore.vala" + g_return_if_fail (MODEL_IS_CLIP (clip)); +#line 523 "fillmore.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_removed"); +#line 524 "fillmore.vala" + g_signal_parse_name ("moved", MODEL_TYPE_CLIP, &_tmp0_, NULL, FALSE); +#line 524 "fillmore.vala" + g_signal_handlers_disconnect_matched (clip, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, 0, NULL, (GCallback) _recorder_on_clip_moved_model_clip_moved, self); +#line 525 "fillmore.vala" + recorder_update_menu (self); +#line 1748 "fillmore.c" +} + + +#line 528 "fillmore.vala" +static void recorder_on_track_selection_changed (Recorder* self, ModelTrack* track) { +#line 528 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 528 "fillmore.vala" + g_return_if_fail (MODEL_IS_TRACK (track)); +#line 529 "fillmore.vala" + if (model_track_get_is_selected (track)) { +#line 1760 "fillmore.c" + { + GeeIterator* _t_it; + _t_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (MODEL_PROJECT (self->project)->tracks)); +#line 530 "fillmore.vala" + while (TRUE) { +#line 1766 "fillmore.c" + ModelTrack* t; +#line 530 "fillmore.vala" + if (!gee_iterator_next (_t_it)) { +#line 530 "fillmore.vala" + break; +#line 1772 "fillmore.c" + } +#line 530 "fillmore.vala" + t = (ModelTrack*) gee_iterator_get (_t_it); +#line 531 "fillmore.vala" + if (t != track) { +#line 532 "fillmore.vala" + model_track_set_selected (t, FALSE); +#line 1780 "fillmore.c" + } + _g_object_unref0 (t); + } + _g_object_unref0 (_t_it); + } + } +} + + +#line 538 "fillmore.vala" +static void recorder_on_clip_moved (Recorder* self, ModelClip* clip) { +#line 538 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 538 "fillmore.vala" + g_return_if_fail (MODEL_IS_CLIP (clip)); +#line 539 "fillmore.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_moved"); +#line 540 "fillmore.vala" + recorder_update_menu (self); +#line 1800 "fillmore.c" +} + + +#line 543 "fillmore.vala" +static void recorder_on_drag_data_received (Recorder* self, GtkWidget* w, GdkDragContext* context, gint x, gint y, GtkSelectionData* selection_data, guint drag_info, guint time) { +#line 543 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 543 "fillmore.vala" + g_return_if_fail (GTK_IS_WIDGET (w)); +#line 543 "fillmore.vala" + g_return_if_fail (GDK_IS_DRAG_CONTEXT (context)); +#line 543 "fillmore.vala" + g_return_if_fail (selection_data != NULL); +#line 545 "fillmore.vala" + gtk_window_present (GTK_WINDOW (self)); +#line 1816 "fillmore.c" +} + + +#line 548 "fillmore.vala" +static void recorder_update_menu (Recorder* self) { +#line 1822 "fillmore.c" + gboolean library_selected; + gboolean selected; + gboolean playhead_on_clip; + gint number_of_tracks; + gboolean is_stopped; + gboolean one_selected; + gboolean _tmp1_ = FALSE; + gboolean _tmp2_ = FALSE; + gboolean _tmp3_ = FALSE; + gboolean _tmp4_ = FALSE; + gboolean _tmp5_ = FALSE; + gboolean _tmp6_ = FALSE; + gboolean _tmp7_ = FALSE; + gboolean _tmp8_ = FALSE; + gboolean _tmp9_ = FALSE; + gboolean _tmp10_ = FALSE; + gboolean _tmp11_ = FALSE; + gboolean _tmp12_ = FALSE; + gboolean _tmp13_ = FALSE; +#line 548 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 549 "fillmore.vala" + library_selected = clip_library_view_has_selection (self->priv->library); +#line 550 "fillmore.vala" + selected = time_line_is_clip_selected (self->timeline); +#line 551 "fillmore.vala" + playhead_on_clip = model_project_playhead_on_clip (MODEL_PROJECT (self->project)); +#line 552 "fillmore.vala" + number_of_tracks = gee_collection_get_size (GEE_COLLECTION (MODEL_PROJECT (self->project)->tracks)); +#line 553 "fillmore.vala" + is_stopped = transport_delegate_is_stopped (TRANSPORT_DELEGATE (self)); +#line 554 "fillmore.vala" + one_selected = FALSE; +#line 555 "fillmore.vala" + if (library_selected) { +#line 1858 "fillmore.c" + GeeArrayList* _tmp0_; +#line 556 "fillmore.vala" + one_selected = gee_collection_get_size (GEE_COLLECTION (_tmp0_ = clip_library_view_get_selected_files (self->priv->library))) == 1; +#line 1862 "fillmore.c" + _g_object_unref0 (_tmp0_); + } else { +#line 557 "fillmore.vala" + if (selected) { +#line 558 "fillmore.vala" + one_selected = gee_collection_get_size (GEE_COLLECTION (self->timeline->selected_clips)) == 1; +#line 1869 "fillmore.c" + } + } +#line 562 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "NewProject", is_stopped); +#line 563 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "Open", is_stopped); +#line 564 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "Save", is_stopped); +#line 565 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "SaveAs", is_stopped); +#line 566 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "Settings", is_stopped); +#line 567 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "Export", model_project_can_export (MODEL_PROJECT (self->project))); +#line 568 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "Quit", !model_project_transport_is_recording (MODEL_PROJECT (self->project))); +#line 571 "fillmore.vala" + if (is_stopped) { +#line 571 "fillmore.vala" + _tmp1_ = model_undo_manager_get_can_undo (MODEL_PROJECT (self->project)->undo_manager); +#line 1890 "fillmore.c" + } else { +#line 571 "fillmore.vala" + _tmp1_ = FALSE; +#line 1894 "fillmore.c" + } +#line 571 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "Undo", _tmp1_); +#line 572 "fillmore.vala" + if (is_stopped) { +#line 572 "fillmore.vala" + _tmp2_ = selected; +#line 1902 "fillmore.c" + } else { +#line 572 "fillmore.vala" + _tmp2_ = FALSE; +#line 1906 "fillmore.c" + } +#line 572 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "Copy", _tmp2_); +#line 573 "fillmore.vala" + if (is_stopped) { +#line 573 "fillmore.vala" + _tmp3_ = selected; +#line 1914 "fillmore.c" + } else { +#line 573 "fillmore.vala" + _tmp3_ = FALSE; +#line 1918 "fillmore.c" + } +#line 573 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "Cut", _tmp3_); +#line 574 "fillmore.vala" + if (gee_collection_get_size (GEE_COLLECTION (self->timeline->clipboard->clips)) != 0) { +#line 574 "fillmore.vala" + _tmp4_ = is_stopped; +#line 1926 "fillmore.c" + } else { +#line 574 "fillmore.vala" + _tmp4_ = FALSE; +#line 1930 "fillmore.c" + } +#line 574 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "Paste", _tmp4_); +#line 575 "fillmore.vala" + if (selected) { +#line 575 "fillmore.vala" + _tmp6_ = TRUE; +#line 1938 "fillmore.c" + } else { +#line 575 "fillmore.vala" + _tmp6_ = library_selected; +#line 1942 "fillmore.c" + } +#line 575 "fillmore.vala" + if (_tmp6_) { +#line 575 "fillmore.vala" + _tmp5_ = is_stopped; +#line 1948 "fillmore.c" + } else { +#line 575 "fillmore.vala" + _tmp5_ = FALSE; +#line 1952 "fillmore.c" + } +#line 575 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "Delete", _tmp5_); +#line 577 "fillmore.vala" + if (selected) { +#line 577 "fillmore.vala" + _tmp8_ = playhead_on_clip; +#line 1960 "fillmore.c" + } else { +#line 577 "fillmore.vala" + _tmp8_ = FALSE; +#line 1964 "fillmore.c" + } +#line 577 "fillmore.vala" + if (_tmp8_) { +#line 577 "fillmore.vala" + _tmp7_ = is_stopped; +#line 1970 "fillmore.c" + } else { +#line 577 "fillmore.vala" + _tmp7_ = FALSE; +#line 1974 "fillmore.c" + } +#line 576 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "SplitAtPlayhead", _tmp7_); +#line 579 "fillmore.vala" + if (selected) { +#line 579 "fillmore.vala" + _tmp10_ = playhead_on_clip; +#line 1982 "fillmore.c" + } else { +#line 579 "fillmore.vala" + _tmp10_ = FALSE; +#line 1986 "fillmore.c" + } +#line 579 "fillmore.vala" + if (_tmp10_) { +#line 579 "fillmore.vala" + _tmp9_ = is_stopped; +#line 1992 "fillmore.c" + } else { +#line 579 "fillmore.vala" + _tmp9_ = FALSE; +#line 1996 "fillmore.c" + } +#line 578 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "TrimToPlayhead", _tmp9_); +#line 580 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "ClipProperties", one_selected); +#line 583 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "ZoomProject", model_project_get_length (MODEL_PROJECT (self->project)) != 0); +#line 586 "fillmore.vala" + if (number_of_tracks > 0) { +#line 586 "fillmore.vala" + _tmp11_ = is_stopped; +#line 2008 "fillmore.c" + } else { +#line 586 "fillmore.vala" + _tmp11_ = FALSE; +#line 2012 "fillmore.c" + } +#line 586 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "Rename", _tmp11_); +#line 587 "fillmore.vala" + if (number_of_tracks > 0) { +#line 587 "fillmore.vala" + _tmp12_ = is_stopped; +#line 2020 "fillmore.c" + } else { +#line 587 "fillmore.vala" + _tmp12_ = FALSE; +#line 2024 "fillmore.c" + } +#line 587 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "DeleteTrack", _tmp12_); +#line 588 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "NewTrack", is_stopped); +#line 591 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "Play", TRUE); +#line 592 "fillmore.vala" + if (number_of_tracks > 0) { +#line 592 "fillmore.vala" + _tmp13_ = is_stopped; +#line 2036 "fillmore.c" + } else { +#line 592 "fillmore.vala" + _tmp13_ = FALSE; +#line 2040 "fillmore.c" + } +#line 592 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "Record", _tmp13_); +#line 2044 "fillmore.c" +} + + +#line 595 "fillmore.vala" +ModelTrack* recorder_selected_track (Recorder* self) { +#line 2050 "fillmore.c" + ModelTrack* result = NULL; +#line 595 "fillmore.vala" + g_return_val_if_fail (IS_RECORDER (self), NULL); +#line 2054 "fillmore.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (MODEL_PROJECT (self->project)->tracks)); +#line 596 "fillmore.vala" + while (TRUE) { +#line 2060 "fillmore.c" + ModelTrack* track; +#line 596 "fillmore.vala" + if (!gee_iterator_next (_track_it)) { +#line 596 "fillmore.vala" + break; +#line 2066 "fillmore.c" + } +#line 596 "fillmore.vala" + track = (ModelTrack*) gee_iterator_get (_track_it); +#line 597 "fillmore.vala" + if (model_track_get_is_selected (track)) { +#line 2072 "fillmore.c" + result = track; + _g_object_unref0 (_track_it); +#line 598 "fillmore.vala" + return result; +#line 2077 "fillmore.c" + } + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } +#line 601 "fillmore.vala" + g_error ("fillmore.vala:601: can't find selected track"); +#line 2085 "fillmore.c" + result = NULL; +#line 602 "fillmore.vala" + return result; +#line 2089 "fillmore.c" +} + + +#line 605 "fillmore.vala" +void recorder_scroll_to_beginning (Recorder* self) { +#line 605 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 606 "fillmore.vala" + gtk_adjustment_set_value (self->priv->h_adjustment, 0.0); +#line 2099 "fillmore.c" +} + + +#line 609 "fillmore.vala" +void recorder_page_to_time (Recorder* self, gint64 time) { +#line 2105 "fillmore.c" + double location_in_window; + gint window_width; + gboolean _tmp0_ = FALSE; +#line 609 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 610 "fillmore.vala" + location_in_window = model_time_system_time_to_xpos (self->timeline->provider, time) - gtk_adjustment_get_value (self->priv->h_adjustment); +#line 611 "fillmore.vala" + window_width = GTK_WIDGET (gtk_widget_get_parent (GTK_WIDGET (self->timeline)))->allocation.width; +#line 612 "fillmore.vala" + if (location_in_window > (0.9 * window_width)) { +#line 612 "fillmore.vala" + _tmp0_ = TRUE; +#line 2119 "fillmore.c" + } else { +#line 613 "fillmore.vala" + _tmp0_ = location_in_window < (0.1 * window_width); +#line 2123 "fillmore.c" + } +#line 612 "fillmore.vala" + if (_tmp0_) { +#line 614 "fillmore.vala" + recorder_scroll_to_time (self, time); +#line 2129 "fillmore.c" + } +} + + +#line 618 "fillmore.vala" +void recorder_scroll_to_time (Recorder* self, gint64 time) { +#line 2136 "fillmore.c" + gint new_adjustment; + gint window_width; + gint max_value; +#line 618 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 619 "fillmore.vala" + new_adjustment = model_time_system_time_to_xpos (self->timeline->provider, time); +#line 620 "fillmore.vala" + window_width = GTK_WIDGET (gtk_widget_get_parent (GTK_WIDGET (self->timeline)))->allocation.width; +#line 621 "fillmore.vala" + if (new_adjustment < GTK_WIDGET (gtk_widget_get_parent (GTK_WIDGET (self->timeline)))->allocation.width) { +#line 622 "fillmore.vala" + new_adjustment = 0; +#line 2150 "fillmore.c" + } else { +#line 624 "fillmore.vala" + new_adjustment = new_adjustment - (window_width / 2); +#line 2154 "fillmore.c" + } +#line 627 "fillmore.vala" + max_value = (gint) (gtk_adjustment_get_upper (self->priv->h_adjustment) - GTK_WIDGET (self->priv->timeline_scrolled)->allocation.width); +#line 628 "fillmore.vala" + if (new_adjustment > max_value) { +#line 629 "fillmore.vala" + new_adjustment = max_value; +#line 2162 "fillmore.c" + } +#line 632 "fillmore.vala" + gtk_adjustment_set_value (self->priv->h_adjustment, (double) new_adjustment); +#line 2166 "fillmore.c" +} + + +#line 635 "fillmore.vala" +void recorder_scroll_to_end (Recorder* self) { +#line 635 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 636 "fillmore.vala" + recorder_scroll_to_time (self, model_project_get_length (MODEL_PROJECT (self->project))); +#line 2176 "fillmore.c" +} + + +#line 639 "fillmore.vala" +static gint recorder_sgn (gint x) { +#line 2182 "fillmore.c" + gint result = 0; + gint _tmp0_ = 0; +#line 640 "fillmore.vala" + if (x == 0) { +#line 2187 "fillmore.c" + result = 0; +#line 641 "fillmore.vala" + return result; +#line 2191 "fillmore.c" + } +#line 642 "fillmore.vala" + if (x < 0) { +#line 642 "fillmore.vala" + _tmp0_ = -1; +#line 2197 "fillmore.c" + } else { +#line 642 "fillmore.vala" + _tmp0_ = 1; +#line 2201 "fillmore.c" + } + result = _tmp0_; +#line 642 "fillmore.vala" + return result; +#line 2206 "fillmore.c" +} + + +#line 645 "fillmore.vala" +void recorder_scroll_toward_center (Recorder* self, gint xpos) { +#line 2212 "fillmore.c" + gint page_size; + gint diff; + gint d; + gint x; + gint max_value; +#line 645 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 646 "fillmore.vala" + if (self->priv->cursor_pos == (-1)) { +#line 647 "fillmore.vala" + self->priv->cursor_pos = xpos - ((gint) gtk_adjustment_get_value (self->priv->h_adjustment)); +#line 2224 "fillmore.c" + } +#line 652 "fillmore.vala" + page_size = (gint) gtk_adjustment_get_page_size (self->priv->h_adjustment); +#line 653 "fillmore.vala" + diff = (page_size / 2) - self->priv->cursor_pos; +#line 654 "fillmore.vala" + d = recorder_sgn (diff) * ((gint) sqrt ((double) abs (diff))); +#line 655 "fillmore.vala" + self->priv->cursor_pos = self->priv->cursor_pos + d; +#line 656 "fillmore.vala" + x = MAX (0, xpos - self->priv->cursor_pos); +#line 657 "fillmore.vala" + max_value = (gint) (gtk_adjustment_get_upper (self->priv->h_adjustment) - GTK_WIDGET (self->priv->timeline_scrolled)->allocation.width); +#line 658 "fillmore.vala" + if (x > max_value) { +#line 659 "fillmore.vala" + x = max_value; +#line 2242 "fillmore.c" + } +#line 661 "fillmore.vala" + gtk_adjustment_set_value (self->priv->h_adjustment, (double) x); +#line 2246 "fillmore.c" +} + + +#line 664 "fillmore.vala" +static gboolean recorder_real_key_press_event (GtkWidget* base, GdkEventKey* event) { +#line 2252 "fillmore.c" + Recorder * self; + gboolean result = FALSE; + self = RECORDER (base); +#line 665 "fillmore.vala" + switch ((*event).keyval) { +#line 2258 "fillmore.c" + case GDK_KP_Enter: + case GDK_Return: + { +#line 668 "fillmore.vala" + if (model_project_transport_is_recording (MODEL_PROJECT (self->project))) { +#line 669 "fillmore.vala" + break; +#line 2266 "fillmore.c" + } +#line 671 "fillmore.vala" + if (((*event).state & GDK_SHIFT_ALT_CONTROL_MASK) != 0) { +#line 2270 "fillmore.c" + result = GTK_WIDGET_CLASS (recorder_parent_class)->key_press_event (GTK_WIDGET (GTK_WINDOW (self)), event); +#line 672 "fillmore.vala" + return result; +#line 2274 "fillmore.c" + } +#line 673 "fillmore.vala" + recorder_on_rewind (self); +#line 674 "fillmore.vala" + break; +#line 2280 "fillmore.c" + } + case GDK_Left: + { +#line 676 "fillmore.vala" + if (model_project_transport_is_recording (MODEL_PROJECT (self->project))) { +#line 677 "fillmore.vala" + break; +#line 2288 "fillmore.c" + } +#line 679 "fillmore.vala" + if (((*event).state & GDK_CONTROL_MASK) != 0) { +#line 680 "fillmore.vala" + model_project_go_previous (MODEL_PROJECT (self->project)); +#line 2294 "fillmore.c" + } else { +#line 682 "fillmore.vala" + view_media_engine_go (MODEL_PROJECT (self->project)->media_engine, model_project_transport_get_position (MODEL_PROJECT (self->project)) - GST_SECOND); +#line 2298 "fillmore.c" + } +#line 684 "fillmore.vala" + recorder_page_to_time (self, model_project_transport_get_position (MODEL_PROJECT (self->project))); +#line 685 "fillmore.vala" + break; +#line 2304 "fillmore.c" + } + case GDK_Right: + { +#line 687 "fillmore.vala" + if (model_project_transport_is_recording (MODEL_PROJECT (self->project))) { +#line 688 "fillmore.vala" + break; +#line 2312 "fillmore.c" + } +#line 690 "fillmore.vala" + if (((*event).state & GDK_CONTROL_MASK) != 0) { +#line 691 "fillmore.vala" + model_project_go_next (MODEL_PROJECT (self->project)); +#line 2318 "fillmore.c" + } else { +#line 693 "fillmore.vala" + view_media_engine_go (MODEL_PROJECT (self->project)->media_engine, model_project_transport_get_position (MODEL_PROJECT (self->project)) + GST_SECOND); +#line 2322 "fillmore.c" + } +#line 695 "fillmore.vala" + recorder_page_to_time (self, model_project_transport_get_position (MODEL_PROJECT (self->project))); +#line 696 "fillmore.vala" + break; +#line 2328 "fillmore.c" + } + case GDK_KP_Add: + case GDK_equal: + case GDK_plus: + { +#line 700 "fillmore.vala" + recorder_on_zoom_in (self); +#line 701 "fillmore.vala" + break; +#line 2338 "fillmore.c" + } + case GDK_KP_Subtract: + case GDK_minus: + case GDK_underscore: + { +#line 705 "fillmore.vala" + recorder_on_zoom_out (self); +#line 706 "fillmore.vala" + break; +#line 2348 "fillmore.c" + } + default: + { + result = GTK_WIDGET_CLASS (recorder_parent_class)->key_press_event (GTK_WIDGET (GTK_WINDOW (self)), event); +#line 708 "fillmore.vala" + return result; +#line 2355 "fillmore.c" + } + } + result = TRUE; +#line 710 "fillmore.vala" + return result; +#line 2361 "fillmore.c" +} + + +#line 714 "fillmore.vala" +static void recorder_on_export (Recorder* self) { +#line 2367 "fillmore.c" + GError * _inner_error_; + char* filename; +#line 714 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 2372 "fillmore.c" + _inner_error_ = NULL; +#line 715 "fillmore.vala" + filename = NULL; +#line 716 "fillmore.vala" + if (dialog_utils_save (GTK_WINDOW (self), "Export", FALSE, RECORDER_export_filters, G_N_ELEMENTS (RECORDER_export_filters), &filename)) { +#line 2378 "fillmore.c" + { + MultiFileProgress* _tmp0_; + GstCaps* _tmp1_; + ViewOggVorbisExport* _tmp2_; + ViewOggVorbisExport* _tmp3_; + ViewOggVorbisExport* _tmp4_; +#line 718 "fillmore.vala" + _tmp0_ = g_object_ref_sink (multi_file_progress_new (GTK_WINDOW (self), 1, "Export", MULTI_FILE_PROGRESS_INTERFACE (MODEL_PROJECT (self->project)->media_engine))); +#line 2387 "fillmore.c" + _g_object_unref0 (_tmp0_); +#line 719 "fillmore.vala" + view_media_engine_disconnect_output (MODEL_PROJECT (self->project)->media_engine, VIEW_MEDIA_CONNECTOR (self->priv->audio_output)); +#line 720 "fillmore.vala" + _tmp3_ = (_tmp2_ = view_ogg_vorbis_export_new (VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Audio, filename, _tmp1_ = view_media_engine_get_project_audio_export_caps (MODEL_PROJECT (self->project)->media_engine), &_inner_error_), _gst_caps_unref0 (_tmp1_), _tmp2_); +#line 2393 "fillmore.c" + if (_inner_error_ != NULL) { + goto __catch5_g_error; + } +#line 720 "fillmore.vala" + self->priv->audio_export = (_tmp4_ = _tmp3_, _g_object_unref0 (self->priv->audio_export), _tmp4_); +#line 722 "fillmore.vala" + view_media_engine_connect_output (MODEL_PROJECT (self->project)->media_engine, VIEW_MEDIA_CONNECTOR (self->priv->audio_export)); +#line 723 "fillmore.vala" + view_media_engine_start_export (MODEL_PROJECT (self->project)->media_engine, filename); +#line 2403 "fillmore.c" + } + goto __finally5; + __catch5_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { +#line 725 "fillmore.vala" + recorder_do_error_dialog ("Could not export file", e->message); +#line 2414 "fillmore.c" + _g_error_free0 (e); + } + } + __finally5: + if (_inner_error_ != NULL) { + _g_free0 (filename); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } + } + _g_free0 (filename); +} + + +#line 730 "fillmore.vala" +static void recorder_on_post_export (Recorder* self, gboolean canceled) { +#line 2432 "fillmore.c" + ViewOggVorbisExport* _tmp1_; +#line 730 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 731 "fillmore.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_post_export"); +#line 732 "fillmore.vala" + view_media_engine_disconnect_output (MODEL_PROJECT (self->project)->media_engine, VIEW_MEDIA_CONNECTOR (self->priv->audio_export)); +#line 733 "fillmore.vala" + view_media_engine_connect_output (MODEL_PROJECT (self->project)->media_engine, VIEW_MEDIA_CONNECTOR (self->priv->audio_output)); +#line 735 "fillmore.vala" + if (canceled) { +#line 2444 "fillmore.c" + char* _tmp0_; +#line 736 "fillmore.vala" + g_remove (_tmp0_ = view_ogg_vorbis_export_get_filename (self->priv->audio_export)); +#line 2448 "fillmore.c" + _g_free0 (_tmp0_); + } +#line 739 "fillmore.vala" + self->priv->audio_export = (_tmp1_ = NULL, _g_object_unref0 (self->priv->audio_export), _tmp1_); +#line 2453 "fillmore.c" +} + + +#line 742 "fillmore.vala" +static void _recorder_on_project_new_finished_closing_recorder_finished_closing (Recorder* _sender, gboolean project_did_close, gpointer self) { +#line 2459 "fillmore.c" + recorder_on_project_new_finished_closing (self, project_did_close); +} + + +#line 742 "fillmore.vala" +static void recorder_on_project_new_finished_closing (Recorder* self, gboolean project_did_close) { +#line 2466 "fillmore.c" + guint _tmp0_; + guint _tmp1_; +#line 742 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 743 "fillmore.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_project_new_finished_closing"); +#line 744 "fillmore.vala" + g_signal_parse_name ("closed", MODEL_TYPE_PROJECT, &_tmp0_, NULL, FALSE); +#line 744 "fillmore.vala" + g_signal_handlers_disconnect_matched (MODEL_PROJECT (self->project), G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, 0, NULL, (GCallback) _recorder_on_project_close_model_project_closed, self); +#line 745 "fillmore.vala" + g_signal_parse_name ("finished-closing", TYPE_RECORDER, &_tmp1_, NULL, FALSE); +#line 745 "fillmore.vala" + g_signal_handlers_disconnect_matched (self, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp1_, 0, NULL, (GCallback) _recorder_on_project_new_finished_closing_recorder_finished_closing, self); +#line 746 "fillmore.vala" + if (project_did_close) { +#line 747 "fillmore.vala" + view_media_engine_set_play_state (MODEL_PROJECT (self->project)->media_engine, PLAY_STATE_LOADING); +#line 748 "fillmore.vala" + model_project_load (MODEL_PROJECT (self->project), NULL); +#line 749 "fillmore.vala" + recorder_default_track_set (self); +#line 750 "fillmore.vala" + gst_element_set_state (GST_ELEMENT (MODEL_PROJECT (self->project)->media_engine->pipeline), GST_STATE_PAUSED); +#line 751 "fillmore.vala" + model_undo_manager_reset (MODEL_PROJECT (self->project)->undo_manager); +#line 2493 "fillmore.c" + } +} + + +#line 755 "fillmore.vala" +static void recorder_on_project_new (Recorder* self) { +#line 755 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 756 "fillmore.vala" + gee_abstract_collection_clear (GEE_ABSTRACT_COLLECTION (self->priv->load_errors)); +#line 757 "fillmore.vala" + g_signal_connect_object (MODEL_PROJECT (self->project), "closed", (GCallback) _recorder_on_project_close_model_project_closed, self, 0); +#line 758 "fillmore.vala" + g_signal_connect_object (self, "finished-closing", (GCallback) _recorder_on_project_new_finished_closing_recorder_finished_closing, self, 0); +#line 759 "fillmore.vala" + model_project_close (MODEL_PROJECT (self->project)); +#line 2510 "fillmore.c" +} + + +#line 762 "fillmore.vala" +static void _recorder_on_project_open_finished_closing_recorder_finished_closing (Recorder* _sender, gboolean project_did_close, gpointer self) { +#line 2516 "fillmore.c" + recorder_on_project_open_finished_closing (self, project_did_close); +} + + +static void _g_slist_free_g_free (GSList* self) { + g_slist_foreach (self, (GFunc) g_free, NULL); + g_slist_free (self); +} + + +#line 762 "fillmore.vala" +static void recorder_on_project_open_finished_closing (Recorder* self, gboolean project_did_close) { +#line 2529 "fillmore.c" + guint _tmp0_; + guint _tmp1_; +#line 762 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 763 "fillmore.vala" + g_signal_parse_name ("closed", MODEL_TYPE_PROJECT, &_tmp0_, NULL, FALSE); +#line 763 "fillmore.vala" + g_signal_handlers_disconnect_matched (MODEL_PROJECT (self->project), G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, 0, NULL, (GCallback) _recorder_on_project_close_model_project_closed, self); +#line 764 "fillmore.vala" + g_signal_parse_name ("finished-closing", TYPE_RECORDER, &_tmp1_, NULL, FALSE); +#line 764 "fillmore.vala" + g_signal_handlers_disconnect_matched (self, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp1_, 0, NULL, (GCallback) _recorder_on_project_open_finished_closing_recorder_finished_closing, self); +#line 765 "fillmore.vala" + if (project_did_close) { +#line 2544 "fillmore.c" + GSList* filenames; + GSList* _tmp4_; + gboolean _tmp3_; + GSList* _tmp2_ = NULL; + filenames = NULL; +#line 767 "fillmore.vala" + if ((_tmp3_ = dialog_utils_open (GTK_WINDOW (self), RECORDER_filters, G_N_ELEMENTS (RECORDER_filters), FALSE, FALSE, &_tmp2_), filenames = (_tmp4_ = _tmp2_, __g_slist_free_g_free0 (filenames), _tmp4_), _tmp3_)) { +#line 768 "fillmore.vala" + self->priv->loading = TRUE; +#line 769 "fillmore.vala" + model_project_load (MODEL_PROJECT (self->project), (const char*) filenames->data); +#line 2556 "fillmore.c" + } + __g_slist_free_g_free0 (filenames); + } +} + + +#line 774 "fillmore.vala" +static void recorder_on_project_open (Recorder* self) { +#line 774 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 775 "fillmore.vala" + gee_abstract_collection_clear (GEE_ABSTRACT_COLLECTION (self->priv->load_errors)); +#line 776 "fillmore.vala" + g_signal_connect_object (MODEL_PROJECT (self->project), "closed", (GCallback) _recorder_on_project_close_model_project_closed, self, 0); +#line 777 "fillmore.vala" + g_signal_connect_object (self, "finished-closing", (GCallback) _recorder_on_project_open_finished_closing_recorder_finished_closing, self, 0); +#line 778 "fillmore.vala" + model_project_close (MODEL_PROJECT (self->project)); +#line 2575 "fillmore.c" +} + + +#line 781 "fillmore.vala" +static void recorder_on_project_save_as (Recorder* self) { +#line 781 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 782 "fillmore.vala" + recorder_save_dialog (self); +#line 2585 "fillmore.c" +} + + +#line 785 "fillmore.vala" +static void recorder_on_project_save (Recorder* self) { +#line 785 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 786 "fillmore.vala" + recorder_do_save (self); +#line 2595 "fillmore.c" +} + + +#line 789 "fillmore.vala" +static void _recorder_on_save_new_file_finished_closing_recorder_finished_closing (Recorder* _sender, gboolean project_did_close, gpointer self) { +#line 2601 "fillmore.c" + recorder_on_save_new_file_finished_closing (self, project_did_close); +} + + +#line 789 "fillmore.vala" +static void recorder_on_save_new_file_finished_closing (Recorder* self, gboolean did_close) { +#line 2608 "fillmore.c" + guint _tmp0_; + guint _tmp1_; + char* _tmp2_; +#line 789 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 790 "fillmore.vala" + g_signal_parse_name ("closed", MODEL_TYPE_PROJECT, &_tmp0_, NULL, FALSE); +#line 790 "fillmore.vala" + g_signal_handlers_disconnect_matched (MODEL_PROJECT (self->project), G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, 0, NULL, (GCallback) _recorder_on_project_close_model_project_closed, self); +#line 791 "fillmore.vala" + g_signal_parse_name ("finished-closing", TYPE_RECORDER, &_tmp1_, NULL, FALSE); +#line 791 "fillmore.vala" + g_signal_handlers_disconnect_matched (self, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp1_, 0, NULL, (GCallback) _recorder_on_save_new_file_finished_closing_recorder_finished_closing, self); +#line 792 "fillmore.vala" + model_project_load (MODEL_PROJECT (self->project), _tmp2_ = model_project_get_project_file (MODEL_PROJECT (self->project))); +#line 2624 "fillmore.c" + _g_free0 (_tmp2_); +} + + +#line 795 "fillmore.vala" +static gboolean recorder_do_save (Recorder* self) { +#line 2631 "fillmore.c" + gboolean result = FALSE; + char* _tmp0_; + gboolean _tmp1_; +#line 795 "fillmore.vala" + g_return_val_if_fail (IS_RECORDER (self), FALSE); +#line 796 "fillmore.vala" + if ((_tmp1_ = (_tmp0_ = model_project_get_project_file (MODEL_PROJECT (self->project))) != NULL, _g_free0 (_tmp0_), _tmp1_)) { +#line 797 "fillmore.vala" + model_project_save (MODEL_PROJECT (self->project), NULL); +#line 2641 "fillmore.c" + result = TRUE; +#line 798 "fillmore.vala" + return result; +#line 2645 "fillmore.c" + } else { + result = recorder_save_dialog (self); +#line 801 "fillmore.vala" + return result; +#line 2650 "fillmore.c" + } +} + + +#line 805 "fillmore.vala" +static gboolean recorder_save_dialog (Recorder* self) { +#line 2657 "fillmore.c" + gboolean result = FALSE; + char* _tmp0_; + gboolean _tmp1_; + gboolean saving_new_file; + char* filename; + char* _tmp2_; + gboolean _tmp3_; + gboolean create_directory; +#line 805 "fillmore.vala" + g_return_val_if_fail (IS_RECORDER (self), FALSE); +#line 806 "fillmore.vala" + saving_new_file = (_tmp1_ = (_tmp0_ = model_project_get_project_file (MODEL_PROJECT (self->project))) == NULL, _g_free0 (_tmp0_), _tmp1_); +#line 808 "fillmore.vala" + filename = model_project_get_project_file (MODEL_PROJECT (self->project)); +#line 809 "fillmore.vala" + create_directory = (_tmp3_ = (_tmp2_ = model_project_get_project_file (MODEL_PROJECT (self->project))) == NULL, _g_free0 (_tmp2_), _tmp3_); +#line 810 "fillmore.vala" + if (dialog_utils_save (GTK_WINDOW (self), "Save Project", create_directory, RECORDER_filters, G_N_ELEMENTS (RECORDER_filters), &filename)) { +#line 2676 "fillmore.c" + gboolean _tmp4_ = FALSE; +#line 811 "fillmore.vala" + model_project_save (MODEL_PROJECT (self->project), filename); +#line 812 "fillmore.vala" + if (saving_new_file) { +#line 2682 "fillmore.c" + char* _tmp5_; +#line 812 "fillmore.vala" + _tmp4_ = (_tmp5_ = model_project_get_project_file (MODEL_PROJECT (self->project))) != NULL; +#line 2686 "fillmore.c" + _g_free0 (_tmp5_); + } else { +#line 812 "fillmore.vala" + _tmp4_ = FALSE; +#line 2691 "fillmore.c" + } +#line 812 "fillmore.vala" + if (_tmp4_) { +#line 813 "fillmore.vala" + g_signal_connect_object (MODEL_PROJECT (self->project), "closed", (GCallback) _recorder_on_project_close_model_project_closed, self, 0); +#line 814 "fillmore.vala" + g_signal_connect_object (self, "finished-closing", (GCallback) _recorder_on_save_new_file_finished_closing_recorder_finished_closing, self, 0); +#line 815 "fillmore.vala" + model_project_close (MODEL_PROJECT (self->project)); +#line 2701 "fillmore.c" + } + result = TRUE; + _g_free0 (filename); +#line 817 "fillmore.vala" + return result; +#line 2707 "fillmore.c" + } + result = FALSE; + _g_free0 (filename); +#line 819 "fillmore.vala" + return result; +#line 2713 "fillmore.c" +} + + +#line 822 "fillmore.vala" +static void recorder_on_properties (Recorder* self) { +#line 2719 "fillmore.c" + GError * _inner_error_; + GtkBuilder* builder; + ProjectProperties* properties; + gint response; +#line 822 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 2726 "fillmore.c" + _inner_error_ = NULL; +#line 823 "fillmore.vala" + builder = gtk_builder_new (); +#line 2730 "fillmore.c" + { + char* _tmp2_; + char* _tmp1_; + GFile* _tmp0_; +#line 825 "fillmore.vala" + gtk_builder_add_from_file (builder, _tmp2_ = g_strconcat (_tmp1_ = g_file_get_path (_tmp0_ = app_dirs_get_exec_dir ()), "/resources/fillmore.glade", NULL), &_inner_error_); +#line 2737 "fillmore.c" + _g_free0 (_tmp2_); + _g_free0 (_tmp1_); + _g_object_unref0 (_tmp0_); + if (_inner_error_ != NULL) { + goto __catch6_g_error; + } + } + goto __finally6; + __catch6_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { +#line 829 "fillmore.vala" + fprintf (stdout, "%s\n", e->message); +#line 2754 "fillmore.c" + _g_error_free0 (e); + _g_object_unref0 (builder); +#line 830 "fillmore.vala" + return; +#line 2759 "fillmore.c" + } + } + __finally6: + if (_inner_error_ != NULL) { + _g_object_unref0 (builder); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } +#line 832 "fillmore.vala" + gtk_builder_connect_signals (builder, NULL); +#line 833 "fillmore.vala" + properties = _g_object_ref0 (PROJECT_PROPERTIES (gtk_builder_get_object (builder, "projectproperties1"))); +#line 834 "fillmore.vala" + project_properties_setup (properties, MODEL_PROJECT (self->project), builder); +#line 836 "fillmore.vala" + response = gtk_dialog_run (GTK_DIALOG (properties)); +#line 837 "fillmore.vala" + if (response == GTK_RESPONSE_APPLY) { +#line 2779 "fillmore.c" + char* description; + Fraction _tmp4_; + Fraction _tmp3_ = {0}; +#line 838 "fillmore.vala" + description = g_strdup ("Set Project Properties"); +#line 839 "fillmore.vala" + model_undo_manager_start_transaction (MODEL_PROJECT (self->project)->undo_manager, description); +#line 840 "fillmore.vala" + model_project_set_bpm (MODEL_PROJECT (self->project), project_properties_get_tempo (properties)); +#line 841 "fillmore.vala" + model_project_set_time_signature (MODEL_PROJECT (self->project), (_tmp4_ = (project_properties_get_time_signature (properties, &_tmp3_), _tmp3_), &_tmp4_)); +#line 842 "fillmore.vala" + MODEL_PROJECT (self->project)->click_during_record = project_properties_during_record (properties); +#line 843 "fillmore.vala" + MODEL_PROJECT (self->project)->click_during_play = project_properties_during_play (properties); +#line 844 "fillmore.vala" + MODEL_PROJECT (self->project)->click_volume = project_properties_get_click_volume (properties); +#line 845 "fillmore.vala" + model_undo_manager_end_transaction (MODEL_PROJECT (self->project)->undo_manager, description); +#line 2799 "fillmore.c" + _g_free0 (description); + } +#line 847 "fillmore.vala" + gtk_object_destroy (GTK_OBJECT (properties)); +#line 2804 "fillmore.c" + _g_object_unref0 (builder); + _g_object_unref0 (properties); +} + + +#line 850 "fillmore.vala" +static void _recorder_on_quit_finished_closing_recorder_finished_closing (Recorder* _sender, gboolean project_did_close, gpointer self) { +#line 2812 "fillmore.c" + recorder_on_quit_finished_closing (self, project_did_close); +} + + +#line 850 "fillmore.vala" +static void recorder_on_quit_finished_closing (Recorder* self, gboolean project_did_close) { +#line 2819 "fillmore.c" + guint _tmp0_; + guint _tmp1_; +#line 850 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 851 "fillmore.vala" + g_signal_parse_name ("closed", MODEL_TYPE_PROJECT, &_tmp0_, NULL, FALSE); +#line 851 "fillmore.vala" + g_signal_handlers_disconnect_matched (MODEL_PROJECT (self->project), G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, 0, NULL, (GCallback) _recorder_on_project_close_model_project_closed, self); +#line 852 "fillmore.vala" + g_signal_parse_name ("finished-closing", TYPE_RECORDER, &_tmp1_, NULL, FALSE); +#line 852 "fillmore.vala" + g_signal_handlers_disconnect_matched (self, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp1_, 0, NULL, (GCallback) _recorder_on_quit_finished_closing_recorder_finished_closing, self); +#line 853 "fillmore.vala" + if (project_did_close) { +#line 854 "fillmore.vala" + gtk_main_quit (); +#line 2836 "fillmore.c" + } +} + + +#line 858 "fillmore.vala" +static void recorder_on_quit (Recorder* self) { +#line 858 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 859 "fillmore.vala" + if (!model_project_transport_is_recording (MODEL_PROJECT (self->project))) { +#line 860 "fillmore.vala" + g_signal_connect_object (MODEL_PROJECT (self->project), "closed", (GCallback) _recorder_on_project_close_model_project_closed, self, 0); +#line 861 "fillmore.vala" + g_signal_connect_object (self, "finished-closing", (GCallback) _recorder_on_quit_finished_closing_recorder_finished_closing, self, 0); +#line 862 "fillmore.vala" + model_project_close (MODEL_PROJECT (self->project)); +#line 2853 "fillmore.c" + } +} + + +#line 866 "fillmore.vala" +static gboolean recorder_on_delete_event (Recorder* self) { +#line 2860 "fillmore.c" + gboolean result = FALSE; +#line 866 "fillmore.vala" + g_return_val_if_fail (IS_RECORDER (self), FALSE); +#line 867 "fillmore.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_delete_event"); +#line 868 "fillmore.vala" + recorder_on_quit (self); +#line 2868 "fillmore.c" + result = TRUE; +#line 869 "fillmore.vala" + return result; +#line 2872 "fillmore.c" +} + + +#line 872 "fillmore.vala" +static void recorder_on_project_close (Recorder* self) { +#line 872 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 873 "fillmore.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_project_close"); +#line 874 "fillmore.vala" + if (model_undo_manager_get_is_dirty (MODEL_PROJECT (self->project)->undo_manager)) { +#line 875 "fillmore.vala" + switch (dialog_utils_save_close_cancel (GTK_WINDOW (self), NULL, "Save changes before closing?")) { +#line 2886 "fillmore.c" + case GTK_RESPONSE_ACCEPT: + { +#line 877 "fillmore.vala" + if (!recorder_do_save (self)) { +#line 878 "fillmore.vala" + g_signal_emit_by_name (self, "finished-closing", FALSE); +#line 879 "fillmore.vala" + return; +#line 2895 "fillmore.c" + } +#line 881 "fillmore.vala" + break; +#line 2899 "fillmore.c" + } + case GTK_RESPONSE_NO: + { + char* _tmp0_; + gboolean _tmp1_; +#line 884 "fillmore.vala" + if ((_tmp1_ = (_tmp0_ = model_project_get_project_file (MODEL_PROJECT (self->project))) == NULL, _g_free0 (_tmp0_), _tmp1_)) { +#line 885 "fillmore.vala" + model_project_save (MODEL_PROJECT (self->project), NULL); +#line 2909 "fillmore.c" + } +#line 887 "fillmore.vala" + break; +#line 2913 "fillmore.c" + } + case GTK_RESPONSE_DELETE_EVENT: + case GTK_RESPONSE_CANCEL: + { +#line 890 "fillmore.vala" + g_signal_emit_by_name (self, "finished-closing", FALSE); +#line 891 "fillmore.vala" + return; +#line 2922 "fillmore.c" + } + default: + { +#line 893 "fillmore.vala" + g_assert (FALSE); +#line 894 "fillmore.vala" + break; +#line 2930 "fillmore.c" + } + } + } +#line 897 "fillmore.vala" + g_signal_emit_by_name (self, "finished-closing", TRUE); +#line 2936 "fillmore.c" +} + + +#line 901 "fillmore.vala" +static void recorder_on_cut (Recorder* self) { +#line 901 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 902 "fillmore.vala" + time_line_do_cut (self->timeline); +#line 2946 "fillmore.c" +} + + +#line 905 "fillmore.vala" +static void recorder_on_copy (Recorder* self) { +#line 905 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 906 "fillmore.vala" + time_line_do_copy (self->timeline); +#line 2956 "fillmore.c" +} + + +#line 909 "fillmore.vala" +static void recorder_on_paste (Recorder* self) { +#line 909 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 910 "fillmore.vala" + time_line_paste (self->timeline); +#line 2966 "fillmore.c" +} + + +#line 913 "fillmore.vala" +static void recorder_on_undo (Recorder* self) { +#line 913 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 914 "fillmore.vala" + model_project_undo (MODEL_PROJECT (self->project)); +#line 2976 "fillmore.c" +} + + +#line 917 "fillmore.vala" +static void recorder_on_delete (Recorder* self) { +#line 917 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 918 "fillmore.vala" + if (clip_library_view_has_selection (self->priv->library)) { +#line 919 "fillmore.vala" + clip_library_view_delete_selection (self->priv->library); +#line 2988 "fillmore.c" + } else { +#line 921 "fillmore.vala" + time_line_delete_selection (self->timeline); +#line 2992 "fillmore.c" + } +} + + +#line 925 "fillmore.vala" +static void recorder_on_select_all (Recorder* self) { +#line 925 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 926 "fillmore.vala" + if (clip_library_view_has_selection (self->priv->library)) { +#line 927 "fillmore.vala" + clip_library_view_select_all (self->priv->library); +#line 3005 "fillmore.c" + } else { +#line 929 "fillmore.vala" + time_line_select_all (self->timeline); +#line 3009 "fillmore.c" + } +} + + +#line 933 "fillmore.vala" +void recorder_on_split_at_playhead (Recorder* self) { +#line 933 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 934 "fillmore.vala" + model_project_split_at_playhead (MODEL_PROJECT (self->project)); +#line 3020 "fillmore.c" +} + + +#line 937 "fillmore.vala" +void recorder_on_trim_to_playhead (Recorder* self) { +#line 937 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 938 "fillmore.vala" + model_project_trim_to_playhead (MODEL_PROJECT (self->project)); +#line 3030 "fillmore.c" +} + + +#line 941 "fillmore.vala" +void recorder_on_clip_properties (Recorder* self) { +#line 941 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 942 "fillmore.vala" + if (clip_library_view_has_selection (self->priv->library)) { +#line 3040 "fillmore.c" + GeeArrayList* files; +#line 943 "fillmore.vala" + files = clip_library_view_get_selected_files (self->priv->library); +#line 944 "fillmore.vala" + if (gee_collection_get_size (GEE_COLLECTION (files)) == 1) { +#line 3046 "fillmore.c" + char* file_name; + ModelClipFile* clip_file; +#line 945 "fillmore.vala" + file_name = (char*) gee_abstract_list_get (GEE_ABSTRACT_LIST (files), 0); +#line 946 "fillmore.vala" + clip_file = model_project_find_clipfile (MODEL_PROJECT (self->project), file_name); +#line 947 "fillmore.vala" + dialog_utils_show_clip_properties (GTK_WINDOW (self), NULL, clip_file, NULL); +#line 3055 "fillmore.c" + _g_free0 (file_name); + _g_object_unref0 (clip_file); + } + _g_object_unref0 (files); + } else { + GeeArrayList* clips; +#line 950 "fillmore.vala" + clips = _g_object_ref0 (self->timeline->selected_clips); +#line 951 "fillmore.vala" + if (gee_collection_get_size (GEE_COLLECTION (clips)) == 1) { +#line 3066 "fillmore.c" + ClipView* clip_view; +#line 952 "fillmore.vala" + clip_view = (ClipView*) gee_abstract_list_get (GEE_ABSTRACT_LIST (clips), 0); +#line 953 "fillmore.vala" + dialog_utils_show_clip_properties (GTK_WINDOW (self), clip_view, NULL, NULL); +#line 3072 "fillmore.c" + _g_object_unref0 (clip_view); + } + _g_object_unref0 (clips); + } +} + + +#line 960 "fillmore.vala" +static void recorder_on_track_new (Recorder* self) { +#line 3082 "fillmore.c" + UITrackInformation* dialog; + char* _tmp0_; +#line 960 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 961 "fillmore.vala" + dialog = g_object_ref_sink (ui_track_information_new ()); +#line 962 "fillmore.vala" + ui_track_information_set_track_name (dialog, _tmp0_ = recorder_get_default_track_name (self)); +#line 3091 "fillmore.c" + _g_free0 (_tmp0_); +#line 963 "fillmore.vala" + if (recorder_track_name_dialog (self, dialog, NULL)) { +#line 3095 "fillmore.c" + ModelAudioTrack* _tmp2_; + char* _tmp1_; +#line 964 "fillmore.vala" + model_project_add_track (MODEL_PROJECT (self->project), MODEL_TRACK (_tmp2_ = model_audio_track_new (MODEL_PROJECT (self->project), _tmp1_ = ui_track_information_get_track_name (dialog)))); +#line 3100 "fillmore.c" + _g_object_unref0 (_tmp2_); + _g_free0 (_tmp1_); + } +#line 966 "fillmore.vala" + gtk_object_destroy (GTK_OBJECT (dialog)); +#line 3106 "fillmore.c" + _g_object_unref0 (dialog); +} + + +#line 969 "fillmore.vala" +static void recorder_on_track_rename (Recorder* self) { +#line 3113 "fillmore.c" + UITrackInformation* dialog; + ModelTrack* track; + ModelTrack* _tmp0_; +#line 969 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 970 "fillmore.vala" + dialog = g_object_ref_sink (ui_track_information_new ()); +#line 971 "fillmore.vala" + track = recorder_selected_track (self); +#line 972 "fillmore.vala" + gtk_window_set_title (GTK_WINDOW (dialog), "Rename Track"); +#line 973 "fillmore.vala" + ui_track_information_set_track_name (dialog, (_tmp0_ = recorder_selected_track (self))->display_name); +#line 3127 "fillmore.c" + _g_object_unref0 (_tmp0_); +#line 974 "fillmore.vala" + if (recorder_track_name_dialog (self, dialog, track)) { +#line 3131 "fillmore.c" + char* _tmp1_; +#line 975 "fillmore.vala" + model_track_set_display_name (track, _tmp1_ = ui_track_information_get_track_name (dialog)); +#line 3135 "fillmore.c" + _g_free0 (_tmp1_); + } +#line 977 "fillmore.vala" + gtk_object_destroy (GTK_OBJECT (dialog)); +#line 3140 "fillmore.c" + _g_object_unref0 (dialog); + _g_object_unref0 (track); +} + + +#line 980 "fillmore.vala" +static gboolean recorder_track_name_dialog (Recorder* self, UITrackInformation* dialog, ModelTrack* track) { +#line 3148 "fillmore.c" + gboolean result = FALSE; + GtkResponseType _result_; + gboolean is_ok; + gboolean _tmp2_ = FALSE; +#line 980 "fillmore.vala" + g_return_val_if_fail (IS_RECORDER (self), FALSE); +#line 980 "fillmore.vala" + g_return_val_if_fail (UI_IS_TRACK_INFORMATION (dialog), FALSE); +#line 980 "fillmore.vala" + g_return_val_if_fail ((track == NULL) || MODEL_IS_TRACK (track), FALSE); +#line 981 "fillmore.vala" + _result_ = GTK_RESPONSE_OK; +#line 982 "fillmore.vala" + is_ok = TRUE; +#line 3163 "fillmore.c" + { + gboolean _tmp0_; +#line 983 "fillmore.vala" + _tmp0_ = TRUE; +#line 983 "fillmore.vala" + while (TRUE) { +#line 3170 "fillmore.c" + char* new_name; +#line 983 "fillmore.vala" + if (!_tmp0_) { +#line 3174 "fillmore.c" + gboolean _tmp1_ = FALSE; +#line 999 "fillmore.vala" + if (_result_ == GTK_RESPONSE_OK) { +#line 999 "fillmore.vala" + _tmp1_ = !is_ok; +#line 3180 "fillmore.c" + } else { +#line 999 "fillmore.vala" + _tmp1_ = FALSE; +#line 3184 "fillmore.c" + } +#line 999 "fillmore.vala" + if (!_tmp1_) { +#line 999 "fillmore.vala" + break; +#line 3190 "fillmore.c" + } + } +#line 983 "fillmore.vala" + _tmp0_ = FALSE; +#line 984 "fillmore.vala" + _result_ = (GtkResponseType) gtk_dialog_run (GTK_DIALOG (dialog)); +#line 985 "fillmore.vala" + new_name = ui_track_information_get_track_name (dialog); +#line 987 "fillmore.vala" + if (_result_ == GTK_RESPONSE_OK) { +#line 988 "fillmore.vala" + if (_vala_strcmp0 (new_name, "") == 0) { +#line 989 "fillmore.vala" + is_ok = FALSE; +#line 990 "fillmore.vala" + dialog_utils_error ("Invalid track name.", "The track name cannot be empty."); +#line 3207 "fillmore.c" + } else { +#line 992 "fillmore.vala" + is_ok = !model_project_is_duplicate_track_name (MODEL_PROJECT (self->project), track, new_name); +#line 993 "fillmore.vala" + if (!is_ok) { +#line 994 "fillmore.vala" + dialog_utils_error ("Duplicate track name.", "A track with this name already exists."); +#line 3215 "fillmore.c" + } + } + } + _g_free0 (new_name); + } + } +#line 1000 "fillmore.vala" + if (_result_ == GTK_RESPONSE_OK) { +#line 1000 "fillmore.vala" + _tmp2_ = is_ok; +#line 3226 "fillmore.c" + } else { +#line 1000 "fillmore.vala" + _tmp2_ = FALSE; +#line 3230 "fillmore.c" + } + result = _tmp2_; +#line 1000 "fillmore.vala" + return result; +#line 3235 "fillmore.c" +} + + +#line 1003 "fillmore.vala" +static void recorder_on_track_remove (Recorder* self) { +#line 3241 "fillmore.c" + ModelTrack* _tmp0_; +#line 1003 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 1004 "fillmore.vala" + model_project_remove_track (MODEL_PROJECT (self->project), _tmp0_ = recorder_selected_track (self)); +#line 3247 "fillmore.c" + _g_object_unref0 (_tmp0_); +} + + +#line 1008 "fillmore.vala" +static void recorder_on_zoom_in (Recorder* self) { +#line 1008 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 1009 "fillmore.vala" + recorder_do_zoom (self, 0.1f); +#line 3258 "fillmore.c" +} + + +#line 1012 "fillmore.vala" +static void recorder_on_zoom_out (Recorder* self) { +#line 1012 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 1013 "fillmore.vala" + recorder_do_zoom (self, -0.1f); +#line 3268 "fillmore.c" +} + + +#line 1016 "fillmore.vala" +static void recorder_on_zoom_to_project (Recorder* self) { +#line 1016 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 1017 "fillmore.vala" + time_line_zoom_to_project (self->timeline, gtk_adjustment_get_page_size (self->priv->h_adjustment)); +#line 3278 "fillmore.c" +} + + +#line 1020 "fillmore.vala" +static void recorder_on_snap (Recorder* self) { +#line 1020 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 1021 "fillmore.vala" + MODEL_PROJECT (self->project)->snap_to_clip = !MODEL_PROJECT (self->project)->snap_to_clip; +#line 3288 "fillmore.c" +} + + +#line 1024 "fillmore.vala" +static void recorder_on_view_library (Recorder* self) { +#line 1024 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 1025 "fillmore.vala" + if (GTK_PANED (self->priv->timeline_library_pane)->child2 == GTK_WIDGET (self->priv->library_scrolled)) { +#line 1026 "fillmore.vala" + gtk_container_remove (GTK_CONTAINER (self->priv->timeline_library_pane), GTK_WIDGET (self->priv->library_scrolled)); +#line 1027 "fillmore.vala" + MODEL_PROJECT (self->project)->library_visible = FALSE; +#line 3302 "fillmore.c" + } else { +#line 1029 "fillmore.vala" + gtk_paned_add2 (GTK_PANED (self->priv->timeline_library_pane), GTK_WIDGET (self->priv->library_scrolled)); +#line 1030 "fillmore.vala" + gtk_widget_show_all (GTK_WIDGET (self->priv->timeline_library_pane)); +#line 1031 "fillmore.vala" + MODEL_PROJECT (self->project)->library_visible = TRUE; +#line 3310 "fillmore.c" + } +} + + +#line 1035 "fillmore.vala" +static void recorder_on_library_size_allocate (Recorder* self, GdkRectangle* rectangle) { +#line 3317 "fillmore.c" + gboolean _tmp0_ = FALSE; +#line 1035 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 1036 "fillmore.vala" + if (!self->priv->loading) { +#line 1036 "fillmore.vala" + _tmp0_ = GTK_PANED (self->priv->timeline_library_pane)->child2 == GTK_WIDGET (self->priv->library_scrolled); +#line 3325 "fillmore.c" + } else { +#line 1036 "fillmore.vala" + _tmp0_ = FALSE; +#line 3329 "fillmore.c" + } +#line 1036 "fillmore.vala" + if (_tmp0_) { +#line 1037 "fillmore.vala" + MODEL_PROJECT (self->project)->library_width = (*rectangle).width; +#line 3335 "fillmore.c" + } +} + + +#line 1043 "fillmore.vala" +static void recorder_on_help_contents (Recorder* self) { +#line 3342 "fillmore.c" + GError * _inner_error_; +#line 1043 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 3346 "fillmore.c" + _inner_error_ = NULL; + { +#line 1045 "fillmore.vala" + gtk_show_uri (NULL, "http://trac.yorba.org/wiki/UsingFillmore0.1", (guint32) 0, &_inner_error_); +#line 3351 "fillmore.c" + if (_inner_error_ != NULL) { + goto __catch7_g_error; + } + } + goto __finally7; + __catch7_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { + _g_error_free0 (e); + } + } + __finally7: + if (_inner_error_ != NULL) { + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } +} + + +#line 1050 "fillmore.vala" +static void recorder_on_about (Recorder* self) { +#line 3377 "fillmore.c" + char* _tmp1_; + char* _tmp0_; +#line 1050 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 1051 "fillmore.vala" + gtk_show_about_dialog (GTK_WINDOW (self), "version", _tmp0_ = model_project_get_version (MODEL_PROJECT (self->project)), "comments", "An audio editor and recorder", "copyright", "Copyright 2009-2010 Yorba Foundation", "website", "http://www.yorba.org", "license", _tmp1_ = model_project_get_license (MODEL_PROJECT (self->project)), "website-label", "Visit the Yorba web site", "authors", MODEL_PROJECT_authors, NULL); +#line 3384 "fillmore.c" + _g_free0 (_tmp1_); + _g_free0 (_tmp0_); +} + + +#line 1062 "fillmore.vala" +static void recorder_on_save_graph (Recorder* self) { +#line 1062 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 1063 "fillmore.vala" + model_project_print_graph (MODEL_PROJECT (self->project), GST_BIN (MODEL_PROJECT (self->project)->media_engine->pipeline), "save_graph"); +#line 3396 "fillmore.c" +} + + +#line 1068 "fillmore.vala" +static void recorder_on_volume (Recorder* self) { +#line 1068 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 3404 "fillmore.c" +} + + +#line 1072 "fillmore.vala" +static void recorder_on_rewind (Recorder* self) { +#line 1072 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 1073 "fillmore.vala" + view_media_engine_go (MODEL_PROJECT (self->project)->media_engine, (gint64) 0); +#line 1074 "fillmore.vala" + recorder_scroll_to_beginning (self); +#line 3416 "fillmore.c" +} + + +#line 1077 "fillmore.vala" +static void recorder_on_end (Recorder* self) { +#line 1077 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 1078 "fillmore.vala" + model_project_go_end (MODEL_PROJECT (self->project)); +#line 1079 "fillmore.vala" + recorder_scroll_to_end (self); +#line 3428 "fillmore.c" +} + + +#line 1082 "fillmore.vala" +static void recorder_on_play (Recorder* self) { +#line 1082 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 1083 "fillmore.vala" + if (model_project_transport_is_recording (MODEL_PROJECT (self->project))) { +#line 1084 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "Record", TRUE); +#line 1085 "fillmore.vala" + gtk_toggle_button_set_active (self->priv->record_button, FALSE); +#line 1086 "fillmore.vala" + gtk_toggle_button_set_active (self->priv->play_button, FALSE); +#line 1087 "fillmore.vala" + view_media_engine_pause (MODEL_PROJECT (self->project)->media_engine); +#line 3446 "fillmore.c" + } else { +#line 1088 "fillmore.vala" + if (gtk_toggle_button_get_active (self->priv->play_button)) { +#line 1089 "fillmore.vala" + view_media_engine_do_play (MODEL_PROJECT (self->project)->media_engine, PLAY_STATE_PLAYING); +#line 3452 "fillmore.c" + } else { +#line 1091 "fillmore.vala" + view_media_engine_pause (MODEL_PROJECT (self->project)->media_engine); +#line 3456 "fillmore.c" + } + } +} + + +#line 1094 "fillmore.vala" +static void recorder_on_record (Recorder* self) { +#line 1094 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 1095 "fillmore.vala" + if (gtk_toggle_button_get_active (self->priv->record_button)) { +#line 3468 "fillmore.c" + ModelTrack* _tmp0_; + ModelAudioTrack* audio_track; + gint number_of_channels = 0; +#line 1096 "fillmore.vala" + audio_track = (_tmp0_ = recorder_selected_track (self), MODEL_IS_AUDIO_TRACK (_tmp0_) ? ((ModelAudioTrack*) _tmp0_) : NULL); +#line 1098 "fillmore.vala" + if (model_audio_track_get_num_channels (audio_track, &number_of_channels)) { +#line 1099 "fillmore.vala" + if (number_of_channels > CHANNELS_PER_TRACK_RECORD) { +#line 1100 "fillmore.vala" + gtk_toggle_button_set_active (self->priv->record_button, FALSE); +#line 1101 "fillmore.vala" + recorder_on_error_occurred (self, "Can not record onto a stereo track", NULL); +#line 3482 "fillmore.c" + _g_object_unref0 (audio_track); +#line 1102 "fillmore.vala" + return; +#line 3486 "fillmore.c" + } + } +#line 1105 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "Record", FALSE); +#line 1106 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "Play", FALSE); +#line 1107 "fillmore.vala" + model_audio_project_record (self->project, audio_track); +#line 3495 "fillmore.c" + _g_object_unref0 (audio_track); + } else { +#line 1110 "fillmore.vala" + recorder_on_play (self); +#line 3500 "fillmore.c" + } +} + + +#line 1114 "fillmore.vala" +static void recorder_on_callback_pulse (Recorder* self) { +#line 1114 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 1115 "fillmore.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_callback_pulse"); +#line 1116 "fillmore.vala" + if (model_project_transport_is_playing (MODEL_PROJECT (self->project))) { +#line 1117 "fillmore.vala" + recorder_scroll_toward_center (self, model_time_system_time_to_xpos (self->priv->provider, MODEL_PROJECT (self->project)->media_engine->position)); +#line 3515 "fillmore.c" + } +#line 1119 "fillmore.vala" + gtk_widget_queue_draw (GTK_WIDGET (self->timeline)); +#line 3519 "fillmore.c" +} + + +#line 1122 "fillmore.vala" +static gint64 recorder_get_zoom_center_time (Recorder* self) { +#line 3525 "fillmore.c" + gint64 result = 0LL; +#line 1122 "fillmore.vala" + g_return_val_if_fail (IS_RECORDER (self), 0LL); +#line 3529 "fillmore.c" + result = model_project_transport_get_position (MODEL_PROJECT (self->project)); +#line 1123 "fillmore.vala" + return result; +#line 3533 "fillmore.c" +} + + +#line 1126 "fillmore.vala" +static void recorder_do_zoom (Recorder* self, float increment) { +#line 1126 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 1127 "fillmore.vala" + self->priv->center_time = recorder_get_zoom_center_time (self); +#line 1128 "fillmore.vala" + time_line_zoom (self->timeline, increment); +#line 3545 "fillmore.c" +} + + +#line 1131 "fillmore.vala" +static void recorder_on_timeline_size_allocate (Recorder* self, GdkRectangle* rectangle) { +#line 1131 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 1132 "fillmore.vala" + if (self->priv->center_time != (-1)) { +#line 3555 "fillmore.c" + gint new_center_pixel; + gint page_size; +#line 1133 "fillmore.vala" + new_center_pixel = model_time_system_time_to_xpos (self->priv->provider, self->priv->center_time); +#line 1134 "fillmore.vala" + page_size = (gint) (gtk_adjustment_get_page_size (self->priv->h_adjustment) / 2); +#line 1135 "fillmore.vala" + gtk_adjustment_clamp_page (self->priv->h_adjustment, (double) (new_center_pixel - page_size), (double) (new_center_pixel + page_size)); +#line 1136 "fillmore.vala" + self->priv->center_time = (gint64) (-1); +#line 3566 "fillmore.c" + } +} + + +#line 1140 "fillmore.vala" +static void recorder_on_timeline_selection_changed (Recorder* self, gboolean selected) { +#line 1140 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 1141 "fillmore.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_timeline_selection_changed"); +#line 1142 "fillmore.vala" + if (selected) { +#line 1143 "fillmore.vala" + clip_library_view_unselect_all (self->priv->library); +#line 3581 "fillmore.c" + } +#line 1145 "fillmore.vala" + recorder_update_menu (self); +#line 3585 "fillmore.c" +} + + +#line 1148 "fillmore.vala" +void recorder_on_library_selection_changed (Recorder* self, gboolean selected) { +#line 1148 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 1149 "fillmore.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_library_selection_changed"); +#line 1150 "fillmore.vala" + if (selected) { +#line 1151 "fillmore.vala" + time_line_deselect_all_clips (self->timeline); +#line 1152 "fillmore.vala" + gtk_widget_queue_draw (GTK_WIDGET (self->timeline)); +#line 3601 "fillmore.c" + } +#line 1154 "fillmore.vala" + recorder_update_menu (self); +#line 3605 "fillmore.c" +} + + +#line 1206 "fillmore.vala" +void recorder_do_error_dialog (const char* major_message, const char* minor_message) { +#line 1206 "fillmore.vala" + g_return_if_fail (major_message != NULL); +#line 1207 "fillmore.vala" + dialog_utils_error (major_message, minor_message); +#line 3615 "fillmore.c" +} + + +#line 1210 "fillmore.vala" +void recorder_on_load_error (Recorder* self, const char* message) { +#line 1210 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 1210 "fillmore.vala" + g_return_if_fail (message != NULL); +#line 1211 "fillmore.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_load_error"); +#line 1212 "fillmore.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->load_errors), message); +#line 3629 "fillmore.c" +} + + +#line 1215 "fillmore.vala" +void recorder_on_load_complete (Recorder* self) { +#line 3635 "fillmore.c" + GtkAction* _tmp0_; + GtkToggleAction* action; + GtkToggleAction* _tmp2_; + GtkAction* _tmp1_; +#line 1215 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 1216 "fillmore.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_load_complete"); +#line 1217 "fillmore.vala" + gst_element_set_state (GST_ELEMENT (MODEL_PROJECT (self->project)->media_engine->pipeline), GST_STATE_PAUSED); +#line 1218 "fillmore.vala" + gtk_paned_set_position (GTK_PANED (self->priv->timeline_library_pane), MODEL_PROJECT (self->project)->library_width); +#line 1220 "fillmore.vala" + action = _g_object_ref0 ((_tmp0_ = gtk_action_group_get_action (self->priv->main_group, "Library"), GTK_IS_TOGGLE_ACTION (_tmp0_) ? ((GtkToggleAction*) _tmp0_) : NULL)); +#line 1221 "fillmore.vala" + if (gtk_toggle_action_get_active (action) != MODEL_PROJECT (self->project)->library_visible) { +#line 1222 "fillmore.vala" + gtk_toggle_action_set_active (action, MODEL_PROJECT (self->project)->library_visible); +#line 3654 "fillmore.c" + } +#line 1225 "fillmore.vala" + action = (_tmp2_ = _g_object_ref0 ((_tmp1_ = gtk_action_group_get_action (self->priv->main_group, "Snap"), GTK_IS_TOGGLE_ACTION (_tmp1_) ? ((GtkToggleAction*) _tmp1_) : NULL)), _g_object_unref0 (action), _tmp2_); +#line 1226 "fillmore.vala" + if (gtk_toggle_action_get_active (action) != MODEL_PROJECT (self->project)->snap_to_clip) { +#line 1227 "fillmore.vala" + gtk_toggle_action_set_active (action, MODEL_PROJECT (self->project)->snap_to_clip); +#line 3662 "fillmore.c" + } +#line 1230 "fillmore.vala" + if (MODEL_PROJECT (self->project)->library_visible) { +#line 1231 "fillmore.vala" + if (GTK_PANED (self->priv->timeline_library_pane)->child2 != GTK_WIDGET (self->priv->library_scrolled)) { +#line 1232 "fillmore.vala" + gtk_paned_add2 (GTK_PANED (self->priv->timeline_library_pane), GTK_WIDGET (self->priv->library_scrolled)); +#line 3670 "fillmore.c" + } + } else { +#line 1235 "fillmore.vala" + if (GTK_PANED (self->priv->timeline_library_pane)->child2 == GTK_WIDGET (self->priv->library_scrolled)) { +#line 1236 "fillmore.vala" + gtk_container_remove (GTK_CONTAINER (self->priv->timeline_library_pane), GTK_WIDGET (self->priv->library_scrolled)); +#line 3677 "fillmore.c" + } + } +#line 1240 "fillmore.vala" + if (gee_collection_get_size (GEE_COLLECTION (self->priv->load_errors)) > 0) { +#line 3682 "fillmore.c" + char* message; +#line 1241 "fillmore.vala" + message = g_strdup (""); +#line 3686 "fillmore.c" + { + GeeIterator* _s_it; + _s_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->priv->load_errors)); +#line 1242 "fillmore.vala" + while (TRUE) { +#line 3692 "fillmore.c" + char* s; + char* _tmp4_; + char* _tmp3_; +#line 1242 "fillmore.vala" + if (!gee_iterator_next (_s_it)) { +#line 1242 "fillmore.vala" + break; +#line 3700 "fillmore.c" + } +#line 1242 "fillmore.vala" + s = (char*) gee_iterator_get (_s_it); +#line 1243 "fillmore.vala" + message = (_tmp4_ = g_strconcat (_tmp3_ = g_strconcat (message, s, NULL), "\n", NULL), _g_free0 (message), _tmp4_); +#line 3706 "fillmore.c" + _g_free0 (_tmp3_); + _g_free0 (s); + } + _g_object_unref0 (_s_it); + } +#line 1245 "fillmore.vala" + recorder_do_error_dialog ("An error occurred loading the project.", message); +#line 3714 "fillmore.c" + _g_free0 (message); + } +#line 1248 "fillmore.vala" + self->priv->loading = FALSE; +#line 3719 "fillmore.c" + _g_object_unref0 (action); +} + + +#line 1251 "fillmore.vala" +static void recorder_on_name_changed (Recorder* self) { +#line 3726 "fillmore.c" + char* _tmp0_; +#line 1251 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 1252 "fillmore.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_name_changed"); +#line 1253 "fillmore.vala" + gtk_window_set_title (GTK_WINDOW (self), _tmp0_ = model_project_get_file_display_name (MODEL_PROJECT (self->project))); +#line 3734 "fillmore.c" + _g_free0 (_tmp0_); +} + + +#line 1256 "fillmore.vala" +static void recorder_on_dirty_changed (Recorder* self, gboolean isDirty) { +#line 3741 "fillmore.c" + GtkMenuItem* file_save; +#line 1256 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 1257 "fillmore.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_dirty_changed"); +#line 1258 "fillmore.vala" + file_save = GTK_MENU_ITEM (recorder_get_widget (self, self->priv->manager, "/MenuBar/ProjectMenu/Save")); +#line 1259 "fillmore.vala" + g_assert (file_save != NULL); +#line 1260 "fillmore.vala" + gtk_widget_set_sensitive (GTK_WIDGET (file_save), isDirty); +#line 3753 "fillmore.c" + _g_object_unref0 (file_save); +} + + +#line 1263 "fillmore.vala" +static void recorder_on_undo_changed (Recorder* self, gboolean can_undo) { +#line 3760 "fillmore.c" + GtkMenuItem* undo; + gboolean _tmp0_ = FALSE; +#line 1263 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 1264 "fillmore.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_undo_changed"); +#line 1265 "fillmore.vala" + undo = GTK_MENU_ITEM (recorder_get_widget (self, self->priv->manager, "/MenuBar/EditMenu/EditUndo")); +#line 1266 "fillmore.vala" + g_assert (undo != NULL); +#line 1268 "fillmore.vala" + if (transport_delegate_is_stopped (TRANSPORT_DELEGATE (self))) { +#line 1268 "fillmore.vala" + _tmp0_ = model_undo_manager_get_can_undo (MODEL_PROJECT (self->project)->undo_manager); +#line 3775 "fillmore.c" + } else { +#line 1268 "fillmore.vala" + _tmp0_ = FALSE; +#line 3779 "fillmore.c" + } +#line 1268 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "Undo", _tmp0_); +#line 3783 "fillmore.c" + _g_object_unref0 (undo); +} + + +#line 1271 "fillmore.vala" +static void recorder_on_playstate_changed (Recorder* self, PlayState playstate) { +#line 1271 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 1272 "fillmore.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_playstate_changed"); +#line 1273 "fillmore.vala" + if (playstate == PLAY_STATE_STOPPED) { +#line 1274 "fillmore.vala" + self->priv->cursor_pos = -1; +#line 1275 "fillmore.vala" + gtk_toggle_button_set_active (self->priv->play_button, FALSE); +#line 1276 "fillmore.vala" + recorder_set_sensitive_group (self, self->priv->main_group, "Export", model_project_can_export (MODEL_PROJECT (self->project))); +#line 1277 "fillmore.vala" + recorder_update_menu (self); +#line 3804 "fillmore.c" + } +} + + +#line 1281 "fillmore.vala" +static void recorder_on_error_occurred (Recorder* self, const char* major_message, const char* minor_message) { +#line 1281 "fillmore.vala" + g_return_if_fail (IS_RECORDER (self)); +#line 1281 "fillmore.vala" + g_return_if_fail (major_message != NULL); +#line 1282 "fillmore.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_error_occurred"); +#line 1283 "fillmore.vala" + dialog_utils_error (major_message, minor_message); +#line 3819 "fillmore.c" +} + + +#line 1286 "fillmore.vala" +static char* recorder_get_fillmore_directory (Recorder* self) { +#line 3825 "fillmore.c" + char* result = NULL; +#line 1286 "fillmore.vala" + g_return_val_if_fail (IS_RECORDER (self), NULL); +#line 3829 "fillmore.c" + result = g_build_filename (g_get_home_dir (), ".fillmore", NULL); +#line 1287 "fillmore.vala" + return result; +#line 3833 "fillmore.c" +} + + +#line 1291 "fillmore.vala" +static gboolean recorder_real_is_playing (TransportDelegate* base) { +#line 3839 "fillmore.c" + Recorder * self; + gboolean result = FALSE; + self = RECORDER (base); + result = model_project_transport_is_playing (MODEL_PROJECT (self->project)); +#line 1292 "fillmore.vala" + return result; +#line 3846 "fillmore.c" +} + + +#line 1295 "fillmore.vala" +static gboolean recorder_real_is_recording (TransportDelegate* base) { +#line 3852 "fillmore.c" + Recorder * self; + gboolean result = FALSE; + self = RECORDER (base); + result = model_project_transport_is_recording (MODEL_PROJECT (self->project)); +#line 1296 "fillmore.vala" + return result; +#line 3859 "fillmore.c" +} + + +#line 1299 "fillmore.vala" +static gboolean recorder_real_is_stopped (TransportDelegate* base) { +#line 3865 "fillmore.c" + Recorder * self; + gboolean result = FALSE; + gboolean _tmp0_ = FALSE; + self = RECORDER (base); +#line 1300 "fillmore.vala" + if (transport_delegate_is_playing (TRANSPORT_DELEGATE (self))) { +#line 1300 "fillmore.vala" + _tmp0_ = TRUE; +#line 3874 "fillmore.c" + } else { +#line 1300 "fillmore.vala" + _tmp0_ = transport_delegate_is_recording (TRANSPORT_DELEGATE (self)); +#line 3878 "fillmore.c" + } + result = !_tmp0_; +#line 1300 "fillmore.vala" + return result; +#line 3883 "fillmore.c" +} + + +static void recorder_class_init (RecorderClass * klass) { + recorder_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (RecorderPrivate)); + GTK_WIDGET_CLASS (klass)->key_press_event = recorder_real_key_press_event; + G_OBJECT_CLASS (klass)->finalize = recorder_finalize; + g_signal_new ("finished_closing", TYPE_RECORDER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1, G_TYPE_BOOLEAN); +} + + +static void recorder_transport_delegate_interface_init (TransportDelegateIface * iface) { + recorder_transport_delegate_parent_iface = g_type_interface_peek_parent (iface); + iface->is_playing = recorder_real_is_playing; + iface->is_recording = recorder_real_is_recording; + iface->is_stopped = recorder_real_is_stopped; +} + + +static void recorder_instance_init (Recorder * self) { + self->priv = RECORDER_GET_PRIVATE (self); + self->priv->cursor_pos = -1; + self->priv->center_time = (gint64) (-1); + self->priv->scrollwin_pos_y = 0; +} + + +static void recorder_finalize (GObject* obj) { + Recorder * self; + self = RECORDER (obj); + _g_object_unref0 (self->project); + _g_object_unref0 (self->timeline); + _g_object_unref0 (self->priv->click_track); + _g_object_unref0 (self->priv->header_area); + _g_object_unref0 (self->priv->library); + _g_object_unref0 (self->priv->provider); + _g_object_unref0 (self->priv->h_adjustment); + _g_object_unref0 (self->priv->timeline_library_pane); + _g_object_unref0 (self->priv->library_scrolled); + _g_object_unref0 (self->priv->timeline_scrolled); + _g_object_unref0 (self->priv->main_group); + _g_object_unref0 (self->priv->play_button); + _g_object_unref0 (self->priv->record_button); + _g_object_unref0 (self->priv->addnew_button); + _g_object_unref0 (self->priv->rewind_button); + _g_object_unref0 (self->priv->forward_button); + _g_object_unref0 (self->priv->zoomin_button); + _g_object_unref0 (self->priv->zoomout_button); + _g_object_unref0 (self->priv->volume_button); + _g_object_unref0 (self->priv->scrollwin); + _g_object_unref0 (self->priv->manager); + _g_object_unref0 (self->priv->audio_export); + _g_object_unref0 (self->priv->audio_output); + _g_object_unref0 (self->priv->load_errors); + G_OBJECT_CLASS (recorder_parent_class)->finalize (obj); +} + + +GType recorder_get_type (void) { + static volatile gsize recorder_type_id__volatile = 0; + if (g_once_init_enter (&recorder_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (RecorderClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) recorder_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Recorder), 0, (GInstanceInitFunc) recorder_instance_init, NULL }; + static const GInterfaceInfo transport_delegate_info = { (GInterfaceInitFunc) recorder_transport_delegate_interface_init, (GInterfaceFinalizeFunc) NULL, NULL}; + GType recorder_type_id; + recorder_type_id = g_type_register_static (GTK_TYPE_WINDOW, "Recorder", &g_define_type_info, 0); + g_type_add_interface_static (recorder_type_id, TYPE_TRANSPORT_DELEGATE, &transport_delegate_info); + g_once_init_leave (&recorder_type_id__volatile, recorder_type_id); + } + return recorder_type_id__volatile; +} + + +#line 1307 "fillmore.vala" +void fillmore_run (Fillmore* self, char** args, int args_length1) { +#line 3959 "fillmore.c" + GError * _inner_error_; + GOptionContext* context; +#line 1307 "fillmore.vala" + g_return_if_fail (IS_FILLMORE (self)); +#line 3964 "fillmore.c" + _inner_error_ = NULL; +#line 1308 "fillmore.vala" + debug_level = -1; +#line 1309 "fillmore.vala" + context = g_option_context_new (" [project file] - Record and edit multitrack audio"); +#line 1311 "fillmore.vala" + g_option_context_add_main_entries (context, options, NULL); +#line 1312 "fillmore.vala" + g_option_context_add_group (context, gst_init_get_option_group ()); +#line 3974 "fillmore.c" + { +#line 1315 "fillmore.vala" + g_option_context_parse (context, &args_length1, &args, &_inner_error_); +#line 3978 "fillmore.c" + if (_inner_error_ != NULL) { + goto __catch8_g_error; + } + } + goto __finally8; + __catch8_g_error: + { + GError * arg_error; + arg_error = _inner_error_; + _inner_error_ = NULL; + { +#line 1317 "fillmore.vala" + fprintf (stderr, "%s\n" \ +"Run 'fillmore --help' for a full list of available command line option" \ +"s.", arg_error->message); +#line 3992 "fillmore.c" + _g_error_free0 (arg_error); + _g_option_context_free0 (context); +#line 1319 "fillmore.vala" + return; +#line 3997 "fillmore.c" + } + } + __finally8: + if (_inner_error_ != NULL) { + _g_option_context_free0 (context); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } + { + GFile* _tmp1_; + GFile* _tmp0_; + char* _tmp2_; + char* rc_file; + char* project_file; + FillmoreClassFactory* _tmp6_; + Recorder* recorder; +#line 1323 "fillmore.vala" + g_set_application_name ("Fillmore"); +#line 1324 "fillmore.vala" + if (debug_level > (-1)) { +#line 1325 "fillmore.vala" + logging_set_logging_level ((LoggingLevel) debug_level); +#line 4021 "fillmore.c" + } +#line 1328 "fillmore.vala" + app_dirs_init (args[0], _PROGRAM_NAME); +#line 1329 "fillmore.vala" + rc_file = (_tmp2_ = g_file_get_path (_tmp1_ = g_file_get_child (_tmp0_ = app_dirs_get_resources_dir (), "fillmore.rc")), _g_object_unref0 (_tmp1_), _g_object_unref0 (_tmp0_), _tmp2_); +#line 1331 "fillmore.vala" + gtk_rc_parse (rc_file); +#line 1334 "fillmore.vala" + project_file = NULL; +#line 1335 "fillmore.vala" + if (args_length1 > 1) { +#line 4033 "fillmore.c" + char* _tmp3_; +#line 1336 "fillmore.vala" + project_file = (_tmp3_ = g_strdup (args[1]), _g_free0 (project_file), _tmp3_); +#line 4037 "fillmore.c" + { + char* _tmp4_; + char* _tmp5_; +#line 1338 "fillmore.vala" + _tmp4_ = g_filename_from_uri (project_file, NULL, &_inner_error_); +#line 4043 "fillmore.c" + if (_inner_error_ != NULL) { + goto __catch10_g_error; + } +#line 1338 "fillmore.vala" + project_file = (_tmp5_ = _tmp4_, _g_free0 (project_file), _tmp5_); +#line 4049 "fillmore.c" + } + goto __finally10; + __catch10_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { + _g_error_free0 (e); + } + } + __finally10: + if (_inner_error_ != NULL) { + _g_free0 (rc_file); + _g_free0 (project_file); + goto __catch9_g_error; + } + } +#line 1342 "fillmore.vala" + class_factory_set_class_factory (CLASS_FACTORY (_tmp6_ = fillmore_class_factory_new ())); +#line 4070 "fillmore.c" + _class_factory_unref0 (_tmp6_); +#line 1343 "fillmore.vala" + view_media_engine_can_run (&_inner_error_); +#line 4074 "fillmore.c" + if (_inner_error_ != NULL) { + _g_free0 (rc_file); + _g_free0 (project_file); + goto __catch9_g_error; + } +#line 1345 "fillmore.vala" + recorder = g_object_ref_sink (recorder_new (project_file, &_inner_error_)); +#line 4082 "fillmore.c" + if (_inner_error_ != NULL) { + _g_free0 (rc_file); + _g_free0 (project_file); + goto __catch9_g_error; + } +#line 1346 "fillmore.vala" + gtk_widget_show_all (GTK_WIDGET (recorder)); +#line 1347 "fillmore.vala" + gtk_main (); +#line 4092 "fillmore.c" + _g_free0 (rc_file); + _g_free0 (project_file); + _g_object_unref0 (recorder); + } + goto __finally9; + __catch9_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { +#line 1349 "fillmore.vala" + recorder_do_error_dialog ("Could not start application.", e->message); +#line 4106 "fillmore.c" + _g_error_free0 (e); + } + } + __finally9: + if (_inner_error_ != NULL) { + _g_option_context_free0 (context); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } + _g_option_context_free0 (context); +} + + +#line 1304 "fillmore.vala" +Fillmore* fillmore_construct (GType object_type) { +#line 4123 "fillmore.c" + Fillmore * self; + self = g_object_newv (object_type, 0, NULL); + return self; +} + + +#line 1304 "fillmore.vala" +Fillmore* fillmore_new (void) { +#line 1304 "fillmore.vala" + return fillmore_construct (TYPE_FILLMORE); +#line 4134 "fillmore.c" +} + + +static GObject * fillmore_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) { + GObject * obj; + GObjectClass * parent_class; + Fillmore * self; + parent_class = G_OBJECT_CLASS (fillmore_parent_class); + obj = parent_class->constructor (type, n_construct_properties, construct_properties); + self = FILLMORE (obj); + { + } + return obj; +} + + +static void fillmore_class_init (FillmoreClass * klass) { + fillmore_parent_class = g_type_class_peek_parent (klass); + G_OBJECT_CLASS (klass)->constructor = fillmore_constructor; +} + + +static void fillmore_instance_init (Fillmore * self) { +} + + +GType fillmore_get_type (void) { + static volatile gsize fillmore_type_id__volatile = 0; + if (g_once_init_enter (&fillmore_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (FillmoreClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) fillmore_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Fillmore), 0, (GInstanceInitFunc) fillmore_instance_init, NULL }; + GType fillmore_type_id; + fillmore_type_id = g_type_register_static (HILDON_TYPE_PROGRAM, "Fillmore", &g_define_type_info, 0); + g_once_init_leave (&fillmore_type_id__volatile, fillmore_type_id); + } + return fillmore_type_id__volatile; +} + + +#line 1354 "fillmore.vala" +gint _vala_main (char** args, int args_length1) { +#line 4175 "fillmore.c" + gint result = 0; + Fillmore* fillmore; +#line 1355 "fillmore.vala" + gtk_init (&args_length1, &args); +#line 1356 "fillmore.vala" + gst_init (&args_length1, &args); +#line 1357 "fillmore.vala" + fillmore = fillmore_new (); +#line 1358 "fillmore.vala" + fillmore_run (fillmore, args, args_length1); +#line 4186 "fillmore.c" + result = 0; + _g_object_unref0 (fillmore); +#line 1359 "fillmore.vala" + return result; +#line 4191 "fillmore.c" +} + + +#line 1354 "fillmore.vala" +int main (int argc, char ** argv) { +#line 4197 "fillmore.c" + g_thread_init (NULL); +#line 1354 "fillmore.vala" + g_type_init (); +#line 1354 "fillmore.vala" + return _vala_main (argv, argc); +#line 4203 "fillmore.c" +} + + +#line 1362 "fillmore.vala" +void NO_main (char** args, int args_length1) { +#line 4209 "fillmore.c" + GError * _inner_error_; + GOptionContext* context; + _inner_error_ = NULL; +#line 1363 "fillmore.vala" + hildon_gtk_init (&args_length1, &args); +#line 1364 "fillmore.vala" + debug_level = -1; +#line 1365 "fillmore.vala" + context = g_option_context_new (" [project file] - Record and edit multitrack audio"); +#line 1367 "fillmore.vala" + g_option_context_add_main_entries (context, options, NULL); +#line 1368 "fillmore.vala" + g_option_context_add_group (context, gst_init_get_option_group ()); +#line 4223 "fillmore.c" + { +#line 1371 "fillmore.vala" + g_option_context_parse (context, &args_length1, &args, &_inner_error_); +#line 4227 "fillmore.c" + if (_inner_error_ != NULL) { + goto __catch11_g_error; + } + } + goto __finally11; + __catch11_g_error: + { + GError * arg_error; + arg_error = _inner_error_; + _inner_error_ = NULL; + { +#line 1373 "fillmore.vala" + fprintf (stderr, "%s\n" \ +"Run 'fillmore --help' for a full list of available command line option" \ +"s.", arg_error->message); +#line 4241 "fillmore.c" + _g_error_free0 (arg_error); + _g_option_context_free0 (context); +#line 1375 "fillmore.vala" + return; +#line 4246 "fillmore.c" + } + } + __finally11: + if (_inner_error_ != NULL) { + _g_option_context_free0 (context); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } +#line 1377 "fillmore.vala" + gtk_init (&args_length1, &args); +#line 4258 "fillmore.c" + { + GFile* _tmp1_; + GFile* _tmp0_; + char* _tmp2_; + char* rc_file; + char* project_file; + FillmoreClassFactory* _tmp6_; + Recorder* recorder; +#line 1379 "fillmore.vala" + g_set_application_name ("Fillmore"); +#line 1380 "fillmore.vala" + if (debug_level > (-1)) { +#line 1381 "fillmore.vala" + logging_set_logging_level ((LoggingLevel) debug_level); +#line 4273 "fillmore.c" + } +#line 1384 "fillmore.vala" + app_dirs_init (args[0], _PROGRAM_NAME); +#line 1385 "fillmore.vala" + rc_file = (_tmp2_ = g_file_get_path (_tmp1_ = g_file_get_child (_tmp0_ = app_dirs_get_resources_dir (), "fillmore.rc")), _g_object_unref0 (_tmp1_), _g_object_unref0 (_tmp0_), _tmp2_); +#line 1387 "fillmore.vala" + gtk_rc_parse (rc_file); +#line 1388 "fillmore.vala" + gst_init (&args_length1, &args); +#line 1390 "fillmore.vala" + project_file = NULL; +#line 1391 "fillmore.vala" + if (args_length1 > 1) { +#line 4287 "fillmore.c" + char* _tmp3_; +#line 1392 "fillmore.vala" + project_file = (_tmp3_ = g_strdup (args[1]), _g_free0 (project_file), _tmp3_); +#line 4291 "fillmore.c" + { + char* _tmp4_; + char* _tmp5_; +#line 1394 "fillmore.vala" + _tmp4_ = g_filename_from_uri (project_file, NULL, &_inner_error_); +#line 4297 "fillmore.c" + if (_inner_error_ != NULL) { + goto __catch13_g_error; + } +#line 1394 "fillmore.vala" + project_file = (_tmp5_ = _tmp4_, _g_free0 (project_file), _tmp5_); +#line 4303 "fillmore.c" + } + goto __finally13; + __catch13_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { + _g_error_free0 (e); + } + } + __finally13: + if (_inner_error_ != NULL) { + _g_free0 (rc_file); + _g_free0 (project_file); + goto __catch12_g_error; + } + } +#line 1398 "fillmore.vala" + class_factory_set_class_factory (CLASS_FACTORY (_tmp6_ = fillmore_class_factory_new ())); +#line 4324 "fillmore.c" + _class_factory_unref0 (_tmp6_); +#line 1399 "fillmore.vala" + view_media_engine_can_run (&_inner_error_); +#line 4328 "fillmore.c" + if (_inner_error_ != NULL) { + _g_free0 (rc_file); + _g_free0 (project_file); + goto __catch12_g_error; + } +#line 1401 "fillmore.vala" + recorder = g_object_ref_sink (recorder_new (project_file, &_inner_error_)); +#line 4336 "fillmore.c" + if (_inner_error_ != NULL) { + _g_free0 (rc_file); + _g_free0 (project_file); + goto __catch12_g_error; + } +#line 1402 "fillmore.vala" + gtk_widget_show_all (GTK_WIDGET (recorder)); +#line 1403 "fillmore.vala" + gtk_main (); +#line 4346 "fillmore.c" + _g_free0 (rc_file); + _g_free0 (project_file); + _g_object_unref0 (recorder); + } + goto __finally12; + __catch12_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { +#line 1405 "fillmore.vala" + recorder_do_error_dialog ("Could not start application.", e->message); +#line 4360 "fillmore.c" + _g_error_free0 (e); + } + } + __finally12: + if (_inner_error_ != NULL) { + _g_option_context_free0 (context); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } + _g_option_context_free0 (context); +} + + +static int _vala_strcmp0 (const char * str1, const char * str2) { + if (str1 == NULL) { + return -(str1 != str2); + } + if (str2 == NULL) { + return str1 != str2; + } + return strcmp (str1, str2); +} + + + + diff --git a/src/fillmore/fillmore/fillmore.o b/src/fillmore/fillmore/fillmore.o new file mode 100644 index 0000000..bc71086 Binary files /dev/null and b/src/fillmore/fillmore/fillmore.o differ diff --git a/src/fillmore/fillmore/header_area.c b/src/fillmore/fillmore/header_area.c new file mode 100644 index 0000000..3ca20da --- /dev/null +++ b/src/fillmore/fillmore/header_area.c @@ -0,0 +1,1227 @@ +/* header_area.c generated by valac, the Vala compiler + * generated from header_area.vala, do not modify */ + +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#define TYPE_TRACK_HEADER (track_header_get_type ()) +#define TRACK_HEADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRACK_HEADER, TrackHeader)) +#define TRACK_HEADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TRACK_HEADER, TrackHeaderClass)) +#define IS_TRACK_HEADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRACK_HEADER)) +#define IS_TRACK_HEADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TRACK_HEADER)) +#define TRACK_HEADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TRACK_HEADER, TrackHeaderClass)) + +typedef struct _TrackHeader TrackHeader; +typedef struct _TrackHeaderClass TrackHeaderClass; +typedef struct _TrackHeaderPrivate TrackHeaderPrivate; + +#define TYPE_HEADER_AREA (header_area_get_type ()) +#define HEADER_AREA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_HEADER_AREA, HeaderArea)) +#define HEADER_AREA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_HEADER_AREA, HeaderAreaClass)) +#define IS_HEADER_AREA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_HEADER_AREA)) +#define IS_HEADER_AREA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_HEADER_AREA)) +#define HEADER_AREA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_HEADER_AREA, HeaderAreaClass)) + +typedef struct _HeaderArea HeaderArea; +typedef struct _HeaderAreaClass HeaderAreaClass; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +typedef struct _HeaderAreaPrivate HeaderAreaPrivate; + +#define TYPE_SLIDER_BASE (slider_base_get_type ()) +#define SLIDER_BASE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SLIDER_BASE, SliderBase)) +#define SLIDER_BASE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SLIDER_BASE, SliderBaseClass)) +#define IS_SLIDER_BASE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SLIDER_BASE)) +#define IS_SLIDER_BASE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SLIDER_BASE)) +#define SLIDER_BASE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SLIDER_BASE, SliderBaseClass)) + +typedef struct _SliderBase SliderBase; +typedef struct _SliderBaseClass SliderBaseClass; +typedef struct _SliderBasePrivate SliderBasePrivate; +#define _g_free0(var) (var = (g_free (var), NULL)) +#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL))) + +#define TYPE_PAN_SLIDER (pan_slider_get_type ()) +#define PAN_SLIDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_PAN_SLIDER, PanSlider)) +#define PAN_SLIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_PAN_SLIDER, PanSliderClass)) +#define IS_PAN_SLIDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_PAN_SLIDER)) +#define IS_PAN_SLIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_PAN_SLIDER)) +#define PAN_SLIDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_PAN_SLIDER, PanSliderClass)) + +typedef struct _PanSlider PanSlider; +typedef struct _PanSliderClass PanSliderClass; +typedef struct _PanSliderPrivate PanSliderPrivate; + +#define TYPE_VOLUME_SLIDER (volume_slider_get_type ()) +#define VOLUME_SLIDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_VOLUME_SLIDER, VolumeSlider)) +#define VOLUME_SLIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_VOLUME_SLIDER, VolumeSliderClass)) +#define IS_VOLUME_SLIDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_VOLUME_SLIDER)) +#define IS_VOLUME_SLIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_VOLUME_SLIDER)) +#define VOLUME_SLIDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_VOLUME_SLIDER, VolumeSliderClass)) + +typedef struct _VolumeSlider VolumeSlider; +typedef struct _VolumeSliderClass VolumeSliderClass; +typedef struct _VolumeSliderPrivate VolumeSliderPrivate; + +#define TYPE_AUDIO_TRACK_HEADER (audio_track_header_get_type ()) +#define AUDIO_TRACK_HEADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_AUDIO_TRACK_HEADER, AudioTrackHeader)) +#define AUDIO_TRACK_HEADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_AUDIO_TRACK_HEADER, AudioTrackHeaderClass)) +#define IS_AUDIO_TRACK_HEADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_AUDIO_TRACK_HEADER)) +#define IS_AUDIO_TRACK_HEADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_AUDIO_TRACK_HEADER)) +#define AUDIO_TRACK_HEADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_AUDIO_TRACK_HEADER, AudioTrackHeaderClass)) + +typedef struct _AudioTrackHeader AudioTrackHeader; +typedef struct _AudioTrackHeaderClass AudioTrackHeaderClass; +typedef struct _AudioTrackHeaderPrivate AudioTrackHeaderPrivate; +#define _pango_font_description_free0(var) ((var == NULL) ? NULL : (var = (pango_font_description_free (var), NULL))) + +#define ID_WORKS_TYPE_VOLUME_AND_PAN_POP_UP (id_works_volume_and_pan_pop_up_get_type ()) +#define ID_WORKS_VOLUME_AND_PAN_POP_UP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), ID_WORKS_TYPE_VOLUME_AND_PAN_POP_UP, IdWorksVolumeAndPanPopUp)) +#define ID_WORKS_VOLUME_AND_PAN_POP_UP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ID_WORKS_TYPE_VOLUME_AND_PAN_POP_UP, IdWorksVolumeAndPanPopUpClass)) +#define ID_WORKS_IS_VOLUME_AND_PAN_POP_UP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ID_WORKS_TYPE_VOLUME_AND_PAN_POP_UP)) +#define ID_WORKS_IS_VOLUME_AND_PAN_POP_UP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ID_WORKS_TYPE_VOLUME_AND_PAN_POP_UP)) +#define ID_WORKS_VOLUME_AND_PAN_POP_UP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ID_WORKS_TYPE_VOLUME_AND_PAN_POP_UP, IdWorksVolumeAndPanPopUpClass)) + +typedef struct _IdWorksVolumeAndPanPopUp IdWorksVolumeAndPanPopUp; +typedef struct _IdWorksVolumeAndPanPopUpClass IdWorksVolumeAndPanPopUpClass; + +#define TYPE_RECORDER (recorder_get_type ()) +#define RECORDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_RECORDER, Recorder)) +#define RECORDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_RECORDER, RecorderClass)) +#define IS_RECORDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_RECORDER)) +#define IS_RECORDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_RECORDER)) +#define RECORDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_RECORDER, RecorderClass)) + +typedef struct _Recorder Recorder; +typedef struct _RecorderClass RecorderClass; +typedef struct _RecorderPrivate RecorderPrivate; + +#define MODEL_TYPE_AUDIO_PROJECT (model_audio_project_get_type ()) +#define MODEL_AUDIO_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_AUDIO_PROJECT, ModelAudioProject)) +#define MODEL_AUDIO_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_AUDIO_PROJECT, ModelAudioProjectClass)) +#define MODEL_IS_AUDIO_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_AUDIO_PROJECT)) +#define MODEL_IS_AUDIO_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_AUDIO_PROJECT)) +#define MODEL_AUDIO_PROJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_AUDIO_PROJECT, ModelAudioProjectClass)) + +typedef struct _ModelAudioProject ModelAudioProject; +typedef struct _ModelAudioProjectClass ModelAudioProjectClass; + +#define TYPE_TRACK_SEPARATOR (track_separator_get_type ()) +#define TRACK_SEPARATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRACK_SEPARATOR, TrackSeparator)) +#define TRACK_SEPARATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TRACK_SEPARATOR, TrackSeparatorClass)) +#define IS_TRACK_SEPARATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRACK_SEPARATOR)) +#define IS_TRACK_SEPARATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TRACK_SEPARATOR)) +#define TRACK_SEPARATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TRACK_SEPARATOR, TrackSeparatorClass)) + +typedef struct _TrackSeparator TrackSeparator; +typedef struct _TrackSeparatorClass TrackSeparatorClass; +#define _g_list_free0(var) ((var == NULL) ? NULL : (var = (g_list_free (var), NULL))) + +struct _TrackHeader { + GtkEventBox parent_instance; + TrackHeaderPrivate * priv; + ModelTrack* track; + HeaderArea* header_area; + GtkLabel* track_label; +}; + +struct _TrackHeaderClass { + GtkEventBoxClass parent_class; +}; + +struct _HeaderArea { + GtkEventBox parent_instance; + HeaderAreaPrivate * priv; + GdkColor background_color; +}; + +struct _HeaderAreaClass { + GtkEventBoxClass parent_class; +}; + +struct _SliderBase { + GtkHScrollbar parent_instance; + SliderBasePrivate * priv; +}; + +struct _SliderBaseClass { + GtkHScrollbarClass parent_class; +}; + +struct _SliderBasePrivate { + GdkPixbuf* slider_image; +}; + +struct _PanSlider { + SliderBase parent_instance; + PanSliderPrivate * priv; +}; + +struct _PanSliderClass { + SliderBaseClass parent_class; +}; + +struct _VolumeSlider { + SliderBase parent_instance; + VolumeSliderPrivate * priv; +}; + +struct _VolumeSliderClass { + SliderBaseClass parent_class; +}; + +struct _AudioTrackHeader { + TrackHeader parent_instance; + AudioTrackHeaderPrivate * priv; + double panorama; + double volume; +}; + +struct _AudioTrackHeaderClass { + TrackHeaderClass parent_class; +}; + +struct _HeaderAreaPrivate { + ModelProject* project; + GtkVBox* vbox; +}; + +struct _Recorder { + GtkWindow parent_instance; + RecorderPrivate * priv; + ModelAudioProject* project; + TimeLine* timeline; +}; + +struct _RecorderClass { + GtkWindowClass parent_class; +}; + + +static gpointer track_header_parent_class = NULL; +static gpointer slider_base_parent_class = NULL; +static gpointer pan_slider_parent_class = NULL; +static gpointer volume_slider_parent_class = NULL; +static gpointer audio_track_header_parent_class = NULL; +static gpointer header_area_parent_class = NULL; + +GType track_header_get_type (void); +GType header_area_get_type (void); +enum { + TRACK_HEADER_DUMMY_PROPERTY +}; +#define TRACK_HEADER_width 100 +static void track_header_on_track_renamed (TrackHeader* self); +static void _track_header_on_track_renamed_model_track_track_renamed (ModelTrack* _sender, ModelTrack* track, gpointer self); +static void track_header_on_track_selection_changed (TrackHeader* self, ModelTrack* track); +static void _track_header_on_track_selection_changed_model_track_track_selection_changed (ModelTrack* _sender, ModelTrack* track, gpointer self); +TrackHeader* track_header_new (ModelTrack* track, HeaderArea* area, gint height); +TrackHeader* track_header_construct (GType object_type, ModelTrack* track, HeaderArea* area, gint height); +void header_area_select (HeaderArea* self, ModelTrack* track); +static gboolean track_header_real_button_press_event (GtkWidget* base, GdkEventButton* event); +ModelTrack* track_header_get_track (TrackHeader* self); +static void track_header_finalize (GObject* obj); +GType slider_base_get_type (void); +#define SLIDER_BASE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_SLIDER_BASE, SliderBasePrivate)) +enum { + SLIDER_BASE_DUMMY_PROPERTY +}; +static gboolean slider_base_real_expose_event (GtkWidget* base, GdkEventExpose* event); +SliderBase* slider_base_new (void); +SliderBase* slider_base_construct (GType object_type); +static GObject * slider_base_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties); +static void slider_base_finalize (GObject* obj); +GType pan_slider_get_type (void); +enum { + PAN_SLIDER_DUMMY_PROPERTY +}; +PanSlider* pan_slider_new (void); +PanSlider* pan_slider_construct (GType object_type); +static GObject * pan_slider_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties); +GType volume_slider_get_type (void); +enum { + VOLUME_SLIDER_DUMMY_PROPERTY +}; +VolumeSlider* volume_slider_new (void); +VolumeSlider* volume_slider_construct (GType object_type); +static GObject * volume_slider_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties); +GType audio_track_header_get_type (void); +enum { + AUDIO_TRACK_HEADER_DUMMY_PROPERTY +}; +static void audio_track_header_on_parameter_changed (AudioTrackHeader* self, ModelParameter parameter, double new_value); +static void _audio_track_header_on_parameter_changed_model_audio_track_parameter_changed (ModelAudioTrack* _sender, ModelParameter parameter, double new_value, gpointer self); +static void audio_track_header_do_volpan_popup (AudioTrackHeader* self); +static void _audio_track_header_do_volpan_popup_gtk_button_clicked (GtkButton* _sender, gpointer self); +AudioTrackHeader* audio_track_header_new (ModelAudioTrack* track, HeaderArea* header, gint height); +AudioTrackHeader* audio_track_header_construct (GType object_type, ModelAudioTrack* track, HeaderArea* header, gint height); +IdWorksVolumeAndPanPopUp* id_works_volume_and_pan_pop_up_new (GtkWidget* parent, const char* title); +IdWorksVolumeAndPanPopUp* id_works_volume_and_pan_pop_up_construct (GType object_type, GtkWidget* parent, const char* title); +GType id_works_volume_and_pan_pop_up_get_type (void); +void id_works_volume_and_pan_pop_up_set_volume (IdWorksVolumeAndPanPopUp* self, double volume); +void id_works_volume_and_pan_pop_up_set_panorama (IdWorksVolumeAndPanPopUp* self, double panorama); +static void audio_track_header_on_volume_updated (AudioTrackHeader* self, double val); +static void _audio_track_header_on_volume_updated_id_works_volume_and_pan_pop_up_volume_updated (IdWorksVolumeAndPanPopUp* _sender, double volume, gpointer self); +static void audio_track_header_on_panorama_updated (AudioTrackHeader* self, double val); +static void _audio_track_header_on_panorama_updated_id_works_volume_and_pan_pop_up_panorama_updated (IdWorksVolumeAndPanPopUp* _sender, double panorama, gpointer self); +static void audio_track_header_finalize (GObject* obj); +#define HEADER_AREA_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_HEADER_AREA, HeaderAreaPrivate)) +enum { + HEADER_AREA_DUMMY_PROPERTY +}; +GType recorder_get_type (void); +GType model_audio_project_get_type (void); +void header_area_on_trackview_removed (HeaderArea* self, TrackView* trackview); +static void _header_area_on_trackview_removed_time_line_trackview_removed (TimeLine* _sender, TrackView* trackview, gpointer self); +void header_area_on_trackview_added (HeaderArea* self, TrackView* trackview); +static void _header_area_on_trackview_added_time_line_trackview_added (TimeLine* _sender, TrackView* trackview, gpointer self); +TrackSeparator* track_separator_new (void); +TrackSeparator* track_separator_construct (GType object_type); +GType track_separator_get_type (void); +HeaderArea* header_area_new (Recorder* recorder, ModelTimeSystem* provider, gint height); +HeaderArea* header_area_construct (GType object_type, Recorder* recorder, ModelTimeSystem* provider, gint height); +static void header_area_finalize (GObject* obj); + + + +#line 30 "header_area.vala" +static void _track_header_on_track_renamed_model_track_track_renamed (ModelTrack* _sender, ModelTrack* track, gpointer self) { +#line 308 "header_area.c" + track_header_on_track_renamed (self); +} + + +#line 35 "header_area.vala" +static void _track_header_on_track_selection_changed_model_track_track_selection_changed (ModelTrack* _sender, ModelTrack* track, gpointer self) { +#line 315 "header_area.c" + track_header_on_track_selection_changed (self, track); +} + + +#line 16 "header_area.vala" +TrackHeader* track_header_construct (GType object_type, ModelTrack* track, HeaderArea* area, gint height) { +#line 322 "header_area.c" + TrackHeader * self; + GdkColor _tmp1_; + GdkColor _tmp0_ = {0}; + GtkLabel* _tmp2_; + GdkColor _tmp4_; + GdkColor _tmp3_ = {0}; +#line 16 "header_area.vala" + g_return_val_if_fail (MODEL_IS_TRACK (track), NULL); +#line 16 "header_area.vala" + g_return_val_if_fail (IS_HEADER_AREA (area), NULL); +#line 333 "header_area.c" + self = g_object_newv (object_type, 0, NULL); +#line 17 "header_area.vala" + self->track = track; +#line 18 "header_area.vala" + self->header_area = area; +#line 20 "header_area.vala" + g_signal_connect_object (track, "track-renamed", (GCallback) _track_header_on_track_renamed_model_track_track_renamed, self, 0); +#line 21 "header_area.vala" + g_signal_connect_object (track, "track-selection-changed", (GCallback) _track_header_on_track_selection_changed_model_track_track_selection_changed, self, 0); +#line 22 "header_area.vala" + gtk_widget_set_size_request (GTK_WIDGET (self), TRACK_HEADER_width, height); +#line 23 "header_area.vala" + gtk_widget_modify_bg (GTK_WIDGET (self), GTK_STATE_NORMAL, &self->header_area->background_color); +#line 24 "header_area.vala" + gtk_widget_modify_bg (GTK_WIDGET (self), GTK_STATE_SELECTED, (_tmp1_ = (parse_color ("#68a", &_tmp0_), _tmp0_), &_tmp1_)); +#line 26 "header_area.vala" + self->track_label = (_tmp2_ = g_object_ref_sink ((GtkLabel*) gtk_label_new (track->display_name)), _g_object_unref0 (self->track_label), _tmp2_); +#line 27 "header_area.vala" + gtk_widget_modify_fg (GTK_WIDGET (self->track_label), GTK_STATE_NORMAL, (_tmp4_ = (parse_color ("#fff", &_tmp3_), _tmp3_), &_tmp4_)); +#line 353 "header_area.c" + return self; +} + + +#line 16 "header_area.vala" +TrackHeader* track_header_new (ModelTrack* track, HeaderArea* area, gint height) { +#line 16 "header_area.vala" + return track_header_construct (TYPE_TRACK_HEADER, track, area, height); +#line 362 "header_area.c" +} + + +#line 30 "header_area.vala" +static void track_header_on_track_renamed (TrackHeader* self) { +#line 30 "header_area.vala" + g_return_if_fail (IS_TRACK_HEADER (self)); +#line 31 "header_area.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_track_renamed"); +#line 32 "header_area.vala" + gtk_label_set_text (self->track_label, self->track->display_name); +#line 374 "header_area.c" +} + + +#line 35 "header_area.vala" +static void track_header_on_track_selection_changed (TrackHeader* self, ModelTrack* track) { +#line 380 "header_area.c" + GtkStateType _tmp0_ = 0; +#line 35 "header_area.vala" + g_return_if_fail (IS_TRACK_HEADER (self)); +#line 35 "header_area.vala" + g_return_if_fail (MODEL_IS_TRACK (track)); +#line 36 "header_area.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_track_selection_changed"); +#line 37 "header_area.vala" + if (model_track_get_is_selected (track)) { +#line 37 "header_area.vala" + _tmp0_ = GTK_STATE_SELECTED; +#line 392 "header_area.c" + } else { +#line 37 "header_area.vala" + _tmp0_ = GTK_STATE_NORMAL; +#line 396 "header_area.c" + } +#line 37 "header_area.vala" + gtk_widget_set_state (GTK_WIDGET (self), _tmp0_); +#line 400 "header_area.c" +} + + +#line 40 "header_area.vala" +static gboolean track_header_real_button_press_event (GtkWidget* base, GdkEventButton* event) { +#line 406 "header_area.c" + TrackHeader * self; + gboolean result = FALSE; + self = TRACK_HEADER (base); +#line 41 "header_area.vala" + header_area_select (self->header_area, self->track); +#line 412 "header_area.c" + result = TRUE; +#line 42 "header_area.vala" + return result; +#line 416 "header_area.c" +} + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 45 "header_area.vala" +ModelTrack* track_header_get_track (TrackHeader* self) { +#line 427 "header_area.c" + ModelTrack* result = NULL; +#line 45 "header_area.vala" + g_return_val_if_fail (IS_TRACK_HEADER (self), NULL); +#line 431 "header_area.c" + result = _g_object_ref0 (self->track); +#line 46 "header_area.vala" + return result; +#line 435 "header_area.c" +} + + +static void track_header_class_init (TrackHeaderClass * klass) { + track_header_parent_class = g_type_class_peek_parent (klass); + GTK_WIDGET_CLASS (klass)->button_press_event = track_header_real_button_press_event; + G_OBJECT_CLASS (klass)->finalize = track_header_finalize; +} + + +static void track_header_instance_init (TrackHeader * self) { +} + + +static void track_header_finalize (GObject* obj) { + TrackHeader * self; + self = TRACK_HEADER (obj); + _g_object_unref0 (self->track_label); + G_OBJECT_CLASS (track_header_parent_class)->finalize (obj); +} + + +GType track_header_get_type (void) { + static volatile gsize track_header_type_id__volatile = 0; + if (g_once_init_enter (&track_header_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (TrackHeaderClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) track_header_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (TrackHeader), 0, (GInstanceInitFunc) track_header_instance_init, NULL }; + GType track_header_type_id; + track_header_type_id = g_type_register_static (GTK_TYPE_EVENT_BOX, "TrackHeader", &g_define_type_info, 0); + g_once_init_leave (&track_header_type_id__volatile, track_header_type_id); + } + return track_header_type_id__volatile; +} + + +#line 62 "header_area.vala" +static gboolean slider_base_real_expose_event (GtkWidget* base, GdkEventExpose* event) { +#line 472 "header_area.c" + SliderBase * self; + gboolean result = FALSE; + GdkGC* gc; + gint radius; + gint center; + gint height; + self = SLIDER_BASE (base); +#line 63 "header_area.vala" + gc = _g_object_ref0 (gtk_widget_get_style (GTK_WIDGET (self))->fg_gc[(gint) GTK_STATE_NORMAL]); +#line 64 "header_area.vala" + radius = (GTK_RANGE (self)->slider_end - GTK_RANGE (self)->slider_start) / 2; +#line 65 "header_area.vala" + center = (GTK_WIDGET (self)->allocation.x + GTK_RANGE (self)->slider_start) + radius; +#line 66 "header_area.vala" + height = GTK_WIDGET (self)->allocation.y + (GTK_WIDGET (self)->allocation.height / 2); +#line 68 "header_area.vala" + gdk_draw_rectangle (GDK_DRAWABLE ((*event).window), gc, FALSE, GTK_WIDGET (self)->allocation.x + radius, height - 2, GTK_WIDGET (self)->allocation.width - (2 * radius), 1); +#line 71 "header_area.vala" + gdk_draw_pixbuf (GDK_DRAWABLE ((*event).window), gc, self->priv->slider_image, 0, 0, center - radius, GTK_WIDGET (self)->allocation.y + 2, gdk_pixbuf_get_width (self->priv->slider_image), gdk_pixbuf_get_height (self->priv->slider_image), GDK_RGB_DITHER_NORMAL, 0, 0); +#line 492 "header_area.c" + result = TRUE; + _g_object_unref0 (gc); +#line 73 "header_area.vala" + return result; +#line 497 "header_area.c" +} + + +#line 50 "header_area.vala" +SliderBase* slider_base_construct (GType object_type) { +#line 503 "header_area.c" + SliderBase * self; + self = g_object_newv (object_type, 0, NULL); + return self; +} + + +#line 50 "header_area.vala" +SliderBase* slider_base_new (void) { +#line 50 "header_area.vala" + return slider_base_construct (TYPE_SLIDER_BASE); +#line 514 "header_area.c" +} + + +static GObject * slider_base_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) { + GObject * obj; + GObjectClass * parent_class; + SliderBase * self; + GError * _inner_error_; + parent_class = G_OBJECT_CLASS (slider_base_parent_class); + obj = parent_class->constructor (type, n_construct_properties, construct_properties); + self = SLIDER_BASE (obj); + _inner_error_ = NULL; + { +#line 53 "header_area.vala" + g_object_set (GTK_WIDGET (self), "can-focus", TRUE, NULL); +#line 530 "header_area.c" + { + char* _tmp2_; + GFile* _tmp1_; + GFile* _tmp0_; + GdkPixbuf* _tmp3_; + GdkPixbuf* _tmp4_; + GdkPixbuf* _tmp5_; +#line 55 "header_area.vala" + _tmp4_ = (_tmp3_ = gdk_pixbuf_new_from_file (_tmp2_ = g_file_get_path (_tmp1_ = g_file_get_child (_tmp0_ = app_dirs_get_resources_dir (), "dot.png")), &_inner_error_), _g_free0 (_tmp2_), _g_object_unref0 (_tmp1_), _g_object_unref0 (_tmp0_), _tmp3_); +#line 540 "header_area.c" + if (_inner_error_ != NULL) { + goto __catch14_g_error; + } +#line 55 "header_area.vala" + self->priv->slider_image = (_tmp5_ = _tmp4_, _g_object_unref0 (self->priv->slider_image), _tmp5_); +#line 546 "header_area.c" + } + goto __finally14; + __catch14_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { +#line 58 "header_area.vala" + g_warning ("header_area.vala:58: Could not load resource for slider: %s", e->message); +#line 557 "header_area.c" + _g_error_free0 (e); + } + } + __finally14: + if (_inner_error_ != NULL) { + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + } + } + return obj; +} + + +static void slider_base_class_init (SliderBaseClass * klass) { + slider_base_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (SliderBasePrivate)); + GTK_WIDGET_CLASS (klass)->expose_event = slider_base_real_expose_event; + G_OBJECT_CLASS (klass)->constructor = slider_base_constructor; + G_OBJECT_CLASS (klass)->finalize = slider_base_finalize; +} + + +static void slider_base_instance_init (SliderBase * self) { + self->priv = SLIDER_BASE_GET_PRIVATE (self); +} + + +static void slider_base_finalize (GObject* obj) { + SliderBase * self; + self = SLIDER_BASE (obj); + _g_object_unref0 (self->priv->slider_image); + G_OBJECT_CLASS (slider_base_parent_class)->finalize (obj); +} + + +GType slider_base_get_type (void) { + static volatile gsize slider_base_type_id__volatile = 0; + if (g_once_init_enter (&slider_base_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (SliderBaseClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) slider_base_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SliderBase), 0, (GInstanceInitFunc) slider_base_instance_init, NULL }; + GType slider_base_type_id; + slider_base_type_id = g_type_register_static (GTK_TYPE_HSCROLLBAR, "SliderBase", &g_define_type_info, 0); + g_once_init_leave (&slider_base_type_id__volatile, slider_base_type_id); + } + return slider_base_type_id__volatile; +} + + +#line 77 "header_area.vala" +PanSlider* pan_slider_construct (GType object_type) { +#line 607 "header_area.c" + PanSlider * self; + self = g_object_newv (object_type, 0, NULL); + return self; +} + + +#line 77 "header_area.vala" +PanSlider* pan_slider_new (void) { +#line 77 "header_area.vala" + return pan_slider_construct (TYPE_PAN_SLIDER); +#line 618 "header_area.c" +} + + +static GObject * pan_slider_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) { + GObject * obj; + GObjectClass * parent_class; + PanSlider * self; + parent_class = G_OBJECT_CLASS (pan_slider_parent_class); + obj = parent_class->constructor (type, n_construct_properties, construct_properties); + self = PAN_SLIDER (obj); + { + } + return obj; +} + + +static void pan_slider_class_init (PanSliderClass * klass) { + pan_slider_parent_class = g_type_class_peek_parent (klass); + G_OBJECT_CLASS (klass)->constructor = pan_slider_constructor; +} + + +static void pan_slider_instance_init (PanSlider * self) { +} + + +GType pan_slider_get_type (void) { + static volatile gsize pan_slider_type_id__volatile = 0; + if (g_once_init_enter (&pan_slider_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (PanSliderClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) pan_slider_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (PanSlider), 0, (GInstanceInitFunc) pan_slider_instance_init, NULL }; + GType pan_slider_type_id; + pan_slider_type_id = g_type_register_static (TYPE_SLIDER_BASE, "PanSlider", &g_define_type_info, 0); + g_once_init_leave (&pan_slider_type_id__volatile, pan_slider_type_id); + } + return pan_slider_type_id__volatile; +} + + +#line 82 "header_area.vala" +VolumeSlider* volume_slider_construct (GType object_type) { +#line 659 "header_area.c" + VolumeSlider * self; + self = g_object_newv (object_type, 0, NULL); + return self; +} + + +#line 82 "header_area.vala" +VolumeSlider* volume_slider_new (void) { +#line 82 "header_area.vala" + return volume_slider_construct (TYPE_VOLUME_SLIDER); +#line 670 "header_area.c" +} + + +static GObject * volume_slider_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) { + GObject * obj; + GObjectClass * parent_class; + VolumeSlider * self; + parent_class = G_OBJECT_CLASS (volume_slider_parent_class); + obj = parent_class->constructor (type, n_construct_properties, construct_properties); + self = VOLUME_SLIDER (obj); + { + } + return obj; +} + + +static void volume_slider_class_init (VolumeSliderClass * klass) { + volume_slider_parent_class = g_type_class_peek_parent (klass); + G_OBJECT_CLASS (klass)->constructor = volume_slider_constructor; +} + + +static void volume_slider_instance_init (VolumeSlider * self) { +} + + +GType volume_slider_get_type (void) { + static volatile gsize volume_slider_type_id__volatile = 0; + if (g_once_init_enter (&volume_slider_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (VolumeSliderClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) volume_slider_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (VolumeSlider), 0, (GInstanceInitFunc) volume_slider_instance_init, NULL }; + GType volume_slider_type_id; + volume_slider_type_id = g_type_register_static (TYPE_SLIDER_BASE, "VolumeSlider", &g_define_type_info, 0); + g_once_init_leave (&volume_slider_type_id__volatile, volume_slider_type_id); + } + return volume_slider_type_id__volatile; +} + + +#line 164 "header_area.vala" +static void _audio_track_header_on_parameter_changed_model_audio_track_parameter_changed (ModelAudioTrack* _sender, ModelParameter parameter, double new_value, gpointer self) { +#line 711 "header_area.c" + audio_track_header_on_parameter_changed (self, parameter, new_value); +} + + +#line 119 "header_area.vala" +static void _audio_track_header_do_volpan_popup_gtk_button_clicked (GtkButton* _sender, gpointer self) { +#line 718 "header_area.c" + audio_track_header_do_volpan_popup (self); +} + + +#line 91 "header_area.vala" +AudioTrackHeader* audio_track_header_construct (GType object_type, ModelAudioTrack* track, HeaderArea* header, gint height) { +#line 725 "header_area.c" + AudioTrackHeader * self; + PangoFontDescription* _tmp0_; + GtkVBox* vbox; + HildonButton* volpan_button; + GtkImage* _tmp1_; +#line 91 "header_area.vala" + g_return_val_if_fail (MODEL_IS_AUDIO_TRACK (track), NULL); +#line 91 "header_area.vala" + g_return_val_if_fail (IS_HEADER_AREA (header), NULL); +#line 92 "header_area.vala" + self = (AudioTrackHeader*) track_header_construct (object_type, MODEL_TRACK (track), header, height); +#line 94 "header_area.vala" + gtk_widget_modify_font (GTK_WIDGET (TRACK_HEADER (self)->track_label), _tmp0_ = pango_font_description_from_string ("Sans 10")); +#line 739 "header_area.c" + _pango_font_description_free0 (_tmp0_); +#line 95 "header_area.vala" + gtk_misc_set_padding (GTK_MISC (TRACK_HEADER (self)->track_label), 4, 2); +#line 96 "header_area.vala" + gtk_misc_set_alignment (GTK_MISC (TRACK_HEADER (self)->track_label), (float) 0, (float) 0); +#line 98 "header_area.vala" + g_signal_connect_object (track, "parameter-changed", (GCallback) _audio_track_header_on_parameter_changed_model_audio_track_parameter_changed, self, 0); +#line 100 "header_area.vala" + self->volume = model_audio_track_get_volume (track); +#line 101 "header_area.vala" + self->panorama = model_audio_track_get_pan (track); +#line 103 "header_area.vala" + vbox = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (FALSE, 0)); +#line 104 "header_area.vala" + gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (TRACK_HEADER (self)->track_label), TRUE, TRUE, (guint) 0); +#line 105 "header_area.vala" + volpan_button = g_object_ref_sink ((HildonButton*) hildon_button_new (HILDON_SIZE_AUTO_HEIGHT | HILDON_SIZE_AUTO_WIDTH, HILDON_BUTTON_ARRANGEMENT_HORIZONTAL)); +#line 107 "header_area.vala" + hildon_button_set_image (volpan_button, GTK_WIDGET (_tmp1_ = g_object_ref_sink ((GtkImage*) gtk_image_new_from_icon_name ("statusarea_volumelevel4", GTK_ICON_SIZE_BUTTON)))); +#line 759 "header_area.c" + _g_object_unref0 (_tmp1_); +#line 108 "header_area.vala" + hildon_button_set_image_position (volpan_button, GTK_POS_LEFT); +#line 109 "header_area.vala" + g_signal_connect_object (GTK_BUTTON (volpan_button), "clicked", (GCallback) _audio_track_header_do_volpan_popup_gtk_button_clicked, self, 0); +#line 110 "header_area.vala" + gtk_container_add (GTK_CONTAINER (vbox), GTK_WIDGET (volpan_button)); +#line 116 "header_area.vala" + gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (vbox)); +#line 769 "header_area.c" + _g_object_unref0 (vbox); + _g_object_unref0 (volpan_button); + return self; +} + + +#line 91 "header_area.vala" +AudioTrackHeader* audio_track_header_new (ModelAudioTrack* track, HeaderArea* header, gint height) { +#line 91 "header_area.vala" + return audio_track_header_construct (TYPE_AUDIO_TRACK_HEADER, track, header, height); +#line 780 "header_area.c" +} + + +#line 148 "header_area.vala" +static void _audio_track_header_on_volume_updated_id_works_volume_and_pan_pop_up_volume_updated (IdWorksVolumeAndPanPopUp* _sender, double volume, gpointer self) { +#line 786 "header_area.c" + audio_track_header_on_volume_updated (self, volume); +} + + +#line 131 "header_area.vala" +static void _audio_track_header_on_panorama_updated_id_works_volume_and_pan_pop_up_panorama_updated (IdWorksVolumeAndPanPopUp* _sender, double panorama, gpointer self) { +#line 793 "header_area.c" + audio_track_header_on_panorama_updated (self, panorama); +} + + +#line 119 "header_area.vala" +static void audio_track_header_do_volpan_popup (AudioTrackHeader* self) { +#line 800 "header_area.c" + char* _tmp0_; + IdWorksVolumeAndPanPopUp* _tmp1_; + IdWorksVolumeAndPanPopUp* dlg; + IdWorksVolumeAndPanPopUp* _tmp2_; +#line 119 "header_area.vala" + g_return_if_fail (IS_AUDIO_TRACK_HEADER (self)); +#line 120 "header_area.vala" + dlg = (_tmp1_ = g_object_ref_sink (id_works_volume_and_pan_pop_up_new (GTK_WIDGET (self), _tmp0_ = g_strconcat ("Volume / Pan: ", TRACK_HEADER (self)->track->display_name, NULL))), _g_free0 (_tmp0_), _tmp1_); +#line 122 "header_area.vala" + id_works_volume_and_pan_pop_up_set_volume (dlg, self->volume); +#line 123 "header_area.vala" + id_works_volume_and_pan_pop_up_set_panorama (dlg, self->panorama); +#line 124 "header_area.vala" + g_signal_connect_object (dlg, "volume-updated", (GCallback) _audio_track_header_on_volume_updated_id_works_volume_and_pan_pop_up_volume_updated, self, 0); +#line 125 "header_area.vala" + g_signal_connect_object (dlg, "panorama-updated", (GCallback) _audio_track_header_on_panorama_updated_id_works_volume_and_pan_pop_up_panorama_updated, self, 0); +#line 126 "header_area.vala" + gtk_dialog_run (GTK_DIALOG (dlg)); +#line 127 "header_area.vala" + gtk_object_destroy (GTK_OBJECT (dlg)); +#line 128 "header_area.vala" + dlg = (_tmp2_ = NULL, _g_object_unref0 (dlg), _tmp2_); +#line 823 "header_area.c" + _g_object_unref0 (dlg); +} + + +#line 131 "header_area.vala" +static void audio_track_header_on_panorama_updated (AudioTrackHeader* self, double val) { +#line 830 "header_area.c" + ModelTrack* _tmp0_; + ModelAudioTrack* audio_track; +#line 131 "header_area.vala" + g_return_if_fail (IS_AUDIO_TRACK_HEADER (self)); +#line 132 "header_area.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_pan_value_changed"); +#line 133 "header_area.vala" + audio_track = _g_object_ref0 ((_tmp0_ = TRACK_HEADER (self)->track, MODEL_IS_AUDIO_TRACK (_tmp0_) ? ((ModelAudioTrack*) _tmp0_) : NULL)); +#line 134 "header_area.vala" + if (audio_track != NULL) { +#line 135 "header_area.vala" + model_audio_track_set_pan (audio_track, val); +#line 843 "header_area.c" + } + _g_object_unref0 (audio_track); +} + + +#line 148 "header_area.vala" +static void audio_track_header_on_volume_updated (AudioTrackHeader* self, double val) { +#line 851 "header_area.c" + ModelTrack* _tmp0_; + ModelAudioTrack* audio_track; +#line 148 "header_area.vala" + g_return_if_fail (IS_AUDIO_TRACK_HEADER (self)); +#line 149 "header_area.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_volume_value_changed"); +#line 150 "header_area.vala" + audio_track = _g_object_ref0 ((_tmp0_ = TRACK_HEADER (self)->track, MODEL_IS_AUDIO_TRACK (_tmp0_) ? ((ModelAudioTrack*) _tmp0_) : NULL)); +#line 151 "header_area.vala" + if (audio_track != NULL) { +#line 152 "header_area.vala" + model_audio_track_set_volume (audio_track, val); +#line 864 "header_area.c" + } + _g_object_unref0 (audio_track); +} + + +#line 164 "header_area.vala" +static void audio_track_header_on_parameter_changed (AudioTrackHeader* self, ModelParameter parameter, double new_value) { +#line 872 "header_area.c" + ModelTrack* _tmp0_; + ModelAudioTrack* audio_track; +#line 164 "header_area.vala" + g_return_if_fail (IS_AUDIO_TRACK_HEADER (self)); +#line 165 "header_area.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_parameter_changed"); +#line 166 "header_area.vala" + audio_track = _g_object_ref0 ((_tmp0_ = TRACK_HEADER (self)->track, MODEL_IS_AUDIO_TRACK (_tmp0_) ? ((ModelAudioTrack*) _tmp0_) : NULL)); +#line 167 "header_area.vala" + g_assert (audio_track != NULL); +#line 168 "header_area.vala" + switch (parameter) { +#line 885 "header_area.c" + case MODEL_PARAMETER_VOLUME: + { +#line 170 "header_area.vala" + self->volume = new_value; +#line 171 "header_area.vala" + break; +#line 892 "header_area.c" + } + case MODEL_PARAMETER_PAN: + { +#line 173 "header_area.vala" + self->panorama = new_value; +#line 174 "header_area.vala" + break; +#line 900 "header_area.c" + } + } + _g_object_unref0 (audio_track); +} + + +static void audio_track_header_class_init (AudioTrackHeaderClass * klass) { + audio_track_header_parent_class = g_type_class_peek_parent (klass); + G_OBJECT_CLASS (klass)->finalize = audio_track_header_finalize; +} + + +static void audio_track_header_instance_init (AudioTrackHeader * self) { +} + + +static void audio_track_header_finalize (GObject* obj) { + AudioTrackHeader * self; + self = AUDIO_TRACK_HEADER (obj); + G_OBJECT_CLASS (audio_track_header_parent_class)->finalize (obj); +} + + +GType audio_track_header_get_type (void) { + static volatile gsize audio_track_header_type_id__volatile = 0; + if (g_once_init_enter (&audio_track_header_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (AudioTrackHeaderClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) audio_track_header_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (AudioTrackHeader), 0, (GInstanceInitFunc) audio_track_header_instance_init, NULL }; + GType audio_track_header_type_id; + audio_track_header_type_id = g_type_register_static (TYPE_TRACK_HEADER, "AudioTrackHeader", &g_define_type_info, 0); + g_once_init_leave (&audio_track_header_type_id__volatile, audio_track_header_type_id); + } + return audio_track_header_type_id__volatile; +} + + +#line 233 "header_area.vala" +static void _header_area_on_trackview_removed_time_line_trackview_removed (TimeLine* _sender, TrackView* trackview, gpointer self) { +#line 938 "header_area.c" + header_area_on_trackview_removed (self, trackview); +} + + +#line 219 "header_area.vala" +static void _header_area_on_trackview_added_time_line_trackview_added (TimeLine* _sender, TrackView* trackview, gpointer self) { +#line 945 "header_area.c" + header_area_on_trackview_added (self, trackview); +} + + +#line 198 "header_area.vala" +HeaderArea* header_area_construct (GType object_type, Recorder* recorder, ModelTimeSystem* provider, gint height) { +#line 952 "header_area.c" + HeaderArea * self; + GtkVBox* _tmp0_; + GtkDrawingArea* status_bar; + TrackSeparator* _tmp1_; +#line 198 "header_area.vala" + g_return_val_if_fail (IS_RECORDER (recorder), NULL); +#line 198 "header_area.vala" + g_return_val_if_fail (MODEL_IS_TIME_SYSTEM (provider), NULL); +#line 961 "header_area.c" + self = g_object_newv (object_type, 0, NULL); +#line 199 "header_area.vala" + self->priv->project = MODEL_PROJECT (recorder->project); +#line 200 "header_area.vala" + g_signal_connect_object (recorder->timeline, "trackview-removed", (GCallback) _header_area_on_trackview_removed_time_line_trackview_removed, self, 0); +#line 201 "header_area.vala" + g_signal_connect_object (recorder->timeline, "trackview-added", (GCallback) _header_area_on_trackview_added_time_line_trackview_added, self, 0); +#line 203 "header_area.vala" + gtk_widget_set_size_request (GTK_WIDGET (self), TRACK_HEADER_width, 0); +#line 204 "header_area.vala" + gtk_widget_modify_bg (GTK_WIDGET (self), GTK_STATE_NORMAL, &self->background_color); +#line 206 "header_area.vala" + self->priv->vbox = (_tmp0_ = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (FALSE, 0)), _g_object_unref0 (self->priv->vbox), _tmp0_); +#line 207 "header_area.vala" + gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (self->priv->vbox)); +#line 208 "header_area.vala" + status_bar = GTK_DRAWING_AREA (g_object_ref_sink (view_status_bar_new (self->priv->project, provider, height))); +#line 210 "header_area.vala" + gtk_box_pack_start (GTK_BOX (self->priv->vbox), GTK_WIDGET (status_bar), FALSE, FALSE, (guint) 0); +#line 212 "header_area.vala" + gtk_box_pack_start (GTK_BOX (self->priv->vbox), GTK_WIDGET (_tmp1_ = g_object_ref_sink (track_separator_new ())), FALSE, FALSE, (guint) 0); +#line 983 "header_area.c" + _g_object_unref0 (_tmp1_); + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (recorder->timeline->tracks)); +#line 214 "header_area.vala" + while (TRUE) { +#line 990 "header_area.c" + TrackView* track; +#line 214 "header_area.vala" + if (!gee_iterator_next (_track_it)) { +#line 214 "header_area.vala" + break; +#line 996 "header_area.c" + } +#line 214 "header_area.vala" + track = (TrackView*) gee_iterator_get (_track_it); +#line 215 "header_area.vala" + header_area_on_trackview_added (self, track); +#line 1002 "header_area.c" + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } + _g_object_unref0 (status_bar); + return self; +} + + +#line 198 "header_area.vala" +HeaderArea* header_area_new (Recorder* recorder, ModelTimeSystem* provider, gint height) { +#line 198 "header_area.vala" + return header_area_construct (TYPE_HEADER_AREA, recorder, provider, height); +#line 1016 "header_area.c" +} + + +#line 219 "header_area.vala" +void header_area_on_trackview_added (HeaderArea* self, TrackView* trackview) { +#line 1022 "header_area.c" + ModelTrack* _tmp0_; + ModelAudioTrack* audio_track; + TrackHeader* header; + TrackSeparator* _tmp1_; +#line 219 "header_area.vala" + g_return_if_fail (IS_HEADER_AREA (self)); +#line 219 "header_area.vala" + g_return_if_fail (IS_TRACK_VIEW (trackview)); +#line 220 "header_area.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_trackview_added"); +#line 221 "header_area.vala" + audio_track = (_tmp0_ = track_view_get_track (trackview), MODEL_IS_AUDIO_TRACK (_tmp0_) ? ((ModelAudioTrack*) _tmp0_) : NULL); +#line 222 "header_area.vala" + g_assert (audio_track != NULL); +#line 226 "header_area.vala" + header = TRACK_HEADER (g_object_ref_sink (audio_track_header_new (audio_track, self, track_view_get_track_height (trackview)))); +#line 227 "header_area.vala" + gtk_box_pack_start (GTK_BOX (self->priv->vbox), GTK_WIDGET (header), FALSE, FALSE, (guint) 0); +#line 228 "header_area.vala" + gtk_box_pack_start (GTK_BOX (self->priv->vbox), GTK_WIDGET (_tmp1_ = g_object_ref_sink (track_separator_new ())), FALSE, FALSE, (guint) 0); +#line 1043 "header_area.c" + _g_object_unref0 (_tmp1_); +#line 229 "header_area.vala" + gtk_widget_show_all (GTK_WIDGET (self->priv->vbox)); +#line 230 "header_area.vala" + header_area_select (self, MODEL_TRACK (audio_track)); +#line 1049 "header_area.c" + _g_object_unref0 (audio_track); + _g_object_unref0 (header); +} + + +#line 233 "header_area.vala" +void header_area_on_trackview_removed (HeaderArea* self, TrackView* trackview) { +#line 1057 "header_area.c" + ModelTrack* track; + TrackHeader* my_track_header; + GtkHSeparator* my_separator; +#line 233 "header_area.vala" + g_return_if_fail (IS_HEADER_AREA (self)); +#line 233 "header_area.vala" + g_return_if_fail (IS_TRACK_VIEW (trackview)); +#line 234 "header_area.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_trackview_removed"); +#line 235 "header_area.vala" + track = track_view_get_track (trackview); +#line 236 "header_area.vala" + my_track_header = NULL; +#line 237 "header_area.vala" + my_separator = NULL; +#line 1073 "header_area.c" + { + GList* widget_collection; + GList* widget_it; +#line 238 "header_area.vala" + widget_collection = gtk_container_get_children (GTK_CONTAINER (self->priv->vbox)); +#line 1079 "header_area.c" + for (widget_it = widget_collection; widget_it != NULL; widget_it = widget_it->next) { + GtkWidget* widget; +#line 238 "header_area.vala" + widget = _g_object_ref0 ((GtkWidget*) widget_it->data); +#line 1084 "header_area.c" + { +#line 239 "header_area.vala" + if (my_track_header == NULL) { +#line 1088 "header_area.c" + GtkWidget* _tmp0_; + TrackHeader* track_header; + gboolean _tmp1_ = FALSE; +#line 240 "header_area.vala" + track_header = _g_object_ref0 ((_tmp0_ = widget, IS_TRACK_HEADER (_tmp0_) ? ((TrackHeader*) _tmp0_) : NULL)); +#line 241 "header_area.vala" + if (track_header != NULL) { +#line 1096 "header_area.c" + ModelTrack* _tmp2_; +#line 241 "header_area.vala" + _tmp1_ = (_tmp2_ = track_header_get_track (track_header)) == track; +#line 1100 "header_area.c" + _g_object_unref0 (_tmp2_); + } else { +#line 241 "header_area.vala" + _tmp1_ = FALSE; +#line 1105 "header_area.c" + } +#line 241 "header_area.vala" + if (_tmp1_) { +#line 1109 "header_area.c" + TrackHeader* _tmp3_; +#line 242 "header_area.vala" + my_track_header = (_tmp3_ = _g_object_ref0 (track_header), _g_object_unref0 (my_track_header), _tmp3_); +#line 1113 "header_area.c" + } + _g_object_unref0 (track_header); + } else { + GtkHSeparator* _tmp5_; + GtkWidget* _tmp4_; +#line 245 "header_area.vala" + my_separator = (_tmp5_ = _g_object_ref0 ((_tmp4_ = widget, GTK_IS_HSEPARATOR (_tmp4_) ? ((GtkHSeparator*) _tmp4_) : NULL)), _g_object_unref0 (my_separator), _tmp5_); +#line 1121 "header_area.c" + _g_object_unref0 (widget); +#line 246 "header_area.vala" + break; +#line 1125 "header_area.c" + } + _g_object_unref0 (widget); + } + } +#line 238 "header_area.vala" + _g_list_free0 (widget_collection); +#line 1132 "header_area.c" + } +#line 250 "header_area.vala" + if (my_track_header != NULL) { +#line 251 "header_area.vala" + gtk_container_remove (GTK_CONTAINER (self->priv->vbox), GTK_WIDGET (my_track_header)); +#line 1138 "header_area.c" + } +#line 254 "header_area.vala" + if (my_separator != NULL) { +#line 255 "header_area.vala" + gtk_container_remove (GTK_CONTAINER (self->priv->vbox), GTK_WIDGET (my_separator)); +#line 1144 "header_area.c" + } +#line 258 "header_area.vala" + if (gee_collection_get_size (GEE_COLLECTION (self->priv->project->tracks)) != 0) { +#line 1148 "header_area.c" + ModelTrack* _tmp6_; +#line 259 "header_area.vala" + header_area_select (self, _tmp6_ = (ModelTrack*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->priv->project->tracks), 0)); +#line 1152 "header_area.c" + _g_object_unref0 (_tmp6_); + } + _g_object_unref0 (track); + _g_object_unref0 (my_track_header); + _g_object_unref0 (my_separator); +} + + +#line 263 "header_area.vala" +void header_area_select (HeaderArea* self, ModelTrack* track) { +#line 263 "header_area.vala" + g_return_if_fail (IS_HEADER_AREA (self)); +#line 263 "header_area.vala" + g_return_if_fail (MODEL_IS_TRACK (track)); +#line 1167 "header_area.c" + { + GeeIterator* _t_it; + _t_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->priv->project->tracks)); +#line 264 "header_area.vala" + while (TRUE) { +#line 1173 "header_area.c" + ModelTrack* t; +#line 264 "header_area.vala" + if (!gee_iterator_next (_t_it)) { +#line 264 "header_area.vala" + break; +#line 1179 "header_area.c" + } +#line 264 "header_area.vala" + t = (ModelTrack*) gee_iterator_get (_t_it); +#line 265 "header_area.vala" + model_track_set_selected (t, t == track); +#line 1185 "header_area.c" + _g_object_unref0 (t); + } + _g_object_unref0 (_t_it); + } +} + + +static void header_area_class_init (HeaderAreaClass * klass) { + header_area_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (HeaderAreaPrivate)); + G_OBJECT_CLASS (klass)->finalize = header_area_finalize; +} + + +static void header_area_instance_init (HeaderArea * self) { + GdkColor _tmp6_ = {0}; + self->priv = HEADER_AREA_GET_PRIVATE (self); + self->background_color = (parse_color ("#666", &_tmp6_), _tmp6_); +} + + +static void header_area_finalize (GObject* obj) { + HeaderArea * self; + self = HEADER_AREA (obj); + _g_object_unref0 (self->priv->vbox); + G_OBJECT_CLASS (header_area_parent_class)->finalize (obj); +} + + +GType header_area_get_type (void) { + static volatile gsize header_area_type_id__volatile = 0; + if (g_once_init_enter (&header_area_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (HeaderAreaClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) header_area_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (HeaderArea), 0, (GInstanceInitFunc) header_area_instance_init, NULL }; + GType header_area_type_id; + header_area_type_id = g_type_register_static (GTK_TYPE_EVENT_BOX, "HeaderArea", &g_define_type_info, 0); + g_once_init_leave (&header_area_type_id__volatile, header_area_type_id); + } + return header_area_type_id__volatile; +} + + + + diff --git a/src/fillmore/fillmore/header_area.o b/src/fillmore/fillmore/header_area.o new file mode 100644 index 0000000..0e68c59 Binary files /dev/null and b/src/fillmore/fillmore/header_area.o differ diff --git a/src/fillmore/fillmore/trackinformation.c b/src/fillmore/fillmore/trackinformation.c new file mode 100644 index 0000000..730e6b4 --- /dev/null +++ b/src/fillmore/fillmore/trackinformation.c @@ -0,0 +1,243 @@ +/* trackinformation.c generated by valac, the Vala compiler + * generated from trackinformation.vala, do not modify */ + +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include + + +#define UI_TYPE_TRACK_INFORMATION (ui_track_information_get_type ()) +#define UI_TRACK_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UI_TYPE_TRACK_INFORMATION, UITrackInformation)) +#define UI_TRACK_INFORMATION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), UI_TYPE_TRACK_INFORMATION, UITrackInformationClass)) +#define UI_IS_TRACK_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UI_TYPE_TRACK_INFORMATION)) +#define UI_IS_TRACK_INFORMATION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), UI_TYPE_TRACK_INFORMATION)) +#define UI_TRACK_INFORMATION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), UI_TYPE_TRACK_INFORMATION, UITrackInformationClass)) + +typedef struct _UITrackInformation UITrackInformation; +typedef struct _UITrackInformationClass UITrackInformationClass; +typedef struct _UITrackInformationPrivate UITrackInformationPrivate; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +#define _g_free0(var) (var = (g_free (var), NULL)) + +struct _UITrackInformation { + HildonDialog parent_instance; + UITrackInformationPrivate * priv; +}; + +struct _UITrackInformationClass { + HildonDialogClass parent_class; +}; + +struct _UITrackInformationPrivate { + HildonEntry* entry; +}; + + +static gpointer ui_track_information_parent_class = NULL; + +GType ui_track_information_get_type (void); +#define UI_TRACK_INFORMATION_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), UI_TYPE_TRACK_INFORMATION, UITrackInformationPrivate)) +enum { + UI_TRACK_INFORMATION_DUMMY_PROPERTY +}; +void ui_track_information_set_track_name (UITrackInformation* self, const char* new_name); +char* ui_track_information_get_track_name (UITrackInformation* self); +static void ui_track_information_on_entry_changed (UITrackInformation* self); +UITrackInformation* ui_track_information_new (void); +UITrackInformation* ui_track_information_construct (GType object_type); +static void _ui_track_information_on_entry_changed_gtk_editable_changed (GtkEditable* _sender, gpointer self); +static GObject * ui_track_information_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties); +static void ui_track_information_finalize (GObject* obj); + + + +#line 34 "trackinformation.vala" +void ui_track_information_set_track_name (UITrackInformation* self, const char* new_name) { +#line 34 "trackinformation.vala" + g_return_if_fail (UI_IS_TRACK_INFORMATION (self)); +#line 34 "trackinformation.vala" + g_return_if_fail (new_name != NULL); +#line 35 "trackinformation.vala" + hildon_entry_set_text (self->priv->entry, new_name); +#line 36 "trackinformation.vala" + gtk_editable_select_region (GTK_EDITABLE (self->priv->entry), 0, -1); +#line 74 "trackinformation.c" +} + + +#line 1018 "glib-2.0.vapi" +static char* string_strip (const char* self) { +#line 80 "trackinformation.c" + char* result = NULL; + char* _result_; +#line 1018 "glib-2.0.vapi" + g_return_val_if_fail (self != NULL, NULL); +#line 1019 "glib-2.0.vapi" + _result_ = g_strdup (self); +#line 1020 "glib-2.0.vapi" + g_strstrip (_result_); +#line 89 "trackinformation.c" + result = _result_; +#line 1021 "glib-2.0.vapi" + return result; +#line 93 "trackinformation.c" +} + + +#line 39 "trackinformation.vala" +char* ui_track_information_get_track_name (UITrackInformation* self) { +#line 99 "trackinformation.c" + char* result = NULL; +#line 39 "trackinformation.vala" + g_return_val_if_fail (UI_IS_TRACK_INFORMATION (self), NULL); +#line 103 "trackinformation.c" + result = string_strip (hildon_entry_get_text (self->priv->entry)); +#line 40 "trackinformation.vala" + return result; +#line 107 "trackinformation.c" +} + + +static glong string_get_length (const char* self) { + glong result; + g_return_val_if_fail (self != NULL, 0L); + result = g_utf8_strlen (self, -1); +#line 1158 "glib-2.0.vapi" + return result; +#line 117 "trackinformation.c" +} + + +#line 43 "trackinformation.vala" +static void ui_track_information_on_entry_changed (UITrackInformation* self) { +#line 123 "trackinformation.c" + char* _tmp0_; + gboolean _tmp1_; + gboolean is_valid; +#line 43 "trackinformation.vala" + g_return_if_fail (UI_IS_TRACK_INFORMATION (self)); +#line 44 "trackinformation.vala" + is_valid = (_tmp1_ = string_get_length (_tmp0_ = ui_track_information_get_track_name (self)) > 0, _g_free0 (_tmp0_), _tmp1_); +#line 45 "trackinformation.vala" + gtk_dialog_set_response_sensitive (GTK_DIALOG (self), (gint) GTK_RESPONSE_OK, is_valid); +#line 133 "trackinformation.c" +} + + +#line 8 "trackinformation.vala" +UITrackInformation* ui_track_information_construct (GType object_type) { +#line 139 "trackinformation.c" + UITrackInformation * self; + self = g_object_newv (object_type, 0, NULL); + return self; +} + + +#line 8 "trackinformation.vala" +UITrackInformation* ui_track_information_new (void) { +#line 8 "trackinformation.vala" + return ui_track_information_construct (UI_TYPE_TRACK_INFORMATION); +#line 150 "trackinformation.c" +} + + +#line 43 "trackinformation.vala" +static void _ui_track_information_on_entry_changed_gtk_editable_changed (GtkEditable* _sender, gpointer self) { +#line 156 "trackinformation.c" + ui_track_information_on_entry_changed (self); +} + + +static GObject * ui_track_information_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) { + GObject * obj; + GObjectClass * parent_class; + UITrackInformation * self; + parent_class = G_OBJECT_CLASS (ui_track_information_parent_class); + obj = parent_class->constructor (type, n_construct_properties, construct_properties); + self = UI_TRACK_INFORMATION (obj); + { + GtkLabel* label; + HildonEntry* _tmp0_; + GtkTable* table; +#line 13 "trackinformation.vala" + gtk_window_set_title (GTK_WINDOW (self), "New Track"); +#line 14 "trackinformation.vala" + gtk_window_set_modal (GTK_WINDOW (self), TRUE); +#line 15 "trackinformation.vala" + hildon_dialog_add_buttons (HILDON_DIALOG (self), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL, NULL); +#line 18 "trackinformation.vala" + label = g_object_ref_sink ((GtkLabel*) gtk_label_new ("Track name:")); +#line 19 "trackinformation.vala" + self->priv->entry = (_tmp0_ = g_object_ref_sink ((HildonEntry*) hildon_entry_new (HILDON_SIZE_HALFSCREEN_WIDTH | HILDON_SIZE_FINGER_HEIGHT)), _g_object_unref0 (self->priv->entry), _tmp0_); +#line 20 "trackinformation.vala" + gtk_entry_set_activates_default (GTK_ENTRY (self->priv->entry), TRUE); +#line 21 "trackinformation.vala" + g_signal_connect_object (GTK_EDITABLE (self->priv->entry), "changed", (GCallback) _ui_track_information_on_entry_changed_gtk_editable_changed, self, 0); +#line 23 "trackinformation.vala" + table = g_object_ref_sink ((GtkTable*) gtk_table_new ((guint) 1, (guint) 2, FALSE)); +#line 24 "trackinformation.vala" + gtk_table_attach_defaults (table, GTK_WIDGET (label), (guint) 0, (guint) 1, (guint) 0, (guint) 1); +#line 25 "trackinformation.vala" + gtk_table_attach_defaults (table, GTK_WIDGET (self->priv->entry), (guint) 1, (guint) 2, (guint) 0, (guint) 1); +#line 26 "trackinformation.vala" + gtk_table_set_col_spacing (table, (guint) 0, (guint) 12); +#line 27 "trackinformation.vala" + gtk_container_set_border_width (GTK_CONTAINER (table), (guint) 12); +#line 29 "trackinformation.vala" + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (self)->vbox), GTK_WIDGET (table), TRUE, TRUE, (guint) 0); +#line 30 "trackinformation.vala" + gtk_widget_show_all (GTK_WIDGET (self)); +#line 31 "trackinformation.vala" + gtk_dialog_set_default_response (GTK_DIALOG (self), (gint) GTK_RESPONSE_OK); +#line 202 "trackinformation.c" + _g_object_unref0 (label); + _g_object_unref0 (table); + } + return obj; +} + + +static void ui_track_information_class_init (UITrackInformationClass * klass) { + ui_track_information_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (UITrackInformationPrivate)); + G_OBJECT_CLASS (klass)->constructor = ui_track_information_constructor; + G_OBJECT_CLASS (klass)->finalize = ui_track_information_finalize; +} + + +static void ui_track_information_instance_init (UITrackInformation * self) { + self->priv = UI_TRACK_INFORMATION_GET_PRIVATE (self); +} + + +static void ui_track_information_finalize (GObject* obj) { + UITrackInformation * self; + self = UI_TRACK_INFORMATION (obj); + _g_object_unref0 (self->priv->entry); + G_OBJECT_CLASS (ui_track_information_parent_class)->finalize (obj); +} + + +GType ui_track_information_get_type (void) { + static volatile gsize ui_track_information_type_id__volatile = 0; + if (g_once_init_enter (&ui_track_information_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (UITrackInformationClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ui_track_information_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (UITrackInformation), 0, (GInstanceInitFunc) ui_track_information_instance_init, NULL }; + GType ui_track_information_type_id; + ui_track_information_type_id = g_type_register_static (HILDON_TYPE_DIALOG, "UITrackInformation", &g_define_type_info, 0); + g_once_init_leave (&ui_track_information_type_id__volatile, ui_track_information_type_id); + } + return ui_track_information_type_id__volatile; +} + + + + diff --git a/src/fillmore/fillmore/trackinformation.o b/src/fillmore/fillmore/trackinformation.o new file mode 100644 index 0000000..5e8bc0a Binary files /dev/null and b/src/fillmore/fillmore/trackinformation.o differ diff --git a/src/fillmore/header_area.vala b/src/fillmore/header_area.vala new file mode 100644 index 0000000..17bf8fd --- /dev/null +++ b/src/fillmore/header_area.vala @@ -0,0 +1,268 @@ +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +using Logging; + +class TrackHeader : Gtk.EventBox { + protected weak Model.Track track; + protected weak HeaderArea header_area; + protected Gtk.Label track_label; + + public const int width = 100; + + public TrackHeader(Model.Track track, HeaderArea area, int height) { + this.track = track; + this.header_area = area; + + track.track_renamed.connect(on_track_renamed); + track.track_selection_changed.connect(on_track_selection_changed); + set_size_request(width, height); + modify_bg(Gtk.StateType.NORMAL, header_area.background_color); + modify_bg(Gtk.StateType.SELECTED, parse_color("#68a")); + + track_label = new Gtk.Label(track.display_name); + track_label.modify_fg(Gtk.StateType.NORMAL, parse_color("#fff")); + } + + void on_track_renamed() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_track_renamed"); + track_label.set_text(track.display_name); + } + + void on_track_selection_changed(Model.Track track) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_track_selection_changed"); + set_state(track.get_is_selected() ? Gtk.StateType.SELECTED : Gtk.StateType.NORMAL); + } + + public override bool button_press_event(Gdk.EventButton event) { + header_area.select(track); + return true; + } + + public Model.Track get_track() { + return track; + } +} + +public class SliderBase : Gtk.HScrollbar { + Gdk.Pixbuf slider_image; + construct { + can_focus = true; + try { + slider_image = new Gdk.Pixbuf.from_file( + AppDirs.get_resources_dir().get_child("dot.png").get_path()); + } catch (GLib.Error e) { + warning("Could not load resource for slider: %s", e.message); + } + } + + public override bool expose_event (Gdk.EventExpose event) { + Gdk.GC gc = style.fg_gc[(int) Gtk.StateType.NORMAL]; + int radius = (slider_end - slider_start) / 2; + int center = allocation.x + slider_start + radius; + int height = allocation.y + allocation.height / 2; + + event.window.draw_rectangle(gc, false, + allocation.x + radius, height - 2, allocation.width - 2 * radius, 1); + + event.window.draw_pixbuf(gc, slider_image, 0, 0, center - radius, allocation.y + 2, + slider_image.get_width(), slider_image.get_height(), Gdk.RgbDither.NORMAL, 0, 0); + return true; + } +} + +class PanSlider : SliderBase { + construct { + } +} + +public class VolumeSlider : SliderBase { + construct { + } +} + +class AudioTrackHeader : TrackHeader { + public double panorama; + public double volume; + + public AudioTrackHeader(Model.AudioTrack track, HeaderArea header, int height) { + base(track, header, height); + + track_label.modify_font(Pango.FontDescription.from_string("Sans 10")); + track_label.set_padding(4, 2); + track_label.set_alignment(0,0); + + track.parameter_changed.connect(on_parameter_changed); + + volume = track.get_volume(); + panorama = track.get_pan(); + + Gtk.VBox vbox = new Gtk.VBox(false, 0); + vbox.pack_start(track_label, true, true, 0); + Hildon.Button volpan_button = new Hildon.Button(Hildon.SizeType.AUTO_HEIGHT | Hildon.SizeType.AUTO_WIDTH, Hildon.ButtonArrangement.HORIZONTAL); + //volpan_button.set_text("Vol", ""); + volpan_button.set_image(new Gtk.Image.from_icon_name("statusarea_volumelevel4", Gtk.IconSize.BUTTON)); + volpan_button.set_image_position(Gtk.PositionType.LEFT); + volpan_button.clicked.connect(do_volpan_popup); + vbox.add(volpan_button); + + //View.AudioMeter meter = new View.AudioMeter(track); + //vbox.add(meter); + //vbox.add(volume_box); + //vbox.add(pan_box); + add(vbox); + } + + void do_volpan_popup() { + IdWorks.VolumeAndPanPopUp dlg = new IdWorks.VolumeAndPanPopUp(this, "Volume / Pan: " + track.display_name); + //dlg.set_transient_for(this.get_transient_for()); + dlg.set_volume(this.volume); + dlg.set_panorama(this.panorama); + dlg.volume_updated.connect(on_volume_updated); + dlg.panorama_updated.connect(on_panorama_updated); + dlg.run(); + dlg.destroy(); + dlg = null; + } + + void on_panorama_updated(double val) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_pan_value_changed"); + Model.AudioTrack audio_track = track as Model.AudioTrack; + if (audio_track != null) { + audio_track.set_pan(val); + } + } + + /*void on_pan_value_changed() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_pan_value_changed"); + Model.AudioTrack audio_track = track as Model.AudioTrack; + if (audio_track != null) { + Gtk.Adjustment adjustment = pan.get_adjustment(); + audio_track.set_pan(adjustment.get_value()); + } + }*/ + + void on_volume_updated(double val) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_volume_value_changed"); + Model.AudioTrack audio_track = track as Model.AudioTrack; + if (audio_track != null) { + audio_track.set_volume(val); + } + } + + /*void on_volume_value_changed() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_volume_value_changed"); + Model.AudioTrack audio_track = track as Model.AudioTrack; + if (audio_track != null) { + Gtk.Adjustment adjustment = volume.get_adjustment(); + audio_track.set_volume(adjustment.get_value()); + } + }*/ + void on_parameter_changed(Model.Parameter parameter, double new_value) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_parameter_changed"); + Model.AudioTrack audio_track = track as Model.AudioTrack; + assert(audio_track != null); + switch(parameter) { + case Model.Parameter.VOLUME: + volume = new_value; + break; + case Model.Parameter.PAN: + panorama = new_value; + break; + } + } + /* void on_parameter_changed(Model.Parameter parameter, double new_value) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_parameter_changed"); + Model.AudioTrack audio_track = track as Model.AudioTrack; + assert(audio_track != null); + switch(parameter) { + case Model.Parameter.VOLUME: + volume.set_value(new_value); + break; + case Model.Parameter.PAN: + pan.set_value(new_value); + break; + } + }*/ +} + +class HeaderArea : Gtk.EventBox { + weak Model.Project project; + + Gtk.VBox vbox; + public Gdk.Color background_color = parse_color("#666"); + + public HeaderArea(Recorder recorder, Model.TimeSystem provider, int height) { + this.project = recorder.project; + recorder.timeline.trackview_removed.connect(on_trackview_removed); + recorder.timeline.trackview_added.connect(on_trackview_added); + + set_size_request(TrackHeader.width, 0); + modify_bg(Gtk.StateType.NORMAL, background_color); + + vbox = new Gtk.VBox(false, 0); + add(vbox); + Gtk.DrawingArea status_bar = new View.StatusBar(project, provider, height); + + vbox.pack_start(status_bar, false, false, 0); + + vbox.pack_start(new TrackSeparator(), false, false, 0); + + foreach (TrackView track in recorder.timeline.tracks) { + on_trackview_added(track); + } + } + + public void on_trackview_added(TrackView trackview) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_trackview_added"); + Model.AudioTrack audio_track = trackview.get_track() as Model.AudioTrack; + assert(audio_track != null); + //we are currently only supporting audio tracks. We'll probably have + //a separate method for adding video track, midi track, aux input, etc + + TrackHeader header = new AudioTrackHeader(audio_track, this, trackview.get_track_height()); + vbox.pack_start(header, false, false, 0); + vbox.pack_start(new TrackSeparator(), false, false, 0); + vbox.show_all(); + select(audio_track); + } + + public void on_trackview_removed(TrackView trackview) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_trackview_removed"); + Model.Track track = trackview.get_track(); + TrackHeader? my_track_header = null; + Gtk.HSeparator? my_separator = null; + foreach(Gtk.Widget widget in vbox.get_children()) { + if (my_track_header == null) { + TrackHeader? track_header = widget as TrackHeader; + if (track_header != null && track_header.get_track() == track) { + my_track_header = track_header; + } + } else { + my_separator = widget as Gtk.HSeparator; + break; + } + } + + if (my_track_header != null) { + vbox.remove(my_track_header); + } + + if (my_separator != null) { + vbox.remove(my_separator); + } + + if (project.tracks.size != 0) { + select(project.tracks[0]); + } + } + + public void select(Model.Track track) { + foreach (Model.Track t in project.tracks) + t.set_selected(t == track); + } +} + diff --git a/src/fillmore/sources.mk b/src/fillmore/sources.mk new file mode 100644 index 0000000..d3ceff5 --- /dev/null +++ b/src/fillmore/sources.mk @@ -0,0 +1,9 @@ +$(SRC_PREFIX)SRC_FILES = \ + audio_project.vala \ + fillmore.vala \ + FillmoreClassFactory.vala \ + header_area.vala \ + ProjectProperties.vala \ + trackinformation.vala \ + VolumeAndPanPopUp.vala + diff --git a/src/fillmore/trackinformation.vala b/src/fillmore/trackinformation.vala new file mode 100644 index 0000000..b8f588d --- /dev/null +++ b/src/fillmore/trackinformation.vala @@ -0,0 +1,48 @@ +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +namespace UI { + class TrackInformation : Hildon.Dialog { + + Hildon.Entry entry; + + construct { + set_title("New Track"); + set_modal(true); + add_buttons(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, + Gtk.STOCK_OK, Gtk.ResponseType.OK, + null); + Gtk.Label label = new Gtk.Label("Track name:"); + entry = new Hildon.Entry(Hildon.SizeType.HALFSCREEN_WIDTH | Hildon.SizeType.FINGER_HEIGHT); + entry.set_activates_default(true); + entry.changed.connect(on_entry_changed); + + Gtk.Table table = new Gtk.Table(1, 2, false); + table.attach_defaults(label, 0, 1, 0, 1); + table.attach_defaults(entry, 1, 2, 0, 1); + table.set_col_spacing(0, 12); + table.set_border_width(12); + + vbox.pack_start(table, true, true, 0); + show_all(); + set_default_response(Gtk.ResponseType.OK); + } + + public void set_track_name(string new_name) { + entry.set_text(new_name); + entry.select_region(0, -1); + } + + public string get_track_name() { + return entry.get_text().strip(); + } + + private void on_entry_changed() { + bool is_valid = get_track_name().length > 0; + set_response_sensitive(Gtk.ResponseType.OK, is_valid); + } + } +} diff --git a/src/lombard/Makefile b/src/lombard/Makefile new file mode 100644 index 0000000..7bbf762 --- /dev/null +++ b/src/lombard/Makefile @@ -0,0 +1,18 @@ +PROGRAM = ../../$(PROGRAM_NAME) +all: $(PROGRAM) +USE_MARINA_VAPI=1 +-include ../../configure.mk + +VALA_LDFLAGS = -lmarina -L../marina +VALA_LDFLAGS += `pkg-config --libs $(EXT_PKGS)` +MARINA_DEPEND = ../marina/libmarina.a + +-include sources.mk + +ifndef BUILD_DIR +BUILD_DIR=lombard +endif + +-include ../../marina.mk +HEADER_DIRS += ../marina + diff --git a/src/lombard/lombard.vala b/src/lombard/lombard.vala new file mode 100644 index 0000000..e83f85e --- /dev/null +++ b/src/lombard/lombard.vala @@ -0,0 +1,909 @@ +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +using Logging; + +int debug_level; +const OptionEntry[] options = { + { "debug-level", 0, 0, OptionArg.INT, &debug_level, + "Control amount of diagnostic information", + "[0 (minimal),5 (maximum)]" }, + { null } +}; + +class App : Gtk.Window, TransportDelegate { + Gtk.DrawingArea drawing_area; + + Model.VideoProject project; + View.VideoOutput video_output; + View.AudioOutput audio_output; + View.OggVorbisExport export_connector; + + TimeLine timeline; + ClipLibraryView library; + View.StatusBar status_bar; + + Gtk.HPaned h_pane; + + Gtk.ScrolledWindow library_scrolled; + Gtk.ScrolledWindow timeline_scrolled; + Gtk.Adjustment h_adjustment; + + double prev_adjustment_lower; + double prev_adjustment_upper; + + Gtk.ActionGroup main_group; + + int64 center_time = -1; + + Gtk.VBox vbox = null; + Gtk.MenuBar menubar; + Gtk.UIManager manager; + + string project_filename; + Gee.ArrayList load_errors; + bool loading; + + public const string NAME = "Lombard"; + const string LibraryToggle = "Library"; + + const Gtk.ActionEntry[] entries = { + { "Project", null, "_Project", null, null, null }, + { "Open", Gtk.STOCK_OPEN, "_Open...", null, null, on_open }, + { "Save", Gtk.STOCK_SAVE, null, null, null, on_save }, + { "SaveAs", Gtk.STOCK_SAVE_AS, "Save _As...", "S", null, on_save_as }, + { "Play", Gtk.STOCK_MEDIA_PLAY, "_Play / Pause", "space", null, on_play_pause }, + { "Export", null, "_Export...", "E", null, on_export }, + { "Quit", Gtk.STOCK_QUIT, null, null, null, on_quit }, + + { "Edit", null, "_Edit", null, null, null }, + { "Undo", Gtk.STOCK_UNDO, null, "Z", null, on_undo }, + { "Cut", Gtk.STOCK_CUT, null, null, null, on_cut }, + { "Copy", Gtk.STOCK_COPY, null, null, null, on_copy }, + { "Paste", Gtk.STOCK_PASTE, null, null, null, on_paste }, + { "Delete", Gtk.STOCK_DELETE, null, "Delete", null, on_delete }, + { "SelectAll", Gtk.STOCK_SELECT_ALL, null, "A", null, on_select_all }, + { "SplitAtPlayhead", null, "_Split at Playhead", "P", null, on_split_at_playhead }, + { "TrimToPlayhead", null, "Trim to Play_head", "H", null, on_trim_to_playhead }, + { "ClipProperties", Gtk.STOCK_PROPERTIES, "Properti_es", "Return", + null, on_clip_properties }, + + { "View", null, "_View", null, null, null }, + { "ZoomIn", Gtk.STOCK_ZOOM_IN, "Zoom _In", "plus", null, on_zoom_in }, + { "ZoomOut", Gtk.STOCK_ZOOM_OUT, "Zoom _Out", "minus", null, on_zoom_out }, + { "ZoomProject", null, "Fit to _Window", "Z", null, on_zoom_to_project }, + + { "Go", null, "_Go", null, null, null }, + { "Start", Gtk.STOCK_GOTO_FIRST, "_Start", "Home", null, on_go_start }, + { "End", Gtk.STOCK_GOTO_LAST, "_End", "End", null, on_go_end }, + + { "Help", null, "_Help", null, null, null }, + { "Contents", Gtk.STOCK_HELP, "_Contents", "F1", + "More information on Lombard", on_help_contents}, + { "About", Gtk.STOCK_ABOUT, null, null, null, on_about }, + { "SaveGraph", null, "Save _Graph", null, "Save graph", on_save_graph } + }; + + const Gtk.ToggleActionEntry[] check_actions = { + { LibraryToggle, null, "_Library", "F9", null, on_view_library, true }, + { "Snap", null, "_Snap to Clip Edges", null, null, on_snap, true } + }; + + const string ui = """ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +"""; + + const DialogUtils.filter_description_struct[] filters = { + { "Lombard Project Files", Model.Project.LOMBARD_FILE_EXTENSION }, + { "Fillmore Project Files", Model.Project.FILLMORE_FILE_EXTENSION } + }; + + const DialogUtils.filter_description_struct[] export_filters = { + { "Ogg Files", "ogg" } + }; + + public App(string? project_file) throws Error { + try { + set_icon_from_file( + AppDirs.get_resources_dir().get_child("lombard_icon.png").get_path()); + } catch (GLib.Error e) { + warning("Could not load application icon: %s", e.message); + } + + if (debug_level > -1) { + set_logging_level((Logging.Level)debug_level); + } + ClassFactory.set_transport_delegate(this); + set_default_size(600, 500); + project_filename = project_file; + + load_errors = new Gee.ArrayList(); + drawing_area = new Gtk.DrawingArea(); + drawing_area.realize.connect(on_drawing_realize); + drawing_area.modify_bg(Gtk.StateType.NORMAL, parse_color("#000")); + + main_group = new Gtk.ActionGroup("main"); + main_group.add_actions(entries, this); + main_group.add_toggle_actions(check_actions, this); + + manager = new Gtk.UIManager(); + manager.insert_action_group(main_group, 0); + try { + manager.add_ui_from_string(ui, -1); + } catch (Error e) { error("%s", e.message); } + + menubar = (Gtk.MenuBar) get_widget(manager, "/MenuBar"); + + project = new Model.VideoProject(project_filename); + project.snap_to_clip = true; + project.name_changed.connect(set_project_name); + project.load_error.connect(on_load_error); + project.load_complete.connect(on_load_complete); + project.error_occurred.connect(do_error_dialog); + project.undo_manager.undo_changed.connect(on_undo_changed); + project.media_engine.post_export.connect(on_post_export); + project.playstate_changed.connect(on_playstate_changed); + + audio_output = new View.AudioOutput(project.media_engine.get_project_audio_caps()); + project.media_engine.connect_output(audio_output); + + timeline = new TimeLine(project, project.time_provider, + Gdk.DragAction.COPY | Gdk.DragAction.MOVE); + timeline.selection_changed.connect(on_timeline_selection_changed); + timeline.track_changed.connect(on_track_changed); + timeline.drag_data_received.connect(on_drag_data_received); + timeline.size_allocate.connect(on_timeline_size_allocate); + project.media_engine.position_changed.connect(on_position_changed); + project.media_engine.callback_pulse.connect(on_callback_pulse); + ClipView.context_menu = (Gtk.Menu) manager.get_widget("/ClipContextMenu"); + ClipLibraryView.context_menu = (Gtk.Menu) manager.get_widget("/LibraryContextMenu"); + + library = new ClipLibraryView(project, project.time_provider, "Drag clips here.", + Gdk.DragAction.COPY | Gdk.DragAction.MOVE); + library.selection_changed.connect(on_library_selection_changed); + library.drag_data_received.connect(on_drag_data_received); + + status_bar = new View.StatusBar(project, project.time_provider, TimeLine.BAR_HEIGHT); + + library_scrolled = new Gtk.ScrolledWindow(null, null); + library_scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC); + library_scrolled.add_with_viewport(library); + + toggle_library(true); + + Gtk.MenuItem? save_graph = (Gtk.MenuItem?) + get_widget(manager, "/MenuBar/HelpMenu/SaveGraph"); + + // TODO: only destroy it if --debug is not specified on the command line + // or conversely, only add it if --debug is specified on the command line + if (save_graph != null) { + save_graph.destroy(); + } + + add_accel_group(manager.get_accel_group()); + + on_undo_changed(false); + + delete_event.connect(on_delete_event); + + if (project_filename == null) { + default_track_set(); + on_load_complete(); + } + + update_menu(); + show_all(); + } + + void default_track_set() { + project.add_track(new Model.VideoTrack(project)); + project.add_track(new Model.AudioTrack(project, "Audio Track")); + } + + bool on_delete_event() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_delete_event"); + on_quit(); + return true; + } + + void on_quit() { + if (project.undo_manager.is_dirty) { + switch (DialogUtils.save_close_cancel(this, null, "Save changes before closing?")) { + case Gtk.ResponseType.ACCEPT: + if (!do_save()) { + return; + } + break; + case Gtk.ResponseType.CLOSE: + break; + case Gtk.ResponseType.DELETE_EVENT: // when user presses escape. + case Gtk.ResponseType.CANCEL: + return; + default: + assert(false); + break; + } + } + + Gtk.main_quit(); + } + + void toggle_library(bool showing) { + if (vbox == null) { + vbox = new Gtk.VBox(false, 0); + vbox.pack_start(menubar, false, false, 0); + + Gtk.VPaned v_pane = new Gtk.VPaned(); + v_pane.set_position(290); + + h_pane = new Gtk.HPaned(); + h_pane.set_position(300); + h_pane.child2_resize = 1; + h_pane.child1_resize = 0; + + if (showing) { + h_pane.add1(library_scrolled); + h_pane.add2(drawing_area); + } else { + h_pane.add2(drawing_area); + } + h_pane.child2.size_allocate.connect(on_library_size_allocate); + v_pane.add1(h_pane); + + timeline_scrolled = new Gtk.ScrolledWindow(null, null); + timeline_scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC); + timeline_scrolled.add_with_viewport(timeline); + + Gtk.VBox timeline_vbox = new Gtk.VBox(false, 0); + timeline_vbox.pack_start(status_bar, false, false, 0); + timeline_vbox.pack_start(timeline_scrolled, true, true, 0); + v_pane.add2(timeline_vbox); + + v_pane.child1_resize = 1; + v_pane.child2_resize = 0; + + h_adjustment = timeline_scrolled.get_hadjustment(); + h_adjustment.changed.connect(on_adjustment_changed); + prev_adjustment_lower = h_adjustment.get_lower(); + prev_adjustment_upper = h_adjustment.get_upper(); + + vbox.pack_start(v_pane, true, true, 0); + + add(vbox); + } else { + project.library_visible = showing; + if (showing) { + h_pane.add1(library_scrolled); + } else { + h_pane.remove(library_scrolled); + } + } + show_all(); + } + + void on_drawing_realize() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_drawing_realize"); + loading = true; + project.load(project_filename); + try { + video_output = new View.VideoOutput(drawing_area); + project.media_engine.connect_output(video_output); + } catch (Error e) { + do_error_dialog("Could not create video output", e.message); + } + } + + void on_adjustment_changed(Gtk.Adjustment a) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_adjustment_changed"); + if (prev_adjustment_upper != a.get_upper() || + prev_adjustment_lower != a.get_lower()) { + + prev_adjustment_lower = a.get_lower(); + prev_adjustment_upper = a.get_upper(); + } + } + + void on_drag_data_received(Gtk.Widget w, Gdk.DragContext context, int x, int y, + Gtk.SelectionData selection_data, uint drag_info, uint time) { + present(); + } + + public void set_project_name(string? filename) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "set_project_name"); + set_title(project.get_file_display_name()); + } + + public static void do_error_dialog(string message, string? minor_message) { + DialogUtils.error(message, minor_message); + } + + public void on_load_error(string message) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_load_error"); + load_errors.add(message); + } + + public void on_load_complete() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_load_complete"); + queue_draw(); + if (project.find_video_track() == null) { + project.add_track(new Model.VideoTrack(project)); + } + + project.media_engine.pipeline.set_state(Gst.State.PAUSED); + h_pane.set_position(h_pane.allocation.width - project.library_width); + Gtk.ToggleAction action = main_group.get_action(LibraryToggle) as Gtk.ToggleAction; + if (action.get_active() != project.library_visible) { + action.set_active(project.library_visible); + } + + action = main_group.get_action("Snap") as Gtk.ToggleAction; + if (action.get_active() != project.snap_to_clip) { + action.set_active(project.snap_to_clip); + } + + if (project.library_visible) { + if (h_pane.child1 != library_scrolled) { + h_pane.add1(library_scrolled); + } + } else { + if (h_pane.child1 == library_scrolled) { + h_pane.remove(library_scrolled); + } + } + + if (load_errors.size > 0) { + string message = ""; + foreach (string s in load_errors) { + message = message + s + "\n"; + } + do_error_dialog("An error occurred loading the project.", message); + } + loading = false; + } + + void on_library_size_allocate(Gdk.Rectangle rectangle) { + if (!loading && h_pane.child1 == library_scrolled) { + project.library_width = rectangle.width; + } + } + + // Loader code + + public void load_file(string name, Model.LibraryImporter im) { + if (get_file_extension(name) == Model.Project.LOMBARD_FILE_EXTENSION || + get_file_extension(name) == Model.Project.FILLMORE_FILE_EXTENSION) + load_project(name); + else { + try { + im.add_file(name); + } catch (Error e) { + do_error_dialog("Error loading file", e.message); + } + } + } + + void on_open() { + load_errors.clear(); + GLib.SList filenames; + if (DialogUtils.open(this, filters, true, true, out filenames)) { + project.create_clip_importer(null, false, 0, false, null, 0); + project.importer.started.connect(on_importer_started); + try { + foreach (string s in filenames) { + string str; + try { + str = GLib.Filename.from_uri(s); + } catch (GLib.ConvertError e) { str = s; } + load_file(str, project.importer); + } + project.importer.start(); + } catch (Error e) { + do_error_dialog("Could not open file", e.message); + } + } + } + + void on_importer_started(Model.ClipImporter i, int num) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_importer_started"); + new MultiFileProgress(this, num, "Import", i); + } + + bool do_save_dialog() { + string? filename = project.get_project_file(); + bool create_directory = filename == null; + if (DialogUtils.save(this, "Save Project", create_directory, filters, ref filename)) { + project.save(filename); + return true; + } + return false; + } + + void on_save_as() { + do_save_dialog(); + } + + void on_save() { + do_save(); + } + + bool do_save() { + if (project.get_project_file() != null) { + project.save(null); + return true; + } + return do_save_dialog(); + } + + public void load_project(string filename) { + loading = true; + + try { + project.media_engine.disconnect_output(video_output); + video_output = new View.VideoOutput(drawing_area); + project.media_engine.connect_output(video_output); + } catch (Error e) { + do_error_dialog("Could not create video output", e.message); + } + + project.load(filename); + + } + + const float SCROLL_MARGIN = 0.05f; + + void scroll_toward_center(int xpos) { + int cursor_pos = xpos - (int) h_adjustment.value; + + // Move the cursor position toward the center of the window. We compute + // the remaining distance and move by its square root; this results in + // a smooth decelerating motion. + int page_size = (int) h_adjustment.page_size; + int diff = page_size / 2 - cursor_pos; + int d = sign(diff) * (int) Math.sqrt(diff.abs()); + cursor_pos += d; + + int x = int.max(0, xpos - cursor_pos); + int max_value = (int)(h_adjustment.upper - timeline_scrolled.allocation.width); + if (x > max_value) { + x = max_value; + } + h_adjustment.set_value(x); + + h_adjustment.set_value(x); + } + + public void on_split_at_playhead() { + project.split_at_playhead(); + } + + public void on_trim_to_playhead() { + project.trim_to_playhead(); + } + + public void on_clip_properties() { + Fraction? frames_per_second = null; + project.get_framerate_fraction(out frames_per_second); + if (library.has_selection()) { + Gee.ArrayList files = library.get_selected_files(); + if (files.size == 1) { + string file_name = files.get(0); + Model.ClipFile? clip_file = project.find_clipfile(file_name); + DialogUtils.show_clip_properties(this, null, clip_file, frames_per_second); + } + } else { + Gee.ArrayList clips = timeline.selected_clips; + if (clips.size == 1) { + ClipView clip_view = clips.get(0); + DialogUtils.show_clip_properties(this, clip_view, null, frames_per_second); + } + } + } + + public void on_position_changed() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_position_changed"); + update_menu(); + } + + void on_callback_pulse() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_callback_pulse"); + if (project.transport_is_playing()) { + scroll_toward_center(project.time_provider.time_to_xpos(project.media_engine.position)); + } + timeline.queue_draw(); + } + + public void on_track_changed() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_track_changed"); + update_menu(); + } + + void update_menu() { + bool library_selected = library.has_selection(); + bool clip_selected = timeline.is_clip_selected(); + bool stopped = is_stopped(); + bool clip_is_trimmed = false; + bool playhead_on_clip = project.playhead_on_clip(); + bool dir; + bool can_trim = project.can_trim(out dir); + bool one_selected = false; + if (library_selected) { + one_selected = library.get_selected_files().size == 1; + } else if (clip_selected) { + one_selected = timeline.selected_clips.size == 1; + } + + if (clip_selected) { + foreach (ClipView clip_view in timeline.selected_clips) { + clip_is_trimmed = clip_view.clip.is_trimmed(); + if (clip_is_trimmed) { + break; + } + } + } + // File menu + set_sensitive_group(main_group, "Open", stopped); + set_sensitive_group(main_group, "Save", stopped); + set_sensitive_group(main_group, "SaveAs", stopped); + set_sensitive_group(main_group, "Export", project.can_export()); + + // Edit Menu + set_sensitive_group(main_group, "Undo", stopped && project.undo_manager.can_undo); + set_sensitive_group(main_group, "Delete", stopped && (clip_selected || library_selected)); + set_sensitive_group(main_group, "Cut", stopped && clip_selected); + set_sensitive_group(main_group, "Copy", stopped && clip_selected); + set_sensitive_group(main_group, "Paste", stopped && timeline.clipboard.clips.size > 0); + set_sensitive_group(main_group, "ClipProperties", one_selected); + + set_sensitive_group(main_group, "SplitAtPlayhead", stopped && playhead_on_clip); + set_sensitive_group(main_group, "TrimToPlayhead", stopped && can_trim); + + // View Menu + set_sensitive_group(main_group, "ZoomProject", project.get_length() != 0); + + } + + public void on_timeline_selection_changed(bool selected) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_timeline_selection_changed"); + if (selected) + library.unselect_all(); + update_menu(); + } + + public void on_library_selection_changed(bool selected) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_library_selection_changed"); + if (selected) { + timeline.deselect_all_clips(); + timeline.queue_draw(); + } + update_menu(); + } + + // We must use a key press event to handle the up arrow and down arrow keys, + // since GTK does not allow them to be used as accelerators. + public override bool key_press_event(Gdk.EventKey event) { + switch (event.keyval) { + case KeySyms.KP_Enter: + case KeySyms.Return: + if ((event.state & GDK_SHIFT_ALT_CONTROL_MASK) != 0) + return base.key_press_event(event); + on_go_start(); + break; + case KeySyms.Left: + if ((event.state & Gdk.ModifierType.CONTROL_MASK) != 0) { + project.go_previous(); + } else { + project.go_previous_frame(); + } + break; + case KeySyms.Right: + if ((event.state & Gdk.ModifierType.CONTROL_MASK) != 0) { + project.go_next(); + } else { + project.go_next_frame(); + } + break; + case KeySyms.KP_Add: + case KeySyms.equal: + case KeySyms.plus: + on_zoom_in(); + break; + case KeySyms.KP_Subtract: + case KeySyms.minus: + case KeySyms.underscore: + on_zoom_out(); + break; + default: + return base.key_press_event(event); + } + return true; + } + + void on_snap() { + project.snap_to_clip = !project.snap_to_clip; + } + + void on_view_library() { + Gtk.ToggleAction action = main_group.get_action(LibraryToggle) as Gtk.ToggleAction; + toggle_library(action.get_active()); + } + + int64 get_zoom_center_time() { + return project.transport_get_position(); + } + + void do_zoom(float increment) { + center_time = get_zoom_center_time(); + timeline.zoom(increment); + } + + void on_zoom_in() { + do_zoom(0.1f); + } + + void on_zoom_out() { + do_zoom(-0.1f); + } + + void on_zoom_to_project() { + timeline.zoom_to_project(h_adjustment.page_size); + } + + void on_timeline_size_allocate(Gdk.Rectangle rectangle) { + if (center_time != -1) { + int new_center_pixel = project.time_provider.time_to_xpos(center_time); + int page_size = (int)(h_adjustment.get_page_size() / 2); + h_adjustment.clamp_page(new_center_pixel - page_size, new_center_pixel + page_size); + center_time = -1; + } + } + + void set_sensitive_group(Gtk.ActionGroup group, string group_path, bool sensitive) { + Gtk.Action action = group.get_action(group_path); + action.set_sensitive(sensitive); + } + + // File commands + + void on_play_pause() { + if (project.transport_is_playing()) + project.media_engine.pause(); + else { + // TODO: we should be calling play() here, which in turn would call + // do_play(Model.PlayState). This is not currently how the code is organized. + // This is part of a checkin that is already large, so putting this off for another + // checkin for ease of testing. + project.media_engine.do_play(PlayState.PLAYING); + } + } + + void on_export() { + string filename = null; + if (DialogUtils.save(this, "Export", false, export_filters, ref filename)) { + new MultiFileProgress(this, 1, "Export", project.media_engine); + project.media_engine.disconnect_output(audio_output); + project.media_engine.disconnect_output(video_output); + try { + export_connector = new View.OggVorbisExport( + View.MediaConnector.MediaTypes.Audio | View.MediaConnector.MediaTypes.Video, + filename, project.media_engine.get_project_audio_export_caps()); + project.media_engine.connect_output(export_connector); + project.media_engine.start_export(filename); + } catch (Error e) { + do_error_dialog("Could not export file", e.message); + } + } + } + + void on_post_export(bool canceled) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_post_export"); + project.media_engine.disconnect_output(export_connector); + project.media_engine.connect_output(audio_output); + project.media_engine.connect_output(video_output); + if (canceled) { + GLib.FileUtils.remove(export_connector.get_filename()); + } + export_connector = null; + } + + // Edit commands + + void on_undo() { + project.undo(); + } + + void on_delete() { + if (library.has_selection()) + library.delete_selection(); + else + timeline.delete_selection(); + } + + void on_cut() { + timeline.do_cut(); + } + + void on_copy() { + timeline.do_copy(); + } + + void on_paste() { + timeline.paste(); + } + + void on_playstate_changed(PlayState playstate) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_playstate_changed"); + if (playstate == PlayState.STOPPED) { + update_menu(); + } + } + + void on_undo_changed(bool can_undo) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_undo_changed"); + Gtk.MenuItem? undo = (Gtk.MenuItem?) get_widget(manager, "/MenuBar/EditMenu/EditUndo"); + assert(undo != null); + //undo.set_label("_Undo " + project.undo_manager.get_undo_title()); + set_sensitive_group(main_group, "Undo", is_stopped() && project.undo_manager.can_undo); + } + + void on_select_all() { + if (library.has_selection()) { + library.select_all(); + } else { + timeline.select_all(); + } + } + + // Go commands + + void on_go_start() { project.go_start(); } + + void on_go_end() { project.go_end(); } + + // Help commands + + void on_help_contents() { + try { + Gtk.show_uri(null, "http://trac.yorba.org/wiki/UsingLombard0.1", 0); + } catch (GLib.Error e) { + } + } + + void on_about() { + Gtk.show_about_dialog(this, + "version", project.get_version(), + "comments", "A video editor", + "copyright", "Copyright 2009-2010 Yorba Foundation", + "website", "http://www.yorba.org", + "license", project.get_license(), + "website-label", "Visit the Yorba web site", + "authors", project.authors + ); + } + + void on_save_graph() { + project.print_graph(project.media_engine.pipeline, "save_graph"); + } + + // Transport Delegate methods + bool is_recording() { + return project.transport_is_recording(); + } + + bool is_playing() { + return project.transport_is_playing(); + } + + bool is_stopped() { + return !(is_playing() || is_recording()); + } +} + +extern const string _PROGRAM_NAME; + +void main(string[] args) { + debug_level = -1; + OptionContext context = new OptionContext( + " [project file] - Create and edit movies"); + context.add_main_entries(options, null); + context.add_group(Gst.init_get_option_group()); + + try { + context.parse(ref args); + } catch (GLib.Error arg_error) { + stderr.printf("%s\nRun 'lombard --help' for a full list of available command line options.", + arg_error.message); + return; + } + Gtk.init(ref args); + + try { + GLib.Environment.set_application_name("Lombard"); + + AppDirs.init(args[0], _PROGRAM_NAME); + Gst.init(ref args); + + if (args.length > 2) { + stderr.printf("usage: %s [project-file]\n", args[0]); + return; + } + + string? project_file = null; + if (args.length > 1) { + project_file = args[1]; + try { + project_file = GLib.Filename.from_uri(project_file); + } catch (GLib.Error e) { } + } + + string str = GLib.Environment.get_variable("LOMBARD_DEBUG"); + debug_enabled = (str != null && (str[0] >= '1')); + ClassFactory.set_class_factory(new ClassFactory()); + View.MediaEngine.can_run(); + + new App(project_file); + Gtk.main(); + } catch (Error e) { + App.do_error_dialog("Could not launch application", "%s.".printf(e.message)); + } +} + diff --git a/src/lombard/lombard/.stamp b/src/lombard/lombard/.stamp new file mode 100644 index 0000000..e69de29 diff --git a/src/lombard/lombard/lombard.c b/src/lombard/lombard/lombard.c new file mode 100644 index 0000000..1b8a507 --- /dev/null +++ b/src/lombard/lombard/lombard.c @@ -0,0 +1,2888 @@ +/* lombard.c generated by valac, the Vala compiler + * generated from lombard.vala, do not modify */ + +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#define TYPE_APP (app_get_type ()) +#define APP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_APP, App)) +#define APP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_APP, AppClass)) +#define IS_APP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_APP)) +#define IS_APP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_APP)) +#define APP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_APP, AppClass)) + +typedef struct _App App; +typedef struct _AppClass AppClass; +typedef struct _AppPrivate AppPrivate; + +#define MODEL_TYPE_VIDEO_PROJECT (model_video_project_get_type ()) +#define MODEL_VIDEO_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_VIDEO_PROJECT, ModelVideoProject)) +#define MODEL_VIDEO_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_VIDEO_PROJECT, ModelVideoProjectClass)) +#define MODEL_IS_VIDEO_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_VIDEO_PROJECT)) +#define MODEL_IS_VIDEO_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_VIDEO_PROJECT)) +#define MODEL_VIDEO_PROJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_VIDEO_PROJECT, ModelVideoProjectClass)) + +typedef struct _ModelVideoProject ModelVideoProject; +typedef struct _ModelVideoProjectClass ModelVideoProjectClass; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +#define _g_free0(var) (var = (g_free (var), NULL)) +#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL))) +#define _gst_caps_unref0(var) ((var == NULL) ? NULL : (var = (gst_caps_unref (var), NULL))) +typedef struct _ModelVideoProjectPrivate ModelVideoProjectPrivate; +#define __g_slist_free_g_free0(var) ((var == NULL) ? NULL : (var = (_g_slist_free_g_free (var), NULL))) +#define _g_option_context_free0(var) ((var == NULL) ? NULL : (var = (g_option_context_free (var), NULL))) +#define _class_factory_unref0(var) ((var == NULL) ? NULL : (var = (class_factory_unref (var), NULL))) + +struct _App { + GtkWindow parent_instance; + AppPrivate * priv; +}; + +struct _AppClass { + GtkWindowClass parent_class; +}; + +struct _AppPrivate { + GtkDrawingArea* drawing_area; + ModelVideoProject* project; + ViewVideoOutput* video_output; + ViewAudioOutput* audio_output; + ViewOggVorbisExport* export_connector; + TimeLine* timeline; + ClipLibraryView* library; + ViewStatusBar* status_bar; + GtkHPaned* h_pane; + GtkScrolledWindow* library_scrolled; + GtkScrolledWindow* timeline_scrolled; + GtkAdjustment* h_adjustment; + double prev_adjustment_lower; + double prev_adjustment_upper; + GtkActionGroup* main_group; + gint64 center_time; + GtkVBox* vbox; + GtkMenuBar* menubar; + GtkUIManager* manager; + char* project_filename; + GeeArrayList* load_errors; + gboolean loading; +}; + +struct _ModelVideoProject { + ModelProject parent_instance; + ModelVideoProjectPrivate * priv; + ModelTimecodeTimeSystem* time_provider; +}; + +struct _ModelVideoProjectClass { + ModelProjectClass parent_class; +}; + + +extern gint debug_level; +gint debug_level = 0; +static gpointer app_parent_class = NULL; +static TransportDelegateIface* app_transport_delegate_parent_iface = NULL; + +GType app_get_type (void); +GType model_video_project_get_type (void); +#define APP_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_APP, AppPrivate)) +enum { + APP_DUMMY_PROPERTY +}; +#define APP_NAME "Lombard" +#define APP_LibraryToggle "Library" +static void app_on_open (App* self); +static void _app_on_open_gtk_action_callback (GtkAction* action, gpointer self); +static void app_on_save (App* self); +static void _app_on_save_gtk_action_callback (GtkAction* action, gpointer self); +static void app_on_save_as (App* self); +static void _app_on_save_as_gtk_action_callback (GtkAction* action, gpointer self); +static void app_on_play_pause (App* self); +static void _app_on_play_pause_gtk_action_callback (GtkAction* action, gpointer self); +static void app_on_export (App* self); +static void _app_on_export_gtk_action_callback (GtkAction* action, gpointer self); +static void app_on_quit (App* self); +static void _app_on_quit_gtk_action_callback (GtkAction* action, gpointer self); +static void app_on_undo (App* self); +static void _app_on_undo_gtk_action_callback (GtkAction* action, gpointer self); +static void app_on_cut (App* self); +static void _app_on_cut_gtk_action_callback (GtkAction* action, gpointer self); +static void app_on_copy (App* self); +static void _app_on_copy_gtk_action_callback (GtkAction* action, gpointer self); +static void app_on_paste (App* self); +static void _app_on_paste_gtk_action_callback (GtkAction* action, gpointer self); +static void app_on_delete (App* self); +static void _app_on_delete_gtk_action_callback (GtkAction* action, gpointer self); +static void app_on_select_all (App* self); +static void _app_on_select_all_gtk_action_callback (GtkAction* action, gpointer self); +void app_on_split_at_playhead (App* self); +static void _app_on_split_at_playhead_gtk_action_callback (GtkAction* action, gpointer self); +void app_on_trim_to_playhead (App* self); +static void _app_on_trim_to_playhead_gtk_action_callback (GtkAction* action, gpointer self); +void app_on_clip_properties (App* self); +static void _app_on_clip_properties_gtk_action_callback (GtkAction* action, gpointer self); +static void app_on_zoom_in (App* self); +static void _app_on_zoom_in_gtk_action_callback (GtkAction* action, gpointer self); +static void app_on_zoom_out (App* self); +static void _app_on_zoom_out_gtk_action_callback (GtkAction* action, gpointer self); +static void app_on_zoom_to_project (App* self); +static void _app_on_zoom_to_project_gtk_action_callback (GtkAction* action, gpointer self); +static void app_on_go_start (App* self); +static void _app_on_go_start_gtk_action_callback (GtkAction* action, gpointer self); +static void app_on_go_end (App* self); +static void _app_on_go_end_gtk_action_callback (GtkAction* action, gpointer self); +static void app_on_help_contents (App* self); +static void _app_on_help_contents_gtk_action_callback (GtkAction* action, gpointer self); +static void app_on_about (App* self); +static void _app_on_about_gtk_action_callback (GtkAction* action, gpointer self); +static void app_on_save_graph (App* self); +static void _app_on_save_graph_gtk_action_callback (GtkAction* action, gpointer self); +static void app_on_view_library (App* self); +static void _app_on_view_library_gtk_action_callback (GtkAction* action, gpointer self); +static void app_on_snap (App* self); +static void _app_on_snap_gtk_action_callback (GtkAction* action, gpointer self); +#define APP_ui "\n" \ +"\n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +"\n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +" \n" \ +"\n" +#define APP_SCROLL_MARGIN 0.05f +static void app_on_drawing_realize (App* self); +static void _app_on_drawing_realize_gtk_widget_realize (GtkWidget* _sender, gpointer self); +ModelVideoProject* model_video_project_new (const char* filename, GError** error); +ModelVideoProject* model_video_project_construct (GType object_type, const char* filename, GError** error); +void app_set_project_name (App* self, const char* filename); +static void _app_set_project_name_model_project_name_changed (ModelProject* _sender, const char* project_file, gpointer self); +void app_on_load_error (App* self, const char* message); +static void _app_on_load_error_model_project_load_error (ModelProject* _sender, const char* _error_, gpointer self); +void app_on_load_complete (App* self); +static void _app_on_load_complete_model_project_load_complete (ModelProject* _sender, gpointer self); +void app_do_error_dialog (const char* message, const char* minor_message); +static void _app_do_error_dialog_model_project_error_occurred (ModelProject* _sender, const char* major_message, const char* minor_message, gpointer self); +static void app_on_undo_changed (App* self, gboolean can_undo); +static void _app_on_undo_changed_model_undo_manager_undo_changed (ModelUndoManager* _sender, gboolean can_undo, gpointer self); +static void app_on_post_export (App* self, gboolean canceled); +static void _app_on_post_export_view_media_engine_post_export (ViewMediaEngine* _sender, gboolean canceled, gpointer self); +static void app_on_playstate_changed (App* self, PlayState playstate); +static void _app_on_playstate_changed_model_project_playstate_changed (ModelProject* _sender, PlayState playstate, gpointer self); +void app_on_timeline_selection_changed (App* self, gboolean selected); +static void _app_on_timeline_selection_changed_time_line_selection_changed (TimeLine* _sender, gboolean selected, gpointer self); +void app_on_track_changed (App* self); +static void _app_on_track_changed_time_line_track_changed (TimeLine* _sender, gpointer self); +static void app_on_drag_data_received (App* self, GtkWidget* w, GdkDragContext* context, gint x, gint y, GtkSelectionData* selection_data, guint drag_info, guint time); +static void _app_on_drag_data_received_gtk_widget_drag_data_received (GtkWidget* _sender, GdkDragContext* context, gint x, gint y, GtkSelectionData* selection_data, guint info, guint time_, gpointer self); +static void app_on_timeline_size_allocate (App* self, GdkRectangle* rectangle); +static void _app_on_timeline_size_allocate_gtk_widget_size_allocate (GtkWidget* _sender, GdkRectangle* allocation, gpointer self); +void app_on_position_changed (App* self); +static void _app_on_position_changed_view_media_engine_position_changed (ViewMediaEngine* _sender, gint64 position, gpointer self); +static void app_on_callback_pulse (App* self); +static void _app_on_callback_pulse_view_media_engine_callback_pulse (ViewMediaEngine* _sender, gpointer self); +void app_on_library_selection_changed (App* self, gboolean selected); +static void _app_on_library_selection_changed_clip_library_view_selection_changed (ClipLibraryView* _sender, gboolean selected, gpointer self); +static void app_toggle_library (App* self, gboolean showing); +static gboolean app_on_delete_event (App* self); +static gboolean _app_on_delete_event_gtk_widget_delete_event (GtkWidget* _sender, GdkEvent* event, gpointer self); +static void app_default_track_set (App* self); +static void app_update_menu (App* self); +App* app_new (const char* project_file, GError** error); +App* app_construct (GType object_type, const char* project_file, GError** error); +static gboolean app_do_save (App* self); +static void app_on_library_size_allocate (App* self, GdkRectangle* rectangle); +static void _app_on_library_size_allocate_gtk_widget_size_allocate (GtkWidget* _sender, GdkRectangle* allocation, gpointer self); +static void app_on_adjustment_changed (App* self, GtkAdjustment* a); +static void _app_on_adjustment_changed_gtk_adjustment_changed (GtkAdjustment* _sender, gpointer self); +void app_load_project (App* self, const char* filename); +void app_load_file (App* self, const char* name, ModelLibraryImporter* im); +static void _g_slist_free_g_free (GSList* self); +static void app_on_importer_started (App* self, ModelClipImporter* i, gint num); +static void _app_on_importer_started_model_library_importer_started (ModelLibraryImporter* _sender, ModelClipImporter* i, gint num, gpointer self); +static gboolean app_do_save_dialog (App* self); +static void app_scroll_toward_center (App* self, gint xpos); +gboolean model_video_project_get_framerate_fraction (ModelVideoProject* self, Fraction* rate); +static Fraction* _fraction_dup (Fraction* self); +static void app_set_sensitive_group (App* self, GtkActionGroup* group, const char* group_path, gboolean sensitive); +void model_video_project_go_previous_frame (ModelVideoProject* self); +void model_video_project_go_next_frame (ModelVideoProject* self); +static gboolean app_real_key_press_event (GtkWidget* base, GdkEventKey* event); +static gint64 app_get_zoom_center_time (App* self); +static void app_do_zoom (App* self, float increment); +static gboolean app_real_is_recording (TransportDelegate* base); +static gboolean app_real_is_playing (TransportDelegate* base); +static gboolean app_real_is_stopped (TransportDelegate* base); +static void app_finalize (GObject* obj); +void _vala_main (char** args, int args_length1); +static int _vala_strcmp0 (const char * str1, const char * str2); + +const GOptionEntry options[2] = {{"debug-level", (gchar) 0, 0, G_OPTION_ARG_INT, &debug_level, "Control amount of diagnostic information", "[0 (minimal),5 (maximum)]"}, {NULL}}; +static const GtkActionEntry APP_entries[28] = {{"Project", NULL, "_Project", NULL, NULL, (GCallback) NULL}, {"Open", GTK_STOCK_OPEN, "_Open...", NULL, NULL, (GCallback) _app_on_open_gtk_action_callback}, {"Save", GTK_STOCK_SAVE, NULL, NULL, NULL, (GCallback) _app_on_save_gtk_action_callback}, {"SaveAs", GTK_STOCK_SAVE_AS, "Save _As...", "S", NULL, (GCallback) _app_on_save_as_gtk_action_callback}, {"Play", GTK_STOCK_MEDIA_PLAY, "_Play / Pause", "space", NULL, (GCallback) _app_on_play_pause_gtk_action_callback}, {"Export", NULL, "_Export...", "E", NULL, (GCallback) _app_on_export_gtk_action_callback}, {"Quit", GTK_STOCK_QUIT, NULL, NULL, NULL, (GCallback) _app_on_quit_gtk_action_callback}, {"Edit", NULL, "_Edit", NULL, NULL, (GCallback) NULL}, {"Undo", GTK_STOCK_UNDO, NULL, "Z", NULL, (GCallback) _app_on_undo_gtk_action_callback}, {"Cut", GTK_STOCK_CUT, NULL, NULL, NULL, (GCallback) _app_on_cut_gtk_action_callback}, {"Copy", GTK_STOCK_COPY, NULL, NULL, NULL, (GCallback) _app_on_copy_gtk_action_callback}, {"Paste", GTK_STOCK_PASTE, NULL, NULL, NULL, (GCallback) _app_on_paste_gtk_action_callback}, {"Delete", GTK_STOCK_DELETE, NULL, "Delete", NULL, (GCallback) _app_on_delete_gtk_action_callback}, {"SelectAll", GTK_STOCK_SELECT_ALL, NULL, "A", NULL, (GCallback) _app_on_select_all_gtk_action_callback}, {"SplitAtPlayhead", NULL, "_Split at Playhead", "P", NULL, (GCallback) _app_on_split_at_playhead_gtk_action_callback}, {"TrimToPlayhead", NULL, "Trim to Play_head", "H", NULL, (GCallback) _app_on_trim_to_playhead_gtk_action_callback}, {"ClipProperties", GTK_STOCK_PROPERTIES, "Properti_es", "Return", NULL, (GCallback) _app_on_clip_properties_gtk_action_callback}, {"View", NULL, "_View", NULL, NULL, (GCallback) NULL}, {"ZoomIn", GTK_STOCK_ZOOM_IN, "Zoom _In", "plus", NULL, (GCallback) _app_on_zoom_in_gtk_action_callback}, {"ZoomOut", GTK_STOCK_ZOOM_OUT, "Zoom _Out", "minus", NULL, (GCallback) _app_on_zoom_out_gtk_action_callback}, {"ZoomProject", NULL, "Fit to _Window", "Z", NULL, (GCallback) _app_on_zoom_to_project_gtk_action_callback}, {"Go", NULL, "_Go", NULL, NULL, (GCallback) NULL}, {"Start", GTK_STOCK_GOTO_FIRST, "_Start", "Home", NULL, (GCallback) _app_on_go_start_gtk_action_callback}, {"End", GTK_STOCK_GOTO_LAST, "_End", "End", NULL, (GCallback) _app_on_go_end_gtk_action_callback}, {"Help", NULL, "_Help", NULL, NULL, (GCallback) NULL}, {"Contents", GTK_STOCK_HELP, "_Contents", "F1", "More information on Lombard", (GCallback) _app_on_help_contents_gtk_action_callback}, {"About", GTK_STOCK_ABOUT, NULL, NULL, NULL, (GCallback) _app_on_about_gtk_action_callback}, {"SaveGraph", NULL, "Save _Graph", NULL, "Save graph", (GCallback) _app_on_save_graph_gtk_action_callback}}; +static const GtkToggleActionEntry APP_check_actions[2] = {{APP_LibraryToggle, NULL, "_Library", "F9", NULL, (GCallback) _app_on_view_library_gtk_action_callback, TRUE}, {"Snap", NULL, "_Snap to Clip Edges", NULL, NULL, (GCallback) _app_on_snap_gtk_action_callback, TRUE}}; +static const DialogUtilsfilter_description_struct APP_filters[2] = {{"Lombard Project Files", MODEL_PROJECT_LOMBARD_FILE_EXTENSION}, {"Fillmore Project Files", MODEL_PROJECT_FILLMORE_FILE_EXTENSION}}; +static const DialogUtilsfilter_description_struct APP_export_filters[1] = {{"Ogg Files", "ogg"}}; + + +#line 445 "lombard.vala" +static void _app_on_open_gtk_action_callback (GtkAction* action, gpointer self) { +#line 242 "lombard.c" + app_on_open (self); +} + + +#line 485 "lombard.vala" +static void _app_on_save_gtk_action_callback (GtkAction* action, gpointer self) { +#line 249 "lombard.c" + app_on_save (self); +} + + +#line 481 "lombard.vala" +static void _app_on_save_as_gtk_action_callback (GtkAction* action, gpointer self) { +#line 256 "lombard.c" + app_on_save_as (self); +} + + +#line 727 "lombard.vala" +static void _app_on_play_pause_gtk_action_callback (GtkAction* action, gpointer self) { +#line 263 "lombard.c" + app_on_play_pause (self); +} + + +#line 739 "lombard.vala" +static void _app_on_export_gtk_action_callback (GtkAction* action, gpointer self) { +#line 270 "lombard.c" + app_on_export (self); +} + + +#line 269 "lombard.vala" +static void _app_on_quit_gtk_action_callback (GtkAction* action, gpointer self) { +#line 277 "lombard.c" + app_on_quit (self); +} + + +#line 770 "lombard.vala" +static void _app_on_undo_gtk_action_callback (GtkAction* action, gpointer self) { +#line 284 "lombard.c" + app_on_undo (self); +} + + +#line 781 "lombard.vala" +static void _app_on_cut_gtk_action_callback (GtkAction* action, gpointer self) { +#line 291 "lombard.c" + app_on_cut (self); +} + + +#line 785 "lombard.vala" +static void _app_on_copy_gtk_action_callback (GtkAction* action, gpointer self) { +#line 298 "lombard.c" + app_on_copy (self); +} + + +#line 789 "lombard.vala" +static void _app_on_paste_gtk_action_callback (GtkAction* action, gpointer self) { +#line 305 "lombard.c" + app_on_paste (self); +} + + +#line 774 "lombard.vala" +static void _app_on_delete_gtk_action_callback (GtkAction* action, gpointer self) { +#line 312 "lombard.c" + app_on_delete (self); +} + + +#line 808 "lombard.vala" +static void _app_on_select_all_gtk_action_callback (GtkAction* action, gpointer self) { +#line 319 "lombard.c" + app_on_select_all (self); +} + + +#line 535 "lombard.vala" +static void _app_on_split_at_playhead_gtk_action_callback (GtkAction* action, gpointer self) { +#line 326 "lombard.c" + app_on_split_at_playhead (self); +} + + +#line 539 "lombard.vala" +static void _app_on_trim_to_playhead_gtk_action_callback (GtkAction* action, gpointer self) { +#line 333 "lombard.c" + app_on_trim_to_playhead (self); +} + + +#line 543 "lombard.vala" +static void _app_on_clip_properties_gtk_action_callback (GtkAction* action, gpointer self) { +#line 340 "lombard.c" + app_on_clip_properties (self); +} + + +#line 699 "lombard.vala" +static void _app_on_zoom_in_gtk_action_callback (GtkAction* action, gpointer self) { +#line 347 "lombard.c" + app_on_zoom_in (self); +} + + +#line 703 "lombard.vala" +static void _app_on_zoom_out_gtk_action_callback (GtkAction* action, gpointer self) { +#line 354 "lombard.c" + app_on_zoom_out (self); +} + + +#line 707 "lombard.vala" +static void _app_on_zoom_to_project_gtk_action_callback (GtkAction* action, gpointer self) { +#line 361 "lombard.c" + app_on_zoom_to_project (self); +} + + +#line 818 "lombard.vala" +static void _app_on_go_start_gtk_action_callback (GtkAction* action, gpointer self) { +#line 368 "lombard.c" + app_on_go_start (self); +} + + +#line 820 "lombard.vala" +static void _app_on_go_end_gtk_action_callback (GtkAction* action, gpointer self) { +#line 375 "lombard.c" + app_on_go_end (self); +} + + +#line 824 "lombard.vala" +static void _app_on_help_contents_gtk_action_callback (GtkAction* action, gpointer self) { +#line 382 "lombard.c" + app_on_help_contents (self); +} + + +#line 831 "lombard.vala" +static void _app_on_about_gtk_action_callback (GtkAction* action, gpointer self) { +#line 389 "lombard.c" + app_on_about (self); +} + + +#line 843 "lombard.vala" +static void _app_on_save_graph_gtk_action_callback (GtkAction* action, gpointer self) { +#line 396 "lombard.c" + app_on_save_graph (self); +} + + +#line 685 "lombard.vala" +static void _app_on_view_library_gtk_action_callback (GtkAction* action, gpointer self) { +#line 403 "lombard.c" + app_on_view_library (self); +} + + +#line 681 "lombard.vala" +static void _app_on_snap_gtk_action_callback (GtkAction* action, gpointer self) { +#line 410 "lombard.c" + app_on_snap (self); +} + + +#line 344 "lombard.vala" +static void _app_on_drawing_realize_gtk_widget_realize (GtkWidget* _sender, gpointer self) { +#line 417 "lombard.c" + app_on_drawing_realize (self); +} + + +#line 371 "lombard.vala" +static void _app_set_project_name_model_project_name_changed (ModelProject* _sender, const char* project_file, gpointer self) { +#line 424 "lombard.c" + app_set_project_name (self, project_file); +} + + +#line 380 "lombard.vala" +static void _app_on_load_error_model_project_load_error (ModelProject* _sender, const char* _error_, gpointer self) { +#line 431 "lombard.c" + app_on_load_error (self, _error_); +} + + +#line 385 "lombard.vala" +static void _app_on_load_complete_model_project_load_complete (ModelProject* _sender, gpointer self) { +#line 438 "lombard.c" + app_on_load_complete (self); +} + + +#line 376 "lombard.vala" +static void _app_do_error_dialog_model_project_error_occurred (ModelProject* _sender, const char* major_message, const char* minor_message, gpointer self) { +#line 445 "lombard.c" + app_do_error_dialog (major_message, minor_message); +} + + +#line 800 "lombard.vala" +static void _app_on_undo_changed_model_undo_manager_undo_changed (ModelUndoManager* _sender, gboolean can_undo, gpointer self) { +#line 452 "lombard.c" + app_on_undo_changed (self, can_undo); +} + + +#line 757 "lombard.vala" +static void _app_on_post_export_view_media_engine_post_export (ViewMediaEngine* _sender, gboolean canceled, gpointer self) { +#line 459 "lombard.c" + app_on_post_export (self, canceled); +} + + +#line 793 "lombard.vala" +static void _app_on_playstate_changed_model_project_playstate_changed (ModelProject* _sender, PlayState playstate, gpointer self) { +#line 466 "lombard.c" + app_on_playstate_changed (self, playstate); +} + + +#line 625 "lombard.vala" +static void _app_on_timeline_selection_changed_time_line_selection_changed (TimeLine* _sender, gboolean selected, gpointer self) { +#line 473 "lombard.c" + app_on_timeline_selection_changed (self, selected); +} + + +#line 575 "lombard.vala" +static void _app_on_track_changed_time_line_track_changed (TimeLine* _sender, gpointer self) { +#line 480 "lombard.c" + app_on_track_changed (self); +} + + +#line 366 "lombard.vala" +static void _app_on_drag_data_received_gtk_widget_drag_data_received (GtkWidget* _sender, GdkDragContext* context, gint x, gint y, GtkSelectionData* selection_data, guint info, guint time_, gpointer self) { +#line 487 "lombard.c" + app_on_drag_data_received (self, _sender, context, x, y, selection_data, info, time_); +} + + +#line 711 "lombard.vala" +static void _app_on_timeline_size_allocate_gtk_widget_size_allocate (GtkWidget* _sender, GdkRectangle* allocation, gpointer self) { +#line 494 "lombard.c" + app_on_timeline_size_allocate (self, allocation); +} + + +#line 562 "lombard.vala" +static void _app_on_position_changed_view_media_engine_position_changed (ViewMediaEngine* _sender, gint64 position, gpointer self) { +#line 501 "lombard.c" + app_on_position_changed (self); +} + + +#line 567 "lombard.vala" +static void _app_on_callback_pulse_view_media_engine_callback_pulse (ViewMediaEngine* _sender, gpointer self) { +#line 508 "lombard.c" + app_on_callback_pulse (self); +} + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 632 "lombard.vala" +static void _app_on_library_selection_changed_clip_library_view_selection_changed (ClipLibraryView* _sender, gboolean selected, gpointer self) { +#line 520 "lombard.c" + app_on_library_selection_changed (self, selected); +} + + +#line 263 "lombard.vala" +static gboolean _app_on_delete_event_gtk_widget_delete_event (GtkWidget* _sender, GdkEvent* event, gpointer self) { +#line 527 "lombard.c" + gboolean result; + result = app_on_delete_event (self); + return result; +} + + +#line 165 "lombard.vala" +App* app_construct (GType object_type, const char* project_file, GError** error) { +#line 536 "lombard.c" + GError * _inner_error_; + App * self; + char* _tmp3_; + GeeArrayList* _tmp4_; + GtkDrawingArea* _tmp5_; + GdkColor _tmp7_; + GdkColor _tmp6_ = {0}; + GtkActionGroup* _tmp8_; + GtkUIManager* _tmp9_; + GtkMenuBar* _tmp10_; + ModelVideoProject* _tmp11_; + ModelVideoProject* _tmp12_; + GstCaps* _tmp13_; + ViewAudioOutput* _tmp14_; + ViewAudioOutput* _tmp15_; + ViewAudioOutput* _tmp16_; + TimeLine* _tmp17_; + GtkMenu* _tmp18_; + GtkMenu* _tmp19_; + ClipLibraryView* _tmp20_; + ViewStatusBar* _tmp21_; + GtkScrolledWindow* _tmp22_; + GtkMenuItem* save_graph; + _inner_error_ = NULL; + self = g_object_newv (object_type, 0, NULL); + { + char* _tmp2_; + GFile* _tmp1_; + GFile* _tmp0_; +#line 167 "lombard.vala" + gtk_window_set_icon_from_file (GTK_WINDOW (self), _tmp2_ = g_file_get_path (_tmp1_ = g_file_get_child (_tmp0_ = app_dirs_get_resources_dir (), "lombard_icon.png")), &_inner_error_); +#line 568 "lombard.c" + _g_free0 (_tmp2_); + _g_object_unref0 (_tmp1_); + _g_object_unref0 (_tmp0_); + if (_inner_error_ != NULL) { + goto __catch0_g_error; + } + } + goto __finally0; + __catch0_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { +#line 170 "lombard.vala" + g_warning ("lombard.vala:170: Could not load application icon: %s", e->message); +#line 585 "lombard.c" + _g_error_free0 (e); + } + } + __finally0: + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 173 "lombard.vala" + if (debug_level > (-1)) { +#line 174 "lombard.vala" + logging_set_logging_level ((LoggingLevel) debug_level); +#line 599 "lombard.c" + } +#line 176 "lombard.vala" + class_factory_set_transport_delegate (TRANSPORT_DELEGATE (self)); +#line 177 "lombard.vala" + gtk_window_set_default_size (GTK_WINDOW (self), 600, 500); +#line 178 "lombard.vala" + self->priv->project_filename = (_tmp3_ = g_strdup (project_file), _g_free0 (self->priv->project_filename), _tmp3_); +#line 180 "lombard.vala" + self->priv->load_errors = (_tmp4_ = gee_array_list_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL), _g_object_unref0 (self->priv->load_errors), _tmp4_); +#line 181 "lombard.vala" + self->priv->drawing_area = (_tmp5_ = g_object_ref_sink ((GtkDrawingArea*) gtk_drawing_area_new ()), _g_object_unref0 (self->priv->drawing_area), _tmp5_); +#line 182 "lombard.vala" + g_signal_connect_object (GTK_WIDGET (self->priv->drawing_area), "realize", (GCallback) _app_on_drawing_realize_gtk_widget_realize, self, 0); +#line 183 "lombard.vala" + gtk_widget_modify_bg (GTK_WIDGET (self->priv->drawing_area), GTK_STATE_NORMAL, (_tmp7_ = (parse_color ("#000", &_tmp6_), _tmp6_), &_tmp7_)); +#line 185 "lombard.vala" + self->priv->main_group = (_tmp8_ = gtk_action_group_new ("main"), _g_object_unref0 (self->priv->main_group), _tmp8_); +#line 186 "lombard.vala" + gtk_action_group_add_actions (self->priv->main_group, APP_entries, G_N_ELEMENTS (APP_entries), self); +#line 187 "lombard.vala" + gtk_action_group_add_toggle_actions (self->priv->main_group, APP_check_actions, G_N_ELEMENTS (APP_check_actions), self); +#line 189 "lombard.vala" + self->priv->manager = (_tmp9_ = gtk_ui_manager_new (), _g_object_unref0 (self->priv->manager), _tmp9_); +#line 190 "lombard.vala" + gtk_ui_manager_insert_action_group (self->priv->manager, self->priv->main_group, 0); +#line 625 "lombard.c" + { +#line 192 "lombard.vala" + gtk_ui_manager_add_ui_from_string (self->priv->manager, APP_ui, (gssize) (-1), &_inner_error_); +#line 629 "lombard.c" + if (_inner_error_ != NULL) { + goto __catch1_g_error; + } + } + goto __finally1; + __catch1_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { +#line 193 "lombard.vala" + g_error ("lombard.vala:193: %s", e->message); +#line 643 "lombard.c" + _g_error_free0 (e); + } + } + __finally1: + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 195 "lombard.vala" + self->priv->menubar = (_tmp10_ = GTK_MENU_BAR (get_widget (self->priv->manager, "/MenuBar")), _g_object_unref0 (self->priv->menubar), _tmp10_); +#line 197 "lombard.vala" + _tmp11_ = model_video_project_new (self->priv->project_filename, &_inner_error_); +#line 657 "lombard.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 197 "lombard.vala" + self->priv->project = (_tmp12_ = _tmp11_, _g_object_unref0 (self->priv->project), _tmp12_); +#line 198 "lombard.vala" + MODEL_PROJECT (self->priv->project)->snap_to_clip = TRUE; +#line 199 "lombard.vala" + g_signal_connect_object (MODEL_PROJECT (self->priv->project), "name-changed", (GCallback) _app_set_project_name_model_project_name_changed, self, 0); +#line 200 "lombard.vala" + g_signal_connect_object (MODEL_PROJECT (self->priv->project), "load-error", (GCallback) _app_on_load_error_model_project_load_error, self, 0); +#line 201 "lombard.vala" + g_signal_connect_object (MODEL_PROJECT (self->priv->project), "load-complete", (GCallback) _app_on_load_complete_model_project_load_complete, self, 0); +#line 202 "lombard.vala" + g_signal_connect (MODEL_PROJECT (self->priv->project), "error-occurred", (GCallback) _app_do_error_dialog_model_project_error_occurred, NULL); +#line 203 "lombard.vala" + g_signal_connect_object (MODEL_PROJECT (self->priv->project)->undo_manager, "undo-changed", (GCallback) _app_on_undo_changed_model_undo_manager_undo_changed, self, 0); +#line 204 "lombard.vala" + g_signal_connect_object (MODEL_PROJECT (self->priv->project)->media_engine, "post-export", (GCallback) _app_on_post_export_view_media_engine_post_export, self, 0); +#line 205 "lombard.vala" + g_signal_connect_object (MODEL_PROJECT (self->priv->project), "playstate-changed", (GCallback) _app_on_playstate_changed_model_project_playstate_changed, self, 0); +#line 207 "lombard.vala" + _tmp15_ = (_tmp14_ = view_audio_output_new (_tmp13_ = view_media_engine_get_project_audio_caps (MODEL_PROJECT (self->priv->project)->media_engine), &_inner_error_), _gst_caps_unref0 (_tmp13_), _tmp14_); +#line 683 "lombard.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 207 "lombard.vala" + self->priv->audio_output = (_tmp16_ = _tmp15_, _g_object_unref0 (self->priv->audio_output), _tmp16_); +#line 208 "lombard.vala" + view_media_engine_connect_output (MODEL_PROJECT (self->priv->project)->media_engine, VIEW_MEDIA_CONNECTOR (self->priv->audio_output)); +#line 210 "lombard.vala" + self->priv->timeline = (_tmp17_ = g_object_ref_sink (time_line_new (MODEL_PROJECT (self->priv->project), MODEL_TIME_SYSTEM (self->priv->project->time_provider), GDK_ACTION_COPY | GDK_ACTION_MOVE)), _g_object_unref0 (self->priv->timeline), _tmp17_); +#line 212 "lombard.vala" + g_signal_connect_object (self->priv->timeline, "selection-changed", (GCallback) _app_on_timeline_selection_changed_time_line_selection_changed, self, 0); +#line 213 "lombard.vala" + g_signal_connect_object (self->priv->timeline, "track-changed", (GCallback) _app_on_track_changed_time_line_track_changed, self, 0); +#line 214 "lombard.vala" + g_signal_connect_object (GTK_WIDGET (self->priv->timeline), "drag-data-received", (GCallback) _app_on_drag_data_received_gtk_widget_drag_data_received, self, 0); +#line 215 "lombard.vala" + g_signal_connect_object (GTK_WIDGET (self->priv->timeline), "size-allocate", (GCallback) _app_on_timeline_size_allocate_gtk_widget_size_allocate, self, 0); +#line 216 "lombard.vala" + g_signal_connect_object (MODEL_PROJECT (self->priv->project)->media_engine, "position-changed", (GCallback) _app_on_position_changed_view_media_engine_position_changed, self, 0); +#line 217 "lombard.vala" + g_signal_connect_object (MODEL_PROJECT (self->priv->project)->media_engine, "callback-pulse", (GCallback) _app_on_callback_pulse_view_media_engine_callback_pulse, self, 0); +#line 218 "lombard.vala" + clip_view_context_menu = (_tmp18_ = _g_object_ref0 (GTK_MENU (gtk_ui_manager_get_widget (self->priv->manager, "/ClipContextMenu"))), _g_object_unref0 (clip_view_context_menu), _tmp18_); +#line 219 "lombard.vala" + clip_library_view_context_menu = (_tmp19_ = _g_object_ref0 (GTK_MENU (gtk_ui_manager_get_widget (self->priv->manager, "/LibraryContextMenu"))), _g_object_unref0 (clip_library_view_context_menu), _tmp19_); +#line 221 "lombard.vala" + self->priv->library = (_tmp20_ = g_object_ref_sink (clip_library_view_new (MODEL_PROJECT (self->priv->project), MODEL_TIME_SYSTEM (self->priv->project->time_provider), "Drag clips here.", GDK_ACTION_COPY | GDK_ACTION_MOVE)), _g_object_unref0 (self->priv->library), _tmp20_); +#line 223 "lombard.vala" + g_signal_connect_object (self->priv->library, "selection-changed", (GCallback) _app_on_library_selection_changed_clip_library_view_selection_changed, self, 0); +#line 224 "lombard.vala" + g_signal_connect_object (GTK_WIDGET (self->priv->library), "drag-data-received", (GCallback) _app_on_drag_data_received_gtk_widget_drag_data_received, self, 0); +#line 226 "lombard.vala" + self->priv->status_bar = (_tmp21_ = g_object_ref_sink (view_status_bar_new (MODEL_PROJECT (self->priv->project), MODEL_TIME_SYSTEM (self->priv->project->time_provider), TIME_LINE_BAR_HEIGHT)), _g_object_unref0 (self->priv->status_bar), _tmp21_); +#line 228 "lombard.vala" + self->priv->library_scrolled = (_tmp22_ = g_object_ref_sink ((GtkScrolledWindow*) gtk_scrolled_window_new (NULL, NULL)), _g_object_unref0 (self->priv->library_scrolled), _tmp22_); +#line 229 "lombard.vala" + gtk_scrolled_window_set_policy (self->priv->library_scrolled, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); +#line 230 "lombard.vala" + gtk_scrolled_window_add_with_viewport (self->priv->library_scrolled, GTK_WIDGET (self->priv->library)); +#line 232 "lombard.vala" + app_toggle_library (self, TRUE); +#line 234 "lombard.vala" + save_graph = GTK_MENU_ITEM (get_widget (self->priv->manager, "/MenuBar/HelpMenu/SaveGraph")); +#line 239 "lombard.vala" + if (save_graph != NULL) { +#line 240 "lombard.vala" + gtk_object_destroy (GTK_OBJECT (save_graph)); +#line 733 "lombard.c" + } +#line 243 "lombard.vala" + gtk_window_add_accel_group (GTK_WINDOW (self), gtk_ui_manager_get_accel_group (self->priv->manager)); +#line 245 "lombard.vala" + app_on_undo_changed (self, FALSE); +#line 247 "lombard.vala" + g_signal_connect_object (GTK_WIDGET (self), "delete-event", (GCallback) _app_on_delete_event_gtk_widget_delete_event, self, 0); +#line 249 "lombard.vala" + if (self->priv->project_filename == NULL) { +#line 250 "lombard.vala" + app_default_track_set (self); +#line 251 "lombard.vala" + app_on_load_complete (self); +#line 747 "lombard.c" + } +#line 254 "lombard.vala" + app_update_menu (self); +#line 255 "lombard.vala" + gtk_widget_show_all (GTK_WIDGET (self)); +#line 753 "lombard.c" + _g_object_unref0 (save_graph); + return self; +} + + +#line 165 "lombard.vala" +App* app_new (const char* project_file, GError** error) { +#line 165 "lombard.vala" + return app_construct (TYPE_APP, project_file, error); +#line 763 "lombard.c" +} + + +#line 258 "lombard.vala" +static void app_default_track_set (App* self) { +#line 769 "lombard.c" + ModelVideoTrack* _tmp0_; + ModelAudioTrack* _tmp1_; +#line 258 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 259 "lombard.vala" + model_project_add_track (MODEL_PROJECT (self->priv->project), MODEL_TRACK (_tmp0_ = model_video_track_new (MODEL_PROJECT (self->priv->project)))); +#line 776 "lombard.c" + _g_object_unref0 (_tmp0_); +#line 260 "lombard.vala" + model_project_add_track (MODEL_PROJECT (self->priv->project), MODEL_TRACK (_tmp1_ = model_audio_track_new (MODEL_PROJECT (self->priv->project), "Audio Track"))); +#line 780 "lombard.c" + _g_object_unref0 (_tmp1_); +} + + +#line 263 "lombard.vala" +static gboolean app_on_delete_event (App* self) { +#line 787 "lombard.c" + gboolean result = FALSE; +#line 263 "lombard.vala" + g_return_val_if_fail (IS_APP (self), FALSE); +#line 264 "lombard.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_delete_event"); +#line 265 "lombard.vala" + app_on_quit (self); +#line 795 "lombard.c" + result = TRUE; +#line 266 "lombard.vala" + return result; +#line 799 "lombard.c" +} + + +#line 269 "lombard.vala" +static void app_on_quit (App* self) { +#line 269 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 270 "lombard.vala" + if (model_undo_manager_get_is_dirty (MODEL_PROJECT (self->priv->project)->undo_manager)) { +#line 271 "lombard.vala" + switch (dialog_utils_save_close_cancel (GTK_WINDOW (self), NULL, "Save changes before closing?")) { +#line 811 "lombard.c" + case GTK_RESPONSE_ACCEPT: + { +#line 273 "lombard.vala" + if (!app_do_save (self)) { +#line 274 "lombard.vala" + return; +#line 818 "lombard.c" + } +#line 276 "lombard.vala" + break; +#line 822 "lombard.c" + } + case GTK_RESPONSE_CLOSE: + { +#line 278 "lombard.vala" + break; +#line 828 "lombard.c" + } + case GTK_RESPONSE_DELETE_EVENT: + case GTK_RESPONSE_CANCEL: + { +#line 281 "lombard.vala" + return; +#line 835 "lombard.c" + } + default: + { +#line 283 "lombard.vala" + g_assert (FALSE); +#line 284 "lombard.vala" + break; +#line 843 "lombard.c" + } + } + } +#line 288 "lombard.vala" + gtk_main_quit (); +#line 849 "lombard.c" +} + + +#line 424 "lombard.vala" +static void _app_on_library_size_allocate_gtk_widget_size_allocate (GtkWidget* _sender, GdkRectangle* allocation, gpointer self) { +#line 855 "lombard.c" + app_on_library_size_allocate (self, allocation); +} + + +#line 356 "lombard.vala" +static void _app_on_adjustment_changed_gtk_adjustment_changed (GtkAdjustment* _sender, gpointer self) { +#line 862 "lombard.c" + app_on_adjustment_changed (self, _sender); +} + + +#line 291 "lombard.vala" +static void app_toggle_library (App* self, gboolean showing) { +#line 291 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 292 "lombard.vala" + if (self->priv->vbox == NULL) { +#line 873 "lombard.c" + GtkVBox* _tmp0_; + GtkVPaned* v_pane; + GtkHPaned* _tmp1_; + GtkScrolledWindow* _tmp2_; + GtkVBox* timeline_vbox; + GtkAdjustment* _tmp3_; +#line 293 "lombard.vala" + self->priv->vbox = (_tmp0_ = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (FALSE, 0)), _g_object_unref0 (self->priv->vbox), _tmp0_); +#line 294 "lombard.vala" + gtk_box_pack_start (GTK_BOX (self->priv->vbox), GTK_WIDGET (self->priv->menubar), FALSE, FALSE, (guint) 0); +#line 296 "lombard.vala" + v_pane = g_object_ref_sink ((GtkVPaned*) gtk_vpaned_new ()); +#line 297 "lombard.vala" + gtk_paned_set_position (GTK_PANED (v_pane), 290); +#line 299 "lombard.vala" + self->priv->h_pane = (_tmp1_ = g_object_ref_sink ((GtkHPaned*) gtk_hpaned_new ()), _g_object_unref0 (self->priv->h_pane), _tmp1_); +#line 300 "lombard.vala" + gtk_paned_set_position (GTK_PANED (self->priv->h_pane), 300); +#line 301 "lombard.vala" + GTK_PANED (self->priv->h_pane)->child2_resize = (guint) 1; +#line 302 "lombard.vala" + GTK_PANED (self->priv->h_pane)->child1_resize = (guint) 0; +#line 304 "lombard.vala" + if (showing) { +#line 305 "lombard.vala" + gtk_paned_add1 (GTK_PANED (self->priv->h_pane), GTK_WIDGET (self->priv->library_scrolled)); +#line 306 "lombard.vala" + gtk_paned_add2 (GTK_PANED (self->priv->h_pane), GTK_WIDGET (self->priv->drawing_area)); +#line 902 "lombard.c" + } else { +#line 308 "lombard.vala" + gtk_paned_add2 (GTK_PANED (self->priv->h_pane), GTK_WIDGET (self->priv->drawing_area)); +#line 906 "lombard.c" + } +#line 310 "lombard.vala" + g_signal_connect_object (GTK_PANED (self->priv->h_pane)->child2, "size-allocate", (GCallback) _app_on_library_size_allocate_gtk_widget_size_allocate, self, 0); +#line 311 "lombard.vala" + gtk_paned_add1 (GTK_PANED (v_pane), GTK_WIDGET (self->priv->h_pane)); +#line 313 "lombard.vala" + self->priv->timeline_scrolled = (_tmp2_ = g_object_ref_sink ((GtkScrolledWindow*) gtk_scrolled_window_new (NULL, NULL)), _g_object_unref0 (self->priv->timeline_scrolled), _tmp2_); +#line 314 "lombard.vala" + gtk_scrolled_window_set_policy (self->priv->timeline_scrolled, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); +#line 315 "lombard.vala" + gtk_scrolled_window_add_with_viewport (self->priv->timeline_scrolled, GTK_WIDGET (self->priv->timeline)); +#line 317 "lombard.vala" + timeline_vbox = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (FALSE, 0)); +#line 318 "lombard.vala" + gtk_box_pack_start (GTK_BOX (timeline_vbox), GTK_WIDGET (self->priv->status_bar), FALSE, FALSE, (guint) 0); +#line 319 "lombard.vala" + gtk_box_pack_start (GTK_BOX (timeline_vbox), GTK_WIDGET (self->priv->timeline_scrolled), TRUE, TRUE, (guint) 0); +#line 320 "lombard.vala" + gtk_paned_add2 (GTK_PANED (v_pane), GTK_WIDGET (timeline_vbox)); +#line 322 "lombard.vala" + GTK_PANED (v_pane)->child1_resize = (guint) 1; +#line 323 "lombard.vala" + GTK_PANED (v_pane)->child2_resize = (guint) 0; +#line 325 "lombard.vala" + self->priv->h_adjustment = (_tmp3_ = _g_object_ref0 (gtk_scrolled_window_get_hadjustment (self->priv->timeline_scrolled)), _g_object_unref0 (self->priv->h_adjustment), _tmp3_); +#line 326 "lombard.vala" + g_signal_connect_object (self->priv->h_adjustment, "changed", (GCallback) _app_on_adjustment_changed_gtk_adjustment_changed, self, 0); +#line 327 "lombard.vala" + self->priv->prev_adjustment_lower = gtk_adjustment_get_lower (self->priv->h_adjustment); +#line 328 "lombard.vala" + self->priv->prev_adjustment_upper = gtk_adjustment_get_upper (self->priv->h_adjustment); +#line 330 "lombard.vala" + gtk_box_pack_start (GTK_BOX (self->priv->vbox), GTK_WIDGET (v_pane), TRUE, TRUE, (guint) 0); +#line 332 "lombard.vala" + gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (self->priv->vbox)); +#line 942 "lombard.c" + _g_object_unref0 (v_pane); + _g_object_unref0 (timeline_vbox); + } else { +#line 334 "lombard.vala" + MODEL_PROJECT (self->priv->project)->library_visible = showing; +#line 335 "lombard.vala" + if (showing) { +#line 336 "lombard.vala" + gtk_paned_add1 (GTK_PANED (self->priv->h_pane), GTK_WIDGET (self->priv->library_scrolled)); +#line 952 "lombard.c" + } else { +#line 338 "lombard.vala" + gtk_container_remove (GTK_CONTAINER (self->priv->h_pane), GTK_WIDGET (self->priv->library_scrolled)); +#line 956 "lombard.c" + } + } +#line 341 "lombard.vala" + gtk_widget_show_all (GTK_WIDGET (self)); +#line 961 "lombard.c" +} + + +#line 344 "lombard.vala" +static void app_on_drawing_realize (App* self) { +#line 967 "lombard.c" + GError * _inner_error_; +#line 344 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 971 "lombard.c" + _inner_error_ = NULL; +#line 345 "lombard.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_drawing_realize"); +#line 346 "lombard.vala" + self->priv->loading = TRUE; +#line 347 "lombard.vala" + model_project_load (MODEL_PROJECT (self->priv->project), self->priv->project_filename); +#line 979 "lombard.c" + { + ViewVideoOutput* _tmp0_; + ViewVideoOutput* _tmp1_; +#line 349 "lombard.vala" + _tmp0_ = view_video_output_new (GTK_WIDGET (self->priv->drawing_area), &_inner_error_); +#line 985 "lombard.c" + if (_inner_error_ != NULL) { + goto __catch2_g_error; + } +#line 349 "lombard.vala" + self->priv->video_output = (_tmp1_ = _tmp0_, _g_object_unref0 (self->priv->video_output), _tmp1_); +#line 350 "lombard.vala" + view_media_engine_connect_output (MODEL_PROJECT (self->priv->project)->media_engine, VIEW_MEDIA_CONNECTOR (self->priv->video_output)); +#line 993 "lombard.c" + } + goto __finally2; + __catch2_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { +#line 352 "lombard.vala" + app_do_error_dialog ("Could not create video output", e->message); +#line 1004 "lombard.c" + _g_error_free0 (e); + } + } + __finally2: + if (_inner_error_ != NULL) { + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } +} + + +#line 356 "lombard.vala" +static void app_on_adjustment_changed (App* self, GtkAdjustment* a) { +#line 1019 "lombard.c" + gboolean _tmp0_ = FALSE; +#line 356 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 356 "lombard.vala" + g_return_if_fail (GTK_IS_ADJUSTMENT (a)); +#line 357 "lombard.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_adjustment_changed"); +#line 358 "lombard.vala" + if (self->priv->prev_adjustment_upper != gtk_adjustment_get_upper (a)) { +#line 358 "lombard.vala" + _tmp0_ = TRUE; +#line 1031 "lombard.c" + } else { +#line 359 "lombard.vala" + _tmp0_ = self->priv->prev_adjustment_lower != gtk_adjustment_get_lower (a); +#line 1035 "lombard.c" + } +#line 358 "lombard.vala" + if (_tmp0_) { +#line 361 "lombard.vala" + self->priv->prev_adjustment_lower = gtk_adjustment_get_lower (a); +#line 362 "lombard.vala" + self->priv->prev_adjustment_upper = gtk_adjustment_get_upper (a); +#line 1043 "lombard.c" + } +} + + +#line 366 "lombard.vala" +static void app_on_drag_data_received (App* self, GtkWidget* w, GdkDragContext* context, gint x, gint y, GtkSelectionData* selection_data, guint drag_info, guint time) { +#line 366 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 366 "lombard.vala" + g_return_if_fail (GTK_IS_WIDGET (w)); +#line 366 "lombard.vala" + g_return_if_fail (GDK_IS_DRAG_CONTEXT (context)); +#line 366 "lombard.vala" + g_return_if_fail (selection_data != NULL); +#line 368 "lombard.vala" + gtk_window_present (GTK_WINDOW (self)); +#line 1060 "lombard.c" +} + + +#line 371 "lombard.vala" +void app_set_project_name (App* self, const char* filename) { +#line 1066 "lombard.c" + char* _tmp0_; +#line 371 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 372 "lombard.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "set_project_name"); +#line 373 "lombard.vala" + gtk_window_set_title (GTK_WINDOW (self), _tmp0_ = model_project_get_file_display_name (MODEL_PROJECT (self->priv->project))); +#line 1074 "lombard.c" + _g_free0 (_tmp0_); +} + + +#line 376 "lombard.vala" +void app_do_error_dialog (const char* message, const char* minor_message) { +#line 376 "lombard.vala" + g_return_if_fail (message != NULL); +#line 377 "lombard.vala" + dialog_utils_error (message, minor_message); +#line 1085 "lombard.c" +} + + +#line 380 "lombard.vala" +void app_on_load_error (App* self, const char* message) { +#line 380 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 380 "lombard.vala" + g_return_if_fail (message != NULL); +#line 381 "lombard.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_load_error"); +#line 382 "lombard.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->load_errors), message); +#line 1099 "lombard.c" +} + + +#line 385 "lombard.vala" +void app_on_load_complete (App* self) { +#line 1105 "lombard.c" + ModelVideoTrack* _tmp0_; + gboolean _tmp1_; + GtkAction* _tmp3_; + GtkToggleAction* action; + GtkToggleAction* _tmp5_; + GtkAction* _tmp4_; +#line 385 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 386 "lombard.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_load_complete"); +#line 387 "lombard.vala" + gtk_widget_queue_draw (GTK_WIDGET (self)); +#line 388 "lombard.vala" + if ((_tmp1_ = (_tmp0_ = model_project_find_video_track (MODEL_PROJECT (self->priv->project))) == NULL, _g_object_unref0 (_tmp0_), _tmp1_)) { +#line 1120 "lombard.c" + ModelVideoTrack* _tmp2_; +#line 389 "lombard.vala" + model_project_add_track (MODEL_PROJECT (self->priv->project), MODEL_TRACK (_tmp2_ = model_video_track_new (MODEL_PROJECT (self->priv->project)))); +#line 1124 "lombard.c" + _g_object_unref0 (_tmp2_); + } +#line 392 "lombard.vala" + gst_element_set_state (GST_ELEMENT (MODEL_PROJECT (self->priv->project)->media_engine->pipeline), GST_STATE_PAUSED); +#line 393 "lombard.vala" + gtk_paned_set_position (GTK_PANED (self->priv->h_pane), GTK_WIDGET (self->priv->h_pane)->allocation.width - MODEL_PROJECT (self->priv->project)->library_width); +#line 394 "lombard.vala" + action = _g_object_ref0 ((_tmp3_ = gtk_action_group_get_action (self->priv->main_group, APP_LibraryToggle), GTK_IS_TOGGLE_ACTION (_tmp3_) ? ((GtkToggleAction*) _tmp3_) : NULL)); +#line 395 "lombard.vala" + if (gtk_toggle_action_get_active (action) != MODEL_PROJECT (self->priv->project)->library_visible) { +#line 396 "lombard.vala" + gtk_toggle_action_set_active (action, MODEL_PROJECT (self->priv->project)->library_visible); +#line 1137 "lombard.c" + } +#line 399 "lombard.vala" + action = (_tmp5_ = _g_object_ref0 ((_tmp4_ = gtk_action_group_get_action (self->priv->main_group, "Snap"), GTK_IS_TOGGLE_ACTION (_tmp4_) ? ((GtkToggleAction*) _tmp4_) : NULL)), _g_object_unref0 (action), _tmp5_); +#line 400 "lombard.vala" + if (gtk_toggle_action_get_active (action) != MODEL_PROJECT (self->priv->project)->snap_to_clip) { +#line 401 "lombard.vala" + gtk_toggle_action_set_active (action, MODEL_PROJECT (self->priv->project)->snap_to_clip); +#line 1145 "lombard.c" + } +#line 404 "lombard.vala" + if (MODEL_PROJECT (self->priv->project)->library_visible) { +#line 405 "lombard.vala" + if (GTK_PANED (self->priv->h_pane)->child1 != GTK_WIDGET (self->priv->library_scrolled)) { +#line 406 "lombard.vala" + gtk_paned_add1 (GTK_PANED (self->priv->h_pane), GTK_WIDGET (self->priv->library_scrolled)); +#line 1153 "lombard.c" + } + } else { +#line 409 "lombard.vala" + if (GTK_PANED (self->priv->h_pane)->child1 == GTK_WIDGET (self->priv->library_scrolled)) { +#line 410 "lombard.vala" + gtk_container_remove (GTK_CONTAINER (self->priv->h_pane), GTK_WIDGET (self->priv->library_scrolled)); +#line 1160 "lombard.c" + } + } +#line 414 "lombard.vala" + if (gee_collection_get_size (GEE_COLLECTION (self->priv->load_errors)) > 0) { +#line 1165 "lombard.c" + char* message; +#line 415 "lombard.vala" + message = g_strdup (""); +#line 1169 "lombard.c" + { + GeeIterator* _s_it; + _s_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->priv->load_errors)); +#line 416 "lombard.vala" + while (TRUE) { +#line 1175 "lombard.c" + char* s; + char* _tmp7_; + char* _tmp6_; +#line 416 "lombard.vala" + if (!gee_iterator_next (_s_it)) { +#line 416 "lombard.vala" + break; +#line 1183 "lombard.c" + } +#line 416 "lombard.vala" + s = (char*) gee_iterator_get (_s_it); +#line 417 "lombard.vala" + message = (_tmp7_ = g_strconcat (_tmp6_ = g_strconcat (message, s, NULL), "\n", NULL), _g_free0 (message), _tmp7_); +#line 1189 "lombard.c" + _g_free0 (_tmp6_); + _g_free0 (s); + } + _g_object_unref0 (_s_it); + } +#line 419 "lombard.vala" + app_do_error_dialog ("An error occurred loading the project.", message); +#line 1197 "lombard.c" + _g_free0 (message); + } +#line 421 "lombard.vala" + self->priv->loading = FALSE; +#line 1202 "lombard.c" + _g_object_unref0 (action); +} + + +#line 424 "lombard.vala" +static void app_on_library_size_allocate (App* self, GdkRectangle* rectangle) { +#line 1209 "lombard.c" + gboolean _tmp0_ = FALSE; +#line 424 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 425 "lombard.vala" + if (!self->priv->loading) { +#line 425 "lombard.vala" + _tmp0_ = GTK_PANED (self->priv->h_pane)->child1 == GTK_WIDGET (self->priv->library_scrolled); +#line 1217 "lombard.c" + } else { +#line 425 "lombard.vala" + _tmp0_ = FALSE; +#line 1221 "lombard.c" + } +#line 425 "lombard.vala" + if (_tmp0_) { +#line 426 "lombard.vala" + MODEL_PROJECT (self->priv->project)->library_width = (*rectangle).width; +#line 1227 "lombard.c" + } +} + + +#line 432 "lombard.vala" +void app_load_file (App* self, const char* name, ModelLibraryImporter* im) { +#line 1234 "lombard.c" + GError * _inner_error_; + gboolean _tmp0_ = FALSE; + char* _tmp1_; + gboolean _tmp2_; +#line 432 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 432 "lombard.vala" + g_return_if_fail (name != NULL); +#line 432 "lombard.vala" + g_return_if_fail (MODEL_IS_LIBRARY_IMPORTER (im)); +#line 1245 "lombard.c" + _inner_error_ = NULL; +#line 433 "lombard.vala" + if ((_tmp2_ = _vala_strcmp0 (_tmp1_ = get_file_extension (name), MODEL_PROJECT_LOMBARD_FILE_EXTENSION) == 0, _g_free0 (_tmp1_), _tmp2_)) { +#line 433 "lombard.vala" + _tmp0_ = TRUE; +#line 1251 "lombard.c" + } else { + char* _tmp3_; +#line 434 "lombard.vala" + _tmp0_ = _vala_strcmp0 (_tmp3_ = get_file_extension (name), MODEL_PROJECT_FILLMORE_FILE_EXTENSION) == 0; +#line 1256 "lombard.c" + _g_free0 (_tmp3_); + } +#line 433 "lombard.vala" + if (_tmp0_) { +#line 435 "lombard.vala" + app_load_project (self, name); +#line 1263 "lombard.c" + } else { + { +#line 438 "lombard.vala" + model_library_importer_add_file (im, name, &_inner_error_); +#line 1268 "lombard.c" + if (_inner_error_ != NULL) { + goto __catch3_g_error; + } + } + goto __finally3; + __catch3_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { +#line 440 "lombard.vala" + app_do_error_dialog ("Error loading file", e->message); +#line 1282 "lombard.c" + _g_error_free0 (e); + } + } + __finally3: + if (_inner_error_ != NULL) { + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } + } +} + + +static void _g_slist_free_g_free (GSList* self) { + g_slist_foreach (self, (GFunc) g_free, NULL); + g_slist_free (self); +} + + +#line 466 "lombard.vala" +static void _app_on_importer_started_model_library_importer_started (ModelLibraryImporter* _sender, ModelClipImporter* i, gint num, gpointer self) { +#line 1304 "lombard.c" + app_on_importer_started (self, i, num); +} + + +#line 445 "lombard.vala" +static void app_on_open (App* self) { +#line 1311 "lombard.c" + GError * _inner_error_; + GSList* filenames; + GSList* _tmp2_; + gboolean _tmp1_; + GSList* _tmp0_ = NULL; +#line 445 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 1319 "lombard.c" + _inner_error_ = NULL; +#line 446 "lombard.vala" + gee_abstract_collection_clear (GEE_ABSTRACT_COLLECTION (self->priv->load_errors)); +#line 1323 "lombard.c" + filenames = NULL; +#line 448 "lombard.vala" + if ((_tmp1_ = dialog_utils_open (GTK_WINDOW (self), APP_filters, G_N_ELEMENTS (APP_filters), TRUE, TRUE, &_tmp0_), filenames = (_tmp2_ = _tmp0_, __g_slist_free_g_free0 (filenames), _tmp2_), _tmp1_)) { +#line 449 "lombard.vala" + model_project_create_clip_importer (MODEL_PROJECT (self->priv->project), NULL, FALSE, (gint64) 0, FALSE, NULL, 0); +#line 450 "lombard.vala" + g_signal_connect_object (MODEL_PROJECT (self->priv->project)->importer, "started", (GCallback) _app_on_importer_started_model_library_importer_started, self, 0); +#line 1331 "lombard.c" + { + { + GSList* s_collection; + GSList* s_it; +#line 452 "lombard.vala" + s_collection = filenames; +#line 1338 "lombard.c" + for (s_it = s_collection; s_it != NULL; s_it = s_it->next) { + char* s; +#line 452 "lombard.vala" + s = g_strdup ((const char*) s_it->data); +#line 1343 "lombard.c" + { + char* str; + str = NULL; + { + char* _tmp3_; + char* _tmp4_; +#line 455 "lombard.vala" + _tmp3_ = g_filename_from_uri (s, NULL, &_inner_error_); +#line 1352 "lombard.c" + if (_inner_error_ != NULL) { + if (_inner_error_->domain == G_CONVERT_ERROR) { + goto __catch5_g_convert_error; + } + _g_free0 (s); + _g_free0 (str); + __g_slist_free_g_free0 (filenames); + g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } +#line 455 "lombard.vala" + str = (_tmp4_ = _tmp3_, _g_free0 (str), _tmp4_); +#line 1366 "lombard.c" + } + goto __finally5; + __catch5_g_convert_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { + char* _tmp5_; +#line 456 "lombard.vala" + str = (_tmp5_ = g_strdup (s), _g_free0 (str), _tmp5_); +#line 1378 "lombard.c" + _g_error_free0 (e); + } + } + __finally5: + if (_inner_error_ != NULL) { + _g_free0 (s); + _g_free0 (str); + goto __catch4_g_error; + } +#line 457 "lombard.vala" + app_load_file (self, str, MODEL_PROJECT (self->priv->project)->importer); +#line 1390 "lombard.c" + _g_free0 (s); + _g_free0 (str); + } + } + } +#line 459 "lombard.vala" + model_library_importer_start (MODEL_PROJECT (self->priv->project)->importer, &_inner_error_); +#line 1398 "lombard.c" + if (_inner_error_ != NULL) { + goto __catch4_g_error; + } + } + goto __finally4; + __catch4_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { +#line 461 "lombard.vala" + app_do_error_dialog ("Could not open file", e->message); +#line 1412 "lombard.c" + _g_error_free0 (e); + } + } + __finally4: + if (_inner_error_ != NULL) { + __g_slist_free_g_free0 (filenames); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } + } + __g_slist_free_g_free0 (filenames); +} + + +#line 466 "lombard.vala" +static void app_on_importer_started (App* self, ModelClipImporter* i, gint num) { +#line 1430 "lombard.c" + MultiFileProgress* _tmp0_; +#line 466 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 466 "lombard.vala" + g_return_if_fail (MODEL_IS_CLIP_IMPORTER (i)); +#line 467 "lombard.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_importer_started"); +#line 468 "lombard.vala" + _tmp0_ = g_object_ref_sink (multi_file_progress_new (GTK_WINDOW (self), num, "Import", MULTI_FILE_PROGRESS_INTERFACE (i))); +#line 1440 "lombard.c" + _g_object_unref0 (_tmp0_); +} + + +#line 471 "lombard.vala" +static gboolean app_do_save_dialog (App* self) { +#line 1447 "lombard.c" + gboolean result = FALSE; + char* filename; + gboolean create_directory; +#line 471 "lombard.vala" + g_return_val_if_fail (IS_APP (self), FALSE); +#line 472 "lombard.vala" + filename = model_project_get_project_file (MODEL_PROJECT (self->priv->project)); +#line 473 "lombard.vala" + create_directory = filename == NULL; +#line 474 "lombard.vala" + if (dialog_utils_save (GTK_WINDOW (self), "Save Project", create_directory, APP_filters, G_N_ELEMENTS (APP_filters), &filename)) { +#line 475 "lombard.vala" + model_project_save (MODEL_PROJECT (self->priv->project), filename); +#line 1461 "lombard.c" + result = TRUE; + _g_free0 (filename); +#line 476 "lombard.vala" + return result; +#line 1466 "lombard.c" + } + result = FALSE; + _g_free0 (filename); +#line 478 "lombard.vala" + return result; +#line 1472 "lombard.c" +} + + +#line 481 "lombard.vala" +static void app_on_save_as (App* self) { +#line 481 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 482 "lombard.vala" + app_do_save_dialog (self); +#line 1482 "lombard.c" +} + + +#line 485 "lombard.vala" +static void app_on_save (App* self) { +#line 485 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 486 "lombard.vala" + app_do_save (self); +#line 1492 "lombard.c" +} + + +#line 489 "lombard.vala" +static gboolean app_do_save (App* self) { +#line 1498 "lombard.c" + gboolean result = FALSE; + char* _tmp0_; + gboolean _tmp1_; +#line 489 "lombard.vala" + g_return_val_if_fail (IS_APP (self), FALSE); +#line 490 "lombard.vala" + if ((_tmp1_ = (_tmp0_ = model_project_get_project_file (MODEL_PROJECT (self->priv->project))) != NULL, _g_free0 (_tmp0_), _tmp1_)) { +#line 491 "lombard.vala" + model_project_save (MODEL_PROJECT (self->priv->project), NULL); +#line 1508 "lombard.c" + result = TRUE; +#line 492 "lombard.vala" + return result; +#line 1512 "lombard.c" + } + result = app_do_save_dialog (self); +#line 494 "lombard.vala" + return result; +#line 1517 "lombard.c" +} + + +#line 497 "lombard.vala" +void app_load_project (App* self, const char* filename) { +#line 1523 "lombard.c" + GError * _inner_error_; +#line 497 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 497 "lombard.vala" + g_return_if_fail (filename != NULL); +#line 1529 "lombard.c" + _inner_error_ = NULL; +#line 498 "lombard.vala" + self->priv->loading = TRUE; +#line 1533 "lombard.c" + { + ViewVideoOutput* _tmp0_; + ViewVideoOutput* _tmp1_; +#line 501 "lombard.vala" + view_media_engine_disconnect_output (MODEL_PROJECT (self->priv->project)->media_engine, VIEW_MEDIA_CONNECTOR (self->priv->video_output)); +#line 502 "lombard.vala" + _tmp0_ = view_video_output_new (GTK_WIDGET (self->priv->drawing_area), &_inner_error_); +#line 1541 "lombard.c" + if (_inner_error_ != NULL) { + goto __catch6_g_error; + } +#line 502 "lombard.vala" + self->priv->video_output = (_tmp1_ = _tmp0_, _g_object_unref0 (self->priv->video_output), _tmp1_); +#line 503 "lombard.vala" + view_media_engine_connect_output (MODEL_PROJECT (self->priv->project)->media_engine, VIEW_MEDIA_CONNECTOR (self->priv->video_output)); +#line 1549 "lombard.c" + } + goto __finally6; + __catch6_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { +#line 505 "lombard.vala" + app_do_error_dialog ("Could not create video output", e->message); +#line 1560 "lombard.c" + _g_error_free0 (e); + } + } + __finally6: + if (_inner_error_ != NULL) { + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } +#line 508 "lombard.vala" + model_project_load (MODEL_PROJECT (self->priv->project), filename); +#line 1572 "lombard.c" +} + + +#line 514 "lombard.vala" +static void app_scroll_toward_center (App* self, gint xpos) { +#line 1578 "lombard.c" + gint cursor_pos; + gint page_size; + gint diff; + gint d; + gint x; + gint max_value; +#line 514 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 515 "lombard.vala" + cursor_pos = xpos - ((gint) gtk_adjustment_get_value (self->priv->h_adjustment)); +#line 520 "lombard.vala" + page_size = (gint) gtk_adjustment_get_page_size (self->priv->h_adjustment); +#line 521 "lombard.vala" + diff = (page_size / 2) - cursor_pos; +#line 522 "lombard.vala" + d = sign (diff) * ((gint) sqrt ((double) abs (diff))); +#line 523 "lombard.vala" + cursor_pos = cursor_pos + d; +#line 525 "lombard.vala" + x = MAX (0, xpos - cursor_pos); +#line 526 "lombard.vala" + max_value = (gint) (gtk_adjustment_get_upper (self->priv->h_adjustment) - GTK_WIDGET (self->priv->timeline_scrolled)->allocation.width); +#line 527 "lombard.vala" + if (x > max_value) { +#line 528 "lombard.vala" + x = max_value; +#line 1605 "lombard.c" + } +#line 530 "lombard.vala" + gtk_adjustment_set_value (self->priv->h_adjustment, (double) x); +#line 532 "lombard.vala" + gtk_adjustment_set_value (self->priv->h_adjustment, (double) x); +#line 1611 "lombard.c" +} + + +#line 535 "lombard.vala" +void app_on_split_at_playhead (App* self) { +#line 535 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 536 "lombard.vala" + model_project_split_at_playhead (MODEL_PROJECT (self->priv->project)); +#line 1621 "lombard.c" +} + + +#line 539 "lombard.vala" +void app_on_trim_to_playhead (App* self) { +#line 539 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 540 "lombard.vala" + model_project_trim_to_playhead (MODEL_PROJECT (self->priv->project)); +#line 1631 "lombard.c" +} + + +static Fraction* _fraction_dup (Fraction* self) { + Fraction* dup; + dup = g_new0 (Fraction, 1); + memcpy (dup, self, sizeof (Fraction)); + return dup; +} + + +static gpointer __fraction_dup0 (gpointer self) { + return self ? _fraction_dup (self) : NULL; +} + + +#line 543 "lombard.vala" +void app_on_clip_properties (App* self) { +#line 1650 "lombard.c" + Fraction* frames_per_second; + Fraction* _tmp1_; + Fraction _tmp0_ = {0}; +#line 543 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 544 "lombard.vala" + frames_per_second = NULL; +#line 545 "lombard.vala" + model_video_project_get_framerate_fraction (self->priv->project, &_tmp0_); +#line 545 "lombard.vala" + frames_per_second = (_tmp1_ = __fraction_dup0 (&_tmp0_), _g_free0 (frames_per_second), _tmp1_); +#line 546 "lombard.vala" + if (clip_library_view_has_selection (self->priv->library)) { +#line 1664 "lombard.c" + GeeArrayList* files; +#line 547 "lombard.vala" + files = clip_library_view_get_selected_files (self->priv->library); +#line 548 "lombard.vala" + if (gee_collection_get_size (GEE_COLLECTION (files)) == 1) { +#line 1670 "lombard.c" + char* file_name; + ModelClipFile* clip_file; +#line 549 "lombard.vala" + file_name = (char*) gee_abstract_list_get (GEE_ABSTRACT_LIST (files), 0); +#line 550 "lombard.vala" + clip_file = model_project_find_clipfile (MODEL_PROJECT (self->priv->project), file_name); +#line 551 "lombard.vala" + dialog_utils_show_clip_properties (GTK_WINDOW (self), NULL, clip_file, frames_per_second); +#line 1679 "lombard.c" + _g_free0 (file_name); + _g_object_unref0 (clip_file); + } + _g_object_unref0 (files); + } else { + GeeArrayList* clips; +#line 554 "lombard.vala" + clips = _g_object_ref0 (self->priv->timeline->selected_clips); +#line 555 "lombard.vala" + if (gee_collection_get_size (GEE_COLLECTION (clips)) == 1) { +#line 1690 "lombard.c" + ClipView* clip_view; +#line 556 "lombard.vala" + clip_view = (ClipView*) gee_abstract_list_get (GEE_ABSTRACT_LIST (clips), 0); +#line 557 "lombard.vala" + dialog_utils_show_clip_properties (GTK_WINDOW (self), clip_view, NULL, frames_per_second); +#line 1696 "lombard.c" + _g_object_unref0 (clip_view); + } + _g_object_unref0 (clips); + } + _g_free0 (frames_per_second); +} + + +#line 562 "lombard.vala" +void app_on_position_changed (App* self) { +#line 562 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 563 "lombard.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_position_changed"); +#line 564 "lombard.vala" + app_update_menu (self); +#line 1713 "lombard.c" +} + + +#line 567 "lombard.vala" +static void app_on_callback_pulse (App* self) { +#line 567 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 568 "lombard.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_callback_pulse"); +#line 569 "lombard.vala" + if (model_project_transport_is_playing (MODEL_PROJECT (self->priv->project))) { +#line 570 "lombard.vala" + app_scroll_toward_center (self, model_time_system_time_to_xpos (MODEL_TIME_SYSTEM (self->priv->project->time_provider), MODEL_PROJECT (self->priv->project)->media_engine->position)); +#line 1727 "lombard.c" + } +#line 572 "lombard.vala" + gtk_widget_queue_draw (GTK_WIDGET (self->priv->timeline)); +#line 1731 "lombard.c" +} + + +#line 575 "lombard.vala" +void app_on_track_changed (App* self) { +#line 575 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 576 "lombard.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_track_changed"); +#line 577 "lombard.vala" + app_update_menu (self); +#line 1743 "lombard.c" +} + + +#line 580 "lombard.vala" +static void app_update_menu (App* self) { +#line 1749 "lombard.c" + gboolean library_selected; + gboolean clip_selected; + gboolean stopped; + gboolean clip_is_trimmed; + gboolean playhead_on_clip; + gboolean dir = FALSE; + gboolean can_trim; + gboolean one_selected; + gboolean _tmp1_ = FALSE; + gboolean _tmp2_ = FALSE; + gboolean _tmp4_ = FALSE; + gboolean _tmp5_ = FALSE; + gboolean _tmp6_ = FALSE; + gboolean _tmp7_ = FALSE; + gboolean _tmp8_ = FALSE; +#line 580 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 581 "lombard.vala" + library_selected = clip_library_view_has_selection (self->priv->library); +#line 582 "lombard.vala" + clip_selected = time_line_is_clip_selected (self->priv->timeline); +#line 583 "lombard.vala" + stopped = transport_delegate_is_stopped (TRANSPORT_DELEGATE (self)); +#line 584 "lombard.vala" + clip_is_trimmed = FALSE; +#line 585 "lombard.vala" + playhead_on_clip = model_project_playhead_on_clip (MODEL_PROJECT (self->priv->project)); +#line 587 "lombard.vala" + can_trim = model_project_can_trim (MODEL_PROJECT (self->priv->project), &dir); +#line 588 "lombard.vala" + one_selected = FALSE; +#line 589 "lombard.vala" + if (library_selected) { +#line 1783 "lombard.c" + GeeArrayList* _tmp0_; +#line 590 "lombard.vala" + one_selected = gee_collection_get_size (GEE_COLLECTION (_tmp0_ = clip_library_view_get_selected_files (self->priv->library))) == 1; +#line 1787 "lombard.c" + _g_object_unref0 (_tmp0_); + } else { +#line 591 "lombard.vala" + if (clip_selected) { +#line 592 "lombard.vala" + one_selected = gee_collection_get_size (GEE_COLLECTION (self->priv->timeline->selected_clips)) == 1; +#line 1794 "lombard.c" + } + } +#line 595 "lombard.vala" + if (clip_selected) { +#line 1799 "lombard.c" + { + GeeIterator* _clip_view_it; + _clip_view_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->priv->timeline->selected_clips)); +#line 596 "lombard.vala" + while (TRUE) { +#line 1805 "lombard.c" + ClipView* clip_view; +#line 596 "lombard.vala" + if (!gee_iterator_next (_clip_view_it)) { +#line 596 "lombard.vala" + break; +#line 1811 "lombard.c" + } +#line 596 "lombard.vala" + clip_view = (ClipView*) gee_iterator_get (_clip_view_it); +#line 597 "lombard.vala" + clip_is_trimmed = model_clip_is_trimmed (clip_view->clip); +#line 598 "lombard.vala" + if (clip_is_trimmed) { +#line 1819 "lombard.c" + _g_object_unref0 (clip_view); +#line 599 "lombard.vala" + break; +#line 1823 "lombard.c" + } + _g_object_unref0 (clip_view); + } + _g_object_unref0 (_clip_view_it); + } + } +#line 604 "lombard.vala" + app_set_sensitive_group (self, self->priv->main_group, "Open", stopped); +#line 605 "lombard.vala" + app_set_sensitive_group (self, self->priv->main_group, "Save", stopped); +#line 606 "lombard.vala" + app_set_sensitive_group (self, self->priv->main_group, "SaveAs", stopped); +#line 607 "lombard.vala" + app_set_sensitive_group (self, self->priv->main_group, "Export", model_project_can_export (MODEL_PROJECT (self->priv->project))); +#line 610 "lombard.vala" + if (stopped) { +#line 610 "lombard.vala" + _tmp1_ = model_undo_manager_get_can_undo (MODEL_PROJECT (self->priv->project)->undo_manager); +#line 1842 "lombard.c" + } else { +#line 610 "lombard.vala" + _tmp1_ = FALSE; +#line 1846 "lombard.c" + } +#line 610 "lombard.vala" + app_set_sensitive_group (self, self->priv->main_group, "Undo", _tmp1_); +#line 611 "lombard.vala" + if (stopped) { +#line 1852 "lombard.c" + gboolean _tmp3_ = FALSE; +#line 611 "lombard.vala" + if (clip_selected) { +#line 611 "lombard.vala" + _tmp3_ = TRUE; +#line 1858 "lombard.c" + } else { +#line 611 "lombard.vala" + _tmp3_ = library_selected; +#line 1862 "lombard.c" + } +#line 611 "lombard.vala" + _tmp2_ = _tmp3_; +#line 1866 "lombard.c" + } else { +#line 611 "lombard.vala" + _tmp2_ = FALSE; +#line 1870 "lombard.c" + } +#line 611 "lombard.vala" + app_set_sensitive_group (self, self->priv->main_group, "Delete", _tmp2_); +#line 612 "lombard.vala" + if (stopped) { +#line 612 "lombard.vala" + _tmp4_ = clip_selected; +#line 1878 "lombard.c" + } else { +#line 612 "lombard.vala" + _tmp4_ = FALSE; +#line 1882 "lombard.c" + } +#line 612 "lombard.vala" + app_set_sensitive_group (self, self->priv->main_group, "Cut", _tmp4_); +#line 613 "lombard.vala" + if (stopped) { +#line 613 "lombard.vala" + _tmp5_ = clip_selected; +#line 1890 "lombard.c" + } else { +#line 613 "lombard.vala" + _tmp5_ = FALSE; +#line 1894 "lombard.c" + } +#line 613 "lombard.vala" + app_set_sensitive_group (self, self->priv->main_group, "Copy", _tmp5_); +#line 614 "lombard.vala" + if (stopped) { +#line 614 "lombard.vala" + _tmp6_ = gee_collection_get_size (GEE_COLLECTION (self->priv->timeline->clipboard->clips)) > 0; +#line 1902 "lombard.c" + } else { +#line 614 "lombard.vala" + _tmp6_ = FALSE; +#line 1906 "lombard.c" + } +#line 614 "lombard.vala" + app_set_sensitive_group (self, self->priv->main_group, "Paste", _tmp6_); +#line 615 "lombard.vala" + app_set_sensitive_group (self, self->priv->main_group, "ClipProperties", one_selected); +#line 617 "lombard.vala" + if (stopped) { +#line 617 "lombard.vala" + _tmp7_ = playhead_on_clip; +#line 1916 "lombard.c" + } else { +#line 617 "lombard.vala" + _tmp7_ = FALSE; +#line 1920 "lombard.c" + } +#line 617 "lombard.vala" + app_set_sensitive_group (self, self->priv->main_group, "SplitAtPlayhead", _tmp7_); +#line 618 "lombard.vala" + if (stopped) { +#line 618 "lombard.vala" + _tmp8_ = can_trim; +#line 1928 "lombard.c" + } else { +#line 618 "lombard.vala" + _tmp8_ = FALSE; +#line 1932 "lombard.c" + } +#line 618 "lombard.vala" + app_set_sensitive_group (self, self->priv->main_group, "TrimToPlayhead", _tmp8_); +#line 621 "lombard.vala" + app_set_sensitive_group (self, self->priv->main_group, "ZoomProject", model_project_get_length (MODEL_PROJECT (self->priv->project)) != 0); +#line 1938 "lombard.c" +} + + +#line 625 "lombard.vala" +void app_on_timeline_selection_changed (App* self, gboolean selected) { +#line 625 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 626 "lombard.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_timeline_selection_changed"); +#line 627 "lombard.vala" + if (selected) { +#line 628 "lombard.vala" + clip_library_view_unselect_all (self->priv->library); +#line 1952 "lombard.c" + } +#line 629 "lombard.vala" + app_update_menu (self); +#line 1956 "lombard.c" +} + + +#line 632 "lombard.vala" +void app_on_library_selection_changed (App* self, gboolean selected) { +#line 632 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 633 "lombard.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_library_selection_changed"); +#line 634 "lombard.vala" + if (selected) { +#line 635 "lombard.vala" + time_line_deselect_all_clips (self->priv->timeline); +#line 636 "lombard.vala" + gtk_widget_queue_draw (GTK_WIDGET (self->priv->timeline)); +#line 1972 "lombard.c" + } +#line 638 "lombard.vala" + app_update_menu (self); +#line 1976 "lombard.c" +} + + +#line 643 "lombard.vala" +static gboolean app_real_key_press_event (GtkWidget* base, GdkEventKey* event) { +#line 1982 "lombard.c" + App * self; + gboolean result = FALSE; + self = APP (base); +#line 644 "lombard.vala" + switch ((*event).keyval) { +#line 1988 "lombard.c" + case GDK_KP_Enter: + case GDK_Return: + { +#line 647 "lombard.vala" + if (((*event).state & GDK_SHIFT_ALT_CONTROL_MASK) != 0) { +#line 1994 "lombard.c" + result = GTK_WIDGET_CLASS (app_parent_class)->key_press_event (GTK_WIDGET (GTK_WINDOW (self)), event); +#line 648 "lombard.vala" + return result; +#line 1998 "lombard.c" + } +#line 649 "lombard.vala" + app_on_go_start (self); +#line 650 "lombard.vala" + break; +#line 2004 "lombard.c" + } + case GDK_Left: + { +#line 652 "lombard.vala" + if (((*event).state & GDK_CONTROL_MASK) != 0) { +#line 653 "lombard.vala" + model_project_go_previous (MODEL_PROJECT (self->priv->project)); +#line 2012 "lombard.c" + } else { +#line 655 "lombard.vala" + model_video_project_go_previous_frame (self->priv->project); +#line 2016 "lombard.c" + } +#line 657 "lombard.vala" + break; +#line 2020 "lombard.c" + } + case GDK_Right: + { +#line 659 "lombard.vala" + if (((*event).state & GDK_CONTROL_MASK) != 0) { +#line 660 "lombard.vala" + model_project_go_next (MODEL_PROJECT (self->priv->project)); +#line 2028 "lombard.c" + } else { +#line 662 "lombard.vala" + model_video_project_go_next_frame (self->priv->project); +#line 2032 "lombard.c" + } +#line 664 "lombard.vala" + break; +#line 2036 "lombard.c" + } + case GDK_KP_Add: + case GDK_equal: + case GDK_plus: + { +#line 668 "lombard.vala" + app_on_zoom_in (self); +#line 669 "lombard.vala" + break; +#line 2046 "lombard.c" + } + case GDK_KP_Subtract: + case GDK_minus: + case GDK_underscore: + { +#line 673 "lombard.vala" + app_on_zoom_out (self); +#line 674 "lombard.vala" + break; +#line 2056 "lombard.c" + } + default: + { + result = GTK_WIDGET_CLASS (app_parent_class)->key_press_event (GTK_WIDGET (GTK_WINDOW (self)), event); +#line 676 "lombard.vala" + return result; +#line 2063 "lombard.c" + } + } + result = TRUE; +#line 678 "lombard.vala" + return result; +#line 2069 "lombard.c" +} + + +#line 681 "lombard.vala" +static void app_on_snap (App* self) { +#line 681 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 682 "lombard.vala" + MODEL_PROJECT (self->priv->project)->snap_to_clip = !MODEL_PROJECT (self->priv->project)->snap_to_clip; +#line 2079 "lombard.c" +} + + +#line 685 "lombard.vala" +static void app_on_view_library (App* self) { +#line 2085 "lombard.c" + GtkAction* _tmp0_; + GtkToggleAction* action; +#line 685 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 686 "lombard.vala" + action = _g_object_ref0 ((_tmp0_ = gtk_action_group_get_action (self->priv->main_group, APP_LibraryToggle), GTK_IS_TOGGLE_ACTION (_tmp0_) ? ((GtkToggleAction*) _tmp0_) : NULL)); +#line 687 "lombard.vala" + app_toggle_library (self, gtk_toggle_action_get_active (action)); +#line 2094 "lombard.c" + _g_object_unref0 (action); +} + + +#line 690 "lombard.vala" +static gint64 app_get_zoom_center_time (App* self) { +#line 2101 "lombard.c" + gint64 result = 0LL; +#line 690 "lombard.vala" + g_return_val_if_fail (IS_APP (self), 0LL); +#line 2105 "lombard.c" + result = model_project_transport_get_position (MODEL_PROJECT (self->priv->project)); +#line 691 "lombard.vala" + return result; +#line 2109 "lombard.c" +} + + +#line 694 "lombard.vala" +static void app_do_zoom (App* self, float increment) { +#line 694 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 695 "lombard.vala" + self->priv->center_time = app_get_zoom_center_time (self); +#line 696 "lombard.vala" + time_line_zoom (self->priv->timeline, increment); +#line 2121 "lombard.c" +} + + +#line 699 "lombard.vala" +static void app_on_zoom_in (App* self) { +#line 699 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 700 "lombard.vala" + app_do_zoom (self, 0.1f); +#line 2131 "lombard.c" +} + + +#line 703 "lombard.vala" +static void app_on_zoom_out (App* self) { +#line 703 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 704 "lombard.vala" + app_do_zoom (self, -0.1f); +#line 2141 "lombard.c" +} + + +#line 707 "lombard.vala" +static void app_on_zoom_to_project (App* self) { +#line 707 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 708 "lombard.vala" + time_line_zoom_to_project (self->priv->timeline, gtk_adjustment_get_page_size (self->priv->h_adjustment)); +#line 2151 "lombard.c" +} + + +#line 711 "lombard.vala" +static void app_on_timeline_size_allocate (App* self, GdkRectangle* rectangle) { +#line 711 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 712 "lombard.vala" + if (self->priv->center_time != (-1)) { +#line 2161 "lombard.c" + gint new_center_pixel; + gint page_size; +#line 713 "lombard.vala" + new_center_pixel = model_time_system_time_to_xpos (MODEL_TIME_SYSTEM (self->priv->project->time_provider), self->priv->center_time); +#line 714 "lombard.vala" + page_size = (gint) (gtk_adjustment_get_page_size (self->priv->h_adjustment) / 2); +#line 715 "lombard.vala" + gtk_adjustment_clamp_page (self->priv->h_adjustment, (double) (new_center_pixel - page_size), (double) (new_center_pixel + page_size)); +#line 716 "lombard.vala" + self->priv->center_time = (gint64) (-1); +#line 2172 "lombard.c" + } +} + + +#line 720 "lombard.vala" +static void app_set_sensitive_group (App* self, GtkActionGroup* group, const char* group_path, gboolean sensitive) { +#line 2179 "lombard.c" + GtkAction* action; +#line 720 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 720 "lombard.vala" + g_return_if_fail (GTK_IS_ACTION_GROUP (group)); +#line 720 "lombard.vala" + g_return_if_fail (group_path != NULL); +#line 721 "lombard.vala" + action = _g_object_ref0 (gtk_action_group_get_action (group, group_path)); +#line 722 "lombard.vala" + gtk_action_set_sensitive (action, sensitive); +#line 2191 "lombard.c" + _g_object_unref0 (action); +} + + +#line 727 "lombard.vala" +static void app_on_play_pause (App* self) { +#line 727 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 728 "lombard.vala" + if (model_project_transport_is_playing (MODEL_PROJECT (self->priv->project))) { +#line 729 "lombard.vala" + view_media_engine_pause (MODEL_PROJECT (self->priv->project)->media_engine); +#line 2204 "lombard.c" + } else { +#line 735 "lombard.vala" + view_media_engine_do_play (MODEL_PROJECT (self->priv->project)->media_engine, PLAY_STATE_PLAYING); +#line 2208 "lombard.c" + } +} + + +#line 739 "lombard.vala" +static void app_on_export (App* self) { +#line 2215 "lombard.c" + GError * _inner_error_; + char* filename; +#line 739 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 2220 "lombard.c" + _inner_error_ = NULL; +#line 740 "lombard.vala" + filename = NULL; +#line 741 "lombard.vala" + if (dialog_utils_save (GTK_WINDOW (self), "Export", FALSE, APP_export_filters, G_N_ELEMENTS (APP_export_filters), &filename)) { +#line 2226 "lombard.c" + MultiFileProgress* _tmp0_; +#line 742 "lombard.vala" + _tmp0_ = g_object_ref_sink (multi_file_progress_new (GTK_WINDOW (self), 1, "Export", MULTI_FILE_PROGRESS_INTERFACE (MODEL_PROJECT (self->priv->project)->media_engine))); +#line 2230 "lombard.c" + _g_object_unref0 (_tmp0_); +#line 743 "lombard.vala" + view_media_engine_disconnect_output (MODEL_PROJECT (self->priv->project)->media_engine, VIEW_MEDIA_CONNECTOR (self->priv->audio_output)); +#line 744 "lombard.vala" + view_media_engine_disconnect_output (MODEL_PROJECT (self->priv->project)->media_engine, VIEW_MEDIA_CONNECTOR (self->priv->video_output)); +#line 2236 "lombard.c" + { + GstCaps* _tmp1_; + ViewOggVorbisExport* _tmp2_; + ViewOggVorbisExport* _tmp3_; + ViewOggVorbisExport* _tmp4_; +#line 746 "lombard.vala" + _tmp3_ = (_tmp2_ = view_ogg_vorbis_export_new (VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Audio | VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Video, filename, _tmp1_ = view_media_engine_get_project_audio_export_caps (MODEL_PROJECT (self->priv->project)->media_engine), &_inner_error_), _gst_caps_unref0 (_tmp1_), _tmp2_); +#line 2244 "lombard.c" + if (_inner_error_ != NULL) { + goto __catch7_g_error; + } +#line 746 "lombard.vala" + self->priv->export_connector = (_tmp4_ = _tmp3_, _g_object_unref0 (self->priv->export_connector), _tmp4_); +#line 749 "lombard.vala" + view_media_engine_connect_output (MODEL_PROJECT (self->priv->project)->media_engine, VIEW_MEDIA_CONNECTOR (self->priv->export_connector)); +#line 750 "lombard.vala" + view_media_engine_start_export (MODEL_PROJECT (self->priv->project)->media_engine, filename); +#line 2254 "lombard.c" + } + goto __finally7; + __catch7_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { +#line 752 "lombard.vala" + app_do_error_dialog ("Could not export file", e->message); +#line 2265 "lombard.c" + _g_error_free0 (e); + } + } + __finally7: + if (_inner_error_ != NULL) { + _g_free0 (filename); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } + } + _g_free0 (filename); +} + + +#line 757 "lombard.vala" +static void app_on_post_export (App* self, gboolean canceled) { +#line 2283 "lombard.c" + ViewOggVorbisExport* _tmp1_; +#line 757 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 758 "lombard.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_post_export"); +#line 759 "lombard.vala" + view_media_engine_disconnect_output (MODEL_PROJECT (self->priv->project)->media_engine, VIEW_MEDIA_CONNECTOR (self->priv->export_connector)); +#line 760 "lombard.vala" + view_media_engine_connect_output (MODEL_PROJECT (self->priv->project)->media_engine, VIEW_MEDIA_CONNECTOR (self->priv->audio_output)); +#line 761 "lombard.vala" + view_media_engine_connect_output (MODEL_PROJECT (self->priv->project)->media_engine, VIEW_MEDIA_CONNECTOR (self->priv->video_output)); +#line 762 "lombard.vala" + if (canceled) { +#line 2297 "lombard.c" + char* _tmp0_; +#line 763 "lombard.vala" + g_remove (_tmp0_ = view_ogg_vorbis_export_get_filename (self->priv->export_connector)); +#line 2301 "lombard.c" + _g_free0 (_tmp0_); + } +#line 765 "lombard.vala" + self->priv->export_connector = (_tmp1_ = NULL, _g_object_unref0 (self->priv->export_connector), _tmp1_); +#line 2306 "lombard.c" +} + + +#line 770 "lombard.vala" +static void app_on_undo (App* self) { +#line 770 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 771 "lombard.vala" + model_project_undo (MODEL_PROJECT (self->priv->project)); +#line 2316 "lombard.c" +} + + +#line 774 "lombard.vala" +static void app_on_delete (App* self) { +#line 774 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 775 "lombard.vala" + if (clip_library_view_has_selection (self->priv->library)) { +#line 776 "lombard.vala" + clip_library_view_delete_selection (self->priv->library); +#line 2328 "lombard.c" + } else { +#line 778 "lombard.vala" + time_line_delete_selection (self->priv->timeline); +#line 2332 "lombard.c" + } +} + + +#line 781 "lombard.vala" +static void app_on_cut (App* self) { +#line 781 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 782 "lombard.vala" + time_line_do_cut (self->priv->timeline); +#line 2343 "lombard.c" +} + + +#line 785 "lombard.vala" +static void app_on_copy (App* self) { +#line 785 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 786 "lombard.vala" + time_line_do_copy (self->priv->timeline); +#line 2353 "lombard.c" +} + + +#line 789 "lombard.vala" +static void app_on_paste (App* self) { +#line 789 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 790 "lombard.vala" + time_line_paste (self->priv->timeline); +#line 2363 "lombard.c" +} + + +#line 793 "lombard.vala" +static void app_on_playstate_changed (App* self, PlayState playstate) { +#line 793 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 794 "lombard.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_playstate_changed"); +#line 795 "lombard.vala" + if (playstate == PLAY_STATE_STOPPED) { +#line 796 "lombard.vala" + app_update_menu (self); +#line 2377 "lombard.c" + } +} + + +#line 800 "lombard.vala" +static void app_on_undo_changed (App* self, gboolean can_undo) { +#line 2384 "lombard.c" + GtkMenuItem* undo; + gboolean _tmp0_ = FALSE; +#line 800 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 801 "lombard.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_undo_changed"); +#line 802 "lombard.vala" + undo = GTK_MENU_ITEM (get_widget (self->priv->manager, "/MenuBar/EditMenu/EditUndo")); +#line 803 "lombard.vala" + g_assert (undo != NULL); +#line 805 "lombard.vala" + if (transport_delegate_is_stopped (TRANSPORT_DELEGATE (self))) { +#line 805 "lombard.vala" + _tmp0_ = model_undo_manager_get_can_undo (MODEL_PROJECT (self->priv->project)->undo_manager); +#line 2399 "lombard.c" + } else { +#line 805 "lombard.vala" + _tmp0_ = FALSE; +#line 2403 "lombard.c" + } +#line 805 "lombard.vala" + app_set_sensitive_group (self, self->priv->main_group, "Undo", _tmp0_); +#line 2407 "lombard.c" + _g_object_unref0 (undo); +} + + +#line 808 "lombard.vala" +static void app_on_select_all (App* self) { +#line 808 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 809 "lombard.vala" + if (clip_library_view_has_selection (self->priv->library)) { +#line 810 "lombard.vala" + clip_library_view_select_all (self->priv->library); +#line 2420 "lombard.c" + } else { +#line 812 "lombard.vala" + time_line_select_all (self->priv->timeline); +#line 2424 "lombard.c" + } +} + + +#line 818 "lombard.vala" +static void app_on_go_start (App* self) { +#line 818 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 818 "lombard.vala" + model_project_go_start (MODEL_PROJECT (self->priv->project)); +#line 2435 "lombard.c" +} + + +#line 820 "lombard.vala" +static void app_on_go_end (App* self) { +#line 820 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 820 "lombard.vala" + model_project_go_end (MODEL_PROJECT (self->priv->project)); +#line 2445 "lombard.c" +} + + +#line 824 "lombard.vala" +static void app_on_help_contents (App* self) { +#line 2451 "lombard.c" + GError * _inner_error_; +#line 824 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 2455 "lombard.c" + _inner_error_ = NULL; + { +#line 826 "lombard.vala" + gtk_show_uri (NULL, "http://trac.yorba.org/wiki/UsingLombard0.1", (guint32) 0, &_inner_error_); +#line 2460 "lombard.c" + if (_inner_error_ != NULL) { + goto __catch8_g_error; + } + } + goto __finally8; + __catch8_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { + _g_error_free0 (e); + } + } + __finally8: + if (_inner_error_ != NULL) { + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } +} + + +#line 831 "lombard.vala" +static void app_on_about (App* self) { +#line 2486 "lombard.c" + char* _tmp1_; + char* _tmp0_; +#line 831 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 832 "lombard.vala" + gtk_show_about_dialog (GTK_WINDOW (self), "version", _tmp0_ = model_project_get_version (MODEL_PROJECT (self->priv->project)), "comments", "A video editor", "copyright", "Copyright 2009-2010 Yorba Foundation", "website", "http://www.yorba.org", "license", _tmp1_ = model_project_get_license (MODEL_PROJECT (self->priv->project)), "website-label", "Visit the Yorba web site", "authors", MODEL_PROJECT_authors, NULL); +#line 2493 "lombard.c" + _g_free0 (_tmp1_); + _g_free0 (_tmp0_); +} + + +#line 843 "lombard.vala" +static void app_on_save_graph (App* self) { +#line 843 "lombard.vala" + g_return_if_fail (IS_APP (self)); +#line 844 "lombard.vala" + model_project_print_graph (MODEL_PROJECT (self->priv->project), GST_BIN (MODEL_PROJECT (self->priv->project)->media_engine->pipeline), "save_graph"); +#line 2505 "lombard.c" +} + + +#line 848 "lombard.vala" +static gboolean app_real_is_recording (TransportDelegate* base) { +#line 2511 "lombard.c" + App * self; + gboolean result = FALSE; + self = APP (base); + result = model_project_transport_is_recording (MODEL_PROJECT (self->priv->project)); +#line 849 "lombard.vala" + return result; +#line 2518 "lombard.c" +} + + +#line 852 "lombard.vala" +static gboolean app_real_is_playing (TransportDelegate* base) { +#line 2524 "lombard.c" + App * self; + gboolean result = FALSE; + self = APP (base); + result = model_project_transport_is_playing (MODEL_PROJECT (self->priv->project)); +#line 853 "lombard.vala" + return result; +#line 2531 "lombard.c" +} + + +#line 856 "lombard.vala" +static gboolean app_real_is_stopped (TransportDelegate* base) { +#line 2537 "lombard.c" + App * self; + gboolean result = FALSE; + gboolean _tmp0_ = FALSE; + self = APP (base); +#line 857 "lombard.vala" + if (transport_delegate_is_playing (TRANSPORT_DELEGATE (self))) { +#line 857 "lombard.vala" + _tmp0_ = TRUE; +#line 2546 "lombard.c" + } else { +#line 857 "lombard.vala" + _tmp0_ = transport_delegate_is_recording (TRANSPORT_DELEGATE (self)); +#line 2550 "lombard.c" + } + result = !_tmp0_; +#line 857 "lombard.vala" + return result; +#line 2555 "lombard.c" +} + + +static void app_class_init (AppClass * klass) { + app_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (AppPrivate)); + GTK_WIDGET_CLASS (klass)->key_press_event = app_real_key_press_event; + G_OBJECT_CLASS (klass)->finalize = app_finalize; +} + + +static void app_transport_delegate_interface_init (TransportDelegateIface * iface) { + app_transport_delegate_parent_iface = g_type_interface_peek_parent (iface); + iface->is_recording = app_real_is_recording; + iface->is_playing = app_real_is_playing; + iface->is_stopped = app_real_is_stopped; +} + + +static void app_instance_init (App * self) { + self->priv = APP_GET_PRIVATE (self); + self->priv->center_time = (gint64) (-1); + self->priv->vbox = NULL; +} + + +static void app_finalize (GObject* obj) { + App * self; + self = APP (obj); + _g_object_unref0 (self->priv->drawing_area); + _g_object_unref0 (self->priv->project); + _g_object_unref0 (self->priv->video_output); + _g_object_unref0 (self->priv->audio_output); + _g_object_unref0 (self->priv->export_connector); + _g_object_unref0 (self->priv->timeline); + _g_object_unref0 (self->priv->library); + _g_object_unref0 (self->priv->status_bar); + _g_object_unref0 (self->priv->h_pane); + _g_object_unref0 (self->priv->library_scrolled); + _g_object_unref0 (self->priv->timeline_scrolled); + _g_object_unref0 (self->priv->h_adjustment); + _g_object_unref0 (self->priv->main_group); + _g_object_unref0 (self->priv->vbox); + _g_object_unref0 (self->priv->menubar); + _g_object_unref0 (self->priv->manager); + _g_free0 (self->priv->project_filename); + _g_object_unref0 (self->priv->load_errors); + G_OBJECT_CLASS (app_parent_class)->finalize (obj); +} + + +GType app_get_type (void) { + static volatile gsize app_type_id__volatile = 0; + if (g_once_init_enter (&app_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (AppClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) app_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (App), 0, (GInstanceInitFunc) app_instance_init, NULL }; + static const GInterfaceInfo transport_delegate_info = { (GInterfaceInitFunc) app_transport_delegate_interface_init, (GInterfaceFinalizeFunc) NULL, NULL}; + GType app_type_id; + app_type_id = g_type_register_static (GTK_TYPE_WINDOW, "App", &g_define_type_info, 0); + g_type_add_interface_static (app_type_id, TYPE_TRANSPORT_DELEGATE, &transport_delegate_info); + g_once_init_leave (&app_type_id__volatile, app_type_id); + } + return app_type_id__volatile; +} + + +#line 863 "lombard.vala" +void _vala_main (char** args, int args_length1) { +#line 2623 "lombard.c" + GError * _inner_error_; + GOptionContext* context; + _inner_error_ = NULL; +#line 864 "lombard.vala" + debug_level = -1; +#line 865 "lombard.vala" + context = g_option_context_new (" [project file] - Create and edit movies"); +#line 867 "lombard.vala" + g_option_context_add_main_entries (context, options, NULL); +#line 868 "lombard.vala" + g_option_context_add_group (context, gst_init_get_option_group ()); +#line 2635 "lombard.c" + { +#line 871 "lombard.vala" + g_option_context_parse (context, &args_length1, &args, &_inner_error_); +#line 2639 "lombard.c" + if (_inner_error_ != NULL) { + goto __catch9_g_error; + } + } + goto __finally9; + __catch9_g_error: + { + GError * arg_error; + arg_error = _inner_error_; + _inner_error_ = NULL; + { +#line 873 "lombard.vala" + fprintf (stderr, "%s\n" \ +"Run 'lombard --help' for a full list of available command line options" \ +".", arg_error->message); +#line 2653 "lombard.c" + _g_error_free0 (arg_error); + _g_option_context_free0 (context); +#line 875 "lombard.vala" + return; +#line 2658 "lombard.c" + } + } + __finally9: + if (_inner_error_ != NULL) { + _g_option_context_free0 (context); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } +#line 877 "lombard.vala" + gtk_init (&args_length1, &args); +#line 2670 "lombard.c" + { + char* project_file; + char* str; + gboolean _tmp3_ = FALSE; + ClassFactory* _tmp4_; + App* _tmp5_; +#line 880 "lombard.vala" + g_set_application_name ("Lombard"); +#line 882 "lombard.vala" + app_dirs_init (args[0], _PROGRAM_NAME); +#line 883 "lombard.vala" + gst_init (&args_length1, &args); +#line 885 "lombard.vala" + if (args_length1 > 2) { +#line 886 "lombard.vala" + fprintf (stderr, "usage: %s [project-file]\n", args[0]); +#line 2687 "lombard.c" + _g_option_context_free0 (context); +#line 887 "lombard.vala" + return; +#line 2691 "lombard.c" + } +#line 890 "lombard.vala" + project_file = NULL; +#line 891 "lombard.vala" + if (args_length1 > 1) { +#line 2697 "lombard.c" + char* _tmp0_; +#line 892 "lombard.vala" + project_file = (_tmp0_ = g_strdup (args[1]), _g_free0 (project_file), _tmp0_); +#line 2701 "lombard.c" + { + char* _tmp1_; + char* _tmp2_; +#line 894 "lombard.vala" + _tmp1_ = g_filename_from_uri (project_file, NULL, &_inner_error_); +#line 2707 "lombard.c" + if (_inner_error_ != NULL) { + goto __catch11_g_error; + } +#line 894 "lombard.vala" + project_file = (_tmp2_ = _tmp1_, _g_free0 (project_file), _tmp2_); +#line 2713 "lombard.c" + } + goto __finally11; + __catch11_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { + _g_error_free0 (e); + } + } + __finally11: + if (_inner_error_ != NULL) { + _g_free0 (project_file); + goto __catch10_g_error; + } + } +#line 898 "lombard.vala" + str = g_strdup (g_getenv ("LOMBARD_DEBUG")); +#line 899 "lombard.vala" + if (str != NULL) { +#line 899 "lombard.vala" + _tmp3_ = g_utf8_get_char (g_utf8_offset_to_pointer (str, 0)) >= '1'; +#line 2737 "lombard.c" + } else { +#line 899 "lombard.vala" + _tmp3_ = FALSE; +#line 2741 "lombard.c" + } +#line 899 "lombard.vala" + debug_enabled = _tmp3_; +#line 900 "lombard.vala" + class_factory_set_class_factory (_tmp4_ = class_factory_new ()); +#line 2747 "lombard.c" + _class_factory_unref0 (_tmp4_); +#line 901 "lombard.vala" + view_media_engine_can_run (&_inner_error_); +#line 2751 "lombard.c" + if (_inner_error_ != NULL) { + _g_free0 (project_file); + _g_free0 (str); + goto __catch10_g_error; + } +#line 903 "lombard.vala" + _tmp5_ = g_object_ref_sink (app_new (project_file, &_inner_error_)); +#line 2759 "lombard.c" + _g_object_unref0 (_tmp5_); + if (_inner_error_ != NULL) { + _g_free0 (project_file); + _g_free0 (str); + goto __catch10_g_error; + } +#line 904 "lombard.vala" + gtk_main (); +#line 2768 "lombard.c" + _g_free0 (project_file); + _g_free0 (str); + } + goto __finally10; + __catch10_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { + char* _tmp6_; +#line 906 "lombard.vala" + app_do_error_dialog ("Could not launch application", _tmp6_ = g_strdup_printf ("%s.", e->message)); +#line 2782 "lombard.c" + _g_free0 (_tmp6_); + _g_error_free0 (e); + } + } + __finally10: + if (_inner_error_ != NULL) { + _g_option_context_free0 (context); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } + _g_option_context_free0 (context); +} + + +#line 863 "lombard.vala" +int main (int argc, char ** argv) { +#line 2800 "lombard.c" + g_thread_init (NULL); +#line 863 "lombard.vala" + g_type_init (); +#line 863 "lombard.vala" + _vala_main (argv, argc); +#line 863 "lombard.vala" + return 0; +#line 2808 "lombard.c" +} + + +static int _vala_strcmp0 (const char * str1, const char * str2) { + if (str1 == NULL) { + return -(str1 != str2); + } + if (str2 == NULL) { + return str1 != str2; + } + return strcmp (str1, str2); +} + + + + diff --git a/src/lombard/lombard/lombard.o b/src/lombard/lombard/lombard.o new file mode 100644 index 0000000..61205d4 Binary files /dev/null and b/src/lombard/lombard/lombard.o differ diff --git a/src/lombard/lombard/video_project.c b/src/lombard/lombard/video_project.c new file mode 100644 index 0000000..dae05f8 --- /dev/null +++ b/src/lombard/lombard/video_project.c @@ -0,0 +1,292 @@ +/* video_project.c generated by valac, the Vala compiler + * generated from video_project.vala, do not modify */ + +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include + + +#define MODEL_TYPE_VIDEO_PROJECT (model_video_project_get_type ()) +#define MODEL_VIDEO_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_VIDEO_PROJECT, ModelVideoProject)) +#define MODEL_VIDEO_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_VIDEO_PROJECT, ModelVideoProjectClass)) +#define MODEL_IS_VIDEO_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_VIDEO_PROJECT)) +#define MODEL_IS_VIDEO_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_VIDEO_PROJECT)) +#define MODEL_VIDEO_PROJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_VIDEO_PROJECT, ModelVideoProjectClass)) + +typedef struct _ModelVideoProject ModelVideoProject; +typedef struct _ModelVideoProjectClass ModelVideoProjectClass; +typedef struct _ModelVideoProjectPrivate ModelVideoProjectPrivate; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) + +struct _ModelVideoProject { + ModelProject parent_instance; + ModelVideoProjectPrivate * priv; + ModelTimecodeTimeSystem* time_provider; +}; + +struct _ModelVideoProjectClass { + ModelProjectClass parent_class; +}; + + +static gpointer model_video_project_parent_class = NULL; + +GType model_video_project_get_type (void); +enum { + MODEL_VIDEO_PROJECT_DUMMY_PROPERTY +}; +static void model_video_project_real_load_complete (ModelProject* base); +ModelVideoProject* model_video_project_new (const char* filename, GError** error); +ModelVideoProject* model_video_project_construct (GType object_type, const char* filename, GError** error); +#define APP_NAME "Lombard" +static char* model_video_project_real_get_app_name (ModelProject* base); +gboolean model_video_project_get_framerate_fraction (ModelVideoProject* self, Fraction* rate); +static void model_video_project_real_get_clip_time (ModelProject* base, ModelClipFile* f, TimeCode* result); +void model_video_project_go_previous_frame (ModelVideoProject* self); +void model_video_project_go_next_frame (ModelVideoProject* self); +static void model_video_project_finalize (GObject* obj); + + + +#line 14 "video_project.vala" +static void model_video_project_real_load_complete (ModelProject* base) { +#line 63 "video_project.c" + ModelVideoProject * self; + ModelVideoTrack* _tmp0_; + gboolean _tmp1_; + self = MODEL_VIDEO_PROJECT (base); +#line 15 "video_project.vala" + if ((_tmp1_ = (_tmp0_ = model_project_find_video_track (MODEL_PROJECT (self))) == NULL, _g_object_unref0 (_tmp0_), _tmp1_)) { +#line 70 "video_project.c" + ModelVideoTrack* _tmp2_; +#line 16 "video_project.vala" + model_project_add_track (MODEL_PROJECT (self), MODEL_TRACK (_tmp2_ = model_video_track_new (MODEL_PROJECT (self)))); +#line 74 "video_project.c" + _g_object_unref0 (_tmp2_); + } +} + + +#line 20 "video_project.vala" +ModelVideoProject* model_video_project_construct (GType object_type, const char* filename, GError** error) { +#line 82 "video_project.c" + ModelVideoProject * self; +#line 21 "video_project.vala" + self = (ModelVideoProject*) model_project_construct (object_type, filename, TRUE, error); +#line 23 "video_project.vala" + if (self != NULL) { +#line 88 "video_project.c" + ModelTimecodeTimeSystem* _tmp0_; +#line 24 "video_project.vala" + self->time_provider = (_tmp0_ = model_timecode_time_system_new (), _g_object_unref0 (self->time_provider), _tmp0_); +#line 92 "video_project.c" + } + return self; +} + + +#line 20 "video_project.vala" +ModelVideoProject* model_video_project_new (const char* filename, GError** error) { +#line 20 "video_project.vala" + return model_video_project_construct (MODEL_TYPE_VIDEO_PROJECT, filename, error); +#line 102 "video_project.c" +} + + +#line 28 "video_project.vala" +static char* model_video_project_real_get_app_name (ModelProject* base) { +#line 108 "video_project.c" + ModelVideoProject * self; + char* result = NULL; + self = MODEL_VIDEO_PROJECT (base); + result = g_strdup (APP_NAME); +#line 29 "video_project.vala" + return result; +#line 115 "video_project.c" +} + + +#line 32 "video_project.vala" +static void model_video_project_real_get_clip_time (ModelProject* base, ModelClipFile* f, TimeCode* result) { +#line 121 "video_project.c" + ModelVideoProject * self; + TimeCode _tmp0_ = {0}; + TimeCode t; + self = MODEL_VIDEO_PROJECT (base); +#line 32 "video_project.vala" + g_return_if_fail (MODEL_IS_CLIP_FILE (f)); +#line 33 "video_project.vala" + t = (_tmp0_); +#line 35 "video_project.vala" + if (model_clip_file_is_of_type (f, MODEL_MEDIA_TYPE_VIDEO)) { +#line 132 "video_project.c" + Fraction rate = {0}; + TimeCode _tmp1_ = {0}; +#line 37 "video_project.vala" + if (!model_video_project_get_framerate_fraction (self, &rate)) { +#line 38 "video_project.vala" + rate.numerator = 2997; +#line 39 "video_project.vala" + rate.denominator = 100; +#line 141 "video_project.c" + } +#line 41 "video_project.vala" + t = (frame_to_time (time_to_frame_with_rate (model_clip_file_get_length (f), &rate), &rate, &_tmp1_), _tmp1_); +#line 145 "video_project.c" + } else { +#line 43 "video_project.vala" + time_code_get_from_length (&t, model_clip_file_get_length (f)); +#line 149 "video_project.c" + } + *result = t; +#line 45 "video_project.vala" + return; +#line 154 "video_project.c" +} + + +#line 48 "video_project.vala" +void model_video_project_go_previous_frame (ModelVideoProject* self) { +#line 160 "video_project.c" + ModelVideoTrack* video_track; +#line 48 "video_project.vala" + g_return_if_fail (MODEL_IS_VIDEO_PROJECT (self)); +#line 49 "video_project.vala" + video_track = model_project_find_video_track (MODEL_PROJECT (self)); +#line 50 "video_project.vala" + if (video_track != NULL) { +#line 51 "video_project.vala" + view_media_engine_go (MODEL_PROJECT (self)->media_engine, model_video_track_previous_frame (video_track, model_project_transport_get_position (MODEL_PROJECT (self)))); +#line 170 "video_project.c" + } + _g_object_unref0 (video_track); +} + + +#line 55 "video_project.vala" +void model_video_project_go_next_frame (ModelVideoProject* self) { +#line 178 "video_project.c" + ModelVideoTrack* video_track; +#line 55 "video_project.vala" + g_return_if_fail (MODEL_IS_VIDEO_PROJECT (self)); +#line 56 "video_project.vala" + video_track = model_project_find_video_track (MODEL_PROJECT (self)); +#line 57 "video_project.vala" + if (video_track != NULL) { +#line 58 "video_project.vala" + view_media_engine_go (MODEL_PROJECT (self)->media_engine, model_video_track_next_frame (video_track, model_project_transport_get_position (MODEL_PROJECT (self)))); +#line 188 "video_project.c" + } + _g_object_unref0 (video_track); +} + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 62 "video_project.vala" +gboolean model_video_project_get_framerate_fraction (ModelVideoProject* self, Fraction* rate) { +#line 201 "video_project.c" + gboolean result = FALSE; +#line 62 "video_project.vala" + g_return_val_if_fail (MODEL_IS_VIDEO_PROJECT (self), FALSE); +#line 205 "video_project.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (MODEL_PROJECT (self)->tracks)); +#line 63 "video_project.vala" + while (TRUE) { +#line 211 "video_project.c" + ModelTrack* track; + ModelTrack* _tmp0_; + ModelVideoTrack* video_track; + gboolean _tmp1_ = FALSE; +#line 63 "video_project.vala" + if (!gee_iterator_next (_track_it)) { +#line 63 "video_project.vala" + break; +#line 220 "video_project.c" + } +#line 63 "video_project.vala" + track = (ModelTrack*) gee_iterator_get (_track_it); +#line 64 "video_project.vala" + video_track = _g_object_ref0 ((_tmp0_ = track, MODEL_IS_VIDEO_TRACK (_tmp0_) ? ((ModelVideoTrack*) _tmp0_) : NULL)); +#line 65 "video_project.vala" + if (video_track != NULL) { +#line 65 "video_project.vala" + _tmp1_ = model_video_track_get_framerate (video_track, rate); +#line 230 "video_project.c" + } else { +#line 65 "video_project.vala" + _tmp1_ = FALSE; +#line 234 "video_project.c" + } +#line 65 "video_project.vala" + if (_tmp1_) { +#line 238 "video_project.c" + result = TRUE; + _g_object_unref0 (track); + _g_object_unref0 (video_track); + _g_object_unref0 (_track_it); +#line 66 "video_project.vala" + return result; +#line 245 "video_project.c" + } + _g_object_unref0 (track); + _g_object_unref0 (video_track); + } + _g_object_unref0 (_track_it); + } + result = FALSE; +#line 68 "video_project.vala" + return result; +#line 255 "video_project.c" +} + + +static void model_video_project_class_init (ModelVideoProjectClass * klass) { + model_video_project_parent_class = g_type_class_peek_parent (klass); + MODEL_PROJECT_CLASS (klass)->load_complete = model_video_project_real_load_complete; + MODEL_PROJECT_CLASS (klass)->get_app_name = model_video_project_real_get_app_name; + MODEL_PROJECT_CLASS (klass)->get_clip_time = model_video_project_real_get_clip_time; + G_OBJECT_CLASS (klass)->finalize = model_video_project_finalize; +} + + +static void model_video_project_instance_init (ModelVideoProject * self) { +} + + +static void model_video_project_finalize (GObject* obj) { + ModelVideoProject * self; + self = MODEL_VIDEO_PROJECT (obj); + _g_object_unref0 (self->time_provider); + G_OBJECT_CLASS (model_video_project_parent_class)->finalize (obj); +} + + +GType model_video_project_get_type (void) { + static volatile gsize model_video_project_type_id__volatile = 0; + if (g_once_init_enter (&model_video_project_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelVideoProjectClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_video_project_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelVideoProject), 0, (GInstanceInitFunc) model_video_project_instance_init, NULL }; + GType model_video_project_type_id; + model_video_project_type_id = g_type_register_static (MODEL_TYPE_PROJECT, "ModelVideoProject", &g_define_type_info, 0); + g_once_init_leave (&model_video_project_type_id__volatile, model_video_project_type_id); + } + return model_video_project_type_id__volatile; +} + + + + diff --git a/src/lombard/lombard/video_project.o b/src/lombard/lombard/video_project.o new file mode 100644 index 0000000..56358c9 Binary files /dev/null and b/src/lombard/lombard/video_project.o differ diff --git a/src/lombard/sources.mk b/src/lombard/sources.mk new file mode 100644 index 0000000..2e617b3 --- /dev/null +++ b/src/lombard/sources.mk @@ -0,0 +1,4 @@ +$(SRC_PREFIX)SRC_FILES = \ + lombard.vala \ + video_project.vala + diff --git a/src/lombard/video_project.vala b/src/lombard/video_project.vala new file mode 100644 index 0000000..1265288 --- /dev/null +++ b/src/lombard/video_project.vala @@ -0,0 +1,71 @@ +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +using Logging; + +namespace Model { + +class VideoProject : Project { + public TimecodeTimeSystem time_provider; + + public override void load_complete() { + if (find_video_track() == null) { + add_track(new VideoTrack(this)); + } + } + + public VideoProject(string? filename) throws Error { + base(filename, true); + // TODO: When vala supports throwing from base constructor remove this check + if (this != null) { + time_provider = new TimecodeTimeSystem(); + } + } + + public override string get_app_name() { + return App.NAME; + } + + public override TimeCode get_clip_time(ClipFile f) { + TimeCode t = {}; + + if (f.is_of_type(MediaType.VIDEO)) { + Fraction rate; + if (!get_framerate_fraction(out rate)) { + rate.numerator = 2997; + rate.denominator = 100; + } + t = frame_to_time(time_to_frame_with_rate(f.length, rate), rate); + } else + t.get_from_length(f.length); + + return t; + } + + public void go_previous_frame() { + VideoTrack? video_track = find_video_track(); + if (video_track != null) { + media_engine.go(video_track.previous_frame(transport_get_position())); + } + } + + public void go_next_frame() { + VideoTrack? video_track = find_video_track(); + if (video_track != null) { + media_engine.go(video_track.next_frame(transport_get_position())); + } + } + + public bool get_framerate_fraction(out Fraction rate) { + foreach (Track track in tracks) { + VideoTrack video_track = track as VideoTrack; + if (video_track != null && video_track.get_framerate(out rate)) + return true; + } + return false; + } +} +} diff --git a/src/marina/AppDirs.vala b/src/marina/AppDirs.vala new file mode 100644 index 0000000..04d2248 --- /dev/null +++ b/src/marina/AppDirs.vala @@ -0,0 +1,44 @@ +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU LGPL (version 2.1 or later). + * See the COPYING file in this distribution. + */ + +extern const string _PREFIX; + + +public class AppDirs { + static File exec_dir; + static string program_name; + + public static void init(string arg0, string program_name) { + File exec_file = File.new_for_path(Environment.find_program_in_path(arg0)); + exec_dir = exec_file.get_parent(); + AppDirs.program_name = program_name; + } + + public static void terminate() { + } + + public static File get_exec_dir() { + return exec_dir; + } + + public static File get_resources_dir() { + File exec_dir = get_exec_dir(); + File install_dir = get_install_dir(); + File return_value; + if (install_dir != null) { + return_value = install_dir.get_child("share").get_child(program_name); + } else { // running locally + return_value = exec_dir; + } + return return_value.get_child("resources"); + } + + static File? get_install_dir() { + File prefix_dir = File.new_for_path(_PREFIX); + return exec_dir.has_prefix(prefix_dir) ? prefix_dir : null; + } +} + diff --git a/src/marina/AudioMeter.vala b/src/marina/AudioMeter.vala new file mode 100644 index 0000000..196291b --- /dev/null +++ b/src/marina/AudioMeter.vala @@ -0,0 +1,116 @@ +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +using Logging; + +namespace View { +public class AudioMeter : Gtk.DrawingArea { + Cairo.ImageSurface meter = null; + Cairo.ImageSurface silkscreen; + + bool stereo = false; + double current_level_left = -100; + double current_level_right = -100; + const double minDB = -70; + + public AudioMeter(Model.AudioTrack track) { + int number_of_channels; + if (track.get_num_channels(out number_of_channels)) { + stereo = number_of_channels < 1; + } + + this.requisition.height = 10; + expose_event.connect(on_expose_event); + track.level_changed.connect(on_level_changed); + track.channel_count_changed.connect(on_channel_count_changed); + } + + void initialize_meter() { + meter = new Cairo.ImageSurface(Cairo.Format.ARGB32, + allocation.width, allocation.height); + Cairo.Context context2 = new Cairo.Context(meter); + Cairo.Pattern pat = new Cairo.Pattern.linear(0, 0, allocation.width, 0); + pat.add_color_stop_rgb(0, 0.1, 1, 0.4); + pat.add_color_stop_rgb(0.8, 1, 1, 0); + pat.add_color_stop_rgb(1, 1, 0, 0); + context2.set_source(pat); + context2.rectangle(0, 0, allocation.width, allocation.height); + context2.fill(); + + silkscreen = new Cairo.ImageSurface(Cairo.Format.ARGB32, + allocation.width, allocation.height); + context2 = new Cairo.Context(silkscreen); + context2.set_source_rgba(0, 0, 0, 0); + context2.rectangle(0, 0, allocation.width, allocation.height); + context2.fill(); + + // draw the segment edges + for (int i=0;i<20;++i) { + context2.set_source_rgba(0, 0, 0, 1); + context2.rectangle(i * allocation.width / 20, 0, 3, allocation.height); + context2.fill(); + } + + // draw a bevel around the edge + context2.set_line_width(1.1); + context2.set_source_rgba(0.9, 0.9, 0.9, 0.5); + context2.rectangle(0, 0, allocation.width, allocation.height); + context2.stroke(); + } + + public bool on_expose_event(Gdk.EventExpose event) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_expose_event"); + Gdk.Window window = get_window(); + Cairo.Context context = Gdk.cairo_create(window); + if (meter == null) { + initialize_meter(); + } + + context.set_source_rgb(0, 0, 0); + context.rectangle(0, 0, allocation.width, allocation.height); + context.fill(); + + int bar_height = stereo ? (allocation.height / 2) - 1 : allocation.height - 2; + + if (stereo) { + context.set_source_rgb(1, 1, 1); + context.rectangle(0, bar_height + 1, allocation.width, 0.3); + context.fill(); + } + + context.set_source_surface(meter, 0, 0); + int width = (int) (Math.pow10(current_level_left / 40) * allocation.width); + context.rectangle(0, 1, width, bar_height); + + if (stereo) { + width = (int) (Math.pow10(current_level_right / 40) * allocation.width); + context.rectangle(0, bar_height + 2, width, bar_height); + } + + context.clip(); + context.paint_with_alpha(1); + + context.set_source_surface(silkscreen, 0, 0); + context.paint_with_alpha(1); + + return true; + } + + public void on_level_changed(double level_left, double level_right) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_level_changed"); + current_level_left = level_left < minDB ? minDB : level_left; + current_level_right = level_right < minDB ? minDB : level_right; + Gdk.Window window = get_window(); + window.invalidate_rect(null, false); + } + + public void on_channel_count_changed(int number_of_channels) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_channel_count_changed"); + stereo = number_of_channels > 1; + window.invalidate_rect(null, false); + } +} +} diff --git a/src/marina/ClassFactory.vala b/src/marina/ClassFactory.vala new file mode 100644 index 0000000..53ccfbb --- /dev/null +++ b/src/marina/ClassFactory.vala @@ -0,0 +1,37 @@ +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +public interface TrackView : Gtk.Widget { + public signal void clip_view_added(ClipView clip_view); + public abstract void move_to_top(ClipView clip_view); + public abstract void resize(); + public abstract Model.Track get_track(); + public abstract int get_track_height(); + public abstract Gtk.Widget? find_child(double x, double y); + public abstract void select_all(); +} + +public class ClassFactory { + static ClassFactory class_factory = null; + static TransportDelegate transport_delegate = null; + + public static ClassFactory get_class_factory() { + return class_factory; + } + + public virtual TrackView get_track_view(Model.Track track, TimeLine timeline) { + assert(transport_delegate != null); + return new TrackViewConcrete(transport_delegate, track, timeline); + } + + public static void set_class_factory(ClassFactory class_factory) { + ClassFactory.class_factory = class_factory; + } + + public static void set_transport_delegate(TransportDelegate transport_delegate) { + ClassFactory.transport_delegate = transport_delegate; + } +} diff --git a/src/marina/ClipLibraryView.vala b/src/marina/ClipLibraryView.vala new file mode 100644 index 0000000..c405add --- /dev/null +++ b/src/marina/ClipLibraryView.vala @@ -0,0 +1,487 @@ +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +using Logging; + +public class ClipLibraryView : Gtk.EventBox { + public static Gtk.Menu context_menu; + Model.Project project; + Gtk.TreeView tree_view; + Gtk.TreeSelection selection; + Gtk.Label label = null; + Gtk.ListStore list_store; + int num_clipfiles; + Gee.ArrayList files_dragging = new Gee.ArrayList(); + + Gtk.IconTheme icon_theme; + + Gdk.Pixbuf default_audio_icon; + Gdk.Pixbuf default_video_icon; + Gdk.Pixbuf default_error_icon; + + enum SortMode { + NONE, + ABC + } + + enum ColumnType { + THUMBNAIL, + NAME, + DURATION, + FILENAME + } + + public signal void selection_changed(bool selected); + + SortMode sort_mode; + Model.TimeSystem time_provider; + + public ClipLibraryView(Model.Project p, Model.TimeSystem time_provider, string? drag_message, + Gdk.DragAction actions) { + Gtk.drag_dest_set(this, Gtk.DestDefaults.ALL, drag_target_entries, Gdk.DragAction.COPY); + project = p; + this.time_provider = time_provider; + + icon_theme = Gtk.IconTheme.get_default(); + + list_store = new Gtk.ListStore(4, typeof (Gdk.Pixbuf), typeof (string), + typeof (string), typeof (string), -1); + + tree_view = new Gtk.TreeView.with_model(list_store); + + add_column(ColumnType.THUMBNAIL); + Gtk.TreeViewColumn name_column = add_column(ColumnType.NAME); + add_column(ColumnType.DURATION); + list_store.set_default_sort_func(name_sort); + list_store.set_sort_column_id(name_column.get_sort_column_id(), Gtk.SortType.ASCENDING); + + num_clipfiles = 0; + if (drag_message != null) { + label = new Gtk.Label(drag_message); + label.modify_fg(Gtk.StateType.NORMAL, parse_color("#fff")); + } + + modify_bg(Gtk.StateType.NORMAL, parse_color("#444")); + tree_view.modify_base(Gtk.StateType.NORMAL, parse_color("#444")); + + tree_view.set_headers_visible(false); + project.clipfile_added.connect(on_clipfile_added); + project.clipfile_removed.connect(on_clipfile_removed); + project.cleared.connect(on_remove_all_rows); + project.time_signature_changed.connect(on_time_signature_changed); + + Gtk.drag_source_set(tree_view, Gdk.ModifierType.BUTTON1_MASK, drag_target_entries, actions); + tree_view.drag_begin.connect(on_drag_begin); + tree_view.drag_data_get.connect(on_drag_data_get); + tree_view.cursor_changed.connect(on_cursor_changed); + + selection = tree_view.get_selection(); + selection.set_mode(Gtk.SelectionMode.MULTIPLE); + if (label != null) { + add(label); + } + + // We have to have our own button press and release handlers + // since the normal drag-selection handling does not allow you + // to click outside any cell in the library to clear your selection, + // and also does not allow dragging multiple clips from the library + // to the timeline + tree_view.button_press_event.connect(on_button_pressed); + tree_view.button_release_event.connect(on_button_released); + + try { + default_audio_icon = + icon_theme.load_icon("audio-x-generic", 32, (Gtk.IconLookupFlags) 0); + default_video_icon = + icon_theme.load_icon("video-x-generic", 32, (Gtk.IconLookupFlags) 0); + default_error_icon = + icon_theme.load_icon("error", 32, (Gtk.IconLookupFlags) 0); + } catch (GLib.Error e) { + // TODO: what shall we do if these icons are not available? + } + + sort_mode = SortMode.ABC; + } + + Gtk.TreePath? find_first_selected() { + Gtk.TreeIter it; + Gtk.TreeModel model = tree_view.get_model(); + + bool b = model.get_iter_first(out it); + while (b) { + Gtk.TreePath path = model.get_path(it); + if (selection.path_is_selected(path)) + return path; + + b = model.iter_next(ref it); + } + return null; + } + + bool on_button_pressed(Gdk.EventButton b) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_button_pressed"); + + Gtk.TreePath path; + int cell_x; + int cell_y; + + tree_view.get_path_at_pos((int) b.x, (int) b.y, out path, null, out cell_x, out cell_y); + + if (path == null) { + selection.unselect_all(); + return true; + } + + bool shift_pressed = (b.state & Gdk.ModifierType.SHIFT_MASK) != 0; + bool control_pressed = (b.state & Gdk.ModifierType.CONTROL_MASK) != 0; + + if (!control_pressed && + !shift_pressed) { + if (!selection.path_is_selected(path)) + selection.unselect_all(); + } else { + if (shift_pressed) { + Gtk.TreePath first = find_first_selected(); + + if (first != null) + selection.select_range(first, path); + } + } + selection.select_path(path); + + if (b.button == 3) { + selection_changed(true); + context_menu.select_first(true); + context_menu.popup(null, null, null, 0, b.time); + } else { + context_menu.popdown(); + } + + return true; + } + + bool on_button_released(Gdk.EventButton b) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_button_released"); + Gtk.TreePath path; + Gtk.TreeViewColumn column; + + int cell_x; + int cell_y; + + tree_view.get_path_at_pos((int) b.x, (int) b.y, out path, + out column, out cell_x, out cell_y); + + // The check for cell_x == 0 and cell_y == 0 is here since for whatever reason, this + // function is called when we drop some clips onto the timeline. We only need to mess with + // the selection if we've actually clicked in the tree view, but I cannot find a way to + // guarantee this, since the coordinates that the Gdk.EventButton structure and the + // (cell_x, cell_y) pair give are always 0, 0 when this happens. + // I can assume that clicking on 0, 0 exactly is next to impossible, so I feel this + // strange check is okay. + + if (path == null || + (cell_x == 0 && cell_y == 0)) { + selection_changed(false); + return true; + } + + bool shift_pressed = (b.state & Gdk.ModifierType.SHIFT_MASK) != 0; + bool control_pressed = (b.state & Gdk.ModifierType.CONTROL_MASK) != 0; + + if (!control_pressed && + !shift_pressed) { + if (selection.path_is_selected(path)) + selection.unselect_all(); + } + selection.select_path(path); + selection_changed(true); + + return true; + } + + void on_cursor_changed() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_cursor_changed"); + selection_changed(has_selection()); + } + + public void unselect_all() { + selection.unselect_all(); + selection_changed(false); + } + + public override void drag_data_received(Gdk.DragContext context, int x, int y, + Gtk.SelectionData selection_data, uint drag_info, + uint time) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_drag_data_received"); + string[] a = selection_data.get_uris(); + Gtk.drag_finish(context, true, false, time); + + project.create_clip_importer(null, false, 0, false, (Gtk.Window) get_toplevel(), a.length); + + try { + foreach (string s in a) { + string filename; + try { + filename = GLib.Filename.from_uri(s); + } catch (GLib.ConvertError e) { continue; } + project.importer.add_file(filename); + } + project.importer.start(); + } catch (Error e) { + project.error_occurred("Error importing", e.message); + } + } + + + void on_drag_data_get(Gdk.DragContext context, Gtk.SelectionData data, + uint info, uint time) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_drag_data_get"); + string uri; + string[] uri_array = new string[0]; + + foreach (string s in files_dragging) { + try { + uri = GLib.Filename.to_uri(s); + } catch (GLib.ConvertError e) { + uri = s; + warning("Cannot get URI for %s! (%s)\n", s, e.message); + } + uri_array += uri; + } + data.set_uris(uri_array); + + Gtk.drag_set_icon_default(context); + } + + int get_selected_rows(out GLib.List paths) { + paths = selection.get_selected_rows(null); + return (int) paths.length(); + } + + void on_drag_begin(Gdk.DragContext c) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_drag_begin"); + GLib.List paths; + if (get_selected_rows(out paths) > 0) { + bool set_pixbuf = false; + files_dragging.clear(); + foreach (Gtk.TreePath t in paths) { + Gtk.TreeIter iter; + list_store.get_iter(out iter, t); + + string filename; + list_store.get(iter, ColumnType.FILENAME, out filename, -1); + files_dragging.add(filename); + + if (!set_pixbuf) { + Gdk.Pixbuf pixbuf; + list_store.get(iter, ColumnType.THUMBNAIL, out pixbuf, -1); + + Gtk.drag_set_icon_pixbuf(c, pixbuf, 0, 0); + set_pixbuf = true; + } + } + } + } + + Gtk.TreeViewColumn add_column(ColumnType c) { + Gtk.TreeViewColumn column = new Gtk.TreeViewColumn(); + Gtk.CellRenderer renderer; + + if (c == ColumnType.THUMBNAIL) { + renderer = new Gtk.CellRendererPixbuf(); + } else { + renderer = new Gtk.CellRendererText(); + Gdk.Color color = parse_color("#FFF"); + renderer.set("foreground-gdk", &color); + } + + column.pack_start(renderer, true); + column.set_resizable(true); + + if (c == ColumnType.THUMBNAIL) { + column.add_attribute(renderer, "pixbuf", tree_view.append_column(column) - 1); + } else { + column.add_attribute(renderer, "text", tree_view.append_column(column) - 1); + } + return column; + } + + void update_iter(Gtk.TreeIter it, Model.ClipFile clip_file) { + Gdk.Pixbuf icon; + + if (clip_file.is_online()) { + if (clip_file.thumbnail == null) + icon = (clip_file.is_of_type(Model.MediaType.VIDEO) ? + default_video_icon : default_audio_icon); + else { + icon = clip_file.thumbnail; + } + } else { + icon = default_error_icon; + } + + list_store.set(it, ColumnType.THUMBNAIL, icon, + ColumnType.NAME, isolate_filename(clip_file.filename), + ColumnType.DURATION, time_provider.get_time_duration(clip_file.length), + ColumnType.FILENAME, clip_file.filename, -1); + } + + void on_clipfile_added(Model.ClipFile f) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_file_added"); + Gtk.TreeIter it; + + if (find_clipfile(f, out it) >= 0) { + list_store.remove(it); + } else { + if (num_clipfiles == 0) { + if (label != null) { + remove(label); + } + add(tree_view); + tree_view.show(); + } + num_clipfiles++; + } + + list_store.append(out it); + update_iter(it, f); + } + + int find_clipfile(Model.ClipFile f, out Gtk.TreeIter iter) { + Gtk.TreeModel model = tree_view.get_model(); + + bool b = model.get_iter_first(out iter); + + int i = 0; + while (b) { + string filename; + model.get(iter, ColumnType.FILENAME, out filename); + + if (filename == f.filename) + return i; + + i++; + b = model.iter_next(ref iter); + } + return -1; + } + + public void on_clipfile_removed(Model.ClipFile f) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_file_removed"); + Gtk.TreeIter it; + + if (find_clipfile(f, out it) >= 0) { + remove_row(ref it); + } + } + + bool remove_row(ref Gtk.TreeIter it) { + bool b = list_store.remove(it); + num_clipfiles--; + if (num_clipfiles == 0) { + remove(tree_view); + if (label != null) { + add(label); + label.show(); + } + } + return b; + } + + void on_remove_all_rows() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_remove_all_rows"); + Gtk.TreeModel model = tree_view.get_model(); + Gtk.TreeIter iter; + + bool b = model.get_iter_first(out iter); + + while (b) { + b = remove_row(ref iter); + } + } + + void on_time_signature_changed(Fraction time_signature) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_time_signature_changed"); + Gtk.TreeIter iter; + bool more_items = list_store.get_iter_first(out iter); + while (more_items) { + string filename; + list_store.get(iter, ColumnType.FILENAME, out filename, -1); + Model.ClipFile clip_file = project.find_clipfile(filename); + list_store.set(iter, ColumnType.DURATION, + time_provider.get_time_duration(clip_file.length), -1); + more_items = list_store.iter_next(ref iter); + } + } + + void delete_row(Gtk.TreeModel model, Gtk.TreePath path) { + Gtk.TreeIter it; + if (list_store.get_iter(out it, path)) { + string filename; + model.get(it, ColumnType.FILENAME, out filename, -1); + if (project.clipfile_on_track(filename)) { + if (DialogUtils.delete_cancel("Clip is in use. Delete anyway?") != + Gtk.ResponseType.YES) + return; + } + + project.remove_clipfile(filename); + + if (Path.get_dirname(filename) == project.get_audio_path()) { + if (DialogUtils.delete_keep("Delete clip from disk? This action is not undoable.") + == Gtk.ResponseType.YES) { + if (FileUtils.unlink(filename) != 0) { + project.error_occurred("Could not delete %s", filename); + } + project.undo_manager.reset(); + } + } + } + } + + public bool has_selection() { + GLib.List paths; + return get_selected_rows(out paths) != 0; + } + + public Gee.ArrayList get_selected_files() { + GLib.List paths; + Gee.ArrayList return_value = new Gee.ArrayList(); + if (get_selected_rows(out paths) != 0) { + foreach (Gtk.TreePath path in paths) { + Gtk.TreeIter iter; + if (list_store.get_iter(out iter, path)) { + string name; + list_store.get(iter, ColumnType.FILENAME, out name, -1); + return_value.add(name); + } + } + } + return return_value; + } + + public void delete_selection() { + GLib.List paths; + project.undo_manager.start_transaction("Delete Clips From Library"); + if (get_selected_rows(out paths) > 0) { + for (int i = (int) paths.length() - 1; i >= 0; i--) + delete_row(list_store, paths.nth_data(i)); + } + project.undo_manager.end_transaction("Delete Clips From Library"); + } + + public void select_all() { + selection.select_all(); + } + + int name_sort(Gtk.TreeModel model, Gtk.TreeIter a, Gtk.TreeIter b) { + string left; + string right; + model.get(a, ColumnType.NAME, out left); + model.get(b, ColumnType.NAME, out right); + return stricmp(left, right); + } +} diff --git a/src/marina/DialogUtils.vala b/src/marina/DialogUtils.vala new file mode 100644 index 0000000..a391f02 --- /dev/null +++ b/src/marina/DialogUtils.vala @@ -0,0 +1,350 @@ +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +namespace DialogUtils { + public struct filter_description_struct { + public string name; + public string extension; + } + + Gtk.FileFilter add_filter(Gtk.FileChooserDialog d, string name, string? extension) { + Gtk.FileFilter filter = new Gtk.FileFilter(); + filter.set_name(name); + if (extension != null) { + filter.add_pattern("*." + extension); + } else { + filter.add_pattern("*"); + } + d.add_filter(filter); + return filter; + } + + void add_filters(filter_description_struct[] filter_descriptions, Gtk.FileChooserDialog d, + Gee.ArrayList filters, bool allow_all) { + + int length = filter_descriptions.length; + for (int i=0;i filenames) { + bool return_value = false; + Hildon.FileChooserDialog file_chooser = new Hildon.FileChooserDialog(parent, Gtk.FileChooserAction.OPEN); + file_chooser.set_title("Open Files"); + //file_chooser.set_parent(parent); + //file_chooser.set_current_folder(GLib.Environment.get_home_dir()); + //file_chooser.set_safe_folder(GLib.Environment.get_home_dir()); + file_chooser.set_show_upnp(true); + Gee.ArrayList filters = new Gee.ArrayList(); + add_filters(filter_descriptions, (Gtk.FileChooserDialog)file_chooser, filters, allow_all); + file_chooser.set_select_multiple(allow_multiple); + if (file_chooser.run() == Gtk.ResponseType.OK) { + return_value = true; + filenames = file_chooser.get_filenames(); + } + file_chooser.destroy(); + return return_value; + } + + public bool save(Gtk.Window parent, string title, bool create_directory, + filter_description_struct[] filter_descriptions, ref string filename) { + bool return_value = false; + + + Hildon.FileChooserDialog file_chooser = new Hildon.FileChooserDialog(parent, Gtk.FileChooserAction.SAVE); + file_chooser.set_title(title); + file_chooser.set_show_upnp(false); + if (filename != null) { + file_chooser.set_current_folder(Path.get_dirname(filename)); + } else { + //file_chooser.set_current_folder(GLib.Environment.get_home_dir()); + } + int length = filter_descriptions.length; + Gee.ArrayList filters = new Gee.ArrayList(); + + // add_filters(filter_descriptions, (Gtk.FileChooserDialog)file_chooser, filters, false); + + //all this extra code is because the dialog doesn't append the extension for us + //in the filename, so we can't use d.set_do_overwrite_confirmation + + while (file_chooser.run() == Gtk.ResponseType.OK) { + string local_filename = file_chooser.get_filename(); + if (create_directory) { + if (GLib.DirUtils.create(local_filename, 0777) != 0) { + error("Could not create directory", GLib.strerror(GLib.errno));; + file_chooser.present(); + continue; + } + local_filename = Path.build_filename(local_filename, + Path.get_basename(local_filename)); + } + + unowned Gtk.FileFilter selected_filter = file_chooser.get_filter(); + + int i = 0; + foreach (Gtk.FileFilter file_filter in filters) { + if (file_filter == selected_filter) { + break; + } + ++i; + } + + assert(i < length); + + local_filename = append_extension(local_filename, filter_descriptions[i].extension); + if (!FileUtils.test(local_filename, FileTest.EXISTS) || + confirm_replace(parent, local_filename)) { + return_value = true; + filename = local_filename; + break; + } + else { + file_chooser.present(); + } + } + file_chooser.destroy(); + return return_value; + } + + string bold_message(string message) { + return message; //"" + message + ""; + } + + public void warning(string major_message, string? minor_message) { + string message = bold_message(major_message); + if (minor_message != null) { + message = message + "\n\n" + minor_message; + } + Gtk.Widget banner = Hildon.Banner.show_information_with_markup(null, null, message); + ((Hildon.Banner)banner).set_timeout(1000 * 2); + } + + public void error(string major_message, string? minor_message) { + string message = bold_message(major_message); + if (minor_message != null) { + message = message + "\n\n" + minor_message; + } + Gtk.Widget banner = Hildon.Banner.show_information_with_markup(null, null, message); + ((Hildon.Banner)banner).set_timeout(1000 * 2); + } + + Gtk.ResponseType run_dialog(Gtk.Window? parent, Gtk.MessageType type, + string? title, string message, ButtonStruct[] buttons) { + //string the_message = bold_message(message); + if (null == title) title = "Message"; + Hildon.Dialog dialog = new Hildon.Dialog(); + dialog.set_parent(parent); + dialog.set_title(title); + Gtk.VBox content = (Gtk.VBox)dialog.get_content_area(); + Gtk.Label label = new Gtk.Label(message); + //label.use_markup = true; + label.single_line_mode = false; + label.set_line_wrap(true); + + content.add(label); + + int length = buttons.length; + for (int i = 0; i < length; ++i) { + dialog.add_button(buttons[i].title, buttons[i].type); + } + + dialog.show_all(); + Gtk.ResponseType response = (Gtk.ResponseType) dialog.run(); + dialog.destroy(); + + return response; + } + + Gtk.ResponseType two_button_dialog(string message, string first_button, string second_button) { + Hildon.Dialog d = new Hildon.Dialog(); + + Gtk.VBox contents = (Gtk.VBox)d.get_content_area(); + Gtk.VBox vbox = new Gtk.VBox(true, 4); + Gtk.Label label = new Gtk.Label(message); + label.use_markup = true; + label.single_line_mode = false; + label.set_line_wrap(true); + vbox.pack_start(label); + contents.add(vbox); + d.add_buttons(first_button, Gtk.ResponseType.NO, + second_button, Gtk.ResponseType.YES); + + d.show_all(); + Gtk.ResponseType r = (Gtk.ResponseType) d.run(); + d.destroy(); + + return r; + } + + public Gtk.ResponseType delete_keep(string message) { + return two_button_dialog(message, "Keep", Gtk.STOCK_DELETE); + } + + public Gtk.ResponseType add_cancel(string message) { + return two_button_dialog(message, Gtk.STOCK_CANCEL, Gtk.STOCK_ADD); + } + + public Gtk.ResponseType delete_cancel(string message) { + return two_button_dialog(message, Gtk.STOCK_CANCEL, Gtk.STOCK_DELETE); + } + + public bool confirm_replace(Gtk.Window? parent, string filename) { + return Gtk.ResponseType.YES == two_button_dialog("A file named \"%s\" already exists. Do you want to replace it?", "Cancel", "Replace"); + } + + struct ButtonStruct { + public ButtonStruct(string title, Gtk.ResponseType type) { + this.title = title; + this.type = type; + } + + public string title; + public Gtk.ResponseType type; + } + + public Gtk.ResponseType save_close_cancel(Gtk.Window? parent, string? title, string message) { + ButtonStruct[] buttons = { + ButtonStruct(Gtk.STOCK_CLOSE, Gtk.ResponseType.NO), + ButtonStruct(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL), + ButtonStruct(Gtk.STOCK_SAVE, Gtk.ResponseType.ACCEPT) + }; + + return run_dialog(parent, Gtk.MessageType.WARNING, title, message, buttons); + } + + Gtk.Alignment get_aligned_label(float x, float y, float exp_x, float exp_y, string text, + bool selectable) { + Gtk.Label l = new Gtk.Label(text); + l.set_line_wrap(true); + l.use_markup = true; + l.selectable = selectable; + + Gtk.Alignment a = new Gtk.Alignment(x, y, exp_x, exp_y); + a.add(l); + + return a; + } + + void add_label_to_table(Gtk.Table t, string str, int x, int y, int xpad, int ypad, + bool selectable) { + Gtk.Alignment a = get_aligned_label(0.0f, 0.0f, 0.0f, 0.0f, str, selectable); + t.attach(a, x, x + 1, y, y + 1, Gtk.AttachOptions.FILL, Gtk.AttachOptions.FILL, xpad, ypad); + } + + public void show_clip_properties(Gtk.Window parent, ClipView? selected_clip, + Model.ClipFile ? clip_file, Fraction? frames_per_second) { + Hildon.Dialog d = new Hildon.Dialog.with_buttons("Clip Properties", parent, + Gtk.DialogFlags.MODAL, Gtk.STOCK_OK, Gtk.ResponseType.ACCEPT); + if (selected_clip != null) { + clip_file = selected_clip.clip.clipfile; + } + + d.set("has-separator", false); + + Gtk.Table t = new Gtk.Table(10, 2, false); + int row = 0; + int tab_padding = 25; + + for (int i = 0; i < 10; i++) + t.set_row_spacing(i, 10); + + row = 1; + add_label_to_table(t, "Clip", 0, row++, 5, 0, false); + + if (selected_clip != null) { + add_label_to_table(t, "Name:", 0, row, tab_padding, 0, false); + add_label_to_table(t, "%s".printf(selected_clip.clip.name), 1, row++, 5, 0, true); + } + + add_label_to_table(t, "Location:", 0, row, tab_padding, 0, false); + add_label_to_table(t, "%s".printf(clip_file.filename), 1, row++, 5, 0, true); + + if (selected_clip != null) { + add_label_to_table(t, "Timeline length:", 0, row, tab_padding, 0, false); + + string length_string = ""; + string actual_length = ""; + + if (frames_per_second != null && frames_per_second.numerator > 0) { + TimeCode time = frame_to_time (time_to_frame_with_rate(selected_clip.clip.duration, + frames_per_second), frames_per_second); + length_string = time.to_string(); + time = frame_to_time(time_to_frame_with_rate( + selected_clip.clip.clipfile.length, frames_per_second), frames_per_second); + actual_length = time.to_string(); + } else { + length_string = time_to_string(selected_clip.clip.duration); + actual_length = time_to_string(selected_clip.clip.clipfile.length); + } + + add_label_to_table(t, "%s".printf(length_string), 1, row++, 5, 0, true); + + if (selected_clip.clip.is_trimmed()) { + add_label_to_table(t, "Actual length:", 0, row, tab_padding, 0, false); + add_label_to_table(t, "%s".printf(actual_length), 1, row++, 5, 0, true); + } + } + + if (clip_file.has_caps_structure(Model.MediaType.VIDEO)) { + add_label_to_table(t, "Video", 0, row++, 5, 0, false); + + int w, h; + if (clip_file.get_dimensions(out w, out h)) { + add_label_to_table(t, "Dimensions:", 0, row, tab_padding, 0, false); + add_label_to_table(t, "%d x %d".printf(w, h), 1, row++, 5, 0, true); + } + + Fraction r; + if (clip_file.get_frame_rate(out r)) { + add_label_to_table(t, "Frame rate:", 0, row, tab_padding, 0, false); + + if (r.numerator % r.denominator != 0) + add_label_to_table(t, + "%.2f frames per second".printf(r.numerator / (float)r.denominator), + 1, row++, 5, 0, true); + else + add_label_to_table(t, + "%d frames per second".printf(r.numerator / r.denominator), + 1, row++, 5, 0, true); + } + } + + if (clip_file.has_caps_structure(Model.MediaType.AUDIO)) { + add_label_to_table(t, "Audio", 0, row++, 5, 0, false); + + int rate; + if (clip_file.get_sample_rate(out rate)) { + add_label_to_table(t, "Sample rate:", 0, row, tab_padding, 0, false); + add_label_to_table(t, "%d Hz".printf(rate), 1, row++, 5, 0, true); + } + + string s; + if (clip_file.get_num_channels_string(out s)) { + add_label_to_table(t, "Number of channels:", 0, row, tab_padding, 0, false); + add_label_to_table(t, "%s".printf(s), 1, row++, 5, 0, true); + } + } + + d.vbox.pack_start(t, false, false, 0); + + d.show_all(); + d.run(); + d.destroy(); + } +} diff --git a/src/marina/Logging.vala b/src/marina/Logging.vala new file mode 100644 index 0000000..da79dad --- /dev/null +++ b/src/marina/Logging.vala @@ -0,0 +1,57 @@ +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ +namespace Logging { + +public enum Facility { + SIGNAL_HANDLERS, + DEVELOPER_WARNINGS, + GRAPH, + LOADING, + IMPORT, + SINGLEDECODEBIN +} + +public enum Level { + CRITICAL, + HIGH, + MEDIUM, + LOW, + INFO, + VERBOSE +} + +const Level active_facility[] = { + Level.CRITICAL, // SIGNAL_HANDLERS + Level.CRITICAL, // DEVELOPER_WARNINGS + Level.CRITICAL, // GRAPH + Level.CRITICAL, //LOADING + Level.CRITICAL, //IMPORT + Level.CRITICAL //SINGLEDECODEBIN +}; + +const string facility_names[] = { + "SIGNAL_HANDLERS", + "DEVELOPER_WARNINGS", + "GRAPH", + "LOADING", + "IMPORT", + "SINGLEDECODEBIN" +}; + +Level current_level = Level.HIGH; + +public void set_logging_level(Level new_level) { + if (new_level <= Level.VERBOSE && new_level >= Level.CRITICAL) { + current_level = new_level; + } +} + +public void emit(Object object, Facility facility, Level level, string message) { + if (level <= current_level || level <= active_facility[facility]) { + stderr.printf("%s(%s): %s\n", object.get_type().name(), facility_names[facility], message); + } +} +} diff --git a/src/marina/Makefile b/src/marina/Makefile new file mode 100644 index 0000000..fa5345b --- /dev/null +++ b/src/marina/Makefile @@ -0,0 +1,29 @@ +LIBRARY = libmarina.a +all: $(LIBRARY) + +# defaults that may be overridden by configure.mk +BUILD_RELEASE=1 + +-include ../../configure.mk + +-include sources.mk + +HEADER_FILES = marina.h +LIBRARY_NAME = --library marina + +ifndef BUILD_DIR +BUILD_DIR=marina +endif + +-include ../../marina.mk + +clean: + rm -f $(EXPANDED_C_FILES) + rm -f $(EXPANDED_SAVE_TEMPS_FILES) + rm -f $(EXPANDED_OBJ_FILES) + rm -f $(VALA_STAMP) + rm -rf $(LIBRARY)-$(VERSION) + rm -f $(LIBRARY) + rm -f $(BUILD_DIR)/marina.vapi + rm -f marina.h + diff --git a/src/marina/MediaEngine.vala b/src/marina/MediaEngine.vala new file mode 100644 index 0000000..1bc90f8 --- /dev/null +++ b/src/marina/MediaEngine.vala @@ -0,0 +1,1190 @@ +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +using Logging; + +public enum PlayState { + STOPPED, + PRE_PLAY, PLAYING, + PRE_RECORD_NULL, PRE_RECORD, RECORDING, POST_RECORD, + PRE_EXPORT, EXPORTING, CANCEL_EXPORT, + LOADING, + CLOSING, CLOSED +} + +public const int CHANNELS_PER_TRACK_PLAYBACK = 2; +public const int CHANNELS_PER_TRACK_RECORD = 1; + +namespace View { + +class MediaClip : Object { + public Gst.Element file_source; + weak Model.Clip clip; + Gst.Bin composition; + + public signal void clip_removed(MediaClip clip); + + public MediaClip(Gst.Bin composition, Model.Clip clip) throws Error { + this.clip = clip; + this.composition = composition; + file_source = make_element("gnlsource"); + if (!clip.is_recording) { + clip.duration_changed.connect(on_duration_changed); + clip.media_start_changed.connect(on_media_start_changed); + clip.start_changed.connect(on_start_changed); + + composition.add(file_source); + + on_start_changed(clip.start); + on_media_start_changed(clip.media_start); + on_duration_changed(clip.duration); + } + clip.removed.connect(on_clip_removed); + } + + ~MediaClip() { + clip.removed.disconnect(on_clip_removed); + if (!clip.is_recording) { + clip.duration_changed.disconnect(on_duration_changed); + clip.media_start_changed.disconnect(on_media_start_changed); + clip.start_changed.disconnect(on_start_changed); + } + file_source.set_state(Gst.State.NULL); + } + + public void on_clip_removed() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_removed"); + composition.remove((Gst.Bin)file_source); + clip_removed(this); + } + + void on_media_start_changed(int64 media_start) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_media_start_changed"); + file_source.set("media-start", media_start); + } + + void on_duration_changed(int64 duration) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_duration_changed"); + file_source.set("duration", duration); + // TODO: is media-duration necessary? + file_source.set("media-duration", duration); + } + + void on_start_changed(int64 start) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_start_changed"); + file_source.set("start", start); + } + + protected void add_single_decode_bin(string filename, string caps) throws Error { + Gst.Element sbin = new SingleDecodeBin(Gst.Caps.from_string(caps), + "singledecoder", filename); + if (((Gst.Bin) file_source).add(sbin)) { + if (!file_source.sync_state_with_parent()) { + clip.clipfile.set_online(false); + } + } + } + + public bool is_equal(Model.Clip clip) { + return clip == this.clip; + } +} + +class MediaAudioClip : MediaClip { + public MediaAudioClip(Gst.Bin composition, Model.Clip clip, string filename) throws Error { + base(composition, clip); + if (!clip.is_recording) { + add_single_decode_bin(filename, "audio/x-raw-float;audio/x-raw-int"); + } + } +} + +class MediaVideoClip : MediaClip { + public MediaVideoClip(Gst.Bin composition, Model.Clip clip, string filename) throws Error { + base(composition, clip); + add_single_decode_bin(filename, "video/x-raw-yuv; video/x-raw-rgb"); + } +} + +public abstract class MediaTrack : Object { + Gee.ArrayList clips; + protected weak MediaEngine media_engine; + protected Gst.Bin composition; + + protected Gst.Element default_source; + protected Gst.Element sink; + + public signal void track_removed(MediaTrack track); + public signal void error_occurred(string major_message, string? minor_message); + + public MediaTrack(MediaEngine media_engine, Model.Track track) throws Error { + clips = new Gee.ArrayList(); + this.media_engine = media_engine; + track.clip_added.connect(on_clip_added); + track.track_removed.connect(on_track_removed); + + media_engine.pre_export.connect(on_pre_export); + media_engine.post_export.connect(on_post_export); + + composition = (Gst.Bin) make_element("gnlcomposition"); + + default_source = make_element_with_name("gnlsource", "track_default_source"); + Gst.Bin default_source_bin = (Gst.Bin) default_source; + if (!default_source_bin.add(empty_element())) + error("can't add empty element"); + + // If we set the priority to 0xffffffff, then Gnonlin will treat this source as + // a default and we won't be able to seek past the end of the last region. + // We want to be able to seek into empty space, so we use a fixed priority instead. + default_source.set("priority", 1); + default_source.set("start", 0 * Gst.SECOND); + default_source.set("duration", 1000000 * Gst.SECOND); + default_source.set("media-start", 0 * Gst.SECOND); + default_source.set("media-duration", 1000000 * Gst.SECOND); + + if (!composition.add(default_source)) { + error("can't add default source"); + } + + media_engine.pipeline.add(composition); + composition.pad_added.connect(on_pad_added); + composition.pad_removed.connect(on_pad_removed); + } + + ~MediaTrack() { + if (composition != null && !media_engine.pipeline.remove(composition)) { + error("couldn't remove composition"); + } + } + + protected abstract Gst.Element empty_element() throws Error; + public abstract Gst.Element? get_element(); + + public abstract void link_new_pad(Gst.Pad pad, Gst.Element track_element); + public abstract void unlink_pad(Gst.Pad pad, Gst.Element track_element); + + void on_clip_added(Model.Clip clip) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_added"); + clip.updated.connect(on_clip_updated); + on_clip_updated(clip); + } + + void on_clip_updated(Model.Clip clip) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_updated"); + if (clip.clipfile.is_online()) { + try { + MediaClip media_clip; + if (clip.type == Model.MediaType.AUDIO) { + media_clip = new MediaAudioClip(composition, clip, clip.clipfile.filename); + } else { + media_clip = new MediaVideoClip(composition, clip, clip.clipfile.filename); + } + media_clip.clip_removed.connect(on_media_clip_removed); + + clips.add(media_clip); + } catch (Error e) { + error_occurred("Could not create clip", e.message); + } + } else { + foreach (MediaClip media_clip in clips) { + if (media_clip.is_equal(clip)) { + media_clip.on_clip_removed(); + } + } + } + } + + void on_media_clip_removed(MediaClip clip) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_media_clip_removed"); + clip.clip_removed.disconnect(on_media_clip_removed); + clips.remove(clip); + } + + void on_pad_added(Gst.Pad pad) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_pad_added"); + link_new_pad(pad, get_element()); + } + + void on_pad_removed(Gst.Pad pad) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_pad_removed"); + unlink_pad(pad, get_element()); + } + + void on_track_removed(Model.Track track) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_track_removed"); + track_removed(this); + } + + void on_pre_export(int64 length) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_pre_export"); + default_source.set("duration", length); + default_source.set("media-duration", length); + } + + void on_post_export(bool deleted) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_post_export"); + default_source.set("duration", 1000000 * Gst.SECOND); + default_source.set("media-duration", 1000000 * Gst.SECOND); + } +} + +public class MediaVideoTrack : MediaTrack { + weak Gst.Element converter; + + public MediaVideoTrack(MediaEngine media_engine, Model.Track track, + Gst.Element converter) throws Error { + base(media_engine, track); + this.converter = converter; + } + + public override Gst.Element? get_element() { + //converter shouldn't be null. since fillmore is currently not supporting + //video, but this is a shared track, we can't guarantee at compile time that + //convert is valid. This is why we have "Gst.Element?" rather than "Gst.Element" + assert(converter != null); + assert(converter.sync_state_with_parent()); + return converter; + } + + protected override Gst.Element empty_element() throws Error { + Gst.Element blackness = make_element("videotestsrc"); + blackness.set("pattern", 2); // 2 == GST_VIDEO_TEST_SRC_BLACK + return blackness; + } + + public override void link_new_pad(Gst.Pad pad, Gst.Element track_element) { + if (pad.link(track_element.get_static_pad("sink")) != Gst.PadLinkReturn.OK) { + error("couldn't link pad to converter"); + } + } + + public override void unlink_pad(Gst.Pad pad, Gst.Element track_element) { + pad.unlink(track_element.get_static_pad("sink")); + } +} + +public class ClickTrack : Object { + Gst.Controller click_controller; + Gst.Controller volume_controller; + Gst.Element audio_source; + Gst.Element audio_convert; + Gst.Element volume; + weak Model.Project project; + + public ClickTrack(MediaEngine engine, Model.Project project) throws Error { + this.project = project; + audio_source = make_element("audiotestsrc"); + audio_convert = make_element("audioconvert"); + volume = make_element("volume"); + GLib.List list = new GLib.List(); + list.append("freq"); + click_controller = new Gst.Controller.list(audio_source, list); + list.remove_all("freq"); + list.append("mute"); + volume_controller = new Gst.Controller.list(volume, list); + engine.pipeline.add_many(audio_source, volume, audio_convert); + audio_source.set("volume", project.click_volume); + + audio_source.link_many(audio_convert, volume, engine.adder); + engine.playstate_changed.connect(on_playstate_changed); + } + + void clear_controllers() { + volume_controller.unset_all("mute"); + click_controller.unset_all("freq"); + volume.set("mute", true); + volume.set("volume", 0.0); + } + + void on_playstate_changed() { + switch (project.media_engine.get_play_state()) { + case PlayState.PRE_EXPORT: + case PlayState.STOPPED: + clear_controllers(); + break; + case PlayState.PLAYING: { + if (project.click_during_play) { + setup_clicks(project.get_bpm(), project.get_time_signature()); + } else { + clear_controllers(); + } + } + break; + case PlayState.PRE_RECORD: { + if (project.click_during_record) { + setup_clicks(project.get_bpm(), project.get_time_signature()); + } else { + // TODO: Hack for bug #1436 Should be waiting for async message + // instead, spend some extra time allowing the seek to finish + setup_clicks(project.get_bpm(), project.get_time_signature()); + clear_controllers(); + } + } + break; + } + } + + void setup_clicks(int bpm, Fraction time_signature) { + clear_controllers(); + volume.set("volume", project.click_volume / 10); + + Gst.Value double_value = Gst.Value(); + double_value.init(Type.from_name("gdouble")); + Gst.Value bool_value = Gst.Value(); + bool_value.init(Type.from_name("gboolean")); + + Gst.ClockTime time = (Gst.ClockTime)(0); + bool_value.set_boolean(true); + volume_controller.set("volume", time, bool_value); + + int64 conversion = (Gst.SECOND * 60) / bpm; + uint64 current_time = 0; + // TODO: We are playing for a hard-coded amount of time. + for (int i = 0; current_time < Gst.SECOND * 60 * 10; ++i) { + current_time = i * conversion; + if (i > 0) { + time = (Gst.ClockTime)(current_time - Gst.SECOND/10); + bool_value.set_boolean(true); + volume_controller.set("mute", time, bool_value); + } + time = (Gst.ClockTime)(current_time); + if ((i % time_signature.numerator) == 0) { + double_value.set_double(880.0); + } else { + double_value.set_double(440.0); + } + click_controller.set("freq", time, double_value); + bool_value.set_boolean(false); + volume_controller.set("mute", time, bool_value); + + time = (Gst.ClockTime)(current_time + Gst.SECOND/10); + bool_value.set_boolean(true); + volume_controller.set("mute", time, bool_value); + } + } +} + +public class MediaAudioTrack : MediaTrack { + Gst.Element audio_convert; + Gst.Element audio_resample; + Gst.Element level; + Gst.Element pan; + Gst.Element volume; + Gst.Pad adder_pad; + + public MediaAudioTrack(MediaEngine media_engine, Model.AudioTrack track) throws Error { + base(media_engine, track); + track.parameter_changed.connect(on_parameter_changed); + + audio_convert = make_element("audioconvert"); + audio_resample = make_element("audioresample"); + level = make_element("level"); + + pan = make_element("audiopanorama"); + on_parameter_changed(Model.Parameter.PAN, track.get_pan()); + volume = make_element("volume"); + on_parameter_changed(Model.Parameter.VOLUME, track.get_volume()); + + Value the_level = (uint64) (Gst.SECOND / 30); + level.set_property("interval", the_level); + Value true_value = true; + level.set_property("message", true_value); + + if (!media_engine.pipeline.add(audio_convert)) { + error("could not add audio_convert"); + } + + if (!media_engine.pipeline.add(audio_resample)) { + error("could not add audio_resample"); + } + + if (!media_engine.pipeline.add(level)) { + error("could not add level"); + } + + if (!media_engine.pipeline.add(pan)) { + error("could not add pan"); + } + + if (!media_engine.pipeline.add(volume)) { + error("could not add volume"); + } + media_engine.level_changed.connect(on_level_changed); + level_changed.connect(track.on_level_changed); + } + + ~MediaAudioTrack() { + media_engine.level_changed.disconnect(on_level_changed); + media_engine.pipeline.remove_many(audio_convert, audio_resample, pan, volume, level); + } + + public signal void level_changed(double level_left, double level_right); + + void on_parameter_changed(Model.Parameter parameter, double new_value) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_parameter_changed"); + switch (parameter) { + case Model.Parameter.PAN: + pan.set_property("panorama", new_value); + break; + case Model.Parameter.VOLUME: + volume.set_property("volume", new_value); + break; + } + } + + void on_level_changed(Gst.Object source, double level_left, double level_right) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_level_changed"); + if (source == level) { + level_changed(level_left, level_right); + } + } + + protected override Gst.Element empty_element() throws Error { + return media_engine.get_audio_silence(); + } + + override void link_new_pad(Gst.Pad pad, Gst.Element track_element) { + Gst.Bin bin = (Gst.Bin) pad.get_parent_element(); + if (!bin.link_many(audio_convert, audio_resample, level, pan, volume)) { + stderr.printf("could not link_new_pad for audio track"); + } + + Gst.Pad volume_pad = volume.get_pad("src"); + adder_pad = track_element.request_new_pad( + track_element.get_compatible_pad_template(volume_pad.get_pad_template()), null); + + if (volume_pad.link(adder_pad) != Gst.PadLinkReturn.OK) { + error("could not link to adder %s->%s\n", volume.name, track_element.name); + } + } + + public override void unlink_pad(Gst.Pad pad, Gst.Element track_element) { + Gst.Bin bin = (Gst.Bin) pad.get_parent_element(); + bin.unlink_many(audio_convert, audio_resample, level, pan, volume, track_element); + track_element.release_request_pad(adder_pad); + } + + public override Gst.Element? get_element() { + return media_engine.adder; + } +} + +public abstract class MediaConnector : Object { + public enum MediaTypes { Audio = 1, Video = 2 } + MediaTypes media_types; + + // AudioIndex and VideoIndex are the order elements are passed in to connect and disconnect + protected int AudioIndex = 0; + protected int VideoIndex = 1; + + protected MediaConnector(MediaTypes media_types) { + this.media_types = media_types; + } + + protected bool has_audio() { + return (media_types & MediaTypes.Audio) == MediaTypes.Audio; + } + + protected bool has_video() { + return (media_types & MediaTypes.Video) == MediaTypes.Video; + } + + public new abstract void connect(MediaEngine media_engine, Gst.Pipeline pipeline, + Gst.Element[] elements); + public abstract void do_disconnect(MediaEngine media_engine, Gst.Pipeline pipeline, + Gst.Element[] elements); +} + +public class VideoOutput : MediaConnector { + Gst.Element sink; + Gtk.Widget output_widget; + + public VideoOutput(Gtk.Widget output_widget) throws Error { + base(MediaTypes.Video); + sink = make_element("xvimagesink"); + sink.set("force-aspect-ratio", true); + this.output_widget = output_widget; + } + + public override void connect(MediaEngine media_engine, Gst.Pipeline pipeline, + Gst.Element[] elements) { + emit(this, Facility.GRAPH, Level.INFO, "connecting"); + + X.ID xid = Gdk.x11_drawable_get_xid(output_widget.window); + Gst.XOverlay overlay = (Gst.XOverlay) sink; + overlay.set_xwindow_id(xid); + + // Once we've connected our video sink to a widget, it's best to turn off GTK + // double buffering for the widget; otherwise the video image flickers as it's resized. + output_widget.unset_flags(Gtk.WidgetFlags.DOUBLE_BUFFERED); + + if (!pipeline.add(sink)) { + error("could not add sink"); + } + if (!elements[VideoIndex].link(sink)) { + error("can't link converter with video sink!"); + } + } + + public override void do_disconnect(MediaEngine media_engine, Gst.Pipeline pipeline, + Gst.Element[] elements) { + emit(this, Facility.GRAPH, Level.INFO, "disconnecting"); + elements[VideoIndex].unlink(sink); + pipeline.remove(sink); + } +} + +public class AudioOutput : MediaConnector { + Gst.Element audio_sink; + Gst.Element capsfilter; + + public AudioOutput(Gst.Caps caps) throws Error { + base(MediaTypes.Audio); + audio_sink = make_element("autoaudiosink"); + capsfilter = make_element("capsfilter"); + capsfilter.set("caps", caps); + } + + public override void connect(MediaEngine media_engine, Gst.Pipeline pipeline, + Gst.Element[] elements) { + pipeline.add_many(capsfilter, audio_sink); + + if (!elements[AudioIndex].link_many(capsfilter, audio_sink)) { + warning("could not link audio_sink"); + } + } + + public override void do_disconnect(MediaEngine media_engine, Gst.Pipeline pipeline, + Gst.Element[] elements) { + elements[AudioIndex].unlink_many(capsfilter, audio_sink); + pipeline.remove_many(capsfilter, audio_sink); + } +} + +public class OggVorbisExport : MediaConnector { + Gst.Element capsfilter; + Gst.Element export_sink; + Gst.Element mux; + Gst.Element file_sink; + Gst.Element video_export_sink; + + public OggVorbisExport(MediaConnector.MediaTypes media_types, string filename, Gst.Caps caps) + throws Error { + base(media_types); + + file_sink = make_element("filesink"); + file_sink.set("location", filename); + mux = make_element("oggmux"); + + if (has_audio()) { + capsfilter = make_element("capsfilter"); + capsfilter.set("caps", caps); + export_sink = make_element("vorbisenc"); + } + + if (has_video()) { + video_export_sink = make_element("theoraenc"); + } + } + + public string get_filename() { + string filename; + file_sink.get("location", out filename); + return filename; + } + + public override void connect(MediaEngine media_engine, Gst.Pipeline pipeline, + Gst.Element[] elements) { + pipeline.add_many(mux, file_sink); + mux.link(file_sink); + + if (has_audio()) { + pipeline.add_many(capsfilter, export_sink); + elements[AudioIndex].link_many(capsfilter, export_sink, mux); + } + + if (has_video()) { + pipeline.add(video_export_sink); + + if (!elements[VideoIndex].link(video_export_sink)) { + error("could not link converter to video_export_sink"); + } + + if (!video_export_sink.link(mux)) { + error("could not link video_export with mux"); + } + } + } + + public override void do_disconnect(MediaEngine media_engine, Gst.Pipeline pipeline, + Gst.Element[] elements) { + if (has_audio()) { + elements[AudioIndex].unlink_many(capsfilter, export_sink, mux); + pipeline.remove_many(capsfilter, export_sink); + } + + if (has_video()) { + elements[VideoIndex].unlink_many(video_export_sink, mux); + pipeline.remove(video_export_sink); + } + + mux.unlink(file_sink); + pipeline.remove_many(mux, file_sink); + } +} + +public class MediaEngine : MultiFileProgressInterface, Object { + const string MIN_GNONLIN = "0.10.11"; + const string MIN_GST_PLUGINS_GOOD = "0.10.15"; + const string MIN_GST_PLUGINS_BASE = "0.10.15"; + public Gst.Pipeline pipeline; + public Gst.Bin record_bin; + // Video playback + public Gst.Element converter; + + // Audio playback + public Gst.Element adder; + + protected Gst.State gst_state; + protected PlayState play_state = PlayState.STOPPED; + public int64 position; // current play position in ns + uint callback_id; + public bool playing; + + public Model.AudioTrack record_track; + public Model.Clip record_region; + Gst.Element audio_in; + Gst.Element record_capsfilter; + Gst.Element wav_encoder; + Gst.Element record_sink; + + weak Model.Project project; + + public signal void playstate_changed(); + public signal void position_changed(int64 position); + public signal void pre_export(int64 length); + public signal void post_export(bool canceled); + public signal void callback_pulse(); + public signal void level_changed(Gst.Object source, double level_left, double level_right); + public signal void record_completed(); + public signal void link_for_playback(Gst.Element mux); + public signal void link_for_export(Gst.Element mux); + public signal void prepare_window(); + public signal void error_occurred(string major_message, string? minor_message); + + Gee.ArrayList tracks; + + public MediaEngine(Model.Project project, bool include_video) throws Error { + tracks = new Gee.ArrayList(); + this.project = project; + playstate_changed.connect(project.on_playstate_changed); + pipeline = new Gst.Pipeline("pipeline"); + pipeline.set_auto_flush_bus(false); + + if (include_video) { + converter = make_element("ffmpegcolorspace"); + pipeline.add(converter); + } + + Gst.Element silence = get_audio_silence(); + + adder = make_element("adder"); + + Gst.Element audio_convert = make_element_with_name("audioconvert", "projectconvert"); + pipeline.add_many(silence, audio_convert, adder); + + if (!silence.link_many(audio_convert, adder)) { + error("silence: couldn't link"); + } + + Gst.Bus bus = pipeline.get_bus(); + + bus.add_signal_watch(); + bus.message["error"] += on_error; + bus.message["warning"] += on_warning; + bus.message["eos"] += on_eos; + bus.message["state-changed"] += on_state_change; + bus.message["element"] += on_element; + } + + public static void can_run() throws Error { + Gst.Registry registry = Gst.Registry.get_default(); + check_version(registry, "adder", "gst-plugins-base", MIN_GST_PLUGINS_BASE); + check_version(registry, "level", "gst-plugins-good", MIN_GST_PLUGINS_GOOD); + check_version(registry, "gnonlin", "gnonlin", View.MediaEngine.MIN_GNONLIN); + } + + static void check_version(Gst.Registry registry, string plugin_name, + string package_name, string min_version) throws Error { + Gst.Plugin plugin = registry.find_plugin(plugin_name); + if (plugin == null) { + throw new MediaError.MISSING_PLUGIN( + "You must install %s to use this program".printf(package_name)); + } + + string version = plugin.get_version(); + if (!version_at_least(version, min_version)) { + throw new MediaError.MISSING_PLUGIN( + "You have %s version %s, but this program requires at least version %s".printf( + package_name, version, min_version)); + } + } + + public void connect_output(MediaConnector connector) { + connector.connect(this, pipeline, { adder, converter }); + } + + public void disconnect_output(MediaConnector connector) { + pipeline.seek_simple(Gst.Format.TIME, Gst.SeekFlags.FLUSH, 0); + pipeline.set_state(Gst.State.NULL); + connector.do_disconnect(this, pipeline, {adder, converter}); + } + + public Gst.Element get_audio_silence() throws Error { + Gst.Element silence = make_element("audiotestsrc"); + silence.set("wave", 4); // 4 is silence + Gst.Caps audio_cap = get_project_audio_caps(); + foreach (Gst.Pad pad in silence.pads) { + pad.set_caps(audio_cap); + } + return silence; + } + + public int get_sample_rate() { + return 48000; + } + + public int get_sample_width() { + return 16; + } + + public int get_sample_depth() { + return 16; + } + + public PlayState get_play_state() { + return play_state; + } + + public void set_play_state(PlayState play_state) { + this.play_state = play_state; + } + + protected Gst.Caps build_audio_caps(int num_channels) { + string caps = "audio/x-raw-int,rate=%d,channels=%d,width=%d,depth=%d"; + caps = caps.printf(get_sample_rate(), num_channels, get_sample_width(), get_sample_depth()); + return Gst.Caps.from_string(caps); + } + + public Gst.Caps get_project_audio_caps() { + return build_audio_caps(CHANNELS_PER_TRACK_PLAYBACK); + } + + public Gst.Caps get_project_audio_export_caps() { + return Gst.Caps.from_string( + "audio/x-raw-float,rate=48000,channels=2,width=32"); + } + + void on_warning(Gst.Bus bus, Gst.Message message) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_warning"); + Error error; + string text; + message.parse_warning(out error, out text); + warning("%s", text); + } + + void on_error(Gst.Bus bus, Gst.Message message) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_error"); + Error error; + string text; + message.parse_error(out error, out text); + warning("%s", text); + project.print_graph(pipeline, "bus_error"); + } + + void on_eos(Gst.Bus bus, Gst.Message message) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_eos"); + if (play_state == PlayState.EXPORTING) + pipeline.set_state(Gst.State.NULL); + } + + void on_element(Gst.Bus bus, Gst.Message message) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_element"); + unowned Gst.Structure structure = message.get_structure(); + + if (play_state == PlayState.PLAYING && structure.get_name().to_string() == "level") { + Gst.Value? rms = structure.get_value("rms"); + uint size = rms.list_get_size(); + Gst.Value? temp = rms.list_get_value(0); + double level_left = temp.get_double(); + double level_right = level_left; + + if (size > 1) { + temp = rms.list_get_value(1); + level_right = temp.get_double(); + } + level_changed(message.src, level_left, level_right); + } + } + + void on_state_change(Gst.Bus bus, Gst.Message message) { + if (message.src != pipeline) { + emit(this, Facility.GRAPH, Level.VERBOSE, + "on_state_change returning. message from %s".printf(message.src.get_name())); + return; + } + + Gst.State old_state; + Gst.State new_state; + Gst.State pending; + + message.parse_state_changed(out old_state, out new_state, out pending); + + emit(this, Facility.GRAPH, Level.INFO, + "on_state_change old(%s) new(%s) pending(%s)".printf(old_state.to_string(), + new_state.to_string(), pending.to_string())); + if (new_state == gst_state) + return; + + gst_state = new_state; + do_state_change(); + } + + protected bool do_state_change() { + playstate_changed(); + switch (play_state) { + case PlayState.STOPPED: + if (gst_state != Gst.State.PAUSED) { + pipeline.set_state(Gst.State.PAUSED); + } else { + go(position); + } + return true; + case PlayState.PRE_EXPORT: + if (gst_state != Gst.State.PAUSED) { + return false; + } + do_paused_state_export(); + return true; + case PlayState.EXPORTING: + if (gst_state != Gst.State.NULL) + return false; + end_export(false); + return true; + case PlayState.CANCEL_EXPORT: + if (gst_state != Gst.State.NULL) + return false; + end_export(true); + return true; + case PlayState.CLOSING: + close(); + return true; + case PlayState.PRE_RECORD_NULL: + if (gst_state == Gst.State.NULL) { + try { + start_record(record_region); + } catch (GLib.Error error) { + error_occurred("An error occurred starting the recording.", null); + warning("An error occurred starting the recording: %s", error.message); + } + return true; + } + break; + case PlayState.PRE_RECORD: + if (gst_state == Gst.State.PAUSED) { + do_play(PlayState.RECORDING); + return true; + } + break; + case PlayState.POST_RECORD: + if (gst_state != Gst.State.NULL) { + set_gst_state(Gst.State.NULL); + } else { + post_record(); + set_gst_state(Gst.State.PAUSED); + play_state = PlayState.STOPPED; + } + return true; + } + return false; + } + + protected virtual void do_null_state_export(int64 length) { + pre_export(length); + play_state = PlayState.PRE_EXPORT; + pipeline.set_state(Gst.State.PAUSED); + } + + void do_paused_state_export() { + play_state = PlayState.EXPORTING; + + if (callback_id == 0) + callback_id = Timeout.add(50, on_callback); + pipeline.set_state(Gst.State.PLAYING); + } + + void end_export(bool deleted) { + play_state = PlayState.STOPPED; + + callback_id = 0; + post_export(deleted); + } + + public void go(int64 pos) { + if (position == pos) { + pipeline.seek_simple(Gst.Format.TIME, Gst.SeekFlags.FLUSH, position); + return; + } + if (pos < 0) + position = 0; + else + position = pos; + + // We ignore the return value of seek_simple(); sometimes it returns false even when + // a seek succeeds. + pipeline.seek_simple(Gst.Format.TIME, Gst.SeekFlags.FLUSH, position); + position_changed(position); + } + + bool on_callback() { + if ((play_state == PlayState.STOPPED && !playing) || + (play_state == PlayState.POST_RECORD)) { + callback_id = 0; + return false; + } + + Gst.Format format = Gst.Format.TIME; + int64 time = 0; + if (pipeline.query_position(ref format, out time) && format == Gst.Format.TIME) { + position = time; + callback_pulse(); + + if (play_state == PlayState.PLAYING) { + if (position >= project.get_length()) { + go(project.get_length()); + pause(); + } + position_changed(time); + } else if (play_state == PlayState.EXPORTING) { + if (time > project.get_length()) { + fraction_updated(1.0); + } + else + fraction_updated(time / (double) project.get_length()); + } else if (play_state == PlayState.RECORDING) { + position_changed(time); + } + } + return true; + } + + public virtual void pause() { + if (project.transport_is_recording()) { + record_bin.send_event(new Gst.Event.eos()); + play_state = PlayState.POST_RECORD; + } else { + if (!playing) { + return; + } + play_state = PlayState.STOPPED; + } + set_gst_state(Gst.State.PAUSED); + playing = false; + } + + // TODO: don't expose Gst.State + public void set_gst_state(Gst.State state) { + if (pipeline.set_state(state) == Gst.StateChangeReturn.FAILURE) + error("can't set state"); + } + + void seek(Gst.SeekFlags flags, int64 pos) { + // We do *not* check the return value of seek_simple here: it will often + // be false when seeking into a GnlSource which we have not yet played, + // even though the seek appears to work fine in that case. + pipeline.seek_simple(Gst.Format.TIME, flags, pos); + } + + public void do_play(PlayState new_state) { + seek(Gst.SeekFlags.FLUSH, position); + play_state = new_state; + play(); + } + + void play() { + if (playing) + return; + + set_gst_state(Gst.State.PLAYING); + if (callback_id == 0) + callback_id = Timeout.add(50, on_callback); + playing = true; + } + + public void start_export(string filename) { + file_updated(filename, 0); + do_null_state_export(project.get_length()); + } + + void cancel() { + play_state = PlayState.CANCEL_EXPORT; + pipeline.set_state(Gst.State.NULL); + } + + public void complete() { + pipeline.set_state(Gst.State.NULL); + } + + public void on_load_complete() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_load_complete"); + play_state = PlayState.STOPPED; + pipeline.set_state(Gst.State.PAUSED); + } + + public void on_callback_pulse() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_callback_pulse"); + if (record_region != null) { + record_region.duration = position - record_region.start; + } + } + + public void close() { + if (gst_state != Gst.State.NULL) { + play_state = PlayState.CLOSING; + set_gst_state(Gst.State.NULL); + } else { + play_state = PlayState.CLOSED; + } + playstate_changed(); + } + + public void post_record() { + assert(gst_state == Gst.State.NULL); + + record_track._delete_clip(record_region); + + audio_in.unlink_many(record_capsfilter, wav_encoder, record_sink); + record_bin.remove_many(audio_in, record_capsfilter, wav_encoder, record_sink); + pipeline.remove(record_bin); + record_completed(); + record_bin = null; + record_region = null; + record_track = null; + audio_in = record_capsfilter = null; + wav_encoder = record_sink = null; + set_gst_state(Gst.State.PAUSED); + } + + public void record(Model.AudioTrack track) { + assert(gst_state != Gst.State.NULL); + play_state = PlayState.PRE_RECORD_NULL; + set_gst_state(Gst.State.NULL); + record_track = track; + + string filename = new_audio_filename(track); + Model.ClipFile clip_file = new Model.ClipFile(filename); + record_region = new Model.Clip(clip_file, Model.MediaType.AUDIO, "", position, 0, 1, true); + } + + public void start_record(Model.Clip region) throws Error { + if (project.transport_is_recording()) + return; + + if (project.transport_is_playing()) + error("can't switch from playing to recording"); + + if (gst_state != Gst.State.NULL) + error("can't record now: %s", gst_state.to_string()); + record_bin = new Gst.Bin("recordingbin"); + record_track._move(record_region, position); + record_track.clip_added(record_region, true); + audio_in = make_element("pulsesrc"); + audio_in.set_property("device", "source.hw0"); /// TODO + record_capsfilter = make_element("capsfilter"); + record_capsfilter.set("caps", get_record_audio_caps()); + record_sink = make_element("filesink"); + record_sink.set("location", record_region.clipfile.filename); + wav_encoder = make_element("wavenc"); + + record_bin.add_many(audio_in, record_capsfilter, wav_encoder, record_sink); + if (!audio_in.link_many(record_capsfilter, wav_encoder, record_sink)) + error("audio_in: couldn't link"); + pipeline.add(record_bin); + + play_state = PlayState.PRE_RECORD; + set_gst_state(Gst.State.PAUSED); // we must advance to PAUSED before we can seek + } + + protected Gst.Caps get_record_audio_caps() { + return build_audio_caps(CHANNELS_PER_TRACK_RECORD); + } + + string new_audio_filename(Model.Track track) { + int i = 1; + string base_path = project.get_audio_path(); + GLib.DirUtils.create(base_path, 0777); + string base_name = Path.build_filename(base_path, generate_base(track.display_name)); + while (true) { + string name = "%s_%d.wav".printf(base_name, i); + if (!FileUtils.test(name, FileTest.EXISTS)) { + return name; + } + ++i; + } + } + + string generate_base(string name) { + string base_name = name.down(); + base_name.canon("abcdefghijklmnopqrstuvwxyz1234567890", '_'); + return base_name; + } + + public void on_track_added(Model.Track track) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_track_added"); + MediaTrack? media_track = null; + try { + switch (track.media_type()) { + case Model.MediaType.AUDIO: + media_track = create_audio_track(track); + break; + case Model.MediaType.VIDEO: + media_track = new MediaVideoTrack(this, track, converter); + break; + } + } catch(GLib.Error error) { + error_occurred("An error occurred adding the track.", null); + warning("An error occurred adding the track: %s", error.message); + return; + } + + media_track.track_removed.connect(on_track_removed); + media_track.error_occurred.connect(on_error_occurred); + + tracks.add(media_track); + } + + MediaTrack create_audio_track(Model.Track track) throws Error { + Model.AudioTrack? model_track = track as Model.AudioTrack; + MediaAudioTrack? audio_track = null; + if (model_track != null) { + audio_track = new MediaAudioTrack(this, model_track); + } else { + assert(false); + } + return audio_track; + } + + void on_track_removed(MediaTrack track) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_track_removed"); + tracks.remove(track); + } + + void on_error_occurred(string major_message, string? minor_message) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_error_occurred"); + error_occurred(major_message, minor_message); + } +} +} diff --git a/src/marina/MultiFileProgress.vala b/src/marina/MultiFileProgress.vala new file mode 100644 index 0000000..a44e733 --- /dev/null +++ b/src/marina/MultiFileProgress.vala @@ -0,0 +1,112 @@ +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +using Logging; + +public interface MultiFileProgressInterface : Object { + public signal void fraction_updated(double d); + public signal void file_updated(string filename, int index); + public signal void done(); + + public abstract void cancel(); + public abstract void complete(); +} + +public class MultiFileProgress : Gtk.Window { + Gtk.ProgressBar progress_bar; + Gtk.Label file_label; + Gtk.Label number_label; + Gtk.Button cancel_button; + int num_files; + bool needs_show; + + MultiFileProgressInterface provider_interface; + + string dialog_title; + + public MultiFileProgress(Gtk.Window parent, int num_files, + string dialog_title, MultiFileProgressInterface provider) { + this.num_files = num_files; + needs_show = true; + file_label = new Gtk.Label(""); + number_label = new Gtk.Label(""); + progress_bar = new Gtk.ProgressBar(); + + Gtk.VBox vbox = new Gtk.VBox(true, 0); + + vbox.pack_start(number_label, false, false, 0); + vbox.pack_start(file_label, false, false, 0); + vbox.pack_start(progress_bar, false, false, 0); + + Gtk.HButtonBox button_area = new Gtk.HButtonBox(); + button_area.set("layout-style", Gtk.ButtonBoxStyle.CENTER); + + cancel_button = new Gtk.Button.from_stock(Gtk.STOCK_CANCEL); + cancel_button.clicked.connect(on_cancel_clicked); + + button_area.add(cancel_button); + + vbox.pack_start(button_area, false, false, 0); + add(vbox); + + set_transient_for(parent); + set_title(dialog_title); + this.dialog_title = dialog_title; + + provider_interface = provider; + + provider_interface.fraction_updated.connect(on_fraction_updated); + provider_interface.file_updated.connect(on_file_updated); + provider_interface.done.connect(on_done); + } + + void on_done() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_done"); + destroy(); + } + + void on_cancel_clicked() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_cancel_clicked"); + destroy(); + } + + void on_destroy() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_destroy"); + if (progress_bar.get_fraction() < 1.0) + provider_interface.cancel(); + else + provider_interface.complete(); + } + + void on_fraction_updated(double d) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_fraction_updated"); + if (needs_show) { + needs_show = false; + set_border_width(8); + set_resizable(false); + set_modal(true); + + destroy.connect(on_destroy); + + show_all(); + } + + progress_bar.set_fraction(d); + + if (progress_bar.get_fraction() == 1.0) + destroy(); + else { + show_all(); + queue_draw(); + } + } + + void on_file_updated(string filename, int index) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_file_updated"); + number_label.set_text("%sing %d of %d".printf(dialog_title, index + 1, num_files)); + file_label.set_text("%s".printf(filename)); + } +} diff --git a/src/marina/ProjectLoader.vala b/src/marina/ProjectLoader.vala new file mode 100644 index 0000000..7a9ffdf --- /dev/null +++ b/src/marina/ProjectLoader.vala @@ -0,0 +1,353 @@ +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +using Logging; + +namespace Model { + +public class LoaderHandler : Object { + public signal void load_error(string error_message); + public signal void complete(); + + public LoaderHandler() { + } + + public virtual bool commit_library(string[] attr_names, string[] attr_values) { + return true; + } + + public virtual bool commit_marina(string[] attr_names, string[] attr_values) { + return true; + } + + public virtual bool commit_track(string[] attr_names, string[] attr_values) { + return true; + } + + public virtual bool commit_clip(string[] attr_names, string[] attr_values) { + return true; + } + + public virtual bool commit_clipfile(string[] attr_names, string[] attr_values) { + return true; + } + + public virtual bool commit_time_signature_entry(string[] attr_names, string[] attr_values) { + return true; + } + + public virtual bool commit_tempo_entry(string[] attr_names, string[] attr_values) { + return true; + } + + public virtual bool commit_click(string[] attr_names, string[] attr_values) { + return true; + } + + public virtual bool commit_library_preference(string[] attr_names, string[] attr_values) { + return true; + } + + public virtual void leave_library() { + } + + public virtual void leave_marina() { + } + + public virtual void leave_track() { + } + + public virtual void leave_clip() { + } + + public virtual void leave_clipfile() { + + } +} + +// TODO: Move these classes into separate file +public class XmlTreeLoader { + XmlElement current_element = null; + public XmlElement root = null; + + public XmlTreeLoader(string document) { + MarkupParser parser = { xml_start_element, xml_end_element, null, null }; + MarkupParseContext context = + new MarkupParseContext(parser, (MarkupParseFlags) 0, this, null); + try { + context.parse(document, document.length); + } catch (MarkupError e) { + } + + } + + void xml_start_element(GLib.MarkupParseContext c, string name, + string[] attr_names, string[] attr_values) { + Model.XmlElement new_element = new Model.XmlElement(name, attr_names, attr_values, current_element); + if (root == null) { + root = new_element; + } else { + assert(current_element != null); + current_element.add_child(new_element); + } + + current_element = new_element; + } + + void xml_end_element(GLib.MarkupParseContext c, string name) { + assert(current_element != null); + current_element = current_element.parent; + } +} + +// ProjectBuilder is responsible for verifying the structure of the XML document. +// Subclasses of this class will be responsible for checking the attributes of +// any particular element. +class ProjectBuilder : Object { + LoaderHandler handler; + + public signal void error_occurred(string error); + + public ProjectBuilder(LoaderHandler handler) { + this.handler = handler; + } + + bool check_name(string expected_name, XmlElement node) { + if (node.name == expected_name) { + return true; + } + + error_occurred("expected %s, got %s".printf(expected_name, node.name)); + return false; + } + + void handle_clip(XmlElement clip) { + if (check_name("clip", clip)) { + if (handler.commit_clip(clip.attribute_names, clip.attribute_values)) { + if (clip.children.size != 0) { + error_occurred("clip cannot have children"); + } + handler.leave_clip(); + } + } + } + + void handle_track(XmlElement track) { + if (check_name("track", track)) { + emit(this, Facility.LOADING, Level.VERBOSE, "loading track"); + if (handler.commit_track(track.attribute_names, track.attribute_values)) { + foreach (XmlElement child in track.children) { + handle_clip(child); + } + handler.leave_track(); + } + } + } + + void handle_preference(XmlElement preference) { + if ("click" == preference.name) { + handler.commit_click(preference.attribute_names, preference.attribute_values); + } else if ("library" == preference.name) { + handler.commit_library_preference( + preference.attribute_names, preference.attribute_values); + } else { + error_occurred("Unknown preference: %s".printf(preference.name)); + } + } + + void handle_time_signature(XmlElement time_signature) { + foreach (XmlElement child in time_signature.children) { + if (check_name("entry", child)) { + if (!handler.commit_time_signature_entry(child.attribute_names, + child.attribute_values)) { + error_occurred("Improper time signature node"); + } + } + } + } + + void handle_tempo(XmlElement tempo) { + foreach (XmlElement child in tempo.children) { + if (check_name("entry", child)) { + if (!handler.commit_tempo_entry(child.attribute_names, child.attribute_values)) { + error_occurred("Improper tempo node"); + } + } + } + } + + void handle_map(XmlElement map) { + switch (map.name) { + case "tempo": + handle_tempo(map); + break; + case "time_signature": + handle_time_signature(map); + break; + default: + error_occurred("improper map node"); + break; + } + } + + void handle_library(XmlElement library) { + if (handler.commit_library(library.attribute_names, library.attribute_values)) { + foreach (XmlElement child in library.children) { + if (!handler.commit_clipfile(child.attribute_names, child.attribute_values)) + error_occurred("Improper library node"); + } + handler.leave_library(); + } + } + + void handle_tracks(XmlElement tracks) { + foreach (XmlElement child in tracks.children) { + handle_track(child); + } + } + + void handle_preferences(XmlElement preferences) { + foreach (XmlElement child in preferences.children) { + handle_preference(child); + } + } + void handle_maps(XmlElement maps) { + foreach (XmlElement child in maps.children) { + handle_map(child); + } + } + public bool check_project(XmlElement? root) { + if (root == null) { + error_occurred("Invalid XML file!"); + return false; + } + + if (check_name("marina", root) && + handler.commit_marina(root.attribute_names, root.attribute_values)) { + if (root.children.size != 3 && root.children.size != 4) { + error_occurred("Improper number of children!"); + return false; + } + + if (!check_name("library", root.children[0]) || + !check_name("tracks", root.children[1]) || + !check_name("preferences", root.children[2])) + return false; + + if (root.children.size == 4 && !check_name("maps", root.children[3])) { + return false; + } + } else + return false; + return true; + } + + public void build_project(XmlElement? root) { + handle_library(root.children[0]); + handle_tracks(root.children[1]); + handle_preferences(root.children[2]); + if (root.children.size == 4) { + handle_maps(root.children[3]); + } + + handler.leave_marina(); + } +} + +public class XmlElement { + public string name { get; private set; } + + public string[] attribute_names; + + public string[] attribute_values; + + public Gee.ArrayList children { get { return _children; } } + + public weak XmlElement? parent { get; private set; } + + private Gee.ArrayList _children; + public XmlElement(string name, string[] attribute_names, string[] attribute_values, + XmlElement? parent) { + this.name = name; + + this.attribute_names = copy_array(attribute_names); + this.attribute_values = copy_array(attribute_values); + this.parent = parent; + this._children = new Gee.ArrayList(); + } + + public void add_child(XmlElement child_element) { + _children.add(child_element); + } +} + +public class ProjectLoader : Object { + string? file_name; + LoaderHandler loader_handler; + string text; + size_t text_len; + bool project_load_completed = false; + bool load_completed_fired = false; + bool handler_completed = false; + + public signal void load_started(string filename); + public signal void load_complete(); + public signal void load_error(string error); + + public ProjectLoader(LoaderHandler loader_handler, string? file_name) { + this.file_name = file_name; + this.loader_handler = loader_handler; + loader_handler.load_error.connect(on_load_error); + loader_handler.complete.connect(on_handler_complete); + } + + void on_load_error(string error) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_load_error"); + load_error(error); + } + + void on_handler_complete() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_handler_complete"); + handler_completed = true; + if (project_load_completed && !load_completed_fired) { + load_completed_fired = true; + load_complete(); + } + } + + public void load() { + try { + FileUtils.get_contents(file_name, out text, out text_len); + } catch (FileError e) { + emit(this, Facility.LOADING, Level.MEDIUM, + "error loading %s: %s".printf(file_name, e.message)); + load_error(e.message); + load_complete(); + return; + } + emit(this, Facility.LOADING, Level.VERBOSE, "Building tree for %s".printf(file_name)); + XmlTreeLoader tree_loader = new XmlTreeLoader(text); + + ProjectBuilder builder = new ProjectBuilder(loader_handler); + builder.error_occurred.connect(on_load_error); + + if (builder.check_project(tree_loader.root)) { + emit(this, Facility.LOADING, Level.VERBOSE, "project checked out. starting load"); + load_started(file_name); + builder.build_project(tree_loader.root); + project_load_completed = true; + if (handler_completed && !load_completed_fired) { + load_completed_fired = true; + load_complete(); + } + } + else { + emit(this, Facility.LOADING, Level.INFO, "project did not check out. stopping."); + load_complete(); + } + } +} +} diff --git a/src/marina/Ruler.vala b/src/marina/Ruler.vala new file mode 100644 index 0000000..9bd0477 --- /dev/null +++ b/src/marina/Ruler.vala @@ -0,0 +1,80 @@ +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +namespace View { +public class Ruler : Gtk.DrawingArea { + weak Model.TimeSystem provider; + const int BORDER = 4; + + public signal void position_changed(int x); + + public Ruler(Model.TimeSystem provider, int height) { + this.provider = provider; + set_flags(Gtk.WidgetFlags.NO_WINDOW); + set_size_request(0, height); + } + + public override bool expose_event(Gdk.EventExpose event) { + int x = event.area.x; + int frame = provider.get_start_token(x); + + Cairo.Context context = Gdk.cairo_create(window); + + Gdk.cairo_set_source_color(context, parse_color("#777")); + context.rectangle(event.area.x, event.area.y, event.area.width, event.area.height); + context.fill(); + + Cairo.Antialias old_antialias = context.get_antialias(); + + context.set_antialias(Cairo.Antialias.NONE); + context.set_source_rgb(1.0, 1.0, 1.0); + int stop = event.area.x + event.area.width; + Pango.FontDescription f = Pango.FontDescription.from_string("Sans 9"); + while (x <= stop) { + x = provider.frame_to_xsize(frame); + int y = provider.get_pixel_height(frame); + + context.move_to(x + BORDER, 0); + context.line_to(x + BORDER, y); + + string? display_string = provider.get_display_string(frame); + if (display_string != null) { + Pango.Layout layout = create_pango_layout(display_string); + + int w; + int h; + layout.set_font_description(f); + layout.get_pixel_size (out w, out h); + int text_pos = x - (w / 2) + BORDER; + if (text_pos < 0) { + text_pos = 0; + } + + Gdk.draw_layout(window, style.white_gc, text_pos, 7, layout); + } + + frame = provider.get_next_position(frame); + } + context.set_antialias(old_antialias); + context.set_line_width(1.0); + context.stroke(); + return true; + } + + public override bool button_press_event(Gdk.EventButton event) { + position_changed((int) event.x); + return false; + } + + public override bool motion_notify_event(Gdk.EventMotion event) { + if ((event.state & Gdk.ModifierType.BUTTON1_MASK) != 0) { + queue_draw(); + position_changed((int) event.x); + } + return false; + } +} +} diff --git a/src/marina/StatusBar.vala b/src/marina/StatusBar.vala new file mode 100644 index 0000000..4e29c83 --- /dev/null +++ b/src/marina/StatusBar.vala @@ -0,0 +1,41 @@ +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +using Logging; + +namespace View { +public class StatusBar : Gtk.DrawingArea { + Model.TimeSystem provider; + int64 current_position = 0; + + public StatusBar(Model.Project p, Model.TimeSystem provider, int height) { + set_flags(Gtk.WidgetFlags.NO_WINDOW); + modify_bg(Gtk.StateType.NORMAL, parse_color("#666")); + set_size_request(0, height); + + p.media_engine.position_changed.connect(on_position_changed); + this.provider = provider; + } + + public void on_position_changed(int64 new_position) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_position_changed"); + current_position = new_position; + queue_draw(); + } + + public override bool expose_event(Gdk.EventExpose e) { + window.draw_rectangle(style.bg_gc[(int) Gtk.StateType.NORMAL], true, + allocation.x, allocation.y, allocation.width, allocation.height); + + string time = provider.get_time_string(current_position); + + Pango.Layout layout = create_pango_layout(time); + Gdk.draw_layout(window, style.white_gc, allocation.x + 4, allocation.y + 2, layout); + + return true; + } +} +} diff --git a/src/marina/TimeSystem.vala b/src/marina/TimeSystem.vala new file mode 100644 index 0000000..77a4411 --- /dev/null +++ b/src/marina/TimeSystem.vala @@ -0,0 +1,406 @@ +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +namespace Model { +using Logging; + +public interface TimeSystem : Object { + public signal void geometry_changed(); + public abstract void calculate_pixel_step(float inc, float pixel_min, float pixel_div); + public abstract int64 xpos_to_time(int x); + public abstract int64 xsize_to_time(int x); + public abstract int time_to_xpos(int64 time); + public abstract int64 get_pixel_snap_time(); + public abstract int time_to_xsize(int64 time); + public abstract float get_pixel_percentage(); + public abstract int get_start_token(int xsize); + public abstract int get_next_position(int token); + public abstract int get_pixel_height(int token); + public abstract string? get_display_string(int token); + public abstract int frame_to_xsize(int frame); + public abstract int xsize_to_frame(int xsize); + public abstract string get_time_string(int64 time); + public abstract string get_time_duration(int64 time); +} + +public abstract class TimeSystemBase : Object { + public const int PIXEL_SNAP_INTERVAL = 10; + + public float pixel_percentage = 0.0f; + public float pixels_per_second; + public int64 pixel_snap_time; + + const int BORDER = 4; // TODO: should use same value as timeline. will happen when this gets + // refactored back into view code. + + abstract int[] get_timeline_seconds(); + abstract int correct_sub_second_value(float seconds, int div, int fps); + + protected int correct_seconds_value (float seconds, int div, int fps) { + if (seconds < 1.0f) { + return correct_sub_second_value(seconds, div, fps); + } + + int i; + int secs = (int) seconds; + int [] timeline_seconds = get_timeline_seconds(); + for (i = timeline_seconds.length - 1; i > 0; i--) { + if (secs <= timeline_seconds[i] && + secs >= timeline_seconds[i - 1]) { + if ((div % (timeline_seconds[i] * fps)) == 0) { + break; + } + if ((div % (timeline_seconds[i - 1] * fps)) == 0) { + i--; + break; + } + } + } + return timeline_seconds[i] * fps; + } + + public int64 get_pixel_snap_time() { + return pixel_snap_time; + } + + public float get_pixel_percentage() { + return pixel_percentage; + } + + public int64 xpos_to_time(int x) { + return xsize_to_time(x - BORDER); + } + + public int64 xsize_to_time(int size) { + return (int64) ((float)(size * Gst.SECOND) / pixels_per_second); + } + + public int time_to_xsize(int64 time) { + return (int) (time * pixels_per_second / Gst.SECOND); + } + + public int time_to_xpos(int64 time) { + int pos = time_to_xsize(time) + BORDER; + + if (xpos_to_time(pos) != time) + pos++; + return pos; + } +} + +public class TimecodeTimeSystem : TimeSystem, TimeSystemBase { + float pixels_per_frame; + + int small_pixel_frames = 0; + int medium_pixel_frames = 0; + int large_pixel_frames = 0; + + public Fraction frame_rate_fraction = Fraction(30000, 1001); + + override int correct_sub_second_value(float seconds, int div, int fps) { + int frames = (int)(fps * seconds); + if (frames == 0) { + return 1; + } + + if (div == 0) { + div = fps; + } + + int mod = div % frames; + while (mod != 0) { + mod = div % (++frames); + } + return frames; + } + + public string get_time_string(int64 the_time) { + string time; + + int frame = time_to_frame_with_rate(the_time, frame_rate_fraction); + time = frame_to_string(frame, frame_rate_fraction); + + return time; + } + + public string get_time_duration(int64 the_time) { + // Timecode is already zero-based + return get_time_string(the_time); + } + public void calculate_pixel_step(float inc, float pixel_min, float pixel_div) { + int pixels_per_large = 300; + int pixels_per_medium = 50; + int pixels_per_small = 20; + + pixel_percentage += inc; + if (pixel_percentage < 0.0f) + pixel_percentage = 0.0f; + else if (pixel_percentage > 1.0f) + pixel_percentage = 1.0f; + + pixels_per_second = pixel_min * GLib.Math.powf(pixel_div, pixel_percentage); + int fps = frame_rate_fraction.nearest_int(); + large_pixel_frames = correct_seconds_value(pixels_per_large / pixels_per_second, 0, fps); + medium_pixel_frames = correct_seconds_value(pixels_per_medium / pixels_per_second, + large_pixel_frames, fps); + small_pixel_frames = correct_seconds_value(pixels_per_small / pixels_per_second, + medium_pixel_frames, fps); + + if (small_pixel_frames == medium_pixel_frames) { + int i = medium_pixel_frames; + + while (--i > 0) { + if ((medium_pixel_frames % i) == 0) { + small_pixel_frames = i; + break; + } + } + } + + pixels_per_frame = pixels_per_second / (float) fps; + pixel_snap_time = xsize_to_time(PIXEL_SNAP_INTERVAL); + } + + public int frame_to_xsize(int frame) { + return ((int) (frame * pixels_per_frame)); + } + + public int xsize_to_frame(int xsize) { + return (int) (xsize / pixels_per_frame); + } + + public int get_start_token(int xsize) { + int start_frame = xsize_to_frame(xsize); + return large_pixel_frames * (start_frame / large_pixel_frames); + } + + public int get_next_position(int token) { + return token + small_pixel_frames; + } + + public string? get_display_string(int frame) { + if ((frame % large_pixel_frames) == 0) { + return frame_to_time(frame, frame_rate_fraction).to_string(); + } + return null; + } + + public int get_pixel_height(int frame) { + if ((frame % medium_pixel_frames) == 0) { + if (medium_pixel_frames == small_pixel_frames && + (medium_pixel_frames != large_pixel_frames && + frame % large_pixel_frames != 0)) { + return 2; + } + else { + return 6; + } + } else { + return 2; + } + } + + override int[] get_timeline_seconds() { + return { 1, 2, 5, 10, 15, 20, 30, 60, 120, 300, 600, 900, 1200, 1800, 3600 }; + } +} + +public interface TempoInformation { + public abstract Fraction get_time_signature(); + public abstract int get_bpm(); + public signal void time_signature_changed(Fraction time_signature); + public signal void bpm_changed(int bpm); +} + +public class BarBeatTimeSystem : TimeSystem, TimeSystemBase { + float pixels_per_sixteenth; + + int small_pixel_sixteenth = 0; + int medium_pixel_sixteenth = 0; + int large_pixel_sixteenth = 0; + int[] timeline_bars = { + 1, 2, 4, 8, 16, 24, 32, 64, 128, 256, 512, 768, 1024, 2048, 3192 + }; + + int bpm; + Fraction time_signature; + float bars_per_minute; + float bars_per_second; + int sixteenths_per_bar; + int sixteenths_per_beat; + + public BarBeatTimeSystem(TempoInformation tempo_information) { + bpm = tempo_information.get_bpm(); + time_signature = tempo_information.get_time_signature(); + tempo_information.bpm_changed.connect(on_bpm_changed); + tempo_information.time_signature_changed.connect(on_time_signature_changed); + set_constants(); + } + + void on_time_signature_changed(Fraction time_signature) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_time_signature_changed"); + this.time_signature = time_signature; + set_constants(); + } + + void on_bpm_changed(int bpm) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_bpm_changed"); + this.bpm = bpm; + set_constants(); + } + + void set_constants() { + bars_per_minute = bpm / (float)time_signature.numerator; + bars_per_second = bars_per_minute / 60.0f; + + sixteenths_per_beat = 16 / time_signature.denominator; + sixteenths_per_bar = time_signature.numerator * sixteenths_per_beat; + geometry_changed(); + } + + override int correct_sub_second_value(float bars, int div, int unused) { + int sixteenths = (int)(sixteenths_per_bar * bars); + + if (sixteenths == 0) { + return 1; + } + + if (sixteenths > sixteenths_per_beat) { + return sixteenths_per_beat; + } + + if (sixteenths > 2) { + return 2; + } + + return 1; + } + + string beats_to_string(int total_sixteenths, bool maximum_resolution, bool zero_based) { + int number_of_measures = + (total_sixteenths / sixteenths_per_beat) / time_signature.numerator; + + int number_of_beats = + (total_sixteenths / sixteenths_per_beat) % time_signature.numerator; + int number_of_sixteenths = total_sixteenths % sixteenths_per_beat; + if (!zero_based) { + ++number_of_measures; + ++number_of_beats; + ++number_of_sixteenths; + } + float pixels_per_bar = pixels_per_second / bars_per_second; + float pixels_per_large_gap = large_pixel_sixteenth * pixels_per_sixteenth; + if (maximum_resolution || + ((pixels_per_large_gap < pixels_per_sixteenth * sixteenths_per_beat) && + number_of_sixteenths > 1)) { + return "%d.%d.%d".printf(number_of_measures, number_of_beats, number_of_sixteenths); + } else if (pixels_per_large_gap < pixels_per_bar && number_of_beats > 1) { + return "%d.%d".printf(number_of_measures, number_of_beats); + } else { + return "%d".printf(number_of_measures); + } + } + + public string get_time_string(int64 the_time) { + double beats_per_second = bpm / 60.0; + double sixteenths_per_second = sixteenths_per_beat * beats_per_second; + double sixteenths_per_nanosecond = sixteenths_per_second / Gst.SECOND; + int total_beats = (int)(the_time * sixteenths_per_nanosecond); + return beats_to_string(total_beats, true, false); + } + + public string get_time_duration(int64 the_time) { + double beats_per_second = bpm / 60.0; + double sixteenths_per_second = sixteenths_per_beat * beats_per_second; + double sixteenths_per_nanosecond = sixteenths_per_second / Gst.SECOND; + int total_beats = (int)(the_time * sixteenths_per_nanosecond); + if (total_beats == 0 && the_time > 0) { + // round up + total_beats = 1; + } + return beats_to_string(total_beats, true, true); + } + + public void calculate_pixel_step(float inc, float pixel_min, float pixel_div) { + int pixels_per_large = 80; + int pixels_per_medium = 40; + int pixels_per_small = 20; + + pixel_percentage += inc; + if (pixel_percentage < 0.0f) { + pixel_percentage = 0.0f; + } else if (pixel_percentage > 1.0f) { + pixel_percentage = 1.0f; + } + + pixels_per_second = pixel_min * GLib.Math.powf(pixel_div, pixel_percentage); + float pixels_per_bar = pixels_per_second / bars_per_second; + large_pixel_sixteenth = correct_seconds_value( + pixels_per_large / pixels_per_bar, 0, sixteenths_per_bar); + + medium_pixel_sixteenth = correct_seconds_value(pixels_per_medium / pixels_per_bar, + large_pixel_sixteenth, sixteenths_per_bar); + small_pixel_sixteenth = correct_seconds_value(pixels_per_small / pixels_per_bar, + medium_pixel_sixteenth, sixteenths_per_bar); + if (small_pixel_sixteenth == medium_pixel_sixteenth) { + int i = medium_pixel_sixteenth; + + while (--i > 0) { + if ((medium_pixel_sixteenth % i) == 0) { + small_pixel_sixteenth = i; + break; + } + } + } + + pixels_per_sixteenth = pixels_per_bar / (float) sixteenths_per_bar; + pixel_snap_time = xsize_to_time(PIXEL_SNAP_INTERVAL); + } + + public int frame_to_xsize(int frame) { + return ((int) (frame * pixels_per_sixteenth)); + } + + public int xsize_to_frame(int xsize) { + return (int) (xsize / pixels_per_sixteenth); + } + + public int get_start_token(int xsize) { + int start_frame = xsize_to_frame(xsize); + return large_pixel_sixteenth * (start_frame / large_pixel_sixteenth); + } + + public int get_next_position(int token) { + return token + small_pixel_sixteenth; + } + + public string? get_display_string(int frame) { + if ((frame % large_pixel_sixteenth) == 0) { + return beats_to_string(frame, false, false); + } + return null; + } + + public int get_pixel_height(int frame) { + if ((frame % medium_pixel_sixteenth) == 0) { + if (medium_pixel_sixteenth == small_pixel_sixteenth && + (medium_pixel_sixteenth != large_pixel_sixteenth && + frame % large_pixel_sixteenth != 0)) { + return 2; + } + else { + return 6; + } + } else { + return 2; + } + } + + override int[] get_timeline_seconds() { + return timeline_bars; + } +} +} diff --git a/src/marina/TrackView.vala b/src/marina/TrackView.vala new file mode 100644 index 0000000..a0a80f6 --- /dev/null +++ b/src/marina/TrackView.vala @@ -0,0 +1,199 @@ +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +using Logging; + +class TrackViewConcrete : TrackView, Gtk.Fixed { + Model.Track track; + TimeLine timeline; + TransportDelegate transport_delegate; + + const int clip_height = 64; + const int TrackHeight = clip_height + TimeLine.BORDER * 2; + + public TrackViewConcrete(TransportDelegate transport_delegate, + Model.Track track, TimeLine timeline) { + this.track = track; + this.timeline = timeline; + this.transport_delegate = transport_delegate; + + track.clip_added.connect(on_clip_added); + track.clip_removed.connect(on_clip_removed); + } + + override void size_request(out Gtk.Requisition requisition) { + base.size_request(out requisition); + requisition.height = TrackHeight; + requisition.width += TimeLine.BORDER; // right margin + } + + void on_clip_moved(ClipView clip) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_moved"); + set_clip_pos(clip); + } + + void on_clip_deleted(Model.Clip clip) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_deleted"); + track.delete_clip(clip); + clear_drag(); + } + + void on_clip_added(Model.Track t, Model.Clip clip, bool select) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_added"); + ClipView view = new ClipView(transport_delegate, clip, timeline.provider, clip_height); + view.clip_moved.connect(on_clip_moved); + view.clip_deleted.connect(on_clip_deleted); + view.move_begin.connect(on_move_begin); + view.trim_begin.connect(on_trim_begin); + + put(view, timeline.provider.time_to_xpos(clip.start), TimeLine.BORDER); + view.show(); + + timeline.track_changed(); + clip_view_added(view); + if (select) { + view.selection_request(view, false); + } + } + + // TODO: This method should not be public. When linking/grouping is done, this method + // should become private. See Timeline.on_clip_view_move_begin for more information. + public void move_to_top(ClipView clip_view) { + /* + * We remove the ClipView from the Fixed object and add it again to make + * sure that when we draw it, it is displayed above every other clip while + * dragging. + */ + remove(clip_view); + put(clip_view, + timeline.provider.time_to_xpos(clip_view.clip.start), + TimeLine.BORDER); + clip_view.show(); + } + + void on_trim_begin(ClipView clip_view) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_trim_begin"); + move_to_top(clip_view); + } + + void on_move_begin(ClipView clip_view, bool do_copy) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_move_begin"); + move_to_top(clip_view); + } + + void set_clip_pos(ClipView view) { + move(view, timeline.provider.time_to_xpos(view.clip.start), TimeLine.BORDER); + queue_draw(); + } + + public void resize() { + foreach (Gtk.Widget w in get_children()) { + ClipView view = w as ClipView; + if (view != null) { + view.on_clip_moved(view.clip); + } + } + } + + void on_clip_removed(Model.Clip clip) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_removed"); + foreach (Gtk.Widget w in get_children()) { + ClipView view = w as ClipView; + if (view.clip == clip) { + view.clip_moved.disconnect(on_clip_moved); + remove(view); + timeline.track_changed(); + return; + } + } + } + +/* + void unselect_gap() { + if (timeline.gap_view != null) { + TrackView parent = timeline.gap_view.parent as TrackView; + parent.remove(timeline.gap_view); + timeline.gap_view = null; + } + } +*/ + + override bool button_press_event(Gdk.EventButton e) { + if (e.type != Gdk.EventType.BUTTON_PRESS && + e.type != Gdk.EventType.2BUTTON_PRESS && + e.type != Gdk.EventType.3BUTTON_PRESS) + return false; + + if (e.button == 1 || + e.button == 3) { +/* + int x = (int) e.x; + int64 time = timeline.provider.xpos_to_time(x); + Model.Gap g; + track.find_containing_gap(time, out g); + if (g.end > g.start) { + int64 length = g.end - g.start; + int width = timeline.provider.time_to_xpos(g.start + length) - + timeline.provider.time_to_xpos(g.start); + + timeline.gap_view = new GapView(g.start, length, + width, clip_height); + timeline.gap_view.removed += on_gap_view_removed; + timeline.gap_view.unselected += on_gap_view_unselected; + put(timeline.gap_view, timeline.provider.time_to_xpos(g.start), TimeLine.BORDER); + timeline.gap_view.show(); + } +*/ + timeline.deselect_all_clips(); + /* + track.set_selected(true); + */ + } + return false; + } + +/* + void on_gap_view_removed(GapView gap_view) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_gap_view_removed"); + track.delete_gap(gap_view.gap); + } + + void on_gap_view_unselected(GapView gap_view) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_gap_view_unselected"); + unselect_gap(); + } +*/ + void clear_drag() { + window.set_cursor(null); + queue_draw(); + } + + public Model.Track get_track() { + return track; + } + + public int get_track_height() { + return TrackHeight; + } + + public Gtk.Widget? find_child(double x, double y) { + foreach (Gtk.Widget w in get_children()) { + if (w.allocation.x <= x && x < w.allocation.x + w.allocation.width) { + return w; + } + } + return null; + } + + public void select_all() { + foreach (Gtk.Widget child in get_children()) { + ClipView? clip_view = child as ClipView; + if (clip_view != null) { + clip_view.select(); + } + } + } +} diff --git a/src/marina/TransportDelegate.vala b/src/marina/TransportDelegate.vala new file mode 100644 index 0000000..d01c2e2 --- /dev/null +++ b/src/marina/TransportDelegate.vala @@ -0,0 +1,11 @@ +/* Copyright 2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +public interface TransportDelegate : Object { + public abstract bool is_playing(); + public abstract bool is_recording(); + public abstract bool is_stopped(); +} diff --git a/src/marina/UndoManager.vala b/src/marina/UndoManager.vala new file mode 100644 index 0000000..e7db9e5 --- /dev/null +++ b/src/marina/UndoManager.vala @@ -0,0 +1,103 @@ +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +namespace Model { +public class UndoManager { + int saved_index = 0; + bool _in_undo = false; + Gee.ArrayList command_list = new Gee.ArrayList(); + public bool is_dirty { get { return saved_index != command_list.size; } } + public bool can_undo { get { return command_list.size > 0; } } + public bool in_undo { get { return _in_undo; } private set { _in_undo = value; } } + + public signal void undo_changed(bool can_undo); + public signal void dirty_changed(bool is_dirty); + + public class UndoManager() { + } + + public void reset() { + command_list.clear(); + saved_index = 0; + undo_changed(false); + } + + public void mark_clean() { + saved_index = command_list.size; + dirty_changed(false); + } + + public void start_transaction(string description) { + TransactionCommand command = new TransactionCommand(false, description); + command_list.add(command); + undo_changed(true); + } + + public void end_transaction(string description) { + TransactionCommand command = new TransactionCommand(true, description); + command_list.add(command); + undo_changed(true); + } + + public void do_command(Command the_command) { + if (!in_undo) { + the_command.apply(); + Command? current_command = get_current_command(); + if (current_command == null || !current_command.merge(the_command)) { + command_list.add(the_command); + } + dirty_changed(true); + undo_changed(can_undo); + } + } + + Command? get_current_command() { + int index = command_list.size - 1; + if (index >= 0) { + return command_list[index]; + } else { + return null; + } + } + + public void undo() { + assert(in_undo == false); + in_undo = true; + int in_transaction = 0; + do { + Command? the_command = get_current_command(); + if (the_command != null) { + command_list.remove(the_command); + TransactionCommand transaction_command = the_command as TransactionCommand; + if (transaction_command != null) { + if (transaction_command.in_transaction()) { + in_transaction++; + } else { + in_transaction--; + } + } else { + the_command.undo(); + } + } else { + break; + } + } while (in_transaction > 0); + dirty_changed(is_dirty); + undo_changed(can_undo); + in_undo = false; + } + + public string get_undo_title() { + Command? the_command = get_current_command(); + if (the_command != null) { + return the_command.description(); + } else { + return ""; + } + } + +} +} diff --git a/src/marina/clip.vala b/src/marina/clip.vala new file mode 100644 index 0000000..0f3b9c2 --- /dev/null +++ b/src/marina/clip.vala @@ -0,0 +1,607 @@ +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +using Logging; + +namespace Model { + +public enum MediaType { + AUDIO, + VIDEO +} + +public class Gap { + public int64 start; + public int64 end; + + public Gap(int64 start, int64 end) { + this.start = start; + this.end = end; + } + + public bool is_empty() { + return start >= end; + } + + public Gap intersect(Gap g) { + return new Gap(int64.max(start, g.start), int64.min(end, g.end)); + } +} + +public class ClipFile : Object { + public string filename; + int64 _length; + public int64 length { + public get { + if (!online) { + warning("retrieving length while clip offline"); + } + return _length; + } + + public set { + _length = value; + } + } + + bool online; + + public Gst.Caps video_caps; // or null if no video + public Gst.Caps audio_caps; // or null if no audio + public Gdk.Pixbuf thumbnail = null; + + public signal void updated(); + + public ClipFile(string filename, int64 length = 0) { + this.filename = filename; + this.length = length; + online = false; + } + + public bool is_online() { + return online; + } + + public void set_online(bool o) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "set_online"); + online = o; + updated(); + } + + public void set_thumbnail(Gdk.Pixbuf b) { + // TODO: Investigate this + // 56x56 - 62x62 icon size does not work for some reason when + // we display the thumbnail while dragging the clip. + + thumbnail = b.scale_simple(64, 44, Gdk.InterpType.BILINEAR); + } + + public bool has_caps_structure(MediaType m) { + if (m == MediaType.AUDIO) { + if (audio_caps == null || audio_caps.get_size() < 1) + return false; + } else if (m == MediaType.VIDEO) { + if (video_caps == null || video_caps.get_size() < 1) + return false; + } + return true; + } + + public bool is_of_type(MediaType t) { + if (t == MediaType.VIDEO) + return video_caps != null; + return audio_caps != null; + } + + bool get_caps_structure(MediaType m, out Gst.Structure s) { + if (!has_caps_structure(m)) + return false; + if (m == MediaType.AUDIO) { + s = audio_caps.get_structure(0); + } else if (m == MediaType.VIDEO) { + s = video_caps.get_structure(0); + } + return true; + } + + public bool get_frame_rate(out Fraction rate) { + Gst.Structure structure; + if (!get_caps_structure(MediaType.VIDEO, out structure)) + return false; + return structure.get_fraction("framerate", out rate.numerator, out rate.denominator); + } + + public bool get_dimensions(out int w, out int h) { + Gst.Structure s; + + if (!get_caps_structure(MediaType.VIDEO, out s)) + return false; + + return s.get_int("width", out w) && s.get_int("height", out h); + } + + public bool get_sample_rate(out int rate) { + Gst.Structure s; + if (!get_caps_structure(MediaType.AUDIO, out s)) + return false; + + return s.get_int("rate", out rate); + } + + public bool get_video_format(out uint32 fourcc) { + Gst.Structure s; + + if (!get_caps_structure(MediaType.VIDEO, out s)) + return false; + + return s.get_fourcc("format", out fourcc); + } + + public bool get_num_channels(out int channels) { + Gst.Structure s; + if (!get_caps_structure(MediaType.AUDIO, out s)) { + return false; + } + + return s.get_int("channels", out channels); + } + + public bool get_num_channels_string(out string s) { + int i; + if (!get_num_channels(out i)) + return false; + + if (i == 1) + s = "Mono"; + else if (i == 2) + s = "Stereo"; + else if ((i % 2) == 0) + s = "Surround %d.1".printf(i - 1); + else + s = "%d".printf(i); + return true; + } +} + +public abstract class Fetcher : Object { + protected Gst.Element filesrc; + protected Gst.Element decodebin; + protected Gst.Pipeline pipeline; + + public ClipFile clipfile; + public string error_string; + + protected abstract void on_pad_added(Gst.Pad pad); + protected abstract void on_state_change(Gst.Bus bus, Gst.Message message); + + public signal void ready(Fetcher fetcher); + + protected void do_error(string error) { + error_string = error; + pipeline.set_state(Gst.State.NULL); + } + + protected void on_warning(Gst.Bus bus, Gst.Message message) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_warning"); + Error error; + string text; + message.parse_warning(out error, out text); + warning("%s", text); + } + + protected void on_error(Gst.Bus bus, Gst.Message message) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_error"); + Error error; + string text; + message.parse_error(out error, out text); + do_error(text); + } +} + +public class ClipFetcher : Fetcher { + public signal void clipfile_online(bool online); + + public ClipFetcher(string filename) throws Error { + clipfile = new ClipFile(filename); + + clipfile_online.connect(clipfile.set_online); + + filesrc = make_element("filesrc"); + filesrc.set("location", filename); + + decodebin = (Gst.Bin) make_element("decodebin"); + pipeline = new Gst.Pipeline("pipeline"); + pipeline.set_auto_flush_bus(false); + if (pipeline == null) + error("can't construct pipeline"); + pipeline.add_many(filesrc, decodebin); + + if (!filesrc.link(decodebin)) + error("can't link filesrc"); + decodebin.pad_added.connect(on_pad_added); + + Gst.Bus bus = pipeline.get_bus(); + + bus.add_signal_watch(); + bus.message["state-changed"] += on_state_change; + bus.message["error"] += on_error; + bus.message["warning"] += on_warning; + + error_string = null; + pipeline.set_state(Gst.State.PLAYING); + } + + public string get_filename() { return clipfile.filename; } + + protected override void on_pad_added(Gst.Pad pad) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_pad_added"); + Gst.Pad fake_pad; + Gst.Element fake_sink; + try { + if (pad.caps.to_string().has_prefix("video")) { + fake_sink = make_element("fakesink"); + pipeline.add(fake_sink); + fake_pad = fake_sink.get_static_pad("sink"); + + if (!fake_sink.sync_state_with_parent()) { + error("could not sync state with parent"); + } + } else { + fake_sink = make_element("fakesink"); + pipeline.add(fake_sink); + fake_pad = fake_sink.get_static_pad("sink"); + + if (!fake_sink.sync_state_with_parent()) { + error("could not sync state with parent"); + } + } + pad.link(fake_pad); + } + catch (Error e) { + } + } + + Gst.Pad? get_pad(string prefix) { + foreach(Gst.Pad pad in decodebin.pads) { + string caps = pad.caps.to_string(); + if (caps.has_prefix(prefix)) { + return pad; + } + } + return null; + } + + protected override void on_state_change(Gst.Bus bus, Gst.Message message) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_state_change"); + if (message.src != pipeline) + return; + + Gst.State old_state; + Gst.State new_state; + Gst.State pending; + + message.parse_state_changed(out old_state, out new_state, out pending); + if (new_state == old_state) + return; + + if (new_state == Gst.State.PLAYING) { + Gst.Pad? pad = get_pad("video"); + if (pad != null) { + clipfile.video_caps = pad.caps; + } + + pad = get_pad("audio"); + if (pad != null) { + clipfile.audio_caps = pad.caps; + } + + Gst.Format format = Gst.Format.TIME; + int64 length; + if (!pipeline.query_duration(ref format, out length) || + format != Gst.Format.TIME) { + do_error("Can't fetch length"); + return; + } + clipfile.length = length; + + clipfile_online(true); + pipeline.set_state(Gst.State.NULL); + } else if (new_state == Gst.State.NULL) { + ready(this); + } + } +} + +public class ThumbnailFetcher : Fetcher { + ThumbnailSink thumbnail_sink; + Gst.Element colorspace; + int64 seek_position; + bool done_seek; + bool have_thumbnail; + + public ThumbnailFetcher(ClipFile f, int64 time) throws Error { + clipfile = f; + seek_position = time; + + SingleDecodeBin single_bin = new SingleDecodeBin ( + Gst.Caps.from_string ("video/x-raw-rgb; video/x-raw-yuv"), + "singledecoder", f.filename); + + pipeline = new Gst.Pipeline("pipeline"); + pipeline.set_auto_flush_bus(false); + + thumbnail_sink = new ThumbnailSink(); + thumbnail_sink.have_thumbnail.connect(on_have_thumbnail); + + colorspace = make_element("ffmpegcolorspace"); + + pipeline.add_many(single_bin, thumbnail_sink, colorspace); + + single_bin.pad_added.connect(on_pad_added); + + colorspace.link(thumbnail_sink); + + Gst.Bus bus = pipeline.get_bus(); + + bus.add_signal_watch(); + bus.message["state-changed"] += on_state_change; + bus.message["error"] += on_error; + bus.message["warning"] += on_warning; + + have_thumbnail = false; + done_seek = false; + pipeline.set_state(Gst.State.PAUSED); + } + + void on_have_thumbnail(Gdk.Pixbuf buf) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_have_thumbnail"); + if (done_seek) { + have_thumbnail = true; + clipfile.set_thumbnail(buf); + } + } + + protected override void on_pad_added(Gst.Pad pad) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_pad_added"); + Gst.Caps c = pad.get_caps(); + + if (c.to_string().has_prefix("video")) { + pad.link(colorspace.get_static_pad("sink")); + } + } + + protected override void on_state_change(Gst.Bus bus, Gst.Message message) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_state_change"); + if (message.src != pipeline) + return; + + Gst.State new_state; + Gst.State old_state; + Gst.State pending_state; + + message.parse_state_changed (out old_state, out new_state, out pending_state); + if (new_state == old_state && + new_state != Gst.State.PAUSED) + return; + + if (new_state == Gst.State.PAUSED) { + if (!done_seek) { + done_seek = true; + pipeline.seek_simple(Gst.Format.TIME, Gst.SeekFlags.FLUSH, seek_position); + } else { + if (have_thumbnail) + pipeline.set_state(Gst.State.NULL); + } + } else if (new_state == Gst.State.NULL) { + ready(this); + } + } +} + +public class Clip : Object { + public ClipFile clipfile; + public MediaType type; + // TODO: If a clip is being recorded, we don't want to set duration in the MediaClip file. + // Address when handling multiple track recording. This is an ugly hack. + public bool is_recording; + public string name; + int64 _start; + public int64 start { + get { + return _start; + } + + set { + _start = value; + if (connected) { + start_changed(_start); + } + moved(this); + } + } + + int64 _media_start; + public int64 media_start { + get { + return _media_start; + } + } + + int64 _duration; + public int64 duration { + get { + return _duration; + } + + set { + if (value < 0) { + // saturating the duration + value = 0; + } + + if (!is_recording) { + if (value + _media_start > clipfile.length) { + // saturating the duration + value = clipfile.length - media_start; + } + } + + _duration = value; + if (connected) { + duration_changed(_duration); + } + moved(this); + } + } + + bool connected; + + public int64 end { + get { return start + duration; } + } + + public signal void moved(Clip clip); + public signal void updated(Clip clip); + public signal void media_start_changed(int64 media_start); + public signal void duration_changed(int64 duration); + public signal void start_changed(int64 start); + public signal void removed(Clip clip); + + public Clip(ClipFile clipfile, MediaType t, string name, + int64 start, int64 media_start, int64 duration, bool is_recording) { + this.is_recording = is_recording; + this.clipfile = clipfile; + this.type = t; + this.name = name; + this.connected = clipfile.is_online(); + this.set_media_start_duration(media_start, duration); + this.start = start; + clipfile.updated.connect(on_clipfile_updated); + } + + public void gnonlin_connect() { connected = true; } + public void gnonlin_disconnect() { connected = false; } + + void on_clipfile_updated(ClipFile f) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clipfile_updated"); + if (f.is_online()) { + if (!connected) { + connected = true; + // TODO: Assigning to oneself has the side-effect of firing signals. + // fire signals directly. Make certain that loading a file still works + // properly in this case. + set_media_start_duration(media_start, duration); + + start = start; + } + } else { + if (connected) { + connected = false; + } + } + updated(this); + } + + public bool overlap_pos(int64 start, int64 length) { + return start < this.start + this.duration && + this.start < start + length; + } + + public int64 snap(Clip other, int64 pad) { + if (time_in_range(start, other.start, pad)) { + return other.start; + } else if (time_in_range(start, other.end, pad)) { + return other.end; + } else if (time_in_range(end, other.start, pad)) { + return other.start - duration; + } else if (time_in_range(end, other.end, pad)) { + return other.end - duration; + } + return start; + } + + public bool snap_coord(out int64 s, int64 span) { + if (time_in_range(s, start, span)) { + s = start; + return true; + } else if (time_in_range(s, end, span)) { + s = end; + return true; + } + return false; + } + + public Clip copy() { + return new Clip(clipfile, type, name, start, media_start, duration, false); + } + + public bool is_trimmed() { + if (!clipfile.is_online()) + return false; + return duration != clipfile.length; + } + + public void trim(int64 delta, Gdk.WindowEdge edge) { + switch (edge) { + case Gdk.WindowEdge.WEST: + if (media_start + delta < 0) { + delta = -media_start; + } + + if (duration - delta < 0) { + delta = duration; + } + + start += delta; + set_media_start_duration(media_start + delta, duration - delta); + break; + case Gdk.WindowEdge.EAST: + duration += delta; + break; + } + } + + public void set_media_start_duration(int64 media_start, int64 duration) { + if (media_start < 0) { + media_start = 0; + } + + if (duration < 0) { + duration = 0; + } + + if (clipfile.is_online() && media_start + duration > clipfile.length) { + // We are saturating the value + media_start = clipfile.length - duration; + } + + _media_start = media_start; + _duration = duration; + + if (connected) { + media_start_changed(_media_start); + duration_changed(_duration); + } + + moved(this); + } + + public void save(FileStream f, int id) { + f.printf( + " \n", + id, name, start, media_start, duration); + } +} + +public class FetcherCompletion { + public FetcherCompletion() { + } + + public virtual void complete(Fetcher fetcher) { + } +} +} diff --git a/src/marina/command.vala b/src/marina/command.vala new file mode 100644 index 0000000..c2c5083 --- /dev/null +++ b/src/marina/command.vala @@ -0,0 +1,409 @@ +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +namespace Model { +public abstract class Command { + public abstract void apply(); + public abstract void undo(); + public abstract bool merge(Command command); + public abstract string description(); +} + +public enum Parameter { PAN, VOLUME } + +public class ParameterCommand : Command { + AudioTrack target; + Parameter parameter; + double delta; + + public ParameterCommand(AudioTrack target, Parameter parameter, + double new_value, double old_value) { + this.target = target; + this.parameter = parameter; + this.delta = new_value - old_value; + } + + void change_parameter(double amount) { + switch (parameter) { + case Parameter.PAN: + target._set_pan(target.get_pan() + amount); + break; + case Parameter.VOLUME: + target._set_volume(target.get_volume() + amount); + break; + } + } + + public override void apply() { + change_parameter(delta); + } + + public override void undo() { + change_parameter(-delta); + } + + public override bool merge(Command command) { + ParameterCommand parameter_command = command as ParameterCommand; + if (parameter_command != null && parameter_command.parameter == parameter) { + delta = delta + parameter_command.delta; + return true; + } + return false; + } + + public override string description() { + switch (parameter) { + case Parameter.PAN: + return "Adjust Pan"; + case Parameter.VOLUME: + return "Adjust Level"; + default: + assert(false); + return ""; + } + } +} + +public class ClipCommand : Command { + public enum Action { APPEND, DELETE } + Track track; + Clip clip; + int64 time; + Action action; + int index; + bool select; + + public ClipCommand(Action action, Track track, Clip clip, int64 time, bool select) { + this.track = track; + this.clip = clip; + this.time = time; + this.action = action; + this.select = select; + this.index = track.get_clip_index(clip); + } + + public override void apply() { + switch(action) { + case Action.APPEND: + track._append_at_time(clip, time, select); + break; + case Action.DELETE: + track._delete_clip(clip); + break; + default: + assert(false); + break; + } + } + + public override void undo() { + switch(action) { + case Action.APPEND: + track._delete_clip(clip); + break; + case Action.DELETE: + track.add(clip, time, false); + break; + default: + assert(false); + break; + } + } + + public override bool merge(Command command) { + return false; + } + + public override string description() { + switch(action) { + case Action.APPEND: + return "Create Clip"; + case Action.DELETE: + return "Delete Clip"; + default: + assert(false); + return ""; + } + } +} + +public class ClipAddCommand : Command { + Track track; + Clip clip; + int64 delta; + + public ClipAddCommand(Track track, Clip clip, int64 original_time, + int64 new_start) { + this.track = track; + this.clip = clip; + this.delta = new_start - original_time; + } + + public override void apply() { + track._move(clip, clip.start); + } + + public override void undo() { + track.remove_clip_from_array(clip); + track._move(clip, clip.start - delta); + } + + public override bool merge(Command command) { + return false; + } + + public override string description() { + return "Move Clip"; + } +} + +public class ClipSplitCommand : Command { + Track track; + int64 time; + bool do_split; + + public enum Action { SPLIT, JOIN } + + public ClipSplitCommand(Action action, Track track, int64 time) { + this.track = track; + this.time = time; + do_split = action == Action.SPLIT; + } + + public override void apply() { + if (do_split) { + track._split_at(time); + } else { + track._join(time); + } + } + + public override void undo() { + if (do_split) { + track._join(time); + } else { + track._split_at(time); + } + } + + public override bool merge(Command command) { + return false; + } + + public override string description() { + if (do_split) { + return "Split Clip"; + } else { + return "Join Clip"; + } + } +} + +public class ClipFileDeleteCommand : Command { + ClipFile clipfile; + Project project; + + public ClipFileDeleteCommand(Project p, ClipFile cf) { + clipfile = cf; + project = p; + } + + public override void apply() { + project._remove_clipfile(clipfile); + } + + public override void undo() { + try { + project._add_clipfile(clipfile); + } catch (Error e) { + project.error_occurred("Could not add clipfile.", e.message); + } + } + + public override bool merge(Command command) { + return false; + } + + public override string description() { + return "Delete from Library"; + } +} + +public class ClipTrimCommand : Command { + Track track; + Clip clip; + int64 delta; + Gdk.WindowEdge edge; + + public ClipTrimCommand(Track track, Clip clip, int64 delta, Gdk.WindowEdge edge) { + this.track = track; + this.clip = clip; + this.delta = delta; + this.edge = edge; + } + + public override void apply() { + track._trim(clip, delta, edge); + } + + public override void undo() { + track._trim(clip, -delta, edge); + } + + public override bool merge(Command command) { + return false; + } + + public override string description() { + return "Trim To Playhead"; + } +} + +public class ClipRevertCommand : Command { + Track track; + Clip clip; + int64 left_delta; + int64 right_delta; + + public ClipRevertCommand(Track track, Clip clip) { + this.track = track; + this.clip = clip; + } + + public override void apply() { + right_delta = clip.end; + left_delta = clip.media_start; + track._revert_to_original(clip); + left_delta -= clip.media_start; + right_delta = clip.end - right_delta - left_delta; + } + + public override void undo() { + track._trim(clip, -left_delta, Gdk.WindowEdge.WEST); + track._trim(clip, -right_delta, Gdk.WindowEdge.EAST); + } + + public override bool merge(Command command) { + return false; + } + + public override string description() { + return "Revert To Original"; + } +} + +public class TimeSignatureCommand : Command { + Fraction new_time_signature; + Fraction old_time_signature; + Project project; + + public TimeSignatureCommand(Project project, Fraction new_time_signature) { + this.project = project; + this.new_time_signature = new_time_signature; + this.old_time_signature = project.get_time_signature(); + } + + public override void apply() { + project._set_time_signature(new_time_signature); + } + + public override void undo() { + project._set_time_signature(old_time_signature); + } + + public override bool merge(Command command) { + return false; + } + + public override string description() { + return "Set Time Signature"; + } +} + +public class BpmCommand : Command { + int delta; + Project project; + + public BpmCommand(Project project, int new_bpm) { + delta = new_bpm - project.get_bpm(); + this.project = project; + } + + public override void apply() { + project._set_bpm(project.get_bpm() + delta); + } + + public override void undo() { + project._set_bpm(project.get_bpm() - delta); + } + + public override bool merge(Command command) { + return false; + } + + public override string description() { + return "Set Tempo"; + } +} + +public class AddClipCommand : Command { + ClipFile clip_file; + Project project; + + public AddClipCommand(Project project, ClipFile clip_file) { + this.project = project; + this.clip_file = clip_file; + } + + public override void apply() { + try { + project._add_clipfile(clip_file); + } catch (GLib.Error error) { + project.error_occurred("Error importing", "An error occurred importing this file."); + } + } + + public override void undo() { + project._remove_clipfile(clip_file); + } + + public override bool merge(Command command) { + return false; + } + + public override string description() { + return "Add Clip To Library"; + } +} + +public class TransactionCommand : Command { + bool open; + string transaction_description; + + public TransactionCommand(bool open, string transaction_description) { + this.open = open; + this.transaction_description = transaction_description; + } + + public bool in_transaction() { + return open; + } + + public override void apply() { + } + + public override void undo() { + } + + public override bool merge(Command command) { + return false; + } + + public override string description() { + return transaction_description; + } +} +} diff --git a/src/marina/import.vala b/src/marina/import.vala new file mode 100644 index 0000000..7c002cb --- /dev/null +++ b/src/marina/import.vala @@ -0,0 +1,469 @@ +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +using Logging; + +namespace Model { + +public class ClipImporter : MultiFileProgressInterface, Object { + enum ImportState { + FETCHING, + IMPORTING, + CANCELLED + } + + string import_directory; + + ImportState import_state; + bool import_done; + bool all_done; + ClipFetcher our_fetcher; + + Gst.Pad video_pad; + Gst.Pad audio_pad; + + Gst.Pipeline pipeline = null; + Gst.Element filesink; + Gst.Element video_convert; + Gst.Element audio_convert; + Gst.Element mux; + + Gst.Bin video_decoder; + Gst.Bin audio_decoder; + + int current_file_importing = 0; + + int64 current_time; + int64 total_time; + int64 previous_time; + + Gee.ArrayList filenames = new Gee.ArrayList(); + Gee.ArrayList queued_fetchers = new Gee.ArrayList(); + Gee.ArrayList queued_filenames = new Gee.ArrayList(); + Gee.ArrayList no_import_formats = new Gee.ArrayList(); + + public signal void clip_complete(ClipFile f); + public signal void importing_started(int num_clips); + public signal void error_occurred(string error); + + public ClipImporter() { + import_directory = GLib.Environment.get_home_dir(); + import_directory += "/.lombard_fillmore_import/"; + + GLib.DirUtils.create(import_directory, 0777); + + no_import_formats.add("YUY2"); + no_import_formats.add("Y41B"); + + import_state = ImportState.FETCHING; + } + + public void add_filename(string filename) { + filenames.add(filename); + } + + bool on_timer_callback() { + int64 time; + Gst.Format format = Gst.Format.TIME; + + if (all_done) + return false; + + if (pipeline.query_position(ref format, out time) && + format == Gst.Format.TIME) { + if (time > previous_time) + current_time += time - previous_time; + previous_time = time; + if (current_time >= total_time) { + fraction_updated(1.0); + return false; + } else + fraction_updated(current_time / (double)total_time); + } + return true; + } + + void start_import() { + import_state = ImportState.IMPORTING; + current_file_importing = 0; + importing_started(queued_fetchers.size); + Timeout.add(50, on_timer_callback); + } + + void cancel() { + all_done = true; + import_state = ImportState.CANCELLED; + if (pipeline != null) { + pipeline.set_state(Gst.State.NULL); + } + } + + public void start() throws Error { + process_curr_file(); + } + + void process_curr_file() throws Error { + if (import_state == ImportState.FETCHING) { + if (current_file_importing == filenames.size) { + if (queued_fetchers.size == 0) + done(); + else + start_import(); + } else { + emit(this, Facility.IMPORT, Level.VERBOSE, + "fetching %s".printf(filenames[current_file_importing])); + our_fetcher = new Model.ClipFetcher(filenames[current_file_importing]); + our_fetcher.ready.connect(on_fetcher_ready); + } + } + + if (import_state == ImportState.IMPORTING) { + if (current_file_importing == queued_fetchers.size) { + fraction_updated(1.0); + all_done = true; + } else + do_import(queued_fetchers[current_file_importing]); + } + } + + // TODO: Rework this + void complete() { + all_done = true; + } + + void do_import_complete() throws Error{ + if (import_state == ImportState.IMPORTING) { + our_fetcher.clipfile.filename = append_extension( + queued_filenames[current_file_importing], "mov"); + clip_complete(our_fetcher.clipfile); + } else + total_time += our_fetcher.clipfile.length; + + current_file_importing++; + + if (current_file_importing <= filenames.size) + process_curr_file(); + else + warning ("do_import_complete: current_file_importing out of bounds! %d %d".printf( + current_file_importing, filenames.size)); + } + + bool need_to_import(Fetcher f) { + //for now, use the clip as is + return false; + /* + if (f.clipfile.is_of_type(MediaType.VIDEO)) { + uint32 format; + if (f.clipfile.get_video_format(out format)) { + foreach (string s in no_import_formats) { + if (format == *(uint32*)s) { + return false; + } + } + return true; + } + } + return false; + */ + } + + void on_fetcher_ready(Fetcher f) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_fetcher_ready"); + try { + if (f.error_string != null) { + error_occurred(f.error_string); + do_import_complete(); + return; + } + + if (need_to_import(f)) { + string checksum; + if (md5_checksum_on_file(f.clipfile.filename, out checksum)) { + string base_filename = import_directory + isolate_filename(f.clipfile.filename); + + int index = 0; + string new_filename = base_filename; + while (true) { + string existing_checksum; + if (get_file_md5_checksum(new_filename, out existing_checksum)) { + if (checksum == existing_checksum) { + // Re-fetch this clip to get the correct caps + filenames[current_file_importing] = + append_extension(new_filename, "mov"); + current_file_importing--; + total_time -= f.clipfile.length; + break; + } + index++; + new_filename = base_filename + index.to_string(); + } else { + // Truly need to import + save_file_md5_checksum(new_filename, checksum); + queued_filenames.add(new_filename); + queued_fetchers.add(f as ClipFetcher); + break; + } + } + } else + error("Cannot get md5 checksum for file %s!", f.clipfile.filename); + } else { + clip_complete(f.clipfile); + } + do_import_complete(); + } catch (Error e) { + error_occurred(e.message); + } + } + + void do_import(ClipFetcher f) throws Error { + file_updated(f.clipfile.filename, current_file_importing); + previous_time = 0; + + our_fetcher = f; + import_done = false; + pipeline = new Gst.Pipeline("pipeline"); + pipeline.set_auto_flush_bus(false); + + Gst.Bus bus = pipeline.get_bus(); + bus.add_signal_watch(); + + bus.message["state-changed"] += on_state_changed; + bus.message["eos"] += on_eos; + bus.message["error"] += on_error; + bus.message["warning"] += on_warning; + + mux = make_element("qtmux"); + + filesink = make_element("filesink"); + filesink.set("location", append_extension(queued_filenames[current_file_importing], "mov")); + + pipeline.add_many(mux, filesink); + + if (f.clipfile.is_of_type(MediaType.VIDEO)) { + video_convert = make_element("ffmpegcolorspace"); + pipeline.add(video_convert); + + video_decoder = new SingleDecodeBin(Gst.Caps.from_string( + "video/x-raw-yuv"), + "videodecodebin", + f.clipfile.filename); + video_decoder.pad_added.connect(on_pad_added); + + pipeline.add(video_decoder); + + if (!video_convert.link(mux)) + error("do_import: Cannot link video converter to mux!"); + } + if (f.clipfile.is_of_type(MediaType.AUDIO)) { + audio_convert = make_element("audioconvert"); + pipeline.add(audio_convert); + + // setup for importing h.264 and other int flavors. change to audio/x-raw-float + // if you need to import ogg and other float flavors. see bug 2055 + audio_decoder = new SingleDecodeBin( + Gst.Caps.from_string("audio/x-raw-int"), + "audiodecodebin", f.clipfile.filename); + audio_decoder.pad_added.connect(on_pad_added); + + pipeline.add(audio_decoder); + + if (!audio_convert.link(mux)) + error("do_import: Cannot link audio convert to mux!"); + } + + if (!mux.link(filesink)) + error("do_import: Cannot link mux to filesink!"); + + emit(this, Facility.IMPORT, Level.VERBOSE, + "Starting import to %s...".printf(queued_filenames[current_file_importing])); + pipeline.set_state(Gst.State.PLAYING); + } + + void on_pad_added(Gst.Pad p) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_pad_added"); + + string str = p.caps.to_string(); + Gst.Pad sink = null; + + if (str.has_prefix("video")) { + video_pad = p; + sink = video_convert.get_compatible_pad(p, p.caps); + } else if (str.has_prefix("audio")) { + audio_pad = p; + sink = audio_convert.get_compatible_pad(p, p.caps); + } else { + //error_occurred here gives a segfault + warning("Unrecognized prefix %s".printf(str)); + return; + } + + if (p.link(sink) != Gst.PadLinkReturn.OK) { + error("Cannot link pad in importer!"); + } + } + + void on_error(Gst.Bus bus, Gst.Message message) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_error"); + Error e; + string text; + message.parse_error(out e, out text); + warning("%s\n", text); + error_occurred(text); + } + + void on_warning(Gst.Bus bus, Gst.Message message) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_warning"); + Error e; + string text; + message.parse_warning(out e, out text); + warning("%s", text); + } + + void on_state_changed(Gst.Bus b, Gst.Message m) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_state_changed"); + if (m.src != pipeline) + return; + + Gst.State old_state; + Gst.State new_state; + Gst.State pending; + + m.parse_state_changed (out old_state, out new_state, out pending); + + if (old_state == new_state) + return; + + emit(this, Facility.IMPORT, Level.VERBOSE, + "Import State in %s".printf(new_state.to_string())); + if (new_state == Gst.State.PAUSED) { + if (!import_done) { + if (video_pad != null) { + our_fetcher.clipfile.video_caps = video_pad.caps; + } + if (audio_pad != null) { + our_fetcher.clipfile.audio_caps = audio_pad.caps; + } + emit(this, Facility.IMPORT, Level.VERBOSE, + "Got clipfile info for: %s".printf(our_fetcher.clipfile.filename)); + } + } else if (new_state == Gst.State.NULL) { + if (import_state == ImportState.CANCELLED) { + GLib.FileUtils.remove(append_extension(queued_filenames[current_file_importing], + "mov")); + GLib.FileUtils.remove(append_extension(queued_filenames[current_file_importing], + "md5")); + } else { + if (import_done) + try { + do_import_complete(); + } catch (Error e) { + error_occurred(e.message); + } + } + } + } + + void on_eos() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_eos"); + import_done = true; + pipeline.set_state(Gst.State.NULL); + } +} + +public class LibraryImporter : Object { + protected Project project; + public ClipImporter importer; + + public signal void started(ClipImporter i, int num); + + public LibraryImporter(Project p) { + project = p; + + importer = new ClipImporter(); + importer.clip_complete.connect(on_clip_complete); + importer.error_occurred.connect(on_error_occurred); + importer.importing_started.connect(on_importer_started); + } + + void on_importer_started(ClipImporter i, int num) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_importer_started"); + started(i, num); + } + + void on_error_occurred(string error) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_error_occurred"); + emit(this, Facility.DEVELOPER_WARNINGS, Level.INFO, error); + project.error_occurred("Error importing", "An error occurred importing this file."); + } + + protected virtual void append_existing_clipfile(ClipFile f) { + + } + + protected virtual void on_clip_complete(ClipFile f) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_complete"); + ClipFile cf = project.find_clipfile(f.filename); + if (cf == null) { + project.add_clipfile(f); + } + } + + public void add_file(string filename) throws Error { + ClipFile cf = project.find_clipfile(filename); + + if (cf != null) + append_existing_clipfile(cf); + else + importer.add_filename(filename); + } + + public void start() throws Error { + importer.start(); + } +} + +public class TimelineImporter : LibraryImporter { + Track track; + int64 time_to_add; + bool both_tracks; + + public TimelineImporter(Track track, Project p, int64 time_to_add, bool both_tracks) { + base(p); + this.track = track; + this.time_to_add = time_to_add; + this.both_tracks = both_tracks; + } + + void add_to_both(ClipFile clip_file) { + if (both_tracks) { + Track other_track; + if (track is Model.VideoTrack) { + other_track = project.find_audio_track(); + } else { + other_track = project.find_video_track(); + } + if (other_track != null) { + project.add(other_track, clip_file, time_to_add); + } + } + } + + protected override void append_existing_clipfile(ClipFile f) { + project.undo_manager.start_transaction("Create Clip"); + project.add(track, f, time_to_add); + add_to_both(f); + project.undo_manager.end_transaction("Create Clip"); + } + + protected override void on_clip_complete(ClipFile f) { + project.undo_manager.start_transaction("Create Clip"); + base.on_clip_complete(f); + project.add(track, f, time_to_add); + add_to_both(f); + project.undo_manager.end_transaction("Create Clip"); + } +} +} diff --git a/src/marina/libmarina.a b/src/marina/libmarina.a new file mode 100644 index 0000000..4f7ed1b Binary files /dev/null and b/src/marina/libmarina.a differ diff --git a/src/marina/marina.h b/src/marina/marina.h new file mode 100644 index 0000000..7abc8f2 --- /dev/null +++ b/src/marina/marina.h @@ -0,0 +1,2142 @@ +/* marina.h generated by valac, the Vala compiler, do not modify */ + + +#ifndef __MARINA_H__ +#define __MARINA_H__ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +G_BEGIN_DECLS + + +#define TYPE_APP_DIRS (app_dirs_get_type ()) +#define APP_DIRS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_APP_DIRS, AppDirs)) +#define APP_DIRS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_APP_DIRS, AppDirsClass)) +#define IS_APP_DIRS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_APP_DIRS)) +#define IS_APP_DIRS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_APP_DIRS)) +#define APP_DIRS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_APP_DIRS, AppDirsClass)) + +typedef struct _AppDirs AppDirs; +typedef struct _AppDirsClass AppDirsClass; +typedef struct _AppDirsPrivate AppDirsPrivate; + +#define VIEW_TYPE_AUDIO_METER (view_audio_meter_get_type ()) +#define VIEW_AUDIO_METER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_AUDIO_METER, ViewAudioMeter)) +#define VIEW_AUDIO_METER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_AUDIO_METER, ViewAudioMeterClass)) +#define VIEW_IS_AUDIO_METER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_AUDIO_METER)) +#define VIEW_IS_AUDIO_METER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_AUDIO_METER)) +#define VIEW_AUDIO_METER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_AUDIO_METER, ViewAudioMeterClass)) + +typedef struct _ViewAudioMeter ViewAudioMeter; +typedef struct _ViewAudioMeterClass ViewAudioMeterClass; +typedef struct _ViewAudioMeterPrivate ViewAudioMeterPrivate; + +#define MODEL_TYPE_TRACK (model_track_get_type ()) +#define MODEL_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TRACK, ModelTrack)) +#define MODEL_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TRACK, ModelTrackClass)) +#define MODEL_IS_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TRACK)) +#define MODEL_IS_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TRACK)) +#define MODEL_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TRACK, ModelTrackClass)) + +typedef struct _ModelTrack ModelTrack; +typedef struct _ModelTrackClass ModelTrackClass; + +#define MODEL_TYPE_AUDIO_TRACK (model_audio_track_get_type ()) +#define MODEL_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrack)) +#define MODEL_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrackClass)) +#define MODEL_IS_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_AUDIO_TRACK)) +#define MODEL_IS_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_AUDIO_TRACK)) +#define MODEL_AUDIO_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrackClass)) + +typedef struct _ModelAudioTrack ModelAudioTrack; +typedef struct _ModelAudioTrackClass ModelAudioTrackClass; + +#define TYPE_TRACK_VIEW (track_view_get_type ()) +#define TRACK_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRACK_VIEW, TrackView)) +#define IS_TRACK_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRACK_VIEW)) +#define TRACK_VIEW_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_TRACK_VIEW, TrackViewIface)) + +typedef struct _TrackView TrackView; +typedef struct _TrackViewIface TrackViewIface; + +#define TYPE_CLIP_VIEW (clip_view_get_type ()) +#define CLIP_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CLIP_VIEW, ClipView)) +#define CLIP_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CLIP_VIEW, ClipViewClass)) +#define IS_CLIP_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CLIP_VIEW)) +#define IS_CLIP_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CLIP_VIEW)) +#define CLIP_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CLIP_VIEW, ClipViewClass)) + +typedef struct _ClipView ClipView; +typedef struct _ClipViewClass ClipViewClass; + +#define TYPE_CLASS_FACTORY (class_factory_get_type ()) +#define CLASS_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CLASS_FACTORY, ClassFactory)) +#define CLASS_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CLASS_FACTORY, ClassFactoryClass)) +#define IS_CLASS_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CLASS_FACTORY)) +#define IS_CLASS_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CLASS_FACTORY)) +#define CLASS_FACTORY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CLASS_FACTORY, ClassFactoryClass)) + +typedef struct _ClassFactory ClassFactory; +typedef struct _ClassFactoryClass ClassFactoryClass; +typedef struct _ClassFactoryPrivate ClassFactoryPrivate; + +#define TYPE_TIME_LINE (time_line_get_type ()) +#define TIME_LINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TIME_LINE, TimeLine)) +#define TIME_LINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TIME_LINE, TimeLineClass)) +#define IS_TIME_LINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TIME_LINE)) +#define IS_TIME_LINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TIME_LINE)) +#define TIME_LINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TIME_LINE, TimeLineClass)) + +typedef struct _TimeLine TimeLine; +typedef struct _TimeLineClass TimeLineClass; + +#define TYPE_TRANSPORT_DELEGATE (transport_delegate_get_type ()) +#define TRANSPORT_DELEGATE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRANSPORT_DELEGATE, TransportDelegate)) +#define IS_TRANSPORT_DELEGATE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRANSPORT_DELEGATE)) +#define TRANSPORT_DELEGATE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_TRANSPORT_DELEGATE, TransportDelegateIface)) + +typedef struct _TransportDelegate TransportDelegate; +typedef struct _TransportDelegateIface TransportDelegateIface; + +#define TYPE_CLIP_LIBRARY_VIEW (clip_library_view_get_type ()) +#define CLIP_LIBRARY_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CLIP_LIBRARY_VIEW, ClipLibraryView)) +#define CLIP_LIBRARY_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CLIP_LIBRARY_VIEW, ClipLibraryViewClass)) +#define IS_CLIP_LIBRARY_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CLIP_LIBRARY_VIEW)) +#define IS_CLIP_LIBRARY_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CLIP_LIBRARY_VIEW)) +#define CLIP_LIBRARY_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CLIP_LIBRARY_VIEW, ClipLibraryViewClass)) + +typedef struct _ClipLibraryView ClipLibraryView; +typedef struct _ClipLibraryViewClass ClipLibraryViewClass; +typedef struct _ClipLibraryViewPrivate ClipLibraryViewPrivate; + +#define MODEL_TYPE_PROJECT (model_project_get_type ()) +#define MODEL_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT, ModelProject)) +#define MODEL_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT, ModelProjectClass)) +#define MODEL_IS_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT)) +#define MODEL_IS_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT)) +#define MODEL_PROJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT, ModelProjectClass)) + +typedef struct _ModelProject ModelProject; +typedef struct _ModelProjectClass ModelProjectClass; + +#define MODEL_TYPE_TIME_SYSTEM (model_time_system_get_type ()) +#define MODEL_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TIME_SYSTEM, ModelTimeSystem)) +#define MODEL_IS_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TIME_SYSTEM)) +#define MODEL_TIME_SYSTEM_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MODEL_TYPE_TIME_SYSTEM, ModelTimeSystemIface)) + +typedef struct _ModelTimeSystem ModelTimeSystem; +typedef struct _ModelTimeSystemIface ModelTimeSystemIface; + +#define MODEL_TYPE_CLIP_FILE (model_clip_file_get_type ()) +#define MODEL_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFile)) +#define MODEL_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) +#define MODEL_IS_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE)) +#define MODEL_IS_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE)) +#define MODEL_CLIP_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) + +typedef struct _ModelClipFile ModelClipFile; +typedef struct _ModelClipFileClass ModelClipFileClass; + +#define MODEL_TYPE_MEDIA_TYPE (model_media_type_get_type ()) + +#define MODEL_TYPE_GAP (model_gap_get_type ()) +#define MODEL_GAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_GAP, ModelGap)) +#define MODEL_GAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_GAP, ModelGapClass)) +#define MODEL_IS_GAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_GAP)) +#define MODEL_IS_GAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_GAP)) +#define MODEL_GAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_GAP, ModelGapClass)) + +typedef struct _ModelGap ModelGap; +typedef struct _ModelGapClass ModelGapClass; +typedef struct _ModelGapPrivate ModelGapPrivate; +typedef struct _ModelClipFilePrivate ModelClipFilePrivate; + +#define TYPE_FRACTION (fraction_get_type ()) +typedef struct _Fraction Fraction; + +#define MODEL_TYPE_FETCHER (model_fetcher_get_type ()) +#define MODEL_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_FETCHER, ModelFetcher)) +#define MODEL_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_FETCHER, ModelFetcherClass)) +#define MODEL_IS_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_FETCHER)) +#define MODEL_IS_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_FETCHER)) +#define MODEL_FETCHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_FETCHER, ModelFetcherClass)) + +typedef struct _ModelFetcher ModelFetcher; +typedef struct _ModelFetcherClass ModelFetcherClass; +typedef struct _ModelFetcherPrivate ModelFetcherPrivate; + +#define MODEL_TYPE_CLIP_FETCHER (model_clip_fetcher_get_type ()) +#define MODEL_CLIP_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcher)) +#define MODEL_CLIP_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcherClass)) +#define MODEL_IS_CLIP_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FETCHER)) +#define MODEL_IS_CLIP_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FETCHER)) +#define MODEL_CLIP_FETCHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcherClass)) + +typedef struct _ModelClipFetcher ModelClipFetcher; +typedef struct _ModelClipFetcherClass ModelClipFetcherClass; +typedef struct _ModelClipFetcherPrivate ModelClipFetcherPrivate; + +#define MODEL_TYPE_THUMBNAIL_FETCHER (model_thumbnail_fetcher_get_type ()) +#define MODEL_THUMBNAIL_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_THUMBNAIL_FETCHER, ModelThumbnailFetcher)) +#define MODEL_THUMBNAIL_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_THUMBNAIL_FETCHER, ModelThumbnailFetcherClass)) +#define MODEL_IS_THUMBNAIL_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_THUMBNAIL_FETCHER)) +#define MODEL_IS_THUMBNAIL_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_THUMBNAIL_FETCHER)) +#define MODEL_THUMBNAIL_FETCHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_THUMBNAIL_FETCHER, ModelThumbnailFetcherClass)) + +typedef struct _ModelThumbnailFetcher ModelThumbnailFetcher; +typedef struct _ModelThumbnailFetcherClass ModelThumbnailFetcherClass; +typedef struct _ModelThumbnailFetcherPrivate ModelThumbnailFetcherPrivate; + +#define MODEL_TYPE_CLIP (model_clip_get_type ()) +#define MODEL_CLIP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP, ModelClip)) +#define MODEL_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP, ModelClipClass)) +#define MODEL_IS_CLIP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP)) +#define MODEL_IS_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP)) +#define MODEL_CLIP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP, ModelClipClass)) + +typedef struct _ModelClip ModelClip; +typedef struct _ModelClipClass ModelClipClass; +typedef struct _ModelClipPrivate ModelClipPrivate; + +#define MODEL_TYPE_FETCHER_COMPLETION (model_fetcher_completion_get_type ()) +#define MODEL_FETCHER_COMPLETION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_FETCHER_COMPLETION, ModelFetcherCompletion)) +#define MODEL_FETCHER_COMPLETION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_FETCHER_COMPLETION, ModelFetcherCompletionClass)) +#define MODEL_IS_FETCHER_COMPLETION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_FETCHER_COMPLETION)) +#define MODEL_IS_FETCHER_COMPLETION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_FETCHER_COMPLETION)) +#define MODEL_FETCHER_COMPLETION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_FETCHER_COMPLETION, ModelFetcherCompletionClass)) + +typedef struct _ModelFetcherCompletion ModelFetcherCompletion; +typedef struct _ModelFetcherCompletionClass ModelFetcherCompletionClass; +typedef struct _ModelFetcherCompletionPrivate ModelFetcherCompletionPrivate; + +#define MODEL_TYPE_COMMAND (model_command_get_type ()) +#define MODEL_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_COMMAND, ModelCommand)) +#define MODEL_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_COMMAND, ModelCommandClass)) +#define MODEL_IS_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_COMMAND)) +#define MODEL_IS_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_COMMAND)) +#define MODEL_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_COMMAND, ModelCommandClass)) + +typedef struct _ModelCommand ModelCommand; +typedef struct _ModelCommandClass ModelCommandClass; +typedef struct _ModelCommandPrivate ModelCommandPrivate; + +#define MODEL_TYPE_PARAMETER (model_parameter_get_type ()) + +#define MODEL_TYPE_PARAMETER_COMMAND (model_parameter_command_get_type ()) +#define MODEL_PARAMETER_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PARAMETER_COMMAND, ModelParameterCommand)) +#define MODEL_PARAMETER_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PARAMETER_COMMAND, ModelParameterCommandClass)) +#define MODEL_IS_PARAMETER_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PARAMETER_COMMAND)) +#define MODEL_IS_PARAMETER_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PARAMETER_COMMAND)) +#define MODEL_PARAMETER_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PARAMETER_COMMAND, ModelParameterCommandClass)) + +typedef struct _ModelParameterCommand ModelParameterCommand; +typedef struct _ModelParameterCommandClass ModelParameterCommandClass; +typedef struct _ModelParameterCommandPrivate ModelParameterCommandPrivate; + +#define MODEL_TYPE_CLIP_COMMAND (model_clip_command_get_type ()) +#define MODEL_CLIP_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_COMMAND, ModelClipCommand)) +#define MODEL_CLIP_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_COMMAND, ModelClipCommandClass)) +#define MODEL_IS_CLIP_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_COMMAND)) +#define MODEL_IS_CLIP_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_COMMAND)) +#define MODEL_CLIP_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_COMMAND, ModelClipCommandClass)) + +typedef struct _ModelClipCommand ModelClipCommand; +typedef struct _ModelClipCommandClass ModelClipCommandClass; +typedef struct _ModelClipCommandPrivate ModelClipCommandPrivate; + +#define MODEL_CLIP_COMMAND_TYPE_ACTION (model_clip_command_action_get_type ()) + +#define MODEL_TYPE_CLIP_ADD_COMMAND (model_clip_add_command_get_type ()) +#define MODEL_CLIP_ADD_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_ADD_COMMAND, ModelClipAddCommand)) +#define MODEL_CLIP_ADD_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_ADD_COMMAND, ModelClipAddCommandClass)) +#define MODEL_IS_CLIP_ADD_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_ADD_COMMAND)) +#define MODEL_IS_CLIP_ADD_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_ADD_COMMAND)) +#define MODEL_CLIP_ADD_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_ADD_COMMAND, ModelClipAddCommandClass)) + +typedef struct _ModelClipAddCommand ModelClipAddCommand; +typedef struct _ModelClipAddCommandClass ModelClipAddCommandClass; +typedef struct _ModelClipAddCommandPrivate ModelClipAddCommandPrivate; + +#define MODEL_TYPE_CLIP_SPLIT_COMMAND (model_clip_split_command_get_type ()) +#define MODEL_CLIP_SPLIT_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_SPLIT_COMMAND, ModelClipSplitCommand)) +#define MODEL_CLIP_SPLIT_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_SPLIT_COMMAND, ModelClipSplitCommandClass)) +#define MODEL_IS_CLIP_SPLIT_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_SPLIT_COMMAND)) +#define MODEL_IS_CLIP_SPLIT_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_SPLIT_COMMAND)) +#define MODEL_CLIP_SPLIT_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_SPLIT_COMMAND, ModelClipSplitCommandClass)) + +typedef struct _ModelClipSplitCommand ModelClipSplitCommand; +typedef struct _ModelClipSplitCommandClass ModelClipSplitCommandClass; +typedef struct _ModelClipSplitCommandPrivate ModelClipSplitCommandPrivate; + +#define MODEL_CLIP_SPLIT_COMMAND_TYPE_ACTION (model_clip_split_command_action_get_type ()) + +#define MODEL_TYPE_CLIP_FILE_DELETE_COMMAND (model_clip_file_delete_command_get_type ()) +#define MODEL_CLIP_FILE_DELETE_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND, ModelClipFileDeleteCommand)) +#define MODEL_CLIP_FILE_DELETE_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND, ModelClipFileDeleteCommandClass)) +#define MODEL_IS_CLIP_FILE_DELETE_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND)) +#define MODEL_IS_CLIP_FILE_DELETE_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND)) +#define MODEL_CLIP_FILE_DELETE_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND, ModelClipFileDeleteCommandClass)) + +typedef struct _ModelClipFileDeleteCommand ModelClipFileDeleteCommand; +typedef struct _ModelClipFileDeleteCommandClass ModelClipFileDeleteCommandClass; +typedef struct _ModelClipFileDeleteCommandPrivate ModelClipFileDeleteCommandPrivate; + +#define MODEL_TYPE_CLIP_TRIM_COMMAND (model_clip_trim_command_get_type ()) +#define MODEL_CLIP_TRIM_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_TRIM_COMMAND, ModelClipTrimCommand)) +#define MODEL_CLIP_TRIM_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_TRIM_COMMAND, ModelClipTrimCommandClass)) +#define MODEL_IS_CLIP_TRIM_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_TRIM_COMMAND)) +#define MODEL_IS_CLIP_TRIM_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_TRIM_COMMAND)) +#define MODEL_CLIP_TRIM_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_TRIM_COMMAND, ModelClipTrimCommandClass)) + +typedef struct _ModelClipTrimCommand ModelClipTrimCommand; +typedef struct _ModelClipTrimCommandClass ModelClipTrimCommandClass; +typedef struct _ModelClipTrimCommandPrivate ModelClipTrimCommandPrivate; + +#define MODEL_TYPE_CLIP_REVERT_COMMAND (model_clip_revert_command_get_type ()) +#define MODEL_CLIP_REVERT_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_REVERT_COMMAND, ModelClipRevertCommand)) +#define MODEL_CLIP_REVERT_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_REVERT_COMMAND, ModelClipRevertCommandClass)) +#define MODEL_IS_CLIP_REVERT_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_REVERT_COMMAND)) +#define MODEL_IS_CLIP_REVERT_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_REVERT_COMMAND)) +#define MODEL_CLIP_REVERT_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_REVERT_COMMAND, ModelClipRevertCommandClass)) + +typedef struct _ModelClipRevertCommand ModelClipRevertCommand; +typedef struct _ModelClipRevertCommandClass ModelClipRevertCommandClass; +typedef struct _ModelClipRevertCommandPrivate ModelClipRevertCommandPrivate; + +#define MODEL_TYPE_TIME_SIGNATURE_COMMAND (model_time_signature_command_get_type ()) +#define MODEL_TIME_SIGNATURE_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TIME_SIGNATURE_COMMAND, ModelTimeSignatureCommand)) +#define MODEL_TIME_SIGNATURE_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TIME_SIGNATURE_COMMAND, ModelTimeSignatureCommandClass)) +#define MODEL_IS_TIME_SIGNATURE_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TIME_SIGNATURE_COMMAND)) +#define MODEL_IS_TIME_SIGNATURE_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TIME_SIGNATURE_COMMAND)) +#define MODEL_TIME_SIGNATURE_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TIME_SIGNATURE_COMMAND, ModelTimeSignatureCommandClass)) + +typedef struct _ModelTimeSignatureCommand ModelTimeSignatureCommand; +typedef struct _ModelTimeSignatureCommandClass ModelTimeSignatureCommandClass; +typedef struct _ModelTimeSignatureCommandPrivate ModelTimeSignatureCommandPrivate; + +#define MODEL_TYPE_BPM_COMMAND (model_bpm_command_get_type ()) +#define MODEL_BPM_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_BPM_COMMAND, ModelBpmCommand)) +#define MODEL_BPM_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_BPM_COMMAND, ModelBpmCommandClass)) +#define MODEL_IS_BPM_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_BPM_COMMAND)) +#define MODEL_IS_BPM_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_BPM_COMMAND)) +#define MODEL_BPM_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_BPM_COMMAND, ModelBpmCommandClass)) + +typedef struct _ModelBpmCommand ModelBpmCommand; +typedef struct _ModelBpmCommandClass ModelBpmCommandClass; +typedef struct _ModelBpmCommandPrivate ModelBpmCommandPrivate; + +#define MODEL_TYPE_ADD_CLIP_COMMAND (model_add_clip_command_get_type ()) +#define MODEL_ADD_CLIP_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_ADD_CLIP_COMMAND, ModelAddClipCommand)) +#define MODEL_ADD_CLIP_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_ADD_CLIP_COMMAND, ModelAddClipCommandClass)) +#define MODEL_IS_ADD_CLIP_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_ADD_CLIP_COMMAND)) +#define MODEL_IS_ADD_CLIP_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_ADD_CLIP_COMMAND)) +#define MODEL_ADD_CLIP_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_ADD_CLIP_COMMAND, ModelAddClipCommandClass)) + +typedef struct _ModelAddClipCommand ModelAddClipCommand; +typedef struct _ModelAddClipCommandClass ModelAddClipCommandClass; +typedef struct _ModelAddClipCommandPrivate ModelAddClipCommandPrivate; + +#define MODEL_TYPE_TRANSACTION_COMMAND (model_transaction_command_get_type ()) +#define MODEL_TRANSACTION_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TRANSACTION_COMMAND, ModelTransactionCommand)) +#define MODEL_TRANSACTION_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TRANSACTION_COMMAND, ModelTransactionCommandClass)) +#define MODEL_IS_TRANSACTION_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TRANSACTION_COMMAND)) +#define MODEL_IS_TRANSACTION_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TRANSACTION_COMMAND)) +#define MODEL_TRANSACTION_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TRANSACTION_COMMAND, ModelTransactionCommandClass)) + +typedef struct _ModelTransactionCommand ModelTransactionCommand; +typedef struct _ModelTransactionCommandClass ModelTransactionCommandClass; +typedef struct _ModelTransactionCommandPrivate ModelTransactionCommandPrivate; + +#define DIALOG_UTILS_TYPE_FILTER_DESCRIPTION_STRUCT (dialog_utils_filter_description_struct_get_type ()) +typedef struct _DialogUtilsfilter_description_struct DialogUtilsfilter_description_struct; + +#define TYPE_MULTI_FILE_PROGRESS_INTERFACE (multi_file_progress_interface_get_type ()) +#define MULTI_FILE_PROGRESS_INTERFACE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MULTI_FILE_PROGRESS_INTERFACE, MultiFileProgressInterface)) +#define IS_MULTI_FILE_PROGRESS_INTERFACE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MULTI_FILE_PROGRESS_INTERFACE)) +#define MULTI_FILE_PROGRESS_INTERFACE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_MULTI_FILE_PROGRESS_INTERFACE, MultiFileProgressInterfaceIface)) + +typedef struct _MultiFileProgressInterface MultiFileProgressInterface; +typedef struct _MultiFileProgressInterfaceIface MultiFileProgressInterfaceIface; + +#define MODEL_TYPE_CLIP_IMPORTER (model_clip_importer_get_type ()) +#define MODEL_CLIP_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_IMPORTER, ModelClipImporter)) +#define MODEL_CLIP_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_IMPORTER, ModelClipImporterClass)) +#define MODEL_IS_CLIP_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_IMPORTER)) +#define MODEL_IS_CLIP_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_IMPORTER)) +#define MODEL_CLIP_IMPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_IMPORTER, ModelClipImporterClass)) + +typedef struct _ModelClipImporter ModelClipImporter; +typedef struct _ModelClipImporterClass ModelClipImporterClass; +typedef struct _ModelClipImporterPrivate ModelClipImporterPrivate; + +#define MODEL_TYPE_LIBRARY_IMPORTER (model_library_importer_get_type ()) +#define MODEL_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporter)) +#define MODEL_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass)) +#define MODEL_IS_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_LIBRARY_IMPORTER)) +#define MODEL_IS_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_LIBRARY_IMPORTER)) +#define MODEL_LIBRARY_IMPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass)) + +typedef struct _ModelLibraryImporter ModelLibraryImporter; +typedef struct _ModelLibraryImporterClass ModelLibraryImporterClass; +typedef struct _ModelLibraryImporterPrivate ModelLibraryImporterPrivate; + +#define MODEL_TYPE_TIMELINE_IMPORTER (model_timeline_importer_get_type ()) +#define MODEL_TIMELINE_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TIMELINE_IMPORTER, ModelTimelineImporter)) +#define MODEL_TIMELINE_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TIMELINE_IMPORTER, ModelTimelineImporterClass)) +#define MODEL_IS_TIMELINE_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TIMELINE_IMPORTER)) +#define MODEL_IS_TIMELINE_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TIMELINE_IMPORTER)) +#define MODEL_TIMELINE_IMPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TIMELINE_IMPORTER, ModelTimelineImporterClass)) + +typedef struct _ModelTimelineImporter ModelTimelineImporter; +typedef struct _ModelTimelineImporterClass ModelTimelineImporterClass; +typedef struct _ModelTimelineImporterPrivate ModelTimelineImporterPrivate; + +#define LOGGING_TYPE_FACILITY (logging_facility_get_type ()) + +#define LOGGING_TYPE_LEVEL (logging_level_get_type ()) + +#define TYPE_PLAY_STATE (play_state_get_type ()) + +#define VIEW_TYPE_MEDIA_TRACK (view_media_track_get_type ()) +#define VIEW_MEDIA_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_TRACK, ViewMediaTrack)) +#define VIEW_MEDIA_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_TRACK, ViewMediaTrackClass)) +#define VIEW_IS_MEDIA_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_TRACK)) +#define VIEW_IS_MEDIA_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_TRACK)) +#define VIEW_MEDIA_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_TRACK, ViewMediaTrackClass)) + +typedef struct _ViewMediaTrack ViewMediaTrack; +typedef struct _ViewMediaTrackClass ViewMediaTrackClass; +typedef struct _ViewMediaTrackPrivate ViewMediaTrackPrivate; + +#define VIEW_TYPE_MEDIA_ENGINE (view_media_engine_get_type ()) +#define VIEW_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngine)) +#define VIEW_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass)) +#define VIEW_IS_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_ENGINE)) +#define VIEW_IS_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_ENGINE)) +#define VIEW_MEDIA_ENGINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass)) + +typedef struct _ViewMediaEngine ViewMediaEngine; +typedef struct _ViewMediaEngineClass ViewMediaEngineClass; + +#define VIEW_TYPE_MEDIA_VIDEO_TRACK (view_media_video_track_get_type ()) +#define VIEW_MEDIA_VIDEO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_VIDEO_TRACK, ViewMediaVideoTrack)) +#define VIEW_MEDIA_VIDEO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_VIDEO_TRACK, ViewMediaVideoTrackClass)) +#define VIEW_IS_MEDIA_VIDEO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_VIDEO_TRACK)) +#define VIEW_IS_MEDIA_VIDEO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_VIDEO_TRACK)) +#define VIEW_MEDIA_VIDEO_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_VIDEO_TRACK, ViewMediaVideoTrackClass)) + +typedef struct _ViewMediaVideoTrack ViewMediaVideoTrack; +typedef struct _ViewMediaVideoTrackClass ViewMediaVideoTrackClass; +typedef struct _ViewMediaVideoTrackPrivate ViewMediaVideoTrackPrivate; + +#define VIEW_TYPE_CLICK_TRACK (view_click_track_get_type ()) +#define VIEW_CLICK_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_CLICK_TRACK, ViewClickTrack)) +#define VIEW_CLICK_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_CLICK_TRACK, ViewClickTrackClass)) +#define VIEW_IS_CLICK_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_CLICK_TRACK)) +#define VIEW_IS_CLICK_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_CLICK_TRACK)) +#define VIEW_CLICK_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_CLICK_TRACK, ViewClickTrackClass)) + +typedef struct _ViewClickTrack ViewClickTrack; +typedef struct _ViewClickTrackClass ViewClickTrackClass; +typedef struct _ViewClickTrackPrivate ViewClickTrackPrivate; + +#define VIEW_TYPE_MEDIA_AUDIO_TRACK (view_media_audio_track_get_type ()) +#define VIEW_MEDIA_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_AUDIO_TRACK, ViewMediaAudioTrack)) +#define VIEW_MEDIA_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_AUDIO_TRACK, ViewMediaAudioTrackClass)) +#define VIEW_IS_MEDIA_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_AUDIO_TRACK)) +#define VIEW_IS_MEDIA_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_AUDIO_TRACK)) +#define VIEW_MEDIA_AUDIO_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_AUDIO_TRACK, ViewMediaAudioTrackClass)) + +typedef struct _ViewMediaAudioTrack ViewMediaAudioTrack; +typedef struct _ViewMediaAudioTrackClass ViewMediaAudioTrackClass; +typedef struct _ViewMediaAudioTrackPrivate ViewMediaAudioTrackPrivate; + +#define VIEW_TYPE_MEDIA_CONNECTOR (view_media_connector_get_type ()) +#define VIEW_MEDIA_CONNECTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_CONNECTOR, ViewMediaConnector)) +#define VIEW_MEDIA_CONNECTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_CONNECTOR, ViewMediaConnectorClass)) +#define VIEW_IS_MEDIA_CONNECTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_CONNECTOR)) +#define VIEW_IS_MEDIA_CONNECTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_CONNECTOR)) +#define VIEW_MEDIA_CONNECTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_CONNECTOR, ViewMediaConnectorClass)) + +typedef struct _ViewMediaConnector ViewMediaConnector; +typedef struct _ViewMediaConnectorClass ViewMediaConnectorClass; +typedef struct _ViewMediaConnectorPrivate ViewMediaConnectorPrivate; + +#define VIEW_MEDIA_CONNECTOR_TYPE_MEDIA_TYPES (view_media_connector_media_types_get_type ()) + +#define VIEW_TYPE_VIDEO_OUTPUT (view_video_output_get_type ()) +#define VIEW_VIDEO_OUTPUT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_VIDEO_OUTPUT, ViewVideoOutput)) +#define VIEW_VIDEO_OUTPUT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_VIDEO_OUTPUT, ViewVideoOutputClass)) +#define VIEW_IS_VIDEO_OUTPUT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_VIDEO_OUTPUT)) +#define VIEW_IS_VIDEO_OUTPUT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_VIDEO_OUTPUT)) +#define VIEW_VIDEO_OUTPUT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_VIDEO_OUTPUT, ViewVideoOutputClass)) + +typedef struct _ViewVideoOutput ViewVideoOutput; +typedef struct _ViewVideoOutputClass ViewVideoOutputClass; +typedef struct _ViewVideoOutputPrivate ViewVideoOutputPrivate; + +#define VIEW_TYPE_AUDIO_OUTPUT (view_audio_output_get_type ()) +#define VIEW_AUDIO_OUTPUT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_AUDIO_OUTPUT, ViewAudioOutput)) +#define VIEW_AUDIO_OUTPUT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_AUDIO_OUTPUT, ViewAudioOutputClass)) +#define VIEW_IS_AUDIO_OUTPUT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_AUDIO_OUTPUT)) +#define VIEW_IS_AUDIO_OUTPUT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_AUDIO_OUTPUT)) +#define VIEW_AUDIO_OUTPUT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_AUDIO_OUTPUT, ViewAudioOutputClass)) + +typedef struct _ViewAudioOutput ViewAudioOutput; +typedef struct _ViewAudioOutputClass ViewAudioOutputClass; +typedef struct _ViewAudioOutputPrivate ViewAudioOutputPrivate; + +#define VIEW_TYPE_OGG_VORBIS_EXPORT (view_ogg_vorbis_export_get_type ()) +#define VIEW_OGG_VORBIS_EXPORT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_OGG_VORBIS_EXPORT, ViewOggVorbisExport)) +#define VIEW_OGG_VORBIS_EXPORT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_OGG_VORBIS_EXPORT, ViewOggVorbisExportClass)) +#define VIEW_IS_OGG_VORBIS_EXPORT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_OGG_VORBIS_EXPORT)) +#define VIEW_IS_OGG_VORBIS_EXPORT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_OGG_VORBIS_EXPORT)) +#define VIEW_OGG_VORBIS_EXPORT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_OGG_VORBIS_EXPORT, ViewOggVorbisExportClass)) + +typedef struct _ViewOggVorbisExport ViewOggVorbisExport; +typedef struct _ViewOggVorbisExportClass ViewOggVorbisExportClass; +typedef struct _ViewOggVorbisExportPrivate ViewOggVorbisExportPrivate; +typedef struct _ViewMediaEnginePrivate ViewMediaEnginePrivate; + +#define TYPE_MULTI_FILE_PROGRESS (multi_file_progress_get_type ()) +#define MULTI_FILE_PROGRESS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MULTI_FILE_PROGRESS, MultiFileProgress)) +#define MULTI_FILE_PROGRESS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_MULTI_FILE_PROGRESS, MultiFileProgressClass)) +#define IS_MULTI_FILE_PROGRESS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MULTI_FILE_PROGRESS)) +#define IS_MULTI_FILE_PROGRESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_MULTI_FILE_PROGRESS)) +#define MULTI_FILE_PROGRESS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_MULTI_FILE_PROGRESS, MultiFileProgressClass)) + +typedef struct _MultiFileProgress MultiFileProgress; +typedef struct _MultiFileProgressClass MultiFileProgressClass; +typedef struct _MultiFileProgressPrivate MultiFileProgressPrivate; + +#define MODEL_TYPE_LOADER_HANDLER (model_loader_handler_get_type ()) +#define MODEL_LOADER_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_LOADER_HANDLER, ModelLoaderHandler)) +#define MODEL_LOADER_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_LOADER_HANDLER, ModelLoaderHandlerClass)) +#define MODEL_IS_LOADER_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_LOADER_HANDLER)) +#define MODEL_IS_LOADER_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_LOADER_HANDLER)) +#define MODEL_LOADER_HANDLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_LOADER_HANDLER, ModelLoaderHandlerClass)) + +typedef struct _ModelLoaderHandler ModelLoaderHandler; +typedef struct _ModelLoaderHandlerClass ModelLoaderHandlerClass; +typedef struct _ModelLoaderHandlerPrivate ModelLoaderHandlerPrivate; + +#define MODEL_TYPE_XML_TREE_LOADER (model_xml_tree_loader_get_type ()) +#define MODEL_XML_TREE_LOADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_XML_TREE_LOADER, ModelXmlTreeLoader)) +#define MODEL_XML_TREE_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_XML_TREE_LOADER, ModelXmlTreeLoaderClass)) +#define MODEL_IS_XML_TREE_LOADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_XML_TREE_LOADER)) +#define MODEL_IS_XML_TREE_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_XML_TREE_LOADER)) +#define MODEL_XML_TREE_LOADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_XML_TREE_LOADER, ModelXmlTreeLoaderClass)) + +typedef struct _ModelXmlTreeLoader ModelXmlTreeLoader; +typedef struct _ModelXmlTreeLoaderClass ModelXmlTreeLoaderClass; +typedef struct _ModelXmlTreeLoaderPrivate ModelXmlTreeLoaderPrivate; + +#define MODEL_TYPE_XML_ELEMENT (model_xml_element_get_type ()) +#define MODEL_XML_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_XML_ELEMENT, ModelXmlElement)) +#define MODEL_XML_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_XML_ELEMENT, ModelXmlElementClass)) +#define MODEL_IS_XML_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_XML_ELEMENT)) +#define MODEL_IS_XML_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_XML_ELEMENT)) +#define MODEL_XML_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_XML_ELEMENT, ModelXmlElementClass)) + +typedef struct _ModelXmlElement ModelXmlElement; +typedef struct _ModelXmlElementClass ModelXmlElementClass; +typedef struct _ModelXmlElementPrivate ModelXmlElementPrivate; + +#define MODEL_TYPE_PROJECT_LOADER (model_project_loader_get_type ()) +#define MODEL_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoader)) +#define MODEL_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass)) +#define MODEL_IS_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT_LOADER)) +#define MODEL_IS_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT_LOADER)) +#define MODEL_PROJECT_LOADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass)) + +typedef struct _ModelProjectLoader ModelProjectLoader; +typedef struct _ModelProjectLoaderClass ModelProjectLoaderClass; +typedef struct _ModelProjectLoaderPrivate ModelProjectLoaderPrivate; + +#define MODEL_TYPE_MEDIA_LOADER_HANDLER (model_media_loader_handler_get_type ()) +#define MODEL_MEDIA_LOADER_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_MEDIA_LOADER_HANDLER, ModelMediaLoaderHandler)) +#define MODEL_MEDIA_LOADER_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_MEDIA_LOADER_HANDLER, ModelMediaLoaderHandlerClass)) +#define MODEL_IS_MEDIA_LOADER_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_MEDIA_LOADER_HANDLER)) +#define MODEL_IS_MEDIA_LOADER_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_MEDIA_LOADER_HANDLER)) +#define MODEL_MEDIA_LOADER_HANDLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_MEDIA_LOADER_HANDLER, ModelMediaLoaderHandlerClass)) + +typedef struct _ModelMediaLoaderHandler ModelMediaLoaderHandler; +typedef struct _ModelMediaLoaderHandlerClass ModelMediaLoaderHandlerClass; +typedef struct _ModelMediaLoaderHandlerPrivate ModelMediaLoaderHandlerPrivate; + +#define MODEL_TYPE_TEMPO_INFORMATION (model_tempo_information_get_type ()) +#define MODEL_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformation)) +#define MODEL_IS_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TEMPO_INFORMATION)) +#define MODEL_TEMPO_INFORMATION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformationIface)) + +typedef struct _ModelTempoInformation ModelTempoInformation; +typedef struct _ModelTempoInformationIface ModelTempoInformationIface; +typedef struct _ModelProjectPrivate ModelProjectPrivate; + +#define TYPE_TIME_CODE (time_code_get_type ()) +typedef struct _TimeCode TimeCode; + +#define MODEL_TYPE_UNDO_MANAGER (model_undo_manager_get_type ()) +#define MODEL_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManager)) +#define MODEL_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass)) +#define MODEL_IS_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_UNDO_MANAGER)) +#define MODEL_IS_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_UNDO_MANAGER)) +#define MODEL_UNDO_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass)) + +typedef struct _ModelUndoManager ModelUndoManager; +typedef struct _ModelUndoManagerClass ModelUndoManagerClass; + +#define MODEL_TYPE_VIDEO_TRACK (model_video_track_get_type ()) +#define MODEL_VIDEO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_VIDEO_TRACK, ModelVideoTrack)) +#define MODEL_VIDEO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_VIDEO_TRACK, ModelVideoTrackClass)) +#define MODEL_IS_VIDEO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_VIDEO_TRACK)) +#define MODEL_IS_VIDEO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_VIDEO_TRACK)) +#define MODEL_VIDEO_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_VIDEO_TRACK, ModelVideoTrackClass)) + +typedef struct _ModelVideoTrack ModelVideoTrack; +typedef struct _ModelVideoTrackClass ModelVideoTrackClass; + +#define VIEW_TYPE_RULER (view_ruler_get_type ()) +#define VIEW_RULER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_RULER, ViewRuler)) +#define VIEW_RULER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_RULER, ViewRulerClass)) +#define VIEW_IS_RULER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_RULER)) +#define VIEW_IS_RULER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_RULER)) +#define VIEW_RULER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_RULER, ViewRulerClass)) + +typedef struct _ViewRuler ViewRuler; +typedef struct _ViewRulerClass ViewRulerClass; +typedef struct _ViewRulerPrivate ViewRulerPrivate; + +#define VIEW_TYPE_STATUS_BAR (view_status_bar_get_type ()) +#define VIEW_STATUS_BAR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_STATUS_BAR, ViewStatusBar)) +#define VIEW_STATUS_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_STATUS_BAR, ViewStatusBarClass)) +#define VIEW_IS_STATUS_BAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_STATUS_BAR)) +#define VIEW_IS_STATUS_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_STATUS_BAR)) +#define VIEW_STATUS_BAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_STATUS_BAR, ViewStatusBarClass)) + +typedef struct _ViewStatusBar ViewStatusBar; +typedef struct _ViewStatusBarClass ViewStatusBarClass; +typedef struct _ViewStatusBarPrivate ViewStatusBarPrivate; + +#define TYPE_TRACK_CLIP_PAIR (track_clip_pair_get_type ()) +#define TRACK_CLIP_PAIR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRACK_CLIP_PAIR, TrackClipPair)) +#define TRACK_CLIP_PAIR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TRACK_CLIP_PAIR, TrackClipPairClass)) +#define IS_TRACK_CLIP_PAIR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRACK_CLIP_PAIR)) +#define IS_TRACK_CLIP_PAIR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TRACK_CLIP_PAIR)) +#define TRACK_CLIP_PAIR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TRACK_CLIP_PAIR, TrackClipPairClass)) + +typedef struct _TrackClipPair TrackClipPair; +typedef struct _TrackClipPairClass TrackClipPairClass; +typedef struct _TrackClipPairPrivate TrackClipPairPrivate; + +#define TYPE_CLIPBOARD (clipboard_get_type ()) +#define CLIPBOARD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CLIPBOARD, Clipboard)) +#define CLIPBOARD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CLIPBOARD, ClipboardClass)) +#define IS_CLIPBOARD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CLIPBOARD)) +#define IS_CLIPBOARD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CLIPBOARD)) +#define CLIPBOARD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CLIPBOARD, ClipboardClass)) + +typedef struct _Clipboard Clipboard; +typedef struct _ClipboardClass ClipboardClass; +typedef struct _ClipboardPrivate ClipboardPrivate; +typedef struct _TimeLinePrivate TimeLinePrivate; + +#define MODEL_TYPE_TIME_SYSTEM_BASE (model_time_system_base_get_type ()) +#define MODEL_TIME_SYSTEM_BASE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TIME_SYSTEM_BASE, ModelTimeSystemBase)) +#define MODEL_TIME_SYSTEM_BASE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TIME_SYSTEM_BASE, ModelTimeSystemBaseClass)) +#define MODEL_IS_TIME_SYSTEM_BASE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TIME_SYSTEM_BASE)) +#define MODEL_IS_TIME_SYSTEM_BASE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TIME_SYSTEM_BASE)) +#define MODEL_TIME_SYSTEM_BASE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TIME_SYSTEM_BASE, ModelTimeSystemBaseClass)) + +typedef struct _ModelTimeSystemBase ModelTimeSystemBase; +typedef struct _ModelTimeSystemBaseClass ModelTimeSystemBaseClass; +typedef struct _ModelTimeSystemBasePrivate ModelTimeSystemBasePrivate; + +#define MODEL_TYPE_TIMECODE_TIME_SYSTEM (model_timecode_time_system_get_type ()) +#define MODEL_TIMECODE_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TIMECODE_TIME_SYSTEM, ModelTimecodeTimeSystem)) +#define MODEL_TIMECODE_TIME_SYSTEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TIMECODE_TIME_SYSTEM, ModelTimecodeTimeSystemClass)) +#define MODEL_IS_TIMECODE_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TIMECODE_TIME_SYSTEM)) +#define MODEL_IS_TIMECODE_TIME_SYSTEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TIMECODE_TIME_SYSTEM)) +#define MODEL_TIMECODE_TIME_SYSTEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TIMECODE_TIME_SYSTEM, ModelTimecodeTimeSystemClass)) + +typedef struct _ModelTimecodeTimeSystem ModelTimecodeTimeSystem; +typedef struct _ModelTimecodeTimeSystemClass ModelTimecodeTimeSystemClass; +typedef struct _ModelTimecodeTimeSystemPrivate ModelTimecodeTimeSystemPrivate; + +#define MODEL_TYPE_BAR_BEAT_TIME_SYSTEM (model_bar_beat_time_system_get_type ()) +#define MODEL_BAR_BEAT_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_BAR_BEAT_TIME_SYSTEM, ModelBarBeatTimeSystem)) +#define MODEL_BAR_BEAT_TIME_SYSTEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_BAR_BEAT_TIME_SYSTEM, ModelBarBeatTimeSystemClass)) +#define MODEL_IS_BAR_BEAT_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_BAR_BEAT_TIME_SYSTEM)) +#define MODEL_IS_BAR_BEAT_TIME_SYSTEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_BAR_BEAT_TIME_SYSTEM)) +#define MODEL_BAR_BEAT_TIME_SYSTEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_BAR_BEAT_TIME_SYSTEM, ModelBarBeatTimeSystemClass)) + +typedef struct _ModelBarBeatTimeSystem ModelBarBeatTimeSystem; +typedef struct _ModelBarBeatTimeSystemClass ModelBarBeatTimeSystemClass; +typedef struct _ModelBarBeatTimeSystemPrivate ModelBarBeatTimeSystemPrivate; +typedef struct _ModelTrackPrivate ModelTrackPrivate; +typedef struct _ModelAudioTrackPrivate ModelAudioTrackPrivate; + +#define TYPE_GAP_VIEW (gap_view_get_type ()) +#define GAP_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_GAP_VIEW, GapView)) +#define GAP_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_GAP_VIEW, GapViewClass)) +#define IS_GAP_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_GAP_VIEW)) +#define IS_GAP_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_GAP_VIEW)) +#define GAP_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_GAP_VIEW, GapViewClass)) + +typedef struct _GapView GapView; +typedef struct _GapViewClass GapViewClass; +typedef struct _GapViewPrivate GapViewPrivate; +typedef struct _ClipViewPrivate ClipViewPrivate; +typedef struct _ModelUndoManagerPrivate ModelUndoManagerPrivate; +typedef struct _ModelVideoTrackPrivate ModelVideoTrackPrivate; + +struct _AppDirs { + GTypeInstance parent_instance; + volatile int ref_count; + AppDirsPrivate * priv; +}; + +struct _AppDirsClass { + GTypeClass parent_class; + void (*finalize) (AppDirs *self); +}; + +struct _ViewAudioMeter { + GtkDrawingArea parent_instance; + ViewAudioMeterPrivate * priv; +}; + +struct _ViewAudioMeterClass { + GtkDrawingAreaClass parent_class; +}; + +struct _TrackViewIface { + GTypeInterface parent_iface; + void (*move_to_top) (TrackView* self, ClipView* clip_view); + void (*resize) (TrackView* self); + ModelTrack* (*get_track) (TrackView* self); + gint (*get_track_height) (TrackView* self); + GtkWidget* (*find_child) (TrackView* self, double x, double y); + void (*select_all) (TrackView* self); +}; + +struct _ClassFactory { + GTypeInstance parent_instance; + volatile int ref_count; + ClassFactoryPrivate * priv; +}; + +struct _ClassFactoryClass { + GTypeClass parent_class; + void (*finalize) (ClassFactory *self); + TrackView* (*get_track_view) (ClassFactory* self, ModelTrack* track, TimeLine* timeline); +}; + +struct _TransportDelegateIface { + GTypeInterface parent_iface; + gboolean (*is_playing) (TransportDelegate* self); + gboolean (*is_recording) (TransportDelegate* self); + gboolean (*is_stopped) (TransportDelegate* self); +}; + +struct _ClipLibraryView { + GtkEventBox parent_instance; + ClipLibraryViewPrivate * priv; +}; + +struct _ClipLibraryViewClass { + GtkEventBoxClass parent_class; +}; + +struct _ModelTimeSystemIface { + GTypeInterface parent_iface; + void (*calculate_pixel_step) (ModelTimeSystem* self, float inc, float pixel_min, float pixel_div); + gint64 (*xpos_to_time) (ModelTimeSystem* self, gint x); + gint64 (*xsize_to_time) (ModelTimeSystem* self, gint x); + gint (*time_to_xpos) (ModelTimeSystem* self, gint64 time); + gint64 (*get_pixel_snap_time) (ModelTimeSystem* self); + gint (*time_to_xsize) (ModelTimeSystem* self, gint64 time); + float (*get_pixel_percentage) (ModelTimeSystem* self); + gint (*get_start_token) (ModelTimeSystem* self, gint xsize); + gint (*get_next_position) (ModelTimeSystem* self, gint token); + gint (*get_pixel_height) (ModelTimeSystem* self, gint token); + char* (*get_display_string) (ModelTimeSystem* self, gint token); + gint (*frame_to_xsize) (ModelTimeSystem* self, gint frame); + gint (*xsize_to_frame) (ModelTimeSystem* self, gint xsize); + char* (*get_time_string) (ModelTimeSystem* self, gint64 time); + char* (*get_time_duration) (ModelTimeSystem* self, gint64 time); +}; + +typedef enum { + MODEL_MEDIA_TYPE_AUDIO, + MODEL_MEDIA_TYPE_VIDEO +} ModelMediaType; + +struct _ModelGap { + GTypeInstance parent_instance; + volatile int ref_count; + ModelGapPrivate * priv; + gint64 start; + gint64 end; +}; + +struct _ModelGapClass { + GTypeClass parent_class; + void (*finalize) (ModelGap *self); +}; + +struct _ModelClipFile { + GObject parent_instance; + ModelClipFilePrivate * priv; + char* filename; + GstCaps* video_caps; + GstCaps* audio_caps; + GdkPixbuf* thumbnail; +}; + +struct _ModelClipFileClass { + GObjectClass parent_class; +}; + +struct _Fraction { + gint numerator; + gint denominator; +}; + +struct _ModelFetcher { + GObject parent_instance; + ModelFetcherPrivate * priv; + GstElement* filesrc; + GstElement* decodebin; + GstPipeline* pipeline; + ModelClipFile* clipfile; + char* error_string; +}; + +struct _ModelFetcherClass { + GObjectClass parent_class; + void (*on_pad_added) (ModelFetcher* self, GstPad* pad); + void (*on_state_change) (ModelFetcher* self, GstBus* bus, GstMessage* message); +}; + +struct _ModelClipFetcher { + ModelFetcher parent_instance; + ModelClipFetcherPrivate * priv; +}; + +struct _ModelClipFetcherClass { + ModelFetcherClass parent_class; +}; + +struct _ModelThumbnailFetcher { + ModelFetcher parent_instance; + ModelThumbnailFetcherPrivate * priv; +}; + +struct _ModelThumbnailFetcherClass { + ModelFetcherClass parent_class; +}; + +struct _ModelClip { + GObject parent_instance; + ModelClipPrivate * priv; + ModelClipFile* clipfile; + ModelMediaType type; + gboolean is_recording; + char* name; +}; + +struct _ModelClipClass { + GObjectClass parent_class; +}; + +struct _ModelFetcherCompletion { + GTypeInstance parent_instance; + volatile int ref_count; + ModelFetcherCompletionPrivate * priv; +}; + +struct _ModelFetcherCompletionClass { + GTypeClass parent_class; + void (*finalize) (ModelFetcherCompletion *self); + void (*complete) (ModelFetcherCompletion* self, ModelFetcher* fetcher); +}; + +struct _ModelCommand { + GTypeInstance parent_instance; + volatile int ref_count; + ModelCommandPrivate * priv; +}; + +struct _ModelCommandClass { + GTypeClass parent_class; + void (*finalize) (ModelCommand *self); + void (*apply) (ModelCommand* self); + void (*undo) (ModelCommand* self); + gboolean (*merge) (ModelCommand* self, ModelCommand* command); + char* (*description) (ModelCommand* self); +}; + +typedef enum { + MODEL_PARAMETER_PAN, + MODEL_PARAMETER_VOLUME +} ModelParameter; + +struct _ModelParameterCommand { + ModelCommand parent_instance; + ModelParameterCommandPrivate * priv; +}; + +struct _ModelParameterCommandClass { + ModelCommandClass parent_class; +}; + +struct _ModelClipCommand { + ModelCommand parent_instance; + ModelClipCommandPrivate * priv; +}; + +struct _ModelClipCommandClass { + ModelCommandClass parent_class; +}; + +typedef enum { + MODEL_CLIP_COMMAND_ACTION_APPEND, + MODEL_CLIP_COMMAND_ACTION_DELETE +} ModelClipCommandAction; + +struct _ModelClipAddCommand { + ModelCommand parent_instance; + ModelClipAddCommandPrivate * priv; +}; + +struct _ModelClipAddCommandClass { + ModelCommandClass parent_class; +}; + +struct _ModelClipSplitCommand { + ModelCommand parent_instance; + ModelClipSplitCommandPrivate * priv; +}; + +struct _ModelClipSplitCommandClass { + ModelCommandClass parent_class; +}; + +typedef enum { + MODEL_CLIP_SPLIT_COMMAND_ACTION_SPLIT, + MODEL_CLIP_SPLIT_COMMAND_ACTION_JOIN +} ModelClipSplitCommandAction; + +struct _ModelClipFileDeleteCommand { + ModelCommand parent_instance; + ModelClipFileDeleteCommandPrivate * priv; +}; + +struct _ModelClipFileDeleteCommandClass { + ModelCommandClass parent_class; +}; + +struct _ModelClipTrimCommand { + ModelCommand parent_instance; + ModelClipTrimCommandPrivate * priv; +}; + +struct _ModelClipTrimCommandClass { + ModelCommandClass parent_class; +}; + +struct _ModelClipRevertCommand { + ModelCommand parent_instance; + ModelClipRevertCommandPrivate * priv; +}; + +struct _ModelClipRevertCommandClass { + ModelCommandClass parent_class; +}; + +struct _ModelTimeSignatureCommand { + ModelCommand parent_instance; + ModelTimeSignatureCommandPrivate * priv; +}; + +struct _ModelTimeSignatureCommandClass { + ModelCommandClass parent_class; +}; + +struct _ModelBpmCommand { + ModelCommand parent_instance; + ModelBpmCommandPrivate * priv; +}; + +struct _ModelBpmCommandClass { + ModelCommandClass parent_class; +}; + +struct _ModelAddClipCommand { + ModelCommand parent_instance; + ModelAddClipCommandPrivate * priv; +}; + +struct _ModelAddClipCommandClass { + ModelCommandClass parent_class; +}; + +struct _ModelTransactionCommand { + ModelCommand parent_instance; + ModelTransactionCommandPrivate * priv; +}; + +struct _ModelTransactionCommandClass { + ModelCommandClass parent_class; +}; + +struct _DialogUtilsfilter_description_struct { + char* name; + char* extension; +}; + +struct _MultiFileProgressInterfaceIface { + GTypeInterface parent_iface; + void (*cancel) (MultiFileProgressInterface* self); + void (*complete) (MultiFileProgressInterface* self); +}; + +struct _ModelClipImporter { + GObject parent_instance; + ModelClipImporterPrivate * priv; +}; + +struct _ModelClipImporterClass { + GObjectClass parent_class; +}; + +struct _ModelLibraryImporter { + GObject parent_instance; + ModelLibraryImporterPrivate * priv; + ModelProject* project; + ModelClipImporter* importer; +}; + +struct _ModelLibraryImporterClass { + GObjectClass parent_class; + void (*append_existing_clipfile) (ModelLibraryImporter* self, ModelClipFile* f); + void (*on_clip_complete) (ModelLibraryImporter* self, ModelClipFile* f); +}; + +struct _ModelTimelineImporter { + ModelLibraryImporter parent_instance; + ModelTimelineImporterPrivate * priv; +}; + +struct _ModelTimelineImporterClass { + ModelLibraryImporterClass parent_class; +}; + +typedef enum { + LOGGING_FACILITY_SIGNAL_HANDLERS, + LOGGING_FACILITY_DEVELOPER_WARNINGS, + LOGGING_FACILITY_GRAPH, + LOGGING_FACILITY_LOADING, + LOGGING_FACILITY_IMPORT, + LOGGING_FACILITY_SINGLEDECODEBIN +} LoggingFacility; + +typedef enum { + LOGGING_LEVEL_CRITICAL, + LOGGING_LEVEL_HIGH, + LOGGING_LEVEL_MEDIUM, + LOGGING_LEVEL_LOW, + LOGGING_LEVEL_INFO, + LOGGING_LEVEL_VERBOSE +} LoggingLevel; + +typedef enum { + PLAY_STATE_STOPPED, + PLAY_STATE_PRE_PLAY, + PLAY_STATE_PLAYING, + PLAY_STATE_PRE_RECORD_NULL, + PLAY_STATE_PRE_RECORD, + PLAY_STATE_RECORDING, + PLAY_STATE_POST_RECORD, + PLAY_STATE_PRE_EXPORT, + PLAY_STATE_EXPORTING, + PLAY_STATE_CANCEL_EXPORT, + PLAY_STATE_LOADING, + PLAY_STATE_CLOSING, + PLAY_STATE_CLOSED +} PlayState; + +struct _ViewMediaTrack { + GObject parent_instance; + ViewMediaTrackPrivate * priv; + ViewMediaEngine* media_engine; + GstBin* composition; + GstElement* default_source; + GstElement* sink; +}; + +struct _ViewMediaTrackClass { + GObjectClass parent_class; + GstElement* (*empty_element) (ViewMediaTrack* self, GError** error); + GstElement* (*get_element) (ViewMediaTrack* self); + void (*link_new_pad) (ViewMediaTrack* self, GstPad* pad, GstElement* track_element); + void (*unlink_pad) (ViewMediaTrack* self, GstPad* pad, GstElement* track_element); +}; + +struct _ViewMediaVideoTrack { + ViewMediaTrack parent_instance; + ViewMediaVideoTrackPrivate * priv; +}; + +struct _ViewMediaVideoTrackClass { + ViewMediaTrackClass parent_class; +}; + +struct _ViewClickTrack { + GObject parent_instance; + ViewClickTrackPrivate * priv; +}; + +struct _ViewClickTrackClass { + GObjectClass parent_class; +}; + +struct _ViewMediaAudioTrack { + ViewMediaTrack parent_instance; + ViewMediaAudioTrackPrivate * priv; +}; + +struct _ViewMediaAudioTrackClass { + ViewMediaTrackClass parent_class; +}; + +struct _ViewMediaConnector { + GObject parent_instance; + ViewMediaConnectorPrivate * priv; + gint AudioIndex; + gint VideoIndex; +}; + +struct _ViewMediaConnectorClass { + GObjectClass parent_class; + void (*connect) (ViewMediaConnector* self, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1); + void (*do_disconnect) (ViewMediaConnector* self, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1); +}; + +typedef enum { + VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Audio = 1, + VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Video = 2 +} ViewMediaConnectorMediaTypes; + +struct _ViewVideoOutput { + ViewMediaConnector parent_instance; + ViewVideoOutputPrivate * priv; +}; + +struct _ViewVideoOutputClass { + ViewMediaConnectorClass parent_class; +}; + +struct _ViewAudioOutput { + ViewMediaConnector parent_instance; + ViewAudioOutputPrivate * priv; +}; + +struct _ViewAudioOutputClass { + ViewMediaConnectorClass parent_class; +}; + +struct _ViewOggVorbisExport { + ViewMediaConnector parent_instance; + ViewOggVorbisExportPrivate * priv; +}; + +struct _ViewOggVorbisExportClass { + ViewMediaConnectorClass parent_class; +}; + +struct _ViewMediaEngine { + GObject parent_instance; + ViewMediaEnginePrivate * priv; + GstPipeline* pipeline; + GstBin* record_bin; + GstElement* converter; + GstElement* adder; + GstState gst_state; + PlayState play_state; + gint64 position; + gboolean playing; + ModelAudioTrack* record_track; + ModelClip* record_region; +}; + +struct _ViewMediaEngineClass { + GObjectClass parent_class; + void (*do_null_state_export) (ViewMediaEngine* self, gint64 length); + void (*pause) (ViewMediaEngine* self); +}; + +struct _MultiFileProgress { + GtkWindow parent_instance; + MultiFileProgressPrivate * priv; +}; + +struct _MultiFileProgressClass { + GtkWindowClass parent_class; +}; + +struct _ModelLoaderHandler { + GObject parent_instance; + ModelLoaderHandlerPrivate * priv; +}; + +struct _ModelLoaderHandlerClass { + GObjectClass parent_class; + gboolean (*commit_library) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_marina) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_track) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_clip) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_clipfile) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_time_signature_entry) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_tempo_entry) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_click) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_library_preference) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + void (*leave_library) (ModelLoaderHandler* self); + void (*leave_marina) (ModelLoaderHandler* self); + void (*leave_track) (ModelLoaderHandler* self); + void (*leave_clip) (ModelLoaderHandler* self); + void (*leave_clipfile) (ModelLoaderHandler* self); +}; + +struct _ModelXmlTreeLoader { + GTypeInstance parent_instance; + volatile int ref_count; + ModelXmlTreeLoaderPrivate * priv; + ModelXmlElement* root; +}; + +struct _ModelXmlTreeLoaderClass { + GTypeClass parent_class; + void (*finalize) (ModelXmlTreeLoader *self); +}; + +struct _ModelXmlElement { + GTypeInstance parent_instance; + volatile int ref_count; + ModelXmlElementPrivate * priv; + char** attribute_names; + gint attribute_names_length1; + char** attribute_values; + gint attribute_values_length1; +}; + +struct _ModelXmlElementClass { + GTypeClass parent_class; + void (*finalize) (ModelXmlElement *self); +}; + +struct _ModelProjectLoader { + GObject parent_instance; + ModelProjectLoaderPrivate * priv; +}; + +struct _ModelProjectLoaderClass { + GObjectClass parent_class; +}; + +struct _ModelMediaLoaderHandler { + ModelLoaderHandler parent_instance; + ModelMediaLoaderHandlerPrivate * priv; + ModelProject* the_project; + ModelTrack* current_track; +}; + +struct _ModelMediaLoaderHandlerClass { + ModelLoaderHandlerClass parent_class; +}; + +struct _ModelTempoInformationIface { + GTypeInterface parent_iface; + void (*get_time_signature) (ModelTempoInformation* self, Fraction* result); + gint (*get_bpm) (ModelTempoInformation* self); +}; + +struct _TimeCode { + gint hour; + gint minute; + gint second; + gint frame; + gboolean drop_code; +}; + +struct _ModelProject { + GObject parent_instance; + ModelProjectPrivate * priv; + GeeArrayList* tracks; + GeeArrayList* inactive_tracks; + GeeArrayList* clipfiles; + ViewMediaEngine* media_engine; + char* project_file; + ModelProjectLoader* loader; + ModelUndoManager* undo_manager; + ModelLibraryImporter* importer; + Fraction default_framerate; + gboolean click_during_play; + gboolean click_during_record; + double click_volume; + gboolean library_visible; + gint library_width; + gboolean snap_to_clip; +}; + +struct _ModelProjectClass { + GObjectClass parent_class; + void (*get_clip_time) (ModelProject* self, ModelClipFile* f, TimeCode* result); + char* (*get_project_file) (ModelProject* self); + void (*do_append) (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, const char* name, gint64 insert_time); + void (*add_track) (ModelProject* self, ModelTrack* track); + void (*insert_track) (ModelProject* self, gint index, ModelTrack* track); + void (*load) (ModelProject* self, const char* fname); + void (*save) (ModelProject* self, const char* filename); + char* (*get_app_name) (ModelProject* self); + void (*load_complete) (ModelProject* self); +}; + +struct _ViewRuler { + GtkDrawingArea parent_instance; + ViewRulerPrivate * priv; +}; + +struct _ViewRulerClass { + GtkDrawingAreaClass parent_class; +}; + +struct _ViewStatusBar { + GtkDrawingArea parent_instance; + ViewStatusBarPrivate * priv; +}; + +struct _ViewStatusBarClass { + GtkDrawingAreaClass parent_class; +}; + +struct _TrackClipPair { + GTypeInstance parent_instance; + volatile int ref_count; + TrackClipPairPrivate * priv; + ModelTrack* track; + ModelClip* clip; +}; + +struct _TrackClipPairClass { + GTypeClass parent_class; + void (*finalize) (TrackClipPair *self); +}; + +struct _Clipboard { + GTypeInstance parent_instance; + volatile int ref_count; + ClipboardPrivate * priv; + GeeArrayList* clips; +}; + +struct _ClipboardClass { + GTypeClass parent_class; + void (*finalize) (Clipboard *self); +}; + +struct _TimeLine { + GtkEventBox parent_instance; + TimeLinePrivate * priv; + ModelProject* project; + ModelTimeSystem* provider; + ViewRuler* ruler; + GeeArrayList* tracks; + GeeArrayList* selected_clips; + Clipboard* clipboard; +}; + +struct _TimeLineClass { + GtkEventBoxClass parent_class; +}; + +struct _ModelTimeSystemBase { + GObject parent_instance; + ModelTimeSystemBasePrivate * priv; + float pixel_percentage; + float pixels_per_second; + gint64 pixel_snap_time; +}; + +struct _ModelTimeSystemBaseClass { + GObjectClass parent_class; + gint* (*get_timeline_seconds) (ModelTimeSystemBase* self, int* result_length1); + gint (*correct_sub_second_value) (ModelTimeSystemBase* self, float seconds, gint div, gint fps); +}; + +struct _ModelTimecodeTimeSystem { + ModelTimeSystemBase parent_instance; + ModelTimecodeTimeSystemPrivate * priv; + Fraction frame_rate_fraction; +}; + +struct _ModelTimecodeTimeSystemClass { + ModelTimeSystemBaseClass parent_class; +}; + +struct _ModelBarBeatTimeSystem { + ModelTimeSystemBase parent_instance; + ModelBarBeatTimeSystemPrivate * priv; +}; + +struct _ModelBarBeatTimeSystemClass { + ModelTimeSystemBaseClass parent_class; +}; + +struct _ModelTrack { + GObject parent_instance; + ModelTrackPrivate * priv; + ModelProject* project; + GeeArrayList* clips; + char* display_name; +}; + +struct _ModelTrackClass { + GObjectClass parent_class; + char* (*name) (ModelTrack* self); + ModelMediaType (*media_type) (ModelTrack* self); + gboolean (*check) (ModelTrack* self, ModelClip* clip); + void (*on_clip_updated) (ModelTrack* self, ModelClip* clip); + void (*write_attributes) (ModelTrack* self, FILE* f); +}; + +struct _ModelAudioTrack { + ModelTrack parent_instance; + ModelAudioTrackPrivate * priv; +}; + +struct _ModelAudioTrackClass { + ModelTrackClass parent_class; +}; + +struct _GapView { + GtkDrawingArea parent_instance; + GapViewPrivate * priv; + ModelGap* gap; +}; + +struct _GapViewClass { + GtkDrawingAreaClass parent_class; +}; + +struct _ClipView { + GtkDrawingArea parent_instance; + ClipViewPrivate * priv; + ModelClip* clip; + gint64 initial_time; + gboolean is_selected; + gint height; +}; + +struct _ClipViewClass { + GtkDrawingAreaClass parent_class; +}; + +struct _ModelUndoManager { + GTypeInstance parent_instance; + volatile int ref_count; + ModelUndoManagerPrivate * priv; +}; + +struct _ModelUndoManagerClass { + GTypeClass parent_class; + void (*finalize) (ModelUndoManager *self); +}; + +typedef enum { + MEDIA_ERROR_MISSING_PLUGIN +} MediaError; +#define MEDIA_ERROR media_error_quark () +typedef enum { + GDK_Control_L, + GDK_Control_R, + GDK_Down, + GDK_equal, + GDK_Escape, + GDK_KP_Add, + GDK_KP_Enter, + GDK_KP_Subtract, + GDK_Left, + GDK_minus, + GDK_plus, + GDK_Return, + GDK_Right, + GDK_Shift_L, + GDK_Shift_R, + GDK_underscore, + GDK_Up +} KeySyms; + +struct _ModelVideoTrack { + ModelTrack parent_instance; + ModelVideoTrackPrivate * priv; +}; + +struct _ModelVideoTrackClass { + ModelTrackClass parent_class; +}; + + +gpointer app_dirs_ref (gpointer instance); +void app_dirs_unref (gpointer instance); +GParamSpec* param_spec_app_dirs (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void value_set_app_dirs (GValue* value, gpointer v_object); +void value_take_app_dirs (GValue* value, gpointer v_object); +gpointer value_get_app_dirs (const GValue* value); +GType app_dirs_get_type (void); +void app_dirs_init (const char* arg0, const char* program_name); +void app_dirs_terminate (void); +GFile* app_dirs_get_exec_dir (void); +GFile* app_dirs_get_resources_dir (void); +AppDirs* app_dirs_new (void); +AppDirs* app_dirs_construct (GType object_type); +GType view_audio_meter_get_type (void); +GType model_track_get_type (void); +GType model_audio_track_get_type (void); +ViewAudioMeter* view_audio_meter_new (ModelAudioTrack* track); +ViewAudioMeter* view_audio_meter_construct (GType object_type, ModelAudioTrack* track); +gboolean view_audio_meter_on_expose_event (ViewAudioMeter* self, GdkEventExpose* event); +void view_audio_meter_on_level_changed (ViewAudioMeter* self, double level_left, double level_right); +void view_audio_meter_on_channel_count_changed (ViewAudioMeter* self, gint number_of_channels); +GType clip_view_get_type (void); +GType track_view_get_type (void); +void track_view_move_to_top (TrackView* self, ClipView* clip_view); +void track_view_resize (TrackView* self); +ModelTrack* track_view_get_track (TrackView* self); +gint track_view_get_track_height (TrackView* self); +GtkWidget* track_view_find_child (TrackView* self, double x, double y); +void track_view_select_all (TrackView* self); +gpointer class_factory_ref (gpointer instance); +void class_factory_unref (gpointer instance); +GParamSpec* param_spec_class_factory (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void value_set_class_factory (GValue* value, gpointer v_object); +void value_take_class_factory (GValue* value, gpointer v_object); +gpointer value_get_class_factory (const GValue* value); +GType class_factory_get_type (void); +GType time_line_get_type (void); +ClassFactory* class_factory_get_class_factory (void); +TrackView* class_factory_get_track_view (ClassFactory* self, ModelTrack* track, TimeLine* timeline); +void class_factory_set_class_factory (ClassFactory* class_factory); +GType transport_delegate_get_type (void); +void class_factory_set_transport_delegate (TransportDelegate* transport_delegate); +ClassFactory* class_factory_new (void); +ClassFactory* class_factory_construct (GType object_type); +GType clip_library_view_get_type (void); +extern GtkMenu* clip_library_view_context_menu; +GType model_project_get_type (void); +GType model_time_system_get_type (void); +ClipLibraryView* clip_library_view_new (ModelProject* p, ModelTimeSystem* time_provider, const char* drag_message, GdkDragAction actions); +ClipLibraryView* clip_library_view_construct (GType object_type, ModelProject* p, ModelTimeSystem* time_provider, const char* drag_message, GdkDragAction actions); +void clip_library_view_unselect_all (ClipLibraryView* self); +GType model_clip_file_get_type (void); +void clip_library_view_on_clipfile_removed (ClipLibraryView* self, ModelClipFile* f); +gboolean clip_library_view_has_selection (ClipLibraryView* self); +GeeArrayList* clip_library_view_get_selected_files (ClipLibraryView* self); +void clip_library_view_delete_selection (ClipLibraryView* self); +void clip_library_view_select_all (ClipLibraryView* self); +GType model_media_type_get_type (void); +gpointer model_gap_ref (gpointer instance); +void model_gap_unref (gpointer instance); +GParamSpec* model_param_spec_gap (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_gap (GValue* value, gpointer v_object); +void model_value_take_gap (GValue* value, gpointer v_object); +gpointer model_value_get_gap (const GValue* value); +GType model_gap_get_type (void); +ModelGap* model_gap_new (gint64 start, gint64 end); +ModelGap* model_gap_construct (GType object_type, gint64 start, gint64 end); +gboolean model_gap_is_empty (ModelGap* self); +ModelGap* model_gap_intersect (ModelGap* self, ModelGap* g); +ModelClipFile* model_clip_file_new (const char* filename, gint64 length); +ModelClipFile* model_clip_file_construct (GType object_type, const char* filename, gint64 length); +gboolean model_clip_file_is_online (ModelClipFile* self); +void model_clip_file_set_online (ModelClipFile* self, gboolean o); +void model_clip_file_set_thumbnail (ModelClipFile* self, GdkPixbuf* b); +gboolean model_clip_file_has_caps_structure (ModelClipFile* self, ModelMediaType m); +gboolean model_clip_file_is_of_type (ModelClipFile* self, ModelMediaType t); +GType fraction_get_type (void); +Fraction* fraction_dup (const Fraction* self); +void fraction_free (Fraction* self); +gboolean model_clip_file_get_frame_rate (ModelClipFile* self, Fraction* rate); +gboolean model_clip_file_get_dimensions (ModelClipFile* self, gint* w, gint* h); +gboolean model_clip_file_get_sample_rate (ModelClipFile* self, gint* rate); +gboolean model_clip_file_get_video_format (ModelClipFile* self, guint32* fourcc); +gboolean model_clip_file_get_num_channels (ModelClipFile* self, gint* channels); +gboolean model_clip_file_get_num_channels_string (ModelClipFile* self, char** s); +gint64 model_clip_file_get_length (ModelClipFile* self); +void model_clip_file_set_length (ModelClipFile* self, gint64 value); +GType model_fetcher_get_type (void); +void model_fetcher_on_pad_added (ModelFetcher* self, GstPad* pad); +void model_fetcher_on_state_change (ModelFetcher* self, GstBus* bus, GstMessage* message); +void model_fetcher_do_error (ModelFetcher* self, const char* _error_); +void model_fetcher_on_warning (ModelFetcher* self, GstBus* bus, GstMessage* message); +void model_fetcher_on_error (ModelFetcher* self, GstBus* bus, GstMessage* message); +ModelFetcher* model_fetcher_construct (GType object_type); +GType model_clip_fetcher_get_type (void); +ModelClipFetcher* model_clip_fetcher_new (const char* filename, GError** error); +ModelClipFetcher* model_clip_fetcher_construct (GType object_type, const char* filename, GError** error); +char* model_clip_fetcher_get_filename (ModelClipFetcher* self); +GType model_thumbnail_fetcher_get_type (void); +ModelThumbnailFetcher* model_thumbnail_fetcher_new (ModelClipFile* f, gint64 time, GError** error); +ModelThumbnailFetcher* model_thumbnail_fetcher_construct (GType object_type, ModelClipFile* f, gint64 time, GError** error); +GType model_clip_get_type (void); +ModelClip* model_clip_new (ModelClipFile* clipfile, ModelMediaType t, const char* name, gint64 start, gint64 media_start, gint64 duration, gboolean is_recording); +ModelClip* model_clip_construct (GType object_type, ModelClipFile* clipfile, ModelMediaType t, const char* name, gint64 start, gint64 media_start, gint64 duration, gboolean is_recording); +void model_clip_gnonlin_connect (ModelClip* self); +void model_clip_gnonlin_disconnect (ModelClip* self); +gboolean model_clip_overlap_pos (ModelClip* self, gint64 start, gint64 length); +gint64 model_clip_snap (ModelClip* self, ModelClip* other, gint64 pad); +gboolean model_clip_snap_coord (ModelClip* self, gint64* s, gint64 span); +ModelClip* model_clip_copy (ModelClip* self); +gboolean model_clip_is_trimmed (ModelClip* self); +void model_clip_trim (ModelClip* self, gint64 delta, GdkWindowEdge edge); +void model_clip_set_media_start_duration (ModelClip* self, gint64 media_start, gint64 duration); +void model_clip_save (ModelClip* self, FILE* f, gint id); +gint64 model_clip_get_start (ModelClip* self); +void model_clip_set_start (ModelClip* self, gint64 value); +gint64 model_clip_get_media_start (ModelClip* self); +gint64 model_clip_get_duration (ModelClip* self); +void model_clip_set_duration (ModelClip* self, gint64 value); +gint64 model_clip_get_end (ModelClip* self); +gpointer model_fetcher_completion_ref (gpointer instance); +void model_fetcher_completion_unref (gpointer instance); +GParamSpec* model_param_spec_fetcher_completion (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_fetcher_completion (GValue* value, gpointer v_object); +void model_value_take_fetcher_completion (GValue* value, gpointer v_object); +gpointer model_value_get_fetcher_completion (const GValue* value); +GType model_fetcher_completion_get_type (void); +ModelFetcherCompletion* model_fetcher_completion_new (void); +ModelFetcherCompletion* model_fetcher_completion_construct (GType object_type); +void model_fetcher_completion_complete (ModelFetcherCompletion* self, ModelFetcher* fetcher); +gpointer model_command_ref (gpointer instance); +void model_command_unref (gpointer instance); +GParamSpec* model_param_spec_command (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_command (GValue* value, gpointer v_object); +void model_value_take_command (GValue* value, gpointer v_object); +gpointer model_value_get_command (const GValue* value); +GType model_command_get_type (void); +void model_command_apply (ModelCommand* self); +void model_command_undo (ModelCommand* self); +gboolean model_command_merge (ModelCommand* self, ModelCommand* command); +char* model_command_description (ModelCommand* self); +ModelCommand* model_command_construct (GType object_type); +GType model_parameter_get_type (void); +GType model_parameter_command_get_type (void); +ModelParameterCommand* model_parameter_command_new (ModelAudioTrack* target, ModelParameter parameter, double new_value, double old_value); +ModelParameterCommand* model_parameter_command_construct (GType object_type, ModelAudioTrack* target, ModelParameter parameter, double new_value, double old_value); +GType model_clip_command_get_type (void); +GType model_clip_command_action_get_type (void); +ModelClipCommand* model_clip_command_new (ModelClipCommandAction action, ModelTrack* track, ModelClip* clip, gint64 time, gboolean select); +ModelClipCommand* model_clip_command_construct (GType object_type, ModelClipCommandAction action, ModelTrack* track, ModelClip* clip, gint64 time, gboolean select); +GType model_clip_add_command_get_type (void); +ModelClipAddCommand* model_clip_add_command_new (ModelTrack* track, ModelClip* clip, gint64 original_time, gint64 new_start); +ModelClipAddCommand* model_clip_add_command_construct (GType object_type, ModelTrack* track, ModelClip* clip, gint64 original_time, gint64 new_start); +GType model_clip_split_command_get_type (void); +GType model_clip_split_command_action_get_type (void); +ModelClipSplitCommand* model_clip_split_command_new (ModelClipSplitCommandAction action, ModelTrack* track, gint64 time); +ModelClipSplitCommand* model_clip_split_command_construct (GType object_type, ModelClipSplitCommandAction action, ModelTrack* track, gint64 time); +GType model_clip_file_delete_command_get_type (void); +ModelClipFileDeleteCommand* model_clip_file_delete_command_new (ModelProject* p, ModelClipFile* cf); +ModelClipFileDeleteCommand* model_clip_file_delete_command_construct (GType object_type, ModelProject* p, ModelClipFile* cf); +GType model_clip_trim_command_get_type (void); +ModelClipTrimCommand* model_clip_trim_command_new (ModelTrack* track, ModelClip* clip, gint64 delta, GdkWindowEdge edge); +ModelClipTrimCommand* model_clip_trim_command_construct (GType object_type, ModelTrack* track, ModelClip* clip, gint64 delta, GdkWindowEdge edge); +GType model_clip_revert_command_get_type (void); +ModelClipRevertCommand* model_clip_revert_command_new (ModelTrack* track, ModelClip* clip); +ModelClipRevertCommand* model_clip_revert_command_construct (GType object_type, ModelTrack* track, ModelClip* clip); +GType model_time_signature_command_get_type (void); +ModelTimeSignatureCommand* model_time_signature_command_new (ModelProject* project, Fraction* new_time_signature); +ModelTimeSignatureCommand* model_time_signature_command_construct (GType object_type, ModelProject* project, Fraction* new_time_signature); +GType model_bpm_command_get_type (void); +ModelBpmCommand* model_bpm_command_new (ModelProject* project, gint new_bpm); +ModelBpmCommand* model_bpm_command_construct (GType object_type, ModelProject* project, gint new_bpm); +GType model_add_clip_command_get_type (void); +ModelAddClipCommand* model_add_clip_command_new (ModelProject* project, ModelClipFile* clip_file); +ModelAddClipCommand* model_add_clip_command_construct (GType object_type, ModelProject* project, ModelClipFile* clip_file); +GType model_transaction_command_get_type (void); +ModelTransactionCommand* model_transaction_command_new (gboolean open, const char* transaction_description); +ModelTransactionCommand* model_transaction_command_construct (GType object_type, gboolean open, const char* transaction_description); +gboolean model_transaction_command_in_transaction (ModelTransactionCommand* self); +GType dialog_utils_filter_description_struct_get_type (void); +DialogUtilsfilter_description_struct* dialog_utils_filter_description_struct_dup (const DialogUtilsfilter_description_struct* self); +void dialog_utils_filter_description_struct_free (DialogUtilsfilter_description_struct* self); +void dialog_utils_filter_description_struct_copy (const DialogUtilsfilter_description_struct* self, DialogUtilsfilter_description_struct* dest); +void dialog_utils_filter_description_struct_destroy (DialogUtilsfilter_description_struct* self); +gboolean dialog_utils_open (GtkWindow* parent, DialogUtilsfilter_description_struct* filter_descriptions, int filter_descriptions_length1, gboolean allow_multiple, gboolean allow_all, GSList** filenames); +gboolean dialog_utils_save (GtkWindow* parent, const char* title, gboolean create_directory, DialogUtilsfilter_description_struct* filter_descriptions, int filter_descriptions_length1, char** filename); +void dialog_utils_warning (const char* major_message, const char* minor_message); +void dialog_utils_error (const char* major_message, const char* minor_message); +GtkResponseType dialog_utils_delete_keep (const char* message); +GtkResponseType dialog_utils_add_cancel (const char* message); +GtkResponseType dialog_utils_delete_cancel (const char* message); +gboolean dialog_utils_confirm_replace (GtkWindow* parent, const char* filename); +GtkResponseType dialog_utils_save_close_cancel (GtkWindow* parent, const char* title, const char* message); +void dialog_utils_show_clip_properties (GtkWindow* parent, ClipView* selected_clip, ModelClipFile* clip_file, Fraction* frames_per_second); +GType multi_file_progress_interface_get_type (void); +GType model_clip_importer_get_type (void); +ModelClipImporter* model_clip_importer_new (void); +ModelClipImporter* model_clip_importer_construct (GType object_type); +void model_clip_importer_add_filename (ModelClipImporter* self, const char* filename); +void model_clip_importer_start (ModelClipImporter* self, GError** error); +GType model_library_importer_get_type (void); +ModelLibraryImporter* model_library_importer_new (ModelProject* p); +ModelLibraryImporter* model_library_importer_construct (GType object_type, ModelProject* p); +void model_library_importer_append_existing_clipfile (ModelLibraryImporter* self, ModelClipFile* f); +void model_library_importer_on_clip_complete (ModelLibraryImporter* self, ModelClipFile* f); +void model_library_importer_add_file (ModelLibraryImporter* self, const char* filename, GError** error); +void model_library_importer_start (ModelLibraryImporter* self, GError** error); +GType model_timeline_importer_get_type (void); +ModelTimelineImporter* model_timeline_importer_new (ModelTrack* track, ModelProject* p, gint64 time_to_add, gboolean both_tracks); +ModelTimelineImporter* model_timeline_importer_construct (GType object_type, ModelTrack* track, ModelProject* p, gint64 time_to_add, gboolean both_tracks); +GType logging_facility_get_type (void); +GType logging_level_get_type (void); +void logging_set_logging_level (LoggingLevel new_level); +void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message); +GType play_state_get_type (void); +#define CHANNELS_PER_TRACK_PLAYBACK 2 +#define CHANNELS_PER_TRACK_RECORD 1 +GType view_media_track_get_type (void); +GType view_media_engine_get_type (void); +ViewMediaTrack* view_media_track_construct (GType object_type, ViewMediaEngine* media_engine, ModelTrack* track, GError** error); +GstElement* view_media_track_empty_element (ViewMediaTrack* self, GError** error); +GstElement* view_media_track_get_element (ViewMediaTrack* self); +void view_media_track_link_new_pad (ViewMediaTrack* self, GstPad* pad, GstElement* track_element); +void view_media_track_unlink_pad (ViewMediaTrack* self, GstPad* pad, GstElement* track_element); +GType view_media_video_track_get_type (void); +ViewMediaVideoTrack* view_media_video_track_new (ViewMediaEngine* media_engine, ModelTrack* track, GstElement* converter, GError** error); +ViewMediaVideoTrack* view_media_video_track_construct (GType object_type, ViewMediaEngine* media_engine, ModelTrack* track, GstElement* converter, GError** error); +GType view_click_track_get_type (void); +ViewClickTrack* view_click_track_new (ViewMediaEngine* engine, ModelProject* project, GError** error); +ViewClickTrack* view_click_track_construct (GType object_type, ViewMediaEngine* engine, ModelProject* project, GError** error); +GType view_media_audio_track_get_type (void); +ViewMediaAudioTrack* view_media_audio_track_new (ViewMediaEngine* media_engine, ModelAudioTrack* track, GError** error); +ViewMediaAudioTrack* view_media_audio_track_construct (GType object_type, ViewMediaEngine* media_engine, ModelAudioTrack* track, GError** error); +GType view_media_connector_get_type (void); +GType view_media_connector_media_types_get_type (void); +ViewMediaConnector* view_media_connector_construct (GType object_type, ViewMediaConnectorMediaTypes media_types); +gboolean view_media_connector_has_audio (ViewMediaConnector* self); +gboolean view_media_connector_has_video (ViewMediaConnector* self); +void view_media_connector_connect (ViewMediaConnector* self, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1); +void view_media_connector_do_disconnect (ViewMediaConnector* self, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1); +GType view_video_output_get_type (void); +ViewVideoOutput* view_video_output_new (GtkWidget* output_widget, GError** error); +ViewVideoOutput* view_video_output_construct (GType object_type, GtkWidget* output_widget, GError** error); +GType view_audio_output_get_type (void); +ViewAudioOutput* view_audio_output_new (GstCaps* caps, GError** error); +ViewAudioOutput* view_audio_output_construct (GType object_type, GstCaps* caps, GError** error); +GType view_ogg_vorbis_export_get_type (void); +ViewOggVorbisExport* view_ogg_vorbis_export_new (ViewMediaConnectorMediaTypes media_types, const char* filename, GstCaps* caps, GError** error); +ViewOggVorbisExport* view_ogg_vorbis_export_construct (GType object_type, ViewMediaConnectorMediaTypes media_types, const char* filename, GstCaps* caps, GError** error); +char* view_ogg_vorbis_export_get_filename (ViewOggVorbisExport* self); +ViewMediaEngine* view_media_engine_new (ModelProject* project, gboolean include_video, GError** error); +ViewMediaEngine* view_media_engine_construct (GType object_type, ModelProject* project, gboolean include_video, GError** error); +void view_media_engine_can_run (GError** error); +void view_media_engine_connect_output (ViewMediaEngine* self, ViewMediaConnector* connector); +void view_media_engine_disconnect_output (ViewMediaEngine* self, ViewMediaConnector* connector); +GstElement* view_media_engine_get_audio_silence (ViewMediaEngine* self, GError** error); +gint view_media_engine_get_sample_rate (ViewMediaEngine* self); +gint view_media_engine_get_sample_width (ViewMediaEngine* self); +gint view_media_engine_get_sample_depth (ViewMediaEngine* self); +PlayState view_media_engine_get_play_state (ViewMediaEngine* self); +void view_media_engine_set_play_state (ViewMediaEngine* self, PlayState play_state); +GstCaps* view_media_engine_build_audio_caps (ViewMediaEngine* self, gint num_channels); +GstCaps* view_media_engine_get_project_audio_caps (ViewMediaEngine* self); +GstCaps* view_media_engine_get_project_audio_export_caps (ViewMediaEngine* self); +gboolean view_media_engine_do_state_change (ViewMediaEngine* self); +void view_media_engine_do_null_state_export (ViewMediaEngine* self, gint64 length); +void view_media_engine_go (ViewMediaEngine* self, gint64 pos); +void view_media_engine_pause (ViewMediaEngine* self); +void view_media_engine_set_gst_state (ViewMediaEngine* self, GstState state); +void view_media_engine_do_play (ViewMediaEngine* self, PlayState new_state); +void view_media_engine_start_export (ViewMediaEngine* self, const char* filename); +void view_media_engine_on_load_complete (ViewMediaEngine* self); +void view_media_engine_on_callback_pulse (ViewMediaEngine* self); +void view_media_engine_close (ViewMediaEngine* self); +void view_media_engine_post_record (ViewMediaEngine* self); +void view_media_engine_record (ViewMediaEngine* self, ModelAudioTrack* track); +void view_media_engine_start_record (ViewMediaEngine* self, ModelClip* region, GError** error); +GstCaps* view_media_engine_get_record_audio_caps (ViewMediaEngine* self); +void view_media_engine_on_track_added (ViewMediaEngine* self, ModelTrack* track); +void multi_file_progress_interface_cancel (MultiFileProgressInterface* self); +void multi_file_progress_interface_complete (MultiFileProgressInterface* self); +GType multi_file_progress_get_type (void); +MultiFileProgress* multi_file_progress_new (GtkWindow* parent, gint num_files, const char* dialog_title, MultiFileProgressInterface* provider); +MultiFileProgress* multi_file_progress_construct (GType object_type, GtkWindow* parent, gint num_files, const char* dialog_title, MultiFileProgressInterface* provider); +GType model_loader_handler_get_type (void); +ModelLoaderHandler* model_loader_handler_new (void); +ModelLoaderHandler* model_loader_handler_construct (GType object_type); +gboolean model_loader_handler_commit_library (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +gboolean model_loader_handler_commit_marina (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +gboolean model_loader_handler_commit_track (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +gboolean model_loader_handler_commit_clip (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +gboolean model_loader_handler_commit_clipfile (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +gboolean model_loader_handler_commit_time_signature_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +gboolean model_loader_handler_commit_tempo_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +gboolean model_loader_handler_commit_click (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +gboolean model_loader_handler_commit_library_preference (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +void model_loader_handler_leave_library (ModelLoaderHandler* self); +void model_loader_handler_leave_marina (ModelLoaderHandler* self); +void model_loader_handler_leave_track (ModelLoaderHandler* self); +void model_loader_handler_leave_clip (ModelLoaderHandler* self); +void model_loader_handler_leave_clipfile (ModelLoaderHandler* self); +gpointer model_xml_tree_loader_ref (gpointer instance); +void model_xml_tree_loader_unref (gpointer instance); +GParamSpec* model_param_spec_xml_tree_loader (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_xml_tree_loader (GValue* value, gpointer v_object); +void model_value_take_xml_tree_loader (GValue* value, gpointer v_object); +gpointer model_value_get_xml_tree_loader (const GValue* value); +GType model_xml_tree_loader_get_type (void); +gpointer model_xml_element_ref (gpointer instance); +void model_xml_element_unref (gpointer instance); +GParamSpec* model_param_spec_xml_element (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_xml_element (GValue* value, gpointer v_object); +void model_value_take_xml_element (GValue* value, gpointer v_object); +gpointer model_value_get_xml_element (const GValue* value); +GType model_xml_element_get_type (void); +ModelXmlTreeLoader* model_xml_tree_loader_new (const char* document); +ModelXmlTreeLoader* model_xml_tree_loader_construct (GType object_type, const char* document); +ModelXmlElement* model_xml_element_new (const char* name, char** attribute_names, int attribute_names_length1, char** attribute_values, int attribute_values_length1, ModelXmlElement* parent); +ModelXmlElement* model_xml_element_construct (GType object_type, const char* name, char** attribute_names, int attribute_names_length1, char** attribute_values, int attribute_values_length1, ModelXmlElement* parent); +void model_xml_element_add_child (ModelXmlElement* self, ModelXmlElement* child_element); +const char* model_xml_element_get_name (ModelXmlElement* self); +GeeArrayList* model_xml_element_get_children (ModelXmlElement* self); +ModelXmlElement* model_xml_element_get_parent (ModelXmlElement* self); +GType model_project_loader_get_type (void); +ModelProjectLoader* model_project_loader_new (ModelLoaderHandler* loader_handler, const char* file_name); +ModelProjectLoader* model_project_loader_construct (GType object_type, ModelLoaderHandler* loader_handler, const char* file_name); +void model_project_loader_load (ModelProjectLoader* self); +GType model_media_loader_handler_get_type (void); +ModelMediaLoaderHandler* model_media_loader_handler_new (ModelProject* the_project); +ModelMediaLoaderHandler* model_media_loader_handler_construct (GType object_type, ModelProject* the_project); +GType model_tempo_information_get_type (void); +GType time_code_get_type (void); +TimeCode* time_code_dup (const TimeCode* self); +void time_code_free (TimeCode* self); +gpointer model_undo_manager_ref (gpointer instance); +void model_undo_manager_unref (gpointer instance); +GParamSpec* model_param_spec_undo_manager (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_undo_manager (GValue* value, gpointer v_object); +void model_value_take_undo_manager (GValue* value, gpointer v_object); +gpointer model_value_get_undo_manager (const GValue* value); +GType model_undo_manager_get_type (void); +extern Fraction model_project_INVALID_FRAME_RATE; +#define MODEL_PROJECT_FILLMORE_FILE_EXTENSION "fill" +#define MODEL_PROJECT_FILLMORE_FILE_FILTER "*." MODEL_PROJECT_FILLMORE_FILE_EXTENSION +#define MODEL_PROJECT_LOMBARD_FILE_EXTENSION "lom" +#define MODEL_PROJECT_LOMBARD_FILE_FILTER "*." MODEL_PROJECT_LOMBARD_FILE_EXTENSION +void model_project_get_clip_time (ModelProject* self, ModelClipFile* f, TimeCode* result); +ModelProject* model_project_construct (GType object_type, const char* filename, gboolean include_video, GError** error); +void model_project_on_playstate_changed (ModelProject* self); +char* model_project_get_project_file (ModelProject* self); +ModelClipFile* model_project_get_clipfile (ModelProject* self, gint index); +gint model_project_get_clipfile_index (ModelProject* self, ModelClipFile* find); +ModelTrack* model_project_track_from_clip (ModelProject* self, ModelClip* clip); +void model_project_print_graph (ModelProject* self, GstBin* bin, const char* file_name); +gint64 model_project_get_length (ModelProject* self); +gint64 model_project_snap_clip (ModelProject* self, ModelClip* c, gint64 span); +void model_project_snap_coord (ModelProject* self, gint64* coord, gint64 span); +gboolean model_project_can_delete_gap (ModelProject* self, ModelGap* gap); +void model_project_delete_gap (ModelProject* self, ModelGap* gap); +void model_project_do_append (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, const char* name, gint64 insert_time); +void model_project_append (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile); +void model_project_add (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, gint64 time); +void model_project_on_clip_removed (ModelProject* self, ModelTrack* t, ModelClip* clip); +void model_project_split_at_playhead (ModelProject* self); +gboolean model_project_can_trim (ModelProject* self, gboolean* left); +void model_project_trim_to_playhead (ModelProject* self); +void model_project_transport_go (ModelProject* self, gint64 position); +gboolean model_project_transport_is_playing (ModelProject* self); +gboolean model_project_transport_is_recording (ModelProject* self); +gboolean model_project_playhead_on_clip (ModelProject* self); +gboolean model_project_playhead_on_contiguous_clip (ModelProject* self); +gboolean model_project_is_duplicate_track_name (ModelProject* self, ModelTrack* track, const char* new_name); +void model_project_add_track (ModelProject* self, ModelTrack* track); +void model_project_insert_track (ModelProject* self, gint index, ModelTrack* track); +void model_project_add_inactive_track (ModelProject* self, ModelTrack* track); +void model_project_remove_track (ModelProject* self, ModelTrack* track); +void model_project_remove_track_at (ModelProject* self, gint index); +void model_project_add_clipfile (ModelProject* self, ModelClipFile* clipfile); +void _model_project_add_clipfile (ModelProject* self, ModelClipFile* clipfile, GError** error); +gboolean model_project_clipfile_on_track (ModelProject* self, const char* filename); +void _model_project_remove_clipfile (ModelProject* self, ModelClipFile* cf); +void model_project_remove_clipfile (ModelProject* self, const char* filename); +ModelClipFile* model_project_find_clipfile (ModelProject* self, const char* filename); +void model_project_reseek (ModelProject* self); +void model_project_go_start (ModelProject* self); +void model_project_go_end (ModelProject* self); +void model_project_go_previous (ModelProject* self); +void model_project_go_next (ModelProject* self); +gint64 model_project_transport_get_position (ModelProject* self); +void model_project_set_name (ModelProject* self, const char* filename); +void model_project_set_default_framerate (ModelProject* self, Fraction* rate); +char* model_project_get_file_display_name (ModelProject* self); +void model_project_clear (ModelProject* self); +gboolean model_project_can_export (ModelProject* self); +void model_project_on_load_started (ModelProject* self, const char* filename); +void model_project_load (ModelProject* self, const char* fname); +void model_project_on_error_occurred (ModelProject* self, const char* major_error, const char* minor_error); +gint model_project_get_file_version (ModelProject* self); +void model_project_save_library (ModelProject* self, FILE* f); +void model_project_save (ModelProject* self, const char* filename); +void model_project_close (ModelProject* self); +void model_project_on_importer_clip_complete (ModelProject* self, ModelClipFetcher* fetcher); +void model_project_create_clip_fetcher (ModelProject* self, ModelFetcherCompletion* fetcher_completion, const char* filename, GError** error); +gboolean model_project_is_project_extension (ModelProject* self, const char* filename); +void model_project_do_command (ModelProject* self, ModelCommand* the_command); +void model_project_undo (ModelProject* self); +void model_project_create_clip_importer (ModelProject* self, ModelTrack* track, gboolean timeline_add, gint64 time_to_add, gboolean both_tracks, GtkWindow* progress_window_parent, gint number); +char* model_project_get_version (ModelProject* self); +char* model_project_get_app_name (ModelProject* self); +char* model_project_get_license (ModelProject* self); +void model_project_set_time_signature (ModelProject* self, Fraction* time_signature); +void _model_project_set_time_signature (ModelProject* self, Fraction* time_signature); +void model_project_set_bpm (ModelProject* self, gint bpm); +void _model_project_set_bpm (ModelProject* self, gint bpm); +char* model_project_get_audio_path (ModelProject* self); +GType model_video_track_get_type (void); +ModelVideoTrack* model_project_find_video_track (ModelProject* self); +ModelAudioTrack* model_project_find_audio_track (ModelProject* self); +void model_project_load_complete (ModelProject* self); +GType view_ruler_get_type (void); +ViewRuler* view_ruler_new (ModelTimeSystem* provider, gint height); +ViewRuler* view_ruler_construct (GType object_type, ModelTimeSystem* provider, gint height); +GType view_status_bar_get_type (void); +ViewStatusBar* view_status_bar_new (ModelProject* p, ModelTimeSystem* provider, gint height); +ViewStatusBar* view_status_bar_construct (GType object_type, ModelProject* p, ModelTimeSystem* provider, gint height); +void view_status_bar_on_position_changed (ViewStatusBar* self, gint64 new_position); +gpointer track_clip_pair_ref (gpointer instance); +void track_clip_pair_unref (gpointer instance); +GParamSpec* param_spec_track_clip_pair (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void value_set_track_clip_pair (GValue* value, gpointer v_object); +void value_take_track_clip_pair (GValue* value, gpointer v_object); +gpointer value_get_track_clip_pair (const GValue* value); +GType track_clip_pair_get_type (void); +TrackClipPair* track_clip_pair_new (ModelTrack* track, ModelClip* clip); +TrackClipPair* track_clip_pair_construct (GType object_type, ModelTrack* track, ModelClip* clip); +gpointer clipboard_ref (gpointer instance); +void clipboard_unref (gpointer instance); +GParamSpec* param_spec_clipboard (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void value_set_clipboard (GValue* value, gpointer v_object); +void value_take_clipboard (GValue* value, gpointer v_object); +gpointer value_get_clipboard (const GValue* value); +GType clipboard_get_type (void); +void clipboard_select (Clipboard* self, GeeArrayList* selected_clips); +void clipboard_paste (Clipboard* self, ModelTrack* selected_track, gint64 time); +Clipboard* clipboard_new (void); +Clipboard* clipboard_construct (GType object_type); +#define TIME_LINE_BAR_HEIGHT 32 +#define TIME_LINE_BORDER 4 +#define TIME_LINE_RULER_HEIGHT 32 +TimeLine* time_line_new (ModelProject* p, ModelTimeSystem* provider, GdkDragAction actions); +TimeLine* time_line_construct (GType object_type, ModelProject* p, ModelTimeSystem* provider, GdkDragAction actions); +void time_line_zoom_to_project (TimeLine* self, double width); +void time_line_zoom (TimeLine* self, float inc); +void time_line_on_clip_view_added (TimeLine* self, ClipView* clip_view); +void time_line_deselect_all_clips (TimeLine* self); +void time_line_do_clip_move (TimeLine* self, ClipView* clip_view, gint64 delta); +void time_line_on_ruler_position_changed (TimeLine* self, gint x); +gboolean time_line_is_clip_selected (TimeLine* self); +gboolean time_line_gap_selected (TimeLine* self); +void time_line_delete_selection (TimeLine* self); +void time_line_do_cut (TimeLine* self); +void time_line_do_copy (TimeLine* self); +void time_line_paste (TimeLine* self); +void time_line_do_paste (TimeLine* self, gint64 pos); +void time_line_select_all (TimeLine* self); +void time_line_update_pos (TimeLine* self, gint event_x); +GtkWidget* time_line_find_child (TimeLine* self, double x, double y); +void model_time_system_calculate_pixel_step (ModelTimeSystem* self, float inc, float pixel_min, float pixel_div); +gint64 model_time_system_xpos_to_time (ModelTimeSystem* self, gint x); +gint64 model_time_system_xsize_to_time (ModelTimeSystem* self, gint x); +gint model_time_system_time_to_xpos (ModelTimeSystem* self, gint64 time); +gint64 model_time_system_get_pixel_snap_time (ModelTimeSystem* self); +gint model_time_system_time_to_xsize (ModelTimeSystem* self, gint64 time); +float model_time_system_get_pixel_percentage (ModelTimeSystem* self); +gint model_time_system_get_start_token (ModelTimeSystem* self, gint xsize); +gint model_time_system_get_next_position (ModelTimeSystem* self, gint token); +gint model_time_system_get_pixel_height (ModelTimeSystem* self, gint token); +char* model_time_system_get_display_string (ModelTimeSystem* self, gint token); +gint model_time_system_frame_to_xsize (ModelTimeSystem* self, gint frame); +gint model_time_system_xsize_to_frame (ModelTimeSystem* self, gint xsize); +char* model_time_system_get_time_string (ModelTimeSystem* self, gint64 time); +char* model_time_system_get_time_duration (ModelTimeSystem* self, gint64 time); +GType model_time_system_base_get_type (void); +#define MODEL_TIME_SYSTEM_BASE_PIXEL_SNAP_INTERVAL 10 +gint model_time_system_base_correct_seconds_value (ModelTimeSystemBase* self, float seconds, gint div, gint fps); +gint64 model_time_system_base_get_pixel_snap_time (ModelTimeSystemBase* self); +float model_time_system_base_get_pixel_percentage (ModelTimeSystemBase* self); +gint64 model_time_system_base_xpos_to_time (ModelTimeSystemBase* self, gint x); +gint64 model_time_system_base_xsize_to_time (ModelTimeSystemBase* self, gint size); +gint model_time_system_base_time_to_xsize (ModelTimeSystemBase* self, gint64 time); +gint model_time_system_base_time_to_xpos (ModelTimeSystemBase* self, gint64 time); +ModelTimeSystemBase* model_time_system_base_construct (GType object_type); +GType model_timecode_time_system_get_type (void); +ModelTimecodeTimeSystem* model_timecode_time_system_new (void); +ModelTimecodeTimeSystem* model_timecode_time_system_construct (GType object_type); +void model_tempo_information_get_time_signature (ModelTempoInformation* self, Fraction* result); +gint model_tempo_information_get_bpm (ModelTempoInformation* self); +GType model_bar_beat_time_system_get_type (void); +ModelBarBeatTimeSystem* model_bar_beat_time_system_new (ModelTempoInformation* tempo_information); +ModelBarBeatTimeSystem* model_bar_beat_time_system_construct (GType object_type, ModelTempoInformation* tempo_information); +ModelTrack* model_track_construct (GType object_type, ModelProject* project, const char* display_name); +char* model_track_name (ModelTrack* self); +ModelMediaType model_track_media_type (ModelTrack* self); +void model_track_hide (ModelTrack* self); +gboolean model_track_contains_clipfile (ModelTrack* self, ModelClipFile* f); +gboolean model_track_check (ModelTrack* self, ModelClip* clip); +gint64 model_track_get_time_from_pos (ModelTrack* self, ModelClip* clip, gboolean after); +gint64 model_track_snap_clip (ModelTrack* self, ModelClip* c, gint64 span); +gboolean model_track_snap_coord (ModelTrack* self, gint64* coord, gint64 span); +gboolean model_track_clip_is_near (ModelTrack* self, ModelClip* clip, gint64 range, gint64* adjustment); +ModelGap* model_track_find_first_gap (ModelTrack* self, gint64 start); +void model_track_find_containing_gap (ModelTrack* self, gint64 time, ModelGap** g); +ModelClip* model_track_find_overlapping_clip (ModelTrack* self, gint64 start, gint64 length); +ModelClip* model_track_find_nearest_clip_edge (ModelTrack* self, gint64 time, gboolean* after); +void model_track_move (ModelTrack* self, ModelClip* c, gint64 pos, gint64 original_time); +void _model_track_move (ModelTrack* self, ModelClip* c, gint64 pos); +void model_track_add (ModelTrack* self, ModelClip* c, gint64 pos, gboolean select); +void model_track_on_clip_updated (ModelTrack* self, ModelClip* clip); +void model_track_do_clip_paste (ModelTrack* self, ModelClip* clip, gint64 position); +ModelClip* model_track_get_clip (ModelTrack* self, gint i); +gint model_track_get_clip_index (ModelTrack* self, ModelClip* c); +ModelClip* model_track_get_clip_by_position (ModelTrack* self, gint64 pos); +gint64 model_track_get_length (ModelTrack* self); +void _model_track_append_at_time (ModelTrack* self, ModelClip* c, gint64 time, gboolean select); +void model_track_append_at_time (ModelTrack* self, ModelClip* c, gint64 time, gboolean select); +void model_track_delete_clip (ModelTrack* self, ModelClip* clip); +void _model_track_delete_clip (ModelTrack* self, ModelClip* clip); +void model_track_delete_gap (ModelTrack* self, ModelGap* g); +void model_track_remove_clip_from_array (ModelTrack* self, ModelClip* pos); +void model_track_delete_all_clips (ModelTrack* self); +void model_track_revert_to_original (ModelTrack* self, ModelClip* clip); +void _model_track_revert_to_original (ModelTrack* self, ModelClip* c); +gboolean model_track_are_contiguous_clips (ModelTrack* self, gint64 position); +void model_track_split_at (ModelTrack* self, gint64 position); +void _model_track_split_at (ModelTrack* self, gint64 position); +void model_track_join (ModelTrack* self, gint64 position); +void _model_track_join (ModelTrack* self, gint64 position); +void model_track_trim (ModelTrack* self, ModelClip* clip, gint64 delta, GdkWindowEdge edge); +void _model_track_trim (ModelTrack* self, ModelClip* clip, gint64 delta, GdkWindowEdge edge); +gint64 model_track_previous_edit (ModelTrack* self, gint64 pos); +gint64 model_track_next_edit (ModelTrack* self, gint64 pos); +void model_track_write_attributes (ModelTrack* self, FILE* f); +void model_track_save (ModelTrack* self, FILE* f); +char* model_track_get_display_name (ModelTrack* self); +void model_track_set_display_name (ModelTrack* self, const char* new_display_name); +void model_track_set_selected (ModelTrack* self, gboolean is_selected); +gboolean model_track_get_is_selected (ModelTrack* self); +#define MODEL_AUDIO_TRACK_INVALID_CHANNEL_COUNT (-1) +ModelAudioTrack* model_audio_track_new (ModelProject* project, const char* display_name); +ModelAudioTrack* model_audio_track_construct (GType object_type, ModelProject* project, const char* display_name); +void model_audio_track_set_pan (ModelAudioTrack* self, double new_value); +void _model_audio_track_set_pan (ModelAudioTrack* self, double new_value); +double model_audio_track_get_pan (ModelAudioTrack* self); +void model_audio_track_set_volume (ModelAudioTrack* self, double new_volume); +void _model_audio_track_set_volume (ModelAudioTrack* self, double new_volume); +double model_audio_track_get_volume (ModelAudioTrack* self); +void model_audio_track_set_default_num_channels (ModelAudioTrack* self, gint num); +gboolean model_audio_track_get_num_channels (ModelAudioTrack* self, gint* num); +void model_audio_track_on_level_changed (ModelAudioTrack* self, double level_left, double level_right); +gboolean transport_delegate_is_playing (TransportDelegate* self); +gboolean transport_delegate_is_recording (TransportDelegate* self); +gboolean transport_delegate_is_stopped (TransportDelegate* self); +GType gap_view_get_type (void); +GapView* gap_view_new (gint64 start, gint64 length, gint width, gint height); +GapView* gap_view_construct (GType object_type, gint64 start, gint64 length, gint width, gint height); +void gap_view_remove (GapView* self); +void gap_view_unselect (GapView* self); +extern GtkMenu* clip_view_context_menu; +#define CLIP_VIEW_SNAP_DELTA 10 +ClipView* clip_view_new (TransportDelegate* transport_delegate, ModelClip* clip, ModelTimeSystem* time_provider, gint height); +ClipView* clip_view_construct (GType object_type, TransportDelegate* transport_delegate, ModelClip* clip, ModelTimeSystem* time_provider, gint height); +void clip_view_adjust_size (ClipView* self, gint height); +void clip_view_on_clip_moved (ClipView* self, ModelClip* clip); +void clip_view_delete_clip (ClipView* self); +void clip_view_draw (ClipView* self); +void clip_view_select (ClipView* self); +void clip_view_snap (ClipView* self, gint64 amount); +ModelUndoManager* model_undo_manager_new (void); +ModelUndoManager* model_undo_manager_construct (GType object_type); +void model_undo_manager_reset (ModelUndoManager* self); +void model_undo_manager_mark_clean (ModelUndoManager* self); +void model_undo_manager_start_transaction (ModelUndoManager* self, const char* description); +void model_undo_manager_end_transaction (ModelUndoManager* self, const char* description); +void model_undo_manager_do_command (ModelUndoManager* self, ModelCommand* the_command); +void model_undo_manager_undo (ModelUndoManager* self); +char* model_undo_manager_get_undo_title (ModelUndoManager* self); +gboolean model_undo_manager_get_is_dirty (ModelUndoManager* self); +gboolean model_undo_manager_get_can_undo (ModelUndoManager* self); +gboolean model_undo_manager_get_in_undo (ModelUndoManager* self); +GQuark media_error_quark (void); +float float_abs (float f); +gboolean float_within (double f, double epsilon); +gint sign (gint x); +char** copy_array (char** source, int source_length1, int* result_length1); +extern gboolean debug_enabled; +void print_debug (const char* text); +void fraction_init (Fraction *self, gint numerator, gint denominator); +void fraction_init_from_string (Fraction *self, const char* s); +gboolean fraction_equal (Fraction *self, Fraction* f); +gint fraction_nearest_int (Fraction *self); +char* fraction_to_string (Fraction *self); +void time_code_get_from_length (TimeCode *self, gint64 length); +char* time_code_to_string (TimeCode *self); +gboolean time_in_range (gint64 time, gint64 center, gint64 delta); +char* isolate_filename (const char* path); +char* get_file_extension (const char* path); +char* append_extension (const char* path, const char* extension); +gboolean version_at_least (const char* v, const char* w); +gboolean get_file_md5_checksum (const char* filename, char** checksum); +void save_file_md5_checksum (const char* filename, const char* checksum); +gboolean md5_checksum_on_file (const char* filename, char** checksum); +extern GdkModifierType GDK_SHIFT_ALT_CONTROL_MASK; +void parse_color (const char* color, GdkColor* result); +GtkWidget* get_widget (GtkUIManager* manager, const char* name); +void draw_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height); +void draw_right_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height); +void draw_left_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height); +void draw_square_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x, gint y, gint width, gint height); +gboolean is_drop_frame_rate (Fraction* r); +gint64 frame_to_time_with_rate (gint frame, Fraction* rate); +gint time_to_frame_with_rate (gint64 time, Fraction* rate); +void frame_to_time (gint frame, Fraction* rate, TimeCode* result); +char* frame_to_string (gint frame, Fraction* rate); +char* time_to_HHMMSS (gint64 time); +char* time_to_string (gint64 time); +GstElement* make_element_with_name (const char* element_name, const char* display_name, GError** error); +GstElement* make_element (const char* name, GError** error); +ModelVideoTrack* model_video_track_new (ModelProject* project); +ModelVideoTrack* model_video_track_construct (GType object_type, ModelProject* project); +gint model_video_track_get_current_frame (ModelVideoTrack* self, gint64 time); +gint64 model_video_track_previous_frame (ModelVideoTrack* self, gint64 position); +gint64 model_video_track_next_frame (ModelVideoTrack* self, gint64 position); +gboolean model_video_track_get_framerate (ModelVideoTrack* self, Fraction* rate); + +extern const char* MODEL_PROJECT_authors[5]; +extern const GtkTargetEntry drag_target_entries[1]; + +G_END_DECLS + +#endif diff --git a/src/marina/marina/.stamp b/src/marina/marina/.stamp new file mode 100644 index 0000000..e69de29 diff --git a/src/marina/marina/AppDirs.c b/src/marina/marina/AppDirs.c new file mode 100644 index 0000000..5e7effa --- /dev/null +++ b/src/marina/marina/AppDirs.c @@ -0,0 +1,363 @@ +/* AppDirs.c generated by valac, the Vala compiler + * generated from AppDirs.vala, do not modify */ + +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU LGPL (version 2.1 or later). + * See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include + + +#define TYPE_APP_DIRS (app_dirs_get_type ()) +#define APP_DIRS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_APP_DIRS, AppDirs)) +#define APP_DIRS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_APP_DIRS, AppDirsClass)) +#define IS_APP_DIRS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_APP_DIRS)) +#define IS_APP_DIRS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_APP_DIRS)) +#define APP_DIRS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_APP_DIRS, AppDirsClass)) + +typedef struct _AppDirs AppDirs; +typedef struct _AppDirsClass AppDirsClass; +typedef struct _AppDirsPrivate AppDirsPrivate; +#define _g_free0(var) (var = (g_free (var), NULL)) +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +typedef struct _ParamSpecAppDirs ParamSpecAppDirs; + +struct _AppDirs { + GTypeInstance parent_instance; + volatile int ref_count; + AppDirsPrivate * priv; +}; + +struct _AppDirsClass { + GTypeClass parent_class; + void (*finalize) (AppDirs *self); +}; + +struct _ParamSpecAppDirs { + GParamSpec parent_instance; +}; + + +static GFile* app_dirs_exec_dir; +static GFile* app_dirs_exec_dir = NULL; +static char* app_dirs_program_name; +static char* app_dirs_program_name = NULL; +static gpointer app_dirs_parent_class = NULL; + +gpointer app_dirs_ref (gpointer instance); +void app_dirs_unref (gpointer instance); +GParamSpec* param_spec_app_dirs (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void value_set_app_dirs (GValue* value, gpointer v_object); +void value_take_app_dirs (GValue* value, gpointer v_object); +gpointer value_get_app_dirs (const GValue* value); +GType app_dirs_get_type (void); +enum { + APP_DIRS_DUMMY_PROPERTY +}; +void app_dirs_init (const char* arg0, const char* program_name); +void app_dirs_terminate (void); +GFile* app_dirs_get_exec_dir (void); +static GFile* app_dirs_get_install_dir (void); +GFile* app_dirs_get_resources_dir (void); +AppDirs* app_dirs_new (void); +AppDirs* app_dirs_construct (GType object_type); +static void app_dirs_finalize (AppDirs* obj); + + + +#line 14 "AppDirs.vala" +void app_dirs_init (const char* arg0, const char* program_name) { +#line 78 "AppDirs.c" + char* _tmp0_; + GFile* _tmp1_; + GFile* exec_file; + GFile* _tmp2_; + char* _tmp3_; +#line 14 "AppDirs.vala" + g_return_if_fail (arg0 != NULL); +#line 14 "AppDirs.vala" + g_return_if_fail (program_name != NULL); +#line 15 "AppDirs.vala" + exec_file = (_tmp1_ = g_file_new_for_path (_tmp0_ = g_find_program_in_path (arg0)), _g_free0 (_tmp0_), _tmp1_); +#line 16 "AppDirs.vala" + app_dirs_exec_dir = (_tmp2_ = g_file_get_parent (exec_file), _g_object_unref0 (app_dirs_exec_dir), _tmp2_); +#line 17 "AppDirs.vala" + app_dirs_program_name = (_tmp3_ = g_strdup (program_name), _g_free0 (app_dirs_program_name), _tmp3_); +#line 94 "AppDirs.c" + _g_object_unref0 (exec_file); +} + + +#line 20 "AppDirs.vala" +void app_dirs_terminate (void) { +#line 101 "AppDirs.c" +} + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 23 "AppDirs.vala" +GFile* app_dirs_get_exec_dir (void) { +#line 112 "AppDirs.c" + GFile* result = NULL; + result = _g_object_ref0 (app_dirs_exec_dir); +#line 24 "AppDirs.vala" + return result; +#line 117 "AppDirs.c" +} + + +#line 27 "AppDirs.vala" +GFile* app_dirs_get_resources_dir (void) { +#line 123 "AppDirs.c" + GFile* result = NULL; + GFile* exec_dir; + GFile* install_dir; + GFile* return_value; +#line 28 "AppDirs.vala" + exec_dir = app_dirs_get_exec_dir (); +#line 29 "AppDirs.vala" + install_dir = app_dirs_get_install_dir (); +#line 132 "AppDirs.c" + return_value = NULL; +#line 31 "AppDirs.vala" + if (install_dir != NULL) { +#line 136 "AppDirs.c" + GFile* _tmp1_; + GFile* _tmp0_; +#line 32 "AppDirs.vala" + return_value = (_tmp1_ = g_file_get_child (_tmp0_ = g_file_get_child (install_dir, "share"), app_dirs_program_name), _g_object_unref0 (return_value), _tmp1_); +#line 141 "AppDirs.c" + _g_object_unref0 (_tmp0_); + } else { + GFile* _tmp2_; +#line 34 "AppDirs.vala" + return_value = (_tmp2_ = _g_object_ref0 (exec_dir), _g_object_unref0 (return_value), _tmp2_); +#line 147 "AppDirs.c" + } + result = g_file_get_child (return_value, "resources"); + _g_object_unref0 (exec_dir); + _g_object_unref0 (install_dir); + _g_object_unref0 (return_value); +#line 36 "AppDirs.vala" + return result; +#line 155 "AppDirs.c" +} + + +#line 39 "AppDirs.vala" +static GFile* app_dirs_get_install_dir (void) { +#line 161 "AppDirs.c" + GFile* result = NULL; + GFile* prefix_dir; + GFile* _tmp0_; +#line 40 "AppDirs.vala" + prefix_dir = g_file_new_for_path (_PREFIX); +#line 167 "AppDirs.c" + _tmp0_ = NULL; +#line 41 "AppDirs.vala" + if (g_file_has_prefix (app_dirs_exec_dir, prefix_dir)) { +#line 41 "AppDirs.vala" + _tmp0_ = prefix_dir; +#line 173 "AppDirs.c" + } else { +#line 41 "AppDirs.vala" + _tmp0_ = NULL; +#line 177 "AppDirs.c" + } + result = _g_object_ref0 (_tmp0_); + _g_object_unref0 (prefix_dir); +#line 41 "AppDirs.vala" + return result; +#line 183 "AppDirs.c" +} + + +#line 10 "AppDirs.vala" +AppDirs* app_dirs_construct (GType object_type) { +#line 189 "AppDirs.c" + AppDirs* self; + self = (AppDirs*) g_type_create_instance (object_type); + return self; +} + + +#line 10 "AppDirs.vala" +AppDirs* app_dirs_new (void) { +#line 10 "AppDirs.vala" + return app_dirs_construct (TYPE_APP_DIRS); +#line 200 "AppDirs.c" +} + + +static void value_app_dirs_init (GValue* value) { + value->data[0].v_pointer = NULL; +} + + +static void value_app_dirs_free_value (GValue* value) { + if (value->data[0].v_pointer) { + app_dirs_unref (value->data[0].v_pointer); + } +} + + +static void value_app_dirs_copy_value (const GValue* src_value, GValue* dest_value) { + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = app_dirs_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + + +static gpointer value_app_dirs_peek_pointer (const GValue* value) { + return value->data[0].v_pointer; +} + + +static gchar* value_app_dirs_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + if (collect_values[0].v_pointer) { + AppDirs* object; + object = collect_values[0].v_pointer; + if (object->parent_instance.g_class == NULL) { + return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) { + return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } + value->data[0].v_pointer = app_dirs_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + + +static gchar* value_app_dirs_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + AppDirs** object_p; + object_p = collect_values[0].v_pointer; + if (!object_p) { + return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); + } + if (!value->data[0].v_pointer) { + *object_p = NULL; + } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) { + *object_p = value->data[0].v_pointer; + } else { + *object_p = app_dirs_ref (value->data[0].v_pointer); + } + return NULL; +} + + +GParamSpec* param_spec_app_dirs (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) { + ParamSpecAppDirs* spec; + g_return_val_if_fail (g_type_is_a (object_type, TYPE_APP_DIRS), NULL); + spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags); + G_PARAM_SPEC (spec)->value_type = object_type; + return G_PARAM_SPEC (spec); +} + + +gpointer value_get_app_dirs (const GValue* value) { + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_APP_DIRS), NULL); + return value->data[0].v_pointer; +} + + +void value_set_app_dirs (GValue* value, gpointer v_object) { + AppDirs* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_APP_DIRS)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_APP_DIRS)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + app_dirs_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + app_dirs_unref (old); + } +} + + +void value_take_app_dirs (GValue* value, gpointer v_object) { + AppDirs* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_APP_DIRS)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_APP_DIRS)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + app_dirs_unref (old); + } +} + + +static void app_dirs_class_init (AppDirsClass * klass) { + app_dirs_parent_class = g_type_class_peek_parent (klass); + APP_DIRS_CLASS (klass)->finalize = app_dirs_finalize; +} + + +static void app_dirs_instance_init (AppDirs * self) { + self->ref_count = 1; +} + + +static void app_dirs_finalize (AppDirs* obj) { + AppDirs * self; + self = APP_DIRS (obj); +} + + +GType app_dirs_get_type (void) { + static volatile gsize app_dirs_type_id__volatile = 0; + if (g_once_init_enter (&app_dirs_type_id__volatile)) { + static const GTypeValueTable g_define_type_value_table = { value_app_dirs_init, value_app_dirs_free_value, value_app_dirs_copy_value, value_app_dirs_peek_pointer, "p", value_app_dirs_collect_value, "p", value_app_dirs_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (AppDirsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) app_dirs_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (AppDirs), 0, (GInstanceInitFunc) app_dirs_instance_init, &g_define_type_value_table }; + static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) }; + GType app_dirs_type_id; + app_dirs_type_id = g_type_register_fundamental (g_type_fundamental_next (), "AppDirs", &g_define_type_info, &g_define_type_fundamental_info, 0); + g_once_init_leave (&app_dirs_type_id__volatile, app_dirs_type_id); + } + return app_dirs_type_id__volatile; +} + + +gpointer app_dirs_ref (gpointer instance) { + AppDirs* self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + + +void app_dirs_unref (gpointer instance) { + AppDirs* self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + APP_DIRS_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + + + + diff --git a/src/marina/marina/AppDirs.o b/src/marina/marina/AppDirs.o new file mode 100644 index 0000000..17b4f6b Binary files /dev/null and b/src/marina/marina/AppDirs.o differ diff --git a/src/marina/marina/AudioMeter.c b/src/marina/marina/AudioMeter.c new file mode 100644 index 0000000..da03c23 --- /dev/null +++ b/src/marina/marina/AudioMeter.c @@ -0,0 +1,453 @@ +/* AudioMeter.c generated by valac, the Vala compiler + * generated from AudioMeter.vala, do not modify */ + +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#define VIEW_TYPE_AUDIO_METER (view_audio_meter_get_type ()) +#define VIEW_AUDIO_METER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_AUDIO_METER, ViewAudioMeter)) +#define VIEW_AUDIO_METER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_AUDIO_METER, ViewAudioMeterClass)) +#define VIEW_IS_AUDIO_METER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_AUDIO_METER)) +#define VIEW_IS_AUDIO_METER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_AUDIO_METER)) +#define VIEW_AUDIO_METER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_AUDIO_METER, ViewAudioMeterClass)) + +typedef struct _ViewAudioMeter ViewAudioMeter; +typedef struct _ViewAudioMeterClass ViewAudioMeterClass; +typedef struct _ViewAudioMeterPrivate ViewAudioMeterPrivate; +#define _cairo_surface_destroy0(var) ((var == NULL) ? NULL : (var = (cairo_surface_destroy (var), NULL))) + +#define MODEL_TYPE_TRACK (model_track_get_type ()) +#define MODEL_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TRACK, ModelTrack)) +#define MODEL_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TRACK, ModelTrackClass)) +#define MODEL_IS_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TRACK)) +#define MODEL_IS_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TRACK)) +#define MODEL_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TRACK, ModelTrackClass)) + +typedef struct _ModelTrack ModelTrack; +typedef struct _ModelTrackClass ModelTrackClass; + +#define MODEL_TYPE_AUDIO_TRACK (model_audio_track_get_type ()) +#define MODEL_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrack)) +#define MODEL_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrackClass)) +#define MODEL_IS_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_AUDIO_TRACK)) +#define MODEL_IS_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_AUDIO_TRACK)) +#define MODEL_AUDIO_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrackClass)) + +typedef struct _ModelAudioTrack ModelAudioTrack; +typedef struct _ModelAudioTrackClass ModelAudioTrackClass; +#define _cairo_destroy0(var) ((var == NULL) ? NULL : (var = (cairo_destroy (var), NULL))) +#define _cairo_pattern_destroy0(var) ((var == NULL) ? NULL : (var = (cairo_pattern_destroy (var), NULL))) + +#define LOGGING_TYPE_FACILITY (logging_facility_get_type ()) + +#define LOGGING_TYPE_LEVEL (logging_level_get_type ()) +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) + +struct _ViewAudioMeter { + GtkDrawingArea parent_instance; + ViewAudioMeterPrivate * priv; +}; + +struct _ViewAudioMeterClass { + GtkDrawingAreaClass parent_class; +}; + +struct _ViewAudioMeterPrivate { + cairo_surface_t* meter; + cairo_surface_t* silkscreen; + gboolean stereo; + double current_level_left; + double current_level_right; +}; + +typedef enum { + LOGGING_FACILITY_SIGNAL_HANDLERS, + LOGGING_FACILITY_DEVELOPER_WARNINGS, + LOGGING_FACILITY_GRAPH, + LOGGING_FACILITY_LOADING, + LOGGING_FACILITY_IMPORT, + LOGGING_FACILITY_SINGLEDECODEBIN +} LoggingFacility; + +typedef enum { + LOGGING_LEVEL_CRITICAL, + LOGGING_LEVEL_HIGH, + LOGGING_LEVEL_MEDIUM, + LOGGING_LEVEL_LOW, + LOGGING_LEVEL_INFO, + LOGGING_LEVEL_VERBOSE +} LoggingLevel; + + +static gpointer view_audio_meter_parent_class = NULL; + +GType view_audio_meter_get_type (void); +#define VIEW_AUDIO_METER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIEW_TYPE_AUDIO_METER, ViewAudioMeterPrivate)) +enum { + VIEW_AUDIO_METER_DUMMY_PROPERTY +}; +#define VIEW_AUDIO_METER_minDB ((double) (-70)) +GType model_track_get_type (void); +GType model_audio_track_get_type (void); +gboolean model_audio_track_get_num_channels (ModelAudioTrack* self, gint* num); +gboolean view_audio_meter_on_expose_event (ViewAudioMeter* self, GdkEventExpose* event); +static gboolean _view_audio_meter_on_expose_event_gtk_widget_expose_event (GtkWidget* _sender, GdkEventExpose* event, gpointer self); +void view_audio_meter_on_level_changed (ViewAudioMeter* self, double level_left, double level_right); +static void _view_audio_meter_on_level_changed_model_audio_track_level_changed (ModelAudioTrack* _sender, double level_left, double level_right, gpointer self); +void view_audio_meter_on_channel_count_changed (ViewAudioMeter* self, gint number_of_channels); +static void _view_audio_meter_on_channel_count_changed_model_audio_track_channel_count_changed (ModelAudioTrack* _sender, gint channel_count, gpointer self); +ViewAudioMeter* view_audio_meter_new (ModelAudioTrack* track); +ViewAudioMeter* view_audio_meter_construct (GType object_type, ModelAudioTrack* track); +static void view_audio_meter_initialize_meter (ViewAudioMeter* self); +GType logging_facility_get_type (void); +GType logging_level_get_type (void); +void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message); +static void view_audio_meter_finalize (GObject* obj); + + + +#line 64 "AudioMeter.vala" +static gboolean _view_audio_meter_on_expose_event_gtk_widget_expose_event (GtkWidget* _sender, GdkEventExpose* event, gpointer self) { +#line 126 "AudioMeter.c" + gboolean result; + result = view_audio_meter_on_expose_event (self, event); + return result; +} + + +#line 102 "AudioMeter.vala" +static void _view_audio_meter_on_level_changed_model_audio_track_level_changed (ModelAudioTrack* _sender, double level_left, double level_right, gpointer self) { +#line 135 "AudioMeter.c" + view_audio_meter_on_level_changed (self, level_left, level_right); +} + + +#line 110 "AudioMeter.vala" +static void _view_audio_meter_on_channel_count_changed_model_audio_track_channel_count_changed (ModelAudioTrack* _sender, gint channel_count, gpointer self) { +#line 142 "AudioMeter.c" + view_audio_meter_on_channel_count_changed (self, channel_count); +} + + +#line 19 "AudioMeter.vala" +ViewAudioMeter* view_audio_meter_construct (GType object_type, ModelAudioTrack* track) { +#line 149 "AudioMeter.c" + ViewAudioMeter * self; + gint number_of_channels = 0; +#line 19 "AudioMeter.vala" + g_return_val_if_fail (MODEL_IS_AUDIO_TRACK (track), NULL); +#line 154 "AudioMeter.c" + self = g_object_newv (object_type, 0, NULL); +#line 21 "AudioMeter.vala" + if (model_audio_track_get_num_channels (track, &number_of_channels)) { +#line 22 "AudioMeter.vala" + self->priv->stereo = number_of_channels < 1; +#line 160 "AudioMeter.c" + } +#line 25 "AudioMeter.vala" + GTK_WIDGET (self)->requisition.height = 10; +#line 26 "AudioMeter.vala" + g_signal_connect_object (GTK_WIDGET (self), "expose-event", (GCallback) _view_audio_meter_on_expose_event_gtk_widget_expose_event, self, 0); +#line 27 "AudioMeter.vala" + g_signal_connect_object (track, "level-changed", (GCallback) _view_audio_meter_on_level_changed_model_audio_track_level_changed, self, 0); +#line 28 "AudioMeter.vala" + g_signal_connect_object (track, "channel-count-changed", (GCallback) _view_audio_meter_on_channel_count_changed_model_audio_track_channel_count_changed, self, 0); +#line 170 "AudioMeter.c" + return self; +} + + +#line 19 "AudioMeter.vala" +ViewAudioMeter* view_audio_meter_new (ModelAudioTrack* track) { +#line 19 "AudioMeter.vala" + return view_audio_meter_construct (VIEW_TYPE_AUDIO_METER, track); +#line 179 "AudioMeter.c" +} + + +#line 31 "AudioMeter.vala" +static void view_audio_meter_initialize_meter (ViewAudioMeter* self) { +#line 185 "AudioMeter.c" + cairo_surface_t* _tmp0_; + cairo_t* context2; + cairo_pattern_t* pat; + cairo_surface_t* _tmp1_; + cairo_t* _tmp2_; +#line 31 "AudioMeter.vala" + g_return_if_fail (VIEW_IS_AUDIO_METER (self)); +#line 32 "AudioMeter.vala" + self->priv->meter = (_tmp0_ = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, GTK_WIDGET (self)->allocation.width, GTK_WIDGET (self)->allocation.height), _cairo_surface_destroy0 (self->priv->meter), _tmp0_); +#line 34 "AudioMeter.vala" + context2 = cairo_create (self->priv->meter); +#line 35 "AudioMeter.vala" + pat = cairo_pattern_create_linear ((double) 0, (double) 0, (double) GTK_WIDGET (self)->allocation.width, (double) 0); +#line 36 "AudioMeter.vala" + cairo_pattern_add_color_stop_rgb (pat, (double) 0, 0.1, (double) 1, 0.4); +#line 37 "AudioMeter.vala" + cairo_pattern_add_color_stop_rgb (pat, 0.8, (double) 1, (double) 1, (double) 0); +#line 38 "AudioMeter.vala" + cairo_pattern_add_color_stop_rgb (pat, (double) 1, (double) 1, (double) 0, (double) 0); +#line 39 "AudioMeter.vala" + cairo_set_source (context2, pat); +#line 40 "AudioMeter.vala" + cairo_rectangle (context2, (double) 0, (double) 0, (double) GTK_WIDGET (self)->allocation.width, (double) GTK_WIDGET (self)->allocation.height); +#line 41 "AudioMeter.vala" + cairo_fill (context2); +#line 43 "AudioMeter.vala" + self->priv->silkscreen = (_tmp1_ = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, GTK_WIDGET (self)->allocation.width, GTK_WIDGET (self)->allocation.height), _cairo_surface_destroy0 (self->priv->silkscreen), _tmp1_); +#line 45 "AudioMeter.vala" + context2 = (_tmp2_ = cairo_create (self->priv->silkscreen), _cairo_destroy0 (context2), _tmp2_); +#line 46 "AudioMeter.vala" + cairo_set_source_rgba (context2, (double) 0, (double) 0, (double) 0, (double) 0); +#line 47 "AudioMeter.vala" + cairo_rectangle (context2, (double) 0, (double) 0, (double) GTK_WIDGET (self)->allocation.width, (double) GTK_WIDGET (self)->allocation.height); +#line 48 "AudioMeter.vala" + cairo_fill (context2); +#line 221 "AudioMeter.c" + { + gint i; +#line 51 "AudioMeter.vala" + i = 0; +#line 226 "AudioMeter.c" + { + gboolean _tmp3_; +#line 51 "AudioMeter.vala" + _tmp3_ = TRUE; +#line 51 "AudioMeter.vala" + while (TRUE) { +#line 51 "AudioMeter.vala" + if (!_tmp3_) { +#line 51 "AudioMeter.vala" + i = i + 1; +#line 237 "AudioMeter.c" + } +#line 51 "AudioMeter.vala" + _tmp3_ = FALSE; +#line 51 "AudioMeter.vala" + if (!(i < 20)) { +#line 51 "AudioMeter.vala" + break; +#line 245 "AudioMeter.c" + } +#line 52 "AudioMeter.vala" + cairo_set_source_rgba (context2, (double) 0, (double) 0, (double) 0, (double) 1); +#line 53 "AudioMeter.vala" + cairo_rectangle (context2, (double) ((i * GTK_WIDGET (self)->allocation.width) / 20), (double) 0, (double) 3, (double) GTK_WIDGET (self)->allocation.height); +#line 54 "AudioMeter.vala" + cairo_fill (context2); +#line 253 "AudioMeter.c" + } + } + } +#line 58 "AudioMeter.vala" + cairo_set_line_width (context2, 1.1); +#line 59 "AudioMeter.vala" + cairo_set_source_rgba (context2, 0.9, 0.9, 0.9, 0.5); +#line 60 "AudioMeter.vala" + cairo_rectangle (context2, (double) 0, (double) 0, (double) GTK_WIDGET (self)->allocation.width, (double) GTK_WIDGET (self)->allocation.height); +#line 61 "AudioMeter.vala" + cairo_stroke (context2); +#line 265 "AudioMeter.c" + _cairo_destroy0 (context2); + _cairo_pattern_destroy0 (pat); +} + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 64 "AudioMeter.vala" +gboolean view_audio_meter_on_expose_event (ViewAudioMeter* self, GdkEventExpose* event) { +#line 278 "AudioMeter.c" + gboolean result = FALSE; + GdkWindow* window; + cairo_t* context; + gint _tmp0_ = 0; + gint bar_height; + gint width; +#line 64 "AudioMeter.vala" + g_return_val_if_fail (VIEW_IS_AUDIO_METER (self), FALSE); +#line 65 "AudioMeter.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_expose_event"); +#line 66 "AudioMeter.vala" + window = _g_object_ref0 (gtk_widget_get_window (GTK_WIDGET (self))); +#line 67 "AudioMeter.vala" + context = gdk_cairo_create (GDK_DRAWABLE (window)); +#line 68 "AudioMeter.vala" + if (self->priv->meter == NULL) { +#line 69 "AudioMeter.vala" + view_audio_meter_initialize_meter (self); +#line 297 "AudioMeter.c" + } +#line 72 "AudioMeter.vala" + cairo_set_source_rgb (context, (double) 0, (double) 0, (double) 0); +#line 73 "AudioMeter.vala" + cairo_rectangle (context, (double) 0, (double) 0, (double) GTK_WIDGET (self)->allocation.width, (double) GTK_WIDGET (self)->allocation.height); +#line 74 "AudioMeter.vala" + cairo_fill (context); +#line 76 "AudioMeter.vala" + if (self->priv->stereo) { +#line 76 "AudioMeter.vala" + _tmp0_ = (GTK_WIDGET (self)->allocation.height / 2) - 1; +#line 309 "AudioMeter.c" + } else { +#line 76 "AudioMeter.vala" + _tmp0_ = GTK_WIDGET (self)->allocation.height - 2; +#line 313 "AudioMeter.c" + } +#line 76 "AudioMeter.vala" + bar_height = _tmp0_; +#line 78 "AudioMeter.vala" + if (self->priv->stereo) { +#line 79 "AudioMeter.vala" + cairo_set_source_rgb (context, (double) 1, (double) 1, (double) 1); +#line 80 "AudioMeter.vala" + cairo_rectangle (context, (double) 0, (double) (bar_height + 1), (double) GTK_WIDGET (self)->allocation.width, 0.3); +#line 81 "AudioMeter.vala" + cairo_fill (context); +#line 325 "AudioMeter.c" + } +#line 84 "AudioMeter.vala" + cairo_set_source_surface (context, self->priv->meter, (double) 0, (double) 0); +#line 85 "AudioMeter.vala" + width = (gint) (pow10 (self->priv->current_level_left / 40) * GTK_WIDGET (self)->allocation.width); +#line 86 "AudioMeter.vala" + cairo_rectangle (context, (double) 0, (double) 1, (double) width, (double) bar_height); +#line 88 "AudioMeter.vala" + if (self->priv->stereo) { +#line 89 "AudioMeter.vala" + width = (gint) (pow10 (self->priv->current_level_right / 40) * GTK_WIDGET (self)->allocation.width); +#line 90 "AudioMeter.vala" + cairo_rectangle (context, (double) 0, (double) (bar_height + 2), (double) width, (double) bar_height); +#line 339 "AudioMeter.c" + } +#line 93 "AudioMeter.vala" + cairo_clip (context); +#line 94 "AudioMeter.vala" + cairo_paint_with_alpha (context, (double) 1); +#line 96 "AudioMeter.vala" + cairo_set_source_surface (context, self->priv->silkscreen, (double) 0, (double) 0); +#line 97 "AudioMeter.vala" + cairo_paint_with_alpha (context, (double) 1); +#line 349 "AudioMeter.c" + result = TRUE; + _g_object_unref0 (window); + _cairo_destroy0 (context); +#line 99 "AudioMeter.vala" + return result; +#line 355 "AudioMeter.c" +} + + +#line 102 "AudioMeter.vala" +void view_audio_meter_on_level_changed (ViewAudioMeter* self, double level_left, double level_right) { +#line 361 "AudioMeter.c" + double _tmp0_ = 0.0; + double _tmp1_ = 0.0; + GdkWindow* window; +#line 102 "AudioMeter.vala" + g_return_if_fail (VIEW_IS_AUDIO_METER (self)); +#line 103 "AudioMeter.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_level_changed"); +#line 104 "AudioMeter.vala" + if (level_left < VIEW_AUDIO_METER_minDB) { +#line 104 "AudioMeter.vala" + _tmp0_ = VIEW_AUDIO_METER_minDB; +#line 373 "AudioMeter.c" + } else { +#line 104 "AudioMeter.vala" + _tmp0_ = level_left; +#line 377 "AudioMeter.c" + } +#line 104 "AudioMeter.vala" + self->priv->current_level_left = _tmp0_; +#line 105 "AudioMeter.vala" + if (level_right < VIEW_AUDIO_METER_minDB) { +#line 105 "AudioMeter.vala" + _tmp1_ = VIEW_AUDIO_METER_minDB; +#line 385 "AudioMeter.c" + } else { +#line 105 "AudioMeter.vala" + _tmp1_ = level_right; +#line 389 "AudioMeter.c" + } +#line 105 "AudioMeter.vala" + self->priv->current_level_right = _tmp1_; +#line 106 "AudioMeter.vala" + window = _g_object_ref0 (gtk_widget_get_window (GTK_WIDGET (self))); +#line 107 "AudioMeter.vala" + gdk_window_invalidate_rect (window, NULL, FALSE); +#line 397 "AudioMeter.c" + _g_object_unref0 (window); +} + + +#line 110 "AudioMeter.vala" +void view_audio_meter_on_channel_count_changed (ViewAudioMeter* self, gint number_of_channels) { +#line 110 "AudioMeter.vala" + g_return_if_fail (VIEW_IS_AUDIO_METER (self)); +#line 111 "AudioMeter.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_channel_count_changed"); +#line 112 "AudioMeter.vala" + self->priv->stereo = number_of_channels > 1; +#line 113 "AudioMeter.vala" + gdk_window_invalidate_rect (GTK_WIDGET (self)->window, NULL, FALSE); +#line 412 "AudioMeter.c" +} + + +static void view_audio_meter_class_init (ViewAudioMeterClass * klass) { + view_audio_meter_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ViewAudioMeterPrivate)); + G_OBJECT_CLASS (klass)->finalize = view_audio_meter_finalize; +} + + +static void view_audio_meter_instance_init (ViewAudioMeter * self) { + self->priv = VIEW_AUDIO_METER_GET_PRIVATE (self); + self->priv->meter = NULL; + self->priv->stereo = FALSE; + self->priv->current_level_left = (double) (-100); + self->priv->current_level_right = (double) (-100); +} + + +static void view_audio_meter_finalize (GObject* obj) { + ViewAudioMeter * self; + self = VIEW_AUDIO_METER (obj); + _cairo_surface_destroy0 (self->priv->meter); + _cairo_surface_destroy0 (self->priv->silkscreen); + G_OBJECT_CLASS (view_audio_meter_parent_class)->finalize (obj); +} + + +GType view_audio_meter_get_type (void) { + static volatile gsize view_audio_meter_type_id__volatile = 0; + if (g_once_init_enter (&view_audio_meter_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ViewAudioMeterClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_audio_meter_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewAudioMeter), 0, (GInstanceInitFunc) view_audio_meter_instance_init, NULL }; + GType view_audio_meter_type_id; + view_audio_meter_type_id = g_type_register_static (GTK_TYPE_DRAWING_AREA, "ViewAudioMeter", &g_define_type_info, 0); + g_once_init_leave (&view_audio_meter_type_id__volatile, view_audio_meter_type_id); + } + return view_audio_meter_type_id__volatile; +} + + + + diff --git a/src/marina/marina/AudioMeter.o b/src/marina/marina/AudioMeter.o new file mode 100644 index 0000000..8132bdc Binary files /dev/null and b/src/marina/marina/AudioMeter.o differ diff --git a/src/marina/marina/ClassFactory.c b/src/marina/marina/ClassFactory.c new file mode 100644 index 0000000..6761d41 --- /dev/null +++ b/src/marina/marina/ClassFactory.c @@ -0,0 +1,484 @@ +/* ClassFactory.c generated by valac, the Vala compiler + * generated from ClassFactory.vala, do not modify */ + +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include + + +#define TYPE_TRACK_VIEW (track_view_get_type ()) +#define TRACK_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRACK_VIEW, TrackView)) +#define IS_TRACK_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRACK_VIEW)) +#define TRACK_VIEW_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_TRACK_VIEW, TrackViewIface)) + +typedef struct _TrackView TrackView; +typedef struct _TrackViewIface TrackViewIface; + +#define TYPE_CLIP_VIEW (clip_view_get_type ()) +#define CLIP_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CLIP_VIEW, ClipView)) +#define CLIP_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CLIP_VIEW, ClipViewClass)) +#define IS_CLIP_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CLIP_VIEW)) +#define IS_CLIP_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CLIP_VIEW)) +#define CLIP_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CLIP_VIEW, ClipViewClass)) + +typedef struct _ClipView ClipView; +typedef struct _ClipViewClass ClipViewClass; + +#define MODEL_TYPE_TRACK (model_track_get_type ()) +#define MODEL_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TRACK, ModelTrack)) +#define MODEL_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TRACK, ModelTrackClass)) +#define MODEL_IS_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TRACK)) +#define MODEL_IS_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TRACK)) +#define MODEL_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TRACK, ModelTrackClass)) + +typedef struct _ModelTrack ModelTrack; +typedef struct _ModelTrackClass ModelTrackClass; + +#define TYPE_CLASS_FACTORY (class_factory_get_type ()) +#define CLASS_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CLASS_FACTORY, ClassFactory)) +#define CLASS_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CLASS_FACTORY, ClassFactoryClass)) +#define IS_CLASS_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CLASS_FACTORY)) +#define IS_CLASS_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CLASS_FACTORY)) +#define CLASS_FACTORY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CLASS_FACTORY, ClassFactoryClass)) + +typedef struct _ClassFactory ClassFactory; +typedef struct _ClassFactoryClass ClassFactoryClass; +typedef struct _ClassFactoryPrivate ClassFactoryPrivate; + +#define TYPE_TIME_LINE (time_line_get_type ()) +#define TIME_LINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TIME_LINE, TimeLine)) +#define TIME_LINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TIME_LINE, TimeLineClass)) +#define IS_TIME_LINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TIME_LINE)) +#define IS_TIME_LINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TIME_LINE)) +#define TIME_LINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TIME_LINE, TimeLineClass)) + +typedef struct _TimeLine TimeLine; +typedef struct _TimeLineClass TimeLineClass; + +#define TYPE_TRANSPORT_DELEGATE (transport_delegate_get_type ()) +#define TRANSPORT_DELEGATE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRANSPORT_DELEGATE, TransportDelegate)) +#define IS_TRANSPORT_DELEGATE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRANSPORT_DELEGATE)) +#define TRANSPORT_DELEGATE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_TRANSPORT_DELEGATE, TransportDelegateIface)) + +typedef struct _TransportDelegate TransportDelegate; +typedef struct _TransportDelegateIface TransportDelegateIface; + +#define TYPE_TRACK_VIEW_CONCRETE (track_view_concrete_get_type ()) +#define TRACK_VIEW_CONCRETE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRACK_VIEW_CONCRETE, TrackViewConcrete)) +#define TRACK_VIEW_CONCRETE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TRACK_VIEW_CONCRETE, TrackViewConcreteClass)) +#define IS_TRACK_VIEW_CONCRETE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRACK_VIEW_CONCRETE)) +#define IS_TRACK_VIEW_CONCRETE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TRACK_VIEW_CONCRETE)) +#define TRACK_VIEW_CONCRETE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TRACK_VIEW_CONCRETE, TrackViewConcreteClass)) + +typedef struct _TrackViewConcrete TrackViewConcrete; +typedef struct _TrackViewConcreteClass TrackViewConcreteClass; +#define _class_factory_unref0(var) ((var == NULL) ? NULL : (var = (class_factory_unref (var), NULL))) +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +typedef struct _ParamSpecClassFactory ParamSpecClassFactory; + +struct _TrackViewIface { + GTypeInterface parent_iface; + void (*move_to_top) (TrackView* self, ClipView* clip_view); + void (*resize) (TrackView* self); + ModelTrack* (*get_track) (TrackView* self); + gint (*get_track_height) (TrackView* self); + GtkWidget* (*find_child) (TrackView* self, double x, double y); + void (*select_all) (TrackView* self); +}; + +struct _ClassFactory { + GTypeInstance parent_instance; + volatile int ref_count; + ClassFactoryPrivate * priv; +}; + +struct _ClassFactoryClass { + GTypeClass parent_class; + void (*finalize) (ClassFactory *self); + TrackView* (*get_track_view) (ClassFactory* self, ModelTrack* track, TimeLine* timeline); +}; + +struct _TransportDelegateIface { + GTypeInterface parent_iface; + gboolean (*is_playing) (TransportDelegate* self); + gboolean (*is_recording) (TransportDelegate* self); + gboolean (*is_stopped) (TransportDelegate* self); +}; + +struct _ParamSpecClassFactory { + GParamSpec parent_instance; +}; + + +static ClassFactory* class_factory_class_factory; +static ClassFactory* class_factory_class_factory = NULL; +static TransportDelegate* class_factory_transport_delegate; +static TransportDelegate* class_factory_transport_delegate = NULL; +static gpointer class_factory_parent_class = NULL; + +GType clip_view_get_type (void); +GType model_track_get_type (void); +GType track_view_get_type (void); +void track_view_move_to_top (TrackView* self, ClipView* clip_view); +void track_view_resize (TrackView* self); +ModelTrack* track_view_get_track (TrackView* self); +gint track_view_get_track_height (TrackView* self); +GtkWidget* track_view_find_child (TrackView* self, double x, double y); +void track_view_select_all (TrackView* self); +gpointer class_factory_ref (gpointer instance); +void class_factory_unref (gpointer instance); +GParamSpec* param_spec_class_factory (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void value_set_class_factory (GValue* value, gpointer v_object); +void value_take_class_factory (GValue* value, gpointer v_object); +gpointer value_get_class_factory (const GValue* value); +GType class_factory_get_type (void); +GType time_line_get_type (void); +enum { + CLASS_FACTORY_DUMMY_PROPERTY +}; +GType transport_delegate_get_type (void); +ClassFactory* class_factory_get_class_factory (void); +TrackViewConcrete* track_view_concrete_new (TransportDelegate* transport_delegate, ModelTrack* track, TimeLine* timeline); +TrackViewConcrete* track_view_concrete_construct (GType object_type, TransportDelegate* transport_delegate, ModelTrack* track, TimeLine* timeline); +GType track_view_concrete_get_type (void); +TrackView* class_factory_get_track_view (ClassFactory* self, ModelTrack* track, TimeLine* timeline); +static TrackView* class_factory_real_get_track_view (ClassFactory* self, ModelTrack* track, TimeLine* timeline); +void class_factory_set_class_factory (ClassFactory* class_factory); +void class_factory_set_transport_delegate (TransportDelegate* transport_delegate); +ClassFactory* class_factory_new (void); +ClassFactory* class_factory_construct (GType object_type); +static void class_factory_finalize (ClassFactory* obj); + + + +#line 9 "ClassFactory.vala" +void track_view_move_to_top (TrackView* self, ClipView* clip_view) { +#line 9 "ClassFactory.vala" + TRACK_VIEW_GET_INTERFACE (self)->move_to_top (self, clip_view); +#line 168 "ClassFactory.c" +} + + +#line 10 "ClassFactory.vala" +void track_view_resize (TrackView* self) { +#line 10 "ClassFactory.vala" + TRACK_VIEW_GET_INTERFACE (self)->resize (self); +#line 176 "ClassFactory.c" +} + + +#line 11 "ClassFactory.vala" +ModelTrack* track_view_get_track (TrackView* self) { +#line 11 "ClassFactory.vala" + return TRACK_VIEW_GET_INTERFACE (self)->get_track (self); +#line 184 "ClassFactory.c" +} + + +#line 12 "ClassFactory.vala" +gint track_view_get_track_height (TrackView* self) { +#line 12 "ClassFactory.vala" + return TRACK_VIEW_GET_INTERFACE (self)->get_track_height (self); +#line 192 "ClassFactory.c" +} + + +#line 13 "ClassFactory.vala" +GtkWidget* track_view_find_child (TrackView* self, double x, double y) { +#line 13 "ClassFactory.vala" + return TRACK_VIEW_GET_INTERFACE (self)->find_child (self, x, y); +#line 200 "ClassFactory.c" +} + + +#line 14 "ClassFactory.vala" +void track_view_select_all (TrackView* self) { +#line 14 "ClassFactory.vala" + TRACK_VIEW_GET_INTERFACE (self)->select_all (self); +#line 208 "ClassFactory.c" +} + + +static void track_view_base_init (TrackViewIface * iface) { + static gboolean initialized = FALSE; + if (!initialized) { + initialized = TRUE; + g_signal_new ("clip_view_added", TYPE_TRACK_VIEW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, TYPE_CLIP_VIEW); + } +} + + +GType track_view_get_type (void) { + static volatile gsize track_view_type_id__volatile = 0; + if (g_once_init_enter (&track_view_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (TrackViewIface), (GBaseInitFunc) track_view_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL }; + GType track_view_type_id; + track_view_type_id = g_type_register_static (G_TYPE_INTERFACE, "TrackView", &g_define_type_info, 0); + g_type_interface_add_prerequisite (track_view_type_id, GTK_TYPE_WIDGET); + g_once_init_leave (&track_view_type_id__volatile, track_view_type_id); + } + return track_view_type_id__volatile; +} + + +static gpointer _class_factory_ref0 (gpointer self) { + return self ? class_factory_ref (self) : NULL; +} + + +#line 21 "ClassFactory.vala" +ClassFactory* class_factory_get_class_factory (void) { +#line 241 "ClassFactory.c" + ClassFactory* result = NULL; + result = _class_factory_ref0 (class_factory_class_factory); +#line 22 "ClassFactory.vala" + return result; +#line 246 "ClassFactory.c" +} + + +#line 25 "ClassFactory.vala" +static TrackView* class_factory_real_get_track_view (ClassFactory* self, ModelTrack* track, TimeLine* timeline) { +#line 252 "ClassFactory.c" + TrackView* result = NULL; +#line 25 "ClassFactory.vala" + g_return_val_if_fail (IS_CLASS_FACTORY (self), NULL); +#line 25 "ClassFactory.vala" + g_return_val_if_fail (MODEL_IS_TRACK (track), NULL); +#line 25 "ClassFactory.vala" + g_return_val_if_fail (IS_TIME_LINE (timeline), NULL); +#line 26 "ClassFactory.vala" + g_assert (class_factory_transport_delegate != NULL); +#line 262 "ClassFactory.c" + result = TRACK_VIEW (g_object_ref_sink (track_view_concrete_new (class_factory_transport_delegate, track, timeline))); +#line 27 "ClassFactory.vala" + return result; +#line 266 "ClassFactory.c" +} + + +#line 25 "ClassFactory.vala" +TrackView* class_factory_get_track_view (ClassFactory* self, ModelTrack* track, TimeLine* timeline) { +#line 25 "ClassFactory.vala" + return CLASS_FACTORY_GET_CLASS (self)->get_track_view (self, track, timeline); +#line 274 "ClassFactory.c" +} + + +#line 30 "ClassFactory.vala" +void class_factory_set_class_factory (ClassFactory* class_factory) { +#line 280 "ClassFactory.c" + ClassFactory* _tmp0_; +#line 30 "ClassFactory.vala" + g_return_if_fail (IS_CLASS_FACTORY (class_factory)); +#line 31 "ClassFactory.vala" + class_factory_class_factory = (_tmp0_ = _class_factory_ref0 (class_factory), _class_factory_unref0 (class_factory_class_factory), _tmp0_); +#line 286 "ClassFactory.c" +} + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 34 "ClassFactory.vala" +void class_factory_set_transport_delegate (TransportDelegate* transport_delegate) { +#line 297 "ClassFactory.c" + TransportDelegate* _tmp0_; +#line 34 "ClassFactory.vala" + g_return_if_fail (IS_TRANSPORT_DELEGATE (transport_delegate)); +#line 35 "ClassFactory.vala" + class_factory_transport_delegate = (_tmp0_ = _g_object_ref0 (transport_delegate), _g_object_unref0 (class_factory_transport_delegate), _tmp0_); +#line 303 "ClassFactory.c" +} + + +#line 17 "ClassFactory.vala" +ClassFactory* class_factory_construct (GType object_type) { +#line 309 "ClassFactory.c" + ClassFactory* self; + self = (ClassFactory*) g_type_create_instance (object_type); + return self; +} + + +#line 17 "ClassFactory.vala" +ClassFactory* class_factory_new (void) { +#line 17 "ClassFactory.vala" + return class_factory_construct (TYPE_CLASS_FACTORY); +#line 320 "ClassFactory.c" +} + + +static void value_class_factory_init (GValue* value) { + value->data[0].v_pointer = NULL; +} + + +static void value_class_factory_free_value (GValue* value) { + if (value->data[0].v_pointer) { + class_factory_unref (value->data[0].v_pointer); + } +} + + +static void value_class_factory_copy_value (const GValue* src_value, GValue* dest_value) { + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = class_factory_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + + +static gpointer value_class_factory_peek_pointer (const GValue* value) { + return value->data[0].v_pointer; +} + + +static gchar* value_class_factory_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + if (collect_values[0].v_pointer) { + ClassFactory* object; + object = collect_values[0].v_pointer; + if (object->parent_instance.g_class == NULL) { + return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) { + return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } + value->data[0].v_pointer = class_factory_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + + +static gchar* value_class_factory_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + ClassFactory** object_p; + object_p = collect_values[0].v_pointer; + if (!object_p) { + return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); + } + if (!value->data[0].v_pointer) { + *object_p = NULL; + } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) { + *object_p = value->data[0].v_pointer; + } else { + *object_p = class_factory_ref (value->data[0].v_pointer); + } + return NULL; +} + + +GParamSpec* param_spec_class_factory (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) { + ParamSpecClassFactory* spec; + g_return_val_if_fail (g_type_is_a (object_type, TYPE_CLASS_FACTORY), NULL); + spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags); + G_PARAM_SPEC (spec)->value_type = object_type; + return G_PARAM_SPEC (spec); +} + + +gpointer value_get_class_factory (const GValue* value) { + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_CLASS_FACTORY), NULL); + return value->data[0].v_pointer; +} + + +void value_set_class_factory (GValue* value, gpointer v_object) { + ClassFactory* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_CLASS_FACTORY)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_CLASS_FACTORY)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + class_factory_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + class_factory_unref (old); + } +} + + +void value_take_class_factory (GValue* value, gpointer v_object) { + ClassFactory* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_CLASS_FACTORY)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_CLASS_FACTORY)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + class_factory_unref (old); + } +} + + +static void class_factory_class_init (ClassFactoryClass * klass) { + class_factory_parent_class = g_type_class_peek_parent (klass); + CLASS_FACTORY_CLASS (klass)->finalize = class_factory_finalize; + CLASS_FACTORY_CLASS (klass)->get_track_view = class_factory_real_get_track_view; +} + + +static void class_factory_instance_init (ClassFactory * self) { + self->ref_count = 1; +} + + +static void class_factory_finalize (ClassFactory* obj) { + ClassFactory * self; + self = CLASS_FACTORY (obj); +} + + +GType class_factory_get_type (void) { + static volatile gsize class_factory_type_id__volatile = 0; + if (g_once_init_enter (&class_factory_type_id__volatile)) { + static const GTypeValueTable g_define_type_value_table = { value_class_factory_init, value_class_factory_free_value, value_class_factory_copy_value, value_class_factory_peek_pointer, "p", value_class_factory_collect_value, "p", value_class_factory_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (ClassFactoryClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) class_factory_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ClassFactory), 0, (GInstanceInitFunc) class_factory_instance_init, &g_define_type_value_table }; + static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) }; + GType class_factory_type_id; + class_factory_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ClassFactory", &g_define_type_info, &g_define_type_fundamental_info, 0); + g_once_init_leave (&class_factory_type_id__volatile, class_factory_type_id); + } + return class_factory_type_id__volatile; +} + + +gpointer class_factory_ref (gpointer instance) { + ClassFactory* self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + + +void class_factory_unref (gpointer instance) { + ClassFactory* self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + CLASS_FACTORY_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + + + + diff --git a/src/marina/marina/ClassFactory.o b/src/marina/marina/ClassFactory.o new file mode 100644 index 0000000..ec05091 Binary files /dev/null and b/src/marina/marina/ClassFactory.o differ diff --git a/src/marina/marina/ClipLibraryView.c b/src/marina/marina/ClipLibraryView.c new file mode 100644 index 0000000..4f484c1 --- /dev/null +++ b/src/marina/marina/ClipLibraryView.c @@ -0,0 +1,1903 @@ +/* ClipLibraryView.c generated by valac, the Vala compiler + * generated from ClipLibraryView.vala, do not modify */ + +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#define TYPE_CLIP_LIBRARY_VIEW (clip_library_view_get_type ()) +#define CLIP_LIBRARY_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CLIP_LIBRARY_VIEW, ClipLibraryView)) +#define CLIP_LIBRARY_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CLIP_LIBRARY_VIEW, ClipLibraryViewClass)) +#define IS_CLIP_LIBRARY_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CLIP_LIBRARY_VIEW)) +#define IS_CLIP_LIBRARY_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CLIP_LIBRARY_VIEW)) +#define CLIP_LIBRARY_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CLIP_LIBRARY_VIEW, ClipLibraryViewClass)) + +typedef struct _ClipLibraryView ClipLibraryView; +typedef struct _ClipLibraryViewClass ClipLibraryViewClass; +typedef struct _ClipLibraryViewPrivate ClipLibraryViewPrivate; + +#define MODEL_TYPE_PROJECT (model_project_get_type ()) +#define MODEL_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT, ModelProject)) +#define MODEL_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT, ModelProjectClass)) +#define MODEL_IS_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT)) +#define MODEL_IS_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT)) +#define MODEL_PROJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT, ModelProjectClass)) + +typedef struct _ModelProject ModelProject; +typedef struct _ModelProjectClass ModelProjectClass; + +#define CLIP_LIBRARY_VIEW_TYPE_SORT_MODE (clip_library_view_sort_mode_get_type ()) + +#define MODEL_TYPE_TIME_SYSTEM (model_time_system_get_type ()) +#define MODEL_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TIME_SYSTEM, ModelTimeSystem)) +#define MODEL_IS_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TIME_SYSTEM)) +#define MODEL_TIME_SYSTEM_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MODEL_TYPE_TIME_SYSTEM, ModelTimeSystemIface)) + +typedef struct _ModelTimeSystem ModelTimeSystem; +typedef struct _ModelTimeSystemIface ModelTimeSystemIface; + +#define CLIP_LIBRARY_VIEW_TYPE_COLUMN_TYPE (clip_library_view_column_type_get_type ()) +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) + +#define MODEL_TYPE_CLIP_FILE (model_clip_file_get_type ()) +#define MODEL_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFile)) +#define MODEL_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) +#define MODEL_IS_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE)) +#define MODEL_IS_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE)) +#define MODEL_CLIP_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) + +typedef struct _ModelClipFile ModelClipFile; +typedef struct _ModelClipFileClass ModelClipFileClass; + +#define MODEL_TYPE_TEMPO_INFORMATION (model_tempo_information_get_type ()) +#define MODEL_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformation)) +#define MODEL_IS_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TEMPO_INFORMATION)) +#define MODEL_TEMPO_INFORMATION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformationIface)) + +typedef struct _ModelTempoInformation ModelTempoInformation; +typedef struct _ModelTempoInformationIface ModelTempoInformationIface; + +#define TYPE_FRACTION (fraction_get_type ()) +typedef struct _Fraction Fraction; +#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL))) +#define _gtk_tree_path_free0(var) ((var == NULL) ? NULL : (var = (gtk_tree_path_free (var), NULL))) + +#define LOGGING_TYPE_FACILITY (logging_facility_get_type ()) + +#define LOGGING_TYPE_LEVEL (logging_level_get_type ()) + +#define MODEL_TYPE_TRACK (model_track_get_type ()) +#define MODEL_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TRACK, ModelTrack)) +#define MODEL_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TRACK, ModelTrackClass)) +#define MODEL_IS_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TRACK)) +#define MODEL_IS_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TRACK)) +#define MODEL_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TRACK, ModelTrackClass)) + +typedef struct _ModelTrack ModelTrack; +typedef struct _ModelTrackClass ModelTrackClass; +#define _g_free0(var) (var = (g_free (var), NULL)) +typedef struct _ModelProjectPrivate ModelProjectPrivate; + +#define TYPE_TIME_CODE (time_code_get_type ()) +typedef struct _TimeCode TimeCode; + +#define VIEW_TYPE_MEDIA_ENGINE (view_media_engine_get_type ()) +#define VIEW_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngine)) +#define VIEW_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass)) +#define VIEW_IS_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_ENGINE)) +#define VIEW_IS_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_ENGINE)) +#define VIEW_MEDIA_ENGINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass)) + +typedef struct _ViewMediaEngine ViewMediaEngine; +typedef struct _ViewMediaEngineClass ViewMediaEngineClass; + +#define MODEL_TYPE_PROJECT_LOADER (model_project_loader_get_type ()) +#define MODEL_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoader)) +#define MODEL_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass)) +#define MODEL_IS_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT_LOADER)) +#define MODEL_IS_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT_LOADER)) +#define MODEL_PROJECT_LOADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass)) + +typedef struct _ModelProjectLoader ModelProjectLoader; +typedef struct _ModelProjectLoaderClass ModelProjectLoaderClass; + +#define MODEL_TYPE_UNDO_MANAGER (model_undo_manager_get_type ()) +#define MODEL_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManager)) +#define MODEL_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass)) +#define MODEL_IS_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_UNDO_MANAGER)) +#define MODEL_IS_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_UNDO_MANAGER)) +#define MODEL_UNDO_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass)) + +typedef struct _ModelUndoManager ModelUndoManager; +typedef struct _ModelUndoManagerClass ModelUndoManagerClass; + +#define MODEL_TYPE_LIBRARY_IMPORTER (model_library_importer_get_type ()) +#define MODEL_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporter)) +#define MODEL_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass)) +#define MODEL_IS_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_LIBRARY_IMPORTER)) +#define MODEL_IS_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_LIBRARY_IMPORTER)) +#define MODEL_LIBRARY_IMPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass)) + +typedef struct _ModelLibraryImporter ModelLibraryImporter; +typedef struct _ModelLibraryImporterClass ModelLibraryImporterClass; +#define __g_list_free_gtk_tree_path_free0(var) ((var == NULL) ? NULL : (var = (_g_list_free_gtk_tree_path_free (var), NULL))) +typedef struct _ModelClipFilePrivate ModelClipFilePrivate; + +#define MODEL_TYPE_MEDIA_TYPE (model_media_type_get_type ()) + +struct _ClipLibraryView { + GtkEventBox parent_instance; + ClipLibraryViewPrivate * priv; +}; + +struct _ClipLibraryViewClass { + GtkEventBoxClass parent_class; +}; + +typedef enum { + CLIP_LIBRARY_VIEW_SORT_MODE_NONE, + CLIP_LIBRARY_VIEW_SORT_MODE_ABC +} ClipLibraryViewSortMode; + +struct _ModelTimeSystemIface { + GTypeInterface parent_iface; + void (*calculate_pixel_step) (ModelTimeSystem* self, float inc, float pixel_min, float pixel_div); + gint64 (*xpos_to_time) (ModelTimeSystem* self, gint x); + gint64 (*xsize_to_time) (ModelTimeSystem* self, gint x); + gint (*time_to_xpos) (ModelTimeSystem* self, gint64 time); + gint64 (*get_pixel_snap_time) (ModelTimeSystem* self); + gint (*time_to_xsize) (ModelTimeSystem* self, gint64 time); + float (*get_pixel_percentage) (ModelTimeSystem* self); + gint (*get_start_token) (ModelTimeSystem* self, gint xsize); + gint (*get_next_position) (ModelTimeSystem* self, gint token); + gint (*get_pixel_height) (ModelTimeSystem* self, gint token); + char* (*get_display_string) (ModelTimeSystem* self, gint token); + gint (*frame_to_xsize) (ModelTimeSystem* self, gint frame); + gint (*xsize_to_frame) (ModelTimeSystem* self, gint xsize); + char* (*get_time_string) (ModelTimeSystem* self, gint64 time); + char* (*get_time_duration) (ModelTimeSystem* self, gint64 time); +}; + +struct _ClipLibraryViewPrivate { + ModelProject* project; + GtkTreeView* tree_view; + GtkTreeSelection* selection; + GtkLabel* label; + GtkListStore* list_store; + gint num_clipfiles; + GeeArrayList* files_dragging; + GtkIconTheme* icon_theme; + GdkPixbuf* default_audio_icon; + GdkPixbuf* default_video_icon; + GdkPixbuf* default_error_icon; + ClipLibraryViewSortMode sort_mode; + ModelTimeSystem* time_provider; +}; + +typedef enum { + CLIP_LIBRARY_VIEW_COLUMN_TYPE_THUMBNAIL, + CLIP_LIBRARY_VIEW_COLUMN_TYPE_NAME, + CLIP_LIBRARY_VIEW_COLUMN_TYPE_DURATION, + CLIP_LIBRARY_VIEW_COLUMN_TYPE_FILENAME +} ClipLibraryViewColumnType; + +struct _Fraction { + gint numerator; + gint denominator; +}; + +struct _ModelTempoInformationIface { + GTypeInterface parent_iface; + void (*get_time_signature) (ModelTempoInformation* self, Fraction* result); + gint (*get_bpm) (ModelTempoInformation* self); +}; + +typedef enum { + LOGGING_FACILITY_SIGNAL_HANDLERS, + LOGGING_FACILITY_DEVELOPER_WARNINGS, + LOGGING_FACILITY_GRAPH, + LOGGING_FACILITY_LOADING, + LOGGING_FACILITY_IMPORT, + LOGGING_FACILITY_SINGLEDECODEBIN +} LoggingFacility; + +typedef enum { + LOGGING_LEVEL_CRITICAL, + LOGGING_LEVEL_HIGH, + LOGGING_LEVEL_MEDIUM, + LOGGING_LEVEL_LOW, + LOGGING_LEVEL_INFO, + LOGGING_LEVEL_VERBOSE +} LoggingLevel; + +struct _TimeCode { + gint hour; + gint minute; + gint second; + gint frame; + gboolean drop_code; +}; + +struct _ModelProject { + GObject parent_instance; + ModelProjectPrivate * priv; + GeeArrayList* tracks; + GeeArrayList* inactive_tracks; + GeeArrayList* clipfiles; + ViewMediaEngine* media_engine; + char* project_file; + ModelProjectLoader* loader; + ModelUndoManager* undo_manager; + ModelLibraryImporter* importer; + Fraction default_framerate; + gboolean click_during_play; + gboolean click_during_record; + double click_volume; + gboolean library_visible; + gint library_width; + gboolean snap_to_clip; +}; + +struct _ModelProjectClass { + GObjectClass parent_class; + void (*get_clip_time) (ModelProject* self, ModelClipFile* f, TimeCode* result); + char* (*get_project_file) (ModelProject* self); + void (*do_append) (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, const char* name, gint64 insert_time); + void (*add_track) (ModelProject* self, ModelTrack* track); + void (*insert_track) (ModelProject* self, gint index, ModelTrack* track); + void (*load) (ModelProject* self, const char* fname); + void (*save) (ModelProject* self, const char* filename); + char* (*get_app_name) (ModelProject* self); + void (*load_complete) (ModelProject* self); +}; + +struct _ModelClipFile { + GObject parent_instance; + ModelClipFilePrivate * priv; + char* filename; + GstCaps* video_caps; + GstCaps* audio_caps; + GdkPixbuf* thumbnail; +}; + +struct _ModelClipFileClass { + GObjectClass parent_class; +}; + +typedef enum { + MODEL_MEDIA_TYPE_AUDIO, + MODEL_MEDIA_TYPE_VIDEO +} ModelMediaType; + + +extern GtkMenu* clip_library_view_context_menu; +GtkMenu* clip_library_view_context_menu = NULL; +static gpointer clip_library_view_parent_class = NULL; + +GType clip_library_view_get_type (void); +GType model_project_get_type (void); +static GType clip_library_view_sort_mode_get_type (void) G_GNUC_UNUSED; +GType model_time_system_get_type (void); +#define CLIP_LIBRARY_VIEW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_CLIP_LIBRARY_VIEW, ClipLibraryViewPrivate)) +enum { + CLIP_LIBRARY_VIEW_DUMMY_PROPERTY +}; +static GType clip_library_view_column_type_get_type (void) G_GNUC_UNUSED; +static GtkTreeViewColumn* clip_library_view_add_column (ClipLibraryView* self, ClipLibraryViewColumnType c); +static gint clip_library_view_name_sort (ClipLibraryView* self, GtkTreeModel* model, GtkTreeIter* a, GtkTreeIter* b); +static gint _clip_library_view_name_sort_gtk_tree_iter_compare_func (GtkTreeModel* model, GtkTreeIter* a, GtkTreeIter* b, gpointer self); +void parse_color (const char* color, GdkColor* result); +GType model_clip_file_get_type (void); +static void clip_library_view_on_clipfile_added (ClipLibraryView* self, ModelClipFile* f); +static void _clip_library_view_on_clipfile_added_model_project_clipfile_added (ModelProject* _sender, ModelClipFile* c, gpointer self); +void clip_library_view_on_clipfile_removed (ClipLibraryView* self, ModelClipFile* f); +static void _clip_library_view_on_clipfile_removed_model_project_clipfile_removed (ModelProject* _sender, ModelClipFile* clip_file, gpointer self); +static void clip_library_view_on_remove_all_rows (ClipLibraryView* self); +static void _clip_library_view_on_remove_all_rows_model_project_cleared (ModelProject* _sender, gpointer self); +GType fraction_get_type (void); +Fraction* fraction_dup (const Fraction* self); +void fraction_free (Fraction* self); +GType model_tempo_information_get_type (void); +static void clip_library_view_on_time_signature_changed (ClipLibraryView* self, Fraction* time_signature); +static void _clip_library_view_on_time_signature_changed_model_tempo_information_time_signature_changed (ModelTempoInformation* _sender, Fraction* time_signature, gpointer self); +static void clip_library_view_on_drag_begin (ClipLibraryView* self, GdkDragContext* c); +static void _clip_library_view_on_drag_begin_gtk_widget_drag_begin (GtkWidget* _sender, GdkDragContext* context, gpointer self); +static void clip_library_view_on_drag_data_get (ClipLibraryView* self, GdkDragContext* context, GtkSelectionData* data, guint info, guint time); +static void _clip_library_view_on_drag_data_get_gtk_widget_drag_data_get (GtkWidget* _sender, GdkDragContext* context, GtkSelectionData* selection_data, guint info, guint time_, gpointer self); +static void clip_library_view_on_cursor_changed (ClipLibraryView* self); +static void _clip_library_view_on_cursor_changed_gtk_tree_view_cursor_changed (GtkTreeView* _sender, gpointer self); +static gboolean clip_library_view_on_button_pressed (ClipLibraryView* self, GdkEventButton* b); +static gboolean _clip_library_view_on_button_pressed_gtk_widget_button_press_event (GtkWidget* _sender, GdkEventButton* event, gpointer self); +static gboolean clip_library_view_on_button_released (ClipLibraryView* self, GdkEventButton* b); +static gboolean _clip_library_view_on_button_released_gtk_widget_button_release_event (GtkWidget* _sender, GdkEventButton* event, gpointer self); +ClipLibraryView* clip_library_view_new (ModelProject* p, ModelTimeSystem* time_provider, const char* drag_message, GdkDragAction actions); +ClipLibraryView* clip_library_view_construct (GType object_type, ModelProject* p, ModelTimeSystem* time_provider, const char* drag_message, GdkDragAction actions); +static GtkTreePath* clip_library_view_find_first_selected (ClipLibraryView* self); +GType logging_facility_get_type (void); +GType logging_level_get_type (void); +void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message); +gboolean clip_library_view_has_selection (ClipLibraryView* self); +void clip_library_view_unselect_all (ClipLibraryView* self); +GType model_track_get_type (void); +void model_project_create_clip_importer (ModelProject* self, ModelTrack* track, gboolean timeline_add, gint64 time_to_add, gboolean both_tracks, GtkWindow* progress_window_parent, gint number); +GType time_code_get_type (void); +TimeCode* time_code_dup (const TimeCode* self); +void time_code_free (TimeCode* self); +GType view_media_engine_get_type (void); +GType model_project_loader_get_type (void); +gpointer model_undo_manager_ref (gpointer instance); +void model_undo_manager_unref (gpointer instance); +GParamSpec* model_param_spec_undo_manager (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_undo_manager (GValue* value, gpointer v_object); +void model_value_take_undo_manager (GValue* value, gpointer v_object); +gpointer model_value_get_undo_manager (const GValue* value); +GType model_undo_manager_get_type (void); +GType model_library_importer_get_type (void); +void model_library_importer_add_file (ModelLibraryImporter* self, const char* filename, GError** error); +void model_library_importer_start (ModelLibraryImporter* self, GError** error); +static void clip_library_view_real_drag_data_received (GtkWidget* base, GdkDragContext* context, gint x, gint y, GtkSelectionData* selection_data, guint drag_info, guint time); +static void _vala_array_add1 (char*** array, int* length, int* size, char* value); +static void _g_list_free_gtk_tree_path_free (GList* self); +static gint clip_library_view_get_selected_rows (ClipLibraryView* self, GList** paths); +gboolean model_clip_file_is_online (ModelClipFile* self); +GType model_media_type_get_type (void); +gboolean model_clip_file_is_of_type (ModelClipFile* self, ModelMediaType t); +char* isolate_filename (const char* path); +char* model_time_system_get_time_duration (ModelTimeSystem* self, gint64 time); +gint64 model_clip_file_get_length (ModelClipFile* self); +static void clip_library_view_update_iter (ClipLibraryView* self, GtkTreeIter* it, ModelClipFile* clip_file); +static gint clip_library_view_find_clipfile (ClipLibraryView* self, ModelClipFile* f, GtkTreeIter* iter); +static gboolean clip_library_view_remove_row (ClipLibraryView* self, GtkTreeIter* it); +ModelClipFile* model_project_find_clipfile (ModelProject* self, const char* filename); +gboolean model_project_clipfile_on_track (ModelProject* self, const char* filename); +GtkResponseType dialog_utils_delete_cancel (const char* message); +void model_project_remove_clipfile (ModelProject* self, const char* filename); +char* model_project_get_audio_path (ModelProject* self); +GtkResponseType dialog_utils_delete_keep (const char* message); +void model_undo_manager_reset (ModelUndoManager* self); +static void clip_library_view_delete_row (ClipLibraryView* self, GtkTreeModel* model, GtkTreePath* path); +GeeArrayList* clip_library_view_get_selected_files (ClipLibraryView* self); +void model_undo_manager_start_transaction (ModelUndoManager* self, const char* description); +void model_undo_manager_end_transaction (ModelUndoManager* self, const char* description); +void clip_library_view_delete_selection (ClipLibraryView* self); +void clip_library_view_select_all (ClipLibraryView* self); +gint stricmp (const char* str1, const char* str2); +static void clip_library_view_finalize (GObject* obj); +static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func); +static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func); +static gint _vala_array_length (gpointer array); +static int _vala_strcmp0 (const char * str1, const char * str2); + +extern const GtkTargetEntry drag_target_entries[1]; + + +static GType clip_library_view_sort_mode_get_type (void) { + static volatile gsize clip_library_view_sort_mode_type_id__volatile = 0; + if (g_once_init_enter (&clip_library_view_sort_mode_type_id__volatile)) { + static const GEnumValue values[] = {{CLIP_LIBRARY_VIEW_SORT_MODE_NONE, "CLIP_LIBRARY_VIEW_SORT_MODE_NONE", "none"}, {CLIP_LIBRARY_VIEW_SORT_MODE_ABC, "CLIP_LIBRARY_VIEW_SORT_MODE_ABC", "abc"}, {0, NULL, NULL}}; + GType clip_library_view_sort_mode_type_id; + clip_library_view_sort_mode_type_id = g_enum_register_static ("ClipLibraryViewSortMode", values); + g_once_init_leave (&clip_library_view_sort_mode_type_id__volatile, clip_library_view_sort_mode_type_id); + } + return clip_library_view_sort_mode_type_id__volatile; +} + + +static GType clip_library_view_column_type_get_type (void) { + static volatile gsize clip_library_view_column_type_type_id__volatile = 0; + if (g_once_init_enter (&clip_library_view_column_type_type_id__volatile)) { + static const GEnumValue values[] = {{CLIP_LIBRARY_VIEW_COLUMN_TYPE_THUMBNAIL, "CLIP_LIBRARY_VIEW_COLUMN_TYPE_THUMBNAIL", "thumbnail"}, {CLIP_LIBRARY_VIEW_COLUMN_TYPE_NAME, "CLIP_LIBRARY_VIEW_COLUMN_TYPE_NAME", "name"}, {CLIP_LIBRARY_VIEW_COLUMN_TYPE_DURATION, "CLIP_LIBRARY_VIEW_COLUMN_TYPE_DURATION", "duration"}, {CLIP_LIBRARY_VIEW_COLUMN_TYPE_FILENAME, "CLIP_LIBRARY_VIEW_COLUMN_TYPE_FILENAME", "filename"}, {0, NULL, NULL}}; + GType clip_library_view_column_type_type_id; + clip_library_view_column_type_type_id = g_enum_register_static ("ClipLibraryViewColumnType", values); + g_once_init_leave (&clip_library_view_column_type_type_id__volatile, clip_library_view_column_type_type_id); + } + return clip_library_view_column_type_type_id__volatile; +} + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 480 "ClipLibraryView.vala" +static gint _clip_library_view_name_sort_gtk_tree_iter_compare_func (GtkTreeModel* model, GtkTreeIter* a, GtkTreeIter* b, gpointer self) { +#line 422 "ClipLibraryView.c" + gint result; + result = clip_library_view_name_sort (self, model, a, b); + return result; +} + + +#line 332 "ClipLibraryView.vala" +static void _clip_library_view_on_clipfile_added_model_project_clipfile_added (ModelProject* _sender, ModelClipFile* c, gpointer self) { +#line 431 "ClipLibraryView.c" + clip_library_view_on_clipfile_added (self, c); +} + + +#line 372 "ClipLibraryView.vala" +static void _clip_library_view_on_clipfile_removed_model_project_clipfile_removed (ModelProject* _sender, ModelClipFile* clip_file, gpointer self) { +#line 438 "ClipLibraryView.c" + clip_library_view_on_clipfile_removed (self, clip_file); +} + + +#line 394 "ClipLibraryView.vala" +static void _clip_library_view_on_remove_all_rows_model_project_cleared (ModelProject* _sender, gpointer self) { +#line 445 "ClipLibraryView.c" + clip_library_view_on_remove_all_rows (self); +} + + +#line 406 "ClipLibraryView.vala" +static void _clip_library_view_on_time_signature_changed_model_tempo_information_time_signature_changed (ModelTempoInformation* _sender, Fraction* time_signature, gpointer self) { +#line 452 "ClipLibraryView.c" + clip_library_view_on_time_signature_changed (self, time_signature); +} + + +#line 264 "ClipLibraryView.vala" +static void _clip_library_view_on_drag_begin_gtk_widget_drag_begin (GtkWidget* _sender, GdkDragContext* context, gpointer self) { +#line 459 "ClipLibraryView.c" + clip_library_view_on_drag_begin (self, context); +} + + +#line 239 "ClipLibraryView.vala" +static void _clip_library_view_on_drag_data_get_gtk_widget_drag_data_get (GtkWidget* _sender, GdkDragContext* context, GtkSelectionData* selection_data, guint info, guint time_, gpointer self) { +#line 466 "ClipLibraryView.c" + clip_library_view_on_drag_data_get (self, context, selection_data, info, time_); +} + + +#line 205 "ClipLibraryView.vala" +static void _clip_library_view_on_cursor_changed_gtk_tree_view_cursor_changed (GtkTreeView* _sender, gpointer self) { +#line 473 "ClipLibraryView.c" + clip_library_view_on_cursor_changed (self); +} + + +#line 124 "ClipLibraryView.vala" +static gboolean _clip_library_view_on_button_pressed_gtk_widget_button_press_event (GtkWidget* _sender, GdkEventButton* event, gpointer self) { +#line 480 "ClipLibraryView.c" + gboolean result; + result = clip_library_view_on_button_pressed (self, event); + return result; +} + + +#line 166 "ClipLibraryView.vala" +static gboolean _clip_library_view_on_button_released_gtk_widget_button_release_event (GtkWidget* _sender, GdkEventButton* event, gpointer self) { +#line 489 "ClipLibraryView.c" + gboolean result; + result = clip_library_view_on_button_released (self, event); + return result; +} + + +#line 42 "ClipLibraryView.vala" +ClipLibraryView* clip_library_view_construct (GType object_type, ModelProject* p, ModelTimeSystem* time_provider, const char* drag_message, GdkDragAction actions) { +#line 498 "ClipLibraryView.c" + GError * _inner_error_; + ClipLibraryView * self; + ModelProject* _tmp0_; + ModelTimeSystem* _tmp1_; + GtkIconTheme* _tmp2_; + GtkListStore* _tmp3_; + GtkTreeView* _tmp4_; + GtkTreeViewColumn* _tmp5_; + GtkTreeViewColumn* name_column; + GtkTreeViewColumn* _tmp6_; + GdkColor _tmp11_; + GdkColor _tmp10_ = {0}; + GdkColor _tmp13_; + GdkColor _tmp12_ = {0}; + GtkTreeSelection* _tmp14_; +#line 42 "ClipLibraryView.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (p), NULL); +#line 42 "ClipLibraryView.vala" + g_return_val_if_fail (MODEL_IS_TIME_SYSTEM (time_provider), NULL); +#line 518 "ClipLibraryView.c" + _inner_error_ = NULL; + self = g_object_newv (object_type, 0, NULL); +#line 44 "ClipLibraryView.vala" + gtk_drag_dest_set (GTK_WIDGET (self), GTK_DEST_DEFAULT_ALL, drag_target_entries, G_N_ELEMENTS (drag_target_entries), GDK_ACTION_COPY); +#line 45 "ClipLibraryView.vala" + self->priv->project = (_tmp0_ = _g_object_ref0 (p), _g_object_unref0 (self->priv->project), _tmp0_); +#line 46 "ClipLibraryView.vala" + self->priv->time_provider = (_tmp1_ = _g_object_ref0 (time_provider), _g_object_unref0 (self->priv->time_provider), _tmp1_); +#line 48 "ClipLibraryView.vala" + self->priv->icon_theme = (_tmp2_ = _g_object_ref0 (gtk_icon_theme_get_default ()), _g_object_unref0 (self->priv->icon_theme), _tmp2_); +#line 50 "ClipLibraryView.vala" + self->priv->list_store = (_tmp3_ = gtk_list_store_new (4, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, -1, NULL), _g_object_unref0 (self->priv->list_store), _tmp3_); +#line 53 "ClipLibraryView.vala" + self->priv->tree_view = (_tmp4_ = g_object_ref_sink ((GtkTreeView*) gtk_tree_view_new_with_model (GTK_TREE_MODEL (self->priv->list_store))), _g_object_unref0 (self->priv->tree_view), _tmp4_); +#line 55 "ClipLibraryView.vala" + _tmp5_ = clip_library_view_add_column (self, CLIP_LIBRARY_VIEW_COLUMN_TYPE_THUMBNAIL); +#line 535 "ClipLibraryView.c" + _g_object_unref0 (_tmp5_); +#line 56 "ClipLibraryView.vala" + name_column = clip_library_view_add_column (self, CLIP_LIBRARY_VIEW_COLUMN_TYPE_NAME); +#line 57 "ClipLibraryView.vala" + _tmp6_ = clip_library_view_add_column (self, CLIP_LIBRARY_VIEW_COLUMN_TYPE_DURATION); +#line 541 "ClipLibraryView.c" + _g_object_unref0 (_tmp6_); +#line 58 "ClipLibraryView.vala" + gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (self->priv->list_store), _clip_library_view_name_sort_gtk_tree_iter_compare_func, g_object_ref (self), g_object_unref); +#line 59 "ClipLibraryView.vala" + gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (self->priv->list_store), gtk_tree_view_column_get_sort_column_id (name_column), GTK_SORT_ASCENDING); +#line 61 "ClipLibraryView.vala" + self->priv->num_clipfiles = 0; +#line 62 "ClipLibraryView.vala" + if (drag_message != NULL) { +#line 551 "ClipLibraryView.c" + GtkLabel* _tmp7_; + GdkColor _tmp9_; + GdkColor _tmp8_ = {0}; +#line 63 "ClipLibraryView.vala" + self->priv->label = (_tmp7_ = g_object_ref_sink ((GtkLabel*) gtk_label_new (drag_message)), _g_object_unref0 (self->priv->label), _tmp7_); +#line 64 "ClipLibraryView.vala" + gtk_widget_modify_fg (GTK_WIDGET (self->priv->label), GTK_STATE_NORMAL, (_tmp9_ = (parse_color ("#fff", &_tmp8_), _tmp8_), &_tmp9_)); +#line 559 "ClipLibraryView.c" + } +#line 67 "ClipLibraryView.vala" + gtk_widget_modify_bg (GTK_WIDGET (self), GTK_STATE_NORMAL, (_tmp11_ = (parse_color ("#444", &_tmp10_), _tmp10_), &_tmp11_)); +#line 68 "ClipLibraryView.vala" + gtk_widget_modify_base (GTK_WIDGET (self->priv->tree_view), GTK_STATE_NORMAL, (_tmp13_ = (parse_color ("#444", &_tmp12_), _tmp12_), &_tmp13_)); +#line 70 "ClipLibraryView.vala" + gtk_tree_view_set_headers_visible (self->priv->tree_view, FALSE); +#line 71 "ClipLibraryView.vala" + g_signal_connect_object (self->priv->project, "clipfile-added", (GCallback) _clip_library_view_on_clipfile_added_model_project_clipfile_added, self, 0); +#line 72 "ClipLibraryView.vala" + g_signal_connect_object (self->priv->project, "clipfile-removed", (GCallback) _clip_library_view_on_clipfile_removed_model_project_clipfile_removed, self, 0); +#line 73 "ClipLibraryView.vala" + g_signal_connect_object (self->priv->project, "cleared", (GCallback) _clip_library_view_on_remove_all_rows_model_project_cleared, self, 0); +#line 74 "ClipLibraryView.vala" + g_signal_connect_object (MODEL_TEMPO_INFORMATION (self->priv->project), "time-signature-changed", (GCallback) _clip_library_view_on_time_signature_changed_model_tempo_information_time_signature_changed, self, 0); +#line 76 "ClipLibraryView.vala" + gtk_drag_source_set (GTK_WIDGET (self->priv->tree_view), GDK_BUTTON1_MASK, drag_target_entries, G_N_ELEMENTS (drag_target_entries), actions); +#line 77 "ClipLibraryView.vala" + g_signal_connect_object (GTK_WIDGET (self->priv->tree_view), "drag-begin", (GCallback) _clip_library_view_on_drag_begin_gtk_widget_drag_begin, self, 0); +#line 78 "ClipLibraryView.vala" + g_signal_connect_object (GTK_WIDGET (self->priv->tree_view), "drag-data-get", (GCallback) _clip_library_view_on_drag_data_get_gtk_widget_drag_data_get, self, 0); +#line 79 "ClipLibraryView.vala" + g_signal_connect_object (self->priv->tree_view, "cursor-changed", (GCallback) _clip_library_view_on_cursor_changed_gtk_tree_view_cursor_changed, self, 0); +#line 81 "ClipLibraryView.vala" + self->priv->selection = (_tmp14_ = _g_object_ref0 (gtk_tree_view_get_selection (self->priv->tree_view)), _g_object_unref0 (self->priv->selection), _tmp14_); +#line 82 "ClipLibraryView.vala" + gtk_tree_selection_set_mode (self->priv->selection, GTK_SELECTION_MULTIPLE); +#line 83 "ClipLibraryView.vala" + if (self->priv->label != NULL) { +#line 84 "ClipLibraryView.vala" + gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (self->priv->label)); +#line 591 "ClipLibraryView.c" + } +#line 92 "ClipLibraryView.vala" + g_signal_connect_object (GTK_WIDGET (self->priv->tree_view), "button-press-event", (GCallback) _clip_library_view_on_button_pressed_gtk_widget_button_press_event, self, 0); +#line 93 "ClipLibraryView.vala" + g_signal_connect_object (GTK_WIDGET (self->priv->tree_view), "button-release-event", (GCallback) _clip_library_view_on_button_released_gtk_widget_button_release_event, self, 0); +#line 597 "ClipLibraryView.c" + { + GdkPixbuf* _tmp15_; + GdkPixbuf* _tmp16_; + GdkPixbuf* _tmp17_; + GdkPixbuf* _tmp18_; + GdkPixbuf* _tmp19_; + GdkPixbuf* _tmp20_; +#line 97 "ClipLibraryView.vala" + _tmp15_ = gtk_icon_theme_load_icon (self->priv->icon_theme, "audio-x-generic", 32, (GtkIconLookupFlags) 0, &_inner_error_); +#line 607 "ClipLibraryView.c" + if (_inner_error_ != NULL) { + goto __catch0_g_error; + } +#line 96 "ClipLibraryView.vala" + self->priv->default_audio_icon = (_tmp16_ = _g_object_ref0 (_tmp15_), _g_object_unref0 (self->priv->default_audio_icon), _tmp16_); +#line 99 "ClipLibraryView.vala" + _tmp17_ = gtk_icon_theme_load_icon (self->priv->icon_theme, "video-x-generic", 32, (GtkIconLookupFlags) 0, &_inner_error_); +#line 615 "ClipLibraryView.c" + if (_inner_error_ != NULL) { + goto __catch0_g_error; + } +#line 98 "ClipLibraryView.vala" + self->priv->default_video_icon = (_tmp18_ = _g_object_ref0 (_tmp17_), _g_object_unref0 (self->priv->default_video_icon), _tmp18_); +#line 101 "ClipLibraryView.vala" + _tmp19_ = gtk_icon_theme_load_icon (self->priv->icon_theme, "error", 32, (GtkIconLookupFlags) 0, &_inner_error_); +#line 623 "ClipLibraryView.c" + if (_inner_error_ != NULL) { + goto __catch0_g_error; + } +#line 100 "ClipLibraryView.vala" + self->priv->default_error_icon = (_tmp20_ = _g_object_ref0 (_tmp19_), _g_object_unref0 (self->priv->default_error_icon), _tmp20_); +#line 629 "ClipLibraryView.c" + } + goto __finally0; + __catch0_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { + _g_error_free0 (e); + } + } + __finally0: + if (_inner_error_ != NULL) { + _g_object_unref0 (name_column); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return NULL; + } +#line 106 "ClipLibraryView.vala" + self->priv->sort_mode = CLIP_LIBRARY_VIEW_SORT_MODE_ABC; +#line 650 "ClipLibraryView.c" + _g_object_unref0 (name_column); + return self; +} + + +#line 42 "ClipLibraryView.vala" +ClipLibraryView* clip_library_view_new (ModelProject* p, ModelTimeSystem* time_provider, const char* drag_message, GdkDragAction actions) { +#line 42 "ClipLibraryView.vala" + return clip_library_view_construct (TYPE_CLIP_LIBRARY_VIEW, p, time_provider, drag_message, actions); +#line 660 "ClipLibraryView.c" +} + + +#line 109 "ClipLibraryView.vala" +static GtkTreePath* clip_library_view_find_first_selected (ClipLibraryView* self) { +#line 666 "ClipLibraryView.c" + GtkTreePath* result = NULL; + GtkTreeIter it = {0}; + GtkTreeModel* model; + gboolean b; +#line 109 "ClipLibraryView.vala" + g_return_val_if_fail (IS_CLIP_LIBRARY_VIEW (self), NULL); +#line 111 "ClipLibraryView.vala" + model = _g_object_ref0 (gtk_tree_view_get_model (self->priv->tree_view)); +#line 113 "ClipLibraryView.vala" + b = gtk_tree_model_get_iter_first (model, &it); +#line 114 "ClipLibraryView.vala" + while (TRUE) { +#line 679 "ClipLibraryView.c" + GtkTreePath* path; +#line 114 "ClipLibraryView.vala" + if (!b) { +#line 114 "ClipLibraryView.vala" + break; +#line 685 "ClipLibraryView.c" + } +#line 115 "ClipLibraryView.vala" + path = gtk_tree_model_get_path (model, &it); +#line 116 "ClipLibraryView.vala" + if (gtk_tree_selection_path_is_selected (self->priv->selection, path)) { +#line 691 "ClipLibraryView.c" + result = path; + _g_object_unref0 (model); +#line 117 "ClipLibraryView.vala" + return result; +#line 696 "ClipLibraryView.c" + } +#line 119 "ClipLibraryView.vala" + b = gtk_tree_model_iter_next (model, &it); +#line 700 "ClipLibraryView.c" + _gtk_tree_path_free0 (path); + } + result = NULL; + _g_object_unref0 (model); +#line 121 "ClipLibraryView.vala" + return result; +#line 707 "ClipLibraryView.c" +} + + +#line 124 "ClipLibraryView.vala" +static gboolean clip_library_view_on_button_pressed (ClipLibraryView* self, GdkEventButton* b) { +#line 713 "ClipLibraryView.c" + gboolean result = FALSE; + GtkTreePath* path; + gint cell_x = 0; + gint cell_y = 0; + GtkTreePath* _tmp1_; + GtkTreePath* _tmp0_ = NULL; + gboolean shift_pressed; + gboolean control_pressed; + gboolean _tmp2_ = FALSE; +#line 124 "ClipLibraryView.vala" + g_return_val_if_fail (IS_CLIP_LIBRARY_VIEW (self), FALSE); +#line 125 "ClipLibraryView.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_button_pressed"); +#line 727 "ClipLibraryView.c" + path = NULL; +#line 131 "ClipLibraryView.vala" + gtk_tree_view_get_path_at_pos (self->priv->tree_view, (gint) (*b).x, (gint) (*b).y, &_tmp0_, NULL, &cell_x, &cell_y); +#line 131 "ClipLibraryView.vala" + path = (_tmp1_ = _tmp0_, _gtk_tree_path_free0 (path), _tmp1_); +#line 133 "ClipLibraryView.vala" + if (path == NULL) { +#line 134 "ClipLibraryView.vala" + gtk_tree_selection_unselect_all (self->priv->selection); +#line 737 "ClipLibraryView.c" + result = TRUE; + _gtk_tree_path_free0 (path); +#line 135 "ClipLibraryView.vala" + return result; +#line 742 "ClipLibraryView.c" + } +#line 138 "ClipLibraryView.vala" + shift_pressed = ((*b).state & GDK_SHIFT_MASK) != 0; +#line 139 "ClipLibraryView.vala" + control_pressed = ((*b).state & GDK_CONTROL_MASK) != 0; +#line 141 "ClipLibraryView.vala" + if (!control_pressed) { +#line 142 "ClipLibraryView.vala" + _tmp2_ = !shift_pressed; +#line 752 "ClipLibraryView.c" + } else { +#line 141 "ClipLibraryView.vala" + _tmp2_ = FALSE; +#line 756 "ClipLibraryView.c" + } +#line 141 "ClipLibraryView.vala" + if (_tmp2_) { +#line 143 "ClipLibraryView.vala" + if (!gtk_tree_selection_path_is_selected (self->priv->selection, path)) { +#line 144 "ClipLibraryView.vala" + gtk_tree_selection_unselect_all (self->priv->selection); +#line 764 "ClipLibraryView.c" + } + } else { +#line 146 "ClipLibraryView.vala" + if (shift_pressed) { +#line 769 "ClipLibraryView.c" + GtkTreePath* first; +#line 147 "ClipLibraryView.vala" + first = clip_library_view_find_first_selected (self); +#line 149 "ClipLibraryView.vala" + if (first != NULL) { +#line 150 "ClipLibraryView.vala" + gtk_tree_selection_select_range (self->priv->selection, first, path); +#line 777 "ClipLibraryView.c" + } + _gtk_tree_path_free0 (first); + } + } +#line 153 "ClipLibraryView.vala" + gtk_tree_selection_select_path (self->priv->selection, path); +#line 155 "ClipLibraryView.vala" + if ((*b).button == 3) { +#line 156 "ClipLibraryView.vala" + g_signal_emit_by_name (self, "selection-changed", TRUE); +#line 157 "ClipLibraryView.vala" + gtk_menu_shell_select_first (GTK_MENU_SHELL (clip_library_view_context_menu), TRUE); +#line 158 "ClipLibraryView.vala" + gtk_menu_popup (clip_library_view_context_menu, NULL, NULL, NULL, NULL, (guint) 0, (*b).time); +#line 792 "ClipLibraryView.c" + } else { +#line 160 "ClipLibraryView.vala" + gtk_menu_popdown (clip_library_view_context_menu); +#line 796 "ClipLibraryView.c" + } + result = TRUE; + _gtk_tree_path_free0 (path); +#line 163 "ClipLibraryView.vala" + return result; +#line 802 "ClipLibraryView.c" +} + + +#line 166 "ClipLibraryView.vala" +static gboolean clip_library_view_on_button_released (ClipLibraryView* self, GdkEventButton* b) { +#line 808 "ClipLibraryView.c" + gboolean result = FALSE; + GtkTreePath* path; + GtkTreeViewColumn* column; + gint cell_x = 0; + gint cell_y = 0; + GtkTreeViewColumn* _tmp3_; + GtkTreeViewColumn* _tmp2_ = NULL; + GtkTreePath* _tmp1_; + GtkTreePath* _tmp0_ = NULL; + gboolean _tmp4_ = FALSE; + gboolean shift_pressed; + gboolean control_pressed; + gboolean _tmp6_ = FALSE; +#line 166 "ClipLibraryView.vala" + g_return_val_if_fail (IS_CLIP_LIBRARY_VIEW (self), FALSE); +#line 167 "ClipLibraryView.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_button_released"); +#line 826 "ClipLibraryView.c" + path = NULL; + column = NULL; +#line 174 "ClipLibraryView.vala" + (gtk_tree_view_get_path_at_pos (self->priv->tree_view, (gint) (*b).x, (gint) (*b).y, &_tmp0_, &_tmp2_, &cell_x, &cell_y), path = (_tmp1_ = _tmp0_, _gtk_tree_path_free0 (path), _tmp1_)); +#line 174 "ClipLibraryView.vala" + column = (_tmp3_ = _g_object_ref0 (_tmp2_), _g_object_unref0 (column), _tmp3_); +#line 185 "ClipLibraryView.vala" + if (path == NULL) { +#line 185 "ClipLibraryView.vala" + _tmp4_ = TRUE; +#line 837 "ClipLibraryView.c" + } else { + gboolean _tmp5_ = FALSE; +#line 186 "ClipLibraryView.vala" + if (cell_x == 0) { +#line 186 "ClipLibraryView.vala" + _tmp5_ = cell_y == 0; +#line 844 "ClipLibraryView.c" + } else { +#line 186 "ClipLibraryView.vala" + _tmp5_ = FALSE; +#line 848 "ClipLibraryView.c" + } +#line 186 "ClipLibraryView.vala" + _tmp4_ = _tmp5_; +#line 852 "ClipLibraryView.c" + } +#line 185 "ClipLibraryView.vala" + if (_tmp4_) { +#line 187 "ClipLibraryView.vala" + g_signal_emit_by_name (self, "selection-changed", FALSE); +#line 858 "ClipLibraryView.c" + result = TRUE; + _gtk_tree_path_free0 (path); + _g_object_unref0 (column); +#line 188 "ClipLibraryView.vala" + return result; +#line 864 "ClipLibraryView.c" + } +#line 191 "ClipLibraryView.vala" + shift_pressed = ((*b).state & GDK_SHIFT_MASK) != 0; +#line 192 "ClipLibraryView.vala" + control_pressed = ((*b).state & GDK_CONTROL_MASK) != 0; +#line 194 "ClipLibraryView.vala" + if (!control_pressed) { +#line 195 "ClipLibraryView.vala" + _tmp6_ = !shift_pressed; +#line 874 "ClipLibraryView.c" + } else { +#line 194 "ClipLibraryView.vala" + _tmp6_ = FALSE; +#line 878 "ClipLibraryView.c" + } +#line 194 "ClipLibraryView.vala" + if (_tmp6_) { +#line 196 "ClipLibraryView.vala" + if (gtk_tree_selection_path_is_selected (self->priv->selection, path)) { +#line 197 "ClipLibraryView.vala" + gtk_tree_selection_unselect_all (self->priv->selection); +#line 886 "ClipLibraryView.c" + } + } +#line 199 "ClipLibraryView.vala" + gtk_tree_selection_select_path (self->priv->selection, path); +#line 200 "ClipLibraryView.vala" + g_signal_emit_by_name (self, "selection-changed", TRUE); +#line 893 "ClipLibraryView.c" + result = TRUE; + _gtk_tree_path_free0 (path); + _g_object_unref0 (column); +#line 202 "ClipLibraryView.vala" + return result; +#line 899 "ClipLibraryView.c" +} + + +#line 205 "ClipLibraryView.vala" +static void clip_library_view_on_cursor_changed (ClipLibraryView* self) { +#line 205 "ClipLibraryView.vala" + g_return_if_fail (IS_CLIP_LIBRARY_VIEW (self)); +#line 206 "ClipLibraryView.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_cursor_changed"); +#line 207 "ClipLibraryView.vala" + g_signal_emit_by_name (self, "selection-changed", clip_library_view_has_selection (self)); +#line 911 "ClipLibraryView.c" +} + + +#line 210 "ClipLibraryView.vala" +void clip_library_view_unselect_all (ClipLibraryView* self) { +#line 210 "ClipLibraryView.vala" + g_return_if_fail (IS_CLIP_LIBRARY_VIEW (self)); +#line 211 "ClipLibraryView.vala" + gtk_tree_selection_unselect_all (self->priv->selection); +#line 212 "ClipLibraryView.vala" + g_signal_emit_by_name (self, "selection-changed", FALSE); +#line 923 "ClipLibraryView.c" +} + + +#line 215 "ClipLibraryView.vala" +static void clip_library_view_real_drag_data_received (GtkWidget* base, GdkDragContext* context, gint x, gint y, GtkSelectionData* selection_data, guint drag_info, guint time) { +#line 929 "ClipLibraryView.c" + ClipLibraryView * self; + GError * _inner_error_; + char** _tmp1_; + gint _a_size_; + gint a_length1; + char** _tmp0_; + char** a; + self = CLIP_LIBRARY_VIEW (base); +#line 215 "ClipLibraryView.vala" + g_return_if_fail (GDK_IS_DRAG_CONTEXT (context)); +#line 215 "ClipLibraryView.vala" + g_return_if_fail (selection_data != NULL); +#line 942 "ClipLibraryView.c" + _inner_error_ = NULL; +#line 218 "ClipLibraryView.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_drag_data_received"); +#line 946 "ClipLibraryView.c" + a = (_tmp1_ = _tmp0_ = gtk_selection_data_get_uris (selection_data), a_length1 = _vala_array_length (_tmp0_), _a_size_ = a_length1, _tmp1_); +#line 220 "ClipLibraryView.vala" + gtk_drag_finish (context, TRUE, FALSE, (guint32) time); +#line 222 "ClipLibraryView.vala" + model_project_create_clip_importer (self->priv->project, NULL, FALSE, (gint64) 0, FALSE, GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (self))), a_length1); +#line 952 "ClipLibraryView.c" + { + { + char** s_collection; + int s_collection_length1; + int s_it; +#line 225 "ClipLibraryView.vala" + s_collection = a; +#line 960 "ClipLibraryView.c" + s_collection_length1 = a_length1; + for (s_it = 0; s_it < a_length1; s_it = s_it + 1) { + char* s; + s = g_strdup (s_collection[s_it]); + { + char* filename; + filename = NULL; + { + char* _tmp2_; + char* _tmp3_; +#line 228 "ClipLibraryView.vala" + _tmp2_ = g_filename_from_uri (s, NULL, &_inner_error_); +#line 973 "ClipLibraryView.c" + if (_inner_error_ != NULL) { + if (_inner_error_->domain == G_CONVERT_ERROR) { + goto __catch2_g_convert_error; + } + _g_free0 (s); + _g_free0 (filename); + a = (_vala_array_free (a, a_length1, (GDestroyNotify) g_free), NULL); + g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } +#line 228 "ClipLibraryView.vala" + filename = (_tmp3_ = _tmp2_, _g_free0 (filename), _tmp3_); +#line 987 "ClipLibraryView.c" + } + goto __finally2; + __catch2_g_convert_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { + _g_error_free0 (e); + _g_free0 (s); + _g_free0 (filename); +#line 229 "ClipLibraryView.vala" + continue; +#line 1001 "ClipLibraryView.c" + } + } + __finally2: + if (_inner_error_ != NULL) { + _g_free0 (s); + _g_free0 (filename); + goto __catch1_g_error; + } +#line 230 "ClipLibraryView.vala" + model_library_importer_add_file (self->priv->project->importer, filename, &_inner_error_); +#line 1012 "ClipLibraryView.c" + if (_inner_error_ != NULL) { + _g_free0 (s); + _g_free0 (filename); + goto __catch1_g_error; + } + _g_free0 (s); + _g_free0 (filename); + } + } + } +#line 232 "ClipLibraryView.vala" + model_library_importer_start (self->priv->project->importer, &_inner_error_); +#line 1025 "ClipLibraryView.c" + if (_inner_error_ != NULL) { + goto __catch1_g_error; + } + } + goto __finally1; + __catch1_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { +#line 234 "ClipLibraryView.vala" + g_signal_emit_by_name (self->priv->project, "error-occurred", "Error importing", e->message); +#line 1039 "ClipLibraryView.c" + _g_error_free0 (e); + } + } + __finally1: + if (_inner_error_ != NULL) { + a = (_vala_array_free (a, a_length1, (GDestroyNotify) g_free), NULL); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } + a = (_vala_array_free (a, a_length1, (GDestroyNotify) g_free), NULL); +} + + +static void _vala_array_add1 (char*** array, int* length, int* size, char* value) { + if ((*length) == (*size)) { + *size = (*size) ? (2 * (*size)) : 4; + *array = g_renew (char*, *array, (*size) + 1); + } + (*array)[(*length)++] = value; + (*array)[*length] = NULL; +} + + +#line 239 "ClipLibraryView.vala" +static void clip_library_view_on_drag_data_get (ClipLibraryView* self, GdkDragContext* context, GtkSelectionData* data, guint info, guint time) { +#line 1066 "ClipLibraryView.c" + GError * _inner_error_; + char* uri; + char** _tmp0_; + gint _uri_array_size_; + gint uri_array_length1; + char** uri_array; +#line 239 "ClipLibraryView.vala" + g_return_if_fail (IS_CLIP_LIBRARY_VIEW (self)); +#line 239 "ClipLibraryView.vala" + g_return_if_fail (GDK_IS_DRAG_CONTEXT (context)); +#line 239 "ClipLibraryView.vala" + g_return_if_fail (data != NULL); +#line 1079 "ClipLibraryView.c" + _inner_error_ = NULL; +#line 241 "ClipLibraryView.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_drag_data_get"); +#line 1083 "ClipLibraryView.c" + uri = NULL; + uri_array = (_tmp0_ = g_new0 (char*, 0 + 1), uri_array_length1 = 0, _uri_array_size_ = uri_array_length1, _tmp0_); + { + GeeIterator* _s_it; + _s_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->priv->files_dragging)); +#line 245 "ClipLibraryView.vala" + while (TRUE) { +#line 1091 "ClipLibraryView.c" + char* s; +#line 245 "ClipLibraryView.vala" + if (!gee_iterator_next (_s_it)) { +#line 245 "ClipLibraryView.vala" + break; +#line 1097 "ClipLibraryView.c" + } +#line 245 "ClipLibraryView.vala" + s = (char*) gee_iterator_get (_s_it); +#line 1101 "ClipLibraryView.c" + { + char* _tmp1_; + char* _tmp2_; +#line 247 "ClipLibraryView.vala" + _tmp1_ = g_filename_to_uri (s, NULL, &_inner_error_); +#line 1107 "ClipLibraryView.c" + if (_inner_error_ != NULL) { + if (_inner_error_->domain == G_CONVERT_ERROR) { + goto __catch3_g_convert_error; + } + _g_free0 (s); + _g_object_unref0 (_s_it); + _g_free0 (uri); + uri_array = (_vala_array_free (uri_array, uri_array_length1, (GDestroyNotify) g_free), NULL); + g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } +#line 247 "ClipLibraryView.vala" + uri = (_tmp2_ = _tmp1_, _g_free0 (uri), _tmp2_); +#line 1122 "ClipLibraryView.c" + } + goto __finally3; + __catch3_g_convert_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { + char* _tmp3_; +#line 249 "ClipLibraryView.vala" + uri = (_tmp3_ = g_strdup (s), _g_free0 (uri), _tmp3_); +#line 250 "ClipLibraryView.vala" + g_warning ("ClipLibraryView.vala:250: Cannot get URI for %s! (%s)\n", s, e->message); +#line 1136 "ClipLibraryView.c" + _g_error_free0 (e); + } + } + __finally3: + if (_inner_error_ != NULL) { + _g_free0 (s); + _g_object_unref0 (_s_it); + _g_free0 (uri); + uri_array = (_vala_array_free (uri_array, uri_array_length1, (GDestroyNotify) g_free), NULL); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } +#line 252 "ClipLibraryView.vala" + _vala_array_add1 (&uri_array, &uri_array_length1, &_uri_array_size_, g_strdup (uri)); +#line 1152 "ClipLibraryView.c" + _g_free0 (s); + } + _g_object_unref0 (_s_it); + } +#line 254 "ClipLibraryView.vala" + gtk_selection_data_set_uris (data, uri_array); +#line 256 "ClipLibraryView.vala" + gtk_drag_set_icon_default (context); +#line 1161 "ClipLibraryView.c" + _g_free0 (uri); + uri_array = (_vala_array_free (uri_array, uri_array_length1, (GDestroyNotify) g_free), NULL); +} + + +static void _g_list_free_gtk_tree_path_free (GList* self) { + g_list_foreach (self, (GFunc) gtk_tree_path_free, NULL); + g_list_free (self); +} + + +#line 259 "ClipLibraryView.vala" +static gint clip_library_view_get_selected_rows (ClipLibraryView* self, GList** paths) { +#line 1175 "ClipLibraryView.c" + gint result = 0; + GList* _tmp0_; +#line 259 "ClipLibraryView.vala" + g_return_val_if_fail (IS_CLIP_LIBRARY_VIEW (self), 0); +#line 1180 "ClipLibraryView.c" + if (paths != NULL) { + *paths = NULL; + } +#line 260 "ClipLibraryView.vala" + *paths = (_tmp0_ = gtk_tree_selection_get_selected_rows (self->priv->selection, NULL), __g_list_free_gtk_tree_path_free0 (*paths), _tmp0_); +#line 1186 "ClipLibraryView.c" + result = (gint) g_list_length (*paths); +#line 261 "ClipLibraryView.vala" + return result; +#line 1190 "ClipLibraryView.c" +} + + +static gpointer _gtk_tree_path_copy0 (gpointer self) { + return self ? gtk_tree_path_copy (self) : NULL; +} + + +#line 264 "ClipLibraryView.vala" +static void clip_library_view_on_drag_begin (ClipLibraryView* self, GdkDragContext* c) { +#line 1201 "ClipLibraryView.c" + GList* paths; + GList* _tmp2_; + gint _tmp1_; + GList* _tmp0_ = NULL; +#line 264 "ClipLibraryView.vala" + g_return_if_fail (IS_CLIP_LIBRARY_VIEW (self)); +#line 264 "ClipLibraryView.vala" + g_return_if_fail (GDK_IS_DRAG_CONTEXT (c)); +#line 265 "ClipLibraryView.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_drag_begin"); +#line 1212 "ClipLibraryView.c" + paths = NULL; +#line 267 "ClipLibraryView.vala" + if ((_tmp1_ = clip_library_view_get_selected_rows (self, &_tmp0_), paths = (_tmp2_ = _tmp0_, __g_list_free_gtk_tree_path_free0 (paths), _tmp2_), _tmp1_) > 0) { +#line 1216 "ClipLibraryView.c" + gboolean set_pixbuf; +#line 268 "ClipLibraryView.vala" + set_pixbuf = FALSE; +#line 269 "ClipLibraryView.vala" + gee_abstract_collection_clear (GEE_ABSTRACT_COLLECTION (self->priv->files_dragging)); +#line 1222 "ClipLibraryView.c" + { + GList* t_collection; + GList* t_it; +#line 270 "ClipLibraryView.vala" + t_collection = paths; +#line 1228 "ClipLibraryView.c" + for (t_it = t_collection; t_it != NULL; t_it = t_it->next) { + GtkTreePath* t; +#line 270 "ClipLibraryView.vala" + t = _gtk_tree_path_copy0 ((GtkTreePath*) t_it->data); +#line 1233 "ClipLibraryView.c" + { + GtkTreeIter iter = {0}; + char* filename; +#line 272 "ClipLibraryView.vala" + gtk_tree_model_get_iter (GTK_TREE_MODEL (self->priv->list_store), &iter, t); +#line 1239 "ClipLibraryView.c" + filename = NULL; +#line 275 "ClipLibraryView.vala" + gtk_tree_model_get (GTK_TREE_MODEL (self->priv->list_store), &iter, CLIP_LIBRARY_VIEW_COLUMN_TYPE_FILENAME, &filename, -1, -1); +#line 276 "ClipLibraryView.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->files_dragging), filename); +#line 278 "ClipLibraryView.vala" + if (!set_pixbuf) { +#line 1247 "ClipLibraryView.c" + GdkPixbuf* pixbuf; + pixbuf = NULL; +#line 280 "ClipLibraryView.vala" + gtk_tree_model_get (GTK_TREE_MODEL (self->priv->list_store), &iter, CLIP_LIBRARY_VIEW_COLUMN_TYPE_THUMBNAIL, &pixbuf, -1, -1); +#line 282 "ClipLibraryView.vala" + gtk_drag_set_icon_pixbuf (c, pixbuf, 0, 0); +#line 283 "ClipLibraryView.vala" + set_pixbuf = TRUE; +#line 1256 "ClipLibraryView.c" + _g_object_unref0 (pixbuf); + } + _gtk_tree_path_free0 (t); + _g_free0 (filename); + } + } + } + } + __g_list_free_gtk_tree_path_free0 (paths); +} + + +#line 289 "ClipLibraryView.vala" +static GtkTreeViewColumn* clip_library_view_add_column (ClipLibraryView* self, ClipLibraryViewColumnType c) { +#line 1271 "ClipLibraryView.c" + GtkTreeViewColumn* result = NULL; + GtkTreeViewColumn* column; + GtkCellRenderer* renderer; +#line 289 "ClipLibraryView.vala" + g_return_val_if_fail (IS_CLIP_LIBRARY_VIEW (self), NULL); +#line 290 "ClipLibraryView.vala" + column = g_object_ref_sink (gtk_tree_view_column_new ()); +#line 1279 "ClipLibraryView.c" + renderer = NULL; +#line 293 "ClipLibraryView.vala" + if (c == CLIP_LIBRARY_VIEW_COLUMN_TYPE_THUMBNAIL) { +#line 1283 "ClipLibraryView.c" + GtkCellRenderer* _tmp0_; +#line 294 "ClipLibraryView.vala" + renderer = (_tmp0_ = GTK_CELL_RENDERER (g_object_ref_sink ((GtkCellRendererPixbuf*) gtk_cell_renderer_pixbuf_new ())), _g_object_unref0 (renderer), _tmp0_); +#line 1287 "ClipLibraryView.c" + } else { + GtkCellRenderer* _tmp1_; + GdkColor _tmp2_ = {0}; + GdkColor color; +#line 296 "ClipLibraryView.vala" + renderer = (_tmp1_ = GTK_CELL_RENDERER (g_object_ref_sink ((GtkCellRendererText*) gtk_cell_renderer_text_new ())), _g_object_unref0 (renderer), _tmp1_); +#line 297 "ClipLibraryView.vala" + color = (parse_color ("#FFF", &_tmp2_), _tmp2_); +#line 298 "ClipLibraryView.vala" + g_object_set (G_OBJECT (renderer), "foreground-gdk", &color, NULL); +#line 1298 "ClipLibraryView.c" + } +#line 301 "ClipLibraryView.vala" + gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), renderer, TRUE); +#line 302 "ClipLibraryView.vala" + gtk_tree_view_column_set_resizable (column, TRUE); +#line 304 "ClipLibraryView.vala" + if (c == CLIP_LIBRARY_VIEW_COLUMN_TYPE_THUMBNAIL) { +#line 305 "ClipLibraryView.vala" + gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "pixbuf", gtk_tree_view_append_column (self->priv->tree_view, column) - 1); +#line 1308 "ClipLibraryView.c" + } else { +#line 307 "ClipLibraryView.vala" + gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "text", gtk_tree_view_append_column (self->priv->tree_view, column) - 1); +#line 1312 "ClipLibraryView.c" + } + result = column; + _g_object_unref0 (renderer); +#line 309 "ClipLibraryView.vala" + return result; +#line 1318 "ClipLibraryView.c" +} + + +#line 312 "ClipLibraryView.vala" +static void clip_library_view_update_iter (ClipLibraryView* self, GtkTreeIter* it, ModelClipFile* clip_file) { +#line 1324 "ClipLibraryView.c" + GdkPixbuf* icon; + char* _tmp5_; + char* _tmp4_; +#line 312 "ClipLibraryView.vala" + g_return_if_fail (IS_CLIP_LIBRARY_VIEW (self)); +#line 312 "ClipLibraryView.vala" + g_return_if_fail (MODEL_IS_CLIP_FILE (clip_file)); +#line 1332 "ClipLibraryView.c" + icon = NULL; +#line 315 "ClipLibraryView.vala" + if (model_clip_file_is_online (clip_file)) { +#line 316 "ClipLibraryView.vala" + if (clip_file->thumbnail == NULL) { +#line 1338 "ClipLibraryView.c" + GdkPixbuf* _tmp0_; + GdkPixbuf* _tmp1_; + _tmp0_ = NULL; +#line 317 "ClipLibraryView.vala" + if (model_clip_file_is_of_type (clip_file, MODEL_MEDIA_TYPE_VIDEO)) { +#line 318 "ClipLibraryView.vala" + _tmp0_ = self->priv->default_video_icon; +#line 1346 "ClipLibraryView.c" + } else { +#line 318 "ClipLibraryView.vala" + _tmp0_ = self->priv->default_audio_icon; +#line 1350 "ClipLibraryView.c" + } +#line 317 "ClipLibraryView.vala" + icon = (_tmp1_ = _g_object_ref0 (_tmp0_), _g_object_unref0 (icon), _tmp1_); +#line 1354 "ClipLibraryView.c" + } else { + GdkPixbuf* _tmp2_; +#line 320 "ClipLibraryView.vala" + icon = (_tmp2_ = _g_object_ref0 (clip_file->thumbnail), _g_object_unref0 (icon), _tmp2_); +#line 1359 "ClipLibraryView.c" + } + } else { + GdkPixbuf* _tmp3_; +#line 323 "ClipLibraryView.vala" + icon = (_tmp3_ = _g_object_ref0 (self->priv->default_error_icon), _g_object_unref0 (icon), _tmp3_); +#line 1365 "ClipLibraryView.c" + } +#line 326 "ClipLibraryView.vala" + gtk_list_store_set (self->priv->list_store, it, CLIP_LIBRARY_VIEW_COLUMN_TYPE_THUMBNAIL, icon, CLIP_LIBRARY_VIEW_COLUMN_TYPE_NAME, _tmp4_ = isolate_filename (clip_file->filename), CLIP_LIBRARY_VIEW_COLUMN_TYPE_DURATION, _tmp5_ = model_time_system_get_time_duration (self->priv->time_provider, model_clip_file_get_length (clip_file)), CLIP_LIBRARY_VIEW_COLUMN_TYPE_FILENAME, clip_file->filename, -1, -1); +#line 1369 "ClipLibraryView.c" + _g_free0 (_tmp5_); + _g_free0 (_tmp4_); + _g_object_unref0 (icon); +} + + +#line 332 "ClipLibraryView.vala" +static void clip_library_view_on_clipfile_added (ClipLibraryView* self, ModelClipFile* f) { +#line 1378 "ClipLibraryView.c" + GtkTreeIter it = {0}; +#line 332 "ClipLibraryView.vala" + g_return_if_fail (IS_CLIP_LIBRARY_VIEW (self)); +#line 332 "ClipLibraryView.vala" + g_return_if_fail (MODEL_IS_CLIP_FILE (f)); +#line 333 "ClipLibraryView.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_file_added"); +#line 336 "ClipLibraryView.vala" + if (clip_library_view_find_clipfile (self, f, &it) >= 0) { +#line 337 "ClipLibraryView.vala" + gtk_list_store_remove (self->priv->list_store, &it); +#line 1390 "ClipLibraryView.c" + } else { +#line 339 "ClipLibraryView.vala" + if (self->priv->num_clipfiles == 0) { +#line 340 "ClipLibraryView.vala" + if (self->priv->label != NULL) { +#line 341 "ClipLibraryView.vala" + gtk_container_remove (GTK_CONTAINER (self), GTK_WIDGET (self->priv->label)); +#line 1398 "ClipLibraryView.c" + } +#line 343 "ClipLibraryView.vala" + gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (self->priv->tree_view)); +#line 344 "ClipLibraryView.vala" + gtk_widget_show (GTK_WIDGET (self->priv->tree_view)); +#line 1404 "ClipLibraryView.c" + } +#line 346 "ClipLibraryView.vala" + self->priv->num_clipfiles++; +#line 1408 "ClipLibraryView.c" + } +#line 349 "ClipLibraryView.vala" + gtk_list_store_append (self->priv->list_store, &it); +#line 350 "ClipLibraryView.vala" + clip_library_view_update_iter (self, &it, f); +#line 1414 "ClipLibraryView.c" +} + + +#line 353 "ClipLibraryView.vala" +static gint clip_library_view_find_clipfile (ClipLibraryView* self, ModelClipFile* f, GtkTreeIter* iter) { +#line 1420 "ClipLibraryView.c" + gint result = 0; + GtkTreeModel* model; + gboolean b; + gint i; +#line 353 "ClipLibraryView.vala" + g_return_val_if_fail (IS_CLIP_LIBRARY_VIEW (self), 0); +#line 353 "ClipLibraryView.vala" + g_return_val_if_fail (MODEL_IS_CLIP_FILE (f), 0); +#line 354 "ClipLibraryView.vala" + model = _g_object_ref0 (gtk_tree_view_get_model (self->priv->tree_view)); +#line 356 "ClipLibraryView.vala" + b = gtk_tree_model_get_iter_first (model, iter); +#line 358 "ClipLibraryView.vala" + i = 0; +#line 359 "ClipLibraryView.vala" + while (TRUE) { +#line 1437 "ClipLibraryView.c" + char* filename; +#line 359 "ClipLibraryView.vala" + if (!b) { +#line 359 "ClipLibraryView.vala" + break; +#line 1443 "ClipLibraryView.c" + } + filename = NULL; +#line 361 "ClipLibraryView.vala" + gtk_tree_model_get (model, iter, CLIP_LIBRARY_VIEW_COLUMN_TYPE_FILENAME, &filename, -1); +#line 363 "ClipLibraryView.vala" + if (_vala_strcmp0 (filename, f->filename) == 0) { +#line 1450 "ClipLibraryView.c" + result = i; + _g_free0 (filename); + _g_object_unref0 (model); +#line 364 "ClipLibraryView.vala" + return result; +#line 1456 "ClipLibraryView.c" + } +#line 366 "ClipLibraryView.vala" + i++; +#line 367 "ClipLibraryView.vala" + b = gtk_tree_model_iter_next (model, iter); +#line 1462 "ClipLibraryView.c" + _g_free0 (filename); + } + result = -1; + _g_object_unref0 (model); +#line 369 "ClipLibraryView.vala" + return result; +#line 1469 "ClipLibraryView.c" +} + + +#line 372 "ClipLibraryView.vala" +void clip_library_view_on_clipfile_removed (ClipLibraryView* self, ModelClipFile* f) { +#line 1475 "ClipLibraryView.c" + GtkTreeIter it = {0}; +#line 372 "ClipLibraryView.vala" + g_return_if_fail (IS_CLIP_LIBRARY_VIEW (self)); +#line 372 "ClipLibraryView.vala" + g_return_if_fail (MODEL_IS_CLIP_FILE (f)); +#line 373 "ClipLibraryView.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_file_removed"); +#line 376 "ClipLibraryView.vala" + if (clip_library_view_find_clipfile (self, f, &it) >= 0) { +#line 377 "ClipLibraryView.vala" + clip_library_view_remove_row (self, &it); +#line 1487 "ClipLibraryView.c" + } +} + + +#line 381 "ClipLibraryView.vala" +static gboolean clip_library_view_remove_row (ClipLibraryView* self, GtkTreeIter* it) { +#line 1494 "ClipLibraryView.c" + gboolean result = FALSE; + gboolean b; +#line 381 "ClipLibraryView.vala" + g_return_val_if_fail (IS_CLIP_LIBRARY_VIEW (self), FALSE); +#line 382 "ClipLibraryView.vala" + b = gtk_list_store_remove (self->priv->list_store, it); +#line 383 "ClipLibraryView.vala" + self->priv->num_clipfiles--; +#line 384 "ClipLibraryView.vala" + if (self->priv->num_clipfiles == 0) { +#line 385 "ClipLibraryView.vala" + gtk_container_remove (GTK_CONTAINER (self), GTK_WIDGET (self->priv->tree_view)); +#line 386 "ClipLibraryView.vala" + if (self->priv->label != NULL) { +#line 387 "ClipLibraryView.vala" + gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (self->priv->label)); +#line 388 "ClipLibraryView.vala" + gtk_widget_show (GTK_WIDGET (self->priv->label)); +#line 1513 "ClipLibraryView.c" + } + } + result = b; +#line 391 "ClipLibraryView.vala" + return result; +#line 1519 "ClipLibraryView.c" +} + + +#line 394 "ClipLibraryView.vala" +static void clip_library_view_on_remove_all_rows (ClipLibraryView* self) { +#line 1525 "ClipLibraryView.c" + GtkTreeModel* model; + GtkTreeIter iter = {0}; + gboolean b; +#line 394 "ClipLibraryView.vala" + g_return_if_fail (IS_CLIP_LIBRARY_VIEW (self)); +#line 395 "ClipLibraryView.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_remove_all_rows"); +#line 396 "ClipLibraryView.vala" + model = _g_object_ref0 (gtk_tree_view_get_model (self->priv->tree_view)); +#line 399 "ClipLibraryView.vala" + b = gtk_tree_model_get_iter_first (model, &iter); +#line 401 "ClipLibraryView.vala" + while (TRUE) { +#line 401 "ClipLibraryView.vala" + if (!b) { +#line 401 "ClipLibraryView.vala" + break; +#line 1543 "ClipLibraryView.c" + } +#line 402 "ClipLibraryView.vala" + b = clip_library_view_remove_row (self, &iter); +#line 1547 "ClipLibraryView.c" + } + _g_object_unref0 (model); +} + + +#line 406 "ClipLibraryView.vala" +static void clip_library_view_on_time_signature_changed (ClipLibraryView* self, Fraction* time_signature) { +#line 1555 "ClipLibraryView.c" + GtkTreeIter iter = {0}; + gboolean more_items; +#line 406 "ClipLibraryView.vala" + g_return_if_fail (IS_CLIP_LIBRARY_VIEW (self)); +#line 407 "ClipLibraryView.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_time_signature_changed"); +#line 409 "ClipLibraryView.vala" + more_items = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (self->priv->list_store), &iter); +#line 410 "ClipLibraryView.vala" + while (TRUE) { +#line 1566 "ClipLibraryView.c" + char* filename; + ModelClipFile* clip_file; + char* _tmp0_; +#line 410 "ClipLibraryView.vala" + if (!more_items) { +#line 410 "ClipLibraryView.vala" + break; +#line 1574 "ClipLibraryView.c" + } + filename = NULL; +#line 412 "ClipLibraryView.vala" + gtk_tree_model_get (GTK_TREE_MODEL (self->priv->list_store), &iter, CLIP_LIBRARY_VIEW_COLUMN_TYPE_FILENAME, &filename, -1, -1); +#line 413 "ClipLibraryView.vala" + clip_file = model_project_find_clipfile (self->priv->project, filename); +#line 414 "ClipLibraryView.vala" + gtk_list_store_set (self->priv->list_store, &iter, CLIP_LIBRARY_VIEW_COLUMN_TYPE_DURATION, _tmp0_ = model_time_system_get_time_duration (self->priv->time_provider, model_clip_file_get_length (clip_file)), -1, -1); +#line 1583 "ClipLibraryView.c" + _g_free0 (_tmp0_); +#line 416 "ClipLibraryView.vala" + more_items = gtk_tree_model_iter_next (GTK_TREE_MODEL (self->priv->list_store), &iter); +#line 1587 "ClipLibraryView.c" + _g_free0 (filename); + _g_object_unref0 (clip_file); + } +} + + +#line 420 "ClipLibraryView.vala" +static void clip_library_view_delete_row (ClipLibraryView* self, GtkTreeModel* model, GtkTreePath* path) { +#line 1596 "ClipLibraryView.c" + GtkTreeIter it = {0}; +#line 420 "ClipLibraryView.vala" + g_return_if_fail (IS_CLIP_LIBRARY_VIEW (self)); +#line 420 "ClipLibraryView.vala" + g_return_if_fail (GTK_IS_TREE_MODEL (model)); +#line 420 "ClipLibraryView.vala" + g_return_if_fail (path != NULL); +#line 422 "ClipLibraryView.vala" + if (gtk_tree_model_get_iter (GTK_TREE_MODEL (self->priv->list_store), &it, path)) { +#line 1606 "ClipLibraryView.c" + char* filename; + char* _tmp1_; + char* _tmp0_; + gboolean _tmp2_; + filename = NULL; +#line 424 "ClipLibraryView.vala" + gtk_tree_model_get (model, &it, CLIP_LIBRARY_VIEW_COLUMN_TYPE_FILENAME, &filename, -1, -1); +#line 425 "ClipLibraryView.vala" + if (model_project_clipfile_on_track (self->priv->project, filename)) { +#line 426 "ClipLibraryView.vala" + if (dialog_utils_delete_cancel ("Clip is in use. Delete anyway?") != GTK_RESPONSE_YES) { +#line 1618 "ClipLibraryView.c" + _g_free0 (filename); +#line 428 "ClipLibraryView.vala" + return; +#line 1622 "ClipLibraryView.c" + } + } +#line 431 "ClipLibraryView.vala" + model_project_remove_clipfile (self->priv->project, filename); +#line 433 "ClipLibraryView.vala" + if ((_tmp2_ = _vala_strcmp0 (_tmp0_ = g_path_get_dirname (filename), _tmp1_ = model_project_get_audio_path (self->priv->project)) == 0, _g_free0 (_tmp1_), _g_free0 (_tmp0_), _tmp2_)) { +#line 434 "ClipLibraryView.vala" + if (dialog_utils_delete_keep ("Delete clip from disk? This action is not undoable.") == GTK_RESPONSE_YES) { +#line 436 "ClipLibraryView.vala" + if (g_unlink (filename) != 0) { +#line 437 "ClipLibraryView.vala" + g_signal_emit_by_name (self->priv->project, "error-occurred", "Could not delete %s", filename); +#line 1635 "ClipLibraryView.c" + } +#line 439 "ClipLibraryView.vala" + model_undo_manager_reset (self->priv->project->undo_manager); +#line 1639 "ClipLibraryView.c" + } + } + _g_free0 (filename); + } +} + + +#line 445 "ClipLibraryView.vala" +gboolean clip_library_view_has_selection (ClipLibraryView* self) { +#line 1649 "ClipLibraryView.c" + gboolean result = FALSE; + GList* paths; + GList* _tmp2_; + gint _tmp1_; + GList* _tmp0_ = NULL; +#line 445 "ClipLibraryView.vala" + g_return_val_if_fail (IS_CLIP_LIBRARY_VIEW (self), FALSE); +#line 1657 "ClipLibraryView.c" + paths = NULL; + result = (_tmp1_ = clip_library_view_get_selected_rows (self, &_tmp0_), paths = (_tmp2_ = _tmp0_, __g_list_free_gtk_tree_path_free0 (paths), _tmp2_), _tmp1_) != 0; + __g_list_free_gtk_tree_path_free0 (paths); +#line 447 "ClipLibraryView.vala" + return result; +#line 1663 "ClipLibraryView.c" + __g_list_free_gtk_tree_path_free0 (paths); +} + + +#line 450 "ClipLibraryView.vala" +GeeArrayList* clip_library_view_get_selected_files (ClipLibraryView* self) { +#line 1670 "ClipLibraryView.c" + GeeArrayList* result = NULL; + GList* paths; + GeeArrayList* return_value; + GList* _tmp2_; + gint _tmp1_; + GList* _tmp0_ = NULL; +#line 450 "ClipLibraryView.vala" + g_return_val_if_fail (IS_CLIP_LIBRARY_VIEW (self), NULL); +#line 1679 "ClipLibraryView.c" + paths = NULL; +#line 452 "ClipLibraryView.vala" + return_value = gee_array_list_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL); +#line 453 "ClipLibraryView.vala" + if ((_tmp1_ = clip_library_view_get_selected_rows (self, &_tmp0_), paths = (_tmp2_ = _tmp0_, __g_list_free_gtk_tree_path_free0 (paths), _tmp2_), _tmp1_) != 0) { +#line 1685 "ClipLibraryView.c" + { + GList* path_collection; + GList* path_it; +#line 454 "ClipLibraryView.vala" + path_collection = paths; +#line 1691 "ClipLibraryView.c" + for (path_it = path_collection; path_it != NULL; path_it = path_it->next) { + GtkTreePath* path; +#line 454 "ClipLibraryView.vala" + path = _gtk_tree_path_copy0 ((GtkTreePath*) path_it->data); +#line 1696 "ClipLibraryView.c" + { + GtkTreeIter iter = {0}; +#line 456 "ClipLibraryView.vala" + if (gtk_tree_model_get_iter (GTK_TREE_MODEL (self->priv->list_store), &iter, path)) { +#line 1701 "ClipLibraryView.c" + char* name; + name = NULL; +#line 458 "ClipLibraryView.vala" + gtk_tree_model_get (GTK_TREE_MODEL (self->priv->list_store), &iter, CLIP_LIBRARY_VIEW_COLUMN_TYPE_FILENAME, &name, -1, -1); +#line 459 "ClipLibraryView.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (return_value), name); +#line 1708 "ClipLibraryView.c" + _g_free0 (name); + } + _gtk_tree_path_free0 (path); + } + } + } + } + result = return_value; + __g_list_free_gtk_tree_path_free0 (paths); +#line 463 "ClipLibraryView.vala" + return result; +#line 1720 "ClipLibraryView.c" +} + + +#line 466 "ClipLibraryView.vala" +void clip_library_view_delete_selection (ClipLibraryView* self) { +#line 1726 "ClipLibraryView.c" + GList* paths; + GList* _tmp2_; + gint _tmp1_; + GList* _tmp0_ = NULL; +#line 466 "ClipLibraryView.vala" + g_return_if_fail (IS_CLIP_LIBRARY_VIEW (self)); +#line 1733 "ClipLibraryView.c" + paths = NULL; +#line 468 "ClipLibraryView.vala" + model_undo_manager_start_transaction (self->priv->project->undo_manager, "Delete Clips From Library"); +#line 469 "ClipLibraryView.vala" + if ((_tmp1_ = clip_library_view_get_selected_rows (self, &_tmp0_), paths = (_tmp2_ = _tmp0_, __g_list_free_gtk_tree_path_free0 (paths), _tmp2_), _tmp1_) > 0) { +#line 1739 "ClipLibraryView.c" + { + gint i; +#line 470 "ClipLibraryView.vala" + i = ((gint) g_list_length (paths)) - 1; +#line 1744 "ClipLibraryView.c" + { + gboolean _tmp3_; +#line 470 "ClipLibraryView.vala" + _tmp3_ = TRUE; +#line 470 "ClipLibraryView.vala" + while (TRUE) { +#line 470 "ClipLibraryView.vala" + if (!_tmp3_) { +#line 470 "ClipLibraryView.vala" + i--; +#line 1755 "ClipLibraryView.c" + } +#line 470 "ClipLibraryView.vala" + _tmp3_ = FALSE; +#line 470 "ClipLibraryView.vala" + if (!(i >= 0)) { +#line 470 "ClipLibraryView.vala" + break; +#line 1763 "ClipLibraryView.c" + } +#line 471 "ClipLibraryView.vala" + clip_library_view_delete_row (self, GTK_TREE_MODEL (self->priv->list_store), (GtkTreePath*) g_list_nth_data (paths, (guint) i)); +#line 1767 "ClipLibraryView.c" + } + } + } + } +#line 473 "ClipLibraryView.vala" + model_undo_manager_end_transaction (self->priv->project->undo_manager, "Delete Clips From Library"); +#line 1774 "ClipLibraryView.c" + __g_list_free_gtk_tree_path_free0 (paths); +} + + +#line 476 "ClipLibraryView.vala" +void clip_library_view_select_all (ClipLibraryView* self) { +#line 476 "ClipLibraryView.vala" + g_return_if_fail (IS_CLIP_LIBRARY_VIEW (self)); +#line 477 "ClipLibraryView.vala" + gtk_tree_selection_select_all (self->priv->selection); +#line 1785 "ClipLibraryView.c" +} + + +#line 480 "ClipLibraryView.vala" +static gint clip_library_view_name_sort (ClipLibraryView* self, GtkTreeModel* model, GtkTreeIter* a, GtkTreeIter* b) { +#line 1791 "ClipLibraryView.c" + gint result = 0; + char* left; + char* right; +#line 480 "ClipLibraryView.vala" + g_return_val_if_fail (IS_CLIP_LIBRARY_VIEW (self), 0); +#line 480 "ClipLibraryView.vala" + g_return_val_if_fail (GTK_IS_TREE_MODEL (model), 0); +#line 1799 "ClipLibraryView.c" + left = NULL; + right = NULL; +#line 483 "ClipLibraryView.vala" + gtk_tree_model_get (model, a, CLIP_LIBRARY_VIEW_COLUMN_TYPE_NAME, &left, -1); +#line 484 "ClipLibraryView.vala" + gtk_tree_model_get (model, b, CLIP_LIBRARY_VIEW_COLUMN_TYPE_NAME, &right, -1); +#line 1806 "ClipLibraryView.c" + result = stricmp (left, right); + _g_free0 (left); + _g_free0 (right); +#line 485 "ClipLibraryView.vala" + return result; +#line 1812 "ClipLibraryView.c" +} + + +static void clip_library_view_class_init (ClipLibraryViewClass * klass) { + clip_library_view_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ClipLibraryViewPrivate)); + GTK_WIDGET_CLASS (klass)->drag_data_received = clip_library_view_real_drag_data_received; + G_OBJECT_CLASS (klass)->finalize = clip_library_view_finalize; + g_signal_new ("selection_changed", TYPE_CLIP_LIBRARY_VIEW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1, G_TYPE_BOOLEAN); +} + + +static void clip_library_view_instance_init (ClipLibraryView * self) { + self->priv = CLIP_LIBRARY_VIEW_GET_PRIVATE (self); + self->priv->label = NULL; + self->priv->files_dragging = gee_array_list_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL); +} + + +static void clip_library_view_finalize (GObject* obj) { + ClipLibraryView * self; + self = CLIP_LIBRARY_VIEW (obj); + _g_object_unref0 (self->priv->project); + _g_object_unref0 (self->priv->tree_view); + _g_object_unref0 (self->priv->selection); + _g_object_unref0 (self->priv->label); + _g_object_unref0 (self->priv->list_store); + _g_object_unref0 (self->priv->files_dragging); + _g_object_unref0 (self->priv->icon_theme); + _g_object_unref0 (self->priv->default_audio_icon); + _g_object_unref0 (self->priv->default_video_icon); + _g_object_unref0 (self->priv->default_error_icon); + _g_object_unref0 (self->priv->time_provider); + G_OBJECT_CLASS (clip_library_view_parent_class)->finalize (obj); +} + + +GType clip_library_view_get_type (void) { + static volatile gsize clip_library_view_type_id__volatile = 0; + if (g_once_init_enter (&clip_library_view_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ClipLibraryViewClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) clip_library_view_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ClipLibraryView), 0, (GInstanceInitFunc) clip_library_view_instance_init, NULL }; + GType clip_library_view_type_id; + clip_library_view_type_id = g_type_register_static (GTK_TYPE_EVENT_BOX, "ClipLibraryView", &g_define_type_info, 0); + g_once_init_leave (&clip_library_view_type_id__volatile, clip_library_view_type_id); + } + return clip_library_view_type_id__volatile; +} + + +static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) { + if ((array != NULL) && (destroy_func != NULL)) { + int i; + for (i = 0; i < array_length; i = i + 1) { + if (((gpointer*) array)[i] != NULL) { + destroy_func (((gpointer*) array)[i]); + } + } + } +} + + +static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) { + _vala_array_destroy (array, array_length, destroy_func); + g_free (array); +} + + +static gint _vala_array_length (gpointer array) { + int length; + length = 0; + if (array) { + while (((gpointer*) array)[length]) { + length++; + } + } + return length; +} + + +static int _vala_strcmp0 (const char * str1, const char * str2) { + if (str1 == NULL) { + return -(str1 != str2); + } + if (str2 == NULL) { + return str1 != str2; + } + return strcmp (str1, str2); +} + + + + diff --git a/src/marina/marina/ClipLibraryView.o b/src/marina/marina/ClipLibraryView.o new file mode 100644 index 0000000..40c93ca Binary files /dev/null and b/src/marina/marina/ClipLibraryView.o differ diff --git a/src/marina/marina/DialogUtils.c b/src/marina/marina/DialogUtils.c new file mode 100644 index 0000000..b0cc9f5 --- /dev/null +++ b/src/marina/marina/DialogUtils.c @@ -0,0 +1,1207 @@ +/* DialogUtils.c generated by valac, the Vala compiler + * generated from DialogUtils.vala, do not modify */ + +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#define DIALOG_UTILS_TYPE_FILTER_DESCRIPTION_STRUCT (dialog_utils_filter_description_struct_get_type ()) +typedef struct _DialogUtilsfilter_description_struct DialogUtilsfilter_description_struct; +#define _g_free0(var) (var = (g_free (var), NULL)) +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +#define __g_slist_free_g_free0(var) ((var == NULL) ? NULL : (var = (_g_slist_free_g_free (var), NULL))) + +#define DIALOG_UTILS_TYPE_BUTTON_STRUCT (dialog_utils_button_struct_get_type ()) +typedef struct _DialogUtilsButtonStruct DialogUtilsButtonStruct; + +#define TYPE_CLIP_VIEW (clip_view_get_type ()) +#define CLIP_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CLIP_VIEW, ClipView)) +#define CLIP_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CLIP_VIEW, ClipViewClass)) +#define IS_CLIP_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CLIP_VIEW)) +#define IS_CLIP_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CLIP_VIEW)) +#define CLIP_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CLIP_VIEW, ClipViewClass)) + +typedef struct _ClipView ClipView; +typedef struct _ClipViewClass ClipViewClass; +typedef struct _ClipViewPrivate ClipViewPrivate; + +#define MODEL_TYPE_CLIP (model_clip_get_type ()) +#define MODEL_CLIP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP, ModelClip)) +#define MODEL_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP, ModelClipClass)) +#define MODEL_IS_CLIP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP)) +#define MODEL_IS_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP)) +#define MODEL_CLIP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP, ModelClipClass)) + +typedef struct _ModelClip ModelClip; +typedef struct _ModelClipClass ModelClipClass; +typedef struct _ModelClipPrivate ModelClipPrivate; + +#define MODEL_TYPE_CLIP_FILE (model_clip_file_get_type ()) +#define MODEL_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFile)) +#define MODEL_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) +#define MODEL_IS_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE)) +#define MODEL_IS_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE)) +#define MODEL_CLIP_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) + +typedef struct _ModelClipFile ModelClipFile; +typedef struct _ModelClipFileClass ModelClipFileClass; + +#define MODEL_TYPE_MEDIA_TYPE (model_media_type_get_type ()) +typedef struct _ModelClipFilePrivate ModelClipFilePrivate; + +#define TYPE_FRACTION (fraction_get_type ()) +typedef struct _Fraction Fraction; + +#define TYPE_TIME_CODE (time_code_get_type ()) +typedef struct _TimeCode TimeCode; + +struct _DialogUtilsfilter_description_struct { + char* name; + char* extension; +}; + +struct _DialogUtilsButtonStruct { + char* title; + GtkResponseType type; +}; + +struct _ClipView { + GtkDrawingArea parent_instance; + ClipViewPrivate * priv; + ModelClip* clip; + gint64 initial_time; + gboolean is_selected; + gint height; +}; + +struct _ClipViewClass { + GtkDrawingAreaClass parent_class; +}; + +typedef enum { + MODEL_MEDIA_TYPE_AUDIO, + MODEL_MEDIA_TYPE_VIDEO +} ModelMediaType; + +struct _ModelClip { + GObject parent_instance; + ModelClipPrivate * priv; + ModelClipFile* clipfile; + ModelMediaType type; + gboolean is_recording; + char* name; +}; + +struct _ModelClipClass { + GObjectClass parent_class; +}; + +struct _ModelClipFile { + GObject parent_instance; + ModelClipFilePrivate * priv; + char* filename; + GstCaps* video_caps; + GstCaps* audio_caps; + GdkPixbuf* thumbnail; +}; + +struct _ModelClipFileClass { + GObjectClass parent_class; +}; + +struct _Fraction { + gint numerator; + gint denominator; +}; + +struct _TimeCode { + gint hour; + gint minute; + gint second; + gint frame; + gboolean drop_code; +}; + + + +GType dialog_utils_filter_description_struct_get_type (void); +DialogUtilsfilter_description_struct* dialog_utils_filter_description_struct_dup (const DialogUtilsfilter_description_struct* self); +void dialog_utils_filter_description_struct_free (DialogUtilsfilter_description_struct* self); +void dialog_utils_filter_description_struct_copy (const DialogUtilsfilter_description_struct* self, DialogUtilsfilter_description_struct* dest); +void dialog_utils_filter_description_struct_destroy (DialogUtilsfilter_description_struct* self); +GtkFileFilter* dialog_utils_add_filter (GtkFileChooserDialog* d, const char* name, const char* extension); +void dialog_utils_add_filters (DialogUtilsfilter_description_struct* filter_descriptions, int filter_descriptions_length1, GtkFileChooserDialog* d, GeeArrayList* filters, gboolean allow_all); +static void _g_slist_free_g_free (GSList* self); +gboolean dialog_utils_open (GtkWindow* parent, DialogUtilsfilter_description_struct* filter_descriptions, int filter_descriptions_length1, gboolean allow_multiple, gboolean allow_all, GSList** filenames); +void dialog_utils_error (const char* major_message, const char* minor_message); +char* append_extension (const char* path, const char* extension); +gboolean dialog_utils_confirm_replace (GtkWindow* parent, const char* filename); +gboolean dialog_utils_save (GtkWindow* parent, const char* title, gboolean create_directory, DialogUtilsfilter_description_struct* filter_descriptions, int filter_descriptions_length1, char** filename); +char* dialog_utils_bold_message (const char* message); +void dialog_utils_warning (const char* major_message, const char* minor_message); +GType dialog_utils_button_struct_get_type (void); +DialogUtilsButtonStruct* dialog_utils_button_struct_dup (const DialogUtilsButtonStruct* self); +void dialog_utils_button_struct_free (DialogUtilsButtonStruct* self); +void dialog_utils_button_struct_copy (const DialogUtilsButtonStruct* self, DialogUtilsButtonStruct* dest); +void dialog_utils_button_struct_destroy (DialogUtilsButtonStruct* self); +GtkResponseType dialog_utils_run_dialog (GtkWindow* parent, GtkMessageType type, const char* title, const char* message, DialogUtilsButtonStruct* buttons, int buttons_length1); +GtkResponseType dialog_utils_two_button_dialog (const char* message, const char* first_button, const char* second_button); +GtkResponseType dialog_utils_delete_keep (const char* message); +GtkResponseType dialog_utils_add_cancel (const char* message); +GtkResponseType dialog_utils_delete_cancel (const char* message); +void dialog_utils_button_struct_init (DialogUtilsButtonStruct *self, const char* title, GtkResponseType type); +static void _vala_DialogUtilsButtonStruct_array_free (DialogUtilsButtonStruct* array, gint array_length); +GtkResponseType dialog_utils_save_close_cancel (GtkWindow* parent, const char* title, const char* message); +GtkAlignment* dialog_utils_get_aligned_label (float x, float y, float exp_x, float exp_y, const char* text, gboolean selectable); +void dialog_utils_add_label_to_table (GtkTable* t, const char* str, gint x, gint y, gint xpad, gint ypad, gboolean selectable); +GType clip_view_get_type (void); +GType model_clip_get_type (void); +GType model_clip_file_get_type (void); +GType model_media_type_get_type (void); +GType fraction_get_type (void); +Fraction* fraction_dup (const Fraction* self); +void fraction_free (Fraction* self); +GType time_code_get_type (void); +TimeCode* time_code_dup (const TimeCode* self); +void time_code_free (TimeCode* self); +void frame_to_time (gint frame, Fraction* rate, TimeCode* result); +gint time_to_frame_with_rate (gint64 time, Fraction* rate); +gint64 model_clip_get_duration (ModelClip* self); +char* time_code_to_string (TimeCode *self); +gint64 model_clip_file_get_length (ModelClipFile* self); +char* time_to_string (gint64 time); +gboolean model_clip_is_trimmed (ModelClip* self); +gboolean model_clip_file_has_caps_structure (ModelClipFile* self, ModelMediaType m); +gboolean model_clip_file_get_dimensions (ModelClipFile* self, gint* w, gint* h); +gboolean model_clip_file_get_frame_rate (ModelClipFile* self, Fraction* rate); +gboolean model_clip_file_get_sample_rate (ModelClipFile* self, gint* rate); +gboolean model_clip_file_get_num_channels_string (ModelClipFile* self, char** s); +void dialog_utils_show_clip_properties (GtkWindow* parent, ClipView* selected_clip, ModelClipFile* clip_file, Fraction* frames_per_second); + + + +void dialog_utils_filter_description_struct_copy (const DialogUtilsfilter_description_struct* self, DialogUtilsfilter_description_struct* dest) { + dest->name = g_strdup (self->name); + dest->extension = g_strdup (self->extension); +} + + +void dialog_utils_filter_description_struct_destroy (DialogUtilsfilter_description_struct* self) { + _g_free0 (self->name); + _g_free0 (self->extension); +} + + +DialogUtilsfilter_description_struct* dialog_utils_filter_description_struct_dup (const DialogUtilsfilter_description_struct* self) { + DialogUtilsfilter_description_struct* dup; + dup = g_new0 (DialogUtilsfilter_description_struct, 1); + dialog_utils_filter_description_struct_copy (self, dup); + return dup; +} + + +void dialog_utils_filter_description_struct_free (DialogUtilsfilter_description_struct* self) { + dialog_utils_filter_description_struct_destroy (self); + g_free (self); +} + + +GType dialog_utils_filter_description_struct_get_type (void) { + static volatile gsize dialog_utils_filter_description_struct_type_id__volatile = 0; + if (g_once_init_enter (&dialog_utils_filter_description_struct_type_id__volatile)) { + GType dialog_utils_filter_description_struct_type_id; + dialog_utils_filter_description_struct_type_id = g_boxed_type_register_static ("DialogUtilsfilter_description_struct", (GBoxedCopyFunc) dialog_utils_filter_description_struct_dup, (GBoxedFreeFunc) dialog_utils_filter_description_struct_free); + g_once_init_leave (&dialog_utils_filter_description_struct_type_id__volatile, dialog_utils_filter_description_struct_type_id); + } + return dialog_utils_filter_description_struct_type_id__volatile; +} + + +#line 13 "DialogUtils.vala" +GtkFileFilter* dialog_utils_add_filter (GtkFileChooserDialog* d, const char* name, const char* extension) { +#line 242 "DialogUtils.c" + GtkFileFilter* result = NULL; + GtkFileFilter* filter; +#line 13 "DialogUtils.vala" + g_return_val_if_fail (GTK_IS_FILE_CHOOSER_DIALOG (d), NULL); +#line 13 "DialogUtils.vala" + g_return_val_if_fail (name != NULL, NULL); +#line 14 "DialogUtils.vala" + filter = g_object_ref_sink (gtk_file_filter_new ()); +#line 15 "DialogUtils.vala" + gtk_file_filter_set_name (filter, name); +#line 16 "DialogUtils.vala" + if (extension != NULL) { +#line 255 "DialogUtils.c" + char* _tmp0_; +#line 17 "DialogUtils.vala" + gtk_file_filter_add_pattern (filter, _tmp0_ = g_strconcat ("*.", extension, NULL)); +#line 259 "DialogUtils.c" + _g_free0 (_tmp0_); + } else { +#line 19 "DialogUtils.vala" + gtk_file_filter_add_pattern (filter, "*"); +#line 264 "DialogUtils.c" + } +#line 21 "DialogUtils.vala" + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (d), filter); +#line 268 "DialogUtils.c" + result = filter; +#line 22 "DialogUtils.vala" + return result; +#line 272 "DialogUtils.c" +} + + +#line 25 "DialogUtils.vala" +void dialog_utils_add_filters (DialogUtilsfilter_description_struct* filter_descriptions, int filter_descriptions_length1, GtkFileChooserDialog* d, GeeArrayList* filters, gboolean allow_all) { +#line 278 "DialogUtils.c" + gint length; + GtkFileFilter* _tmp2_; +#line 25 "DialogUtils.vala" + g_return_if_fail (GTK_IS_FILE_CHOOSER_DIALOG (d)); +#line 25 "DialogUtils.vala" + g_return_if_fail (GEE_IS_ARRAY_LIST (filters)); +#line 28 "DialogUtils.vala" + length = filter_descriptions_length1; +#line 287 "DialogUtils.c" + { + gint i; +#line 29 "DialogUtils.vala" + i = 0; +#line 292 "DialogUtils.c" + { + gboolean _tmp0_; +#line 29 "DialogUtils.vala" + _tmp0_ = TRUE; +#line 29 "DialogUtils.vala" + while (TRUE) { +#line 299 "DialogUtils.c" + GtkFileFilter* filter; +#line 29 "DialogUtils.vala" + if (!_tmp0_) { +#line 29 "DialogUtils.vala" + i = i + 1; +#line 305 "DialogUtils.c" + } +#line 29 "DialogUtils.vala" + _tmp0_ = FALSE; +#line 29 "DialogUtils.vala" + if (!(i < length)) { +#line 29 "DialogUtils.vala" + break; +#line 313 "DialogUtils.c" + } +#line 30 "DialogUtils.vala" + filter = dialog_utils_add_filter (d, filter_descriptions[i].name, filter_descriptions[i].extension); +#line 32 "DialogUtils.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (filters), filter); +#line 319 "DialogUtils.c" + _g_object_unref0 (filter); + } + } + } +#line 35 "DialogUtils.vala" + if (allow_all) { +#line 326 "DialogUtils.c" + GtkFileFilter* _tmp1_; +#line 36 "DialogUtils.vala" + _tmp1_ = dialog_utils_add_filter (d, "All files", NULL); +#line 330 "DialogUtils.c" + _g_object_unref0 (_tmp1_); + } +#line 40 "DialogUtils.vala" + g_assert (filter_descriptions_length1 == gee_collection_get_size (GEE_COLLECTION (filters))); +#line 42 "DialogUtils.vala" + gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (d), _tmp2_ = (GtkFileFilter*) gee_abstract_list_get (GEE_ABSTRACT_LIST (filters), 0)); +#line 337 "DialogUtils.c" + _g_object_unref0 (_tmp2_); +} + + +static void _g_slist_free_g_free (GSList* self) { + g_slist_foreach (self, (GFunc) g_free, NULL); + g_slist_free (self); +} + + +#line 45 "DialogUtils.vala" +gboolean dialog_utils_open (GtkWindow* parent, DialogUtilsfilter_description_struct* filter_descriptions, int filter_descriptions_length1, gboolean allow_multiple, gboolean allow_all, GSList** filenames) { +#line 350 "DialogUtils.c" + gboolean result = FALSE; + gboolean return_value; + HildonFileChooserDialog* file_chooser; + GeeArrayList* filters; +#line 45 "DialogUtils.vala" + g_return_val_if_fail (GTK_IS_WINDOW (parent), FALSE); +#line 357 "DialogUtils.c" + if (filenames != NULL) { + *filenames = NULL; + } +#line 47 "DialogUtils.vala" + fprintf (stdout, "open called\n"); +#line 48 "DialogUtils.vala" + fflush (stdout); +#line 49 "DialogUtils.vala" + return_value = FALSE; +#line 50 "DialogUtils.vala" + file_chooser = g_object_ref_sink ((HildonFileChooserDialog*) hildon_file_chooser_dialog_new (parent, GTK_FILE_CHOOSER_ACTION_OPEN)); +#line 51 "DialogUtils.vala" + gtk_window_set_title (GTK_WINDOW (file_chooser), "Open Files"); +#line 55 "DialogUtils.vala" + hildon_file_chooser_dialog_set_show_upnp (file_chooser, TRUE); +#line 56 "DialogUtils.vala" + filters = gee_array_list_new (GTK_TYPE_FILE_FILTER, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL); +#line 57 "DialogUtils.vala" + dialog_utils_add_filters (filter_descriptions, filter_descriptions_length1, GTK_FILE_CHOOSER_DIALOG (file_chooser), filters, allow_all); +#line 58 "DialogUtils.vala" + gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (file_chooser), allow_multiple); +#line 59 "DialogUtils.vala" + if (gtk_dialog_run (GTK_DIALOG (file_chooser)) == GTK_RESPONSE_OK) { +#line 381 "DialogUtils.c" + GSList* _tmp0_; +#line 60 "DialogUtils.vala" + return_value = TRUE; +#line 61 "DialogUtils.vala" + *filenames = (_tmp0_ = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (file_chooser)), __g_slist_free_g_free0 (*filenames), _tmp0_); +#line 387 "DialogUtils.c" + } +#line 63 "DialogUtils.vala" + gtk_object_destroy (GTK_OBJECT (file_chooser)); +#line 391 "DialogUtils.c" + result = return_value; + _g_object_unref0 (file_chooser); + _g_object_unref0 (filters); +#line 64 "DialogUtils.vala" + return result; +#line 397 "DialogUtils.c" +} + + +#line 67 "DialogUtils.vala" +gboolean dialog_utils_save (GtkWindow* parent, const char* title, gboolean create_directory, DialogUtilsfilter_description_struct* filter_descriptions, int filter_descriptions_length1, char** filename) { +#line 403 "DialogUtils.c" + gboolean result = FALSE; + gboolean return_value; + HildonFileChooserDialog* file_chooser; + gint length; + GeeArrayList* filters; +#line 67 "DialogUtils.vala" + g_return_val_if_fail (GTK_IS_WINDOW (parent), FALSE); +#line 67 "DialogUtils.vala" + g_return_val_if_fail (title != NULL, FALSE); +#line 67 "DialogUtils.vala" + g_return_val_if_fail (filename != NULL, FALSE); +#line 69 "DialogUtils.vala" + return_value = FALSE; +#line 72 "DialogUtils.vala" + file_chooser = g_object_ref_sink ((HildonFileChooserDialog*) hildon_file_chooser_dialog_new (parent, GTK_FILE_CHOOSER_ACTION_SAVE)); +#line 73 "DialogUtils.vala" + gtk_window_set_title (GTK_WINDOW (file_chooser), title); +#line 74 "DialogUtils.vala" + hildon_file_chooser_dialog_set_show_upnp (file_chooser, FALSE); +#line 75 "DialogUtils.vala" + if ((*filename) != NULL) { +#line 425 "DialogUtils.c" + char* _tmp0_; +#line 76 "DialogUtils.vala" + gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (file_chooser), _tmp0_ = g_path_get_dirname (*filename)); +#line 429 "DialogUtils.c" + _g_free0 (_tmp0_); + } else { + } +#line 80 "DialogUtils.vala" + length = filter_descriptions_length1; +#line 81 "DialogUtils.vala" + filters = gee_array_list_new (GTK_TYPE_FILE_FILTER, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL); +#line 88 "DialogUtils.vala" + while (TRUE) { +#line 439 "DialogUtils.c" + char* local_filename; + GtkFileFilter* selected_filter; + gint i; + char* _tmp3_; + gboolean _tmp4_ = FALSE; +#line 88 "DialogUtils.vala" + if (!(gtk_dialog_run (GTK_DIALOG (file_chooser)) == GTK_RESPONSE_OK)) { +#line 88 "DialogUtils.vala" + break; +#line 449 "DialogUtils.c" + } +#line 89 "DialogUtils.vala" + local_filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (file_chooser)); +#line 90 "DialogUtils.vala" + if (create_directory) { +#line 455 "DialogUtils.c" + char* _tmp2_; + char* _tmp1_; +#line 91 "DialogUtils.vala" + if (g_mkdir (local_filename, 0777) != 0) { +#line 92 "DialogUtils.vala" + dialog_utils_error ("Could not create directory", g_strerror (errno)); +#line 462 "DialogUtils.c" + ; +#line 93 "DialogUtils.vala" + gtk_window_present (GTK_WINDOW (file_chooser)); +#line 466 "DialogUtils.c" + _g_free0 (local_filename); +#line 94 "DialogUtils.vala" + continue; +#line 470 "DialogUtils.c" + } +#line 96 "DialogUtils.vala" + local_filename = (_tmp2_ = g_build_filename (local_filename, _tmp1_ = g_path_get_basename (local_filename), NULL), _g_free0 (local_filename), _tmp2_); +#line 474 "DialogUtils.c" + _g_free0 (_tmp1_); + } +#line 100 "DialogUtils.vala" + selected_filter = gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (file_chooser)); +#line 102 "DialogUtils.vala" + i = 0; +#line 481 "DialogUtils.c" + { + GeeIterator* _file_filter_it; + _file_filter_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (filters)); +#line 103 "DialogUtils.vala" + while (TRUE) { +#line 487 "DialogUtils.c" + GtkFileFilter* file_filter; +#line 103 "DialogUtils.vala" + if (!gee_iterator_next (_file_filter_it)) { +#line 103 "DialogUtils.vala" + break; +#line 493 "DialogUtils.c" + } +#line 103 "DialogUtils.vala" + file_filter = (GtkFileFilter*) gee_iterator_get (_file_filter_it); +#line 104 "DialogUtils.vala" + if (file_filter == selected_filter) { +#line 499 "DialogUtils.c" + _g_object_unref0 (file_filter); +#line 105 "DialogUtils.vala" + break; +#line 503 "DialogUtils.c" + } +#line 107 "DialogUtils.vala" + i = i + 1; +#line 507 "DialogUtils.c" + _g_object_unref0 (file_filter); + } + _g_object_unref0 (_file_filter_it); + } +#line 110 "DialogUtils.vala" + g_assert (i < length); +#line 112 "DialogUtils.vala" + local_filename = (_tmp3_ = append_extension (local_filename, filter_descriptions[i].extension), _g_free0 (local_filename), _tmp3_); +#line 113 "DialogUtils.vala" + if (!g_file_test (local_filename, G_FILE_TEST_EXISTS)) { +#line 113 "DialogUtils.vala" + _tmp4_ = TRUE; +#line 520 "DialogUtils.c" + } else { +#line 114 "DialogUtils.vala" + _tmp4_ = dialog_utils_confirm_replace (parent, local_filename); +#line 524 "DialogUtils.c" + } +#line 113 "DialogUtils.vala" + if (_tmp4_) { +#line 528 "DialogUtils.c" + char* _tmp5_; +#line 115 "DialogUtils.vala" + return_value = TRUE; +#line 116 "DialogUtils.vala" + *filename = (_tmp5_ = g_strdup (local_filename), _g_free0 (*filename), _tmp5_); +#line 534 "DialogUtils.c" + _g_free0 (local_filename); +#line 117 "DialogUtils.vala" + break; +#line 538 "DialogUtils.c" + } else { +#line 120 "DialogUtils.vala" + gtk_window_present (GTK_WINDOW (file_chooser)); +#line 542 "DialogUtils.c" + } + _g_free0 (local_filename); + } +#line 123 "DialogUtils.vala" + gtk_object_destroy (GTK_OBJECT (file_chooser)); +#line 548 "DialogUtils.c" + result = return_value; + _g_object_unref0 (file_chooser); + _g_object_unref0 (filters); +#line 124 "DialogUtils.vala" + return result; +#line 554 "DialogUtils.c" +} + + +#line 127 "DialogUtils.vala" +char* dialog_utils_bold_message (const char* message) { +#line 560 "DialogUtils.c" + char* result = NULL; +#line 127 "DialogUtils.vala" + g_return_val_if_fail (message != NULL, NULL); +#line 564 "DialogUtils.c" + result = g_strdup (message); +#line 128 "DialogUtils.vala" + return result; +#line 568 "DialogUtils.c" +} + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 131 "DialogUtils.vala" +void dialog_utils_warning (const char* major_message, const char* minor_message) { +#line 579 "DialogUtils.c" + char* message; + GtkWidget* banner; +#line 131 "DialogUtils.vala" + g_return_if_fail (major_message != NULL); +#line 132 "DialogUtils.vala" + message = dialog_utils_bold_message (major_message); +#line 133 "DialogUtils.vala" + if (minor_message != NULL) { +#line 588 "DialogUtils.c" + char* _tmp1_; + char* _tmp0_; +#line 134 "DialogUtils.vala" + message = (_tmp1_ = g_strconcat (_tmp0_ = g_strconcat (message, "\n\n", NULL), minor_message, NULL), _g_free0 (message), _tmp1_); +#line 593 "DialogUtils.c" + _g_free0 (_tmp0_); + } +#line 136 "DialogUtils.vala" + banner = _g_object_ref0 (hildon_banner_show_information_with_markup (NULL, NULL, message)); +#line 137 "DialogUtils.vala" + hildon_banner_set_timeout (HILDON_BANNER (banner), (guint) (1000 * 2)); +#line 600 "DialogUtils.c" + _g_free0 (message); + _g_object_unref0 (banner); +} + + +#line 140 "DialogUtils.vala" +void dialog_utils_error (const char* major_message, const char* minor_message) { +#line 608 "DialogUtils.c" + char* message; + GtkWidget* banner; +#line 140 "DialogUtils.vala" + g_return_if_fail (major_message != NULL); +#line 141 "DialogUtils.vala" + message = dialog_utils_bold_message (major_message); +#line 142 "DialogUtils.vala" + if (minor_message != NULL) { +#line 617 "DialogUtils.c" + char* _tmp1_; + char* _tmp0_; +#line 143 "DialogUtils.vala" + message = (_tmp1_ = g_strconcat (_tmp0_ = g_strconcat (message, "\n\n", NULL), minor_message, NULL), _g_free0 (message), _tmp1_); +#line 622 "DialogUtils.c" + _g_free0 (_tmp0_); + } +#line 145 "DialogUtils.vala" + banner = _g_object_ref0 (hildon_banner_show_information_with_markup (NULL, NULL, message)); +#line 146 "DialogUtils.vala" + hildon_banner_set_timeout (HILDON_BANNER (banner), (guint) (1000 * 2)); +#line 629 "DialogUtils.c" + _g_free0 (message); + _g_object_unref0 (banner); +} + + +#line 149 "DialogUtils.vala" +GtkResponseType dialog_utils_run_dialog (GtkWindow* parent, GtkMessageType type, const char* title, const char* message, DialogUtilsButtonStruct* buttons, int buttons_length1) { +#line 637 "DialogUtils.c" + GtkResponseType result = 0; + HildonDialog* dialog; + GtkVBox* content; + GtkLabel* label; + gint length; + GtkResponseType response; +#line 149 "DialogUtils.vala" + g_return_val_if_fail ((parent == NULL) || GTK_IS_WINDOW (parent), 0); +#line 149 "DialogUtils.vala" + g_return_val_if_fail (message != NULL, 0); +#line 152 "DialogUtils.vala" + if (NULL == title) { +#line 152 "DialogUtils.vala" + title = "Message"; +#line 652 "DialogUtils.c" + } +#line 153 "DialogUtils.vala" + dialog = g_object_ref_sink ((HildonDialog*) hildon_dialog_new ()); +#line 154 "DialogUtils.vala" + gtk_widget_set_parent (GTK_WIDGET (dialog), GTK_WIDGET (parent)); +#line 155 "DialogUtils.vala" + gtk_window_set_title (GTK_WINDOW (dialog), title); +#line 156 "DialogUtils.vala" + content = _g_object_ref0 (GTK_VBOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog)))); +#line 157 "DialogUtils.vala" + label = g_object_ref_sink ((GtkLabel*) gtk_label_new (message)); +#line 159 "DialogUtils.vala" + gtk_label_set_single_line_mode (label, FALSE); +#line 160 "DialogUtils.vala" + gtk_label_set_line_wrap (label, TRUE); +#line 162 "DialogUtils.vala" + gtk_container_add (GTK_CONTAINER (content), GTK_WIDGET (label)); +#line 164 "DialogUtils.vala" + length = buttons_length1; +#line 672 "DialogUtils.c" + { + gint i; +#line 165 "DialogUtils.vala" + i = 0; +#line 677 "DialogUtils.c" + { + gboolean _tmp0_; +#line 165 "DialogUtils.vala" + _tmp0_ = TRUE; +#line 165 "DialogUtils.vala" + while (TRUE) { +#line 165 "DialogUtils.vala" + if (!_tmp0_) { +#line 165 "DialogUtils.vala" + i = i + 1; +#line 688 "DialogUtils.c" + } +#line 165 "DialogUtils.vala" + _tmp0_ = FALSE; +#line 165 "DialogUtils.vala" + if (!(i < length)) { +#line 165 "DialogUtils.vala" + break; +#line 696 "DialogUtils.c" + } +#line 166 "DialogUtils.vala" + hildon_dialog_add_button (dialog, buttons[i].title, (gint) buttons[i].type); +#line 700 "DialogUtils.c" + } + } + } +#line 169 "DialogUtils.vala" + gtk_widget_show_all (GTK_WIDGET (dialog)); +#line 170 "DialogUtils.vala" + response = (GtkResponseType) gtk_dialog_run (GTK_DIALOG (dialog)); +#line 171 "DialogUtils.vala" + gtk_object_destroy (GTK_OBJECT (dialog)); +#line 710 "DialogUtils.c" + result = response; + _g_object_unref0 (dialog); + _g_object_unref0 (content); + _g_object_unref0 (label); +#line 173 "DialogUtils.vala" + return result; +#line 717 "DialogUtils.c" +} + + +#line 176 "DialogUtils.vala" +GtkResponseType dialog_utils_two_button_dialog (const char* message, const char* first_button, const char* second_button) { +#line 723 "DialogUtils.c" + GtkResponseType result = 0; + HildonDialog* d; + GtkVBox* contents; + GtkVBox* vbox; + GtkLabel* label; + GtkResponseType r; +#line 176 "DialogUtils.vala" + g_return_val_if_fail (message != NULL, 0); +#line 176 "DialogUtils.vala" + g_return_val_if_fail (first_button != NULL, 0); +#line 176 "DialogUtils.vala" + g_return_val_if_fail (second_button != NULL, 0); +#line 177 "DialogUtils.vala" + d = g_object_ref_sink ((HildonDialog*) hildon_dialog_new ()); +#line 179 "DialogUtils.vala" + contents = _g_object_ref0 (GTK_VBOX (gtk_dialog_get_content_area (GTK_DIALOG (d)))); +#line 180 "DialogUtils.vala" + vbox = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (TRUE, 4)); +#line 181 "DialogUtils.vala" + label = g_object_ref_sink ((GtkLabel*) gtk_label_new (message)); +#line 182 "DialogUtils.vala" + gtk_label_set_use_markup (label, TRUE); +#line 183 "DialogUtils.vala" + gtk_label_set_single_line_mode (label, FALSE); +#line 184 "DialogUtils.vala" + gtk_label_set_line_wrap (label, TRUE); +#line 185 "DialogUtils.vala" + gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (label), TRUE, TRUE, 0); +#line 186 "DialogUtils.vala" + gtk_container_add (GTK_CONTAINER (contents), GTK_WIDGET (vbox)); +#line 187 "DialogUtils.vala" + hildon_dialog_add_buttons (d, first_button, GTK_RESPONSE_NO, second_button, GTK_RESPONSE_YES, NULL); +#line 190 "DialogUtils.vala" + gtk_widget_show_all (GTK_WIDGET (d)); +#line 191 "DialogUtils.vala" + r = (GtkResponseType) gtk_dialog_run (GTK_DIALOG (d)); +#line 192 "DialogUtils.vala" + gtk_object_destroy (GTK_OBJECT (d)); +#line 762 "DialogUtils.c" + result = r; + _g_object_unref0 (d); + _g_object_unref0 (contents); + _g_object_unref0 (vbox); + _g_object_unref0 (label); +#line 194 "DialogUtils.vala" + return result; +#line 770 "DialogUtils.c" +} + + +#line 197 "DialogUtils.vala" +GtkResponseType dialog_utils_delete_keep (const char* message) { +#line 776 "DialogUtils.c" + GtkResponseType result = 0; +#line 197 "DialogUtils.vala" + g_return_val_if_fail (message != NULL, 0); +#line 780 "DialogUtils.c" + result = dialog_utils_two_button_dialog (message, "Keep", GTK_STOCK_DELETE); +#line 198 "DialogUtils.vala" + return result; +#line 784 "DialogUtils.c" +} + + +#line 201 "DialogUtils.vala" +GtkResponseType dialog_utils_add_cancel (const char* message) { +#line 790 "DialogUtils.c" + GtkResponseType result = 0; +#line 201 "DialogUtils.vala" + g_return_val_if_fail (message != NULL, 0); +#line 794 "DialogUtils.c" + result = dialog_utils_two_button_dialog (message, GTK_STOCK_CANCEL, GTK_STOCK_ADD); +#line 202 "DialogUtils.vala" + return result; +#line 798 "DialogUtils.c" +} + + +#line 205 "DialogUtils.vala" +GtkResponseType dialog_utils_delete_cancel (const char* message) { +#line 804 "DialogUtils.c" + GtkResponseType result = 0; +#line 205 "DialogUtils.vala" + g_return_val_if_fail (message != NULL, 0); +#line 808 "DialogUtils.c" + result = dialog_utils_two_button_dialog (message, GTK_STOCK_CANCEL, GTK_STOCK_DELETE); +#line 206 "DialogUtils.vala" + return result; +#line 812 "DialogUtils.c" +} + + +#line 209 "DialogUtils.vala" +gboolean dialog_utils_confirm_replace (GtkWindow* parent, const char* filename) { +#line 818 "DialogUtils.c" + gboolean result = FALSE; +#line 209 "DialogUtils.vala" + g_return_val_if_fail ((parent == NULL) || GTK_IS_WINDOW (parent), FALSE); +#line 209 "DialogUtils.vala" + g_return_val_if_fail (filename != NULL, FALSE); +#line 824 "DialogUtils.c" + result = GTK_RESPONSE_YES == dialog_utils_two_button_dialog ("A file named \"%s\" already exists. Do you want to replace it" \ +"?", "Cancel", "Replace"); +#line 210 "DialogUtils.vala" + return result; +#line 828 "DialogUtils.c" +} + + +#line 214 "DialogUtils.vala" +void dialog_utils_button_struct_init (DialogUtilsButtonStruct *self, const char* title, GtkResponseType type) { +#line 834 "DialogUtils.c" + char* _tmp0_; +#line 214 "DialogUtils.vala" + g_return_if_fail (title != NULL); +#line 838 "DialogUtils.c" + memset (self, 0, sizeof (DialogUtilsButtonStruct)); +#line 215 "DialogUtils.vala" + (*self).title = (_tmp0_ = g_strdup (title), _g_free0 ((*self).title), _tmp0_); +#line 216 "DialogUtils.vala" + (*self).type = type; +#line 844 "DialogUtils.c" +} + + +void dialog_utils_button_struct_copy (const DialogUtilsButtonStruct* self, DialogUtilsButtonStruct* dest) { + dest->title = g_strdup (self->title); + dest->type = self->type; +} + + +void dialog_utils_button_struct_destroy (DialogUtilsButtonStruct* self) { + _g_free0 (self->title); +} + + +DialogUtilsButtonStruct* dialog_utils_button_struct_dup (const DialogUtilsButtonStruct* self) { + DialogUtilsButtonStruct* dup; + dup = g_new0 (DialogUtilsButtonStruct, 1); + dialog_utils_button_struct_copy (self, dup); + return dup; +} + + +void dialog_utils_button_struct_free (DialogUtilsButtonStruct* self) { + dialog_utils_button_struct_destroy (self); + g_free (self); +} + + +GType dialog_utils_button_struct_get_type (void) { + static volatile gsize dialog_utils_button_struct_type_id__volatile = 0; + if (g_once_init_enter (&dialog_utils_button_struct_type_id__volatile)) { + GType dialog_utils_button_struct_type_id; + dialog_utils_button_struct_type_id = g_boxed_type_register_static ("DialogUtilsButtonStruct", (GBoxedCopyFunc) dialog_utils_button_struct_dup, (GBoxedFreeFunc) dialog_utils_button_struct_free); + g_once_init_leave (&dialog_utils_button_struct_type_id__volatile, dialog_utils_button_struct_type_id); + } + return dialog_utils_button_struct_type_id__volatile; +} + + +static void _vala_DialogUtilsButtonStruct_array_free (DialogUtilsButtonStruct* array, gint array_length) { + if (array != NULL) { + int i; + for (i = 0; i < array_length; i = i + 1) { + dialog_utils_button_struct_destroy (&array[i]); + } + } + g_free (array); +} + + +#line 223 "DialogUtils.vala" +GtkResponseType dialog_utils_save_close_cancel (GtkWindow* parent, const char* title, const char* message) { +#line 897 "DialogUtils.c" + GtkResponseType result = 0; + DialogUtilsButtonStruct* _tmp4_; + gint _buttons_size_; + gint buttons_length1; + DialogUtilsButtonStruct* _tmp3_ = NULL; + DialogUtilsButtonStruct _tmp0_ = {0}; + DialogUtilsButtonStruct _tmp1_ = {0}; + DialogUtilsButtonStruct _tmp2_ = {0}; + DialogUtilsButtonStruct* buttons; +#line 223 "DialogUtils.vala" + g_return_val_if_fail ((parent == NULL) || GTK_IS_WINDOW (parent), 0); +#line 223 "DialogUtils.vala" + g_return_val_if_fail (message != NULL, 0); +#line 911 "DialogUtils.c" + buttons = (_tmp4_ = (_tmp3_ = g_new0 (DialogUtilsButtonStruct, 3), _tmp3_[0] = (dialog_utils_button_struct_init (&_tmp0_, GTK_STOCK_CLOSE, GTK_RESPONSE_NO), _tmp0_), _tmp3_[1] = (dialog_utils_button_struct_init (&_tmp1_, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL), _tmp1_), _tmp3_[2] = (dialog_utils_button_struct_init (&_tmp2_, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT), _tmp2_), _tmp3_), buttons_length1 = 3, _buttons_size_ = buttons_length1, _tmp4_); + result = dialog_utils_run_dialog (parent, GTK_MESSAGE_WARNING, title, message, buttons, buttons_length1); + buttons = (_vala_DialogUtilsButtonStruct_array_free (buttons, buttons_length1), NULL); +#line 230 "DialogUtils.vala" + return result; +#line 917 "DialogUtils.c" +} + + +#line 233 "DialogUtils.vala" +GtkAlignment* dialog_utils_get_aligned_label (float x, float y, float exp_x, float exp_y, const char* text, gboolean selectable) { +#line 923 "DialogUtils.c" + GtkAlignment* result = NULL; + GtkLabel* l; + GtkAlignment* a; +#line 233 "DialogUtils.vala" + g_return_val_if_fail (text != NULL, NULL); +#line 235 "DialogUtils.vala" + l = g_object_ref_sink ((GtkLabel*) gtk_label_new (text)); +#line 236 "DialogUtils.vala" + gtk_label_set_line_wrap (l, TRUE); +#line 237 "DialogUtils.vala" + gtk_label_set_use_markup (l, TRUE); +#line 238 "DialogUtils.vala" + gtk_label_set_selectable (l, selectable); +#line 240 "DialogUtils.vala" + a = g_object_ref_sink ((GtkAlignment*) gtk_alignment_new (x, y, exp_x, exp_y)); +#line 241 "DialogUtils.vala" + gtk_container_add (GTK_CONTAINER (a), GTK_WIDGET (l)); +#line 941 "DialogUtils.c" + result = a; + _g_object_unref0 (l); +#line 243 "DialogUtils.vala" + return result; +#line 946 "DialogUtils.c" +} + + +#line 246 "DialogUtils.vala" +void dialog_utils_add_label_to_table (GtkTable* t, const char* str, gint x, gint y, gint xpad, gint ypad, gboolean selectable) { +#line 952 "DialogUtils.c" + GtkAlignment* a; +#line 246 "DialogUtils.vala" + g_return_if_fail (GTK_IS_TABLE (t)); +#line 246 "DialogUtils.vala" + g_return_if_fail (str != NULL); +#line 248 "DialogUtils.vala" + a = dialog_utils_get_aligned_label (0.0f, 0.0f, 0.0f, 0.0f, str, selectable); +#line 249 "DialogUtils.vala" + gtk_table_attach (t, GTK_WIDGET (a), (guint) x, (guint) (x + 1), (guint) y, (guint) (y + 1), GTK_FILL, GTK_FILL, (guint) xpad, (guint) ypad); +#line 962 "DialogUtils.c" + _g_object_unref0 (a); +} + + +#line 252 "DialogUtils.vala" +void dialog_utils_show_clip_properties (GtkWindow* parent, ClipView* selected_clip, ModelClipFile* clip_file, Fraction* frames_per_second) { +#line 969 "DialogUtils.c" + HildonDialog* d; + GtkTable* t; + gint row; + gint tab_padding; + char* _tmp2_; +#line 252 "DialogUtils.vala" + g_return_if_fail (GTK_IS_WINDOW (parent)); +#line 252 "DialogUtils.vala" + g_return_if_fail ((selected_clip == NULL) || IS_CLIP_VIEW (selected_clip)); +#line 252 "DialogUtils.vala" + g_return_if_fail ((clip_file == NULL) || MODEL_IS_CLIP_FILE (clip_file)); +#line 254 "DialogUtils.vala" + d = g_object_ref_sink ((HildonDialog*) hildon_dialog_new_with_buttons ("Clip Properties", parent, GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL)); +#line 256 "DialogUtils.vala" + if (selected_clip != NULL) { +#line 257 "DialogUtils.vala" + clip_file = selected_clip->clip->clipfile; +#line 987 "DialogUtils.c" + } +#line 260 "DialogUtils.vala" + g_object_set (G_OBJECT (d), "has-separator", FALSE, NULL); +#line 262 "DialogUtils.vala" + t = g_object_ref_sink ((GtkTable*) gtk_table_new ((guint) 10, (guint) 2, FALSE)); +#line 263 "DialogUtils.vala" + row = 0; +#line 264 "DialogUtils.vala" + tab_padding = 25; +#line 997 "DialogUtils.c" + { + gint i; +#line 266 "DialogUtils.vala" + i = 0; +#line 1002 "DialogUtils.c" + { + gboolean _tmp0_; +#line 266 "DialogUtils.vala" + _tmp0_ = TRUE; +#line 266 "DialogUtils.vala" + while (TRUE) { +#line 266 "DialogUtils.vala" + if (!_tmp0_) { +#line 266 "DialogUtils.vala" + i++; +#line 1013 "DialogUtils.c" + } +#line 266 "DialogUtils.vala" + _tmp0_ = FALSE; +#line 266 "DialogUtils.vala" + if (!(i < 10)) { +#line 266 "DialogUtils.vala" + break; +#line 1021 "DialogUtils.c" + } +#line 267 "DialogUtils.vala" + gtk_table_set_row_spacing (t, (guint) i, (guint) 10); +#line 1025 "DialogUtils.c" + } + } + } +#line 269 "DialogUtils.vala" + row = 1; +#line 270 "DialogUtils.vala" + dialog_utils_add_label_to_table (t, "Clip", 0, row++, 5, 0, FALSE); +#line 272 "DialogUtils.vala" + if (selected_clip != NULL) { +#line 1035 "DialogUtils.c" + char* _tmp1_; +#line 273 "DialogUtils.vala" + dialog_utils_add_label_to_table (t, "Name:", 0, row, tab_padding, 0, FALSE); +#line 274 "DialogUtils.vala" + dialog_utils_add_label_to_table (t, _tmp1_ = g_strdup_printf ("%s", selected_clip->clip->name), 1, row++, 5, 0, TRUE); +#line 1041 "DialogUtils.c" + _g_free0 (_tmp1_); + } +#line 277 "DialogUtils.vala" + dialog_utils_add_label_to_table (t, "Location:", 0, row, tab_padding, 0, FALSE); +#line 278 "DialogUtils.vala" + dialog_utils_add_label_to_table (t, _tmp2_ = g_strdup_printf ("%s", clip_file->filename), 1, row++, 5, 0, TRUE); +#line 1048 "DialogUtils.c" + _g_free0 (_tmp2_); +#line 280 "DialogUtils.vala" + if (selected_clip != NULL) { +#line 1052 "DialogUtils.c" + char* length_string; + char* actual_length; + gboolean _tmp3_ = FALSE; + char* _tmp10_; +#line 281 "DialogUtils.vala" + dialog_utils_add_label_to_table (t, "Timeline length:", 0, row, tab_padding, 0, FALSE); +#line 283 "DialogUtils.vala" + length_string = g_strdup (""); +#line 284 "DialogUtils.vala" + actual_length = g_strdup (""); +#line 286 "DialogUtils.vala" + if (frames_per_second != NULL) { +#line 286 "DialogUtils.vala" + _tmp3_ = (*frames_per_second).numerator > 0; +#line 1067 "DialogUtils.c" + } else { +#line 286 "DialogUtils.vala" + _tmp3_ = FALSE; +#line 1071 "DialogUtils.c" + } +#line 286 "DialogUtils.vala" + if (_tmp3_) { +#line 1075 "DialogUtils.c" + TimeCode _tmp4_ = {0}; + TimeCode time; + char* _tmp5_; + TimeCode _tmp6_ = {0}; + char* _tmp7_; +#line 287 "DialogUtils.vala" + time = (frame_to_time (time_to_frame_with_rate (model_clip_get_duration (selected_clip->clip), frames_per_second), frames_per_second, &_tmp4_), _tmp4_); +#line 289 "DialogUtils.vala" + length_string = (_tmp5_ = time_code_to_string (&time), _g_free0 (length_string), _tmp5_); +#line 290 "DialogUtils.vala" + time = (frame_to_time (time_to_frame_with_rate (model_clip_file_get_length (selected_clip->clip->clipfile), frames_per_second), frames_per_second, &_tmp6_), _tmp6_); +#line 292 "DialogUtils.vala" + actual_length = (_tmp7_ = time_code_to_string (&time), _g_free0 (actual_length), _tmp7_); +#line 1089 "DialogUtils.c" + } else { + char* _tmp8_; + char* _tmp9_; +#line 294 "DialogUtils.vala" + length_string = (_tmp8_ = time_to_string (model_clip_get_duration (selected_clip->clip)), _g_free0 (length_string), _tmp8_); +#line 295 "DialogUtils.vala" + actual_length = (_tmp9_ = time_to_string (model_clip_file_get_length (selected_clip->clip->clipfile)), _g_free0 (actual_length), _tmp9_); +#line 1097 "DialogUtils.c" + } +#line 298 "DialogUtils.vala" + dialog_utils_add_label_to_table (t, _tmp10_ = g_strdup_printf ("%s", length_string), 1, row++, 5, 0, TRUE); +#line 1101 "DialogUtils.c" + _g_free0 (_tmp10_); +#line 300 "DialogUtils.vala" + if (model_clip_is_trimmed (selected_clip->clip)) { +#line 1105 "DialogUtils.c" + char* _tmp11_; +#line 301 "DialogUtils.vala" + dialog_utils_add_label_to_table (t, "Actual length:", 0, row, tab_padding, 0, FALSE); +#line 302 "DialogUtils.vala" + dialog_utils_add_label_to_table (t, _tmp11_ = g_strdup_printf ("%s", actual_length), 1, row++, 5, 0, TRUE); +#line 1111 "DialogUtils.c" + _g_free0 (_tmp11_); + } + _g_free0 (length_string); + _g_free0 (actual_length); + } +#line 306 "DialogUtils.vala" + if (model_clip_file_has_caps_structure (clip_file, MODEL_MEDIA_TYPE_VIDEO)) { +#line 1119 "DialogUtils.c" + gint w = 0; + gint h = 0; + Fraction r = {0}; +#line 307 "DialogUtils.vala" + dialog_utils_add_label_to_table (t, "Video", 0, row++, 5, 0, FALSE); +#line 310 "DialogUtils.vala" + if (model_clip_file_get_dimensions (clip_file, &w, &h)) { +#line 1127 "DialogUtils.c" + char* _tmp12_; +#line 311 "DialogUtils.vala" + dialog_utils_add_label_to_table (t, "Dimensions:", 0, row, tab_padding, 0, FALSE); +#line 312 "DialogUtils.vala" + dialog_utils_add_label_to_table (t, _tmp12_ = g_strdup_printf ("%d x %d", w, h), 1, row++, 5, 0, TRUE); +#line 1133 "DialogUtils.c" + _g_free0 (_tmp12_); + } +#line 316 "DialogUtils.vala" + if (model_clip_file_get_frame_rate (clip_file, &r)) { +#line 317 "DialogUtils.vala" + dialog_utils_add_label_to_table (t, "Frame rate:", 0, row, tab_padding, 0, FALSE); +#line 319 "DialogUtils.vala" + if ((r.numerator % r.denominator) != 0) { +#line 1142 "DialogUtils.c" + char* _tmp13_; +#line 320 "DialogUtils.vala" + dialog_utils_add_label_to_table (t, _tmp13_ = g_strdup_printf ("%.2f frames per second", (double) (r.numerator / ((float) r.denominator))), 1, row++, 5, 0, TRUE); +#line 1146 "DialogUtils.c" + _g_free0 (_tmp13_); + } else { + char* _tmp14_; +#line 324 "DialogUtils.vala" + dialog_utils_add_label_to_table (t, _tmp14_ = g_strdup_printf ("%d frames per second", r.numerator / r.denominator), 1, row++, 5, 0, TRUE); +#line 1152 "DialogUtils.c" + _g_free0 (_tmp14_); + } + } + } +#line 330 "DialogUtils.vala" + if (model_clip_file_has_caps_structure (clip_file, MODEL_MEDIA_TYPE_AUDIO)) { +#line 1159 "DialogUtils.c" + gint rate = 0; + char* s; + char* _tmp18_; + gboolean _tmp17_; + char* _tmp16_ = NULL; +#line 331 "DialogUtils.vala" + dialog_utils_add_label_to_table (t, "Audio", 0, row++, 5, 0, FALSE); +#line 334 "DialogUtils.vala" + if (model_clip_file_get_sample_rate (clip_file, &rate)) { +#line 1169 "DialogUtils.c" + char* _tmp15_; +#line 335 "DialogUtils.vala" + dialog_utils_add_label_to_table (t, "Sample rate:", 0, row, tab_padding, 0, FALSE); +#line 336 "DialogUtils.vala" + dialog_utils_add_label_to_table (t, _tmp15_ = g_strdup_printf ("%d Hz", rate), 1, row++, 5, 0, TRUE); +#line 1175 "DialogUtils.c" + _g_free0 (_tmp15_); + } + s = NULL; +#line 340 "DialogUtils.vala" + if ((_tmp17_ = model_clip_file_get_num_channels_string (clip_file, &_tmp16_), s = (_tmp18_ = _tmp16_, _g_free0 (s), _tmp18_), _tmp17_)) { +#line 1181 "DialogUtils.c" + char* _tmp19_; +#line 341 "DialogUtils.vala" + dialog_utils_add_label_to_table (t, "Number of channels:", 0, row, tab_padding, 0, FALSE); +#line 342 "DialogUtils.vala" + dialog_utils_add_label_to_table (t, _tmp19_ = g_strdup_printf ("%s", s), 1, row++, 5, 0, TRUE); +#line 1187 "DialogUtils.c" + _g_free0 (_tmp19_); + } + _g_free0 (s); + } +#line 346 "DialogUtils.vala" + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (d)->vbox), GTK_WIDGET (t), FALSE, FALSE, (guint) 0); +#line 348 "DialogUtils.vala" + gtk_widget_show_all (GTK_WIDGET (d)); +#line 349 "DialogUtils.vala" + gtk_dialog_run (GTK_DIALOG (d)); +#line 350 "DialogUtils.vala" + gtk_object_destroy (GTK_OBJECT (d)); +#line 1200 "DialogUtils.c" + _g_object_unref0 (d); + _g_object_unref0 (t); +} + + + + diff --git a/src/marina/marina/DialogUtils.o b/src/marina/marina/DialogUtils.o new file mode 100644 index 0000000..4540822 Binary files /dev/null and b/src/marina/marina/DialogUtils.o differ diff --git a/src/marina/marina/Logging.c b/src/marina/marina/Logging.c new file mode 100644 index 0000000..59595c4 --- /dev/null +++ b/src/marina/marina/Logging.c @@ -0,0 +1,127 @@ +/* Logging.c generated by valac, the Vala compiler + * generated from Logging.vala, do not modify */ + +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include + + +#define LOGGING_TYPE_FACILITY (logging_facility_get_type ()) + +#define LOGGING_TYPE_LEVEL (logging_level_get_type ()) + +typedef enum { + LOGGING_FACILITY_SIGNAL_HANDLERS, + LOGGING_FACILITY_DEVELOPER_WARNINGS, + LOGGING_FACILITY_GRAPH, + LOGGING_FACILITY_LOADING, + LOGGING_FACILITY_IMPORT, + LOGGING_FACILITY_SINGLEDECODEBIN +} LoggingFacility; + +typedef enum { + LOGGING_LEVEL_CRITICAL, + LOGGING_LEVEL_HIGH, + LOGGING_LEVEL_MEDIUM, + LOGGING_LEVEL_LOW, + LOGGING_LEVEL_INFO, + LOGGING_LEVEL_VERBOSE +} LoggingLevel; + + +extern LoggingLevel logging_current_level; +LoggingLevel logging_current_level = LOGGING_LEVEL_HIGH; + +GType logging_facility_get_type (void); +GType logging_level_get_type (void); +void logging_set_logging_level (LoggingLevel new_level); +void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message); + +const LoggingLevel LOGGING_active_facility[6] = {LOGGING_LEVEL_CRITICAL, LOGGING_LEVEL_CRITICAL, LOGGING_LEVEL_CRITICAL, LOGGING_LEVEL_CRITICAL, LOGGING_LEVEL_CRITICAL, LOGGING_LEVEL_CRITICAL}; +const char* LOGGING_facility_names[6] = {"SIGNAL_HANDLERS", "DEVELOPER_WARNINGS", "GRAPH", "LOADING", "IMPORT", "SINGLEDECODEBIN"}; + + +GType logging_facility_get_type (void) { + static volatile gsize logging_facility_type_id__volatile = 0; + if (g_once_init_enter (&logging_facility_type_id__volatile)) { + static const GEnumValue values[] = {{LOGGING_FACILITY_SIGNAL_HANDLERS, "LOGGING_FACILITY_SIGNAL_HANDLERS", "signal-handlers"}, {LOGGING_FACILITY_DEVELOPER_WARNINGS, "LOGGING_FACILITY_DEVELOPER_WARNINGS", "developer-warnings"}, {LOGGING_FACILITY_GRAPH, "LOGGING_FACILITY_GRAPH", "graph"}, {LOGGING_FACILITY_LOADING, "LOGGING_FACILITY_LOADING", "loading"}, {LOGGING_FACILITY_IMPORT, "LOGGING_FACILITY_IMPORT", "import"}, {LOGGING_FACILITY_SINGLEDECODEBIN, "LOGGING_FACILITY_SINGLEDECODEBIN", "singledecodebin"}, {0, NULL, NULL}}; + GType logging_facility_type_id; + logging_facility_type_id = g_enum_register_static ("LoggingFacility", values); + g_once_init_leave (&logging_facility_type_id__volatile, logging_facility_type_id); + } + return logging_facility_type_id__volatile; +} + + +GType logging_level_get_type (void) { + static volatile gsize logging_level_type_id__volatile = 0; + if (g_once_init_enter (&logging_level_type_id__volatile)) { + static const GEnumValue values[] = {{LOGGING_LEVEL_CRITICAL, "LOGGING_LEVEL_CRITICAL", "critical"}, {LOGGING_LEVEL_HIGH, "LOGGING_LEVEL_HIGH", "high"}, {LOGGING_LEVEL_MEDIUM, "LOGGING_LEVEL_MEDIUM", "medium"}, {LOGGING_LEVEL_LOW, "LOGGING_LEVEL_LOW", "low"}, {LOGGING_LEVEL_INFO, "LOGGING_LEVEL_INFO", "info"}, {LOGGING_LEVEL_VERBOSE, "LOGGING_LEVEL_VERBOSE", "verbose"}, {0, NULL, NULL}}; + GType logging_level_type_id; + logging_level_type_id = g_enum_register_static ("LoggingLevel", values); + g_once_init_leave (&logging_level_type_id__volatile, logging_level_type_id); + } + return logging_level_type_id__volatile; +} + + +#line 46 "Logging.vala" +void logging_set_logging_level (LoggingLevel new_level) { +#line 79 "Logging.c" + gboolean _tmp0_ = FALSE; +#line 47 "Logging.vala" + if (new_level <= LOGGING_LEVEL_VERBOSE) { +#line 47 "Logging.vala" + _tmp0_ = new_level >= LOGGING_LEVEL_CRITICAL; +#line 85 "Logging.c" + } else { +#line 47 "Logging.vala" + _tmp0_ = FALSE; +#line 89 "Logging.c" + } +#line 47 "Logging.vala" + if (_tmp0_) { +#line 48 "Logging.vala" + logging_current_level = new_level; +#line 95 "Logging.c" + } +} + + +#line 52 "Logging.vala" +void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message) { +#line 102 "Logging.c" + gboolean _tmp0_ = FALSE; +#line 52 "Logging.vala" + g_return_if_fail (G_IS_OBJECT (object)); +#line 52 "Logging.vala" + g_return_if_fail (message != NULL); +#line 53 "Logging.vala" + if (level <= logging_current_level) { +#line 53 "Logging.vala" + _tmp0_ = TRUE; +#line 112 "Logging.c" + } else { +#line 53 "Logging.vala" + _tmp0_ = level <= LOGGING_active_facility[facility]; +#line 116 "Logging.c" + } +#line 53 "Logging.vala" + if (_tmp0_) { +#line 54 "Logging.vala" + fprintf (stderr, "%s(%s): %s\n", g_type_name (G_TYPE_FROM_INSTANCE (object)), LOGGING_facility_names[facility], message); +#line 122 "Logging.c" + } +} + + + + diff --git a/src/marina/marina/Logging.o b/src/marina/marina/Logging.o new file mode 100644 index 0000000..711e114 Binary files /dev/null and b/src/marina/marina/Logging.o differ diff --git a/src/marina/marina/MediaEngine.c b/src/marina/marina/MediaEngine.c new file mode 100644 index 0000000..47ab326 --- /dev/null +++ b/src/marina/marina/MediaEngine.c @@ -0,0 +1,5111 @@ +/* MediaEngine.c generated by valac, the Vala compiler + * generated from MediaEngine.vala, do not modify */ + +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#define TYPE_PLAY_STATE (play_state_get_type ()) + +#define VIEW_TYPE_MEDIA_CLIP (view_media_clip_get_type ()) +#define VIEW_MEDIA_CLIP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_CLIP, ViewMediaClip)) +#define VIEW_MEDIA_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_CLIP, ViewMediaClipClass)) +#define VIEW_IS_MEDIA_CLIP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_CLIP)) +#define VIEW_IS_MEDIA_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_CLIP)) +#define VIEW_MEDIA_CLIP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_CLIP, ViewMediaClipClass)) + +typedef struct _ViewMediaClip ViewMediaClip; +typedef struct _ViewMediaClipClass ViewMediaClipClass; +typedef struct _ViewMediaClipPrivate ViewMediaClipPrivate; + +#define MODEL_TYPE_CLIP (model_clip_get_type ()) +#define MODEL_CLIP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP, ModelClip)) +#define MODEL_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP, ModelClipClass)) +#define MODEL_IS_CLIP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP)) +#define MODEL_IS_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP)) +#define MODEL_CLIP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP, ModelClipClass)) + +typedef struct _ModelClip ModelClip; +typedef struct _ModelClipClass ModelClipClass; +#define _gst_object_unref0(var) ((var == NULL) ? NULL : (var = (gst_object_unref (var), NULL))) +typedef struct _ModelClipPrivate ModelClipPrivate; + +#define MODEL_TYPE_CLIP_FILE (model_clip_file_get_type ()) +#define MODEL_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFile)) +#define MODEL_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) +#define MODEL_IS_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE)) +#define MODEL_IS_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE)) +#define MODEL_CLIP_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) + +typedef struct _ModelClipFile ModelClipFile; +typedef struct _ModelClipFileClass ModelClipFileClass; + +#define MODEL_TYPE_MEDIA_TYPE (model_media_type_get_type ()) + +#define LOGGING_TYPE_FACILITY (logging_facility_get_type ()) + +#define LOGGING_TYPE_LEVEL (logging_level_get_type ()) + +#define TYPE_SINGLE_DECODE_BIN (single_decode_bin_get_type ()) +#define SINGLE_DECODE_BIN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SINGLE_DECODE_BIN, SingleDecodeBin)) +#define SINGLE_DECODE_BIN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SINGLE_DECODE_BIN, SingleDecodeBinClass)) +#define IS_SINGLE_DECODE_BIN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SINGLE_DECODE_BIN)) +#define IS_SINGLE_DECODE_BIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SINGLE_DECODE_BIN)) +#define SINGLE_DECODE_BIN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SINGLE_DECODE_BIN, SingleDecodeBinClass)) + +typedef struct _SingleDecodeBin SingleDecodeBin; +typedef struct _SingleDecodeBinClass SingleDecodeBinClass; +#define _gst_caps_unref0(var) ((var == NULL) ? NULL : (var = (gst_caps_unref (var), NULL))) + +#define VIEW_TYPE_MEDIA_AUDIO_CLIP (view_media_audio_clip_get_type ()) +#define VIEW_MEDIA_AUDIO_CLIP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_AUDIO_CLIP, ViewMediaAudioClip)) +#define VIEW_MEDIA_AUDIO_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_AUDIO_CLIP, ViewMediaAudioClipClass)) +#define VIEW_IS_MEDIA_AUDIO_CLIP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_AUDIO_CLIP)) +#define VIEW_IS_MEDIA_AUDIO_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_AUDIO_CLIP)) +#define VIEW_MEDIA_AUDIO_CLIP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_AUDIO_CLIP, ViewMediaAudioClipClass)) + +typedef struct _ViewMediaAudioClip ViewMediaAudioClip; +typedef struct _ViewMediaAudioClipClass ViewMediaAudioClipClass; +typedef struct _ViewMediaAudioClipPrivate ViewMediaAudioClipPrivate; + +#define VIEW_TYPE_MEDIA_VIDEO_CLIP (view_media_video_clip_get_type ()) +#define VIEW_MEDIA_VIDEO_CLIP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_VIDEO_CLIP, ViewMediaVideoClip)) +#define VIEW_MEDIA_VIDEO_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_VIDEO_CLIP, ViewMediaVideoClipClass)) +#define VIEW_IS_MEDIA_VIDEO_CLIP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_VIDEO_CLIP)) +#define VIEW_IS_MEDIA_VIDEO_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_VIDEO_CLIP)) +#define VIEW_MEDIA_VIDEO_CLIP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_VIDEO_CLIP, ViewMediaVideoClipClass)) + +typedef struct _ViewMediaVideoClip ViewMediaVideoClip; +typedef struct _ViewMediaVideoClipClass ViewMediaVideoClipClass; +typedef struct _ViewMediaVideoClipPrivate ViewMediaVideoClipPrivate; + +#define VIEW_TYPE_MEDIA_TRACK (view_media_track_get_type ()) +#define VIEW_MEDIA_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_TRACK, ViewMediaTrack)) +#define VIEW_MEDIA_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_TRACK, ViewMediaTrackClass)) +#define VIEW_IS_MEDIA_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_TRACK)) +#define VIEW_IS_MEDIA_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_TRACK)) +#define VIEW_MEDIA_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_TRACK, ViewMediaTrackClass)) + +typedef struct _ViewMediaTrack ViewMediaTrack; +typedef struct _ViewMediaTrackClass ViewMediaTrackClass; +typedef struct _ViewMediaTrackPrivate ViewMediaTrackPrivate; + +#define VIEW_TYPE_MEDIA_ENGINE (view_media_engine_get_type ()) +#define VIEW_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngine)) +#define VIEW_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass)) +#define VIEW_IS_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_ENGINE)) +#define VIEW_IS_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_ENGINE)) +#define VIEW_MEDIA_ENGINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass)) + +typedef struct _ViewMediaEngine ViewMediaEngine; +typedef struct _ViewMediaEngineClass ViewMediaEngineClass; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) + +#define MODEL_TYPE_TRACK (model_track_get_type ()) +#define MODEL_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TRACK, ModelTrack)) +#define MODEL_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TRACK, ModelTrackClass)) +#define MODEL_IS_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TRACK)) +#define MODEL_IS_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TRACK)) +#define MODEL_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TRACK, ModelTrackClass)) + +typedef struct _ModelTrack ModelTrack; +typedef struct _ModelTrackClass ModelTrackClass; + +#define TYPE_MULTI_FILE_PROGRESS_INTERFACE (multi_file_progress_interface_get_type ()) +#define MULTI_FILE_PROGRESS_INTERFACE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MULTI_FILE_PROGRESS_INTERFACE, MultiFileProgressInterface)) +#define IS_MULTI_FILE_PROGRESS_INTERFACE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MULTI_FILE_PROGRESS_INTERFACE)) +#define MULTI_FILE_PROGRESS_INTERFACE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_MULTI_FILE_PROGRESS_INTERFACE, MultiFileProgressInterfaceIface)) + +typedef struct _MultiFileProgressInterface MultiFileProgressInterface; +typedef struct _MultiFileProgressInterfaceIface MultiFileProgressInterfaceIface; +typedef struct _ViewMediaEnginePrivate ViewMediaEnginePrivate; + +#define MODEL_TYPE_AUDIO_TRACK (model_audio_track_get_type ()) +#define MODEL_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrack)) +#define MODEL_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrackClass)) +#define MODEL_IS_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_AUDIO_TRACK)) +#define MODEL_IS_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_AUDIO_TRACK)) +#define MODEL_AUDIO_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrackClass)) + +typedef struct _ModelAudioTrack ModelAudioTrack; +typedef struct _ModelAudioTrackClass ModelAudioTrackClass; +typedef struct _ModelClipFilePrivate ModelClipFilePrivate; +#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL))) + +#define VIEW_TYPE_MEDIA_VIDEO_TRACK (view_media_video_track_get_type ()) +#define VIEW_MEDIA_VIDEO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_VIDEO_TRACK, ViewMediaVideoTrack)) +#define VIEW_MEDIA_VIDEO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_VIDEO_TRACK, ViewMediaVideoTrackClass)) +#define VIEW_IS_MEDIA_VIDEO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_VIDEO_TRACK)) +#define VIEW_IS_MEDIA_VIDEO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_VIDEO_TRACK)) +#define VIEW_MEDIA_VIDEO_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_VIDEO_TRACK, ViewMediaVideoTrackClass)) + +typedef struct _ViewMediaVideoTrack ViewMediaVideoTrack; +typedef struct _ViewMediaVideoTrackClass ViewMediaVideoTrackClass; +typedef struct _ViewMediaVideoTrackPrivate ViewMediaVideoTrackPrivate; + +#define VIEW_TYPE_CLICK_TRACK (view_click_track_get_type ()) +#define VIEW_CLICK_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_CLICK_TRACK, ViewClickTrack)) +#define VIEW_CLICK_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_CLICK_TRACK, ViewClickTrackClass)) +#define VIEW_IS_CLICK_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_CLICK_TRACK)) +#define VIEW_IS_CLICK_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_CLICK_TRACK)) +#define VIEW_CLICK_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_CLICK_TRACK, ViewClickTrackClass)) + +typedef struct _ViewClickTrack ViewClickTrack; +typedef struct _ViewClickTrackClass ViewClickTrackClass; +typedef struct _ViewClickTrackPrivate ViewClickTrackPrivate; + +#define MODEL_TYPE_PROJECT (model_project_get_type ()) +#define MODEL_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT, ModelProject)) +#define MODEL_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT, ModelProjectClass)) +#define MODEL_IS_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT)) +#define MODEL_IS_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT)) +#define MODEL_PROJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT, ModelProjectClass)) + +typedef struct _ModelProject ModelProject; +typedef struct _ModelProjectClass ModelProjectClass; + +#define MODEL_TYPE_TEMPO_INFORMATION (model_tempo_information_get_type ()) +#define MODEL_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformation)) +#define MODEL_IS_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TEMPO_INFORMATION)) +#define MODEL_TEMPO_INFORMATION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformationIface)) + +typedef struct _ModelTempoInformation ModelTempoInformation; +typedef struct _ModelTempoInformationIface ModelTempoInformationIface; + +#define TYPE_FRACTION (fraction_get_type ()) +typedef struct _Fraction Fraction; +typedef struct _ModelProjectPrivate ModelProjectPrivate; + +#define TYPE_TIME_CODE (time_code_get_type ()) +typedef struct _TimeCode TimeCode; + +#define MODEL_TYPE_PROJECT_LOADER (model_project_loader_get_type ()) +#define MODEL_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoader)) +#define MODEL_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass)) +#define MODEL_IS_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT_LOADER)) +#define MODEL_IS_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT_LOADER)) +#define MODEL_PROJECT_LOADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass)) + +typedef struct _ModelProjectLoader ModelProjectLoader; +typedef struct _ModelProjectLoaderClass ModelProjectLoaderClass; + +#define MODEL_TYPE_UNDO_MANAGER (model_undo_manager_get_type ()) +#define MODEL_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManager)) +#define MODEL_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass)) +#define MODEL_IS_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_UNDO_MANAGER)) +#define MODEL_IS_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_UNDO_MANAGER)) +#define MODEL_UNDO_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass)) + +typedef struct _ModelUndoManager ModelUndoManager; +typedef struct _ModelUndoManagerClass ModelUndoManagerClass; + +#define MODEL_TYPE_LIBRARY_IMPORTER (model_library_importer_get_type ()) +#define MODEL_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporter)) +#define MODEL_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass)) +#define MODEL_IS_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_LIBRARY_IMPORTER)) +#define MODEL_IS_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_LIBRARY_IMPORTER)) +#define MODEL_LIBRARY_IMPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass)) + +typedef struct _ModelLibraryImporter ModelLibraryImporter; +typedef struct _ModelLibraryImporterClass ModelLibraryImporterClass; +#define __g_list_free_g_free0(var) ((var == NULL) ? NULL : (var = (_g_list_free_g_free (var), NULL))) + +#define VIEW_TYPE_MEDIA_AUDIO_TRACK (view_media_audio_track_get_type ()) +#define VIEW_MEDIA_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_AUDIO_TRACK, ViewMediaAudioTrack)) +#define VIEW_MEDIA_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_AUDIO_TRACK, ViewMediaAudioTrackClass)) +#define VIEW_IS_MEDIA_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_AUDIO_TRACK)) +#define VIEW_IS_MEDIA_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_AUDIO_TRACK)) +#define VIEW_MEDIA_AUDIO_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_AUDIO_TRACK, ViewMediaAudioTrackClass)) + +typedef struct _ViewMediaAudioTrack ViewMediaAudioTrack; +typedef struct _ViewMediaAudioTrackClass ViewMediaAudioTrackClass; +typedef struct _ViewMediaAudioTrackPrivate ViewMediaAudioTrackPrivate; + +#define MODEL_TYPE_PARAMETER (model_parameter_get_type ()) + +#define VIEW_TYPE_MEDIA_CONNECTOR (view_media_connector_get_type ()) +#define VIEW_MEDIA_CONNECTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_CONNECTOR, ViewMediaConnector)) +#define VIEW_MEDIA_CONNECTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_CONNECTOR, ViewMediaConnectorClass)) +#define VIEW_IS_MEDIA_CONNECTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_CONNECTOR)) +#define VIEW_IS_MEDIA_CONNECTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_CONNECTOR)) +#define VIEW_MEDIA_CONNECTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_CONNECTOR, ViewMediaConnectorClass)) + +typedef struct _ViewMediaConnector ViewMediaConnector; +typedef struct _ViewMediaConnectorClass ViewMediaConnectorClass; +typedef struct _ViewMediaConnectorPrivate ViewMediaConnectorPrivate; + +#define VIEW_MEDIA_CONNECTOR_TYPE_MEDIA_TYPES (view_media_connector_media_types_get_type ()) + +#define VIEW_TYPE_VIDEO_OUTPUT (view_video_output_get_type ()) +#define VIEW_VIDEO_OUTPUT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_VIDEO_OUTPUT, ViewVideoOutput)) +#define VIEW_VIDEO_OUTPUT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_VIDEO_OUTPUT, ViewVideoOutputClass)) +#define VIEW_IS_VIDEO_OUTPUT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_VIDEO_OUTPUT)) +#define VIEW_IS_VIDEO_OUTPUT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_VIDEO_OUTPUT)) +#define VIEW_VIDEO_OUTPUT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_VIDEO_OUTPUT, ViewVideoOutputClass)) + +typedef struct _ViewVideoOutput ViewVideoOutput; +typedef struct _ViewVideoOutputClass ViewVideoOutputClass; +typedef struct _ViewVideoOutputPrivate ViewVideoOutputPrivate; + +#define VIEW_TYPE_AUDIO_OUTPUT (view_audio_output_get_type ()) +#define VIEW_AUDIO_OUTPUT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_AUDIO_OUTPUT, ViewAudioOutput)) +#define VIEW_AUDIO_OUTPUT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_AUDIO_OUTPUT, ViewAudioOutputClass)) +#define VIEW_IS_AUDIO_OUTPUT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_AUDIO_OUTPUT)) +#define VIEW_IS_AUDIO_OUTPUT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_AUDIO_OUTPUT)) +#define VIEW_AUDIO_OUTPUT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_AUDIO_OUTPUT, ViewAudioOutputClass)) + +typedef struct _ViewAudioOutput ViewAudioOutput; +typedef struct _ViewAudioOutputClass ViewAudioOutputClass; +typedef struct _ViewAudioOutputPrivate ViewAudioOutputPrivate; + +#define VIEW_TYPE_OGG_VORBIS_EXPORT (view_ogg_vorbis_export_get_type ()) +#define VIEW_OGG_VORBIS_EXPORT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_OGG_VORBIS_EXPORT, ViewOggVorbisExport)) +#define VIEW_OGG_VORBIS_EXPORT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_OGG_VORBIS_EXPORT, ViewOggVorbisExportClass)) +#define VIEW_IS_OGG_VORBIS_EXPORT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_OGG_VORBIS_EXPORT)) +#define VIEW_IS_OGG_VORBIS_EXPORT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_OGG_VORBIS_EXPORT)) +#define VIEW_OGG_VORBIS_EXPORT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_OGG_VORBIS_EXPORT, ViewOggVorbisExportClass)) + +typedef struct _ViewOggVorbisExport ViewOggVorbisExport; +typedef struct _ViewOggVorbisExportClass ViewOggVorbisExportClass; +typedef struct _ViewOggVorbisExportPrivate ViewOggVorbisExportPrivate; +#define _g_free0(var) (var = (g_free (var), NULL)) +typedef struct _ModelTrackPrivate ModelTrackPrivate; + +typedef enum { + PLAY_STATE_STOPPED, + PLAY_STATE_PRE_PLAY, + PLAY_STATE_PLAYING, + PLAY_STATE_PRE_RECORD_NULL, + PLAY_STATE_PRE_RECORD, + PLAY_STATE_RECORDING, + PLAY_STATE_POST_RECORD, + PLAY_STATE_PRE_EXPORT, + PLAY_STATE_EXPORTING, + PLAY_STATE_CANCEL_EXPORT, + PLAY_STATE_LOADING, + PLAY_STATE_CLOSING, + PLAY_STATE_CLOSED +} PlayState; + +struct _ViewMediaClip { + GObject parent_instance; + ViewMediaClipPrivate * priv; + GstElement* file_source; +}; + +struct _ViewMediaClipClass { + GObjectClass parent_class; +}; + +struct _ViewMediaClipPrivate { + ModelClip* clip; + GstBin* composition; +}; + +typedef enum { + MODEL_MEDIA_TYPE_AUDIO, + MODEL_MEDIA_TYPE_VIDEO +} ModelMediaType; + +struct _ModelClip { + GObject parent_instance; + ModelClipPrivate * priv; + ModelClipFile* clipfile; + ModelMediaType type; + gboolean is_recording; + char* name; +}; + +struct _ModelClipClass { + GObjectClass parent_class; +}; + +typedef enum { + LOGGING_FACILITY_SIGNAL_HANDLERS, + LOGGING_FACILITY_DEVELOPER_WARNINGS, + LOGGING_FACILITY_GRAPH, + LOGGING_FACILITY_LOADING, + LOGGING_FACILITY_IMPORT, + LOGGING_FACILITY_SINGLEDECODEBIN +} LoggingFacility; + +typedef enum { + LOGGING_LEVEL_CRITICAL, + LOGGING_LEVEL_HIGH, + LOGGING_LEVEL_MEDIUM, + LOGGING_LEVEL_LOW, + LOGGING_LEVEL_INFO, + LOGGING_LEVEL_VERBOSE +} LoggingLevel; + +struct _ViewMediaAudioClip { + ViewMediaClip parent_instance; + ViewMediaAudioClipPrivate * priv; +}; + +struct _ViewMediaAudioClipClass { + ViewMediaClipClass parent_class; +}; + +struct _ViewMediaVideoClip { + ViewMediaClip parent_instance; + ViewMediaVideoClipPrivate * priv; +}; + +struct _ViewMediaVideoClipClass { + ViewMediaClipClass parent_class; +}; + +struct _ViewMediaTrack { + GObject parent_instance; + ViewMediaTrackPrivate * priv; + ViewMediaEngine* media_engine; + GstBin* composition; + GstElement* default_source; + GstElement* sink; +}; + +struct _ViewMediaTrackClass { + GObjectClass parent_class; + GstElement* (*empty_element) (ViewMediaTrack* self, GError** error); + GstElement* (*get_element) (ViewMediaTrack* self); + void (*link_new_pad) (ViewMediaTrack* self, GstPad* pad, GstElement* track_element); + void (*unlink_pad) (ViewMediaTrack* self, GstPad* pad, GstElement* track_element); +}; + +struct _ViewMediaTrackPrivate { + GeeArrayList* clips; +}; + +struct _MultiFileProgressInterfaceIface { + GTypeInterface parent_iface; + void (*cancel) (MultiFileProgressInterface* self); + void (*complete) (MultiFileProgressInterface* self); +}; + +struct _ViewMediaEngine { + GObject parent_instance; + ViewMediaEnginePrivate * priv; + GstPipeline* pipeline; + GstBin* record_bin; + GstElement* converter; + GstElement* adder; + GstState gst_state; + PlayState play_state; + gint64 position; + gboolean playing; + ModelAudioTrack* record_track; + ModelClip* record_region; +}; + +struct _ViewMediaEngineClass { + GObjectClass parent_class; + void (*do_null_state_export) (ViewMediaEngine* self, gint64 length); + void (*pause) (ViewMediaEngine* self); +}; + +struct _ModelClipFile { + GObject parent_instance; + ModelClipFilePrivate * priv; + char* filename; + GstCaps* video_caps; + GstCaps* audio_caps; + GdkPixbuf* thumbnail; +}; + +struct _ModelClipFileClass { + GObjectClass parent_class; +}; + +struct _ViewMediaVideoTrack { + ViewMediaTrack parent_instance; + ViewMediaVideoTrackPrivate * priv; +}; + +struct _ViewMediaVideoTrackClass { + ViewMediaTrackClass parent_class; +}; + +struct _ViewMediaVideoTrackPrivate { + GstElement* converter; +}; + +struct _ViewClickTrack { + GObject parent_instance; + ViewClickTrackPrivate * priv; +}; + +struct _ViewClickTrackClass { + GObjectClass parent_class; +}; + +struct _ViewClickTrackPrivate { + GstController* click_controller; + GstController* volume_controller; + GstElement* audio_source; + GstElement* audio_convert; + GstElement* volume; + ModelProject* project; +}; + +struct _Fraction { + gint numerator; + gint denominator; +}; + +struct _ModelTempoInformationIface { + GTypeInterface parent_iface; + void (*get_time_signature) (ModelTempoInformation* self, Fraction* result); + gint (*get_bpm) (ModelTempoInformation* self); +}; + +struct _TimeCode { + gint hour; + gint minute; + gint second; + gint frame; + gboolean drop_code; +}; + +struct _ModelProject { + GObject parent_instance; + ModelProjectPrivate * priv; + GeeArrayList* tracks; + GeeArrayList* inactive_tracks; + GeeArrayList* clipfiles; + ViewMediaEngine* media_engine; + char* project_file; + ModelProjectLoader* loader; + ModelUndoManager* undo_manager; + ModelLibraryImporter* importer; + Fraction default_framerate; + gboolean click_during_play; + gboolean click_during_record; + double click_volume; + gboolean library_visible; + gint library_width; + gboolean snap_to_clip; +}; + +struct _ModelProjectClass { + GObjectClass parent_class; + void (*get_clip_time) (ModelProject* self, ModelClipFile* f, TimeCode* result); + char* (*get_project_file) (ModelProject* self); + void (*do_append) (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, const char* name, gint64 insert_time); + void (*add_track) (ModelProject* self, ModelTrack* track); + void (*insert_track) (ModelProject* self, gint index, ModelTrack* track); + void (*load) (ModelProject* self, const char* fname); + void (*save) (ModelProject* self, const char* filename); + char* (*get_app_name) (ModelProject* self); + void (*load_complete) (ModelProject* self); +}; + +struct _ViewMediaAudioTrack { + ViewMediaTrack parent_instance; + ViewMediaAudioTrackPrivate * priv; +}; + +struct _ViewMediaAudioTrackClass { + ViewMediaTrackClass parent_class; +}; + +struct _ViewMediaAudioTrackPrivate { + GstElement* audio_convert; + GstElement* audio_resample; + GstElement* level; + GstElement* pan; + GstElement* volume; + GstPad* adder_pad; +}; + +typedef enum { + MODEL_PARAMETER_PAN, + MODEL_PARAMETER_VOLUME +} ModelParameter; + +struct _ViewMediaConnector { + GObject parent_instance; + ViewMediaConnectorPrivate * priv; + gint AudioIndex; + gint VideoIndex; +}; + +struct _ViewMediaConnectorClass { + GObjectClass parent_class; + void (*connect) (ViewMediaConnector* self, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1); + void (*do_disconnect) (ViewMediaConnector* self, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1); +}; + +typedef enum { + VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Audio = 1, + VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Video = 2 +} ViewMediaConnectorMediaTypes; + +struct _ViewMediaConnectorPrivate { + ViewMediaConnectorMediaTypes media_types; +}; + +struct _ViewVideoOutput { + ViewMediaConnector parent_instance; + ViewVideoOutputPrivate * priv; +}; + +struct _ViewVideoOutputClass { + ViewMediaConnectorClass parent_class; +}; + +struct _ViewVideoOutputPrivate { + GstElement* sink; + GtkWidget* output_widget; +}; + +struct _ViewAudioOutput { + ViewMediaConnector parent_instance; + ViewAudioOutputPrivate * priv; +}; + +struct _ViewAudioOutputClass { + ViewMediaConnectorClass parent_class; +}; + +struct _ViewAudioOutputPrivate { + GstElement* audio_sink; + GstElement* capsfilter; +}; + +struct _ViewOggVorbisExport { + ViewMediaConnector parent_instance; + ViewOggVorbisExportPrivate * priv; +}; + +struct _ViewOggVorbisExportClass { + ViewMediaConnectorClass parent_class; +}; + +struct _ViewOggVorbisExportPrivate { + GstElement* capsfilter; + GstElement* export_sink; + GstElement* mux; + GstElement* file_sink; + GstElement* video_export_sink; +}; + +struct _ViewMediaEnginePrivate { + guint callback_id; + GstElement* audio_in; + GstElement* record_capsfilter; + GstElement* wav_encoder; + GstElement* record_sink; + ModelProject* project; + GeeArrayList* tracks; +}; + +typedef enum { + MEDIA_ERROR_MISSING_PLUGIN +} MediaError; +#define MEDIA_ERROR media_error_quark () +struct _ModelTrack { + GObject parent_instance; + ModelTrackPrivate * priv; + ModelProject* project; + GeeArrayList* clips; + char* display_name; +}; + +struct _ModelTrackClass { + GObjectClass parent_class; + char* (*name) (ModelTrack* self); + ModelMediaType (*media_type) (ModelTrack* self); + gboolean (*check) (ModelTrack* self, ModelClip* clip); + void (*on_clip_updated) (ModelTrack* self, ModelClip* clip); + void (*write_attributes) (ModelTrack* self, FILE* f); +}; + + +static gpointer view_media_clip_parent_class = NULL; +static gpointer view_media_audio_clip_parent_class = NULL; +static gpointer view_media_video_clip_parent_class = NULL; +static gpointer view_media_track_parent_class = NULL; +static gpointer view_media_video_track_parent_class = NULL; +static gpointer view_click_track_parent_class = NULL; +static gpointer view_media_audio_track_parent_class = NULL; +static gpointer view_media_connector_parent_class = NULL; +static gpointer view_video_output_parent_class = NULL; +static gpointer view_audio_output_parent_class = NULL; +static gpointer view_ogg_vorbis_export_parent_class = NULL; +static gpointer view_media_engine_parent_class = NULL; +static MultiFileProgressInterfaceIface* view_media_engine_multi_file_progress_interface_parent_iface = NULL; + +GType play_state_get_type (void); +#define CHANNELS_PER_TRACK_PLAYBACK 2 +#define CHANNELS_PER_TRACK_RECORD 1 +GType view_media_clip_get_type (void); +GType model_clip_get_type (void); +#define VIEW_MEDIA_CLIP_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIEW_TYPE_MEDIA_CLIP, ViewMediaClipPrivate)) +enum { + VIEW_MEDIA_CLIP_DUMMY_PROPERTY +}; +GstElement* make_element (const char* name, GError** error); +GType model_clip_file_get_type (void); +GType model_media_type_get_type (void); +static void view_media_clip_on_duration_changed (ViewMediaClip* self, gint64 duration); +static void _view_media_clip_on_duration_changed_model_clip_duration_changed (ModelClip* _sender, gint64 duration, gpointer self); +static void view_media_clip_on_media_start_changed (ViewMediaClip* self, gint64 media_start); +static void _view_media_clip_on_media_start_changed_model_clip_media_start_changed (ModelClip* _sender, gint64 media_start, gpointer self); +static void view_media_clip_on_start_changed (ViewMediaClip* self, gint64 start); +static void _view_media_clip_on_start_changed_model_clip_start_changed (ModelClip* _sender, gint64 start, gpointer self); +gint64 model_clip_get_start (ModelClip* self); +gint64 model_clip_get_media_start (ModelClip* self); +gint64 model_clip_get_duration (ModelClip* self); +void view_media_clip_on_clip_removed (ViewMediaClip* self); +static void _view_media_clip_on_clip_removed_model_clip_removed (ModelClip* _sender, ModelClip* clip, gpointer self); +ViewMediaClip* view_media_clip_new (GstBin* composition, ModelClip* clip, GError** error); +ViewMediaClip* view_media_clip_construct (GType object_type, GstBin* composition, ModelClip* clip, GError** error); +GType logging_facility_get_type (void); +GType logging_level_get_type (void); +void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message); +SingleDecodeBin* single_decode_bin_new (GstCaps* caps, const char* name, const char* uri, GError** error); +SingleDecodeBin* single_decode_bin_construct (GType object_type, GstCaps* caps, const char* name, const char* uri, GError** error); +GType single_decode_bin_get_type (void); +void model_clip_file_set_online (ModelClipFile* self, gboolean o); +void view_media_clip_add_single_decode_bin (ViewMediaClip* self, const char* filename, const char* caps, GError** error); +gboolean view_media_clip_is_equal (ViewMediaClip* self, ModelClip* clip); +static void view_media_clip_finalize (GObject* obj); +GType view_media_audio_clip_get_type (void); +enum { + VIEW_MEDIA_AUDIO_CLIP_DUMMY_PROPERTY +}; +ViewMediaAudioClip* view_media_audio_clip_new (GstBin* composition, ModelClip* clip, const char* filename, GError** error); +ViewMediaAudioClip* view_media_audio_clip_construct (GType object_type, GstBin* composition, ModelClip* clip, const char* filename, GError** error); +GType view_media_video_clip_get_type (void); +enum { + VIEW_MEDIA_VIDEO_CLIP_DUMMY_PROPERTY +}; +ViewMediaVideoClip* view_media_video_clip_new (GstBin* composition, ModelClip* clip, const char* filename, GError** error); +ViewMediaVideoClip* view_media_video_clip_construct (GType object_type, GstBin* composition, ModelClip* clip, const char* filename, GError** error); +GType view_media_track_get_type (void); +GType view_media_engine_get_type (void); +#define VIEW_MEDIA_TRACK_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIEW_TYPE_MEDIA_TRACK, ViewMediaTrackPrivate)) +enum { + VIEW_MEDIA_TRACK_DUMMY_PROPERTY +}; +static void view_media_track_on_clip_added (ViewMediaTrack* self, ModelClip* clip); +GType model_track_get_type (void); +static void _view_media_track_on_clip_added_model_track_clip_added (ModelTrack* _sender, ModelClip* clip, gboolean select, gpointer self); +static void view_media_track_on_track_removed (ViewMediaTrack* self, ModelTrack* track); +static void _view_media_track_on_track_removed_model_track_track_removed (ModelTrack* _sender, ModelTrack* track, gpointer self); +static void view_media_track_on_pre_export (ViewMediaTrack* self, gint64 length); +static void _view_media_track_on_pre_export_view_media_engine_pre_export (ViewMediaEngine* _sender, gint64 length, gpointer self); +static void view_media_track_on_post_export (ViewMediaTrack* self, gboolean deleted); +static void _view_media_track_on_post_export_view_media_engine_post_export (ViewMediaEngine* _sender, gboolean canceled, gpointer self); +GstElement* make_element_with_name (const char* element_name, const char* display_name, GError** error); +GstElement* view_media_track_empty_element (ViewMediaTrack* self, GError** error); +GType multi_file_progress_interface_get_type (void); +GType model_audio_track_get_type (void); +static void view_media_track_on_pad_added (ViewMediaTrack* self, GstPad* pad); +static void _view_media_track_on_pad_added_gst_element_pad_added (GstElement* _sender, GstPad* pad, gpointer self); +static void view_media_track_on_pad_removed (ViewMediaTrack* self, GstPad* pad); +static void _view_media_track_on_pad_removed_gst_element_pad_removed (GstElement* _sender, GstPad* pad, gpointer self); +ViewMediaTrack* view_media_track_construct (GType object_type, ViewMediaEngine* media_engine, ModelTrack* track, GError** error); +static GstElement* view_media_track_real_empty_element (ViewMediaTrack* self, GError** error); +GstElement* view_media_track_get_element (ViewMediaTrack* self); +static GstElement* view_media_track_real_get_element (ViewMediaTrack* self); +void view_media_track_link_new_pad (ViewMediaTrack* self, GstPad* pad, GstElement* track_element); +static void view_media_track_real_link_new_pad (ViewMediaTrack* self, GstPad* pad, GstElement* track_element); +void view_media_track_unlink_pad (ViewMediaTrack* self, GstPad* pad, GstElement* track_element); +static void view_media_track_real_unlink_pad (ViewMediaTrack* self, GstPad* pad, GstElement* track_element); +static void view_media_track_on_clip_updated (ViewMediaTrack* self, ModelClip* clip); +static void _view_media_track_on_clip_updated_model_clip_updated (ModelClip* _sender, ModelClip* clip, gpointer self); +gboolean model_clip_file_is_online (ModelClipFile* self); +static void view_media_track_on_media_clip_removed (ViewMediaTrack* self, ViewMediaClip* clip); +static void _view_media_track_on_media_clip_removed_view_media_clip_clip_removed (ViewMediaClip* _sender, ViewMediaClip* clip, gpointer self); +static void view_media_track_finalize (GObject* obj); +GType view_media_video_track_get_type (void); +#define VIEW_MEDIA_VIDEO_TRACK_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIEW_TYPE_MEDIA_VIDEO_TRACK, ViewMediaVideoTrackPrivate)) +enum { + VIEW_MEDIA_VIDEO_TRACK_DUMMY_PROPERTY +}; +ViewMediaVideoTrack* view_media_video_track_new (ViewMediaEngine* media_engine, ModelTrack* track, GstElement* converter, GError** error); +ViewMediaVideoTrack* view_media_video_track_construct (GType object_type, ViewMediaEngine* media_engine, ModelTrack* track, GstElement* converter, GError** error); +static GstElement* view_media_video_track_real_get_element (ViewMediaTrack* base); +static GstElement* view_media_video_track_real_empty_element (ViewMediaTrack* base, GError** error); +static void view_media_video_track_real_link_new_pad (ViewMediaTrack* base, GstPad* pad, GstElement* track_element); +static void view_media_video_track_real_unlink_pad (ViewMediaTrack* base, GstPad* pad, GstElement* track_element); +static void view_media_video_track_finalize (GObject* obj); +GType view_click_track_get_type (void); +GType model_project_get_type (void); +#define VIEW_CLICK_TRACK_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIEW_TYPE_CLICK_TRACK, ViewClickTrackPrivate)) +enum { + VIEW_CLICK_TRACK_DUMMY_PROPERTY +}; +GType fraction_get_type (void); +Fraction* fraction_dup (const Fraction* self); +void fraction_free (Fraction* self); +GType model_tempo_information_get_type (void); +GType time_code_get_type (void); +TimeCode* time_code_dup (const TimeCode* self); +void time_code_free (TimeCode* self); +GType model_project_loader_get_type (void); +gpointer model_undo_manager_ref (gpointer instance); +void model_undo_manager_unref (gpointer instance); +GParamSpec* model_param_spec_undo_manager (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_undo_manager (GValue* value, gpointer v_object); +void model_value_take_undo_manager (GValue* value, gpointer v_object); +gpointer model_value_get_undo_manager (const GValue* value); +GType model_undo_manager_get_type (void); +GType model_library_importer_get_type (void); +static void view_click_track_on_playstate_changed (ViewClickTrack* self); +static void _view_click_track_on_playstate_changed_view_media_engine_playstate_changed (ViewMediaEngine* _sender, gpointer self); +static void _g_list_free_g_free (GList* self); +ViewClickTrack* view_click_track_new (ViewMediaEngine* engine, ModelProject* project, GError** error); +ViewClickTrack* view_click_track_construct (GType object_type, ViewMediaEngine* engine, ModelProject* project, GError** error); +static void view_click_track_clear_controllers (ViewClickTrack* self); +PlayState view_media_engine_get_play_state (ViewMediaEngine* self); +static void view_click_track_setup_clicks (ViewClickTrack* self, gint bpm, Fraction* time_signature); +gint model_tempo_information_get_bpm (ModelTempoInformation* self); +void model_tempo_information_get_time_signature (ModelTempoInformation* self, Fraction* result); +static void view_click_track_finalize (GObject* obj); +GType view_media_audio_track_get_type (void); +#define VIEW_MEDIA_AUDIO_TRACK_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIEW_TYPE_MEDIA_AUDIO_TRACK, ViewMediaAudioTrackPrivate)) +enum { + VIEW_MEDIA_AUDIO_TRACK_DUMMY_PROPERTY +}; +GType model_parameter_get_type (void); +static void view_media_audio_track_on_parameter_changed (ViewMediaAudioTrack* self, ModelParameter parameter, double new_value); +static void _view_media_audio_track_on_parameter_changed_model_audio_track_parameter_changed (ModelAudioTrack* _sender, ModelParameter parameter, double new_value, gpointer self); +double model_audio_track_get_pan (ModelAudioTrack* self); +double model_audio_track_get_volume (ModelAudioTrack* self); +static void view_media_audio_track_on_level_changed (ViewMediaAudioTrack* self, GstObject* source, double level_left, double level_right); +static void _view_media_audio_track_on_level_changed_view_media_engine_level_changed (ViewMediaEngine* _sender, GstObject* source, double level_left, double level_right, gpointer self); +void model_audio_track_on_level_changed (ModelAudioTrack* self, double level_left, double level_right); +static void _model_audio_track_on_level_changed_view_media_audio_track_level_changed (ViewMediaAudioTrack* _sender, double level_left, double level_right, gpointer self); +ViewMediaAudioTrack* view_media_audio_track_new (ViewMediaEngine* media_engine, ModelAudioTrack* track, GError** error); +ViewMediaAudioTrack* view_media_audio_track_construct (GType object_type, ViewMediaEngine* media_engine, ModelAudioTrack* track, GError** error); +GstElement* view_media_engine_get_audio_silence (ViewMediaEngine* self, GError** error); +static GstElement* view_media_audio_track_real_empty_element (ViewMediaTrack* base, GError** error); +static void view_media_audio_track_real_link_new_pad (ViewMediaTrack* base, GstPad* pad, GstElement* track_element); +static void view_media_audio_track_real_unlink_pad (ViewMediaTrack* base, GstPad* pad, GstElement* track_element); +static GstElement* view_media_audio_track_real_get_element (ViewMediaTrack* base); +static void view_media_audio_track_finalize (GObject* obj); +GType view_media_connector_get_type (void); +GType view_media_connector_media_types_get_type (void); +#define VIEW_MEDIA_CONNECTOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIEW_TYPE_MEDIA_CONNECTOR, ViewMediaConnectorPrivate)) +enum { + VIEW_MEDIA_CONNECTOR_DUMMY_PROPERTY +}; +ViewMediaConnector* view_media_connector_construct (GType object_type, ViewMediaConnectorMediaTypes media_types); +gboolean view_media_connector_has_audio (ViewMediaConnector* self); +gboolean view_media_connector_has_video (ViewMediaConnector* self); +void view_media_connector_connect (ViewMediaConnector* self, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1); +static void view_media_connector_real_connect (ViewMediaConnector* self, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1); +void view_media_connector_do_disconnect (ViewMediaConnector* self, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1); +static void view_media_connector_real_do_disconnect (ViewMediaConnector* self, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1); +static void view_media_connector_finalize (GObject* obj); +GType view_video_output_get_type (void); +#define VIEW_VIDEO_OUTPUT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIEW_TYPE_VIDEO_OUTPUT, ViewVideoOutputPrivate)) +enum { + VIEW_VIDEO_OUTPUT_DUMMY_PROPERTY +}; +ViewVideoOutput* view_video_output_new (GtkWidget* output_widget, GError** error); +ViewVideoOutput* view_video_output_construct (GType object_type, GtkWidget* output_widget, GError** error); +static void view_video_output_real_connect (ViewMediaConnector* base, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1); +static void view_video_output_real_do_disconnect (ViewMediaConnector* base, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1); +static void view_video_output_finalize (GObject* obj); +GType view_audio_output_get_type (void); +#define VIEW_AUDIO_OUTPUT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIEW_TYPE_AUDIO_OUTPUT, ViewAudioOutputPrivate)) +enum { + VIEW_AUDIO_OUTPUT_DUMMY_PROPERTY +}; +ViewAudioOutput* view_audio_output_new (GstCaps* caps, GError** error); +ViewAudioOutput* view_audio_output_construct (GType object_type, GstCaps* caps, GError** error); +static void view_audio_output_real_connect (ViewMediaConnector* base, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1); +static void view_audio_output_real_do_disconnect (ViewMediaConnector* base, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1); +static void view_audio_output_finalize (GObject* obj); +GType view_ogg_vorbis_export_get_type (void); +#define VIEW_OGG_VORBIS_EXPORT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIEW_TYPE_OGG_VORBIS_EXPORT, ViewOggVorbisExportPrivate)) +enum { + VIEW_OGG_VORBIS_EXPORT_DUMMY_PROPERTY +}; +ViewOggVorbisExport* view_ogg_vorbis_export_new (ViewMediaConnectorMediaTypes media_types, const char* filename, GstCaps* caps, GError** error); +ViewOggVorbisExport* view_ogg_vorbis_export_construct (GType object_type, ViewMediaConnectorMediaTypes media_types, const char* filename, GstCaps* caps, GError** error); +char* view_ogg_vorbis_export_get_filename (ViewOggVorbisExport* self); +static void view_ogg_vorbis_export_real_connect (ViewMediaConnector* base, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1); +static void view_ogg_vorbis_export_real_do_disconnect (ViewMediaConnector* base, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1); +static void view_ogg_vorbis_export_finalize (GObject* obj); +#define VIEW_MEDIA_ENGINE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEnginePrivate)) +enum { + VIEW_MEDIA_ENGINE_DUMMY_PROPERTY +}; +#define VIEW_MEDIA_ENGINE_MIN_GNONLIN "0.10.11" +#define VIEW_MEDIA_ENGINE_MIN_GST_PLUGINS_GOOD "0.10.15" +#define VIEW_MEDIA_ENGINE_MIN_GST_PLUGINS_BASE "0.10.15" +void model_project_on_playstate_changed (ModelProject* self); +static void _model_project_on_playstate_changed_view_media_engine_playstate_changed (ViewMediaEngine* _sender, gpointer self); +static void view_media_engine_on_error (ViewMediaEngine* self, GstBus* bus, GstMessage* message); +static void _view_media_engine_on_error_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self); +static void view_media_engine_on_warning (ViewMediaEngine* self, GstBus* bus, GstMessage* message); +static void _view_media_engine_on_warning_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self); +static void view_media_engine_on_eos (ViewMediaEngine* self, GstBus* bus, GstMessage* message); +static void _view_media_engine_on_eos_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self); +static void view_media_engine_on_state_change (ViewMediaEngine* self, GstBus* bus, GstMessage* message); +static void _view_media_engine_on_state_change_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self); +static void view_media_engine_on_element (ViewMediaEngine* self, GstBus* bus, GstMessage* message); +static void _view_media_engine_on_element_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self); +ViewMediaEngine* view_media_engine_new (ModelProject* project, gboolean include_video, GError** error); +ViewMediaEngine* view_media_engine_construct (GType object_type, ModelProject* project, gboolean include_video, GError** error); +static void view_media_engine_check_version (GstRegistry* registry, const char* plugin_name, const char* package_name, const char* min_version, GError** error); +void view_media_engine_can_run (GError** error); +GQuark media_error_quark (void); +gboolean version_at_least (const char* v, const char* w); +void view_media_engine_connect_output (ViewMediaEngine* self, ViewMediaConnector* connector); +void view_media_engine_disconnect_output (ViewMediaEngine* self, ViewMediaConnector* connector); +GstCaps* view_media_engine_get_project_audio_caps (ViewMediaEngine* self); +gint view_media_engine_get_sample_rate (ViewMediaEngine* self); +gint view_media_engine_get_sample_width (ViewMediaEngine* self); +gint view_media_engine_get_sample_depth (ViewMediaEngine* self); +void view_media_engine_set_play_state (ViewMediaEngine* self, PlayState play_state); +GstCaps* view_media_engine_build_audio_caps (ViewMediaEngine* self, gint num_channels); +GstCaps* view_media_engine_get_project_audio_export_caps (ViewMediaEngine* self); +void model_project_print_graph (ModelProject* self, GstBin* bin, const char* file_name); +static GValue* _gst_value_dup (GValue* self); +gboolean view_media_engine_do_state_change (ViewMediaEngine* self); +void view_media_engine_go (ViewMediaEngine* self, gint64 pos); +static void view_media_engine_do_paused_state_export (ViewMediaEngine* self); +static void view_media_engine_end_export (ViewMediaEngine* self, gboolean deleted); +void view_media_engine_close (ViewMediaEngine* self); +void view_media_engine_start_record (ViewMediaEngine* self, ModelClip* region, GError** error); +void view_media_engine_do_play (ViewMediaEngine* self, PlayState new_state); +void view_media_engine_set_gst_state (ViewMediaEngine* self, GstState state); +void view_media_engine_post_record (ViewMediaEngine* self); +void view_media_engine_do_null_state_export (ViewMediaEngine* self, gint64 length); +static void view_media_engine_real_do_null_state_export (ViewMediaEngine* self, gint64 length); +static gboolean view_media_engine_on_callback (ViewMediaEngine* self); +static gboolean _view_media_engine_on_callback_gsource_func (gpointer self); +gint64 model_project_get_length (ModelProject* self); +void view_media_engine_pause (ViewMediaEngine* self); +gboolean model_project_transport_is_recording (ModelProject* self); +static void view_media_engine_real_pause (ViewMediaEngine* self); +static void view_media_engine_seek (ViewMediaEngine* self, GstSeekFlags flags, gint64 pos); +static void view_media_engine_play (ViewMediaEngine* self); +void view_media_engine_start_export (ViewMediaEngine* self, const char* filename); +static void view_media_engine_real_cancel (MultiFileProgressInterface* base); +static void view_media_engine_real_complete (MultiFileProgressInterface* base); +void view_media_engine_on_load_complete (ViewMediaEngine* self); +void model_clip_set_duration (ModelClip* self, gint64 value); +void view_media_engine_on_callback_pulse (ViewMediaEngine* self); +void _model_track_delete_clip (ModelTrack* self, ModelClip* clip); +static char* view_media_engine_new_audio_filename (ViewMediaEngine* self, ModelTrack* track); +ModelClipFile* model_clip_file_new (const char* filename, gint64 length); +ModelClipFile* model_clip_file_construct (GType object_type, const char* filename, gint64 length); +ModelClip* model_clip_new (ModelClipFile* clipfile, ModelMediaType t, const char* name, gint64 start, gint64 media_start, gint64 duration, gboolean is_recording); +ModelClip* model_clip_construct (GType object_type, ModelClipFile* clipfile, ModelMediaType t, const char* name, gint64 start, gint64 media_start, gint64 duration, gboolean is_recording); +void view_media_engine_record (ViewMediaEngine* self, ModelAudioTrack* track); +gboolean model_project_transport_is_playing (ModelProject* self); +void _model_track_move (ModelTrack* self, ModelClip* c, gint64 pos); +GstCaps* view_media_engine_get_record_audio_caps (ViewMediaEngine* self); +char* model_project_get_audio_path (ModelProject* self); +static char* view_media_engine_generate_base (ViewMediaEngine* self, const char* name); +ModelMediaType model_track_media_type (ModelTrack* self); +static ViewMediaTrack* view_media_engine_create_audio_track (ViewMediaEngine* self, ModelTrack* track, GError** error); +static void view_media_engine_on_track_removed (ViewMediaEngine* self, ViewMediaTrack* track); +static void _view_media_engine_on_track_removed_view_media_track_track_removed (ViewMediaTrack* _sender, ViewMediaTrack* track, gpointer self); +static void view_media_engine_on_error_occurred (ViewMediaEngine* self, const char* major_message, const char* minor_message); +static void _view_media_engine_on_error_occurred_view_media_track_error_occurred (ViewMediaTrack* _sender, const char* major_message, const char* minor_message, gpointer self); +void view_media_engine_on_track_added (ViewMediaEngine* self, ModelTrack* track); +static void view_media_engine_finalize (GObject* obj); +static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func); +static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func); +static int _vala_strcmp0 (const char * str1, const char * str2); + + +static void g_cclosure_user_marshal_VOID__STRING_STRING (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data); +static void g_cclosure_user_marshal_VOID__DOUBLE_DOUBLE (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data); +static void g_cclosure_user_marshal_VOID__INT64 (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data); +static void g_cclosure_user_marshal_VOID__OBJECT_DOUBLE_DOUBLE (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data); + +GType play_state_get_type (void) { + static volatile gsize play_state_type_id__volatile = 0; + if (g_once_init_enter (&play_state_type_id__volatile)) { + static const GEnumValue values[] = {{PLAY_STATE_STOPPED, "PLAY_STATE_STOPPED", "stopped"}, {PLAY_STATE_PRE_PLAY, "PLAY_STATE_PRE_PLAY", "pre-play"}, {PLAY_STATE_PLAYING, "PLAY_STATE_PLAYING", "playing"}, {PLAY_STATE_PRE_RECORD_NULL, "PLAY_STATE_PRE_RECORD_NULL", "pre-record-null"}, {PLAY_STATE_PRE_RECORD, "PLAY_STATE_PRE_RECORD", "pre-record"}, {PLAY_STATE_RECORDING, "PLAY_STATE_RECORDING", "recording"}, {PLAY_STATE_POST_RECORD, "PLAY_STATE_POST_RECORD", "post-record"}, {PLAY_STATE_PRE_EXPORT, "PLAY_STATE_PRE_EXPORT", "pre-export"}, {PLAY_STATE_EXPORTING, "PLAY_STATE_EXPORTING", "exporting"}, {PLAY_STATE_CANCEL_EXPORT, "PLAY_STATE_CANCEL_EXPORT", "cancel-export"}, {PLAY_STATE_LOADING, "PLAY_STATE_LOADING", "loading"}, {PLAY_STATE_CLOSING, "PLAY_STATE_CLOSING", "closing"}, {PLAY_STATE_CLOSED, "PLAY_STATE_CLOSED", "closed"}, {0, NULL, NULL}}; + GType play_state_type_id; + play_state_type_id = g_enum_register_static ("PlayState", values); + g_once_init_leave (&play_state_type_id__volatile, play_state_type_id); + } + return play_state_type_id__volatile; +} + + +static gpointer _gst_object_ref0 (gpointer self) { + return self ? gst_object_ref (self) : NULL; +} + + +#line 69 "MediaEngine.vala" +static void _view_media_clip_on_duration_changed_model_clip_duration_changed (ModelClip* _sender, gint64 duration, gpointer self) { +#line 970 "MediaEngine.c" + view_media_clip_on_duration_changed (self, duration); +} + + +#line 64 "MediaEngine.vala" +static void _view_media_clip_on_media_start_changed_model_clip_media_start_changed (ModelClip* _sender, gint64 media_start, gpointer self) { +#line 977 "MediaEngine.c" + view_media_clip_on_media_start_changed (self, media_start); +} + + +#line 76 "MediaEngine.vala" +static void _view_media_clip_on_start_changed_model_clip_start_changed (ModelClip* _sender, gint64 start, gpointer self) { +#line 984 "MediaEngine.c" + view_media_clip_on_start_changed (self, start); +} + + +#line 58 "MediaEngine.vala" +static void _view_media_clip_on_clip_removed_model_clip_removed (ModelClip* _sender, ModelClip* clip, gpointer self) { +#line 991 "MediaEngine.c" + view_media_clip_on_clip_removed (self); +} + + +#line 30 "MediaEngine.vala" +ViewMediaClip* view_media_clip_construct (GType object_type, GstBin* composition, ModelClip* clip, GError** error) { +#line 998 "MediaEngine.c" + GError * _inner_error_; + ViewMediaClip * self; + GstBin* _tmp0_; + GstElement* _tmp1_; + GstElement* _tmp2_; +#line 30 "MediaEngine.vala" + g_return_val_if_fail (GST_IS_BIN (composition), NULL); +#line 30 "MediaEngine.vala" + g_return_val_if_fail (MODEL_IS_CLIP (clip), NULL); +#line 1008 "MediaEngine.c" + _inner_error_ = NULL; +#line 30 "MediaEngine.vala" + self = (ViewMediaClip*) g_object_new (object_type, NULL); +#line 31 "MediaEngine.vala" + self->priv->clip = clip; +#line 32 "MediaEngine.vala" + self->priv->composition = (_tmp0_ = _gst_object_ref0 (composition), _gst_object_unref0 (self->priv->composition), _tmp0_); +#line 33 "MediaEngine.vala" + _tmp1_ = make_element ("gnlsource", &_inner_error_); +#line 1018 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 33 "MediaEngine.vala" + self->file_source = (_tmp2_ = _tmp1_, _gst_object_unref0 (self->file_source), _tmp2_); +#line 34 "MediaEngine.vala" + if (!clip->is_recording) { +#line 35 "MediaEngine.vala" + g_signal_connect_object (clip, "duration-changed", (GCallback) _view_media_clip_on_duration_changed_model_clip_duration_changed, self, 0); +#line 36 "MediaEngine.vala" + g_signal_connect_object (clip, "media-start-changed", (GCallback) _view_media_clip_on_media_start_changed_model_clip_media_start_changed, self, 0); +#line 37 "MediaEngine.vala" + g_signal_connect_object (clip, "start-changed", (GCallback) _view_media_clip_on_start_changed_model_clip_start_changed, self, 0); +#line 39 "MediaEngine.vala" + gst_bin_add (composition, _gst_object_ref0 (self->file_source)); +#line 41 "MediaEngine.vala" + view_media_clip_on_start_changed (self, model_clip_get_start (clip)); +#line 42 "MediaEngine.vala" + view_media_clip_on_media_start_changed (self, model_clip_get_media_start (clip)); +#line 43 "MediaEngine.vala" + view_media_clip_on_duration_changed (self, model_clip_get_duration (clip)); +#line 1042 "MediaEngine.c" + } +#line 45 "MediaEngine.vala" + g_signal_connect_object (clip, "removed", (GCallback) _view_media_clip_on_clip_removed_model_clip_removed, self, 0); +#line 1046 "MediaEngine.c" + return self; +} + + +#line 30 "MediaEngine.vala" +ViewMediaClip* view_media_clip_new (GstBin* composition, ModelClip* clip, GError** error) { +#line 30 "MediaEngine.vala" + return view_media_clip_construct (VIEW_TYPE_MEDIA_CLIP, composition, clip, error); +#line 1055 "MediaEngine.c" +} + + +#line 58 "MediaEngine.vala" +void view_media_clip_on_clip_removed (ViewMediaClip* self) { +#line 58 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_CLIP (self)); +#line 59 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_removed"); +#line 60 "MediaEngine.vala" + gst_bin_remove (self->priv->composition, GST_ELEMENT (GST_BIN (self->file_source))); +#line 61 "MediaEngine.vala" + g_signal_emit_by_name (self, "clip-removed", self); +#line 1069 "MediaEngine.c" +} + + +#line 64 "MediaEngine.vala" +static void view_media_clip_on_media_start_changed (ViewMediaClip* self, gint64 media_start) { +#line 64 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_CLIP (self)); +#line 65 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_media_start_changed"); +#line 66 "MediaEngine.vala" + g_object_set (G_OBJECT (self->file_source), "media-start", media_start, NULL); +#line 1081 "MediaEngine.c" +} + + +#line 69 "MediaEngine.vala" +static void view_media_clip_on_duration_changed (ViewMediaClip* self, gint64 duration) { +#line 69 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_CLIP (self)); +#line 70 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_duration_changed"); +#line 71 "MediaEngine.vala" + g_object_set (G_OBJECT (self->file_source), "duration", duration, NULL); +#line 73 "MediaEngine.vala" + g_object_set (G_OBJECT (self->file_source), "media-duration", duration, NULL); +#line 1095 "MediaEngine.c" +} + + +#line 76 "MediaEngine.vala" +static void view_media_clip_on_start_changed (ViewMediaClip* self, gint64 start) { +#line 76 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_CLIP (self)); +#line 77 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_start_changed"); +#line 78 "MediaEngine.vala" + g_object_set (G_OBJECT (self->file_source), "start", start, NULL); +#line 1107 "MediaEngine.c" +} + + +#line 81 "MediaEngine.vala" +void view_media_clip_add_single_decode_bin (ViewMediaClip* self, const char* filename, const char* caps, GError** error) { +#line 1113 "MediaEngine.c" + GError * _inner_error_; + GstCaps* _tmp0_; + GstElement* _tmp1_; + GstElement* sbin; +#line 81 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_CLIP (self)); +#line 81 "MediaEngine.vala" + g_return_if_fail (filename != NULL); +#line 81 "MediaEngine.vala" + g_return_if_fail (caps != NULL); +#line 1124 "MediaEngine.c" + _inner_error_ = NULL; +#line 82 "MediaEngine.vala" + sbin = (_tmp1_ = GST_ELEMENT (single_decode_bin_new (_tmp0_ = gst_caps_from_string (caps), "singledecoder", filename, &_inner_error_)), _gst_caps_unref0 (_tmp0_), _tmp1_); +#line 1128 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + return; + } +#line 84 "MediaEngine.vala" + if (gst_bin_add (GST_BIN (self->file_source), _gst_object_ref0 (sbin))) { +#line 85 "MediaEngine.vala" + if (!gst_element_sync_state_with_parent (self->file_source)) { +#line 86 "MediaEngine.vala" + model_clip_file_set_online (self->priv->clip->clipfile, FALSE); +#line 1139 "MediaEngine.c" + } + } + _gst_object_unref0 (sbin); +} + + +#line 91 "MediaEngine.vala" +gboolean view_media_clip_is_equal (ViewMediaClip* self, ModelClip* clip) { +#line 1148 "MediaEngine.c" + gboolean result = FALSE; +#line 91 "MediaEngine.vala" + g_return_val_if_fail (VIEW_IS_MEDIA_CLIP (self), FALSE); +#line 91 "MediaEngine.vala" + g_return_val_if_fail (MODEL_IS_CLIP (clip), FALSE); +#line 1154 "MediaEngine.c" + result = clip == self->priv->clip; +#line 92 "MediaEngine.vala" + return result; +#line 1158 "MediaEngine.c" +} + + +static void view_media_clip_class_init (ViewMediaClipClass * klass) { + view_media_clip_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ViewMediaClipPrivate)); + G_OBJECT_CLASS (klass)->finalize = view_media_clip_finalize; + g_signal_new ("clip_removed", VIEW_TYPE_MEDIA_CLIP, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, VIEW_TYPE_MEDIA_CLIP); +} + + +static void view_media_clip_instance_init (ViewMediaClip * self) { + self->priv = VIEW_MEDIA_CLIP_GET_PRIVATE (self); +} + + +static void view_media_clip_finalize (GObject* obj) { + ViewMediaClip * self; + self = VIEW_MEDIA_CLIP (obj); + { + guint _tmp0_; +#line 49 "MediaEngine.vala" + g_signal_parse_name ("removed", MODEL_TYPE_CLIP, &_tmp0_, NULL, FALSE); +#line 49 "MediaEngine.vala" + g_signal_handlers_disconnect_matched (self->priv->clip, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, 0, NULL, (GCallback) _view_media_clip_on_clip_removed_model_clip_removed, self); +#line 50 "MediaEngine.vala" + if (!self->priv->clip->is_recording) { +#line 1186 "MediaEngine.c" + guint _tmp1_; + guint _tmp2_; + guint _tmp3_; +#line 51 "MediaEngine.vala" + g_signal_parse_name ("duration-changed", MODEL_TYPE_CLIP, &_tmp1_, NULL, FALSE); +#line 51 "MediaEngine.vala" + g_signal_handlers_disconnect_matched (self->priv->clip, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp1_, 0, NULL, (GCallback) _view_media_clip_on_duration_changed_model_clip_duration_changed, self); +#line 52 "MediaEngine.vala" + g_signal_parse_name ("media-start-changed", MODEL_TYPE_CLIP, &_tmp2_, NULL, FALSE); +#line 52 "MediaEngine.vala" + g_signal_handlers_disconnect_matched (self->priv->clip, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp2_, 0, NULL, (GCallback) _view_media_clip_on_media_start_changed_model_clip_media_start_changed, self); +#line 53 "MediaEngine.vala" + g_signal_parse_name ("start-changed", MODEL_TYPE_CLIP, &_tmp3_, NULL, FALSE); +#line 53 "MediaEngine.vala" + g_signal_handlers_disconnect_matched (self->priv->clip, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp3_, 0, NULL, (GCallback) _view_media_clip_on_start_changed_model_clip_start_changed, self); +#line 1202 "MediaEngine.c" + } +#line 55 "MediaEngine.vala" + gst_element_set_state (self->file_source, GST_STATE_NULL); +#line 1206 "MediaEngine.c" + } + _gst_object_unref0 (self->file_source); + _gst_object_unref0 (self->priv->composition); + G_OBJECT_CLASS (view_media_clip_parent_class)->finalize (obj); +} + + +GType view_media_clip_get_type (void) { + static volatile gsize view_media_clip_type_id__volatile = 0; + if (g_once_init_enter (&view_media_clip_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ViewMediaClipClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_media_clip_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewMediaClip), 0, (GInstanceInitFunc) view_media_clip_instance_init, NULL }; + GType view_media_clip_type_id; + view_media_clip_type_id = g_type_register_static (G_TYPE_OBJECT, "ViewMediaClip", &g_define_type_info, 0); + g_once_init_leave (&view_media_clip_type_id__volatile, view_media_clip_type_id); + } + return view_media_clip_type_id__volatile; +} + + +#line 97 "MediaEngine.vala" +ViewMediaAudioClip* view_media_audio_clip_construct (GType object_type, GstBin* composition, ModelClip* clip, const char* filename, GError** error) { +#line 1228 "MediaEngine.c" + GError * _inner_error_; + ViewMediaAudioClip * self; +#line 97 "MediaEngine.vala" + g_return_val_if_fail (GST_IS_BIN (composition), NULL); +#line 97 "MediaEngine.vala" + g_return_val_if_fail (MODEL_IS_CLIP (clip), NULL); +#line 97 "MediaEngine.vala" + g_return_val_if_fail (filename != NULL, NULL); +#line 1237 "MediaEngine.c" + _inner_error_ = NULL; +#line 98 "MediaEngine.vala" + self = (ViewMediaAudioClip*) view_media_clip_construct (object_type, composition, clip, error); +#line 99 "MediaEngine.vala" + if (!clip->is_recording) { +#line 100 "MediaEngine.vala" + view_media_clip_add_single_decode_bin (VIEW_MEDIA_CLIP (self), filename, "audio/x-raw-float;audio/x-raw-int", &_inner_error_); +#line 1245 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } + } + return self; +} + + +#line 97 "MediaEngine.vala" +ViewMediaAudioClip* view_media_audio_clip_new (GstBin* composition, ModelClip* clip, const char* filename, GError** error) { +#line 97 "MediaEngine.vala" + return view_media_audio_clip_construct (VIEW_TYPE_MEDIA_AUDIO_CLIP, composition, clip, filename, error); +#line 1260 "MediaEngine.c" +} + + +static void view_media_audio_clip_class_init (ViewMediaAudioClipClass * klass) { + view_media_audio_clip_parent_class = g_type_class_peek_parent (klass); +} + + +static void view_media_audio_clip_instance_init (ViewMediaAudioClip * self) { +} + + +GType view_media_audio_clip_get_type (void) { + static volatile gsize view_media_audio_clip_type_id__volatile = 0; + if (g_once_init_enter (&view_media_audio_clip_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ViewMediaAudioClipClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_media_audio_clip_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewMediaAudioClip), 0, (GInstanceInitFunc) view_media_audio_clip_instance_init, NULL }; + GType view_media_audio_clip_type_id; + view_media_audio_clip_type_id = g_type_register_static (VIEW_TYPE_MEDIA_CLIP, "ViewMediaAudioClip", &g_define_type_info, 0); + g_once_init_leave (&view_media_audio_clip_type_id__volatile, view_media_audio_clip_type_id); + } + return view_media_audio_clip_type_id__volatile; +} + + +#line 106 "MediaEngine.vala" +ViewMediaVideoClip* view_media_video_clip_construct (GType object_type, GstBin* composition, ModelClip* clip, const char* filename, GError** error) { +#line 1287 "MediaEngine.c" + GError * _inner_error_; + ViewMediaVideoClip * self; +#line 106 "MediaEngine.vala" + g_return_val_if_fail (GST_IS_BIN (composition), NULL); +#line 106 "MediaEngine.vala" + g_return_val_if_fail (MODEL_IS_CLIP (clip), NULL); +#line 106 "MediaEngine.vala" + g_return_val_if_fail (filename != NULL, NULL); +#line 1296 "MediaEngine.c" + _inner_error_ = NULL; +#line 107 "MediaEngine.vala" + self = (ViewMediaVideoClip*) view_media_clip_construct (object_type, composition, clip, error); +#line 108 "MediaEngine.vala" + view_media_clip_add_single_decode_bin (VIEW_MEDIA_CLIP (self), filename, "video/x-raw-yuv; video/x-raw-rgb", &_inner_error_); +#line 1302 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } + return self; +} + + +#line 106 "MediaEngine.vala" +ViewMediaVideoClip* view_media_video_clip_new (GstBin* composition, ModelClip* clip, const char* filename, GError** error) { +#line 106 "MediaEngine.vala" + return view_media_video_clip_construct (VIEW_TYPE_MEDIA_VIDEO_CLIP, composition, clip, filename, error); +#line 1316 "MediaEngine.c" +} + + +static void view_media_video_clip_class_init (ViewMediaVideoClipClass * klass) { + view_media_video_clip_parent_class = g_type_class_peek_parent (klass); +} + + +static void view_media_video_clip_instance_init (ViewMediaVideoClip * self) { +} + + +GType view_media_video_clip_get_type (void) { + static volatile gsize view_media_video_clip_type_id__volatile = 0; + if (g_once_init_enter (&view_media_video_clip_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ViewMediaVideoClipClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_media_video_clip_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewMediaVideoClip), 0, (GInstanceInitFunc) view_media_video_clip_instance_init, NULL }; + GType view_media_video_clip_type_id; + view_media_video_clip_type_id = g_type_register_static (VIEW_TYPE_MEDIA_CLIP, "ViewMediaVideoClip", &g_define_type_info, 0); + g_once_init_leave (&view_media_video_clip_type_id__volatile, view_media_video_clip_type_id); + } + return view_media_video_clip_type_id__volatile; +} + + +#line 169 "MediaEngine.vala" +static void _view_media_track_on_clip_added_model_track_clip_added (ModelTrack* _sender, ModelClip* clip, gboolean select, gpointer self) { +#line 1343 "MediaEngine.c" + view_media_track_on_clip_added (self, clip); +} + + +#line 216 "MediaEngine.vala" +static void _view_media_track_on_track_removed_model_track_track_removed (ModelTrack* _sender, ModelTrack* track, gpointer self) { +#line 1350 "MediaEngine.c" + view_media_track_on_track_removed (self, track); +} + + +#line 221 "MediaEngine.vala" +static void _view_media_track_on_pre_export_view_media_engine_pre_export (ViewMediaEngine* _sender, gint64 length, gpointer self) { +#line 1357 "MediaEngine.c" + view_media_track_on_pre_export (self, length); +} + + +#line 227 "MediaEngine.vala" +static void _view_media_track_on_post_export_view_media_engine_post_export (ViewMediaEngine* _sender, gboolean canceled, gpointer self) { +#line 1364 "MediaEngine.c" + view_media_track_on_post_export (self, canceled); +} + + +#line 206 "MediaEngine.vala" +static void _view_media_track_on_pad_added_gst_element_pad_added (GstElement* _sender, GstPad* pad, gpointer self) { +#line 1371 "MediaEngine.c" + view_media_track_on_pad_added (self, pad); +} + + +#line 211 "MediaEngine.vala" +static void _view_media_track_on_pad_removed_gst_element_pad_removed (GstElement* _sender, GstPad* pad, gpointer self) { +#line 1378 "MediaEngine.c" + view_media_track_on_pad_removed (self, pad); +} + + +#line 123 "MediaEngine.vala" +ViewMediaTrack* view_media_track_construct (GType object_type, ViewMediaEngine* media_engine, ModelTrack* track, GError** error) { +#line 1385 "MediaEngine.c" + GError * _inner_error_; + ViewMediaTrack * self; + GeeArrayList* _tmp0_; + GstElement* _tmp1_; + GstBin* _tmp2_; + GstElement* _tmp3_; + GstElement* _tmp4_; + GstBin* default_source_bin; + GstElement* _tmp5_; +#line 123 "MediaEngine.vala" + g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (media_engine), NULL); +#line 123 "MediaEngine.vala" + g_return_val_if_fail (MODEL_IS_TRACK (track), NULL); +#line 1399 "MediaEngine.c" + _inner_error_ = NULL; +#line 123 "MediaEngine.vala" + self = (ViewMediaTrack*) g_object_new (object_type, NULL); +#line 124 "MediaEngine.vala" + self->priv->clips = (_tmp0_ = gee_array_list_new (VIEW_TYPE_MEDIA_CLIP, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL), _g_object_unref0 (self->priv->clips), _tmp0_); +#line 125 "MediaEngine.vala" + self->media_engine = media_engine; +#line 126 "MediaEngine.vala" + g_signal_connect_object (track, "clip-added", (GCallback) _view_media_track_on_clip_added_model_track_clip_added, self, 0); +#line 127 "MediaEngine.vala" + g_signal_connect_object (track, "track-removed", (GCallback) _view_media_track_on_track_removed_model_track_track_removed, self, 0); +#line 129 "MediaEngine.vala" + g_signal_connect_object (media_engine, "pre-export", (GCallback) _view_media_track_on_pre_export_view_media_engine_pre_export, self, 0); +#line 130 "MediaEngine.vala" + g_signal_connect_object (media_engine, "post-export", (GCallback) _view_media_track_on_post_export_view_media_engine_post_export, self, 0); +#line 132 "MediaEngine.vala" + _tmp1_ = make_element ("gnlcomposition", &_inner_error_); +#line 1417 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 132 "MediaEngine.vala" + self->composition = (_tmp2_ = GST_BIN (_tmp1_), _gst_object_unref0 (self->composition), _tmp2_); +#line 134 "MediaEngine.vala" + _tmp3_ = make_element_with_name ("gnlsource", "track_default_source", &_inner_error_); +#line 1427 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 134 "MediaEngine.vala" + self->default_source = (_tmp4_ = _tmp3_, _gst_object_unref0 (self->default_source), _tmp4_); +#line 135 "MediaEngine.vala" + default_source_bin = _gst_object_ref0 (GST_BIN (self->default_source)); +#line 136 "MediaEngine.vala" + _tmp5_ = view_media_track_empty_element (self, &_inner_error_); +#line 1439 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + _gst_object_unref0 (default_source_bin); + g_object_unref (self); + return NULL; + } +#line 136 "MediaEngine.vala" + if (!gst_bin_add (default_source_bin, _tmp5_)) { +#line 137 "MediaEngine.vala" + g_error ("MediaEngine.vala:137: can't add empty element"); +#line 1450 "MediaEngine.c" + } +#line 142 "MediaEngine.vala" + g_object_set (G_OBJECT (self->default_source), "priority", 1, NULL); +#line 143 "MediaEngine.vala" + g_object_set (G_OBJECT (self->default_source), "start", 0 * GST_SECOND, NULL); +#line 144 "MediaEngine.vala" + g_object_set (G_OBJECT (self->default_source), "duration", 1000000 * GST_SECOND, NULL); +#line 145 "MediaEngine.vala" + g_object_set (G_OBJECT (self->default_source), "media-start", 0 * GST_SECOND, NULL); +#line 146 "MediaEngine.vala" + g_object_set (G_OBJECT (self->default_source), "media-duration", 1000000 * GST_SECOND, NULL); +#line 148 "MediaEngine.vala" + if (!gst_bin_add (self->composition, _gst_object_ref0 (self->default_source))) { +#line 149 "MediaEngine.vala" + g_error ("MediaEngine.vala:149: can't add default source"); +#line 1466 "MediaEngine.c" + } +#line 152 "MediaEngine.vala" + gst_bin_add (GST_BIN (media_engine->pipeline), _gst_object_ref0 (GST_ELEMENT (self->composition))); +#line 153 "MediaEngine.vala" + g_signal_connect_object (GST_ELEMENT (self->composition), "pad-added", (GCallback) _view_media_track_on_pad_added_gst_element_pad_added, self, 0); +#line 154 "MediaEngine.vala" + g_signal_connect_object (GST_ELEMENT (self->composition), "pad-removed", (GCallback) _view_media_track_on_pad_removed_gst_element_pad_removed, self, 0); +#line 1474 "MediaEngine.c" + _gst_object_unref0 (default_source_bin); + return self; +} + + +#line 163 "MediaEngine.vala" +static GstElement* view_media_track_real_empty_element (ViewMediaTrack* self, GError** error) { +#line 1482 "MediaEngine.c" + g_return_val_if_fail (VIEW_IS_MEDIA_TRACK (self), NULL); + g_critical ("Type `%s' does not implement abstract method `view_media_track_empty_element'", g_type_name (G_TYPE_FROM_INSTANCE (self))); + return NULL; +} + + +#line 163 "MediaEngine.vala" +GstElement* view_media_track_empty_element (ViewMediaTrack* self, GError** error) { +#line 163 "MediaEngine.vala" + return VIEW_MEDIA_TRACK_GET_CLASS (self)->empty_element (self, error); +#line 1493 "MediaEngine.c" +} + + +#line 164 "MediaEngine.vala" +static GstElement* view_media_track_real_get_element (ViewMediaTrack* self) { +#line 1499 "MediaEngine.c" + g_return_val_if_fail (VIEW_IS_MEDIA_TRACK (self), NULL); + g_critical ("Type `%s' does not implement abstract method `view_media_track_get_element'", g_type_name (G_TYPE_FROM_INSTANCE (self))); + return NULL; +} + + +#line 164 "MediaEngine.vala" +GstElement* view_media_track_get_element (ViewMediaTrack* self) { +#line 164 "MediaEngine.vala" + return VIEW_MEDIA_TRACK_GET_CLASS (self)->get_element (self); +#line 1510 "MediaEngine.c" +} + + +#line 166 "MediaEngine.vala" +static void view_media_track_real_link_new_pad (ViewMediaTrack* self, GstPad* pad, GstElement* track_element) { +#line 1516 "MediaEngine.c" + g_return_if_fail (VIEW_IS_MEDIA_TRACK (self)); + g_critical ("Type `%s' does not implement abstract method `view_media_track_link_new_pad'", g_type_name (G_TYPE_FROM_INSTANCE (self))); + return; +} + + +#line 166 "MediaEngine.vala" +void view_media_track_link_new_pad (ViewMediaTrack* self, GstPad* pad, GstElement* track_element) { +#line 166 "MediaEngine.vala" + VIEW_MEDIA_TRACK_GET_CLASS (self)->link_new_pad (self, pad, track_element); +#line 1527 "MediaEngine.c" +} + + +#line 167 "MediaEngine.vala" +static void view_media_track_real_unlink_pad (ViewMediaTrack* self, GstPad* pad, GstElement* track_element) { +#line 1533 "MediaEngine.c" + g_return_if_fail (VIEW_IS_MEDIA_TRACK (self)); + g_critical ("Type `%s' does not implement abstract method `view_media_track_unlink_pad'", g_type_name (G_TYPE_FROM_INSTANCE (self))); + return; +} + + +#line 167 "MediaEngine.vala" +void view_media_track_unlink_pad (ViewMediaTrack* self, GstPad* pad, GstElement* track_element) { +#line 167 "MediaEngine.vala" + VIEW_MEDIA_TRACK_GET_CLASS (self)->unlink_pad (self, pad, track_element); +#line 1544 "MediaEngine.c" +} + + +#line 175 "MediaEngine.vala" +static void _view_media_track_on_clip_updated_model_clip_updated (ModelClip* _sender, ModelClip* clip, gpointer self) { +#line 1550 "MediaEngine.c" + view_media_track_on_clip_updated (self, clip); +} + + +#line 169 "MediaEngine.vala" +static void view_media_track_on_clip_added (ViewMediaTrack* self, ModelClip* clip) { +#line 169 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_TRACK (self)); +#line 169 "MediaEngine.vala" + g_return_if_fail (MODEL_IS_CLIP (clip)); +#line 170 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_added"); +#line 171 "MediaEngine.vala" + g_signal_connect_object (clip, "updated", (GCallback) _view_media_track_on_clip_updated_model_clip_updated, self, 0); +#line 172 "MediaEngine.vala" + view_media_track_on_clip_updated (self, clip); +#line 1567 "MediaEngine.c" +} + + +#line 200 "MediaEngine.vala" +static void _view_media_track_on_media_clip_removed_view_media_clip_clip_removed (ViewMediaClip* _sender, ViewMediaClip* clip, gpointer self) { +#line 1573 "MediaEngine.c" + view_media_track_on_media_clip_removed (self, clip); +} + + +#line 175 "MediaEngine.vala" +static void view_media_track_on_clip_updated (ViewMediaTrack* self, ModelClip* clip) { +#line 1580 "MediaEngine.c" + GError * _inner_error_; +#line 175 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_TRACK (self)); +#line 175 "MediaEngine.vala" + g_return_if_fail (MODEL_IS_CLIP (clip)); +#line 1586 "MediaEngine.c" + _inner_error_ = NULL; +#line 176 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_updated"); +#line 177 "MediaEngine.vala" + if (model_clip_file_is_online (clip->clipfile)) { +#line 1592 "MediaEngine.c" + { + ViewMediaClip* media_clip; + media_clip = NULL; +#line 180 "MediaEngine.vala" + if (clip->type == MODEL_MEDIA_TYPE_AUDIO) { +#line 1598 "MediaEngine.c" + ViewMediaAudioClip* _tmp0_; + ViewMediaClip* _tmp1_; +#line 181 "MediaEngine.vala" + _tmp0_ = view_media_audio_clip_new (self->composition, clip, clip->clipfile->filename, &_inner_error_); +#line 1603 "MediaEngine.c" + if (_inner_error_ != NULL) { + _g_object_unref0 (media_clip); + goto __catch9_g_error; + } +#line 181 "MediaEngine.vala" + media_clip = (_tmp1_ = VIEW_MEDIA_CLIP (_tmp0_), _g_object_unref0 (media_clip), _tmp1_); +#line 1610 "MediaEngine.c" + } else { + ViewMediaVideoClip* _tmp2_; + ViewMediaClip* _tmp3_; +#line 183 "MediaEngine.vala" + _tmp2_ = view_media_video_clip_new (self->composition, clip, clip->clipfile->filename, &_inner_error_); +#line 1616 "MediaEngine.c" + if (_inner_error_ != NULL) { + _g_object_unref0 (media_clip); + goto __catch9_g_error; + } +#line 183 "MediaEngine.vala" + media_clip = (_tmp3_ = VIEW_MEDIA_CLIP (_tmp2_), _g_object_unref0 (media_clip), _tmp3_); +#line 1623 "MediaEngine.c" + } +#line 185 "MediaEngine.vala" + g_signal_connect_object (media_clip, "clip-removed", (GCallback) _view_media_track_on_media_clip_removed_view_media_clip_clip_removed, self, 0); +#line 187 "MediaEngine.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->clips), media_clip); +#line 1629 "MediaEngine.c" + _g_object_unref0 (media_clip); + } + goto __finally9; + __catch9_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { +#line 189 "MediaEngine.vala" + g_signal_emit_by_name (self, "error-occurred", "Could not create clip", e->message); +#line 1641 "MediaEngine.c" + _g_error_free0 (e); + } + } + __finally9: + if (_inner_error_ != NULL) { + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } + } else { + { + GeeIterator* _media_clip_it; + _media_clip_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->priv->clips)); +#line 192 "MediaEngine.vala" + while (TRUE) { +#line 1657 "MediaEngine.c" + ViewMediaClip* media_clip; +#line 192 "MediaEngine.vala" + if (!gee_iterator_next (_media_clip_it)) { +#line 192 "MediaEngine.vala" + break; +#line 1663 "MediaEngine.c" + } +#line 192 "MediaEngine.vala" + media_clip = (ViewMediaClip*) gee_iterator_get (_media_clip_it); +#line 193 "MediaEngine.vala" + if (view_media_clip_is_equal (media_clip, clip)) { +#line 194 "MediaEngine.vala" + view_media_clip_on_clip_removed (media_clip); +#line 1671 "MediaEngine.c" + } + _g_object_unref0 (media_clip); + } + _g_object_unref0 (_media_clip_it); + } + } +} + + +#line 200 "MediaEngine.vala" +static void view_media_track_on_media_clip_removed (ViewMediaTrack* self, ViewMediaClip* clip) { +#line 1683 "MediaEngine.c" + guint _tmp0_; +#line 200 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_TRACK (self)); +#line 200 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_CLIP (clip)); +#line 201 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_media_clip_removed"); +#line 202 "MediaEngine.vala" + g_signal_parse_name ("clip-removed", VIEW_TYPE_MEDIA_CLIP, &_tmp0_, NULL, FALSE); +#line 202 "MediaEngine.vala" + g_signal_handlers_disconnect_matched (clip, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, 0, NULL, (GCallback) _view_media_track_on_media_clip_removed_view_media_clip_clip_removed, self); +#line 203 "MediaEngine.vala" + gee_abstract_collection_remove (GEE_ABSTRACT_COLLECTION (self->priv->clips), clip); +#line 1697 "MediaEngine.c" +} + + +#line 206 "MediaEngine.vala" +static void view_media_track_on_pad_added (ViewMediaTrack* self, GstPad* pad) { +#line 1703 "MediaEngine.c" + GstElement* _tmp0_; +#line 206 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_TRACK (self)); +#line 206 "MediaEngine.vala" + g_return_if_fail (GST_IS_PAD (pad)); +#line 207 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_pad_added"); +#line 208 "MediaEngine.vala" + view_media_track_link_new_pad (self, pad, _tmp0_ = view_media_track_get_element (self)); +#line 1713 "MediaEngine.c" + _gst_object_unref0 (_tmp0_); +} + + +#line 211 "MediaEngine.vala" +static void view_media_track_on_pad_removed (ViewMediaTrack* self, GstPad* pad) { +#line 1720 "MediaEngine.c" + GstElement* _tmp0_; +#line 211 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_TRACK (self)); +#line 211 "MediaEngine.vala" + g_return_if_fail (GST_IS_PAD (pad)); +#line 212 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_pad_removed"); +#line 213 "MediaEngine.vala" + view_media_track_unlink_pad (self, pad, _tmp0_ = view_media_track_get_element (self)); +#line 1730 "MediaEngine.c" + _gst_object_unref0 (_tmp0_); +} + + +#line 216 "MediaEngine.vala" +static void view_media_track_on_track_removed (ViewMediaTrack* self, ModelTrack* track) { +#line 216 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_TRACK (self)); +#line 216 "MediaEngine.vala" + g_return_if_fail (MODEL_IS_TRACK (track)); +#line 217 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_track_removed"); +#line 218 "MediaEngine.vala" + g_signal_emit_by_name (self, "track-removed", self); +#line 1745 "MediaEngine.c" +} + + +#line 221 "MediaEngine.vala" +static void view_media_track_on_pre_export (ViewMediaTrack* self, gint64 length) { +#line 221 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_TRACK (self)); +#line 222 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_pre_export"); +#line 223 "MediaEngine.vala" + g_object_set (G_OBJECT (self->default_source), "duration", length, NULL); +#line 224 "MediaEngine.vala" + g_object_set (G_OBJECT (self->default_source), "media-duration", length, NULL); +#line 1759 "MediaEngine.c" +} + + +#line 227 "MediaEngine.vala" +static void view_media_track_on_post_export (ViewMediaTrack* self, gboolean deleted) { +#line 227 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_TRACK (self)); +#line 228 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_post_export"); +#line 229 "MediaEngine.vala" + g_object_set (G_OBJECT (self->default_source), "duration", 1000000 * GST_SECOND, NULL); +#line 230 "MediaEngine.vala" + g_object_set (G_OBJECT (self->default_source), "media-duration", 1000000 * GST_SECOND, NULL); +#line 1773 "MediaEngine.c" +} + + +static void view_media_track_class_init (ViewMediaTrackClass * klass) { + view_media_track_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ViewMediaTrackPrivate)); + VIEW_MEDIA_TRACK_CLASS (klass)->empty_element = view_media_track_real_empty_element; + VIEW_MEDIA_TRACK_CLASS (klass)->get_element = view_media_track_real_get_element; + VIEW_MEDIA_TRACK_CLASS (klass)->link_new_pad = view_media_track_real_link_new_pad; + VIEW_MEDIA_TRACK_CLASS (klass)->unlink_pad = view_media_track_real_unlink_pad; + G_OBJECT_CLASS (klass)->finalize = view_media_track_finalize; + g_signal_new ("track_removed", VIEW_TYPE_MEDIA_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, VIEW_TYPE_MEDIA_TRACK); + g_signal_new ("error_occurred", VIEW_TYPE_MEDIA_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__STRING_STRING, G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRING); +} + + +static void view_media_track_instance_init (ViewMediaTrack * self) { + self->priv = VIEW_MEDIA_TRACK_GET_PRIVATE (self); +} + + +static void view_media_track_finalize (GObject* obj) { + ViewMediaTrack * self; + self = VIEW_MEDIA_TRACK (obj); + { + gboolean _tmp4_ = FALSE; +#line 158 "MediaEngine.vala" + if (self->composition != NULL) { +#line 158 "MediaEngine.vala" + _tmp4_ = !gst_bin_remove (GST_BIN (self->media_engine->pipeline), GST_ELEMENT (self->composition)); +#line 1804 "MediaEngine.c" + } else { +#line 158 "MediaEngine.vala" + _tmp4_ = FALSE; +#line 1808 "MediaEngine.c" + } +#line 158 "MediaEngine.vala" + if (_tmp4_) { +#line 159 "MediaEngine.vala" + g_error ("MediaEngine.vala:159: couldn't remove composition"); +#line 1814 "MediaEngine.c" + } + } + _g_object_unref0 (self->priv->clips); + _gst_object_unref0 (self->composition); + _gst_object_unref0 (self->default_source); + _gst_object_unref0 (self->sink); + G_OBJECT_CLASS (view_media_track_parent_class)->finalize (obj); +} + + +GType view_media_track_get_type (void) { + static volatile gsize view_media_track_type_id__volatile = 0; + if (g_once_init_enter (&view_media_track_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ViewMediaTrackClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_media_track_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewMediaTrack), 0, (GInstanceInitFunc) view_media_track_instance_init, NULL }; + GType view_media_track_type_id; + view_media_track_type_id = g_type_register_static (G_TYPE_OBJECT, "ViewMediaTrack", &g_define_type_info, G_TYPE_FLAG_ABSTRACT); + g_once_init_leave (&view_media_track_type_id__volatile, view_media_track_type_id); + } + return view_media_track_type_id__volatile; +} + + +#line 237 "MediaEngine.vala" +ViewMediaVideoTrack* view_media_video_track_construct (GType object_type, ViewMediaEngine* media_engine, ModelTrack* track, GstElement* converter, GError** error) { +#line 1839 "MediaEngine.c" + ViewMediaVideoTrack * self; +#line 237 "MediaEngine.vala" + g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (media_engine), NULL); +#line 237 "MediaEngine.vala" + g_return_val_if_fail (MODEL_IS_TRACK (track), NULL); +#line 237 "MediaEngine.vala" + g_return_val_if_fail (GST_IS_ELEMENT (converter), NULL); +#line 239 "MediaEngine.vala" + self = (ViewMediaVideoTrack*) view_media_track_construct (object_type, media_engine, track, error); +#line 240 "MediaEngine.vala" + self->priv->converter = converter; +#line 1851 "MediaEngine.c" + return self; +} + + +#line 237 "MediaEngine.vala" +ViewMediaVideoTrack* view_media_video_track_new (ViewMediaEngine* media_engine, ModelTrack* track, GstElement* converter, GError** error) { +#line 237 "MediaEngine.vala" + return view_media_video_track_construct (VIEW_TYPE_MEDIA_VIDEO_TRACK, media_engine, track, converter, error); +#line 1860 "MediaEngine.c" +} + + +#line 243 "MediaEngine.vala" +static GstElement* view_media_video_track_real_get_element (ViewMediaTrack* base) { +#line 1866 "MediaEngine.c" + ViewMediaVideoTrack * self; + GstElement* result = NULL; + self = VIEW_MEDIA_VIDEO_TRACK (base); +#line 247 "MediaEngine.vala" + g_assert (self->priv->converter != NULL); +#line 248 "MediaEngine.vala" + g_assert (gst_element_sync_state_with_parent (self->priv->converter)); +#line 1874 "MediaEngine.c" + result = _gst_object_ref0 (self->priv->converter); +#line 249 "MediaEngine.vala" + return result; +#line 1878 "MediaEngine.c" +} + + +#line 252 "MediaEngine.vala" +static GstElement* view_media_video_track_real_empty_element (ViewMediaTrack* base, GError** error) { +#line 1884 "MediaEngine.c" + ViewMediaVideoTrack * self; + GstElement* result = NULL; + GError * _inner_error_; + GstElement* blackness; + self = VIEW_MEDIA_VIDEO_TRACK (base); + _inner_error_ = NULL; +#line 253 "MediaEngine.vala" + blackness = make_element ("videotestsrc", &_inner_error_); +#line 1893 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + return NULL; + } +#line 254 "MediaEngine.vala" + g_object_set (G_OBJECT (blackness), "pattern", 2, NULL); +#line 1900 "MediaEngine.c" + result = blackness; +#line 255 "MediaEngine.vala" + return result; +#line 1904 "MediaEngine.c" +} + + +#line 258 "MediaEngine.vala" +static void view_media_video_track_real_link_new_pad (ViewMediaTrack* base, GstPad* pad, GstElement* track_element) { +#line 1910 "MediaEngine.c" + ViewMediaVideoTrack * self; + GstPad* _tmp0_; + gboolean _tmp1_; + self = VIEW_MEDIA_VIDEO_TRACK (base); +#line 258 "MediaEngine.vala" + g_return_if_fail (GST_IS_PAD (pad)); +#line 258 "MediaEngine.vala" + g_return_if_fail (GST_IS_ELEMENT (track_element)); +#line 259 "MediaEngine.vala" + if ((_tmp1_ = gst_pad_link (pad, _tmp0_ = gst_element_get_static_pad (track_element, "sink")) != GST_PAD_LINK_OK, _gst_object_unref0 (_tmp0_), _tmp1_)) { +#line 260 "MediaEngine.vala" + g_error ("MediaEngine.vala:260: couldn't link pad to converter"); +#line 1923 "MediaEngine.c" + } +} + + +#line 264 "MediaEngine.vala" +static void view_media_video_track_real_unlink_pad (ViewMediaTrack* base, GstPad* pad, GstElement* track_element) { +#line 1930 "MediaEngine.c" + ViewMediaVideoTrack * self; + GstPad* _tmp0_; + self = VIEW_MEDIA_VIDEO_TRACK (base); +#line 264 "MediaEngine.vala" + g_return_if_fail (GST_IS_PAD (pad)); +#line 264 "MediaEngine.vala" + g_return_if_fail (GST_IS_ELEMENT (track_element)); +#line 265 "MediaEngine.vala" + gst_pad_unlink (pad, _tmp0_ = gst_element_get_static_pad (track_element, "sink")); +#line 1940 "MediaEngine.c" + _gst_object_unref0 (_tmp0_); +} + + +static void view_media_video_track_class_init (ViewMediaVideoTrackClass * klass) { + view_media_video_track_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ViewMediaVideoTrackPrivate)); + VIEW_MEDIA_TRACK_CLASS (klass)->get_element = view_media_video_track_real_get_element; + VIEW_MEDIA_TRACK_CLASS (klass)->empty_element = view_media_video_track_real_empty_element; + VIEW_MEDIA_TRACK_CLASS (klass)->link_new_pad = view_media_video_track_real_link_new_pad; + VIEW_MEDIA_TRACK_CLASS (klass)->unlink_pad = view_media_video_track_real_unlink_pad; + G_OBJECT_CLASS (klass)->finalize = view_media_video_track_finalize; +} + + +static void view_media_video_track_instance_init (ViewMediaVideoTrack * self) { + self->priv = VIEW_MEDIA_VIDEO_TRACK_GET_PRIVATE (self); +} + + +static void view_media_video_track_finalize (GObject* obj) { + ViewMediaVideoTrack * self; + self = VIEW_MEDIA_VIDEO_TRACK (obj); + G_OBJECT_CLASS (view_media_video_track_parent_class)->finalize (obj); +} + + +GType view_media_video_track_get_type (void) { + static volatile gsize view_media_video_track_type_id__volatile = 0; + if (g_once_init_enter (&view_media_video_track_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ViewMediaVideoTrackClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_media_video_track_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewMediaVideoTrack), 0, (GInstanceInitFunc) view_media_video_track_instance_init, NULL }; + GType view_media_video_track_type_id; + view_media_video_track_type_id = g_type_register_static (VIEW_TYPE_MEDIA_TRACK, "ViewMediaVideoTrack", &g_define_type_info, 0); + g_once_init_leave (&view_media_video_track_type_id__volatile, view_media_video_track_type_id); + } + return view_media_video_track_type_id__volatile; +} + + +#line 302 "MediaEngine.vala" +static void _view_click_track_on_playstate_changed_view_media_engine_playstate_changed (ViewMediaEngine* _sender, gpointer self) { +#line 1982 "MediaEngine.c" + view_click_track_on_playstate_changed (self); +} + + +static void _g_list_free_g_free (GList* self) { + g_list_foreach (self, (GFunc) g_free, NULL); + g_list_free (self); +} + + +#line 277 "MediaEngine.vala" +ViewClickTrack* view_click_track_construct (GType object_type, ViewMediaEngine* engine, ModelProject* project, GError** error) { +#line 1995 "MediaEngine.c" + GError * _inner_error_; + ViewClickTrack * self; + GstElement* _tmp0_; + GstElement* _tmp1_; + GstElement* _tmp2_; + GstElement* _tmp3_; + GstElement* _tmp4_; + GstElement* _tmp5_; + GList* list; + GstController* _tmp6_; + GstController* _tmp7_; +#line 277 "MediaEngine.vala" + g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (engine), NULL); +#line 277 "MediaEngine.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (project), NULL); +#line 2011 "MediaEngine.c" + _inner_error_ = NULL; +#line 277 "MediaEngine.vala" + self = (ViewClickTrack*) g_object_new (object_type, NULL); +#line 278 "MediaEngine.vala" + self->priv->project = project; +#line 279 "MediaEngine.vala" + _tmp0_ = make_element ("audiotestsrc", &_inner_error_); +#line 2019 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 279 "MediaEngine.vala" + self->priv->audio_source = (_tmp1_ = _tmp0_, _gst_object_unref0 (self->priv->audio_source), _tmp1_); +#line 280 "MediaEngine.vala" + _tmp2_ = make_element ("audioconvert", &_inner_error_); +#line 2029 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 280 "MediaEngine.vala" + self->priv->audio_convert = (_tmp3_ = _tmp2_, _gst_object_unref0 (self->priv->audio_convert), _tmp3_); +#line 281 "MediaEngine.vala" + _tmp4_ = make_element ("volume", &_inner_error_); +#line 2039 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 281 "MediaEngine.vala" + self->priv->volume = (_tmp5_ = _tmp4_, _gst_object_unref0 (self->priv->volume), _tmp5_); +#line 282 "MediaEngine.vala" + list = NULL; +#line 283 "MediaEngine.vala" + list = g_list_append (list, g_strdup ("freq")); +#line 284 "MediaEngine.vala" + self->priv->click_controller = (_tmp6_ = gst_controller_new_list (G_OBJECT (self->priv->audio_source), list), _g_object_unref0 (self->priv->click_controller), _tmp6_); +#line 285 "MediaEngine.vala" + list = g_list_remove_all (list, "freq"); +#line 286 "MediaEngine.vala" + list = g_list_append (list, g_strdup ("mute")); +#line 287 "MediaEngine.vala" + self->priv->volume_controller = (_tmp7_ = gst_controller_new_list (G_OBJECT (self->priv->volume), list), _g_object_unref0 (self->priv->volume_controller), _tmp7_); +#line 288 "MediaEngine.vala" + gst_bin_add_many (GST_BIN (engine->pipeline), _gst_object_ref0 (self->priv->audio_source), _gst_object_ref0 (self->priv->volume), _gst_object_ref0 (self->priv->audio_convert), NULL); +#line 289 "MediaEngine.vala" + g_object_set (G_OBJECT (self->priv->audio_source), "volume", project->click_volume, NULL); +#line 291 "MediaEngine.vala" + gst_element_link_many (self->priv->audio_source, self->priv->audio_convert, self->priv->volume, engine->adder, NULL); +#line 292 "MediaEngine.vala" + g_signal_connect_object (engine, "playstate-changed", (GCallback) _view_click_track_on_playstate_changed_view_media_engine_playstate_changed, self, 0); +#line 2067 "MediaEngine.c" + __g_list_free_g_free0 (list); + return self; +} + + +#line 277 "MediaEngine.vala" +ViewClickTrack* view_click_track_new (ViewMediaEngine* engine, ModelProject* project, GError** error) { +#line 277 "MediaEngine.vala" + return view_click_track_construct (VIEW_TYPE_CLICK_TRACK, engine, project, error); +#line 2077 "MediaEngine.c" +} + + +#line 295 "MediaEngine.vala" +static void view_click_track_clear_controllers (ViewClickTrack* self) { +#line 295 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_CLICK_TRACK (self)); +#line 296 "MediaEngine.vala" + gst_controller_unset_all (self->priv->volume_controller, "mute"); +#line 297 "MediaEngine.vala" + gst_controller_unset_all (self->priv->click_controller, "freq"); +#line 298 "MediaEngine.vala" + g_object_set (G_OBJECT (self->priv->volume), "mute", TRUE, NULL); +#line 299 "MediaEngine.vala" + g_object_set (G_OBJECT (self->priv->volume), "volume", 0.0, NULL); +#line 2093 "MediaEngine.c" +} + + +#line 302 "MediaEngine.vala" +static void view_click_track_on_playstate_changed (ViewClickTrack* self) { +#line 302 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_CLICK_TRACK (self)); +#line 303 "MediaEngine.vala" + switch (view_media_engine_get_play_state (self->priv->project->media_engine)) { +#line 2103 "MediaEngine.c" + case PLAY_STATE_PRE_EXPORT: + case PLAY_STATE_STOPPED: + { +#line 306 "MediaEngine.vala" + view_click_track_clear_controllers (self); +#line 307 "MediaEngine.vala" + break; +#line 2111 "MediaEngine.c" + } + case PLAY_STATE_PLAYING: + { + { +#line 309 "MediaEngine.vala" + if (self->priv->project->click_during_play) { +#line 2118 "MediaEngine.c" + Fraction _tmp1_; + Fraction _tmp0_ = {0}; +#line 310 "MediaEngine.vala" + view_click_track_setup_clicks (self, model_tempo_information_get_bpm (MODEL_TEMPO_INFORMATION (self->priv->project)), (_tmp1_ = (model_tempo_information_get_time_signature (MODEL_TEMPO_INFORMATION (self->priv->project), &_tmp0_), _tmp0_), &_tmp1_)); +#line 2123 "MediaEngine.c" + } else { +#line 312 "MediaEngine.vala" + view_click_track_clear_controllers (self); +#line 2127 "MediaEngine.c" + } + } +#line 315 "MediaEngine.vala" + break; +#line 2132 "MediaEngine.c" + } + case PLAY_STATE_PRE_RECORD: + { + { +#line 317 "MediaEngine.vala" + if (self->priv->project->click_during_record) { +#line 2139 "MediaEngine.c" + Fraction _tmp3_; + Fraction _tmp2_ = {0}; +#line 318 "MediaEngine.vala" + view_click_track_setup_clicks (self, model_tempo_information_get_bpm (MODEL_TEMPO_INFORMATION (self->priv->project)), (_tmp3_ = (model_tempo_information_get_time_signature (MODEL_TEMPO_INFORMATION (self->priv->project), &_tmp2_), _tmp2_), &_tmp3_)); +#line 2144 "MediaEngine.c" + } else { + Fraction _tmp5_; + Fraction _tmp4_ = {0}; +#line 322 "MediaEngine.vala" + view_click_track_setup_clicks (self, model_tempo_information_get_bpm (MODEL_TEMPO_INFORMATION (self->priv->project)), (_tmp5_ = (model_tempo_information_get_time_signature (MODEL_TEMPO_INFORMATION (self->priv->project), &_tmp4_), _tmp4_), &_tmp5_)); +#line 323 "MediaEngine.vala" + view_click_track_clear_controllers (self); +#line 2152 "MediaEngine.c" + } + } +#line 326 "MediaEngine.vala" + break; +#line 2157 "MediaEngine.c" + } + } +} + + +#line 330 "MediaEngine.vala" +static void view_click_track_setup_clicks (ViewClickTrack* self, gint bpm, Fraction* time_signature) { +#line 2165 "MediaEngine.c" + GValue double_value = {0}; + GValue bool_value = {0}; + GstClockTime time; + gint64 conversion; + guint64 current_time; +#line 330 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_CLICK_TRACK (self)); +#line 331 "MediaEngine.vala" + view_click_track_clear_controllers (self); +#line 332 "MediaEngine.vala" + g_object_set (G_OBJECT (self->priv->volume), "volume", self->priv->project->click_volume / 10, NULL); +#line 2177 "MediaEngine.c" + memset (&double_value, 0, sizeof (GValue)); +#line 335 "MediaEngine.vala" + g_value_init (&double_value, g_type_from_name ("gdouble")); +#line 2181 "MediaEngine.c" + memset (&bool_value, 0, sizeof (GValue)); +#line 337 "MediaEngine.vala" + g_value_init (&bool_value, g_type_from_name ("gboolean")); +#line 339 "MediaEngine.vala" + time = (GstClockTime) 0; +#line 340 "MediaEngine.vala" + g_value_set_boolean (&bool_value, TRUE); +#line 341 "MediaEngine.vala" + gst_controller_set (self->priv->volume_controller, "volume", time, &bool_value); +#line 343 "MediaEngine.vala" + conversion = (gint64) ((GST_SECOND * 60) / bpm); +#line 344 "MediaEngine.vala" + current_time = (guint64) 0; +#line 2195 "MediaEngine.c" + { + gint i; +#line 346 "MediaEngine.vala" + i = 0; +#line 2200 "MediaEngine.c" + { + gboolean _tmp0_; +#line 346 "MediaEngine.vala" + _tmp0_ = TRUE; +#line 346 "MediaEngine.vala" + while (TRUE) { +#line 346 "MediaEngine.vala" + if (!_tmp0_) { +#line 346 "MediaEngine.vala" + i = i + 1; +#line 2211 "MediaEngine.c" + } +#line 346 "MediaEngine.vala" + _tmp0_ = FALSE; +#line 346 "MediaEngine.vala" + if (!(current_time < ((GST_SECOND * 60) * 10))) { +#line 346 "MediaEngine.vala" + break; +#line 2219 "MediaEngine.c" + } +#line 347 "MediaEngine.vala" + current_time = (guint64) (i * conversion); +#line 348 "MediaEngine.vala" + if (i > 0) { +#line 349 "MediaEngine.vala" + time = (GstClockTime) (current_time - (GST_SECOND / 10)); +#line 350 "MediaEngine.vala" + g_value_set_boolean (&bool_value, TRUE); +#line 351 "MediaEngine.vala" + gst_controller_set (self->priv->volume_controller, "mute", time, &bool_value); +#line 2231 "MediaEngine.c" + } +#line 353 "MediaEngine.vala" + time = (GstClockTime) current_time; +#line 354 "MediaEngine.vala" + if ((i % (*time_signature).numerator) == 0) { +#line 355 "MediaEngine.vala" + g_value_set_double (&double_value, 880.0); +#line 2239 "MediaEngine.c" + } else { +#line 357 "MediaEngine.vala" + g_value_set_double (&double_value, 440.0); +#line 2243 "MediaEngine.c" + } +#line 359 "MediaEngine.vala" + gst_controller_set (self->priv->click_controller, "freq", time, &double_value); +#line 360 "MediaEngine.vala" + g_value_set_boolean (&bool_value, FALSE); +#line 361 "MediaEngine.vala" + gst_controller_set (self->priv->volume_controller, "mute", time, &bool_value); +#line 363 "MediaEngine.vala" + time = (GstClockTime) (current_time + (GST_SECOND / 10)); +#line 364 "MediaEngine.vala" + g_value_set_boolean (&bool_value, TRUE); +#line 365 "MediaEngine.vala" + gst_controller_set (self->priv->volume_controller, "mute", time, &bool_value); +#line 2257 "MediaEngine.c" + } + } + } +} + + +static void view_click_track_class_init (ViewClickTrackClass * klass) { + view_click_track_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ViewClickTrackPrivate)); + G_OBJECT_CLASS (klass)->finalize = view_click_track_finalize; +} + + +static void view_click_track_instance_init (ViewClickTrack * self) { + self->priv = VIEW_CLICK_TRACK_GET_PRIVATE (self); +} + + +static void view_click_track_finalize (GObject* obj) { + ViewClickTrack * self; + self = VIEW_CLICK_TRACK (obj); + _g_object_unref0 (self->priv->click_controller); + _g_object_unref0 (self->priv->volume_controller); + _gst_object_unref0 (self->priv->audio_source); + _gst_object_unref0 (self->priv->audio_convert); + _gst_object_unref0 (self->priv->volume); + G_OBJECT_CLASS (view_click_track_parent_class)->finalize (obj); +} + + +GType view_click_track_get_type (void) { + static volatile gsize view_click_track_type_id__volatile = 0; + if (g_once_init_enter (&view_click_track_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ViewClickTrackClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_click_track_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewClickTrack), 0, (GInstanceInitFunc) view_click_track_instance_init, NULL }; + GType view_click_track_type_id; + view_click_track_type_id = g_type_register_static (G_TYPE_OBJECT, "ViewClickTrack", &g_define_type_info, 0); + g_once_init_leave (&view_click_track_type_id__volatile, view_click_track_type_id); + } + return view_click_track_type_id__volatile; +} + + +#line 426 "MediaEngine.vala" +static void _view_media_audio_track_on_parameter_changed_model_audio_track_parameter_changed (ModelAudioTrack* _sender, ModelParameter parameter, double new_value, gpointer self) { +#line 2302 "MediaEngine.c" + view_media_audio_track_on_parameter_changed (self, parameter, new_value); +} + + +#line 438 "MediaEngine.vala" +static void _view_media_audio_track_on_level_changed_view_media_engine_level_changed (ViewMediaEngine* _sender, GstObject* source, double level_left, double level_right, gpointer self) { +#line 2309 "MediaEngine.c" + view_media_audio_track_on_level_changed (self, source, level_left, level_right); +} + + +#line 610 "track.vala" +static void _model_audio_track_on_level_changed_view_media_audio_track_level_changed (ViewMediaAudioTrack* _sender, double level_left, double level_right, gpointer self) { +#line 2316 "MediaEngine.c" + model_audio_track_on_level_changed (self, level_left, level_right); +} + + +#line 378 "MediaEngine.vala" +ViewMediaAudioTrack* view_media_audio_track_construct (GType object_type, ViewMediaEngine* media_engine, ModelAudioTrack* track, GError** error) { +#line 2323 "MediaEngine.c" + GError * _inner_error_; + ViewMediaAudioTrack * self; + GstElement* _tmp0_; + GstElement* _tmp1_; + GstElement* _tmp2_; + GstElement* _tmp3_; + GstElement* _tmp4_; + GstElement* _tmp5_; + GstElement* _tmp6_; + GstElement* _tmp7_; + GstElement* _tmp8_; + GstElement* _tmp9_; + GValue _tmp10_ = {0}; + GValue the_level; + GValue _tmp11_ = {0}; + GValue true_value; +#line 378 "MediaEngine.vala" + g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (media_engine), NULL); +#line 378 "MediaEngine.vala" + g_return_val_if_fail (MODEL_IS_AUDIO_TRACK (track), NULL); +#line 2344 "MediaEngine.c" + _inner_error_ = NULL; +#line 379 "MediaEngine.vala" + self = (ViewMediaAudioTrack*) view_media_track_construct (object_type, media_engine, MODEL_TRACK (track), error); +#line 380 "MediaEngine.vala" + g_signal_connect_object (track, "parameter-changed", (GCallback) _view_media_audio_track_on_parameter_changed_model_audio_track_parameter_changed, self, 0); +#line 382 "MediaEngine.vala" + _tmp0_ = make_element ("audioconvert", &_inner_error_); +#line 2352 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 382 "MediaEngine.vala" + self->priv->audio_convert = (_tmp1_ = _tmp0_, _gst_object_unref0 (self->priv->audio_convert), _tmp1_); +#line 383 "MediaEngine.vala" + _tmp2_ = make_element ("audioresample", &_inner_error_); +#line 2362 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 383 "MediaEngine.vala" + self->priv->audio_resample = (_tmp3_ = _tmp2_, _gst_object_unref0 (self->priv->audio_resample), _tmp3_); +#line 384 "MediaEngine.vala" + _tmp4_ = make_element ("level", &_inner_error_); +#line 2372 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 384 "MediaEngine.vala" + self->priv->level = (_tmp5_ = _tmp4_, _gst_object_unref0 (self->priv->level), _tmp5_); +#line 386 "MediaEngine.vala" + _tmp6_ = make_element ("audiopanorama", &_inner_error_); +#line 2382 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 386 "MediaEngine.vala" + self->priv->pan = (_tmp7_ = _tmp6_, _gst_object_unref0 (self->priv->pan), _tmp7_); +#line 387 "MediaEngine.vala" + view_media_audio_track_on_parameter_changed (self, MODEL_PARAMETER_PAN, model_audio_track_get_pan (track)); +#line 388 "MediaEngine.vala" + _tmp8_ = make_element ("volume", &_inner_error_); +#line 2394 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 388 "MediaEngine.vala" + self->priv->volume = (_tmp9_ = _tmp8_, _gst_object_unref0 (self->priv->volume), _tmp9_); +#line 389 "MediaEngine.vala" + view_media_audio_track_on_parameter_changed (self, MODEL_PARAMETER_VOLUME, model_audio_track_get_volume (track)); +#line 391 "MediaEngine.vala" + the_level = (g_value_init (&_tmp10_, G_TYPE_UINT64), g_value_set_uint64 (&_tmp10_, (guint64) (GST_SECOND / 30)), _tmp10_); +#line 392 "MediaEngine.vala" + g_object_set_property (G_OBJECT (self->priv->level), "interval", &the_level); +#line 393 "MediaEngine.vala" + true_value = (g_value_init (&_tmp11_, G_TYPE_BOOLEAN), g_value_set_boolean (&_tmp11_, TRUE), _tmp11_); +#line 394 "MediaEngine.vala" + g_object_set_property (G_OBJECT (self->priv->level), "message", &true_value); +#line 396 "MediaEngine.vala" + if (!gst_bin_add (GST_BIN (media_engine->pipeline), _gst_object_ref0 (self->priv->audio_convert))) { +#line 397 "MediaEngine.vala" + g_error ("MediaEngine.vala:397: could not add audio_convert"); +#line 2416 "MediaEngine.c" + } +#line 400 "MediaEngine.vala" + if (!gst_bin_add (GST_BIN (media_engine->pipeline), _gst_object_ref0 (self->priv->audio_resample))) { +#line 401 "MediaEngine.vala" + g_error ("MediaEngine.vala:401: could not add audio_resample"); +#line 2422 "MediaEngine.c" + } +#line 404 "MediaEngine.vala" + if (!gst_bin_add (GST_BIN (media_engine->pipeline), _gst_object_ref0 (self->priv->level))) { +#line 405 "MediaEngine.vala" + g_error ("MediaEngine.vala:405: could not add level"); +#line 2428 "MediaEngine.c" + } +#line 408 "MediaEngine.vala" + if (!gst_bin_add (GST_BIN (media_engine->pipeline), _gst_object_ref0 (self->priv->pan))) { +#line 409 "MediaEngine.vala" + g_error ("MediaEngine.vala:409: could not add pan"); +#line 2434 "MediaEngine.c" + } +#line 412 "MediaEngine.vala" + if (!gst_bin_add (GST_BIN (media_engine->pipeline), _gst_object_ref0 (self->priv->volume))) { +#line 413 "MediaEngine.vala" + g_error ("MediaEngine.vala:413: could not add volume"); +#line 2440 "MediaEngine.c" + } +#line 415 "MediaEngine.vala" + g_signal_connect_object (media_engine, "level-changed", (GCallback) _view_media_audio_track_on_level_changed_view_media_engine_level_changed, self, 0); +#line 416 "MediaEngine.vala" + g_signal_connect_object (self, "level-changed", (GCallback) _model_audio_track_on_level_changed_view_media_audio_track_level_changed, track, 0); +#line 2446 "MediaEngine.c" + G_IS_VALUE (&the_level) ? (g_value_unset (&the_level), NULL) : NULL; + G_IS_VALUE (&true_value) ? (g_value_unset (&true_value), NULL) : NULL; + return self; +} + + +#line 378 "MediaEngine.vala" +ViewMediaAudioTrack* view_media_audio_track_new (ViewMediaEngine* media_engine, ModelAudioTrack* track, GError** error) { +#line 378 "MediaEngine.vala" + return view_media_audio_track_construct (VIEW_TYPE_MEDIA_AUDIO_TRACK, media_engine, track, error); +#line 2457 "MediaEngine.c" +} + + +#line 426 "MediaEngine.vala" +static void view_media_audio_track_on_parameter_changed (ViewMediaAudioTrack* self, ModelParameter parameter, double new_value) { +#line 426 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_AUDIO_TRACK (self)); +#line 427 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_parameter_changed"); +#line 428 "MediaEngine.vala" + switch (parameter) { +#line 2469 "MediaEngine.c" + case MODEL_PARAMETER_PAN: + { + GValue _tmp1_; + GValue _tmp0_ = {0}; +#line 430 "MediaEngine.vala" + g_object_set_property (G_OBJECT (self->priv->pan), "panorama", (_tmp1_ = (g_value_init (&_tmp0_, G_TYPE_DOUBLE), g_value_set_double (&_tmp0_, new_value), _tmp0_), &_tmp1_)); +#line 431 "MediaEngine.vala" + break; +#line 2478 "MediaEngine.c" + } + case MODEL_PARAMETER_VOLUME: + { + GValue _tmp3_; + GValue _tmp2_ = {0}; +#line 433 "MediaEngine.vala" + g_object_set_property (G_OBJECT (self->priv->volume), "volume", (_tmp3_ = (g_value_init (&_tmp2_, G_TYPE_DOUBLE), g_value_set_double (&_tmp2_, new_value), _tmp2_), &_tmp3_)); +#line 434 "MediaEngine.vala" + break; +#line 2488 "MediaEngine.c" + } + } +} + + +#line 438 "MediaEngine.vala" +static void view_media_audio_track_on_level_changed (ViewMediaAudioTrack* self, GstObject* source, double level_left, double level_right) { +#line 438 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_AUDIO_TRACK (self)); +#line 438 "MediaEngine.vala" + g_return_if_fail (GST_IS_OBJECT (source)); +#line 439 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_level_changed"); +#line 440 "MediaEngine.vala" + if (source == GST_OBJECT (self->priv->level)) { +#line 441 "MediaEngine.vala" + g_signal_emit_by_name (self, "level-changed", level_left, level_right); +#line 2506 "MediaEngine.c" + } +} + + +#line 445 "MediaEngine.vala" +static GstElement* view_media_audio_track_real_empty_element (ViewMediaTrack* base, GError** error) { +#line 2513 "MediaEngine.c" + ViewMediaAudioTrack * self; + GstElement* result = NULL; + GError * _inner_error_; + GstElement* _tmp0_; + self = VIEW_MEDIA_AUDIO_TRACK (base); + _inner_error_ = NULL; +#line 446 "MediaEngine.vala" + _tmp0_ = view_media_engine_get_audio_silence (VIEW_MEDIA_TRACK (self)->media_engine, &_inner_error_); +#line 2522 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + return NULL; + } + result = _tmp0_; +#line 446 "MediaEngine.vala" + return result; +#line 2530 "MediaEngine.c" +} + + +#line 449 "MediaEngine.vala" +static void view_media_audio_track_real_link_new_pad (ViewMediaTrack* base, GstPad* pad, GstElement* track_element) { +#line 2536 "MediaEngine.c" + ViewMediaAudioTrack * self; + GstBin* bin; + GstPad* volume_pad; + GstPad* _tmp0_; + self = VIEW_MEDIA_AUDIO_TRACK (base); +#line 449 "MediaEngine.vala" + g_return_if_fail (GST_IS_PAD (pad)); +#line 449 "MediaEngine.vala" + g_return_if_fail (GST_IS_ELEMENT (track_element)); +#line 450 "MediaEngine.vala" + bin = _gst_object_ref0 (GST_BIN (gst_pad_get_parent_element (pad))); +#line 451 "MediaEngine.vala" + if (!gst_element_link_many (GST_ELEMENT (bin), self->priv->audio_convert, self->priv->audio_resample, self->priv->level, self->priv->pan, self->priv->volume, NULL)) { +#line 452 "MediaEngine.vala" + fprintf (stderr, "could not link_new_pad for audio track"); +#line 2552 "MediaEngine.c" + } +#line 455 "MediaEngine.vala" + volume_pad = gst_element_get_pad (self->priv->volume, "src"); +#line 456 "MediaEngine.vala" + self->priv->adder_pad = (_tmp0_ = _gst_object_ref0 (GST_ELEMENT_GET_CLASS (track_element)->request_new_pad (track_element, gst_element_get_compatible_pad_template (track_element, gst_pad_get_pad_template (volume_pad)), NULL)), _gst_object_unref0 (self->priv->adder_pad), _tmp0_); +#line 459 "MediaEngine.vala" + if (gst_pad_link (volume_pad, self->priv->adder_pad) != GST_PAD_LINK_OK) { +#line 460 "MediaEngine.vala" + g_error ("MediaEngine.vala:460: could not link to adder %s->%s\n", gst_object_get_name (GST_OBJECT (self->priv->volume)), gst_object_get_name (GST_OBJECT (track_element))); +#line 2562 "MediaEngine.c" + } + _gst_object_unref0 (bin); + _gst_object_unref0 (volume_pad); +} + + +#line 464 "MediaEngine.vala" +static void view_media_audio_track_real_unlink_pad (ViewMediaTrack* base, GstPad* pad, GstElement* track_element) { +#line 2571 "MediaEngine.c" + ViewMediaAudioTrack * self; + GstBin* bin; + self = VIEW_MEDIA_AUDIO_TRACK (base); +#line 464 "MediaEngine.vala" + g_return_if_fail (GST_IS_PAD (pad)); +#line 464 "MediaEngine.vala" + g_return_if_fail (GST_IS_ELEMENT (track_element)); +#line 465 "MediaEngine.vala" + bin = _gst_object_ref0 (GST_BIN (gst_pad_get_parent_element (pad))); +#line 466 "MediaEngine.vala" + gst_element_unlink_many (GST_ELEMENT (bin), self->priv->audio_convert, self->priv->audio_resample, self->priv->level, self->priv->pan, self->priv->volume, track_element, NULL); +#line 467 "MediaEngine.vala" + gst_element_release_request_pad (track_element, self->priv->adder_pad); +#line 2585 "MediaEngine.c" + _gst_object_unref0 (bin); +} + + +#line 470 "MediaEngine.vala" +static GstElement* view_media_audio_track_real_get_element (ViewMediaTrack* base) { +#line 2592 "MediaEngine.c" + ViewMediaAudioTrack * self; + GstElement* result = NULL; + self = VIEW_MEDIA_AUDIO_TRACK (base); + result = _gst_object_ref0 (VIEW_MEDIA_TRACK (self)->media_engine->adder); +#line 471 "MediaEngine.vala" + return result; +#line 2599 "MediaEngine.c" +} + + +static void view_media_audio_track_class_init (ViewMediaAudioTrackClass * klass) { + view_media_audio_track_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ViewMediaAudioTrackPrivate)); + VIEW_MEDIA_TRACK_CLASS (klass)->empty_element = view_media_audio_track_real_empty_element; + VIEW_MEDIA_TRACK_CLASS (klass)->link_new_pad = view_media_audio_track_real_link_new_pad; + VIEW_MEDIA_TRACK_CLASS (klass)->unlink_pad = view_media_audio_track_real_unlink_pad; + VIEW_MEDIA_TRACK_CLASS (klass)->get_element = view_media_audio_track_real_get_element; + G_OBJECT_CLASS (klass)->finalize = view_media_audio_track_finalize; + g_signal_new ("level_changed", VIEW_TYPE_MEDIA_AUDIO_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__DOUBLE_DOUBLE, G_TYPE_NONE, 2, G_TYPE_DOUBLE, G_TYPE_DOUBLE); +} + + +static void view_media_audio_track_instance_init (ViewMediaAudioTrack * self) { + self->priv = VIEW_MEDIA_AUDIO_TRACK_GET_PRIVATE (self); +} + + +static void view_media_audio_track_finalize (GObject* obj) { + ViewMediaAudioTrack * self; + self = VIEW_MEDIA_AUDIO_TRACK (obj); + { + guint _tmp5_; +#line 420 "MediaEngine.vala" + g_signal_parse_name ("level-changed", VIEW_TYPE_MEDIA_ENGINE, &_tmp5_, NULL, FALSE); +#line 420 "MediaEngine.vala" + g_signal_handlers_disconnect_matched (VIEW_MEDIA_TRACK (self)->media_engine, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp5_, 0, NULL, (GCallback) _view_media_audio_track_on_level_changed_view_media_engine_level_changed, self); +#line 421 "MediaEngine.vala" + gst_bin_remove_many (GST_BIN (VIEW_MEDIA_TRACK (self)->media_engine->pipeline), self->priv->audio_convert, self->priv->audio_resample, self->priv->pan, self->priv->volume, self->priv->level, NULL); +#line 2631 "MediaEngine.c" + } + _gst_object_unref0 (self->priv->audio_convert); + _gst_object_unref0 (self->priv->audio_resample); + _gst_object_unref0 (self->priv->level); + _gst_object_unref0 (self->priv->pan); + _gst_object_unref0 (self->priv->volume); + _gst_object_unref0 (self->priv->adder_pad); + G_OBJECT_CLASS (view_media_audio_track_parent_class)->finalize (obj); +} + + +GType view_media_audio_track_get_type (void) { + static volatile gsize view_media_audio_track_type_id__volatile = 0; + if (g_once_init_enter (&view_media_audio_track_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ViewMediaAudioTrackClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_media_audio_track_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewMediaAudioTrack), 0, (GInstanceInitFunc) view_media_audio_track_instance_init, NULL }; + GType view_media_audio_track_type_id; + view_media_audio_track_type_id = g_type_register_static (VIEW_TYPE_MEDIA_TRACK, "ViewMediaAudioTrack", &g_define_type_info, 0); + g_once_init_leave (&view_media_audio_track_type_id__volatile, view_media_audio_track_type_id); + } + return view_media_audio_track_type_id__volatile; +} + + +GType view_media_connector_media_types_get_type (void) { + static volatile gsize view_media_connector_media_types_type_id__volatile = 0; + if (g_once_init_enter (&view_media_connector_media_types_type_id__volatile)) { + static const GEnumValue values[] = {{VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Audio, "VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Audio", "audio"}, {VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Video, "VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Video", "video"}, {0, NULL, NULL}}; + GType view_media_connector_media_types_type_id; + view_media_connector_media_types_type_id = g_enum_register_static ("ViewMediaConnectorMediaTypes", values); + g_once_init_leave (&view_media_connector_media_types_type_id__volatile, view_media_connector_media_types_type_id); + } + return view_media_connector_media_types_type_id__volatile; +} + + +#line 483 "MediaEngine.vala" +ViewMediaConnector* view_media_connector_construct (GType object_type, ViewMediaConnectorMediaTypes media_types) { +#line 2669 "MediaEngine.c" + ViewMediaConnector * self; +#line 483 "MediaEngine.vala" + self = (ViewMediaConnector*) g_object_new (object_type, NULL); +#line 484 "MediaEngine.vala" + self->priv->media_types = media_types; +#line 2675 "MediaEngine.c" + return self; +} + + +#line 487 "MediaEngine.vala" +gboolean view_media_connector_has_audio (ViewMediaConnector* self) { +#line 2682 "MediaEngine.c" + gboolean result = FALSE; +#line 487 "MediaEngine.vala" + g_return_val_if_fail (VIEW_IS_MEDIA_CONNECTOR (self), FALSE); +#line 2686 "MediaEngine.c" + result = (self->priv->media_types & VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Audio) == VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Audio; +#line 488 "MediaEngine.vala" + return result; +#line 2690 "MediaEngine.c" +} + + +#line 491 "MediaEngine.vala" +gboolean view_media_connector_has_video (ViewMediaConnector* self) { +#line 2696 "MediaEngine.c" + gboolean result = FALSE; +#line 491 "MediaEngine.vala" + g_return_val_if_fail (VIEW_IS_MEDIA_CONNECTOR (self), FALSE); +#line 2700 "MediaEngine.c" + result = (self->priv->media_types & VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Video) == VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Video; +#line 492 "MediaEngine.vala" + return result; +#line 2704 "MediaEngine.c" +} + + +#line 495 "MediaEngine.vala" +static void view_media_connector_real_connect (ViewMediaConnector* self, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1) { +#line 2710 "MediaEngine.c" + g_return_if_fail (VIEW_IS_MEDIA_CONNECTOR (self)); + g_critical ("Type `%s' does not implement abstract method `view_media_connector_connect'", g_type_name (G_TYPE_FROM_INSTANCE (self))); + return; +} + + +#line 495 "MediaEngine.vala" +void view_media_connector_connect (ViewMediaConnector* self, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1) { +#line 495 "MediaEngine.vala" + VIEW_MEDIA_CONNECTOR_GET_CLASS (self)->connect (self, media_engine, pipeline, elements, elements_length1); +#line 2721 "MediaEngine.c" +} + + +#line 497 "MediaEngine.vala" +static void view_media_connector_real_do_disconnect (ViewMediaConnector* self, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1) { +#line 2727 "MediaEngine.c" + g_return_if_fail (VIEW_IS_MEDIA_CONNECTOR (self)); + g_critical ("Type `%s' does not implement abstract method `view_media_connector_do_disconnect'", g_type_name (G_TYPE_FROM_INSTANCE (self))); + return; +} + + +#line 497 "MediaEngine.vala" +void view_media_connector_do_disconnect (ViewMediaConnector* self, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1) { +#line 497 "MediaEngine.vala" + VIEW_MEDIA_CONNECTOR_GET_CLASS (self)->do_disconnect (self, media_engine, pipeline, elements, elements_length1); +#line 2738 "MediaEngine.c" +} + + +static void view_media_connector_class_init (ViewMediaConnectorClass * klass) { + view_media_connector_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ViewMediaConnectorPrivate)); + VIEW_MEDIA_CONNECTOR_CLASS (klass)->connect = view_media_connector_real_connect; + VIEW_MEDIA_CONNECTOR_CLASS (klass)->do_disconnect = view_media_connector_real_do_disconnect; + G_OBJECT_CLASS (klass)->finalize = view_media_connector_finalize; +} + + +static void view_media_connector_instance_init (ViewMediaConnector * self) { + self->priv = VIEW_MEDIA_CONNECTOR_GET_PRIVATE (self); + self->AudioIndex = 0; + self->VideoIndex = 1; +} + + +static void view_media_connector_finalize (GObject* obj) { + ViewMediaConnector * self; + self = VIEW_MEDIA_CONNECTOR (obj); + G_OBJECT_CLASS (view_media_connector_parent_class)->finalize (obj); +} + + +GType view_media_connector_get_type (void) { + static volatile gsize view_media_connector_type_id__volatile = 0; + if (g_once_init_enter (&view_media_connector_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ViewMediaConnectorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_media_connector_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewMediaConnector), 0, (GInstanceInitFunc) view_media_connector_instance_init, NULL }; + GType view_media_connector_type_id; + view_media_connector_type_id = g_type_register_static (G_TYPE_OBJECT, "ViewMediaConnector", &g_define_type_info, G_TYPE_FLAG_ABSTRACT); + g_once_init_leave (&view_media_connector_type_id__volatile, view_media_connector_type_id); + } + return view_media_connector_type_id__volatile; +} + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 505 "MediaEngine.vala" +ViewVideoOutput* view_video_output_construct (GType object_type, GtkWidget* output_widget, GError** error) { +#line 2784 "MediaEngine.c" + GError * _inner_error_; + ViewVideoOutput * self; + GstElement* _tmp0_; + GstElement* _tmp1_; + GtkWidget* _tmp2_; +#line 505 "MediaEngine.vala" + g_return_val_if_fail (GTK_IS_WIDGET (output_widget), NULL); +#line 2792 "MediaEngine.c" + _inner_error_ = NULL; +#line 506 "MediaEngine.vala" + self = (ViewVideoOutput*) view_media_connector_construct (object_type, VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Video); +#line 507 "MediaEngine.vala" + _tmp0_ = make_element ("xvimagesink", &_inner_error_); +#line 2798 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 507 "MediaEngine.vala" + self->priv->sink = (_tmp1_ = _tmp0_, _gst_object_unref0 (self->priv->sink), _tmp1_); +#line 508 "MediaEngine.vala" + g_object_set (G_OBJECT (self->priv->sink), "force-aspect-ratio", TRUE, NULL); +#line 509 "MediaEngine.vala" + self->priv->output_widget = (_tmp2_ = _g_object_ref0 (output_widget), _g_object_unref0 (self->priv->output_widget), _tmp2_); +#line 2810 "MediaEngine.c" + return self; +} + + +#line 505 "MediaEngine.vala" +ViewVideoOutput* view_video_output_new (GtkWidget* output_widget, GError** error) { +#line 505 "MediaEngine.vala" + return view_video_output_construct (VIEW_TYPE_VIDEO_OUTPUT, output_widget, error); +#line 2819 "MediaEngine.c" +} + + +#line 512 "MediaEngine.vala" +static void view_video_output_real_connect (ViewMediaConnector* base, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1) { +#line 2825 "MediaEngine.c" + ViewVideoOutput * self; + XID xid; + GstXOverlay* overlay; + self = VIEW_VIDEO_OUTPUT (base); +#line 512 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (media_engine)); +#line 512 "MediaEngine.vala" + g_return_if_fail (GST_IS_PIPELINE (pipeline)); +#line 514 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_GRAPH, LOGGING_LEVEL_INFO, "connecting"); +#line 516 "MediaEngine.vala" + xid = gdk_x11_drawable_get_xid (GDK_DRAWABLE (self->priv->output_widget->window)); +#line 517 "MediaEngine.vala" + overlay = _gst_object_ref0 (GST_X_OVERLAY (self->priv->sink)); +#line 518 "MediaEngine.vala" + gst_x_overlay_set_xwindow_id (overlay, (gulong) xid); +#line 522 "MediaEngine.vala" + GTK_WIDGET_UNSET_FLAGS (self->priv->output_widget, GTK_DOUBLE_BUFFERED); +#line 524 "MediaEngine.vala" + if (!gst_bin_add (GST_BIN (pipeline), _gst_object_ref0 (self->priv->sink))) { +#line 525 "MediaEngine.vala" + g_error ("MediaEngine.vala:525: could not add sink"); +#line 2848 "MediaEngine.c" + } +#line 527 "MediaEngine.vala" + if (!gst_element_link (elements[VIEW_MEDIA_CONNECTOR (self)->VideoIndex], self->priv->sink)) { +#line 528 "MediaEngine.vala" + g_error ("MediaEngine.vala:528: can't link converter with video sink!"); +#line 2854 "MediaEngine.c" + } + _gst_object_unref0 (overlay); +} + + +#line 532 "MediaEngine.vala" +static void view_video_output_real_do_disconnect (ViewMediaConnector* base, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1) { +#line 2862 "MediaEngine.c" + ViewVideoOutput * self; + self = VIEW_VIDEO_OUTPUT (base); +#line 532 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (media_engine)); +#line 532 "MediaEngine.vala" + g_return_if_fail (GST_IS_PIPELINE (pipeline)); +#line 534 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_GRAPH, LOGGING_LEVEL_INFO, "disconnecting"); +#line 535 "MediaEngine.vala" + gst_element_unlink (elements[VIEW_MEDIA_CONNECTOR (self)->VideoIndex], self->priv->sink); +#line 536 "MediaEngine.vala" + gst_bin_remove (GST_BIN (pipeline), self->priv->sink); +#line 2875 "MediaEngine.c" +} + + +static void view_video_output_class_init (ViewVideoOutputClass * klass) { + view_video_output_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ViewVideoOutputPrivate)); + VIEW_MEDIA_CONNECTOR_CLASS (klass)->connect = view_video_output_real_connect; + VIEW_MEDIA_CONNECTOR_CLASS (klass)->do_disconnect = view_video_output_real_do_disconnect; + G_OBJECT_CLASS (klass)->finalize = view_video_output_finalize; +} + + +static void view_video_output_instance_init (ViewVideoOutput * self) { + self->priv = VIEW_VIDEO_OUTPUT_GET_PRIVATE (self); +} + + +static void view_video_output_finalize (GObject* obj) { + ViewVideoOutput * self; + self = VIEW_VIDEO_OUTPUT (obj); + _gst_object_unref0 (self->priv->sink); + _g_object_unref0 (self->priv->output_widget); + G_OBJECT_CLASS (view_video_output_parent_class)->finalize (obj); +} + + +GType view_video_output_get_type (void) { + static volatile gsize view_video_output_type_id__volatile = 0; + if (g_once_init_enter (&view_video_output_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ViewVideoOutputClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_video_output_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewVideoOutput), 0, (GInstanceInitFunc) view_video_output_instance_init, NULL }; + GType view_video_output_type_id; + view_video_output_type_id = g_type_register_static (VIEW_TYPE_MEDIA_CONNECTOR, "ViewVideoOutput", &g_define_type_info, 0); + g_once_init_leave (&view_video_output_type_id__volatile, view_video_output_type_id); + } + return view_video_output_type_id__volatile; +} + + +#line 544 "MediaEngine.vala" +ViewAudioOutput* view_audio_output_construct (GType object_type, GstCaps* caps, GError** error) { +#line 2916 "MediaEngine.c" + GError * _inner_error_; + ViewAudioOutput * self; + GstElement* _tmp0_; + GstElement* _tmp1_; + GstElement* _tmp2_; + GstElement* _tmp3_; +#line 544 "MediaEngine.vala" + g_return_val_if_fail (GST_IS_CAPS (caps), NULL); +#line 2925 "MediaEngine.c" + _inner_error_ = NULL; +#line 545 "MediaEngine.vala" + self = (ViewAudioOutput*) view_media_connector_construct (object_type, VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_Audio); +#line 546 "MediaEngine.vala" + _tmp0_ = make_element ("autoaudiosink", &_inner_error_); +#line 2931 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 546 "MediaEngine.vala" + self->priv->audio_sink = (_tmp1_ = _tmp0_, _gst_object_unref0 (self->priv->audio_sink), _tmp1_); +#line 547 "MediaEngine.vala" + _tmp2_ = make_element ("capsfilter", &_inner_error_); +#line 2941 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 547 "MediaEngine.vala" + self->priv->capsfilter = (_tmp3_ = _tmp2_, _gst_object_unref0 (self->priv->capsfilter), _tmp3_); +#line 548 "MediaEngine.vala" + g_object_set (G_OBJECT (self->priv->capsfilter), "caps", caps, NULL); +#line 2951 "MediaEngine.c" + return self; +} + + +#line 544 "MediaEngine.vala" +ViewAudioOutput* view_audio_output_new (GstCaps* caps, GError** error) { +#line 544 "MediaEngine.vala" + return view_audio_output_construct (VIEW_TYPE_AUDIO_OUTPUT, caps, error); +#line 2960 "MediaEngine.c" +} + + +#line 551 "MediaEngine.vala" +static void view_audio_output_real_connect (ViewMediaConnector* base, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1) { +#line 2966 "MediaEngine.c" + ViewAudioOutput * self; + self = VIEW_AUDIO_OUTPUT (base); +#line 551 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (media_engine)); +#line 551 "MediaEngine.vala" + g_return_if_fail (GST_IS_PIPELINE (pipeline)); +#line 553 "MediaEngine.vala" + gst_bin_add_many (GST_BIN (pipeline), _gst_object_ref0 (self->priv->capsfilter), _gst_object_ref0 (self->priv->audio_sink), NULL); +#line 555 "MediaEngine.vala" + if (!gst_element_link_many (elements[VIEW_MEDIA_CONNECTOR (self)->AudioIndex], self->priv->capsfilter, self->priv->audio_sink, NULL)) { +#line 556 "MediaEngine.vala" + g_warning ("MediaEngine.vala:556: could not link audio_sink"); +#line 2979 "MediaEngine.c" + } +} + + +#line 560 "MediaEngine.vala" +static void view_audio_output_real_do_disconnect (ViewMediaConnector* base, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1) { +#line 2986 "MediaEngine.c" + ViewAudioOutput * self; + self = VIEW_AUDIO_OUTPUT (base); +#line 560 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (media_engine)); +#line 560 "MediaEngine.vala" + g_return_if_fail (GST_IS_PIPELINE (pipeline)); +#line 562 "MediaEngine.vala" + gst_element_unlink_many (elements[VIEW_MEDIA_CONNECTOR (self)->AudioIndex], self->priv->capsfilter, self->priv->audio_sink, NULL); +#line 563 "MediaEngine.vala" + gst_bin_remove_many (GST_BIN (pipeline), self->priv->capsfilter, self->priv->audio_sink, NULL); +#line 2997 "MediaEngine.c" +} + + +static void view_audio_output_class_init (ViewAudioOutputClass * klass) { + view_audio_output_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ViewAudioOutputPrivate)); + VIEW_MEDIA_CONNECTOR_CLASS (klass)->connect = view_audio_output_real_connect; + VIEW_MEDIA_CONNECTOR_CLASS (klass)->do_disconnect = view_audio_output_real_do_disconnect; + G_OBJECT_CLASS (klass)->finalize = view_audio_output_finalize; +} + + +static void view_audio_output_instance_init (ViewAudioOutput * self) { + self->priv = VIEW_AUDIO_OUTPUT_GET_PRIVATE (self); +} + + +static void view_audio_output_finalize (GObject* obj) { + ViewAudioOutput * self; + self = VIEW_AUDIO_OUTPUT (obj); + _gst_object_unref0 (self->priv->audio_sink); + _gst_object_unref0 (self->priv->capsfilter); + G_OBJECT_CLASS (view_audio_output_parent_class)->finalize (obj); +} + + +GType view_audio_output_get_type (void) { + static volatile gsize view_audio_output_type_id__volatile = 0; + if (g_once_init_enter (&view_audio_output_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ViewAudioOutputClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_audio_output_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewAudioOutput), 0, (GInstanceInitFunc) view_audio_output_instance_init, NULL }; + GType view_audio_output_type_id; + view_audio_output_type_id = g_type_register_static (VIEW_TYPE_MEDIA_CONNECTOR, "ViewAudioOutput", &g_define_type_info, 0); + g_once_init_leave (&view_audio_output_type_id__volatile, view_audio_output_type_id); + } + return view_audio_output_type_id__volatile; +} + + +#line 574 "MediaEngine.vala" +ViewOggVorbisExport* view_ogg_vorbis_export_construct (GType object_type, ViewMediaConnectorMediaTypes media_types, const char* filename, GstCaps* caps, GError** error) { +#line 3038 "MediaEngine.c" + GError * _inner_error_; + ViewOggVorbisExport * self; + GstElement* _tmp0_; + GstElement* _tmp1_; + GstElement* _tmp2_; + GstElement* _tmp3_; +#line 574 "MediaEngine.vala" + g_return_val_if_fail (filename != NULL, NULL); +#line 574 "MediaEngine.vala" + g_return_val_if_fail (GST_IS_CAPS (caps), NULL); +#line 3049 "MediaEngine.c" + _inner_error_ = NULL; +#line 576 "MediaEngine.vala" + self = (ViewOggVorbisExport*) view_media_connector_construct (object_type, media_types); +#line 578 "MediaEngine.vala" + _tmp0_ = make_element ("filesink", &_inner_error_); +#line 3055 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 578 "MediaEngine.vala" + self->priv->file_sink = (_tmp1_ = _tmp0_, _gst_object_unref0 (self->priv->file_sink), _tmp1_); +#line 579 "MediaEngine.vala" + g_object_set (G_OBJECT (self->priv->file_sink), "location", filename, NULL); +#line 580 "MediaEngine.vala" + _tmp2_ = make_element ("oggmux", &_inner_error_); +#line 3067 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 580 "MediaEngine.vala" + self->priv->mux = (_tmp3_ = _tmp2_, _gst_object_unref0 (self->priv->mux), _tmp3_); +#line 582 "MediaEngine.vala" + if (view_media_connector_has_audio (VIEW_MEDIA_CONNECTOR (self))) { +#line 3077 "MediaEngine.c" + GstElement* _tmp4_; + GstElement* _tmp5_; + GstElement* _tmp6_; + GstElement* _tmp7_; +#line 583 "MediaEngine.vala" + _tmp4_ = make_element ("capsfilter", &_inner_error_); +#line 3084 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 583 "MediaEngine.vala" + self->priv->capsfilter = (_tmp5_ = _tmp4_, _gst_object_unref0 (self->priv->capsfilter), _tmp5_); +#line 584 "MediaEngine.vala" + g_object_set (G_OBJECT (self->priv->capsfilter), "caps", caps, NULL); +#line 585 "MediaEngine.vala" + _tmp6_ = make_element ("vorbisenc", &_inner_error_); +#line 3096 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 585 "MediaEngine.vala" + self->priv->export_sink = (_tmp7_ = _tmp6_, _gst_object_unref0 (self->priv->export_sink), _tmp7_); +#line 3104 "MediaEngine.c" + } +#line 588 "MediaEngine.vala" + if (view_media_connector_has_video (VIEW_MEDIA_CONNECTOR (self))) { +#line 3108 "MediaEngine.c" + GstElement* _tmp8_; + GstElement* _tmp9_; +#line 589 "MediaEngine.vala" + _tmp8_ = make_element ("theoraenc", &_inner_error_); +#line 3113 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 589 "MediaEngine.vala" + self->priv->video_export_sink = (_tmp9_ = _tmp8_, _gst_object_unref0 (self->priv->video_export_sink), _tmp9_); +#line 3121 "MediaEngine.c" + } + return self; +} + + +#line 574 "MediaEngine.vala" +ViewOggVorbisExport* view_ogg_vorbis_export_new (ViewMediaConnectorMediaTypes media_types, const char* filename, GstCaps* caps, GError** error) { +#line 574 "MediaEngine.vala" + return view_ogg_vorbis_export_construct (VIEW_TYPE_OGG_VORBIS_EXPORT, media_types, filename, caps, error); +#line 3131 "MediaEngine.c" +} + + +#line 593 "MediaEngine.vala" +char* view_ogg_vorbis_export_get_filename (ViewOggVorbisExport* self) { +#line 3137 "MediaEngine.c" + char* result = NULL; + char* filename; +#line 593 "MediaEngine.vala" + g_return_val_if_fail (VIEW_IS_OGG_VORBIS_EXPORT (self), NULL); +#line 3142 "MediaEngine.c" + filename = NULL; +#line 595 "MediaEngine.vala" + g_object_get (G_OBJECT (self->priv->file_sink), "location", &filename, NULL); +#line 3146 "MediaEngine.c" + result = filename; +#line 596 "MediaEngine.vala" + return result; +#line 3150 "MediaEngine.c" +} + + +#line 599 "MediaEngine.vala" +static void view_ogg_vorbis_export_real_connect (ViewMediaConnector* base, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1) { +#line 3156 "MediaEngine.c" + ViewOggVorbisExport * self; + self = VIEW_OGG_VORBIS_EXPORT (base); +#line 599 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (media_engine)); +#line 599 "MediaEngine.vala" + g_return_if_fail (GST_IS_PIPELINE (pipeline)); +#line 601 "MediaEngine.vala" + gst_bin_add_many (GST_BIN (pipeline), _gst_object_ref0 (self->priv->mux), _gst_object_ref0 (self->priv->file_sink), NULL); +#line 602 "MediaEngine.vala" + gst_element_link (self->priv->mux, self->priv->file_sink); +#line 604 "MediaEngine.vala" + if (view_media_connector_has_audio (VIEW_MEDIA_CONNECTOR (self))) { +#line 605 "MediaEngine.vala" + gst_bin_add_many (GST_BIN (pipeline), _gst_object_ref0 (self->priv->capsfilter), _gst_object_ref0 (self->priv->export_sink), NULL); +#line 606 "MediaEngine.vala" + gst_element_link_many (elements[VIEW_MEDIA_CONNECTOR (self)->AudioIndex], self->priv->capsfilter, self->priv->export_sink, self->priv->mux, NULL); +#line 3173 "MediaEngine.c" + } +#line 609 "MediaEngine.vala" + if (view_media_connector_has_video (VIEW_MEDIA_CONNECTOR (self))) { +#line 610 "MediaEngine.vala" + gst_bin_add (GST_BIN (pipeline), _gst_object_ref0 (self->priv->video_export_sink)); +#line 612 "MediaEngine.vala" + if (!gst_element_link (elements[VIEW_MEDIA_CONNECTOR (self)->VideoIndex], self->priv->video_export_sink)) { +#line 613 "MediaEngine.vala" + g_error ("MediaEngine.vala:613: could not link converter to video_export_sink"); +#line 3183 "MediaEngine.c" + } +#line 616 "MediaEngine.vala" + if (!gst_element_link (self->priv->video_export_sink, self->priv->mux)) { +#line 617 "MediaEngine.vala" + g_error ("MediaEngine.vala:617: could not link video_export with mux"); +#line 3189 "MediaEngine.c" + } + } +} + + +#line 622 "MediaEngine.vala" +static void view_ogg_vorbis_export_real_do_disconnect (ViewMediaConnector* base, ViewMediaEngine* media_engine, GstPipeline* pipeline, GstElement** elements, int elements_length1) { +#line 3197 "MediaEngine.c" + ViewOggVorbisExport * self; + self = VIEW_OGG_VORBIS_EXPORT (base); +#line 622 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (media_engine)); +#line 622 "MediaEngine.vala" + g_return_if_fail (GST_IS_PIPELINE (pipeline)); +#line 624 "MediaEngine.vala" + if (view_media_connector_has_audio (VIEW_MEDIA_CONNECTOR (self))) { +#line 625 "MediaEngine.vala" + gst_element_unlink_many (elements[VIEW_MEDIA_CONNECTOR (self)->AudioIndex], self->priv->capsfilter, self->priv->export_sink, self->priv->mux, NULL); +#line 626 "MediaEngine.vala" + gst_bin_remove_many (GST_BIN (pipeline), self->priv->capsfilter, self->priv->export_sink, NULL); +#line 3210 "MediaEngine.c" + } +#line 629 "MediaEngine.vala" + if (view_media_connector_has_video (VIEW_MEDIA_CONNECTOR (self))) { +#line 630 "MediaEngine.vala" + gst_element_unlink_many (elements[VIEW_MEDIA_CONNECTOR (self)->VideoIndex], self->priv->video_export_sink, self->priv->mux, NULL); +#line 631 "MediaEngine.vala" + gst_bin_remove (GST_BIN (pipeline), self->priv->video_export_sink); +#line 3218 "MediaEngine.c" + } +#line 634 "MediaEngine.vala" + gst_element_unlink (self->priv->mux, self->priv->file_sink); +#line 635 "MediaEngine.vala" + gst_bin_remove_many (GST_BIN (pipeline), self->priv->mux, self->priv->file_sink, NULL); +#line 3224 "MediaEngine.c" +} + + +static void view_ogg_vorbis_export_class_init (ViewOggVorbisExportClass * klass) { + view_ogg_vorbis_export_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ViewOggVorbisExportPrivate)); + VIEW_MEDIA_CONNECTOR_CLASS (klass)->connect = view_ogg_vorbis_export_real_connect; + VIEW_MEDIA_CONNECTOR_CLASS (klass)->do_disconnect = view_ogg_vorbis_export_real_do_disconnect; + G_OBJECT_CLASS (klass)->finalize = view_ogg_vorbis_export_finalize; +} + + +static void view_ogg_vorbis_export_instance_init (ViewOggVorbisExport * self) { + self->priv = VIEW_OGG_VORBIS_EXPORT_GET_PRIVATE (self); +} + + +static void view_ogg_vorbis_export_finalize (GObject* obj) { + ViewOggVorbisExport * self; + self = VIEW_OGG_VORBIS_EXPORT (obj); + _gst_object_unref0 (self->priv->capsfilter); + _gst_object_unref0 (self->priv->export_sink); + _gst_object_unref0 (self->priv->mux); + _gst_object_unref0 (self->priv->file_sink); + _gst_object_unref0 (self->priv->video_export_sink); + G_OBJECT_CLASS (view_ogg_vorbis_export_parent_class)->finalize (obj); +} + + +GType view_ogg_vorbis_export_get_type (void) { + static volatile gsize view_ogg_vorbis_export_type_id__volatile = 0; + if (g_once_init_enter (&view_ogg_vorbis_export_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ViewOggVorbisExportClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_ogg_vorbis_export_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewOggVorbisExport), 0, (GInstanceInitFunc) view_ogg_vorbis_export_instance_init, NULL }; + GType view_ogg_vorbis_export_type_id; + view_ogg_vorbis_export_type_id = g_type_register_static (VIEW_TYPE_MEDIA_CONNECTOR, "ViewOggVorbisExport", &g_define_type_info, 0); + g_once_init_leave (&view_ogg_vorbis_export_type_id__volatile, view_ogg_vorbis_export_type_id); + } + return view_ogg_vorbis_export_type_id__volatile; +} + + +#line 397 "project.vala" +static void _model_project_on_playstate_changed_view_media_engine_playstate_changed (ViewMediaEngine* _sender, gpointer self) { +#line 3268 "MediaEngine.c" + model_project_on_playstate_changed (self); +} + + +#line 799 "MediaEngine.vala" +static void _view_media_engine_on_error_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self) { +#line 3275 "MediaEngine.c" + view_media_engine_on_error (self, _sender, message); +} + + +#line 791 "MediaEngine.vala" +static void _view_media_engine_on_warning_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self) { +#line 3282 "MediaEngine.c" + view_media_engine_on_warning (self, _sender, message); +} + + +#line 808 "MediaEngine.vala" +static void _view_media_engine_on_eos_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self) { +#line 3289 "MediaEngine.c" + view_media_engine_on_eos (self, _sender, message); +} + + +#line 833 "MediaEngine.vala" +static void _view_media_engine_on_state_change_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self) { +#line 3296 "MediaEngine.c" + view_media_engine_on_state_change (self, _sender, message); +} + + +#line 814 "MediaEngine.vala" +static void _view_media_engine_on_element_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self) { +#line 3303 "MediaEngine.c" + view_media_engine_on_element (self, _sender, message); +} + + +#line 680 "MediaEngine.vala" +ViewMediaEngine* view_media_engine_construct (GType object_type, ModelProject* project, gboolean include_video, GError** error) { +#line 3310 "MediaEngine.c" + GError * _inner_error_; + ViewMediaEngine * self; + GeeArrayList* _tmp0_; + GstPipeline* _tmp1_; + GstElement* silence; + GstElement* _tmp4_; + GstElement* _tmp5_; + GstElement* audio_convert; + GstBus* bus; +#line 680 "MediaEngine.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (project), NULL); +#line 3322 "MediaEngine.c" + _inner_error_ = NULL; +#line 680 "MediaEngine.vala" + self = (ViewMediaEngine*) g_object_new (object_type, NULL); +#line 681 "MediaEngine.vala" + self->priv->tracks = (_tmp0_ = gee_array_list_new (VIEW_TYPE_MEDIA_TRACK, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL), _g_object_unref0 (self->priv->tracks), _tmp0_); +#line 682 "MediaEngine.vala" + self->priv->project = project; +#line 683 "MediaEngine.vala" + g_signal_connect_object (self, "playstate-changed", (GCallback) _model_project_on_playstate_changed_view_media_engine_playstate_changed, project, 0); +#line 684 "MediaEngine.vala" + self->pipeline = (_tmp1_ = (GstPipeline*) gst_pipeline_new ("pipeline"), _gst_object_unref0 (self->pipeline), _tmp1_); +#line 685 "MediaEngine.vala" + gst_pipeline_set_auto_flush_bus (self->pipeline, FALSE); +#line 687 "MediaEngine.vala" + if (include_video) { +#line 3338 "MediaEngine.c" + GstElement* _tmp2_; + GstElement* _tmp3_; +#line 688 "MediaEngine.vala" + _tmp2_ = make_element ("ffmpegcolorspace", &_inner_error_); +#line 3343 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 688 "MediaEngine.vala" + self->converter = (_tmp3_ = _tmp2_, _gst_object_unref0 (self->converter), _tmp3_); +#line 689 "MediaEngine.vala" + gst_bin_add (GST_BIN (self->pipeline), _gst_object_ref0 (self->converter)); +#line 3353 "MediaEngine.c" + } +#line 692 "MediaEngine.vala" + silence = view_media_engine_get_audio_silence (self, &_inner_error_); +#line 3357 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 694 "MediaEngine.vala" + _tmp4_ = make_element ("adder", &_inner_error_); +#line 3365 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + _gst_object_unref0 (silence); + g_object_unref (self); + return NULL; + } +#line 694 "MediaEngine.vala" + self->adder = (_tmp5_ = _tmp4_, _gst_object_unref0 (self->adder), _tmp5_); +#line 696 "MediaEngine.vala" + audio_convert = make_element_with_name ("audioconvert", "projectconvert", &_inner_error_); +#line 3376 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + _gst_object_unref0 (silence); + g_object_unref (self); + return NULL; + } +#line 697 "MediaEngine.vala" + gst_bin_add_many (GST_BIN (self->pipeline), _gst_object_ref0 (silence), _gst_object_ref0 (audio_convert), _gst_object_ref0 (self->adder), NULL); +#line 699 "MediaEngine.vala" + if (!gst_element_link_many (silence, audio_convert, self->adder, NULL)) { +#line 700 "MediaEngine.vala" + g_error ("MediaEngine.vala:700: silence: couldn't link"); +#line 3389 "MediaEngine.c" + } +#line 703 "MediaEngine.vala" + bus = gst_pipeline_get_bus (self->pipeline); +#line 705 "MediaEngine.vala" + gst_bus_add_signal_watch (bus); +#line 706 "MediaEngine.vala" + g_signal_connect_object (bus, "message::error", (GCallback) _view_media_engine_on_error_gst_bus_message, self, 0); +#line 707 "MediaEngine.vala" + g_signal_connect_object (bus, "message::warning", (GCallback) _view_media_engine_on_warning_gst_bus_message, self, 0); +#line 708 "MediaEngine.vala" + g_signal_connect_object (bus, "message::eos", (GCallback) _view_media_engine_on_eos_gst_bus_message, self, 0); +#line 709 "MediaEngine.vala" + g_signal_connect_object (bus, "message::state-changed", (GCallback) _view_media_engine_on_state_change_gst_bus_message, self, 0); +#line 710 "MediaEngine.vala" + g_signal_connect_object (bus, "message::element", (GCallback) _view_media_engine_on_element_gst_bus_message, self, 0); +#line 3405 "MediaEngine.c" + _gst_object_unref0 (silence); + _gst_object_unref0 (audio_convert); + _gst_object_unref0 (bus); + return self; +} + + +#line 680 "MediaEngine.vala" +ViewMediaEngine* view_media_engine_new (ModelProject* project, gboolean include_video, GError** error) { +#line 680 "MediaEngine.vala" + return view_media_engine_construct (VIEW_TYPE_MEDIA_ENGINE, project, include_video, error); +#line 3417 "MediaEngine.c" +} + + +#line 713 "MediaEngine.vala" +void view_media_engine_can_run (GError** error) { +#line 3423 "MediaEngine.c" + GError * _inner_error_; + GstRegistry* registry; + _inner_error_ = NULL; +#line 714 "MediaEngine.vala" + registry = _gst_object_ref0 (gst_registry_get_default ()); +#line 715 "MediaEngine.vala" + view_media_engine_check_version (registry, "adder", "gst-plugins-base", VIEW_MEDIA_ENGINE_MIN_GST_PLUGINS_BASE, &_inner_error_); +#line 3431 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + _gst_object_unref0 (registry); + return; + } +#line 716 "MediaEngine.vala" + view_media_engine_check_version (registry, "level", "gst-plugins-good", VIEW_MEDIA_ENGINE_MIN_GST_PLUGINS_GOOD, &_inner_error_); +#line 3439 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + _gst_object_unref0 (registry); + return; + } +#line 717 "MediaEngine.vala" + view_media_engine_check_version (registry, "gnonlin", "gnonlin", VIEW_MEDIA_ENGINE_MIN_GNONLIN, &_inner_error_); +#line 3447 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + _gst_object_unref0 (registry); + return; + } + _gst_object_unref0 (registry); +} + + +#line 720 "MediaEngine.vala" +static void view_media_engine_check_version (GstRegistry* registry, const char* plugin_name, const char* package_name, const char* min_version, GError** error) { +#line 3459 "MediaEngine.c" + GError * _inner_error_; + GstPlugin* plugin; + char* version; +#line 720 "MediaEngine.vala" + g_return_if_fail (GST_IS_REGISTRY (registry)); +#line 720 "MediaEngine.vala" + g_return_if_fail (plugin_name != NULL); +#line 720 "MediaEngine.vala" + g_return_if_fail (package_name != NULL); +#line 720 "MediaEngine.vala" + g_return_if_fail (min_version != NULL); +#line 3471 "MediaEngine.c" + _inner_error_ = NULL; +#line 722 "MediaEngine.vala" + plugin = gst_registry_find_plugin (registry, plugin_name); +#line 723 "MediaEngine.vala" + if (plugin == NULL) { +#line 3477 "MediaEngine.c" + char* _tmp0_; + GError* _tmp1_; + _inner_error_ = (_tmp1_ = g_error_new_literal (MEDIA_ERROR, MEDIA_ERROR_MISSING_PLUGIN, _tmp0_ = g_strdup_printf ("You must install %s to use this program", package_name)), _g_free0 (_tmp0_), _tmp1_); + { + g_propagate_error (error, _inner_error_); + _gst_object_unref0 (plugin); + return; + } + } +#line 728 "MediaEngine.vala" + version = g_strdup (gst_plugin_get_version (plugin)); +#line 729 "MediaEngine.vala" + if (!version_at_least (version, min_version)) { +#line 3491 "MediaEngine.c" + char* _tmp2_; + GError* _tmp3_; + _inner_error_ = (_tmp3_ = g_error_new_literal (MEDIA_ERROR, MEDIA_ERROR_MISSING_PLUGIN, _tmp2_ = g_strdup_printf ("You have %s version %s, but this program requires at least version %s", package_name, version, min_version)), _g_free0 (_tmp2_), _tmp3_); + { + g_propagate_error (error, _inner_error_); + _gst_object_unref0 (plugin); + _g_free0 (version); + return; + } + } + _gst_object_unref0 (plugin); + _g_free0 (version); +} + + +#line 736 "MediaEngine.vala" +void view_media_engine_connect_output (ViewMediaEngine* self, ViewMediaConnector* connector) { +#line 3509 "MediaEngine.c" + gint _tmp1__length1; + GstElement** _tmp1_; + GstElement** _tmp0_ = NULL; +#line 736 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 736 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_CONNECTOR (connector)); +#line 737 "MediaEngine.vala" + view_media_connector_connect (connector, self, self->pipeline, (_tmp1_ = (_tmp0_ = g_new0 (GstElement*, 2 + 1), _tmp0_[0] = _gst_object_ref0 (self->adder), _tmp0_[1] = _gst_object_ref0 (self->converter), _tmp0_), _tmp1__length1 = 2, _tmp1_), 2); +#line 3519 "MediaEngine.c" + _tmp1_ = (_vala_array_free (_tmp1_, _tmp1__length1, (GDestroyNotify) gst_object_unref), NULL); +} + + +#line 740 "MediaEngine.vala" +void view_media_engine_disconnect_output (ViewMediaEngine* self, ViewMediaConnector* connector) { +#line 3526 "MediaEngine.c" + gint _tmp1__length1; + GstElement** _tmp1_; + GstElement** _tmp0_ = NULL; +#line 740 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 740 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_CONNECTOR (connector)); +#line 741 "MediaEngine.vala" + gst_element_seek_simple (GST_ELEMENT (self->pipeline), GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH, (gint64) 0); +#line 742 "MediaEngine.vala" + gst_element_set_state (GST_ELEMENT (self->pipeline), GST_STATE_NULL); +#line 743 "MediaEngine.vala" + view_media_connector_do_disconnect (connector, self, self->pipeline, (_tmp1_ = (_tmp0_ = g_new0 (GstElement*, 2 + 1), _tmp0_[0] = _gst_object_ref0 (self->adder), _tmp0_[1] = _gst_object_ref0 (self->converter), _tmp0_), _tmp1__length1 = 2, _tmp1_), 2); +#line 3540 "MediaEngine.c" + _tmp1_ = (_vala_array_free (_tmp1_, _tmp1__length1, (GDestroyNotify) gst_object_unref), NULL); +} + + +#line 746 "MediaEngine.vala" +GstElement* view_media_engine_get_audio_silence (ViewMediaEngine* self, GError** error) { +#line 3547 "MediaEngine.c" + GstElement* result = NULL; + GError * _inner_error_; + GstElement* silence; + GstCaps* audio_cap; +#line 746 "MediaEngine.vala" + g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), NULL); +#line 3554 "MediaEngine.c" + _inner_error_ = NULL; +#line 747 "MediaEngine.vala" + silence = make_element ("audiotestsrc", &_inner_error_); +#line 3558 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + return NULL; + } +#line 748 "MediaEngine.vala" + g_object_set (G_OBJECT (silence), "wave", 4, NULL); +#line 749 "MediaEngine.vala" + audio_cap = view_media_engine_get_project_audio_caps (self); +#line 3567 "MediaEngine.c" + { + GList* pad_collection; + GList* pad_it; +#line 750 "MediaEngine.vala" + pad_collection = silence->pads; +#line 3573 "MediaEngine.c" + for (pad_it = pad_collection; pad_it != NULL; pad_it = pad_it->next) { + GstPad* pad; +#line 750 "MediaEngine.vala" + pad = _gst_object_ref0 ((GstPad*) pad_it->data); +#line 3578 "MediaEngine.c" + { +#line 751 "MediaEngine.vala" + gst_pad_set_caps (pad, audio_cap); +#line 3582 "MediaEngine.c" + _gst_object_unref0 (pad); + } + } + } + result = silence; + _gst_caps_unref0 (audio_cap); +#line 753 "MediaEngine.vala" + return result; +#line 3591 "MediaEngine.c" +} + + +#line 756 "MediaEngine.vala" +gint view_media_engine_get_sample_rate (ViewMediaEngine* self) { +#line 3597 "MediaEngine.c" + gint result = 0; +#line 756 "MediaEngine.vala" + g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), 0); +#line 3601 "MediaEngine.c" + result = 48000; +#line 757 "MediaEngine.vala" + return result; +#line 3605 "MediaEngine.c" +} + + +#line 760 "MediaEngine.vala" +gint view_media_engine_get_sample_width (ViewMediaEngine* self) { +#line 3611 "MediaEngine.c" + gint result = 0; +#line 760 "MediaEngine.vala" + g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), 0); +#line 3615 "MediaEngine.c" + result = 16; +#line 761 "MediaEngine.vala" + return result; +#line 3619 "MediaEngine.c" +} + + +#line 764 "MediaEngine.vala" +gint view_media_engine_get_sample_depth (ViewMediaEngine* self) { +#line 3625 "MediaEngine.c" + gint result = 0; +#line 764 "MediaEngine.vala" + g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), 0); +#line 3629 "MediaEngine.c" + result = 16; +#line 765 "MediaEngine.vala" + return result; +#line 3633 "MediaEngine.c" +} + + +#line 768 "MediaEngine.vala" +PlayState view_media_engine_get_play_state (ViewMediaEngine* self) { +#line 3639 "MediaEngine.c" + PlayState result = 0; +#line 768 "MediaEngine.vala" + g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), 0); +#line 3643 "MediaEngine.c" + result = self->play_state; +#line 769 "MediaEngine.vala" + return result; +#line 3647 "MediaEngine.c" +} + + +#line 772 "MediaEngine.vala" +void view_media_engine_set_play_state (ViewMediaEngine* self, PlayState play_state) { +#line 772 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 773 "MediaEngine.vala" + self->play_state = play_state; +#line 3657 "MediaEngine.c" +} + + +#line 776 "MediaEngine.vala" +GstCaps* view_media_engine_build_audio_caps (ViewMediaEngine* self, gint num_channels) { +#line 3663 "MediaEngine.c" + GstCaps* result = NULL; + char* caps; + char* _tmp0_; +#line 776 "MediaEngine.vala" + g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), NULL); +#line 777 "MediaEngine.vala" + caps = g_strdup ("audio/x-raw-int,rate=%d,channels=%d,width=%d,depth=%d"); +#line 778 "MediaEngine.vala" + caps = (_tmp0_ = g_strdup_printf (caps, view_media_engine_get_sample_rate (self), num_channels, view_media_engine_get_sample_width (self), view_media_engine_get_sample_depth (self)), _g_free0 (caps), _tmp0_); +#line 3673 "MediaEngine.c" + result = gst_caps_from_string (caps); + _g_free0 (caps); +#line 779 "MediaEngine.vala" + return result; +#line 3678 "MediaEngine.c" +} + + +#line 782 "MediaEngine.vala" +GstCaps* view_media_engine_get_project_audio_caps (ViewMediaEngine* self) { +#line 3684 "MediaEngine.c" + GstCaps* result = NULL; +#line 782 "MediaEngine.vala" + g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), NULL); +#line 3688 "MediaEngine.c" + result = view_media_engine_build_audio_caps (self, CHANNELS_PER_TRACK_PLAYBACK); +#line 783 "MediaEngine.vala" + return result; +#line 3692 "MediaEngine.c" +} + + +#line 786 "MediaEngine.vala" +GstCaps* view_media_engine_get_project_audio_export_caps (ViewMediaEngine* self) { +#line 3698 "MediaEngine.c" + GstCaps* result = NULL; +#line 786 "MediaEngine.vala" + g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), NULL); +#line 3702 "MediaEngine.c" + result = gst_caps_from_string ("audio/x-raw-float,rate=48000,channels=2,width=32"); +#line 787 "MediaEngine.vala" + return result; +#line 3706 "MediaEngine.c" +} + + +#line 791 "MediaEngine.vala" +static void view_media_engine_on_warning (ViewMediaEngine* self, GstBus* bus, GstMessage* message) { +#line 3712 "MediaEngine.c" + GError* _error_; + char* text; + char* _tmp3_; + char* _tmp2_ = NULL; + GError* _tmp1_; + GError* _tmp0_ = NULL; +#line 791 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 791 "MediaEngine.vala" + g_return_if_fail (GST_IS_BUS (bus)); +#line 791 "MediaEngine.vala" + g_return_if_fail (GST_IS_MESSAGE (message)); +#line 792 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_warning"); +#line 3727 "MediaEngine.c" + _error_ = NULL; + text = NULL; +#line 795 "MediaEngine.vala" + (gst_message_parse_warning (message, &_tmp0_, &_tmp2_), _error_ = (_tmp1_ = _tmp0_, _g_error_free0 (_error_), _tmp1_)); +#line 795 "MediaEngine.vala" + text = (_tmp3_ = _tmp2_, _g_free0 (text), _tmp3_); +#line 796 "MediaEngine.vala" + g_warning ("MediaEngine.vala:796: %s", text); +#line 3736 "MediaEngine.c" + _g_error_free0 (_error_); + _g_free0 (text); +} + + +#line 799 "MediaEngine.vala" +static void view_media_engine_on_error (ViewMediaEngine* self, GstBus* bus, GstMessage* message) { +#line 3744 "MediaEngine.c" + GError* _error_; + char* text; + char* _tmp3_; + char* _tmp2_ = NULL; + GError* _tmp1_; + GError* _tmp0_ = NULL; +#line 799 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 799 "MediaEngine.vala" + g_return_if_fail (GST_IS_BUS (bus)); +#line 799 "MediaEngine.vala" + g_return_if_fail (GST_IS_MESSAGE (message)); +#line 800 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_error"); +#line 3759 "MediaEngine.c" + _error_ = NULL; + text = NULL; +#line 803 "MediaEngine.vala" + (gst_message_parse_error (message, &_tmp0_, &_tmp2_), _error_ = (_tmp1_ = _tmp0_, _g_error_free0 (_error_), _tmp1_)); +#line 803 "MediaEngine.vala" + text = (_tmp3_ = _tmp2_, _g_free0 (text), _tmp3_); +#line 804 "MediaEngine.vala" + g_warning ("MediaEngine.vala:804: %s", text); +#line 805 "MediaEngine.vala" + model_project_print_graph (self->priv->project, GST_BIN (self->pipeline), "bus_error"); +#line 3770 "MediaEngine.c" + _g_error_free0 (_error_); + _g_free0 (text); +} + + +#line 808 "MediaEngine.vala" +static void view_media_engine_on_eos (ViewMediaEngine* self, GstBus* bus, GstMessage* message) { +#line 808 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 808 "MediaEngine.vala" + g_return_if_fail (GST_IS_BUS (bus)); +#line 808 "MediaEngine.vala" + g_return_if_fail (GST_IS_MESSAGE (message)); +#line 809 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_eos"); +#line 810 "MediaEngine.vala" + if (self->play_state == PLAY_STATE_EXPORTING) { +#line 811 "MediaEngine.vala" + gst_element_set_state (GST_ELEMENT (self->pipeline), GST_STATE_NULL); +#line 3790 "MediaEngine.c" + } +} + + +#line 1168 "glib-2.0.vapi" +static const char* string_to_string (const char* self) { +#line 3797 "MediaEngine.c" + const char* result = NULL; +#line 1168 "glib-2.0.vapi" + g_return_val_if_fail (self != NULL, NULL); +#line 3801 "MediaEngine.c" + result = self; +#line 1169 "glib-2.0.vapi" + return result; +#line 3805 "MediaEngine.c" +} + + +static GValue* _gst_value_dup (GValue* self) { + GValue* dup; + dup = g_new0 (GValue, 1); + memcpy (dup, self, sizeof (GValue)); + return dup; +} + + +static gpointer __gst_value_dup0 (gpointer self) { + return self ? _gst_value_dup (self) : NULL; +} + + +#line 814 "MediaEngine.vala" +static void view_media_engine_on_element (ViewMediaEngine* self, GstBus* bus, GstMessage* message) { +#line 3824 "MediaEngine.c" + const GstStructure* structure; + gboolean _tmp0_ = FALSE; +#line 814 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 814 "MediaEngine.vala" + g_return_if_fail (GST_IS_BUS (bus)); +#line 814 "MediaEngine.vala" + g_return_if_fail (GST_IS_MESSAGE (message)); +#line 815 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_element"); +#line 816 "MediaEngine.vala" + structure = gst_message_get_structure (message); +#line 818 "MediaEngine.vala" + if (self->play_state == PLAY_STATE_PLAYING) { +#line 818 "MediaEngine.vala" + _tmp0_ = _vala_strcmp0 (string_to_string (gst_structure_get_name (structure)), "level") == 0; +#line 3841 "MediaEngine.c" + } else { +#line 818 "MediaEngine.vala" + _tmp0_ = FALSE; +#line 3845 "MediaEngine.c" + } +#line 818 "MediaEngine.vala" + if (_tmp0_) { +#line 3849 "MediaEngine.c" + GValue* rms; + guint size; + GValue* temp; + double level_left; + double level_right; +#line 819 "MediaEngine.vala" + rms = __gst_value_dup0 (gst_structure_get_value (structure, "rms")); +#line 820 "MediaEngine.vala" + size = gst_value_list_get_size (rms); +#line 821 "MediaEngine.vala" + temp = __gst_value_dup0 (gst_value_list_get_value (rms, (guint) 0)); +#line 822 "MediaEngine.vala" + level_left = g_value_get_double (temp); +#line 823 "MediaEngine.vala" + level_right = level_left; +#line 825 "MediaEngine.vala" + if (size > 1) { +#line 3867 "MediaEngine.c" + GValue* _tmp1_; +#line 826 "MediaEngine.vala" + temp = (_tmp1_ = __gst_value_dup0 (gst_value_list_get_value (rms, (guint) 1)), _g_free0 (temp), _tmp1_); +#line 827 "MediaEngine.vala" + level_right = g_value_get_double (temp); +#line 3873 "MediaEngine.c" + } +#line 829 "MediaEngine.vala" + g_signal_emit_by_name (self, "level-changed", message->src, level_left, level_right); +#line 3877 "MediaEngine.c" + _g_free0 (rms); + _g_free0 (temp); + } +} + + +#line 833 "MediaEngine.vala" +static void view_media_engine_on_state_change (ViewMediaEngine* self, GstBus* bus, GstMessage* message) { +#line 3886 "MediaEngine.c" + GstState old_state = 0; + GstState new_state = 0; + GstState pending = 0; + char* _tmp2_; +#line 833 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 833 "MediaEngine.vala" + g_return_if_fail (GST_IS_BUS (bus)); +#line 833 "MediaEngine.vala" + g_return_if_fail (GST_IS_MESSAGE (message)); +#line 834 "MediaEngine.vala" + if (message->src != GST_OBJECT (self->pipeline)) { +#line 3899 "MediaEngine.c" + char* _tmp1_; + char* _tmp0_; +#line 835 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_GRAPH, LOGGING_LEVEL_VERBOSE, _tmp1_ = g_strdup_printf ("on_state_change returning. message from %s", _tmp0_ = gst_object_get_name (message->src))); +#line 3904 "MediaEngine.c" + _g_free0 (_tmp1_); + _g_free0 (_tmp0_); +#line 837 "MediaEngine.vala" + return; +#line 3909 "MediaEngine.c" + } +#line 844 "MediaEngine.vala" + gst_message_parse_state_changed (message, &old_state, &new_state, &pending); +#line 846 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_GRAPH, LOGGING_LEVEL_INFO, _tmp2_ = g_strdup_printf ("on_state_change old(%s) new(%s) pending(%s)", gst_element_state_get_name (old_state), gst_element_state_get_name (new_state), gst_element_state_get_name (pending))); +#line 3915 "MediaEngine.c" + _g_free0 (_tmp2_); +#line 849 "MediaEngine.vala" + if (new_state == self->gst_state) { +#line 850 "MediaEngine.vala" + return; +#line 3921 "MediaEngine.c" + } +#line 852 "MediaEngine.vala" + self->gst_state = new_state; +#line 853 "MediaEngine.vala" + view_media_engine_do_state_change (self); +#line 3927 "MediaEngine.c" +} + + +#line 856 "MediaEngine.vala" +gboolean view_media_engine_do_state_change (ViewMediaEngine* self) { +#line 3933 "MediaEngine.c" + gboolean result = FALSE; + GError * _inner_error_; +#line 856 "MediaEngine.vala" + g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), FALSE); +#line 3938 "MediaEngine.c" + _inner_error_ = NULL; +#line 857 "MediaEngine.vala" + g_signal_emit_by_name (self, "playstate-changed"); +#line 858 "MediaEngine.vala" + switch (self->play_state) { +#line 3944 "MediaEngine.c" + case PLAY_STATE_STOPPED: + { +#line 860 "MediaEngine.vala" + if (self->gst_state != GST_STATE_PAUSED) { +#line 861 "MediaEngine.vala" + gst_element_set_state (GST_ELEMENT (self->pipeline), GST_STATE_PAUSED); +#line 3951 "MediaEngine.c" + } else { +#line 863 "MediaEngine.vala" + view_media_engine_go (self, self->position); +#line 3955 "MediaEngine.c" + } + result = TRUE; +#line 865 "MediaEngine.vala" + return result; +#line 3960 "MediaEngine.c" + } + case PLAY_STATE_PRE_EXPORT: + { +#line 867 "MediaEngine.vala" + if (self->gst_state != GST_STATE_PAUSED) { +#line 3966 "MediaEngine.c" + result = FALSE; +#line 868 "MediaEngine.vala" + return result; +#line 3970 "MediaEngine.c" + } +#line 870 "MediaEngine.vala" + view_media_engine_do_paused_state_export (self); +#line 3974 "MediaEngine.c" + result = TRUE; +#line 871 "MediaEngine.vala" + return result; +#line 3978 "MediaEngine.c" + } + case PLAY_STATE_EXPORTING: + { +#line 873 "MediaEngine.vala" + if (self->gst_state != GST_STATE_NULL) { +#line 3984 "MediaEngine.c" + result = FALSE; +#line 874 "MediaEngine.vala" + return result; +#line 3988 "MediaEngine.c" + } +#line 875 "MediaEngine.vala" + view_media_engine_end_export (self, FALSE); +#line 3992 "MediaEngine.c" + result = TRUE; +#line 876 "MediaEngine.vala" + return result; +#line 3996 "MediaEngine.c" + } + case PLAY_STATE_CANCEL_EXPORT: + { +#line 878 "MediaEngine.vala" + if (self->gst_state != GST_STATE_NULL) { +#line 4002 "MediaEngine.c" + result = FALSE; +#line 879 "MediaEngine.vala" + return result; +#line 4006 "MediaEngine.c" + } +#line 880 "MediaEngine.vala" + view_media_engine_end_export (self, TRUE); +#line 4010 "MediaEngine.c" + result = TRUE; +#line 881 "MediaEngine.vala" + return result; +#line 4014 "MediaEngine.c" + } + case PLAY_STATE_CLOSING: + { +#line 883 "MediaEngine.vala" + view_media_engine_close (self); +#line 4020 "MediaEngine.c" + result = TRUE; +#line 884 "MediaEngine.vala" + return result; +#line 4024 "MediaEngine.c" + } + case PLAY_STATE_PRE_RECORD_NULL: + { +#line 886 "MediaEngine.vala" + if (self->gst_state == GST_STATE_NULL) { +#line 4030 "MediaEngine.c" + { +#line 888 "MediaEngine.vala" + view_media_engine_start_record (self, self->record_region, &_inner_error_); +#line 4034 "MediaEngine.c" + if (_inner_error_ != NULL) { + goto __catch10_g_error; + } + } + goto __finally10; + __catch10_g_error: + { + GError * _error_; + _error_ = _inner_error_; + _inner_error_ = NULL; + { +#line 890 "MediaEngine.vala" + g_signal_emit_by_name (self, "error-occurred", "An error occurred starting the recording.", NULL); +#line 891 "MediaEngine.vala" + g_warning ("MediaEngine.vala:891: An error occurred starting the recording: %s", _error_->message); +#line 4050 "MediaEngine.c" + _g_error_free0 (_error_); + } + } + __finally10: + if (_inner_error_ != NULL) { + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return FALSE; + } + result = TRUE; +#line 893 "MediaEngine.vala" + return result; +#line 4063 "MediaEngine.c" + } +#line 895 "MediaEngine.vala" + break; +#line 4067 "MediaEngine.c" + } + case PLAY_STATE_PRE_RECORD: + { +#line 897 "MediaEngine.vala" + if (self->gst_state == GST_STATE_PAUSED) { +#line 898 "MediaEngine.vala" + view_media_engine_do_play (self, PLAY_STATE_RECORDING); +#line 4075 "MediaEngine.c" + result = TRUE; +#line 899 "MediaEngine.vala" + return result; +#line 4079 "MediaEngine.c" + } +#line 901 "MediaEngine.vala" + break; +#line 4083 "MediaEngine.c" + } + case PLAY_STATE_POST_RECORD: + { +#line 903 "MediaEngine.vala" + if (self->gst_state != GST_STATE_NULL) { +#line 904 "MediaEngine.vala" + view_media_engine_set_gst_state (self, GST_STATE_NULL); +#line 4091 "MediaEngine.c" + } else { +#line 906 "MediaEngine.vala" + view_media_engine_post_record (self); +#line 907 "MediaEngine.vala" + view_media_engine_set_gst_state (self, GST_STATE_PAUSED); +#line 908 "MediaEngine.vala" + self->play_state = PLAY_STATE_STOPPED; +#line 4099 "MediaEngine.c" + } + result = TRUE; +#line 910 "MediaEngine.vala" + return result; +#line 4104 "MediaEngine.c" + } + } + result = FALSE; +#line 912 "MediaEngine.vala" + return result; +#line 4110 "MediaEngine.c" +} + + +#line 915 "MediaEngine.vala" +static void view_media_engine_real_do_null_state_export (ViewMediaEngine* self, gint64 length) { +#line 915 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 916 "MediaEngine.vala" + g_signal_emit_by_name (self, "pre-export", length); +#line 917 "MediaEngine.vala" + self->play_state = PLAY_STATE_PRE_EXPORT; +#line 918 "MediaEngine.vala" + gst_element_set_state (GST_ELEMENT (self->pipeline), GST_STATE_PAUSED); +#line 4124 "MediaEngine.c" +} + + +#line 915 "MediaEngine.vala" +void view_media_engine_do_null_state_export (ViewMediaEngine* self, gint64 length) { +#line 915 "MediaEngine.vala" + VIEW_MEDIA_ENGINE_GET_CLASS (self)->do_null_state_export (self, length); +#line 4132 "MediaEngine.c" +} + + +#line 952 "MediaEngine.vala" +static gboolean _view_media_engine_on_callback_gsource_func (gpointer self) { +#line 4138 "MediaEngine.c" + gboolean result; + result = view_media_engine_on_callback (self); + return result; +} + + +#line 921 "MediaEngine.vala" +static void view_media_engine_do_paused_state_export (ViewMediaEngine* self) { +#line 921 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 922 "MediaEngine.vala" + self->play_state = PLAY_STATE_EXPORTING; +#line 924 "MediaEngine.vala" + if (self->priv->callback_id == 0) { +#line 925 "MediaEngine.vala" + self->priv->callback_id = g_timeout_add_full (G_PRIORITY_DEFAULT, (guint) 50, _view_media_engine_on_callback_gsource_func, g_object_ref (self), g_object_unref); +#line 4155 "MediaEngine.c" + } +#line 926 "MediaEngine.vala" + gst_element_set_state (GST_ELEMENT (self->pipeline), GST_STATE_PLAYING); +#line 4159 "MediaEngine.c" +} + + +#line 929 "MediaEngine.vala" +static void view_media_engine_end_export (ViewMediaEngine* self, gboolean deleted) { +#line 929 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 930 "MediaEngine.vala" + self->play_state = PLAY_STATE_STOPPED; +#line 932 "MediaEngine.vala" + self->priv->callback_id = (guint) 0; +#line 933 "MediaEngine.vala" + g_signal_emit_by_name (self, "post-export", deleted); +#line 4173 "MediaEngine.c" +} + + +#line 936 "MediaEngine.vala" +void view_media_engine_go (ViewMediaEngine* self, gint64 pos) { +#line 936 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 937 "MediaEngine.vala" + if (self->position == pos) { +#line 938 "MediaEngine.vala" + gst_element_seek_simple (GST_ELEMENT (self->pipeline), GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH, self->position); +#line 939 "MediaEngine.vala" + return; +#line 4187 "MediaEngine.c" + } +#line 941 "MediaEngine.vala" + if (pos < 0) { +#line 942 "MediaEngine.vala" + self->position = (gint64) 0; +#line 4193 "MediaEngine.c" + } else { +#line 944 "MediaEngine.vala" + self->position = pos; +#line 4197 "MediaEngine.c" + } +#line 948 "MediaEngine.vala" + gst_element_seek_simple (GST_ELEMENT (self->pipeline), GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH, self->position); +#line 949 "MediaEngine.vala" + g_signal_emit_by_name (self, "position-changed", self->position); +#line 4203 "MediaEngine.c" +} + + +#line 952 "MediaEngine.vala" +static gboolean view_media_engine_on_callback (ViewMediaEngine* self) { +#line 4209 "MediaEngine.c" + gboolean result = FALSE; + gboolean _tmp0_ = FALSE; + gboolean _tmp1_ = FALSE; + GstFormat format; + gint64 time; + gboolean _tmp2_ = FALSE; +#line 952 "MediaEngine.vala" + g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), FALSE); +#line 953 "MediaEngine.vala" + if (self->play_state == PLAY_STATE_STOPPED) { +#line 953 "MediaEngine.vala" + _tmp1_ = !self->playing; +#line 4222 "MediaEngine.c" + } else { +#line 953 "MediaEngine.vala" + _tmp1_ = FALSE; +#line 4226 "MediaEngine.c" + } +#line 953 "MediaEngine.vala" + if (_tmp1_) { +#line 953 "MediaEngine.vala" + _tmp0_ = TRUE; +#line 4232 "MediaEngine.c" + } else { +#line 954 "MediaEngine.vala" + _tmp0_ = self->play_state == PLAY_STATE_POST_RECORD; +#line 4236 "MediaEngine.c" + } +#line 953 "MediaEngine.vala" + if (_tmp0_) { +#line 955 "MediaEngine.vala" + self->priv->callback_id = (guint) 0; +#line 4242 "MediaEngine.c" + result = FALSE; +#line 956 "MediaEngine.vala" + return result; +#line 4246 "MediaEngine.c" + } +#line 959 "MediaEngine.vala" + format = GST_FORMAT_TIME; +#line 960 "MediaEngine.vala" + time = (gint64) 0; +#line 961 "MediaEngine.vala" + if (gst_element_query_position (GST_ELEMENT (self->pipeline), &format, &time)) { +#line 961 "MediaEngine.vala" + _tmp2_ = format == GST_FORMAT_TIME; +#line 4256 "MediaEngine.c" + } else { +#line 961 "MediaEngine.vala" + _tmp2_ = FALSE; +#line 4260 "MediaEngine.c" + } +#line 961 "MediaEngine.vala" + if (_tmp2_) { +#line 962 "MediaEngine.vala" + self->position = time; +#line 963 "MediaEngine.vala" + g_signal_emit_by_name (self, "callback-pulse"); +#line 965 "MediaEngine.vala" + if (self->play_state == PLAY_STATE_PLAYING) { +#line 966 "MediaEngine.vala" + if (self->position >= model_project_get_length (self->priv->project)) { +#line 967 "MediaEngine.vala" + view_media_engine_go (self, model_project_get_length (self->priv->project)); +#line 968 "MediaEngine.vala" + view_media_engine_pause (self); +#line 4276 "MediaEngine.c" + } +#line 970 "MediaEngine.vala" + g_signal_emit_by_name (self, "position-changed", time); +#line 4280 "MediaEngine.c" + } else { +#line 971 "MediaEngine.vala" + if (self->play_state == PLAY_STATE_EXPORTING) { +#line 972 "MediaEngine.vala" + if (time > model_project_get_length (self->priv->project)) { +#line 973 "MediaEngine.vala" + g_signal_emit_by_name (MULTI_FILE_PROGRESS_INTERFACE (self), "fraction-updated", 1.0); +#line 4288 "MediaEngine.c" + } else { +#line 976 "MediaEngine.vala" + g_signal_emit_by_name (MULTI_FILE_PROGRESS_INTERFACE (self), "fraction-updated", time / ((double) model_project_get_length (self->priv->project))); +#line 4292 "MediaEngine.c" + } + } else { +#line 977 "MediaEngine.vala" + if (self->play_state == PLAY_STATE_RECORDING) { +#line 978 "MediaEngine.vala" + g_signal_emit_by_name (self, "position-changed", time); +#line 4299 "MediaEngine.c" + } + } + } + } + result = TRUE; +#line 981 "MediaEngine.vala" + return result; +#line 4307 "MediaEngine.c" +} + + +#line 984 "MediaEngine.vala" +static void view_media_engine_real_pause (ViewMediaEngine* self) { +#line 984 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 985 "MediaEngine.vala" + if (model_project_transport_is_recording (self->priv->project)) { +#line 986 "MediaEngine.vala" + gst_element_send_event (GST_ELEMENT (self->record_bin), gst_event_new_eos ()); +#line 987 "MediaEngine.vala" + self->play_state = PLAY_STATE_POST_RECORD; +#line 4321 "MediaEngine.c" + } else { +#line 989 "MediaEngine.vala" + if (!self->playing) { +#line 990 "MediaEngine.vala" + return; +#line 4327 "MediaEngine.c" + } +#line 992 "MediaEngine.vala" + self->play_state = PLAY_STATE_STOPPED; +#line 4331 "MediaEngine.c" + } +#line 994 "MediaEngine.vala" + view_media_engine_set_gst_state (self, GST_STATE_PAUSED); +#line 995 "MediaEngine.vala" + self->playing = FALSE; +#line 4337 "MediaEngine.c" +} + + +#line 984 "MediaEngine.vala" +void view_media_engine_pause (ViewMediaEngine* self) { +#line 984 "MediaEngine.vala" + VIEW_MEDIA_ENGINE_GET_CLASS (self)->pause (self); +#line 4345 "MediaEngine.c" +} + + +#line 999 "MediaEngine.vala" +void view_media_engine_set_gst_state (ViewMediaEngine* self, GstState state) { +#line 999 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 1000 "MediaEngine.vala" + if (gst_element_set_state (GST_ELEMENT (self->pipeline), state) == GST_STATE_CHANGE_FAILURE) { +#line 1001 "MediaEngine.vala" + g_error ("MediaEngine.vala:1001: can't set state"); +#line 4357 "MediaEngine.c" + } +} + + +#line 1004 "MediaEngine.vala" +static void view_media_engine_seek (ViewMediaEngine* self, GstSeekFlags flags, gint64 pos) { +#line 1004 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 1008 "MediaEngine.vala" + gst_element_seek_simple (GST_ELEMENT (self->pipeline), GST_FORMAT_TIME, flags, pos); +#line 4368 "MediaEngine.c" +} + + +#line 1011 "MediaEngine.vala" +void view_media_engine_do_play (ViewMediaEngine* self, PlayState new_state) { +#line 1011 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 1012 "MediaEngine.vala" + view_media_engine_seek (self, GST_SEEK_FLAG_FLUSH, self->position); +#line 1013 "MediaEngine.vala" + self->play_state = new_state; +#line 1014 "MediaEngine.vala" + view_media_engine_play (self); +#line 4382 "MediaEngine.c" +} + + +#line 1017 "MediaEngine.vala" +static void view_media_engine_play (ViewMediaEngine* self) { +#line 1017 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 1018 "MediaEngine.vala" + if (self->playing) { +#line 1019 "MediaEngine.vala" + return; +#line 4394 "MediaEngine.c" + } +#line 1021 "MediaEngine.vala" + view_media_engine_set_gst_state (self, GST_STATE_PLAYING); +#line 1022 "MediaEngine.vala" + if (self->priv->callback_id == 0) { +#line 1023 "MediaEngine.vala" + self->priv->callback_id = g_timeout_add_full (G_PRIORITY_DEFAULT, (guint) 50, _view_media_engine_on_callback_gsource_func, g_object_ref (self), g_object_unref); +#line 4402 "MediaEngine.c" + } +#line 1024 "MediaEngine.vala" + self->playing = TRUE; +#line 4406 "MediaEngine.c" +} + + +#line 1027 "MediaEngine.vala" +void view_media_engine_start_export (ViewMediaEngine* self, const char* filename) { +#line 1027 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 1027 "MediaEngine.vala" + g_return_if_fail (filename != NULL); +#line 1028 "MediaEngine.vala" + g_signal_emit_by_name (MULTI_FILE_PROGRESS_INTERFACE (self), "file-updated", filename, 0); +#line 1029 "MediaEngine.vala" + view_media_engine_do_null_state_export (self, model_project_get_length (self->priv->project)); +#line 4420 "MediaEngine.c" +} + + +#line 1032 "MediaEngine.vala" +static void view_media_engine_real_cancel (MultiFileProgressInterface* base) { +#line 4426 "MediaEngine.c" + ViewMediaEngine * self; + self = VIEW_MEDIA_ENGINE (base); +#line 1033 "MediaEngine.vala" + self->play_state = PLAY_STATE_CANCEL_EXPORT; +#line 1034 "MediaEngine.vala" + gst_element_set_state (GST_ELEMENT (self->pipeline), GST_STATE_NULL); +#line 4433 "MediaEngine.c" +} + + +#line 1037 "MediaEngine.vala" +static void view_media_engine_real_complete (MultiFileProgressInterface* base) { +#line 4439 "MediaEngine.c" + ViewMediaEngine * self; + self = VIEW_MEDIA_ENGINE (base); +#line 1038 "MediaEngine.vala" + gst_element_set_state (GST_ELEMENT (self->pipeline), GST_STATE_NULL); +#line 4444 "MediaEngine.c" +} + + +#line 1041 "MediaEngine.vala" +void view_media_engine_on_load_complete (ViewMediaEngine* self) { +#line 1041 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 1042 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_load_complete"); +#line 1043 "MediaEngine.vala" + self->play_state = PLAY_STATE_STOPPED; +#line 1044 "MediaEngine.vala" + gst_element_set_state (GST_ELEMENT (self->pipeline), GST_STATE_PAUSED); +#line 4458 "MediaEngine.c" +} + + +#line 1047 "MediaEngine.vala" +void view_media_engine_on_callback_pulse (ViewMediaEngine* self) { +#line 1047 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 1048 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_callback_pulse"); +#line 1049 "MediaEngine.vala" + if (self->record_region != NULL) { +#line 1050 "MediaEngine.vala" + model_clip_set_duration (self->record_region, self->position - model_clip_get_start (self->record_region)); +#line 4472 "MediaEngine.c" + } +} + + +#line 1054 "MediaEngine.vala" +void view_media_engine_close (ViewMediaEngine* self) { +#line 1054 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 1055 "MediaEngine.vala" + if (self->gst_state != GST_STATE_NULL) { +#line 1056 "MediaEngine.vala" + self->play_state = PLAY_STATE_CLOSING; +#line 1057 "MediaEngine.vala" + view_media_engine_set_gst_state (self, GST_STATE_NULL); +#line 4487 "MediaEngine.c" + } else { +#line 1059 "MediaEngine.vala" + self->play_state = PLAY_STATE_CLOSED; +#line 4491 "MediaEngine.c" + } +#line 1061 "MediaEngine.vala" + g_signal_emit_by_name (self, "playstate-changed"); +#line 4495 "MediaEngine.c" +} + + +#line 1064 "MediaEngine.vala" +void view_media_engine_post_record (ViewMediaEngine* self) { +#line 4501 "MediaEngine.c" + GstBin* _tmp0_; + ModelClip* _tmp1_; + ModelAudioTrack* _tmp2_; + GstElement* _tmp4_; + GstElement* _tmp3_; + GstElement* _tmp6_; + GstElement* _tmp5_; +#line 1064 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 1065 "MediaEngine.vala" + g_assert (self->gst_state == GST_STATE_NULL); +#line 1067 "MediaEngine.vala" + _model_track_delete_clip (MODEL_TRACK (self->record_track), self->record_region); +#line 1069 "MediaEngine.vala" + gst_element_unlink_many (self->priv->audio_in, self->priv->record_capsfilter, self->priv->wav_encoder, self->priv->record_sink, NULL); +#line 1070 "MediaEngine.vala" + gst_bin_remove_many (self->record_bin, self->priv->audio_in, self->priv->record_capsfilter, self->priv->wav_encoder, self->priv->record_sink, NULL); +#line 1071 "MediaEngine.vala" + gst_bin_remove (GST_BIN (self->pipeline), GST_ELEMENT (self->record_bin)); +#line 1072 "MediaEngine.vala" + g_signal_emit_by_name (self, "record-completed"); +#line 1073 "MediaEngine.vala" + self->record_bin = (_tmp0_ = NULL, _gst_object_unref0 (self->record_bin), _tmp0_); +#line 1074 "MediaEngine.vala" + self->record_region = (_tmp1_ = NULL, _g_object_unref0 (self->record_region), _tmp1_); +#line 1075 "MediaEngine.vala" + self->record_track = (_tmp2_ = NULL, _g_object_unref0 (self->record_track), _tmp2_); +#line 1076 "MediaEngine.vala" + self->priv->audio_in = (_tmp4_ = _gst_object_ref0 (self->priv->record_capsfilter = (_tmp3_ = NULL, _gst_object_unref0 (self->priv->record_capsfilter), _tmp3_)), _gst_object_unref0 (self->priv->audio_in), _tmp4_); +#line 1077 "MediaEngine.vala" + self->priv->wav_encoder = (_tmp6_ = _gst_object_ref0 (self->priv->record_sink = (_tmp5_ = NULL, _gst_object_unref0 (self->priv->record_sink), _tmp5_)), _gst_object_unref0 (self->priv->wav_encoder), _tmp6_); +#line 1078 "MediaEngine.vala" + view_media_engine_set_gst_state (self, GST_STATE_PAUSED); +#line 4535 "MediaEngine.c" +} + + +#line 1081 "MediaEngine.vala" +void view_media_engine_record (ViewMediaEngine* self, ModelAudioTrack* track) { +#line 4541 "MediaEngine.c" + ModelAudioTrack* _tmp0_; + char* filename; + ModelClipFile* clip_file; + ModelClip* _tmp1_; +#line 1081 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 1081 "MediaEngine.vala" + g_return_if_fail (MODEL_IS_AUDIO_TRACK (track)); +#line 1082 "MediaEngine.vala" + g_assert (self->gst_state != GST_STATE_NULL); +#line 1083 "MediaEngine.vala" + self->play_state = PLAY_STATE_PRE_RECORD_NULL; +#line 1084 "MediaEngine.vala" + view_media_engine_set_gst_state (self, GST_STATE_NULL); +#line 1085 "MediaEngine.vala" + self->record_track = (_tmp0_ = _g_object_ref0 (track), _g_object_unref0 (self->record_track), _tmp0_); +#line 1087 "MediaEngine.vala" + filename = view_media_engine_new_audio_filename (self, MODEL_TRACK (track)); +#line 1088 "MediaEngine.vala" + clip_file = model_clip_file_new (filename, 0); +#line 1089 "MediaEngine.vala" + self->record_region = (_tmp1_ = model_clip_new (clip_file, MODEL_MEDIA_TYPE_AUDIO, "", self->position, (gint64) 0, (gint64) 1, TRUE), _g_object_unref0 (self->record_region), _tmp1_); +#line 4564 "MediaEngine.c" + _g_free0 (filename); + _g_object_unref0 (clip_file); +} + + +#line 1092 "MediaEngine.vala" +void view_media_engine_start_record (ViewMediaEngine* self, ModelClip* region, GError** error) { +#line 4572 "MediaEngine.c" + GError * _inner_error_; + GstBin* _tmp0_; + GstElement* _tmp1_; + GstElement* _tmp2_; + GValue _tmp4_; + GValue _tmp3_ = {0}; + GstElement* _tmp5_; + GstElement* _tmp6_; + GstCaps* _tmp7_; + GstElement* _tmp8_; + GstElement* _tmp9_; + GstElement* _tmp10_; + GstElement* _tmp11_; +#line 1092 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 1092 "MediaEngine.vala" + g_return_if_fail (MODEL_IS_CLIP (region)); +#line 4590 "MediaEngine.c" + _inner_error_ = NULL; +#line 1093 "MediaEngine.vala" + if (model_project_transport_is_recording (self->priv->project)) { +#line 1094 "MediaEngine.vala" + return; +#line 4596 "MediaEngine.c" + } +#line 1096 "MediaEngine.vala" + if (model_project_transport_is_playing (self->priv->project)) { +#line 1097 "MediaEngine.vala" + g_error ("MediaEngine.vala:1097: can't switch from playing to recording"); +#line 4602 "MediaEngine.c" + } +#line 1099 "MediaEngine.vala" + if (self->gst_state != GST_STATE_NULL) { +#line 1100 "MediaEngine.vala" + g_error ("MediaEngine.vala:1100: can't record now: %s", gst_element_state_get_name (self->gst_state)); +#line 4608 "MediaEngine.c" + } +#line 1101 "MediaEngine.vala" + self->record_bin = (_tmp0_ = (GstBin*) gst_bin_new ("recordingbin"), _gst_object_unref0 (self->record_bin), _tmp0_); +#line 1102 "MediaEngine.vala" + _model_track_move (MODEL_TRACK (self->record_track), self->record_region, self->position); +#line 1103 "MediaEngine.vala" + g_signal_emit_by_name (MODEL_TRACK (self->record_track), "clip-added", self->record_region, TRUE); +#line 1104 "MediaEngine.vala" + _tmp1_ = make_element ("pulsesrc", &_inner_error_); +#line 4618 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + return; + } +#line 1104 "MediaEngine.vala" + self->priv->audio_in = (_tmp2_ = _tmp1_, _gst_object_unref0 (self->priv->audio_in), _tmp2_); +#line 1105 "MediaEngine.vala" + g_object_set_property (G_OBJECT (self->priv->audio_in), "device", (_tmp4_ = (g_value_init (&_tmp3_, G_TYPE_STRING), g_value_set_string (&_tmp3_, "source.hw0"), _tmp3_), &_tmp4_)); +#line 1106 "MediaEngine.vala" + _tmp5_ = make_element ("capsfilter", &_inner_error_); +#line 4629 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + return; + } +#line 1106 "MediaEngine.vala" + self->priv->record_capsfilter = (_tmp6_ = _tmp5_, _gst_object_unref0 (self->priv->record_capsfilter), _tmp6_); +#line 1107 "MediaEngine.vala" + g_object_set (G_OBJECT (self->priv->record_capsfilter), "caps", _tmp7_ = view_media_engine_get_record_audio_caps (self), NULL); +#line 4638 "MediaEngine.c" + _gst_caps_unref0 (_tmp7_); +#line 1108 "MediaEngine.vala" + _tmp8_ = make_element ("filesink", &_inner_error_); +#line 4642 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + return; + } +#line 1108 "MediaEngine.vala" + self->priv->record_sink = (_tmp9_ = _tmp8_, _gst_object_unref0 (self->priv->record_sink), _tmp9_); +#line 1109 "MediaEngine.vala" + g_object_set (G_OBJECT (self->priv->record_sink), "location", self->record_region->clipfile->filename, NULL); +#line 1110 "MediaEngine.vala" + _tmp10_ = make_element ("wavenc", &_inner_error_); +#line 4653 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + return; + } +#line 1110 "MediaEngine.vala" + self->priv->wav_encoder = (_tmp11_ = _tmp10_, _gst_object_unref0 (self->priv->wav_encoder), _tmp11_); +#line 1112 "MediaEngine.vala" + gst_bin_add_many (self->record_bin, _gst_object_ref0 (self->priv->audio_in), _gst_object_ref0 (self->priv->record_capsfilter), _gst_object_ref0 (self->priv->wav_encoder), _gst_object_ref0 (self->priv->record_sink), NULL); +#line 1113 "MediaEngine.vala" + if (!gst_element_link_many (self->priv->audio_in, self->priv->record_capsfilter, self->priv->wav_encoder, self->priv->record_sink, NULL)) { +#line 1114 "MediaEngine.vala" + g_error ("MediaEngine.vala:1114: audio_in: couldn't link"); +#line 4666 "MediaEngine.c" + } +#line 1115 "MediaEngine.vala" + gst_bin_add (GST_BIN (self->pipeline), _gst_object_ref0 (GST_ELEMENT (self->record_bin))); +#line 1117 "MediaEngine.vala" + self->play_state = PLAY_STATE_PRE_RECORD; +#line 1118 "MediaEngine.vala" + view_media_engine_set_gst_state (self, GST_STATE_PAUSED); +#line 4674 "MediaEngine.c" +} + + +#line 1121 "MediaEngine.vala" +GstCaps* view_media_engine_get_record_audio_caps (ViewMediaEngine* self) { +#line 4680 "MediaEngine.c" + GstCaps* result = NULL; +#line 1121 "MediaEngine.vala" + g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), NULL); +#line 4684 "MediaEngine.c" + result = view_media_engine_build_audio_caps (self, CHANNELS_PER_TRACK_RECORD); +#line 1122 "MediaEngine.vala" + return result; +#line 4688 "MediaEngine.c" +} + + +#line 1125 "MediaEngine.vala" +static char* view_media_engine_new_audio_filename (ViewMediaEngine* self, ModelTrack* track) { +#line 4694 "MediaEngine.c" + char* result = NULL; + gint i; + char* base_path; + char* _tmp0_; + char* _tmp1_; + char* base_name; +#line 1125 "MediaEngine.vala" + g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), NULL); +#line 1125 "MediaEngine.vala" + g_return_val_if_fail (MODEL_IS_TRACK (track), NULL); +#line 1126 "MediaEngine.vala" + i = 1; +#line 1127 "MediaEngine.vala" + base_path = model_project_get_audio_path (self->priv->project); +#line 1128 "MediaEngine.vala" + g_mkdir (base_path, 0777); +#line 1129 "MediaEngine.vala" + base_name = (_tmp1_ = g_build_filename (base_path, _tmp0_ = view_media_engine_generate_base (self, track->display_name), NULL), _g_free0 (_tmp0_), _tmp1_); +#line 1130 "MediaEngine.vala" + while (TRUE) { +#line 4715 "MediaEngine.c" + char* name; +#line 1131 "MediaEngine.vala" + name = g_strdup_printf ("%s_%d.wav", base_name, i); +#line 1132 "MediaEngine.vala" + if (!g_file_test (name, G_FILE_TEST_EXISTS)) { +#line 4721 "MediaEngine.c" + result = name; + _g_free0 (base_path); + _g_free0 (base_name); +#line 1133 "MediaEngine.vala" + return result; +#line 4727 "MediaEngine.c" + } +#line 1135 "MediaEngine.vala" + i = i + 1; +#line 4731 "MediaEngine.c" + _g_free0 (name); + } + _g_free0 (base_path); + _g_free0 (base_name); +} + + +#line 1139 "MediaEngine.vala" +static char* view_media_engine_generate_base (ViewMediaEngine* self, const char* name) { +#line 4741 "MediaEngine.c" + char* result = NULL; + char* base_name; +#line 1139 "MediaEngine.vala" + g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), NULL); +#line 1139 "MediaEngine.vala" + g_return_val_if_fail (name != NULL, NULL); +#line 1140 "MediaEngine.vala" + base_name = g_utf8_strdown (name, -1); +#line 1141 "MediaEngine.vala" + g_strcanon (base_name, "abcdefghijklmnopqrstuvwxyz1234567890", '_'); +#line 4752 "MediaEngine.c" + result = base_name; +#line 1142 "MediaEngine.vala" + return result; +#line 4756 "MediaEngine.c" +} + + +#line 1180 "MediaEngine.vala" +static void _view_media_engine_on_track_removed_view_media_track_track_removed (ViewMediaTrack* _sender, ViewMediaTrack* track, gpointer self) { +#line 4762 "MediaEngine.c" + view_media_engine_on_track_removed (self, track); +} + + +#line 1185 "MediaEngine.vala" +static void _view_media_engine_on_error_occurred_view_media_track_error_occurred (ViewMediaTrack* _sender, const char* major_message, const char* minor_message, gpointer self) { +#line 4769 "MediaEngine.c" + view_media_engine_on_error_occurred (self, major_message, minor_message); +} + + +#line 1145 "MediaEngine.vala" +void view_media_engine_on_track_added (ViewMediaEngine* self, ModelTrack* track) { +#line 4776 "MediaEngine.c" + GError * _inner_error_; + ViewMediaTrack* media_track; +#line 1145 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 1145 "MediaEngine.vala" + g_return_if_fail (MODEL_IS_TRACK (track)); +#line 4783 "MediaEngine.c" + _inner_error_ = NULL; +#line 1146 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_track_added"); +#line 1147 "MediaEngine.vala" + media_track = NULL; +#line 4789 "MediaEngine.c" + { +#line 1149 "MediaEngine.vala" + switch (model_track_media_type (track)) { +#line 4793 "MediaEngine.c" + case MODEL_MEDIA_TYPE_AUDIO: + { + ViewMediaTrack* _tmp0_; + ViewMediaTrack* _tmp1_; +#line 1151 "MediaEngine.vala" + _tmp0_ = view_media_engine_create_audio_track (self, track, &_inner_error_); +#line 4800 "MediaEngine.c" + if (_inner_error_ != NULL) { + goto __catch11_g_error; + } +#line 1151 "MediaEngine.vala" + media_track = (_tmp1_ = _tmp0_, _g_object_unref0 (media_track), _tmp1_); +#line 1152 "MediaEngine.vala" + break; +#line 4808 "MediaEngine.c" + } + case MODEL_MEDIA_TYPE_VIDEO: + { + ViewMediaVideoTrack* _tmp2_; + ViewMediaTrack* _tmp3_; +#line 1154 "MediaEngine.vala" + _tmp2_ = view_media_video_track_new (self, track, self->converter, &_inner_error_); +#line 4816 "MediaEngine.c" + if (_inner_error_ != NULL) { + goto __catch11_g_error; + } +#line 1154 "MediaEngine.vala" + media_track = (_tmp3_ = VIEW_MEDIA_TRACK (_tmp2_), _g_object_unref0 (media_track), _tmp3_); +#line 1155 "MediaEngine.vala" + break; +#line 4824 "MediaEngine.c" + } + } + } + goto __finally11; + __catch11_g_error: + { + GError * _error_; + _error_ = _inner_error_; + _inner_error_ = NULL; + { +#line 1158 "MediaEngine.vala" + g_signal_emit_by_name (self, "error-occurred", "An error occurred adding the track.", NULL); +#line 1159 "MediaEngine.vala" + g_warning ("MediaEngine.vala:1159: An error occurred adding the track: %s", _error_->message); +#line 4839 "MediaEngine.c" + _g_error_free0 (_error_); + _g_object_unref0 (media_track); +#line 1160 "MediaEngine.vala" + return; +#line 4844 "MediaEngine.c" + } + } + __finally11: + if (_inner_error_ != NULL) { + _g_object_unref0 (media_track); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } +#line 1163 "MediaEngine.vala" + g_signal_connect_object (media_track, "track-removed", (GCallback) _view_media_engine_on_track_removed_view_media_track_track_removed, self, 0); +#line 1164 "MediaEngine.vala" + g_signal_connect_object (media_track, "error-occurred", (GCallback) _view_media_engine_on_error_occurred_view_media_track_error_occurred, self, 0); +#line 1166 "MediaEngine.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->tracks), media_track); +#line 4860 "MediaEngine.c" + _g_object_unref0 (media_track); +} + + +#line 1169 "MediaEngine.vala" +static ViewMediaTrack* view_media_engine_create_audio_track (ViewMediaEngine* self, ModelTrack* track, GError** error) { +#line 4867 "MediaEngine.c" + ViewMediaTrack* result = NULL; + GError * _inner_error_; + ModelTrack* _tmp0_; + ModelAudioTrack* model_track; + ViewMediaAudioTrack* audio_track; +#line 1169 "MediaEngine.vala" + g_return_val_if_fail (VIEW_IS_MEDIA_ENGINE (self), NULL); +#line 1169 "MediaEngine.vala" + g_return_val_if_fail (MODEL_IS_TRACK (track), NULL); +#line 4877 "MediaEngine.c" + _inner_error_ = NULL; +#line 1170 "MediaEngine.vala" + model_track = _g_object_ref0 ((_tmp0_ = track, MODEL_IS_AUDIO_TRACK (_tmp0_) ? ((ModelAudioTrack*) _tmp0_) : NULL)); +#line 1171 "MediaEngine.vala" + audio_track = NULL; +#line 1172 "MediaEngine.vala" + if (model_track != NULL) { +#line 4885 "MediaEngine.c" + ViewMediaAudioTrack* _tmp1_; + ViewMediaAudioTrack* _tmp2_; +#line 1173 "MediaEngine.vala" + _tmp1_ = view_media_audio_track_new (self, model_track, &_inner_error_); +#line 4890 "MediaEngine.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + _g_object_unref0 (model_track); + _g_object_unref0 (audio_track); + return NULL; + } +#line 1173 "MediaEngine.vala" + audio_track = (_tmp2_ = _tmp1_, _g_object_unref0 (audio_track), _tmp2_); +#line 4899 "MediaEngine.c" + } else { +#line 1175 "MediaEngine.vala" + g_assert (FALSE); +#line 4903 "MediaEngine.c" + } + result = VIEW_MEDIA_TRACK (audio_track); + _g_object_unref0 (model_track); +#line 1177 "MediaEngine.vala" + return result; +#line 4909 "MediaEngine.c" +} + + +#line 1180 "MediaEngine.vala" +static void view_media_engine_on_track_removed (ViewMediaEngine* self, ViewMediaTrack* track) { +#line 1180 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 1180 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_TRACK (track)); +#line 1181 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_track_removed"); +#line 1182 "MediaEngine.vala" + gee_abstract_collection_remove (GEE_ABSTRACT_COLLECTION (self->priv->tracks), track); +#line 4923 "MediaEngine.c" +} + + +#line 1185 "MediaEngine.vala" +static void view_media_engine_on_error_occurred (ViewMediaEngine* self, const char* major_message, const char* minor_message) { +#line 1185 "MediaEngine.vala" + g_return_if_fail (VIEW_IS_MEDIA_ENGINE (self)); +#line 1185 "MediaEngine.vala" + g_return_if_fail (major_message != NULL); +#line 1186 "MediaEngine.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_error_occurred"); +#line 1187 "MediaEngine.vala" + g_signal_emit_by_name (self, "error-occurred", major_message, minor_message); +#line 4937 "MediaEngine.c" +} + + +static void view_media_engine_class_init (ViewMediaEngineClass * klass) { + view_media_engine_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ViewMediaEnginePrivate)); + VIEW_MEDIA_ENGINE_CLASS (klass)->do_null_state_export = view_media_engine_real_do_null_state_export; + VIEW_MEDIA_ENGINE_CLASS (klass)->pause = view_media_engine_real_pause; + G_OBJECT_CLASS (klass)->finalize = view_media_engine_finalize; + g_signal_new ("playstate_changed", VIEW_TYPE_MEDIA_ENGINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); + g_signal_new ("position_changed", VIEW_TYPE_MEDIA_ENGINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__INT64, G_TYPE_NONE, 1, G_TYPE_INT64); + g_signal_new ("pre_export", VIEW_TYPE_MEDIA_ENGINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__INT64, G_TYPE_NONE, 1, G_TYPE_INT64); + g_signal_new ("post_export", VIEW_TYPE_MEDIA_ENGINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1, G_TYPE_BOOLEAN); + g_signal_new ("callback_pulse", VIEW_TYPE_MEDIA_ENGINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); + g_signal_new ("level_changed", VIEW_TYPE_MEDIA_ENGINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__OBJECT_DOUBLE_DOUBLE, G_TYPE_NONE, 3, GST_TYPE_OBJECT, G_TYPE_DOUBLE, G_TYPE_DOUBLE); + g_signal_new ("record_completed", VIEW_TYPE_MEDIA_ENGINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); + g_signal_new ("link_for_playback", VIEW_TYPE_MEDIA_ENGINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GST_TYPE_ELEMENT); + g_signal_new ("link_for_export", VIEW_TYPE_MEDIA_ENGINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GST_TYPE_ELEMENT); + g_signal_new ("prepare_window", VIEW_TYPE_MEDIA_ENGINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); + g_signal_new ("error_occurred", VIEW_TYPE_MEDIA_ENGINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__STRING_STRING, G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRING); +} + + +static void view_media_engine_multi_file_progress_interface_interface_init (MultiFileProgressInterfaceIface * iface) { + view_media_engine_multi_file_progress_interface_parent_iface = g_type_interface_peek_parent (iface); + iface->cancel = view_media_engine_real_cancel; + iface->complete = view_media_engine_real_complete; +} + + +static void view_media_engine_instance_init (ViewMediaEngine * self) { + self->priv = VIEW_MEDIA_ENGINE_GET_PRIVATE (self); + self->play_state = PLAY_STATE_STOPPED; +} + + +static void view_media_engine_finalize (GObject* obj) { + ViewMediaEngine * self; + self = VIEW_MEDIA_ENGINE (obj); + _gst_object_unref0 (self->pipeline); + _gst_object_unref0 (self->record_bin); + _gst_object_unref0 (self->converter); + _gst_object_unref0 (self->adder); + _g_object_unref0 (self->record_track); + _g_object_unref0 (self->record_region); + _gst_object_unref0 (self->priv->audio_in); + _gst_object_unref0 (self->priv->record_capsfilter); + _gst_object_unref0 (self->priv->wav_encoder); + _gst_object_unref0 (self->priv->record_sink); + _g_object_unref0 (self->priv->tracks); + G_OBJECT_CLASS (view_media_engine_parent_class)->finalize (obj); +} + + +GType view_media_engine_get_type (void) { + static volatile gsize view_media_engine_type_id__volatile = 0; + if (g_once_init_enter (&view_media_engine_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ViewMediaEngineClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_media_engine_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewMediaEngine), 0, (GInstanceInitFunc) view_media_engine_instance_init, NULL }; + static const GInterfaceInfo multi_file_progress_interface_info = { (GInterfaceInitFunc) view_media_engine_multi_file_progress_interface_interface_init, (GInterfaceFinalizeFunc) NULL, NULL}; + GType view_media_engine_type_id; + view_media_engine_type_id = g_type_register_static (G_TYPE_OBJECT, "ViewMediaEngine", &g_define_type_info, 0); + g_type_add_interface_static (view_media_engine_type_id, TYPE_MULTI_FILE_PROGRESS_INTERFACE, &multi_file_progress_interface_info); + g_once_init_leave (&view_media_engine_type_id__volatile, view_media_engine_type_id); + } + return view_media_engine_type_id__volatile; +} + + +static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) { + if ((array != NULL) && (destroy_func != NULL)) { + int i; + for (i = 0; i < array_length; i = i + 1) { + if (((gpointer*) array)[i] != NULL) { + destroy_func (((gpointer*) array)[i]); + } + } + } +} + + +static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) { + _vala_array_destroy (array, array_length, destroy_func); + g_free (array); +} + + +static int _vala_strcmp0 (const char * str1, const char * str2) { + if (str1 == NULL) { + return -(str1 != str2); + } + if (str2 == NULL) { + return str1 != str2; + } + return strcmp (str1, str2); +} + + + +static void g_cclosure_user_marshal_VOID__STRING_STRING (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) { + typedef void (*GMarshalFunc_VOID__STRING_STRING) (gpointer data1, const char* arg_1, const char* arg_2, gpointer data2); + register GMarshalFunc_VOID__STRING_STRING callback; + register GCClosure * cc; + register gpointer data1, data2; + cc = (GCClosure *) closure; + g_return_if_fail (n_param_values == 3); + if (G_CCLOSURE_SWAP_DATA (closure)) { + data1 = closure->data; + data2 = param_values->data[0].v_pointer; + } else { + data1 = param_values->data[0].v_pointer; + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__STRING_STRING) (marshal_data ? marshal_data : cc->callback); + callback (data1, g_value_get_string (param_values + 1), g_value_get_string (param_values + 2), data2); +} + + +static void g_cclosure_user_marshal_VOID__DOUBLE_DOUBLE (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) { + typedef void (*GMarshalFunc_VOID__DOUBLE_DOUBLE) (gpointer data1, double arg_1, double arg_2, gpointer data2); + register GMarshalFunc_VOID__DOUBLE_DOUBLE callback; + register GCClosure * cc; + register gpointer data1, data2; + cc = (GCClosure *) closure; + g_return_if_fail (n_param_values == 3); + if (G_CCLOSURE_SWAP_DATA (closure)) { + data1 = closure->data; + data2 = param_values->data[0].v_pointer; + } else { + data1 = param_values->data[0].v_pointer; + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__DOUBLE_DOUBLE) (marshal_data ? marshal_data : cc->callback); + callback (data1, g_value_get_double (param_values + 1), g_value_get_double (param_values + 2), data2); +} + + +static void g_cclosure_user_marshal_VOID__INT64 (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) { + typedef void (*GMarshalFunc_VOID__INT64) (gpointer data1, gint64 arg_1, gpointer data2); + register GMarshalFunc_VOID__INT64 callback; + register GCClosure * cc; + register gpointer data1, data2; + cc = (GCClosure *) closure; + g_return_if_fail (n_param_values == 2); + if (G_CCLOSURE_SWAP_DATA (closure)) { + data1 = closure->data; + data2 = param_values->data[0].v_pointer; + } else { + data1 = param_values->data[0].v_pointer; + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__INT64) (marshal_data ? marshal_data : cc->callback); + callback (data1, g_value_get_int64 (param_values + 1), data2); +} + + +static void g_cclosure_user_marshal_VOID__OBJECT_DOUBLE_DOUBLE (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) { + typedef void (*GMarshalFunc_VOID__OBJECT_DOUBLE_DOUBLE) (gpointer data1, gpointer arg_1, double arg_2, double arg_3, gpointer data2); + register GMarshalFunc_VOID__OBJECT_DOUBLE_DOUBLE callback; + register GCClosure * cc; + register gpointer data1, data2; + cc = (GCClosure *) closure; + g_return_if_fail (n_param_values == 4); + if (G_CCLOSURE_SWAP_DATA (closure)) { + data1 = closure->data; + data2 = param_values->data[0].v_pointer; + } else { + data1 = param_values->data[0].v_pointer; + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__OBJECT_DOUBLE_DOUBLE) (marshal_data ? marshal_data : cc->callback); + callback (data1, g_value_get_object (param_values + 1), g_value_get_double (param_values + 2), g_value_get_double (param_values + 3), data2); +} + + + diff --git a/src/marina/marina/MediaEngine.o b/src/marina/marina/MediaEngine.o new file mode 100644 index 0000000..881eb6f Binary files /dev/null and b/src/marina/marina/MediaEngine.o differ diff --git a/src/marina/marina/MultiFileProgress.c b/src/marina/marina/MultiFileProgress.c new file mode 100644 index 0000000..df969ee --- /dev/null +++ b/src/marina/marina/MultiFileProgress.c @@ -0,0 +1,441 @@ +/* MultiFileProgress.c generated by valac, the Vala compiler + * generated from MultiFileProgress.vala, do not modify */ + +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include + + +#define TYPE_MULTI_FILE_PROGRESS_INTERFACE (multi_file_progress_interface_get_type ()) +#define MULTI_FILE_PROGRESS_INTERFACE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MULTI_FILE_PROGRESS_INTERFACE, MultiFileProgressInterface)) +#define IS_MULTI_FILE_PROGRESS_INTERFACE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MULTI_FILE_PROGRESS_INTERFACE)) +#define MULTI_FILE_PROGRESS_INTERFACE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_MULTI_FILE_PROGRESS_INTERFACE, MultiFileProgressInterfaceIface)) + +typedef struct _MultiFileProgressInterface MultiFileProgressInterface; +typedef struct _MultiFileProgressInterfaceIface MultiFileProgressInterfaceIface; + +#define TYPE_MULTI_FILE_PROGRESS (multi_file_progress_get_type ()) +#define MULTI_FILE_PROGRESS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MULTI_FILE_PROGRESS, MultiFileProgress)) +#define MULTI_FILE_PROGRESS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_MULTI_FILE_PROGRESS, MultiFileProgressClass)) +#define IS_MULTI_FILE_PROGRESS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MULTI_FILE_PROGRESS)) +#define IS_MULTI_FILE_PROGRESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_MULTI_FILE_PROGRESS)) +#define MULTI_FILE_PROGRESS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_MULTI_FILE_PROGRESS, MultiFileProgressClass)) + +typedef struct _MultiFileProgress MultiFileProgress; +typedef struct _MultiFileProgressClass MultiFileProgressClass; +typedef struct _MultiFileProgressPrivate MultiFileProgressPrivate; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +#define _g_free0(var) (var = (g_free (var), NULL)) + +#define LOGGING_TYPE_FACILITY (logging_facility_get_type ()) + +#define LOGGING_TYPE_LEVEL (logging_level_get_type ()) + +struct _MultiFileProgressInterfaceIface { + GTypeInterface parent_iface; + void (*cancel) (MultiFileProgressInterface* self); + void (*complete) (MultiFileProgressInterface* self); +}; + +struct _MultiFileProgress { + GtkWindow parent_instance; + MultiFileProgressPrivate * priv; +}; + +struct _MultiFileProgressClass { + GtkWindowClass parent_class; +}; + +struct _MultiFileProgressPrivate { + GtkProgressBar* progress_bar; + GtkLabel* file_label; + GtkLabel* number_label; + GtkButton* cancel_button; + gint num_files; + gboolean needs_show; + MultiFileProgressInterface* provider_interface; + char* dialog_title; +}; + +typedef enum { + LOGGING_FACILITY_SIGNAL_HANDLERS, + LOGGING_FACILITY_DEVELOPER_WARNINGS, + LOGGING_FACILITY_GRAPH, + LOGGING_FACILITY_LOADING, + LOGGING_FACILITY_IMPORT, + LOGGING_FACILITY_SINGLEDECODEBIN +} LoggingFacility; + +typedef enum { + LOGGING_LEVEL_CRITICAL, + LOGGING_LEVEL_HIGH, + LOGGING_LEVEL_MEDIUM, + LOGGING_LEVEL_LOW, + LOGGING_LEVEL_INFO, + LOGGING_LEVEL_VERBOSE +} LoggingLevel; + + +static gpointer multi_file_progress_parent_class = NULL; + +GType multi_file_progress_interface_get_type (void); +void multi_file_progress_interface_cancel (MultiFileProgressInterface* self); +void multi_file_progress_interface_complete (MultiFileProgressInterface* self); +GType multi_file_progress_get_type (void); +#define MULTI_FILE_PROGRESS_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_MULTI_FILE_PROGRESS, MultiFileProgressPrivate)) +enum { + MULTI_FILE_PROGRESS_DUMMY_PROPERTY +}; +static void multi_file_progress_on_cancel_clicked (MultiFileProgress* self); +static void _multi_file_progress_on_cancel_clicked_gtk_button_clicked (GtkButton* _sender, gpointer self); +static void multi_file_progress_on_fraction_updated (MultiFileProgress* self, double d); +static void _multi_file_progress_on_fraction_updated_multi_file_progress_interface_fraction_updated (MultiFileProgressInterface* _sender, double d, gpointer self); +static void multi_file_progress_on_file_updated (MultiFileProgress* self, const char* filename, gint index); +static void _multi_file_progress_on_file_updated_multi_file_progress_interface_file_updated (MultiFileProgressInterface* _sender, const char* filename, gint index, gpointer self); +static void multi_file_progress_on_done (MultiFileProgress* self); +static void _multi_file_progress_on_done_multi_file_progress_interface_done (MultiFileProgressInterface* _sender, gpointer self); +MultiFileProgress* multi_file_progress_new (GtkWindow* parent, gint num_files, const char* dialog_title, MultiFileProgressInterface* provider); +MultiFileProgress* multi_file_progress_construct (GType object_type, GtkWindow* parent, gint num_files, const char* dialog_title, MultiFileProgressInterface* provider); +GType logging_facility_get_type (void); +GType logging_level_get_type (void); +void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message); +static void multi_file_progress_on_destroy (MultiFileProgress* self); +static void _multi_file_progress_on_destroy_gtk_object_destroy (GtkObject* _sender, gpointer self); +static void multi_file_progress_finalize (GObject* obj); + + +static void g_cclosure_user_marshal_VOID__STRING_INT (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data); + +#line 14 "MultiFileProgress.vala" +void multi_file_progress_interface_cancel (MultiFileProgressInterface* self) { +#line 14 "MultiFileProgress.vala" + MULTI_FILE_PROGRESS_INTERFACE_GET_INTERFACE (self)->cancel (self); +#line 124 "MultiFileProgress.c" +} + + +#line 15 "MultiFileProgress.vala" +void multi_file_progress_interface_complete (MultiFileProgressInterface* self) { +#line 15 "MultiFileProgress.vala" + MULTI_FILE_PROGRESS_INTERFACE_GET_INTERFACE (self)->complete (self); +#line 132 "MultiFileProgress.c" +} + + +static void multi_file_progress_interface_base_init (MultiFileProgressInterfaceIface * iface) { + static gboolean initialized = FALSE; + if (!initialized) { + initialized = TRUE; + g_signal_new ("fraction_updated", TYPE_MULTI_FILE_PROGRESS_INTERFACE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__DOUBLE, G_TYPE_NONE, 1, G_TYPE_DOUBLE); + g_signal_new ("file_updated", TYPE_MULTI_FILE_PROGRESS_INTERFACE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__STRING_INT, G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_INT); + g_signal_new ("done", TYPE_MULTI_FILE_PROGRESS_INTERFACE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); + } +} + + +GType multi_file_progress_interface_get_type (void) { + static volatile gsize multi_file_progress_interface_type_id__volatile = 0; + if (g_once_init_enter (&multi_file_progress_interface_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (MultiFileProgressInterfaceIface), (GBaseInitFunc) multi_file_progress_interface_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL }; + GType multi_file_progress_interface_type_id; + multi_file_progress_interface_type_id = g_type_register_static (G_TYPE_INTERFACE, "MultiFileProgressInterface", &g_define_type_info, 0); + g_type_interface_add_prerequisite (multi_file_progress_interface_type_id, G_TYPE_OBJECT); + g_once_init_leave (&multi_file_progress_interface_type_id__volatile, multi_file_progress_interface_type_id); + } + return multi_file_progress_interface_type_id__volatile; +} + + +#line 71 "MultiFileProgress.vala" +static void _multi_file_progress_on_cancel_clicked_gtk_button_clicked (GtkButton* _sender, gpointer self) { +#line 162 "MultiFileProgress.c" + multi_file_progress_on_cancel_clicked (self); +} + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 84 "MultiFileProgress.vala" +static void _multi_file_progress_on_fraction_updated_multi_file_progress_interface_fraction_updated (MultiFileProgressInterface* _sender, double d, gpointer self) { +#line 174 "MultiFileProgress.c" + multi_file_progress_on_fraction_updated (self, d); +} + + +#line 107 "MultiFileProgress.vala" +static void _multi_file_progress_on_file_updated_multi_file_progress_interface_file_updated (MultiFileProgressInterface* _sender, const char* filename, gint index, gpointer self) { +#line 181 "MultiFileProgress.c" + multi_file_progress_on_file_updated (self, filename, index); +} + + +#line 66 "MultiFileProgress.vala" +static void _multi_file_progress_on_done_multi_file_progress_interface_done (MultiFileProgressInterface* _sender, gpointer self) { +#line 188 "MultiFileProgress.c" + multi_file_progress_on_done (self); +} + + +#line 30 "MultiFileProgress.vala" +MultiFileProgress* multi_file_progress_construct (GType object_type, GtkWindow* parent, gint num_files, const char* dialog_title, MultiFileProgressInterface* provider) { +#line 195 "MultiFileProgress.c" + MultiFileProgress * self; + GtkLabel* _tmp0_; + GtkLabel* _tmp1_; + GtkProgressBar* _tmp2_; + GtkVBox* vbox; + GtkHButtonBox* button_area; + GtkButton* _tmp3_; + char* _tmp4_; + MultiFileProgressInterface* _tmp5_; +#line 30 "MultiFileProgress.vala" + g_return_val_if_fail (GTK_IS_WINDOW (parent), NULL); +#line 30 "MultiFileProgress.vala" + g_return_val_if_fail (dialog_title != NULL, NULL); +#line 30 "MultiFileProgress.vala" + g_return_val_if_fail (IS_MULTI_FILE_PROGRESS_INTERFACE (provider), NULL); +#line 211 "MultiFileProgress.c" + self = g_object_newv (object_type, 0, NULL); +#line 32 "MultiFileProgress.vala" + self->priv->num_files = num_files; +#line 33 "MultiFileProgress.vala" + self->priv->needs_show = TRUE; +#line 34 "MultiFileProgress.vala" + self->priv->file_label = (_tmp0_ = g_object_ref_sink ((GtkLabel*) gtk_label_new ("")), _g_object_unref0 (self->priv->file_label), _tmp0_); +#line 35 "MultiFileProgress.vala" + self->priv->number_label = (_tmp1_ = g_object_ref_sink ((GtkLabel*) gtk_label_new ("")), _g_object_unref0 (self->priv->number_label), _tmp1_); +#line 36 "MultiFileProgress.vala" + self->priv->progress_bar = (_tmp2_ = g_object_ref_sink ((GtkProgressBar*) gtk_progress_bar_new ()), _g_object_unref0 (self->priv->progress_bar), _tmp2_); +#line 38 "MultiFileProgress.vala" + vbox = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (TRUE, 0)); +#line 40 "MultiFileProgress.vala" + gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (self->priv->number_label), FALSE, FALSE, (guint) 0); +#line 41 "MultiFileProgress.vala" + gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (self->priv->file_label), FALSE, FALSE, (guint) 0); +#line 42 "MultiFileProgress.vala" + gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (self->priv->progress_bar), FALSE, FALSE, (guint) 0); +#line 44 "MultiFileProgress.vala" + button_area = g_object_ref_sink ((GtkHButtonBox*) gtk_hbutton_box_new ()); +#line 45 "MultiFileProgress.vala" + g_object_set (G_OBJECT (button_area), "layout-style", GTK_BUTTONBOX_CENTER, NULL); +#line 47 "MultiFileProgress.vala" + self->priv->cancel_button = (_tmp3_ = g_object_ref_sink ((GtkButton*) gtk_button_new_from_stock (GTK_STOCK_CANCEL)), _g_object_unref0 (self->priv->cancel_button), _tmp3_); +#line 48 "MultiFileProgress.vala" + g_signal_connect_object (self->priv->cancel_button, "clicked", (GCallback) _multi_file_progress_on_cancel_clicked_gtk_button_clicked, self, 0); +#line 50 "MultiFileProgress.vala" + gtk_container_add (GTK_CONTAINER (button_area), GTK_WIDGET (self->priv->cancel_button)); +#line 52 "MultiFileProgress.vala" + gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (button_area), FALSE, FALSE, (guint) 0); +#line 53 "MultiFileProgress.vala" + gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (vbox)); +#line 55 "MultiFileProgress.vala" + gtk_window_set_transient_for (GTK_WINDOW (self), parent); +#line 56 "MultiFileProgress.vala" + gtk_window_set_title (GTK_WINDOW (self), dialog_title); +#line 57 "MultiFileProgress.vala" + self->priv->dialog_title = (_tmp4_ = g_strdup (dialog_title), _g_free0 (self->priv->dialog_title), _tmp4_); +#line 59 "MultiFileProgress.vala" + self->priv->provider_interface = (_tmp5_ = _g_object_ref0 (provider), _g_object_unref0 (self->priv->provider_interface), _tmp5_); +#line 61 "MultiFileProgress.vala" + g_signal_connect_object (self->priv->provider_interface, "fraction-updated", (GCallback) _multi_file_progress_on_fraction_updated_multi_file_progress_interface_fraction_updated, self, 0); +#line 62 "MultiFileProgress.vala" + g_signal_connect_object (self->priv->provider_interface, "file-updated", (GCallback) _multi_file_progress_on_file_updated_multi_file_progress_interface_file_updated, self, 0); +#line 63 "MultiFileProgress.vala" + g_signal_connect_object (self->priv->provider_interface, "done", (GCallback) _multi_file_progress_on_done_multi_file_progress_interface_done, self, 0); +#line 259 "MultiFileProgress.c" + _g_object_unref0 (vbox); + _g_object_unref0 (button_area); + return self; +} + + +#line 30 "MultiFileProgress.vala" +MultiFileProgress* multi_file_progress_new (GtkWindow* parent, gint num_files, const char* dialog_title, MultiFileProgressInterface* provider) { +#line 30 "MultiFileProgress.vala" + return multi_file_progress_construct (TYPE_MULTI_FILE_PROGRESS, parent, num_files, dialog_title, provider); +#line 270 "MultiFileProgress.c" +} + + +#line 66 "MultiFileProgress.vala" +static void multi_file_progress_on_done (MultiFileProgress* self) { +#line 66 "MultiFileProgress.vala" + g_return_if_fail (IS_MULTI_FILE_PROGRESS (self)); +#line 67 "MultiFileProgress.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_done"); +#line 68 "MultiFileProgress.vala" + gtk_object_destroy (GTK_OBJECT (self)); +#line 282 "MultiFileProgress.c" +} + + +#line 71 "MultiFileProgress.vala" +static void multi_file_progress_on_cancel_clicked (MultiFileProgress* self) { +#line 71 "MultiFileProgress.vala" + g_return_if_fail (IS_MULTI_FILE_PROGRESS (self)); +#line 72 "MultiFileProgress.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_cancel_clicked"); +#line 73 "MultiFileProgress.vala" + gtk_object_destroy (GTK_OBJECT (self)); +#line 294 "MultiFileProgress.c" +} + + +#line 76 "MultiFileProgress.vala" +static void multi_file_progress_on_destroy (MultiFileProgress* self) { +#line 76 "MultiFileProgress.vala" + g_return_if_fail (IS_MULTI_FILE_PROGRESS (self)); +#line 77 "MultiFileProgress.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_destroy"); +#line 78 "MultiFileProgress.vala" + if (gtk_progress_bar_get_fraction (self->priv->progress_bar) < 1.0) { +#line 79 "MultiFileProgress.vala" + multi_file_progress_interface_cancel (self->priv->provider_interface); +#line 308 "MultiFileProgress.c" + } else { +#line 81 "MultiFileProgress.vala" + multi_file_progress_interface_complete (self->priv->provider_interface); +#line 312 "MultiFileProgress.c" + } +} + + +#line 76 "MultiFileProgress.vala" +static void _multi_file_progress_on_destroy_gtk_object_destroy (GtkObject* _sender, gpointer self) { +#line 319 "MultiFileProgress.c" + multi_file_progress_on_destroy (self); +} + + +#line 84 "MultiFileProgress.vala" +static void multi_file_progress_on_fraction_updated (MultiFileProgress* self, double d) { +#line 84 "MultiFileProgress.vala" + g_return_if_fail (IS_MULTI_FILE_PROGRESS (self)); +#line 85 "MultiFileProgress.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_fraction_updated"); +#line 86 "MultiFileProgress.vala" + if (self->priv->needs_show) { +#line 87 "MultiFileProgress.vala" + self->priv->needs_show = FALSE; +#line 88 "MultiFileProgress.vala" + gtk_container_set_border_width (GTK_CONTAINER (self), (guint) 8); +#line 89 "MultiFileProgress.vala" + gtk_window_set_resizable (GTK_WINDOW (self), FALSE); +#line 90 "MultiFileProgress.vala" + gtk_window_set_modal (GTK_WINDOW (self), TRUE); +#line 92 "MultiFileProgress.vala" + g_signal_connect_object (GTK_OBJECT (self), "destroy", (GCallback) _multi_file_progress_on_destroy_gtk_object_destroy, self, 0); +#line 94 "MultiFileProgress.vala" + gtk_widget_show_all (GTK_WIDGET (self)); +#line 344 "MultiFileProgress.c" + } +#line 97 "MultiFileProgress.vala" + gtk_progress_bar_set_fraction (self->priv->progress_bar, d); +#line 99 "MultiFileProgress.vala" + if (gtk_progress_bar_get_fraction (self->priv->progress_bar) == 1.0) { +#line 100 "MultiFileProgress.vala" + gtk_object_destroy (GTK_OBJECT (self)); +#line 352 "MultiFileProgress.c" + } else { +#line 102 "MultiFileProgress.vala" + gtk_widget_show_all (GTK_WIDGET (self)); +#line 103 "MultiFileProgress.vala" + gtk_widget_queue_draw (GTK_WIDGET (self)); +#line 358 "MultiFileProgress.c" + } +} + + +#line 107 "MultiFileProgress.vala" +static void multi_file_progress_on_file_updated (MultiFileProgress* self, const char* filename, gint index) { +#line 365 "MultiFileProgress.c" + char* _tmp0_; + char* _tmp1_; +#line 107 "MultiFileProgress.vala" + g_return_if_fail (IS_MULTI_FILE_PROGRESS (self)); +#line 107 "MultiFileProgress.vala" + g_return_if_fail (filename != NULL); +#line 108 "MultiFileProgress.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_file_updated"); +#line 109 "MultiFileProgress.vala" + gtk_label_set_text (self->priv->number_label, _tmp0_ = g_strdup_printf ("%sing %d of %d", self->priv->dialog_title, index + 1, self->priv->num_files)); +#line 376 "MultiFileProgress.c" + _g_free0 (_tmp0_); +#line 110 "MultiFileProgress.vala" + gtk_label_set_text (self->priv->file_label, _tmp1_ = g_strdup_printf ("%s", filename)); +#line 380 "MultiFileProgress.c" + _g_free0 (_tmp1_); +} + + +static void multi_file_progress_class_init (MultiFileProgressClass * klass) { + multi_file_progress_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (MultiFileProgressPrivate)); + G_OBJECT_CLASS (klass)->finalize = multi_file_progress_finalize; +} + + +static void multi_file_progress_instance_init (MultiFileProgress * self) { + self->priv = MULTI_FILE_PROGRESS_GET_PRIVATE (self); +} + + +static void multi_file_progress_finalize (GObject* obj) { + MultiFileProgress * self; + self = MULTI_FILE_PROGRESS (obj); + _g_object_unref0 (self->priv->progress_bar); + _g_object_unref0 (self->priv->file_label); + _g_object_unref0 (self->priv->number_label); + _g_object_unref0 (self->priv->cancel_button); + _g_object_unref0 (self->priv->provider_interface); + _g_free0 (self->priv->dialog_title); + G_OBJECT_CLASS (multi_file_progress_parent_class)->finalize (obj); +} + + +GType multi_file_progress_get_type (void) { + static volatile gsize multi_file_progress_type_id__volatile = 0; + if (g_once_init_enter (&multi_file_progress_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (MultiFileProgressClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) multi_file_progress_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (MultiFileProgress), 0, (GInstanceInitFunc) multi_file_progress_instance_init, NULL }; + GType multi_file_progress_type_id; + multi_file_progress_type_id = g_type_register_static (GTK_TYPE_WINDOW, "MultiFileProgress", &g_define_type_info, 0); + g_once_init_leave (&multi_file_progress_type_id__volatile, multi_file_progress_type_id); + } + return multi_file_progress_type_id__volatile; +} + + + +static void g_cclosure_user_marshal_VOID__STRING_INT (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) { + typedef void (*GMarshalFunc_VOID__STRING_INT) (gpointer data1, const char* arg_1, gint arg_2, gpointer data2); + register GMarshalFunc_VOID__STRING_INT callback; + register GCClosure * cc; + register gpointer data1, data2; + cc = (GCClosure *) closure; + g_return_if_fail (n_param_values == 3); + if (G_CCLOSURE_SWAP_DATA (closure)) { + data1 = closure->data; + data2 = param_values->data[0].v_pointer; + } else { + data1 = param_values->data[0].v_pointer; + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__STRING_INT) (marshal_data ? marshal_data : cc->callback); + callback (data1, g_value_get_string (param_values + 1), g_value_get_int (param_values + 2), data2); +} + + + diff --git a/src/marina/marina/MultiFileProgress.o b/src/marina/marina/MultiFileProgress.o new file mode 100644 index 0000000..0c3b979 Binary files /dev/null and b/src/marina/marina/MultiFileProgress.o differ diff --git a/src/marina/marina/ProjectLoader.c b/src/marina/marina/ProjectLoader.c new file mode 100644 index 0000000..9edaf3e --- /dev/null +++ b/src/marina/marina/ProjectLoader.c @@ -0,0 +1,2126 @@ +/* ProjectLoader.c generated by valac, the Vala compiler + * generated from ProjectLoader.vala, do not modify */ + +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include + + +#define MODEL_TYPE_LOADER_HANDLER (model_loader_handler_get_type ()) +#define MODEL_LOADER_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_LOADER_HANDLER, ModelLoaderHandler)) +#define MODEL_LOADER_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_LOADER_HANDLER, ModelLoaderHandlerClass)) +#define MODEL_IS_LOADER_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_LOADER_HANDLER)) +#define MODEL_IS_LOADER_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_LOADER_HANDLER)) +#define MODEL_LOADER_HANDLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_LOADER_HANDLER, ModelLoaderHandlerClass)) + +typedef struct _ModelLoaderHandler ModelLoaderHandler; +typedef struct _ModelLoaderHandlerClass ModelLoaderHandlerClass; +typedef struct _ModelLoaderHandlerPrivate ModelLoaderHandlerPrivate; + +#define MODEL_TYPE_XML_TREE_LOADER (model_xml_tree_loader_get_type ()) +#define MODEL_XML_TREE_LOADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_XML_TREE_LOADER, ModelXmlTreeLoader)) +#define MODEL_XML_TREE_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_XML_TREE_LOADER, ModelXmlTreeLoaderClass)) +#define MODEL_IS_XML_TREE_LOADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_XML_TREE_LOADER)) +#define MODEL_IS_XML_TREE_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_XML_TREE_LOADER)) +#define MODEL_XML_TREE_LOADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_XML_TREE_LOADER, ModelXmlTreeLoaderClass)) + +typedef struct _ModelXmlTreeLoader ModelXmlTreeLoader; +typedef struct _ModelXmlTreeLoaderClass ModelXmlTreeLoaderClass; +typedef struct _ModelXmlTreeLoaderPrivate ModelXmlTreeLoaderPrivate; + +#define MODEL_TYPE_XML_ELEMENT (model_xml_element_get_type ()) +#define MODEL_XML_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_XML_ELEMENT, ModelXmlElement)) +#define MODEL_XML_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_XML_ELEMENT, ModelXmlElementClass)) +#define MODEL_IS_XML_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_XML_ELEMENT)) +#define MODEL_IS_XML_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_XML_ELEMENT)) +#define MODEL_XML_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_XML_ELEMENT, ModelXmlElementClass)) + +typedef struct _ModelXmlElement ModelXmlElement; +typedef struct _ModelXmlElementClass ModelXmlElementClass; +#define _model_xml_element_unref0(var) ((var == NULL) ? NULL : (var = (model_xml_element_unref (var), NULL))) +#define _g_markup_parse_context_free0(var) ((var == NULL) ? NULL : (var = (g_markup_parse_context_free (var), NULL))) +#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL))) +typedef struct _ModelParamSpecXmlTreeLoader ModelParamSpecXmlTreeLoader; + +#define MODEL_TYPE_PROJECT_BUILDER (model_project_builder_get_type ()) +#define MODEL_PROJECT_BUILDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT_BUILDER, ModelProjectBuilder)) +#define MODEL_PROJECT_BUILDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT_BUILDER, ModelProjectBuilderClass)) +#define MODEL_IS_PROJECT_BUILDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT_BUILDER)) +#define MODEL_IS_PROJECT_BUILDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT_BUILDER)) +#define MODEL_PROJECT_BUILDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT_BUILDER, ModelProjectBuilderClass)) + +typedef struct _ModelProjectBuilder ModelProjectBuilder; +typedef struct _ModelProjectBuilderClass ModelProjectBuilderClass; +typedef struct _ModelProjectBuilderPrivate ModelProjectBuilderPrivate; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +#define _g_free0(var) (var = (g_free (var), NULL)) +typedef struct _ModelXmlElementPrivate ModelXmlElementPrivate; + +#define LOGGING_TYPE_FACILITY (logging_facility_get_type ()) + +#define LOGGING_TYPE_LEVEL (logging_level_get_type ()) +typedef struct _ModelParamSpecXmlElement ModelParamSpecXmlElement; + +#define MODEL_TYPE_PROJECT_LOADER (model_project_loader_get_type ()) +#define MODEL_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoader)) +#define MODEL_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass)) +#define MODEL_IS_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT_LOADER)) +#define MODEL_IS_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT_LOADER)) +#define MODEL_PROJECT_LOADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass)) + +typedef struct _ModelProjectLoader ModelProjectLoader; +typedef struct _ModelProjectLoaderClass ModelProjectLoaderClass; +typedef struct _ModelProjectLoaderPrivate ModelProjectLoaderPrivate; +#define _model_xml_tree_loader_unref0(var) ((var == NULL) ? NULL : (var = (model_xml_tree_loader_unref (var), NULL))) + +struct _ModelLoaderHandler { + GObject parent_instance; + ModelLoaderHandlerPrivate * priv; +}; + +struct _ModelLoaderHandlerClass { + GObjectClass parent_class; + gboolean (*commit_library) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_marina) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_track) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_clip) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_clipfile) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_time_signature_entry) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_tempo_entry) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_click) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_library_preference) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + void (*leave_library) (ModelLoaderHandler* self); + void (*leave_marina) (ModelLoaderHandler* self); + void (*leave_track) (ModelLoaderHandler* self); + void (*leave_clip) (ModelLoaderHandler* self); + void (*leave_clipfile) (ModelLoaderHandler* self); +}; + +struct _ModelXmlTreeLoader { + GTypeInstance parent_instance; + volatile int ref_count; + ModelXmlTreeLoaderPrivate * priv; + ModelXmlElement* root; +}; + +struct _ModelXmlTreeLoaderClass { + GTypeClass parent_class; + void (*finalize) (ModelXmlTreeLoader *self); +}; + +struct _ModelXmlTreeLoaderPrivate { + ModelXmlElement* current_element; +}; + +struct _ModelParamSpecXmlTreeLoader { + GParamSpec parent_instance; +}; + +struct _ModelProjectBuilder { + GObject parent_instance; + ModelProjectBuilderPrivate * priv; +}; + +struct _ModelProjectBuilderClass { + GObjectClass parent_class; +}; + +struct _ModelProjectBuilderPrivate { + ModelLoaderHandler* handler; +}; + +struct _ModelXmlElement { + GTypeInstance parent_instance; + volatile int ref_count; + ModelXmlElementPrivate * priv; + char** attribute_names; + gint attribute_names_length1; + char** attribute_values; + gint attribute_values_length1; +}; + +struct _ModelXmlElementClass { + GTypeClass parent_class; + void (*finalize) (ModelXmlElement *self); +}; + +typedef enum { + LOGGING_FACILITY_SIGNAL_HANDLERS, + LOGGING_FACILITY_DEVELOPER_WARNINGS, + LOGGING_FACILITY_GRAPH, + LOGGING_FACILITY_LOADING, + LOGGING_FACILITY_IMPORT, + LOGGING_FACILITY_SINGLEDECODEBIN +} LoggingFacility; + +typedef enum { + LOGGING_LEVEL_CRITICAL, + LOGGING_LEVEL_HIGH, + LOGGING_LEVEL_MEDIUM, + LOGGING_LEVEL_LOW, + LOGGING_LEVEL_INFO, + LOGGING_LEVEL_VERBOSE +} LoggingLevel; + +struct _ModelXmlElementPrivate { + char* _name; + ModelXmlElement* _parent; + GeeArrayList* _children; +}; + +struct _ModelParamSpecXmlElement { + GParamSpec parent_instance; +}; + +struct _ModelProjectLoader { + GObject parent_instance; + ModelProjectLoaderPrivate * priv; +}; + +struct _ModelProjectLoaderClass { + GObjectClass parent_class; +}; + +struct _ModelProjectLoaderPrivate { + char* file_name; + ModelLoaderHandler* loader_handler; + char* text; + gsize text_len; + gboolean project_load_completed; + gboolean load_completed_fired; + gboolean handler_completed; +}; + + +static gpointer model_loader_handler_parent_class = NULL; +static gpointer model_xml_tree_loader_parent_class = NULL; +static gpointer model_project_builder_parent_class = NULL; +static gpointer model_xml_element_parent_class = NULL; +static gpointer model_project_loader_parent_class = NULL; + +GType model_loader_handler_get_type (void); +enum { + MODEL_LOADER_HANDLER_DUMMY_PROPERTY +}; +ModelLoaderHandler* model_loader_handler_new (void); +ModelLoaderHandler* model_loader_handler_construct (GType object_type); +gboolean model_loader_handler_commit_library (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +static gboolean model_loader_handler_real_commit_library (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +gboolean model_loader_handler_commit_marina (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +static gboolean model_loader_handler_real_commit_marina (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +gboolean model_loader_handler_commit_track (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +static gboolean model_loader_handler_real_commit_track (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +gboolean model_loader_handler_commit_clip (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +static gboolean model_loader_handler_real_commit_clip (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +gboolean model_loader_handler_commit_clipfile (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +static gboolean model_loader_handler_real_commit_clipfile (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +gboolean model_loader_handler_commit_time_signature_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +static gboolean model_loader_handler_real_commit_time_signature_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +gboolean model_loader_handler_commit_tempo_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +static gboolean model_loader_handler_real_commit_tempo_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +gboolean model_loader_handler_commit_click (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +static gboolean model_loader_handler_real_commit_click (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +gboolean model_loader_handler_commit_library_preference (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +static gboolean model_loader_handler_real_commit_library_preference (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +void model_loader_handler_leave_library (ModelLoaderHandler* self); +static void model_loader_handler_real_leave_library (ModelLoaderHandler* self); +void model_loader_handler_leave_marina (ModelLoaderHandler* self); +static void model_loader_handler_real_leave_marina (ModelLoaderHandler* self); +void model_loader_handler_leave_track (ModelLoaderHandler* self); +static void model_loader_handler_real_leave_track (ModelLoaderHandler* self); +void model_loader_handler_leave_clip (ModelLoaderHandler* self); +static void model_loader_handler_real_leave_clip (ModelLoaderHandler* self); +void model_loader_handler_leave_clipfile (ModelLoaderHandler* self); +static void model_loader_handler_real_leave_clipfile (ModelLoaderHandler* self); +gpointer model_xml_tree_loader_ref (gpointer instance); +void model_xml_tree_loader_unref (gpointer instance); +GParamSpec* model_param_spec_xml_tree_loader (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_xml_tree_loader (GValue* value, gpointer v_object); +void model_value_take_xml_tree_loader (GValue* value, gpointer v_object); +gpointer model_value_get_xml_tree_loader (const GValue* value); +GType model_xml_tree_loader_get_type (void); +gpointer model_xml_element_ref (gpointer instance); +void model_xml_element_unref (gpointer instance); +GParamSpec* model_param_spec_xml_element (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_xml_element (GValue* value, gpointer v_object); +void model_value_take_xml_element (GValue* value, gpointer v_object); +gpointer model_value_get_xml_element (const GValue* value); +GType model_xml_element_get_type (void); +#define MODEL_XML_TREE_LOADER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_XML_TREE_LOADER, ModelXmlTreeLoaderPrivate)) +enum { + MODEL_XML_TREE_LOADER_DUMMY_PROPERTY +}; +static void model_xml_tree_loader_xml_start_element (ModelXmlTreeLoader* self, GMarkupParseContext* c, const char* name, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +static void _model_xml_tree_loader_xml_start_element_gmarkup_parser_start_element_func (GMarkupParseContext* context, const char* element_name, char** attribute_names, char** attribute_values, gpointer self); +static void model_xml_tree_loader_xml_end_element (ModelXmlTreeLoader* self, GMarkupParseContext* c, const char* name); +static void _model_xml_tree_loader_xml_end_element_gmarkup_parser_end_element_func (GMarkupParseContext* context, const char* element_name, gpointer self); +ModelXmlTreeLoader* model_xml_tree_loader_new (const char* document); +ModelXmlTreeLoader* model_xml_tree_loader_construct (GType object_type, const char* document); +ModelXmlElement* model_xml_element_new (const char* name, char** attribute_names, int attribute_names_length1, char** attribute_values, int attribute_values_length1, ModelXmlElement* parent); +ModelXmlElement* model_xml_element_construct (GType object_type, const char* name, char** attribute_names, int attribute_names_length1, char** attribute_values, int attribute_values_length1, ModelXmlElement* parent); +void model_xml_element_add_child (ModelXmlElement* self, ModelXmlElement* child_element); +ModelXmlElement* model_xml_element_get_parent (ModelXmlElement* self); +static void model_xml_tree_loader_finalize (ModelXmlTreeLoader* obj); +GType model_project_builder_get_type (void); +#define MODEL_PROJECT_BUILDER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_PROJECT_BUILDER, ModelProjectBuilderPrivate)) +enum { + MODEL_PROJECT_BUILDER_DUMMY_PROPERTY +}; +ModelProjectBuilder* model_project_builder_new (ModelLoaderHandler* handler); +ModelProjectBuilder* model_project_builder_construct (GType object_type, ModelLoaderHandler* handler); +const char* model_xml_element_get_name (ModelXmlElement* self); +static gboolean model_project_builder_check_name (ModelProjectBuilder* self, const char* expected_name, ModelXmlElement* node); +GeeArrayList* model_xml_element_get_children (ModelXmlElement* self); +static void model_project_builder_handle_clip (ModelProjectBuilder* self, ModelXmlElement* clip); +GType logging_facility_get_type (void); +GType logging_level_get_type (void); +void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message); +static void model_project_builder_handle_track (ModelProjectBuilder* self, ModelXmlElement* track); +static void model_project_builder_handle_preference (ModelProjectBuilder* self, ModelXmlElement* preference); +static void model_project_builder_handle_time_signature (ModelProjectBuilder* self, ModelXmlElement* time_signature); +static void model_project_builder_handle_tempo (ModelProjectBuilder* self, ModelXmlElement* tempo); +static void model_project_builder_handle_map (ModelProjectBuilder* self, ModelXmlElement* map); +static void model_project_builder_handle_library (ModelProjectBuilder* self, ModelXmlElement* library); +static void model_project_builder_handle_tracks (ModelProjectBuilder* self, ModelXmlElement* tracks); +static void model_project_builder_handle_preferences (ModelProjectBuilder* self, ModelXmlElement* preferences); +static void model_project_builder_handle_maps (ModelProjectBuilder* self, ModelXmlElement* maps); +gboolean model_project_builder_check_project (ModelProjectBuilder* self, ModelXmlElement* root); +void model_project_builder_build_project (ModelProjectBuilder* self, ModelXmlElement* root); +static void model_project_builder_finalize (GObject* obj); +#define MODEL_XML_ELEMENT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_XML_ELEMENT, ModelXmlElementPrivate)) +enum { + MODEL_XML_ELEMENT_DUMMY_PROPERTY +}; +static void model_xml_element_set_name (ModelXmlElement* self, const char* value); +char** copy_array (char** source, int source_length1, int* result_length1); +static void model_xml_element_set_parent (ModelXmlElement* self, ModelXmlElement* value); +static void model_xml_element_finalize (ModelXmlElement* obj); +GType model_project_loader_get_type (void); +#define MODEL_PROJECT_LOADER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderPrivate)) +enum { + MODEL_PROJECT_LOADER_DUMMY_PROPERTY +}; +static void model_project_loader_on_load_error (ModelProjectLoader* self, const char* _error_); +static void _model_project_loader_on_load_error_model_loader_handler_load_error (ModelLoaderHandler* _sender, const char* error_message, gpointer self); +static void model_project_loader_on_handler_complete (ModelProjectLoader* self); +static void _model_project_loader_on_handler_complete_model_loader_handler_complete (ModelLoaderHandler* _sender, gpointer self); +ModelProjectLoader* model_project_loader_new (ModelLoaderHandler* loader_handler, const char* file_name); +ModelProjectLoader* model_project_loader_construct (GType object_type, ModelLoaderHandler* loader_handler, const char* file_name); +static void _model_project_loader_on_load_error_model_project_builder_error_occurred (ModelProjectBuilder* _sender, const char* _error_, gpointer self); +void model_project_loader_load (ModelProjectLoader* self); +static void model_project_loader_finalize (GObject* obj); +static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func); +static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func); +static gint _vala_array_length (gpointer array); +static int _vala_strcmp0 (const char * str1, const char * str2); + + + +#line 15 "ProjectLoader.vala" +ModelLoaderHandler* model_loader_handler_construct (GType object_type) { +#line 332 "ProjectLoader.c" + ModelLoaderHandler * self; +#line 15 "ProjectLoader.vala" + self = (ModelLoaderHandler*) g_object_new (object_type, NULL); +#line 336 "ProjectLoader.c" + return self; +} + + +#line 15 "ProjectLoader.vala" +ModelLoaderHandler* model_loader_handler_new (void) { +#line 15 "ProjectLoader.vala" + return model_loader_handler_construct (MODEL_TYPE_LOADER_HANDLER); +#line 345 "ProjectLoader.c" +} + + +#line 18 "ProjectLoader.vala" +static gboolean model_loader_handler_real_commit_library (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 351 "ProjectLoader.c" + gboolean result = FALSE; +#line 18 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE); +#line 355 "ProjectLoader.c" + result = TRUE; +#line 19 "ProjectLoader.vala" + return result; +#line 359 "ProjectLoader.c" +} + + +#line 18 "ProjectLoader.vala" +gboolean model_loader_handler_commit_library (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 18 "ProjectLoader.vala" + return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_library (self, attr_names, attr_names_length1, attr_values, attr_values_length1); +#line 367 "ProjectLoader.c" +} + + +#line 22 "ProjectLoader.vala" +static gboolean model_loader_handler_real_commit_marina (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 373 "ProjectLoader.c" + gboolean result = FALSE; +#line 22 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE); +#line 377 "ProjectLoader.c" + result = TRUE; +#line 23 "ProjectLoader.vala" + return result; +#line 381 "ProjectLoader.c" +} + + +#line 22 "ProjectLoader.vala" +gboolean model_loader_handler_commit_marina (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 22 "ProjectLoader.vala" + return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_marina (self, attr_names, attr_names_length1, attr_values, attr_values_length1); +#line 389 "ProjectLoader.c" +} + + +#line 26 "ProjectLoader.vala" +static gboolean model_loader_handler_real_commit_track (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 395 "ProjectLoader.c" + gboolean result = FALSE; +#line 26 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE); +#line 399 "ProjectLoader.c" + result = TRUE; +#line 27 "ProjectLoader.vala" + return result; +#line 403 "ProjectLoader.c" +} + + +#line 26 "ProjectLoader.vala" +gboolean model_loader_handler_commit_track (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 26 "ProjectLoader.vala" + return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_track (self, attr_names, attr_names_length1, attr_values, attr_values_length1); +#line 411 "ProjectLoader.c" +} + + +#line 30 "ProjectLoader.vala" +static gboolean model_loader_handler_real_commit_clip (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 417 "ProjectLoader.c" + gboolean result = FALSE; +#line 30 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE); +#line 421 "ProjectLoader.c" + result = TRUE; +#line 31 "ProjectLoader.vala" + return result; +#line 425 "ProjectLoader.c" +} + + +#line 30 "ProjectLoader.vala" +gboolean model_loader_handler_commit_clip (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 30 "ProjectLoader.vala" + return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_clip (self, attr_names, attr_names_length1, attr_values, attr_values_length1); +#line 433 "ProjectLoader.c" +} + + +#line 34 "ProjectLoader.vala" +static gboolean model_loader_handler_real_commit_clipfile (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 439 "ProjectLoader.c" + gboolean result = FALSE; +#line 34 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE); +#line 443 "ProjectLoader.c" + result = TRUE; +#line 35 "ProjectLoader.vala" + return result; +#line 447 "ProjectLoader.c" +} + + +#line 34 "ProjectLoader.vala" +gboolean model_loader_handler_commit_clipfile (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 34 "ProjectLoader.vala" + return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_clipfile (self, attr_names, attr_names_length1, attr_values, attr_values_length1); +#line 455 "ProjectLoader.c" +} + + +#line 38 "ProjectLoader.vala" +static gboolean model_loader_handler_real_commit_time_signature_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 461 "ProjectLoader.c" + gboolean result = FALSE; +#line 38 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE); +#line 465 "ProjectLoader.c" + result = TRUE; +#line 39 "ProjectLoader.vala" + return result; +#line 469 "ProjectLoader.c" +} + + +#line 38 "ProjectLoader.vala" +gboolean model_loader_handler_commit_time_signature_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 38 "ProjectLoader.vala" + return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_time_signature_entry (self, attr_names, attr_names_length1, attr_values, attr_values_length1); +#line 477 "ProjectLoader.c" +} + + +#line 42 "ProjectLoader.vala" +static gboolean model_loader_handler_real_commit_tempo_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 483 "ProjectLoader.c" + gboolean result = FALSE; +#line 42 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE); +#line 487 "ProjectLoader.c" + result = TRUE; +#line 43 "ProjectLoader.vala" + return result; +#line 491 "ProjectLoader.c" +} + + +#line 42 "ProjectLoader.vala" +gboolean model_loader_handler_commit_tempo_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 42 "ProjectLoader.vala" + return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_tempo_entry (self, attr_names, attr_names_length1, attr_values, attr_values_length1); +#line 499 "ProjectLoader.c" +} + + +#line 46 "ProjectLoader.vala" +static gboolean model_loader_handler_real_commit_click (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 505 "ProjectLoader.c" + gboolean result = FALSE; +#line 46 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE); +#line 509 "ProjectLoader.c" + result = TRUE; +#line 47 "ProjectLoader.vala" + return result; +#line 513 "ProjectLoader.c" +} + + +#line 46 "ProjectLoader.vala" +gboolean model_loader_handler_commit_click (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 46 "ProjectLoader.vala" + return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_click (self, attr_names, attr_names_length1, attr_values, attr_values_length1); +#line 521 "ProjectLoader.c" +} + + +#line 50 "ProjectLoader.vala" +static gboolean model_loader_handler_real_commit_library_preference (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 527 "ProjectLoader.c" + gboolean result = FALSE; +#line 50 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE); +#line 531 "ProjectLoader.c" + result = TRUE; +#line 51 "ProjectLoader.vala" + return result; +#line 535 "ProjectLoader.c" +} + + +#line 50 "ProjectLoader.vala" +gboolean model_loader_handler_commit_library_preference (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 50 "ProjectLoader.vala" + return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_library_preference (self, attr_names, attr_names_length1, attr_values, attr_values_length1); +#line 543 "ProjectLoader.c" +} + + +#line 54 "ProjectLoader.vala" +static void model_loader_handler_real_leave_library (ModelLoaderHandler* self) { +#line 54 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_LOADER_HANDLER (self)); +#line 551 "ProjectLoader.c" +} + + +#line 54 "ProjectLoader.vala" +void model_loader_handler_leave_library (ModelLoaderHandler* self) { +#line 54 "ProjectLoader.vala" + MODEL_LOADER_HANDLER_GET_CLASS (self)->leave_library (self); +#line 559 "ProjectLoader.c" +} + + +#line 57 "ProjectLoader.vala" +static void model_loader_handler_real_leave_marina (ModelLoaderHandler* self) { +#line 57 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_LOADER_HANDLER (self)); +#line 567 "ProjectLoader.c" +} + + +#line 57 "ProjectLoader.vala" +void model_loader_handler_leave_marina (ModelLoaderHandler* self) { +#line 57 "ProjectLoader.vala" + MODEL_LOADER_HANDLER_GET_CLASS (self)->leave_marina (self); +#line 575 "ProjectLoader.c" +} + + +#line 60 "ProjectLoader.vala" +static void model_loader_handler_real_leave_track (ModelLoaderHandler* self) { +#line 60 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_LOADER_HANDLER (self)); +#line 583 "ProjectLoader.c" +} + + +#line 60 "ProjectLoader.vala" +void model_loader_handler_leave_track (ModelLoaderHandler* self) { +#line 60 "ProjectLoader.vala" + MODEL_LOADER_HANDLER_GET_CLASS (self)->leave_track (self); +#line 591 "ProjectLoader.c" +} + + +#line 63 "ProjectLoader.vala" +static void model_loader_handler_real_leave_clip (ModelLoaderHandler* self) { +#line 63 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_LOADER_HANDLER (self)); +#line 599 "ProjectLoader.c" +} + + +#line 63 "ProjectLoader.vala" +void model_loader_handler_leave_clip (ModelLoaderHandler* self) { +#line 63 "ProjectLoader.vala" + MODEL_LOADER_HANDLER_GET_CLASS (self)->leave_clip (self); +#line 607 "ProjectLoader.c" +} + + +#line 66 "ProjectLoader.vala" +static void model_loader_handler_real_leave_clipfile (ModelLoaderHandler* self) { +#line 66 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_LOADER_HANDLER (self)); +#line 615 "ProjectLoader.c" +} + + +#line 66 "ProjectLoader.vala" +void model_loader_handler_leave_clipfile (ModelLoaderHandler* self) { +#line 66 "ProjectLoader.vala" + MODEL_LOADER_HANDLER_GET_CLASS (self)->leave_clipfile (self); +#line 623 "ProjectLoader.c" +} + + +static void model_loader_handler_class_init (ModelLoaderHandlerClass * klass) { + model_loader_handler_parent_class = g_type_class_peek_parent (klass); + MODEL_LOADER_HANDLER_CLASS (klass)->commit_library = model_loader_handler_real_commit_library; + MODEL_LOADER_HANDLER_CLASS (klass)->commit_marina = model_loader_handler_real_commit_marina; + MODEL_LOADER_HANDLER_CLASS (klass)->commit_track = model_loader_handler_real_commit_track; + MODEL_LOADER_HANDLER_CLASS (klass)->commit_clip = model_loader_handler_real_commit_clip; + MODEL_LOADER_HANDLER_CLASS (klass)->commit_clipfile = model_loader_handler_real_commit_clipfile; + MODEL_LOADER_HANDLER_CLASS (klass)->commit_time_signature_entry = model_loader_handler_real_commit_time_signature_entry; + MODEL_LOADER_HANDLER_CLASS (klass)->commit_tempo_entry = model_loader_handler_real_commit_tempo_entry; + MODEL_LOADER_HANDLER_CLASS (klass)->commit_click = model_loader_handler_real_commit_click; + MODEL_LOADER_HANDLER_CLASS (klass)->commit_library_preference = model_loader_handler_real_commit_library_preference; + MODEL_LOADER_HANDLER_CLASS (klass)->leave_library = model_loader_handler_real_leave_library; + MODEL_LOADER_HANDLER_CLASS (klass)->leave_marina = model_loader_handler_real_leave_marina; + MODEL_LOADER_HANDLER_CLASS (klass)->leave_track = model_loader_handler_real_leave_track; + MODEL_LOADER_HANDLER_CLASS (klass)->leave_clip = model_loader_handler_real_leave_clip; + MODEL_LOADER_HANDLER_CLASS (klass)->leave_clipfile = model_loader_handler_real_leave_clipfile; + g_signal_new ("load_error", MODEL_TYPE_LOADER_HANDLER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING); + g_signal_new ("complete", MODEL_TYPE_LOADER_HANDLER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); +} + + +static void model_loader_handler_instance_init (ModelLoaderHandler * self) { +} + + +GType model_loader_handler_get_type (void) { + static volatile gsize model_loader_handler_type_id__volatile = 0; + if (g_once_init_enter (&model_loader_handler_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelLoaderHandlerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_loader_handler_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelLoaderHandler), 0, (GInstanceInitFunc) model_loader_handler_instance_init, NULL }; + GType model_loader_handler_type_id; + model_loader_handler_type_id = g_type_register_static (G_TYPE_OBJECT, "ModelLoaderHandler", &g_define_type_info, 0); + g_once_init_leave (&model_loader_handler_type_id__volatile, model_loader_handler_type_id); + } + return model_loader_handler_type_id__volatile; +} + + +#line 87 "ProjectLoader.vala" +static void _model_xml_tree_loader_xml_start_element_gmarkup_parser_start_element_func (GMarkupParseContext* context, const char* element_name, char** attribute_names, char** attribute_values, gpointer self) { +#line 666 "ProjectLoader.c" + model_xml_tree_loader_xml_start_element (self, context, element_name, attribute_names, _vala_array_length (attribute_names), attribute_values, _vala_array_length (attribute_values)); +} + + +#line 100 "ProjectLoader.vala" +static void _model_xml_tree_loader_xml_end_element_gmarkup_parser_end_element_func (GMarkupParseContext* context, const char* element_name, gpointer self) { +#line 673 "ProjectLoader.c" + model_xml_tree_loader_xml_end_element (self, context, element_name); +} + + +static glong string_get_length (const char* self) { + glong result; + g_return_val_if_fail (self != NULL, 0L); + result = g_utf8_strlen (self, -1); +#line 1158 "glib-2.0.vapi" + return result; +#line 684 "ProjectLoader.c" +} + + +#line 76 "ProjectLoader.vala" +ModelXmlTreeLoader* model_xml_tree_loader_construct (GType object_type, const char* document) { +#line 690 "ProjectLoader.c" + GError * _inner_error_; + ModelXmlTreeLoader* self; + GMarkupParser _tmp0_ = {0}; + GMarkupParser parser; + GMarkupParseContext* context; +#line 76 "ProjectLoader.vala" + g_return_val_if_fail (document != NULL, NULL); +#line 698 "ProjectLoader.c" + _inner_error_ = NULL; + self = (ModelXmlTreeLoader*) g_type_create_instance (object_type); +#line 77 "ProjectLoader.vala" + parser = (_tmp0_.start_element = _model_xml_tree_loader_xml_start_element_gmarkup_parser_start_element_func, _tmp0_.end_element = _model_xml_tree_loader_xml_end_element_gmarkup_parser_end_element_func, _tmp0_.text = NULL, _tmp0_.passthrough = NULL, _tmp0_); +#line 79 "ProjectLoader.vala" + context = g_markup_parse_context_new (&parser, (GMarkupParseFlags) 0, self, NULL); +#line 705 "ProjectLoader.c" + { +#line 81 "ProjectLoader.vala" + g_markup_parse_context_parse (context, document, (gssize) string_get_length (document), &_inner_error_); +#line 709 "ProjectLoader.c" + if (_inner_error_ != NULL) { + if (_inner_error_->domain == G_MARKUP_ERROR) { + goto __catch12_g_markup_error; + } + _g_markup_parse_context_free0 (context); + g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return NULL; + } + } + goto __finally12; + __catch12_g_markup_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { + _g_error_free0 (e); + } + } + __finally12: + if (_inner_error_ != NULL) { + _g_markup_parse_context_free0 (context); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return NULL; + } + _g_markup_parse_context_free0 (context); + return self; +} + + +#line 76 "ProjectLoader.vala" +ModelXmlTreeLoader* model_xml_tree_loader_new (const char* document) { +#line 76 "ProjectLoader.vala" + return model_xml_tree_loader_construct (MODEL_TYPE_XML_TREE_LOADER, document); +#line 746 "ProjectLoader.c" +} + + +static gpointer _model_xml_element_ref0 (gpointer self) { + return self ? model_xml_element_ref (self) : NULL; +} + + +#line 87 "ProjectLoader.vala" +static void model_xml_tree_loader_xml_start_element (ModelXmlTreeLoader* self, GMarkupParseContext* c, const char* name, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 757 "ProjectLoader.c" + ModelXmlElement* new_element; + ModelXmlElement* _tmp1_; +#line 87 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_TREE_LOADER (self)); +#line 87 "ProjectLoader.vala" + g_return_if_fail (c != NULL); +#line 87 "ProjectLoader.vala" + g_return_if_fail (name != NULL); +#line 89 "ProjectLoader.vala" + new_element = model_xml_element_new (name, attr_names, attr_names_length1, attr_values, attr_values_length1, self->priv->current_element); +#line 90 "ProjectLoader.vala" + if (self->root == NULL) { +#line 770 "ProjectLoader.c" + ModelXmlElement* _tmp0_; +#line 91 "ProjectLoader.vala" + self->root = (_tmp0_ = _model_xml_element_ref0 (new_element), _model_xml_element_unref0 (self->root), _tmp0_); +#line 774 "ProjectLoader.c" + } else { +#line 93 "ProjectLoader.vala" + g_assert (self->priv->current_element != NULL); +#line 94 "ProjectLoader.vala" + model_xml_element_add_child (self->priv->current_element, new_element); +#line 780 "ProjectLoader.c" + } +#line 97 "ProjectLoader.vala" + self->priv->current_element = (_tmp1_ = _model_xml_element_ref0 (new_element), _model_xml_element_unref0 (self->priv->current_element), _tmp1_); +#line 784 "ProjectLoader.c" + _model_xml_element_unref0 (new_element); +} + + +#line 100 "ProjectLoader.vala" +static void model_xml_tree_loader_xml_end_element (ModelXmlTreeLoader* self, GMarkupParseContext* c, const char* name) { +#line 791 "ProjectLoader.c" + ModelXmlElement* _tmp0_; +#line 100 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_TREE_LOADER (self)); +#line 100 "ProjectLoader.vala" + g_return_if_fail (c != NULL); +#line 100 "ProjectLoader.vala" + g_return_if_fail (name != NULL); +#line 101 "ProjectLoader.vala" + g_assert (self->priv->current_element != NULL); +#line 102 "ProjectLoader.vala" + self->priv->current_element = (_tmp0_ = _model_xml_element_ref0 (model_xml_element_get_parent (self->priv->current_element)), _model_xml_element_unref0 (self->priv->current_element), _tmp0_); +#line 803 "ProjectLoader.c" +} + + +static void model_value_xml_tree_loader_init (GValue* value) { + value->data[0].v_pointer = NULL; +} + + +static void model_value_xml_tree_loader_free_value (GValue* value) { + if (value->data[0].v_pointer) { + model_xml_tree_loader_unref (value->data[0].v_pointer); + } +} + + +static void model_value_xml_tree_loader_copy_value (const GValue* src_value, GValue* dest_value) { + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = model_xml_tree_loader_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + + +static gpointer model_value_xml_tree_loader_peek_pointer (const GValue* value) { + return value->data[0].v_pointer; +} + + +static gchar* model_value_xml_tree_loader_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + if (collect_values[0].v_pointer) { + ModelXmlTreeLoader* object; + object = collect_values[0].v_pointer; + if (object->parent_instance.g_class == NULL) { + return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) { + return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } + value->data[0].v_pointer = model_xml_tree_loader_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + + +static gchar* model_value_xml_tree_loader_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + ModelXmlTreeLoader** object_p; + object_p = collect_values[0].v_pointer; + if (!object_p) { + return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); + } + if (!value->data[0].v_pointer) { + *object_p = NULL; + } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) { + *object_p = value->data[0].v_pointer; + } else { + *object_p = model_xml_tree_loader_ref (value->data[0].v_pointer); + } + return NULL; +} + + +GParamSpec* model_param_spec_xml_tree_loader (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) { + ModelParamSpecXmlTreeLoader* spec; + g_return_val_if_fail (g_type_is_a (object_type, MODEL_TYPE_XML_TREE_LOADER), NULL); + spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags); + G_PARAM_SPEC (spec)->value_type = object_type; + return G_PARAM_SPEC (spec); +} + + +gpointer model_value_get_xml_tree_loader (const GValue* value) { + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_XML_TREE_LOADER), NULL); + return value->data[0].v_pointer; +} + + +void model_value_set_xml_tree_loader (GValue* value, gpointer v_object) { + ModelXmlTreeLoader* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_XML_TREE_LOADER)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_XML_TREE_LOADER)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + model_xml_tree_loader_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + model_xml_tree_loader_unref (old); + } +} + + +void model_value_take_xml_tree_loader (GValue* value, gpointer v_object) { + ModelXmlTreeLoader* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_XML_TREE_LOADER)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_XML_TREE_LOADER)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + model_xml_tree_loader_unref (old); + } +} + + +static void model_xml_tree_loader_class_init (ModelXmlTreeLoaderClass * klass) { + model_xml_tree_loader_parent_class = g_type_class_peek_parent (klass); + MODEL_XML_TREE_LOADER_CLASS (klass)->finalize = model_xml_tree_loader_finalize; + g_type_class_add_private (klass, sizeof (ModelXmlTreeLoaderPrivate)); +} + + +static void model_xml_tree_loader_instance_init (ModelXmlTreeLoader * self) { + self->priv = MODEL_XML_TREE_LOADER_GET_PRIVATE (self); + self->priv->current_element = NULL; + self->root = NULL; + self->ref_count = 1; +} + + +static void model_xml_tree_loader_finalize (ModelXmlTreeLoader* obj) { + ModelXmlTreeLoader * self; + self = MODEL_XML_TREE_LOADER (obj); + _model_xml_element_unref0 (self->priv->current_element); + _model_xml_element_unref0 (self->root); +} + + +GType model_xml_tree_loader_get_type (void) { + static volatile gsize model_xml_tree_loader_type_id__volatile = 0; + if (g_once_init_enter (&model_xml_tree_loader_type_id__volatile)) { + static const GTypeValueTable g_define_type_value_table = { model_value_xml_tree_loader_init, model_value_xml_tree_loader_free_value, model_value_xml_tree_loader_copy_value, model_value_xml_tree_loader_peek_pointer, "p", model_value_xml_tree_loader_collect_value, "p", model_value_xml_tree_loader_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (ModelXmlTreeLoaderClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_xml_tree_loader_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelXmlTreeLoader), 0, (GInstanceInitFunc) model_xml_tree_loader_instance_init, &g_define_type_value_table }; + static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) }; + GType model_xml_tree_loader_type_id; + model_xml_tree_loader_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ModelXmlTreeLoader", &g_define_type_info, &g_define_type_fundamental_info, 0); + g_once_init_leave (&model_xml_tree_loader_type_id__volatile, model_xml_tree_loader_type_id); + } + return model_xml_tree_loader_type_id__volatile; +} + + +gpointer model_xml_tree_loader_ref (gpointer instance) { + ModelXmlTreeLoader* self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + + +void model_xml_tree_loader_unref (gpointer instance) { + ModelXmlTreeLoader* self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + MODEL_XML_TREE_LOADER_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 114 "ProjectLoader.vala" +ModelProjectBuilder* model_project_builder_construct (GType object_type, ModelLoaderHandler* handler) { +#line 979 "ProjectLoader.c" + ModelProjectBuilder * self; + ModelLoaderHandler* _tmp0_; +#line 114 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (handler), NULL); +#line 114 "ProjectLoader.vala" + self = (ModelProjectBuilder*) g_object_new (object_type, NULL); +#line 115 "ProjectLoader.vala" + self->priv->handler = (_tmp0_ = _g_object_ref0 (handler), _g_object_unref0 (self->priv->handler), _tmp0_); +#line 988 "ProjectLoader.c" + return self; +} + + +#line 114 "ProjectLoader.vala" +ModelProjectBuilder* model_project_builder_new (ModelLoaderHandler* handler) { +#line 114 "ProjectLoader.vala" + return model_project_builder_construct (MODEL_TYPE_PROJECT_BUILDER, handler); +#line 997 "ProjectLoader.c" +} + + +#line 118 "ProjectLoader.vala" +static gboolean model_project_builder_check_name (ModelProjectBuilder* self, const char* expected_name, ModelXmlElement* node) { +#line 1003 "ProjectLoader.c" + gboolean result = FALSE; + char* _tmp0_; +#line 118 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_PROJECT_BUILDER (self), FALSE); +#line 118 "ProjectLoader.vala" + g_return_val_if_fail (expected_name != NULL, FALSE); +#line 118 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_XML_ELEMENT (node), FALSE); +#line 119 "ProjectLoader.vala" + if (_vala_strcmp0 (model_xml_element_get_name (node), expected_name) == 0) { +#line 1014 "ProjectLoader.c" + result = TRUE; +#line 120 "ProjectLoader.vala" + return result; +#line 1018 "ProjectLoader.c" + } +#line 123 "ProjectLoader.vala" + g_signal_emit_by_name (self, "error-occurred", _tmp0_ = g_strdup_printf ("expected %s, got %s", expected_name, model_xml_element_get_name (node))); +#line 1022 "ProjectLoader.c" + _g_free0 (_tmp0_); + result = FALSE; +#line 124 "ProjectLoader.vala" + return result; +#line 1027 "ProjectLoader.c" +} + + +#line 127 "ProjectLoader.vala" +static void model_project_builder_handle_clip (ModelProjectBuilder* self, ModelXmlElement* clip) { +#line 127 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self)); +#line 127 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_ELEMENT (clip)); +#line 128 "ProjectLoader.vala" + if (model_project_builder_check_name (self, "clip", clip)) { +#line 129 "ProjectLoader.vala" + if (model_loader_handler_commit_clip (self->priv->handler, clip->attribute_names, clip->attribute_names_length1, clip->attribute_values, clip->attribute_values_length1)) { +#line 130 "ProjectLoader.vala" + if (gee_collection_get_size (GEE_COLLECTION (model_xml_element_get_children (clip))) != 0) { +#line 131 "ProjectLoader.vala" + g_signal_emit_by_name (self, "error-occurred", "clip cannot have children"); +#line 1045 "ProjectLoader.c" + } +#line 133 "ProjectLoader.vala" + model_loader_handler_leave_clip (self->priv->handler); +#line 1049 "ProjectLoader.c" + } + } +} + + +#line 138 "ProjectLoader.vala" +static void model_project_builder_handle_track (ModelProjectBuilder* self, ModelXmlElement* track) { +#line 138 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self)); +#line 138 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_ELEMENT (track)); +#line 139 "ProjectLoader.vala" + if (model_project_builder_check_name (self, "track", track)) { +#line 140 "ProjectLoader.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_LOADING, LOGGING_LEVEL_VERBOSE, "loading track"); +#line 141 "ProjectLoader.vala" + if (model_loader_handler_commit_track (self->priv->handler, track->attribute_names, track->attribute_names_length1, track->attribute_values, track->attribute_values_length1)) { +#line 1067 "ProjectLoader.c" + { + GeeIterator* _child_it; + _child_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (model_xml_element_get_children (track))); +#line 142 "ProjectLoader.vala" + while (TRUE) { +#line 1073 "ProjectLoader.c" + ModelXmlElement* child; +#line 142 "ProjectLoader.vala" + if (!gee_iterator_next (_child_it)) { +#line 142 "ProjectLoader.vala" + break; +#line 1079 "ProjectLoader.c" + } +#line 142 "ProjectLoader.vala" + child = (ModelXmlElement*) gee_iterator_get (_child_it); +#line 143 "ProjectLoader.vala" + model_project_builder_handle_clip (self, child); +#line 1085 "ProjectLoader.c" + _model_xml_element_unref0 (child); + } + _g_object_unref0 (_child_it); + } +#line 145 "ProjectLoader.vala" + model_loader_handler_leave_track (self->priv->handler); +#line 1092 "ProjectLoader.c" + } + } +} + + +#line 150 "ProjectLoader.vala" +static void model_project_builder_handle_preference (ModelProjectBuilder* self, ModelXmlElement* preference) { +#line 150 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self)); +#line 150 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_ELEMENT (preference)); +#line 151 "ProjectLoader.vala" + if (_vala_strcmp0 ("click", model_xml_element_get_name (preference)) == 0) { +#line 152 "ProjectLoader.vala" + model_loader_handler_commit_click (self->priv->handler, preference->attribute_names, preference->attribute_names_length1, preference->attribute_values, preference->attribute_values_length1); +#line 1108 "ProjectLoader.c" + } else { +#line 153 "ProjectLoader.vala" + if (_vala_strcmp0 ("library", model_xml_element_get_name (preference)) == 0) { +#line 154 "ProjectLoader.vala" + model_loader_handler_commit_library_preference (self->priv->handler, preference->attribute_names, preference->attribute_names_length1, preference->attribute_values, preference->attribute_values_length1); +#line 1114 "ProjectLoader.c" + } else { + char* _tmp0_; +#line 157 "ProjectLoader.vala" + g_signal_emit_by_name (self, "error-occurred", _tmp0_ = g_strdup_printf ("Unknown preference: %s", model_xml_element_get_name (preference))); +#line 1119 "ProjectLoader.c" + _g_free0 (_tmp0_); + } + } +} + + +#line 161 "ProjectLoader.vala" +static void model_project_builder_handle_time_signature (ModelProjectBuilder* self, ModelXmlElement* time_signature) { +#line 161 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self)); +#line 161 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_ELEMENT (time_signature)); +#line 1132 "ProjectLoader.c" + { + GeeIterator* _child_it; + _child_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (model_xml_element_get_children (time_signature))); +#line 162 "ProjectLoader.vala" + while (TRUE) { +#line 1138 "ProjectLoader.c" + ModelXmlElement* child; +#line 162 "ProjectLoader.vala" + if (!gee_iterator_next (_child_it)) { +#line 162 "ProjectLoader.vala" + break; +#line 1144 "ProjectLoader.c" + } +#line 162 "ProjectLoader.vala" + child = (ModelXmlElement*) gee_iterator_get (_child_it); +#line 163 "ProjectLoader.vala" + if (model_project_builder_check_name (self, "entry", child)) { +#line 164 "ProjectLoader.vala" + if (!model_loader_handler_commit_time_signature_entry (self->priv->handler, child->attribute_names, child->attribute_names_length1, child->attribute_values, child->attribute_values_length1)) { +#line 166 "ProjectLoader.vala" + g_signal_emit_by_name (self, "error-occurred", "Improper time signature node"); +#line 1154 "ProjectLoader.c" + } + } + _model_xml_element_unref0 (child); + } + _g_object_unref0 (_child_it); + } +} + + +#line 172 "ProjectLoader.vala" +static void model_project_builder_handle_tempo (ModelProjectBuilder* self, ModelXmlElement* tempo) { +#line 172 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self)); +#line 172 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_ELEMENT (tempo)); +#line 1170 "ProjectLoader.c" + { + GeeIterator* _child_it; + _child_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (model_xml_element_get_children (tempo))); +#line 173 "ProjectLoader.vala" + while (TRUE) { +#line 1176 "ProjectLoader.c" + ModelXmlElement* child; +#line 173 "ProjectLoader.vala" + if (!gee_iterator_next (_child_it)) { +#line 173 "ProjectLoader.vala" + break; +#line 1182 "ProjectLoader.c" + } +#line 173 "ProjectLoader.vala" + child = (ModelXmlElement*) gee_iterator_get (_child_it); +#line 174 "ProjectLoader.vala" + if (model_project_builder_check_name (self, "entry", child)) { +#line 175 "ProjectLoader.vala" + if (!model_loader_handler_commit_tempo_entry (self->priv->handler, child->attribute_names, child->attribute_names_length1, child->attribute_values, child->attribute_values_length1)) { +#line 176 "ProjectLoader.vala" + g_signal_emit_by_name (self, "error-occurred", "Improper tempo node"); +#line 1192 "ProjectLoader.c" + } + } + _model_xml_element_unref0 (child); + } + _g_object_unref0 (_child_it); + } +} + + +#line 182 "ProjectLoader.vala" +static void model_project_builder_handle_map (ModelProjectBuilder* self, ModelXmlElement* map) { +#line 1204 "ProjectLoader.c" + GQuark _tmp1_; + const char* _tmp0_; + static GQuark _tmp1__label0 = 0; + static GQuark _tmp1__label1 = 0; +#line 182 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self)); +#line 182 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_ELEMENT (map)); +#line 1213 "ProjectLoader.c" + _tmp0_ = model_xml_element_get_name (map); + _tmp1_ = (NULL == _tmp0_) ? 0 : g_quark_from_string (_tmp0_); + if (_tmp1_ == ((0 != _tmp1__label0) ? _tmp1__label0 : (_tmp1__label0 = g_quark_from_static_string ("tempo")))) + switch (0) { + default: + { +#line 185 "ProjectLoader.vala" + model_project_builder_handle_tempo (self, map); +#line 186 "ProjectLoader.vala" + break; +#line 1224 "ProjectLoader.c" + } + } else if (_tmp1_ == ((0 != _tmp1__label1) ? _tmp1__label1 : (_tmp1__label1 = g_quark_from_static_string ("time_signature")))) + switch (0) { + default: + { +#line 188 "ProjectLoader.vala" + model_project_builder_handle_time_signature (self, map); +#line 189 "ProjectLoader.vala" + break; +#line 1234 "ProjectLoader.c" + } + } else + switch (0) { + default: + { +#line 191 "ProjectLoader.vala" + g_signal_emit_by_name (self, "error-occurred", "improper map node"); +#line 192 "ProjectLoader.vala" + break; +#line 1244 "ProjectLoader.c" + } + } +} + + +#line 196 "ProjectLoader.vala" +static void model_project_builder_handle_library (ModelProjectBuilder* self, ModelXmlElement* library) { +#line 196 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self)); +#line 196 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_ELEMENT (library)); +#line 197 "ProjectLoader.vala" + if (model_loader_handler_commit_library (self->priv->handler, library->attribute_names, library->attribute_names_length1, library->attribute_values, library->attribute_values_length1)) { +#line 1258 "ProjectLoader.c" + { + GeeIterator* _child_it; + _child_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (model_xml_element_get_children (library))); +#line 198 "ProjectLoader.vala" + while (TRUE) { +#line 1264 "ProjectLoader.c" + ModelXmlElement* child; +#line 198 "ProjectLoader.vala" + if (!gee_iterator_next (_child_it)) { +#line 198 "ProjectLoader.vala" + break; +#line 1270 "ProjectLoader.c" + } +#line 198 "ProjectLoader.vala" + child = (ModelXmlElement*) gee_iterator_get (_child_it); +#line 199 "ProjectLoader.vala" + if (!model_loader_handler_commit_clipfile (self->priv->handler, child->attribute_names, child->attribute_names_length1, child->attribute_values, child->attribute_values_length1)) { +#line 200 "ProjectLoader.vala" + g_signal_emit_by_name (self, "error-occurred", "Improper library node"); +#line 1278 "ProjectLoader.c" + } + _model_xml_element_unref0 (child); + } + _g_object_unref0 (_child_it); + } +#line 202 "ProjectLoader.vala" + model_loader_handler_leave_library (self->priv->handler); +#line 1286 "ProjectLoader.c" + } +} + + +#line 206 "ProjectLoader.vala" +static void model_project_builder_handle_tracks (ModelProjectBuilder* self, ModelXmlElement* tracks) { +#line 206 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self)); +#line 206 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_ELEMENT (tracks)); +#line 1297 "ProjectLoader.c" + { + GeeIterator* _child_it; + _child_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (model_xml_element_get_children (tracks))); +#line 207 "ProjectLoader.vala" + while (TRUE) { +#line 1303 "ProjectLoader.c" + ModelXmlElement* child; +#line 207 "ProjectLoader.vala" + if (!gee_iterator_next (_child_it)) { +#line 207 "ProjectLoader.vala" + break; +#line 1309 "ProjectLoader.c" + } +#line 207 "ProjectLoader.vala" + child = (ModelXmlElement*) gee_iterator_get (_child_it); +#line 208 "ProjectLoader.vala" + model_project_builder_handle_track (self, child); +#line 1315 "ProjectLoader.c" + _model_xml_element_unref0 (child); + } + _g_object_unref0 (_child_it); + } +} + + +#line 212 "ProjectLoader.vala" +static void model_project_builder_handle_preferences (ModelProjectBuilder* self, ModelXmlElement* preferences) { +#line 212 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self)); +#line 212 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_ELEMENT (preferences)); +#line 1329 "ProjectLoader.c" + { + GeeIterator* _child_it; + _child_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (model_xml_element_get_children (preferences))); +#line 213 "ProjectLoader.vala" + while (TRUE) { +#line 1335 "ProjectLoader.c" + ModelXmlElement* child; +#line 213 "ProjectLoader.vala" + if (!gee_iterator_next (_child_it)) { +#line 213 "ProjectLoader.vala" + break; +#line 1341 "ProjectLoader.c" + } +#line 213 "ProjectLoader.vala" + child = (ModelXmlElement*) gee_iterator_get (_child_it); +#line 214 "ProjectLoader.vala" + model_project_builder_handle_preference (self, child); +#line 1347 "ProjectLoader.c" + _model_xml_element_unref0 (child); + } + _g_object_unref0 (_child_it); + } +} + + +#line 217 "ProjectLoader.vala" +static void model_project_builder_handle_maps (ModelProjectBuilder* self, ModelXmlElement* maps) { +#line 217 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self)); +#line 217 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_ELEMENT (maps)); +#line 1361 "ProjectLoader.c" + { + GeeIterator* _child_it; + _child_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (model_xml_element_get_children (maps))); +#line 218 "ProjectLoader.vala" + while (TRUE) { +#line 1367 "ProjectLoader.c" + ModelXmlElement* child; +#line 218 "ProjectLoader.vala" + if (!gee_iterator_next (_child_it)) { +#line 218 "ProjectLoader.vala" + break; +#line 1373 "ProjectLoader.c" + } +#line 218 "ProjectLoader.vala" + child = (ModelXmlElement*) gee_iterator_get (_child_it); +#line 219 "ProjectLoader.vala" + model_project_builder_handle_map (self, child); +#line 1379 "ProjectLoader.c" + _model_xml_element_unref0 (child); + } + _g_object_unref0 (_child_it); + } +} + + +#line 222 "ProjectLoader.vala" +gboolean model_project_builder_check_project (ModelProjectBuilder* self, ModelXmlElement* root) { +#line 1389 "ProjectLoader.c" + gboolean result = FALSE; + gboolean _tmp0_ = FALSE; +#line 222 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_PROJECT_BUILDER (self), FALSE); +#line 222 "ProjectLoader.vala" + g_return_val_if_fail ((root == NULL) || MODEL_IS_XML_ELEMENT (root), FALSE); +#line 223 "ProjectLoader.vala" + if (root == NULL) { +#line 224 "ProjectLoader.vala" + g_signal_emit_by_name (self, "error-occurred", "Invalid XML file!"); +#line 1400 "ProjectLoader.c" + result = FALSE; +#line 225 "ProjectLoader.vala" + return result; +#line 1404 "ProjectLoader.c" + } +#line 228 "ProjectLoader.vala" + if (model_project_builder_check_name (self, "marina", root)) { +#line 229 "ProjectLoader.vala" + _tmp0_ = model_loader_handler_commit_marina (self->priv->handler, root->attribute_names, root->attribute_names_length1, root->attribute_values, root->attribute_values_length1); +#line 1410 "ProjectLoader.c" + } else { +#line 228 "ProjectLoader.vala" + _tmp0_ = FALSE; +#line 1414 "ProjectLoader.c" + } +#line 228 "ProjectLoader.vala" + if (_tmp0_) { +#line 1418 "ProjectLoader.c" + gboolean _tmp1_ = FALSE; + gboolean _tmp2_ = FALSE; + gboolean _tmp3_ = FALSE; + ModelXmlElement* _tmp4_; + gboolean _tmp5_; + gboolean _tmp8_ = FALSE; +#line 230 "ProjectLoader.vala" + if (gee_collection_get_size (GEE_COLLECTION (model_xml_element_get_children (root))) != 3) { +#line 230 "ProjectLoader.vala" + _tmp1_ = gee_collection_get_size (GEE_COLLECTION (model_xml_element_get_children (root))) != 4; +#line 1429 "ProjectLoader.c" + } else { +#line 230 "ProjectLoader.vala" + _tmp1_ = FALSE; +#line 1433 "ProjectLoader.c" + } +#line 230 "ProjectLoader.vala" + if (_tmp1_) { +#line 231 "ProjectLoader.vala" + g_signal_emit_by_name (self, "error-occurred", "Improper number of children!"); +#line 1439 "ProjectLoader.c" + result = FALSE; +#line 232 "ProjectLoader.vala" + return result; +#line 1443 "ProjectLoader.c" + } +#line 235 "ProjectLoader.vala" + if ((_tmp5_ = !model_project_builder_check_name (self, "library", _tmp4_ = (ModelXmlElement*) gee_abstract_list_get (GEE_ABSTRACT_LIST (model_xml_element_get_children (root)), 0)), _model_xml_element_unref0 (_tmp4_), _tmp5_)) { +#line 235 "ProjectLoader.vala" + _tmp3_ = TRUE; +#line 1449 "ProjectLoader.c" + } else { + ModelXmlElement* _tmp6_; +#line 236 "ProjectLoader.vala" + _tmp3_ = !model_project_builder_check_name (self, "tracks", _tmp6_ = (ModelXmlElement*) gee_abstract_list_get (GEE_ABSTRACT_LIST (model_xml_element_get_children (root)), 1)); +#line 1454 "ProjectLoader.c" + _model_xml_element_unref0 (_tmp6_); + } +#line 235 "ProjectLoader.vala" + if (_tmp3_) { +#line 235 "ProjectLoader.vala" + _tmp2_ = TRUE; +#line 1461 "ProjectLoader.c" + } else { + ModelXmlElement* _tmp7_; +#line 237 "ProjectLoader.vala" + _tmp2_ = !model_project_builder_check_name (self, "preferences", _tmp7_ = (ModelXmlElement*) gee_abstract_list_get (GEE_ABSTRACT_LIST (model_xml_element_get_children (root)), 2)); +#line 1466 "ProjectLoader.c" + _model_xml_element_unref0 (_tmp7_); + } +#line 235 "ProjectLoader.vala" + if (_tmp2_) { +#line 1471 "ProjectLoader.c" + result = FALSE; +#line 238 "ProjectLoader.vala" + return result; +#line 1475 "ProjectLoader.c" + } +#line 240 "ProjectLoader.vala" + if (gee_collection_get_size (GEE_COLLECTION (model_xml_element_get_children (root))) == 4) { +#line 1479 "ProjectLoader.c" + ModelXmlElement* _tmp9_; +#line 240 "ProjectLoader.vala" + _tmp8_ = !model_project_builder_check_name (self, "maps", _tmp9_ = (ModelXmlElement*) gee_abstract_list_get (GEE_ABSTRACT_LIST (model_xml_element_get_children (root)), 3)); +#line 1483 "ProjectLoader.c" + _model_xml_element_unref0 (_tmp9_); + } else { +#line 240 "ProjectLoader.vala" + _tmp8_ = FALSE; +#line 1488 "ProjectLoader.c" + } +#line 240 "ProjectLoader.vala" + if (_tmp8_) { +#line 1492 "ProjectLoader.c" + result = FALSE; +#line 241 "ProjectLoader.vala" + return result; +#line 1496 "ProjectLoader.c" + } + } else { + result = FALSE; +#line 244 "ProjectLoader.vala" + return result; +#line 1502 "ProjectLoader.c" + } + result = TRUE; +#line 245 "ProjectLoader.vala" + return result; +#line 1507 "ProjectLoader.c" +} + + +#line 248 "ProjectLoader.vala" +void model_project_builder_build_project (ModelProjectBuilder* self, ModelXmlElement* root) { +#line 1513 "ProjectLoader.c" + ModelXmlElement* _tmp0_; + ModelXmlElement* _tmp1_; + ModelXmlElement* _tmp2_; +#line 248 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self)); +#line 248 "ProjectLoader.vala" + g_return_if_fail ((root == NULL) || MODEL_IS_XML_ELEMENT (root)); +#line 249 "ProjectLoader.vala" + model_project_builder_handle_library (self, _tmp0_ = (ModelXmlElement*) gee_abstract_list_get (GEE_ABSTRACT_LIST (model_xml_element_get_children (root)), 0)); +#line 1523 "ProjectLoader.c" + _model_xml_element_unref0 (_tmp0_); +#line 250 "ProjectLoader.vala" + model_project_builder_handle_tracks (self, _tmp1_ = (ModelXmlElement*) gee_abstract_list_get (GEE_ABSTRACT_LIST (model_xml_element_get_children (root)), 1)); +#line 1527 "ProjectLoader.c" + _model_xml_element_unref0 (_tmp1_); +#line 251 "ProjectLoader.vala" + model_project_builder_handle_preferences (self, _tmp2_ = (ModelXmlElement*) gee_abstract_list_get (GEE_ABSTRACT_LIST (model_xml_element_get_children (root)), 2)); +#line 1531 "ProjectLoader.c" + _model_xml_element_unref0 (_tmp2_); +#line 252 "ProjectLoader.vala" + if (gee_collection_get_size (GEE_COLLECTION (model_xml_element_get_children (root))) == 4) { +#line 1535 "ProjectLoader.c" + ModelXmlElement* _tmp3_; +#line 253 "ProjectLoader.vala" + model_project_builder_handle_maps (self, _tmp3_ = (ModelXmlElement*) gee_abstract_list_get (GEE_ABSTRACT_LIST (model_xml_element_get_children (root)), 3)); +#line 1539 "ProjectLoader.c" + _model_xml_element_unref0 (_tmp3_); + } +#line 256 "ProjectLoader.vala" + model_loader_handler_leave_marina (self->priv->handler); +#line 1544 "ProjectLoader.c" +} + + +static void model_project_builder_class_init (ModelProjectBuilderClass * klass) { + model_project_builder_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ModelProjectBuilderPrivate)); + G_OBJECT_CLASS (klass)->finalize = model_project_builder_finalize; + g_signal_new ("error_occurred", MODEL_TYPE_PROJECT_BUILDER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING); +} + + +static void model_project_builder_instance_init (ModelProjectBuilder * self) { + self->priv = MODEL_PROJECT_BUILDER_GET_PRIVATE (self); +} + + +static void model_project_builder_finalize (GObject* obj) { + ModelProjectBuilder * self; + self = MODEL_PROJECT_BUILDER (obj); + _g_object_unref0 (self->priv->handler); + G_OBJECT_CLASS (model_project_builder_parent_class)->finalize (obj); +} + + +GType model_project_builder_get_type (void) { + static volatile gsize model_project_builder_type_id__volatile = 0; + if (g_once_init_enter (&model_project_builder_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelProjectBuilderClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_project_builder_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelProjectBuilder), 0, (GInstanceInitFunc) model_project_builder_instance_init, NULL }; + GType model_project_builder_type_id; + model_project_builder_type_id = g_type_register_static (G_TYPE_OBJECT, "ModelProjectBuilder", &g_define_type_info, 0); + g_once_init_leave (&model_project_builder_type_id__volatile, model_project_builder_type_id); + } + return model_project_builder_type_id__volatile; +} + + +#line 272 "ProjectLoader.vala" +ModelXmlElement* model_xml_element_construct (GType object_type, const char* name, char** attribute_names, int attribute_names_length1, char** attribute_values, int attribute_values_length1, ModelXmlElement* parent) { +#line 1583 "ProjectLoader.c" + ModelXmlElement* self; + char** _tmp1_; + gint _tmp0_; + char** _tmp3_; + gint _tmp2_; + GeeArrayList* _tmp4_; +#line 272 "ProjectLoader.vala" + g_return_val_if_fail (name != NULL, NULL); +#line 272 "ProjectLoader.vala" + g_return_val_if_fail ((parent == NULL) || MODEL_IS_XML_ELEMENT (parent), NULL); +#line 1594 "ProjectLoader.c" + self = (ModelXmlElement*) g_type_create_instance (object_type); +#line 274 "ProjectLoader.vala" + model_xml_element_set_name (self, name); +#line 276 "ProjectLoader.vala" + self->attribute_names = (_tmp1_ = copy_array (attribute_names, attribute_names_length1, &_tmp0_), self->attribute_names = (_vala_array_free (self->attribute_names, self->attribute_names_length1, (GDestroyNotify) g_free), NULL), self->attribute_names_length1 = _tmp0_, _tmp1_); +#line 277 "ProjectLoader.vala" + self->attribute_values = (_tmp3_ = copy_array (attribute_values, attribute_values_length1, &_tmp2_), self->attribute_values = (_vala_array_free (self->attribute_values, self->attribute_values_length1, (GDestroyNotify) g_free), NULL), self->attribute_values_length1 = _tmp2_, _tmp3_); +#line 278 "ProjectLoader.vala" + model_xml_element_set_parent (self, parent); +#line 279 "ProjectLoader.vala" + self->priv->_children = (_tmp4_ = gee_array_list_new (MODEL_TYPE_XML_ELEMENT, (GBoxedCopyFunc) model_xml_element_ref, model_xml_element_unref, NULL), _g_object_unref0 (self->priv->_children), _tmp4_); +#line 1606 "ProjectLoader.c" + return self; +} + + +#line 272 "ProjectLoader.vala" +ModelXmlElement* model_xml_element_new (const char* name, char** attribute_names, int attribute_names_length1, char** attribute_values, int attribute_values_length1, ModelXmlElement* parent) { +#line 272 "ProjectLoader.vala" + return model_xml_element_construct (MODEL_TYPE_XML_ELEMENT, name, attribute_names, attribute_names_length1, attribute_values, attribute_values_length1, parent); +#line 1615 "ProjectLoader.c" +} + + +#line 282 "ProjectLoader.vala" +void model_xml_element_add_child (ModelXmlElement* self, ModelXmlElement* child_element) { +#line 282 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_ELEMENT (self)); +#line 282 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_ELEMENT (child_element)); +#line 283 "ProjectLoader.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->_children), child_element); +#line 1627 "ProjectLoader.c" +} + + +const char* model_xml_element_get_name (ModelXmlElement* self) { + const char* result; + g_return_val_if_fail (MODEL_IS_XML_ELEMENT (self), NULL); + result = self->priv->_name; +#line 261 "ProjectLoader.vala" + return result; +#line 1637 "ProjectLoader.c" +} + + +static void model_xml_element_set_name (ModelXmlElement* self, const char* value) { + char* _tmp0_; + g_return_if_fail (MODEL_IS_XML_ELEMENT (self)); + self->priv->_name = (_tmp0_ = g_strdup (value), _g_free0 (self->priv->_name), _tmp0_); +} + + +GeeArrayList* model_xml_element_get_children (ModelXmlElement* self) { + GeeArrayList* result; + g_return_val_if_fail (MODEL_IS_XML_ELEMENT (self), NULL); + result = self->priv->_children; +#line 267 "ProjectLoader.vala" + return result; +#line 1654 "ProjectLoader.c" +} + + +ModelXmlElement* model_xml_element_get_parent (ModelXmlElement* self) { + ModelXmlElement* result; + g_return_val_if_fail (MODEL_IS_XML_ELEMENT (self), NULL); + result = self->priv->_parent; +#line 269 "ProjectLoader.vala" + return result; +#line 1664 "ProjectLoader.c" +} + + +static void model_xml_element_set_parent (ModelXmlElement* self, ModelXmlElement* value) { + g_return_if_fail (MODEL_IS_XML_ELEMENT (self)); + self->priv->_parent = value; +} + + +static void model_value_xml_element_init (GValue* value) { + value->data[0].v_pointer = NULL; +} + + +static void model_value_xml_element_free_value (GValue* value) { + if (value->data[0].v_pointer) { + model_xml_element_unref (value->data[0].v_pointer); + } +} + + +static void model_value_xml_element_copy_value (const GValue* src_value, GValue* dest_value) { + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = model_xml_element_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + + +static gpointer model_value_xml_element_peek_pointer (const GValue* value) { + return value->data[0].v_pointer; +} + + +static gchar* model_value_xml_element_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + if (collect_values[0].v_pointer) { + ModelXmlElement* object; + object = collect_values[0].v_pointer; + if (object->parent_instance.g_class == NULL) { + return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) { + return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } + value->data[0].v_pointer = model_xml_element_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + + +static gchar* model_value_xml_element_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + ModelXmlElement** object_p; + object_p = collect_values[0].v_pointer; + if (!object_p) { + return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); + } + if (!value->data[0].v_pointer) { + *object_p = NULL; + } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) { + *object_p = value->data[0].v_pointer; + } else { + *object_p = model_xml_element_ref (value->data[0].v_pointer); + } + return NULL; +} + + +GParamSpec* model_param_spec_xml_element (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) { + ModelParamSpecXmlElement* spec; + g_return_val_if_fail (g_type_is_a (object_type, MODEL_TYPE_XML_ELEMENT), NULL); + spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags); + G_PARAM_SPEC (spec)->value_type = object_type; + return G_PARAM_SPEC (spec); +} + + +gpointer model_value_get_xml_element (const GValue* value) { + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_XML_ELEMENT), NULL); + return value->data[0].v_pointer; +} + + +void model_value_set_xml_element (GValue* value, gpointer v_object) { + ModelXmlElement* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_XML_ELEMENT)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_XML_ELEMENT)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + model_xml_element_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + model_xml_element_unref (old); + } +} + + +void model_value_take_xml_element (GValue* value, gpointer v_object) { + ModelXmlElement* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_XML_ELEMENT)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_XML_ELEMENT)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + model_xml_element_unref (old); + } +} + + +static void model_xml_element_class_init (ModelXmlElementClass * klass) { + model_xml_element_parent_class = g_type_class_peek_parent (klass); + MODEL_XML_ELEMENT_CLASS (klass)->finalize = model_xml_element_finalize; + g_type_class_add_private (klass, sizeof (ModelXmlElementPrivate)); +} + + +static void model_xml_element_instance_init (ModelXmlElement * self) { + self->priv = MODEL_XML_ELEMENT_GET_PRIVATE (self); + self->ref_count = 1; +} + + +static void model_xml_element_finalize (ModelXmlElement* obj) { + ModelXmlElement * self; + self = MODEL_XML_ELEMENT (obj); + _g_free0 (self->priv->_name); + self->attribute_names = (_vala_array_free (self->attribute_names, self->attribute_names_length1, (GDestroyNotify) g_free), NULL); + self->attribute_values = (_vala_array_free (self->attribute_values, self->attribute_values_length1, (GDestroyNotify) g_free), NULL); + _g_object_unref0 (self->priv->_children); +} + + +GType model_xml_element_get_type (void) { + static volatile gsize model_xml_element_type_id__volatile = 0; + if (g_once_init_enter (&model_xml_element_type_id__volatile)) { + static const GTypeValueTable g_define_type_value_table = { model_value_xml_element_init, model_value_xml_element_free_value, model_value_xml_element_copy_value, model_value_xml_element_peek_pointer, "p", model_value_xml_element_collect_value, "p", model_value_xml_element_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (ModelXmlElementClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_xml_element_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelXmlElement), 0, (GInstanceInitFunc) model_xml_element_instance_init, &g_define_type_value_table }; + static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) }; + GType model_xml_element_type_id; + model_xml_element_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ModelXmlElement", &g_define_type_info, &g_define_type_fundamental_info, 0); + g_once_init_leave (&model_xml_element_type_id__volatile, model_xml_element_type_id); + } + return model_xml_element_type_id__volatile; +} + + +gpointer model_xml_element_ref (gpointer instance) { + ModelXmlElement* self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + + +void model_xml_element_unref (gpointer instance) { + ModelXmlElement* self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + MODEL_XML_ELEMENT_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + + +#line 307 "ProjectLoader.vala" +static void _model_project_loader_on_load_error_model_loader_handler_load_error (ModelLoaderHandler* _sender, const char* error_message, gpointer self) { +#line 1841 "ProjectLoader.c" + model_project_loader_on_load_error (self, error_message); +} + + +#line 312 "ProjectLoader.vala" +static void _model_project_loader_on_handler_complete_model_loader_handler_complete (ModelLoaderHandler* _sender, gpointer self) { +#line 1848 "ProjectLoader.c" + model_project_loader_on_handler_complete (self); +} + + +#line 300 "ProjectLoader.vala" +ModelProjectLoader* model_project_loader_construct (GType object_type, ModelLoaderHandler* loader_handler, const char* file_name) { +#line 1855 "ProjectLoader.c" + ModelProjectLoader * self; + char* _tmp0_; + ModelLoaderHandler* _tmp1_; +#line 300 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (loader_handler), NULL); +#line 300 "ProjectLoader.vala" + self = (ModelProjectLoader*) g_object_new (object_type, NULL); +#line 301 "ProjectLoader.vala" + self->priv->file_name = (_tmp0_ = g_strdup (file_name), _g_free0 (self->priv->file_name), _tmp0_); +#line 302 "ProjectLoader.vala" + self->priv->loader_handler = (_tmp1_ = _g_object_ref0 (loader_handler), _g_object_unref0 (self->priv->loader_handler), _tmp1_); +#line 303 "ProjectLoader.vala" + g_signal_connect_object (loader_handler, "load-error", (GCallback) _model_project_loader_on_load_error_model_loader_handler_load_error, self, 0); +#line 304 "ProjectLoader.vala" + g_signal_connect_object (loader_handler, "complete", (GCallback) _model_project_loader_on_handler_complete_model_loader_handler_complete, self, 0); +#line 1871 "ProjectLoader.c" + return self; +} + + +#line 300 "ProjectLoader.vala" +ModelProjectLoader* model_project_loader_new (ModelLoaderHandler* loader_handler, const char* file_name) { +#line 300 "ProjectLoader.vala" + return model_project_loader_construct (MODEL_TYPE_PROJECT_LOADER, loader_handler, file_name); +#line 1880 "ProjectLoader.c" +} + + +#line 307 "ProjectLoader.vala" +static void model_project_loader_on_load_error (ModelProjectLoader* self, const char* _error_) { +#line 307 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_LOADER (self)); +#line 307 "ProjectLoader.vala" + g_return_if_fail (_error_ != NULL); +#line 308 "ProjectLoader.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_load_error"); +#line 309 "ProjectLoader.vala" + g_signal_emit_by_name (self, "load-error", _error_); +#line 1894 "ProjectLoader.c" +} + + +#line 312 "ProjectLoader.vala" +static void model_project_loader_on_handler_complete (ModelProjectLoader* self) { +#line 1900 "ProjectLoader.c" + gboolean _tmp0_ = FALSE; +#line 312 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_LOADER (self)); +#line 313 "ProjectLoader.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_handler_complete"); +#line 314 "ProjectLoader.vala" + self->priv->handler_completed = TRUE; +#line 315 "ProjectLoader.vala" + if (self->priv->project_load_completed) { +#line 315 "ProjectLoader.vala" + _tmp0_ = !self->priv->load_completed_fired; +#line 1912 "ProjectLoader.c" + } else { +#line 315 "ProjectLoader.vala" + _tmp0_ = FALSE; +#line 1916 "ProjectLoader.c" + } +#line 315 "ProjectLoader.vala" + if (_tmp0_) { +#line 316 "ProjectLoader.vala" + self->priv->load_completed_fired = TRUE; +#line 317 "ProjectLoader.vala" + g_signal_emit_by_name (self, "load-complete"); +#line 1924 "ProjectLoader.c" + } +} + + +#line 307 "ProjectLoader.vala" +static void _model_project_loader_on_load_error_model_project_builder_error_occurred (ModelProjectBuilder* _sender, const char* _error_, gpointer self) { +#line 1931 "ProjectLoader.c" + model_project_loader_on_load_error (self, _error_); +} + + +#line 321 "ProjectLoader.vala" +void model_project_loader_load (ModelProjectLoader* self) { +#line 1938 "ProjectLoader.c" + GError * _inner_error_; + char* _tmp3_; + ModelXmlTreeLoader* tree_loader; + ModelProjectBuilder* builder; +#line 321 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_LOADER (self)); +#line 1945 "ProjectLoader.c" + _inner_error_ = NULL; + { + char* _tmp1_; + char* _tmp0_ = NULL; +#line 323 "ProjectLoader.vala" + g_file_get_contents (self->priv->file_name, &_tmp0_, &self->priv->text_len, &_inner_error_); +#line 323 "ProjectLoader.vala" + self->priv->text = (_tmp1_ = _tmp0_, _g_free0 (self->priv->text), _tmp1_); +#line 1954 "ProjectLoader.c" + if (_inner_error_ != NULL) { + if (_inner_error_->domain == G_FILE_ERROR) { + goto __catch13_g_file_error; + } + g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } + } + goto __finally13; + __catch13_g_file_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { + char* _tmp2_; +#line 325 "ProjectLoader.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_LOADING, LOGGING_LEVEL_MEDIUM, _tmp2_ = g_strdup_printf ("error loading %s: %s", self->priv->file_name, e->message)); +#line 1974 "ProjectLoader.c" + _g_free0 (_tmp2_); +#line 327 "ProjectLoader.vala" + g_signal_emit_by_name (self, "load-error", e->message); +#line 328 "ProjectLoader.vala" + g_signal_emit_by_name (self, "load-complete"); +#line 1980 "ProjectLoader.c" + _g_error_free0 (e); +#line 329 "ProjectLoader.vala" + return; +#line 1984 "ProjectLoader.c" + } + } + __finally13: + if (_inner_error_ != NULL) { + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } +#line 331 "ProjectLoader.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_LOADING, LOGGING_LEVEL_VERBOSE, _tmp3_ = g_strdup_printf ("Building tree for %s", self->priv->file_name)); +#line 1995 "ProjectLoader.c" + _g_free0 (_tmp3_); +#line 332 "ProjectLoader.vala" + tree_loader = model_xml_tree_loader_new (self->priv->text); +#line 334 "ProjectLoader.vala" + builder = model_project_builder_new (self->priv->loader_handler); +#line 335 "ProjectLoader.vala" + g_signal_connect_object (builder, "error-occurred", (GCallback) _model_project_loader_on_load_error_model_project_builder_error_occurred, self, 0); +#line 337 "ProjectLoader.vala" + if (model_project_builder_check_project (builder, tree_loader->root)) { +#line 2005 "ProjectLoader.c" + gboolean _tmp4_ = FALSE; +#line 338 "ProjectLoader.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_LOADING, LOGGING_LEVEL_VERBOSE, "project checked out. starting load"); +#line 339 "ProjectLoader.vala" + g_signal_emit_by_name (self, "load-started", self->priv->file_name); +#line 340 "ProjectLoader.vala" + model_project_builder_build_project (builder, tree_loader->root); +#line 341 "ProjectLoader.vala" + self->priv->project_load_completed = TRUE; +#line 342 "ProjectLoader.vala" + if (self->priv->handler_completed) { +#line 342 "ProjectLoader.vala" + _tmp4_ = !self->priv->load_completed_fired; +#line 2019 "ProjectLoader.c" + } else { +#line 342 "ProjectLoader.vala" + _tmp4_ = FALSE; +#line 2023 "ProjectLoader.c" + } +#line 342 "ProjectLoader.vala" + if (_tmp4_) { +#line 343 "ProjectLoader.vala" + self->priv->load_completed_fired = TRUE; +#line 344 "ProjectLoader.vala" + g_signal_emit_by_name (self, "load-complete"); +#line 2031 "ProjectLoader.c" + } + } else { +#line 348 "ProjectLoader.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_LOADING, LOGGING_LEVEL_INFO, "project did not check out. stopping."); +#line 349 "ProjectLoader.vala" + g_signal_emit_by_name (self, "load-complete"); +#line 2038 "ProjectLoader.c" + } + _model_xml_tree_loader_unref0 (tree_loader); + _g_object_unref0 (builder); +} + + +static void model_project_loader_class_init (ModelProjectLoaderClass * klass) { + model_project_loader_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ModelProjectLoaderPrivate)); + G_OBJECT_CLASS (klass)->finalize = model_project_loader_finalize; + g_signal_new ("load_started", MODEL_TYPE_PROJECT_LOADER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING); + g_signal_new ("load_complete", MODEL_TYPE_PROJECT_LOADER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); + g_signal_new ("load_error", MODEL_TYPE_PROJECT_LOADER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING); +} + + +static void model_project_loader_instance_init (ModelProjectLoader * self) { + self->priv = MODEL_PROJECT_LOADER_GET_PRIVATE (self); + self->priv->project_load_completed = FALSE; + self->priv->load_completed_fired = FALSE; + self->priv->handler_completed = FALSE; +} + + +static void model_project_loader_finalize (GObject* obj) { + ModelProjectLoader * self; + self = MODEL_PROJECT_LOADER (obj); + _g_free0 (self->priv->file_name); + _g_object_unref0 (self->priv->loader_handler); + _g_free0 (self->priv->text); + G_OBJECT_CLASS (model_project_loader_parent_class)->finalize (obj); +} + + +GType model_project_loader_get_type (void) { + static volatile gsize model_project_loader_type_id__volatile = 0; + if (g_once_init_enter (&model_project_loader_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelProjectLoaderClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_project_loader_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelProjectLoader), 0, (GInstanceInitFunc) model_project_loader_instance_init, NULL }; + GType model_project_loader_type_id; + model_project_loader_type_id = g_type_register_static (G_TYPE_OBJECT, "ModelProjectLoader", &g_define_type_info, 0); + g_once_init_leave (&model_project_loader_type_id__volatile, model_project_loader_type_id); + } + return model_project_loader_type_id__volatile; +} + + +static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) { + if ((array != NULL) && (destroy_func != NULL)) { + int i; + for (i = 0; i < array_length; i = i + 1) { + if (((gpointer*) array)[i] != NULL) { + destroy_func (((gpointer*) array)[i]); + } + } + } +} + + +static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) { + _vala_array_destroy (array, array_length, destroy_func); + g_free (array); +} + + +static gint _vala_array_length (gpointer array) { + int length; + length = 0; + if (array) { + while (((gpointer*) array)[length]) { + length++; + } + } + return length; +} + + +static int _vala_strcmp0 (const char * str1, const char * str2) { + if (str1 == NULL) { + return -(str1 != str2); + } + if (str2 == NULL) { + return str1 != str2; + } + return strcmp (str1, str2); +} + + + + diff --git a/src/marina/marina/ProjectLoader.o b/src/marina/marina/ProjectLoader.o new file mode 100644 index 0000000..c3909bd Binary files /dev/null and b/src/marina/marina/ProjectLoader.o differ diff --git a/src/marina/marina/Ruler.c b/src/marina/marina/Ruler.c new file mode 100644 index 0000000..058d32b --- /dev/null +++ b/src/marina/marina/Ruler.c @@ -0,0 +1,306 @@ +/* Ruler.c generated by valac, the Vala compiler + * generated from Ruler.vala, do not modify */ + +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#define VIEW_TYPE_RULER (view_ruler_get_type ()) +#define VIEW_RULER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_RULER, ViewRuler)) +#define VIEW_RULER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_RULER, ViewRulerClass)) +#define VIEW_IS_RULER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_RULER)) +#define VIEW_IS_RULER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_RULER)) +#define VIEW_RULER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_RULER, ViewRulerClass)) + +typedef struct _ViewRuler ViewRuler; +typedef struct _ViewRulerClass ViewRulerClass; +typedef struct _ViewRulerPrivate ViewRulerPrivate; + +#define MODEL_TYPE_TIME_SYSTEM (model_time_system_get_type ()) +#define MODEL_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TIME_SYSTEM, ModelTimeSystem)) +#define MODEL_IS_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TIME_SYSTEM)) +#define MODEL_TIME_SYSTEM_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MODEL_TYPE_TIME_SYSTEM, ModelTimeSystemIface)) + +typedef struct _ModelTimeSystem ModelTimeSystem; +typedef struct _ModelTimeSystemIface ModelTimeSystemIface; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +#define _g_free0(var) (var = (g_free (var), NULL)) +#define _cairo_destroy0(var) ((var == NULL) ? NULL : (var = (cairo_destroy (var), NULL))) +#define _pango_font_description_free0(var) ((var == NULL) ? NULL : (var = (pango_font_description_free (var), NULL))) + +struct _ViewRuler { + GtkDrawingArea parent_instance; + ViewRulerPrivate * priv; +}; + +struct _ViewRulerClass { + GtkDrawingAreaClass parent_class; +}; + +struct _ModelTimeSystemIface { + GTypeInterface parent_iface; + void (*calculate_pixel_step) (ModelTimeSystem* self, float inc, float pixel_min, float pixel_div); + gint64 (*xpos_to_time) (ModelTimeSystem* self, gint x); + gint64 (*xsize_to_time) (ModelTimeSystem* self, gint x); + gint (*time_to_xpos) (ModelTimeSystem* self, gint64 time); + gint64 (*get_pixel_snap_time) (ModelTimeSystem* self); + gint (*time_to_xsize) (ModelTimeSystem* self, gint64 time); + float (*get_pixel_percentage) (ModelTimeSystem* self); + gint (*get_start_token) (ModelTimeSystem* self, gint xsize); + gint (*get_next_position) (ModelTimeSystem* self, gint token); + gint (*get_pixel_height) (ModelTimeSystem* self, gint token); + char* (*get_display_string) (ModelTimeSystem* self, gint token); + gint (*frame_to_xsize) (ModelTimeSystem* self, gint frame); + gint (*xsize_to_frame) (ModelTimeSystem* self, gint xsize); + char* (*get_time_string) (ModelTimeSystem* self, gint64 time); + char* (*get_time_duration) (ModelTimeSystem* self, gint64 time); +}; + +struct _ViewRulerPrivate { + ModelTimeSystem* provider; +}; + + +static gpointer view_ruler_parent_class = NULL; + +GType view_ruler_get_type (void); +GType model_time_system_get_type (void); +#define VIEW_RULER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIEW_TYPE_RULER, ViewRulerPrivate)) +enum { + VIEW_RULER_DUMMY_PROPERTY +}; +#define VIEW_RULER_BORDER 4 +ViewRuler* view_ruler_new (ModelTimeSystem* provider, gint height); +ViewRuler* view_ruler_construct (GType object_type, ModelTimeSystem* provider, gint height); +gint model_time_system_get_start_token (ModelTimeSystem* self, gint xsize); +void parse_color (const char* color, GdkColor* result); +gint model_time_system_frame_to_xsize (ModelTimeSystem* self, gint frame); +gint model_time_system_get_pixel_height (ModelTimeSystem* self, gint token); +char* model_time_system_get_display_string (ModelTimeSystem* self, gint token); +gint model_time_system_get_next_position (ModelTimeSystem* self, gint token); +static gboolean view_ruler_real_expose_event (GtkWidget* base, GdkEventExpose* event); +static gboolean view_ruler_real_button_press_event (GtkWidget* base, GdkEventButton* event); +static gboolean view_ruler_real_motion_notify_event (GtkWidget* base, GdkEventMotion* event); +static void view_ruler_finalize (GObject* obj); + + + +#line 14 "Ruler.vala" +ViewRuler* view_ruler_construct (GType object_type, ModelTimeSystem* provider, gint height) { +#line 105 "Ruler.c" + ViewRuler * self; +#line 14 "Ruler.vala" + g_return_val_if_fail (MODEL_IS_TIME_SYSTEM (provider), NULL); +#line 109 "Ruler.c" + self = g_object_newv (object_type, 0, NULL); +#line 15 "Ruler.vala" + self->priv->provider = provider; +#line 16 "Ruler.vala" + GTK_WIDGET_SET_FLAGS (GTK_WIDGET (self), GTK_NO_WINDOW); +#line 17 "Ruler.vala" + gtk_widget_set_size_request (GTK_WIDGET (self), 0, height); +#line 117 "Ruler.c" + return self; +} + + +#line 14 "Ruler.vala" +ViewRuler* view_ruler_new (ModelTimeSystem* provider, gint height) { +#line 14 "Ruler.vala" + return view_ruler_construct (VIEW_TYPE_RULER, provider, height); +#line 126 "Ruler.c" +} + + +#line 20 "Ruler.vala" +static gboolean view_ruler_real_expose_event (GtkWidget* base, GdkEventExpose* event) { +#line 132 "Ruler.c" + ViewRuler * self; + gboolean result = FALSE; + gint x; + gint frame; + cairo_t* context; + GdkColor _tmp1_; + GdkColor _tmp0_ = {0}; + cairo_antialias_t old_antialias; + gint stop; + PangoFontDescription* f; + self = VIEW_RULER (base); +#line 21 "Ruler.vala" + x = (*event).area.x; +#line 22 "Ruler.vala" + frame = model_time_system_get_start_token (self->priv->provider, x); +#line 24 "Ruler.vala" + context = gdk_cairo_create (GDK_DRAWABLE (GTK_WIDGET (self)->window)); +#line 26 "Ruler.vala" + gdk_cairo_set_source_color (context, (_tmp1_ = (parse_color ("#777", &_tmp0_), _tmp0_), &_tmp1_)); +#line 27 "Ruler.vala" + cairo_rectangle (context, (double) (*event).area.x, (double) (*event).area.y, (double) (*event).area.width, (double) (*event).area.height); +#line 28 "Ruler.vala" + cairo_fill (context); +#line 30 "Ruler.vala" + old_antialias = cairo_get_antialias (context); +#line 32 "Ruler.vala" + cairo_set_antialias (context, CAIRO_ANTIALIAS_NONE); +#line 33 "Ruler.vala" + cairo_set_source_rgb (context, 1.0, 1.0, 1.0); +#line 34 "Ruler.vala" + stop = (*event).area.x + (*event).area.width; +#line 35 "Ruler.vala" + f = pango_font_description_from_string ("Sans 9"); +#line 36 "Ruler.vala" + while (TRUE) { +#line 168 "Ruler.c" + gint y; + char* display_string; +#line 36 "Ruler.vala" + if (!(x <= stop)) { +#line 36 "Ruler.vala" + break; +#line 175 "Ruler.c" + } +#line 37 "Ruler.vala" + x = model_time_system_frame_to_xsize (self->priv->provider, frame); +#line 38 "Ruler.vala" + y = model_time_system_get_pixel_height (self->priv->provider, frame); +#line 40 "Ruler.vala" + cairo_move_to (context, (double) (x + VIEW_RULER_BORDER), (double) 0); +#line 41 "Ruler.vala" + cairo_line_to (context, (double) (x + VIEW_RULER_BORDER), (double) y); +#line 43 "Ruler.vala" + display_string = model_time_system_get_display_string (self->priv->provider, frame); +#line 44 "Ruler.vala" + if (display_string != NULL) { +#line 189 "Ruler.c" + PangoLayout* layout; + gint w = 0; + gint h = 0; + gint text_pos; +#line 45 "Ruler.vala" + layout = gtk_widget_create_pango_layout (GTK_WIDGET (self), display_string); +#line 49 "Ruler.vala" + pango_layout_set_font_description (layout, f); +#line 50 "Ruler.vala" + pango_layout_get_pixel_size (layout, &w, &h); +#line 51 "Ruler.vala" + text_pos = (x - (w / 2)) + VIEW_RULER_BORDER; +#line 52 "Ruler.vala" + if (text_pos < 0) { +#line 53 "Ruler.vala" + text_pos = 0; +#line 206 "Ruler.c" + } +#line 56 "Ruler.vala" + gdk_draw_layout (GDK_DRAWABLE (GTK_WIDGET (self)->window), gtk_widget_get_style (GTK_WIDGET (self))->white_gc, text_pos, 7, layout); +#line 210 "Ruler.c" + _g_object_unref0 (layout); + } +#line 59 "Ruler.vala" + frame = model_time_system_get_next_position (self->priv->provider, frame); +#line 215 "Ruler.c" + _g_free0 (display_string); + } +#line 61 "Ruler.vala" + cairo_set_antialias (context, old_antialias); +#line 62 "Ruler.vala" + cairo_set_line_width (context, 1.0); +#line 63 "Ruler.vala" + cairo_stroke (context); +#line 224 "Ruler.c" + result = TRUE; + _cairo_destroy0 (context); + _pango_font_description_free0 (f); +#line 64 "Ruler.vala" + return result; +#line 230 "Ruler.c" +} + + +#line 67 "Ruler.vala" +static gboolean view_ruler_real_button_press_event (GtkWidget* base, GdkEventButton* event) { +#line 236 "Ruler.c" + ViewRuler * self; + gboolean result = FALSE; + self = VIEW_RULER (base); +#line 68 "Ruler.vala" + g_signal_emit_by_name (self, "position-changed", (gint) (*event).x); +#line 242 "Ruler.c" + result = FALSE; +#line 69 "Ruler.vala" + return result; +#line 246 "Ruler.c" +} + + +#line 72 "Ruler.vala" +static gboolean view_ruler_real_motion_notify_event (GtkWidget* base, GdkEventMotion* event) { +#line 252 "Ruler.c" + ViewRuler * self; + gboolean result = FALSE; + self = VIEW_RULER (base); +#line 73 "Ruler.vala" + if (((*event).state & GDK_BUTTON1_MASK) != 0) { +#line 74 "Ruler.vala" + gtk_widget_queue_draw (GTK_WIDGET (self)); +#line 75 "Ruler.vala" + g_signal_emit_by_name (self, "position-changed", (gint) (*event).x); +#line 262 "Ruler.c" + } + result = FALSE; +#line 77 "Ruler.vala" + return result; +#line 267 "Ruler.c" +} + + +static void view_ruler_class_init (ViewRulerClass * klass) { + view_ruler_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ViewRulerPrivate)); + GTK_WIDGET_CLASS (klass)->expose_event = view_ruler_real_expose_event; + GTK_WIDGET_CLASS (klass)->button_press_event = view_ruler_real_button_press_event; + GTK_WIDGET_CLASS (klass)->motion_notify_event = view_ruler_real_motion_notify_event; + G_OBJECT_CLASS (klass)->finalize = view_ruler_finalize; + g_signal_new ("position_changed", VIEW_TYPE_RULER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT); +} + + +static void view_ruler_instance_init (ViewRuler * self) { + self->priv = VIEW_RULER_GET_PRIVATE (self); +} + + +static void view_ruler_finalize (GObject* obj) { + ViewRuler * self; + self = VIEW_RULER (obj); + G_OBJECT_CLASS (view_ruler_parent_class)->finalize (obj); +} + + +GType view_ruler_get_type (void) { + static volatile gsize view_ruler_type_id__volatile = 0; + if (g_once_init_enter (&view_ruler_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ViewRulerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_ruler_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewRuler), 0, (GInstanceInitFunc) view_ruler_instance_init, NULL }; + GType view_ruler_type_id; + view_ruler_type_id = g_type_register_static (GTK_TYPE_DRAWING_AREA, "ViewRuler", &g_define_type_info, 0); + g_once_init_leave (&view_ruler_type_id__volatile, view_ruler_type_id); + } + return view_ruler_type_id__volatile; +} + + + + diff --git a/src/marina/marina/Ruler.o b/src/marina/marina/Ruler.o new file mode 100644 index 0000000..3148528 Binary files /dev/null and b/src/marina/marina/Ruler.o differ diff --git a/src/marina/marina/StatusBar.c b/src/marina/marina/StatusBar.c new file mode 100644 index 0000000..b6b72c1 --- /dev/null +++ b/src/marina/marina/StatusBar.c @@ -0,0 +1,401 @@ +/* StatusBar.c generated by valac, the Vala compiler + * generated from StatusBar.vala, do not modify */ + +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#define VIEW_TYPE_STATUS_BAR (view_status_bar_get_type ()) +#define VIEW_STATUS_BAR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_STATUS_BAR, ViewStatusBar)) +#define VIEW_STATUS_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_STATUS_BAR, ViewStatusBarClass)) +#define VIEW_IS_STATUS_BAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_STATUS_BAR)) +#define VIEW_IS_STATUS_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_STATUS_BAR)) +#define VIEW_STATUS_BAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_STATUS_BAR, ViewStatusBarClass)) + +typedef struct _ViewStatusBar ViewStatusBar; +typedef struct _ViewStatusBarClass ViewStatusBarClass; +typedef struct _ViewStatusBarPrivate ViewStatusBarPrivate; + +#define MODEL_TYPE_TIME_SYSTEM (model_time_system_get_type ()) +#define MODEL_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TIME_SYSTEM, ModelTimeSystem)) +#define MODEL_IS_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TIME_SYSTEM)) +#define MODEL_TIME_SYSTEM_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MODEL_TYPE_TIME_SYSTEM, ModelTimeSystemIface)) + +typedef struct _ModelTimeSystem ModelTimeSystem; +typedef struct _ModelTimeSystemIface ModelTimeSystemIface; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) + +#define MODEL_TYPE_TEMPO_INFORMATION (model_tempo_information_get_type ()) +#define MODEL_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformation)) +#define MODEL_IS_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TEMPO_INFORMATION)) +#define MODEL_TEMPO_INFORMATION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformationIface)) + +typedef struct _ModelTempoInformation ModelTempoInformation; +typedef struct _ModelTempoInformationIface ModelTempoInformationIface; + +#define TYPE_FRACTION (fraction_get_type ()) +typedef struct _Fraction Fraction; + +#define MODEL_TYPE_PROJECT (model_project_get_type ()) +#define MODEL_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT, ModelProject)) +#define MODEL_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT, ModelProjectClass)) +#define MODEL_IS_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT)) +#define MODEL_IS_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT)) +#define MODEL_PROJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT, ModelProjectClass)) + +typedef struct _ModelProject ModelProject; +typedef struct _ModelProjectClass ModelProjectClass; +typedef struct _ModelProjectPrivate ModelProjectPrivate; + +#define MODEL_TYPE_CLIP_FILE (model_clip_file_get_type ()) +#define MODEL_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFile)) +#define MODEL_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) +#define MODEL_IS_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE)) +#define MODEL_IS_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE)) +#define MODEL_CLIP_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) + +typedef struct _ModelClipFile ModelClipFile; +typedef struct _ModelClipFileClass ModelClipFileClass; + +#define TYPE_TIME_CODE (time_code_get_type ()) +typedef struct _TimeCode TimeCode; + +#define MODEL_TYPE_TRACK (model_track_get_type ()) +#define MODEL_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TRACK, ModelTrack)) +#define MODEL_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TRACK, ModelTrackClass)) +#define MODEL_IS_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TRACK)) +#define MODEL_IS_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TRACK)) +#define MODEL_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TRACK, ModelTrackClass)) + +typedef struct _ModelTrack ModelTrack; +typedef struct _ModelTrackClass ModelTrackClass; + +#define VIEW_TYPE_MEDIA_ENGINE (view_media_engine_get_type ()) +#define VIEW_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngine)) +#define VIEW_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass)) +#define VIEW_IS_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_ENGINE)) +#define VIEW_IS_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_ENGINE)) +#define VIEW_MEDIA_ENGINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass)) + +typedef struct _ViewMediaEngine ViewMediaEngine; +typedef struct _ViewMediaEngineClass ViewMediaEngineClass; + +#define MODEL_TYPE_PROJECT_LOADER (model_project_loader_get_type ()) +#define MODEL_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoader)) +#define MODEL_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass)) +#define MODEL_IS_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT_LOADER)) +#define MODEL_IS_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT_LOADER)) +#define MODEL_PROJECT_LOADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass)) + +typedef struct _ModelProjectLoader ModelProjectLoader; +typedef struct _ModelProjectLoaderClass ModelProjectLoaderClass; + +#define MODEL_TYPE_UNDO_MANAGER (model_undo_manager_get_type ()) +#define MODEL_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManager)) +#define MODEL_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass)) +#define MODEL_IS_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_UNDO_MANAGER)) +#define MODEL_IS_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_UNDO_MANAGER)) +#define MODEL_UNDO_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass)) + +typedef struct _ModelUndoManager ModelUndoManager; +typedef struct _ModelUndoManagerClass ModelUndoManagerClass; + +#define MODEL_TYPE_LIBRARY_IMPORTER (model_library_importer_get_type ()) +#define MODEL_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporter)) +#define MODEL_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass)) +#define MODEL_IS_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_LIBRARY_IMPORTER)) +#define MODEL_IS_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_LIBRARY_IMPORTER)) +#define MODEL_LIBRARY_IMPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass)) + +typedef struct _ModelLibraryImporter ModelLibraryImporter; +typedef struct _ModelLibraryImporterClass ModelLibraryImporterClass; + +#define LOGGING_TYPE_FACILITY (logging_facility_get_type ()) + +#define LOGGING_TYPE_LEVEL (logging_level_get_type ()) +#define _g_free0(var) (var = (g_free (var), NULL)) + +struct _ViewStatusBar { + GtkDrawingArea parent_instance; + ViewStatusBarPrivate * priv; +}; + +struct _ViewStatusBarClass { + GtkDrawingAreaClass parent_class; +}; + +struct _ModelTimeSystemIface { + GTypeInterface parent_iface; + void (*calculate_pixel_step) (ModelTimeSystem* self, float inc, float pixel_min, float pixel_div); + gint64 (*xpos_to_time) (ModelTimeSystem* self, gint x); + gint64 (*xsize_to_time) (ModelTimeSystem* self, gint x); + gint (*time_to_xpos) (ModelTimeSystem* self, gint64 time); + gint64 (*get_pixel_snap_time) (ModelTimeSystem* self); + gint (*time_to_xsize) (ModelTimeSystem* self, gint64 time); + float (*get_pixel_percentage) (ModelTimeSystem* self); + gint (*get_start_token) (ModelTimeSystem* self, gint xsize); + gint (*get_next_position) (ModelTimeSystem* self, gint token); + gint (*get_pixel_height) (ModelTimeSystem* self, gint token); + char* (*get_display_string) (ModelTimeSystem* self, gint token); + gint (*frame_to_xsize) (ModelTimeSystem* self, gint frame); + gint (*xsize_to_frame) (ModelTimeSystem* self, gint xsize); + char* (*get_time_string) (ModelTimeSystem* self, gint64 time); + char* (*get_time_duration) (ModelTimeSystem* self, gint64 time); +}; + +struct _ViewStatusBarPrivate { + ModelTimeSystem* provider; + gint64 current_position; +}; + +struct _Fraction { + gint numerator; + gint denominator; +}; + +struct _ModelTempoInformationIface { + GTypeInterface parent_iface; + void (*get_time_signature) (ModelTempoInformation* self, Fraction* result); + gint (*get_bpm) (ModelTempoInformation* self); +}; + +struct _TimeCode { + gint hour; + gint minute; + gint second; + gint frame; + gboolean drop_code; +}; + +struct _ModelProject { + GObject parent_instance; + ModelProjectPrivate * priv; + GeeArrayList* tracks; + GeeArrayList* inactive_tracks; + GeeArrayList* clipfiles; + ViewMediaEngine* media_engine; + char* project_file; + ModelProjectLoader* loader; + ModelUndoManager* undo_manager; + ModelLibraryImporter* importer; + Fraction default_framerate; + gboolean click_during_play; + gboolean click_during_record; + double click_volume; + gboolean library_visible; + gint library_width; + gboolean snap_to_clip; +}; + +struct _ModelProjectClass { + GObjectClass parent_class; + void (*get_clip_time) (ModelProject* self, ModelClipFile* f, TimeCode* result); + char* (*get_project_file) (ModelProject* self); + void (*do_append) (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, const char* name, gint64 insert_time); + void (*add_track) (ModelProject* self, ModelTrack* track); + void (*insert_track) (ModelProject* self, gint index, ModelTrack* track); + void (*load) (ModelProject* self, const char* fname); + void (*save) (ModelProject* self, const char* filename); + char* (*get_app_name) (ModelProject* self); + void (*load_complete) (ModelProject* self); +}; + +typedef enum { + LOGGING_FACILITY_SIGNAL_HANDLERS, + LOGGING_FACILITY_DEVELOPER_WARNINGS, + LOGGING_FACILITY_GRAPH, + LOGGING_FACILITY_LOADING, + LOGGING_FACILITY_IMPORT, + LOGGING_FACILITY_SINGLEDECODEBIN +} LoggingFacility; + +typedef enum { + LOGGING_LEVEL_CRITICAL, + LOGGING_LEVEL_HIGH, + LOGGING_LEVEL_MEDIUM, + LOGGING_LEVEL_LOW, + LOGGING_LEVEL_INFO, + LOGGING_LEVEL_VERBOSE +} LoggingLevel; + + +static gpointer view_status_bar_parent_class = NULL; + +GType view_status_bar_get_type (void); +GType model_time_system_get_type (void); +#define VIEW_STATUS_BAR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIEW_TYPE_STATUS_BAR, ViewStatusBarPrivate)) +enum { + VIEW_STATUS_BAR_DUMMY_PROPERTY +}; +void parse_color (const char* color, GdkColor* result); +GType fraction_get_type (void); +Fraction* fraction_dup (const Fraction* self); +void fraction_free (Fraction* self); +GType model_tempo_information_get_type (void); +GType model_project_get_type (void); +GType model_clip_file_get_type (void); +GType time_code_get_type (void); +TimeCode* time_code_dup (const TimeCode* self); +void time_code_free (TimeCode* self); +GType model_track_get_type (void); +GType view_media_engine_get_type (void); +GType model_project_loader_get_type (void); +gpointer model_undo_manager_ref (gpointer instance); +void model_undo_manager_unref (gpointer instance); +GParamSpec* model_param_spec_undo_manager (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_undo_manager (GValue* value, gpointer v_object); +void model_value_take_undo_manager (GValue* value, gpointer v_object); +gpointer model_value_get_undo_manager (const GValue* value); +GType model_undo_manager_get_type (void); +GType model_library_importer_get_type (void); +void view_status_bar_on_position_changed (ViewStatusBar* self, gint64 new_position); +static void _view_status_bar_on_position_changed_view_media_engine_position_changed (ViewMediaEngine* _sender, gint64 position, gpointer self); +ViewStatusBar* view_status_bar_new (ModelProject* p, ModelTimeSystem* provider, gint height); +ViewStatusBar* view_status_bar_construct (GType object_type, ModelProject* p, ModelTimeSystem* provider, gint height); +GType logging_facility_get_type (void); +GType logging_level_get_type (void); +void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message); +char* model_time_system_get_time_string (ModelTimeSystem* self, gint64 time); +static gboolean view_status_bar_real_expose_event (GtkWidget* base, GdkEventExpose* e); +static void view_status_bar_finalize (GObject* obj); + + + +#line 23 "StatusBar.vala" +static void _view_status_bar_on_position_changed_view_media_engine_position_changed (ViewMediaEngine* _sender, gint64 position, gpointer self) { +#line 281 "StatusBar.c" + view_status_bar_on_position_changed (self, position); +} + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 14 "StatusBar.vala" +ViewStatusBar* view_status_bar_construct (GType object_type, ModelProject* p, ModelTimeSystem* provider, gint height) { +#line 293 "StatusBar.c" + ViewStatusBar * self; + GdkColor _tmp1_; + GdkColor _tmp0_ = {0}; + ModelTimeSystem* _tmp2_; +#line 14 "StatusBar.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (p), NULL); +#line 14 "StatusBar.vala" + g_return_val_if_fail (MODEL_IS_TIME_SYSTEM (provider), NULL); +#line 302 "StatusBar.c" + self = g_object_newv (object_type, 0, NULL); +#line 15 "StatusBar.vala" + GTK_WIDGET_SET_FLAGS (GTK_WIDGET (self), GTK_NO_WINDOW); +#line 16 "StatusBar.vala" + gtk_widget_modify_bg (GTK_WIDGET (self), GTK_STATE_NORMAL, (_tmp1_ = (parse_color ("#666", &_tmp0_), _tmp0_), &_tmp1_)); +#line 17 "StatusBar.vala" + gtk_widget_set_size_request (GTK_WIDGET (self), 0, height); +#line 19 "StatusBar.vala" + g_signal_connect_object (p->media_engine, "position-changed", (GCallback) _view_status_bar_on_position_changed_view_media_engine_position_changed, self, 0); +#line 20 "StatusBar.vala" + self->priv->provider = (_tmp2_ = _g_object_ref0 (provider), _g_object_unref0 (self->priv->provider), _tmp2_); +#line 314 "StatusBar.c" + return self; +} + + +#line 14 "StatusBar.vala" +ViewStatusBar* view_status_bar_new (ModelProject* p, ModelTimeSystem* provider, gint height) { +#line 14 "StatusBar.vala" + return view_status_bar_construct (VIEW_TYPE_STATUS_BAR, p, provider, height); +#line 323 "StatusBar.c" +} + + +#line 23 "StatusBar.vala" +void view_status_bar_on_position_changed (ViewStatusBar* self, gint64 new_position) { +#line 23 "StatusBar.vala" + g_return_if_fail (VIEW_IS_STATUS_BAR (self)); +#line 24 "StatusBar.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_position_changed"); +#line 25 "StatusBar.vala" + self->priv->current_position = new_position; +#line 26 "StatusBar.vala" + gtk_widget_queue_draw (GTK_WIDGET (self)); +#line 337 "StatusBar.c" +} + + +#line 29 "StatusBar.vala" +static gboolean view_status_bar_real_expose_event (GtkWidget* base, GdkEventExpose* e) { +#line 343 "StatusBar.c" + ViewStatusBar * self; + gboolean result = FALSE; + char* time; + PangoLayout* layout; + self = VIEW_STATUS_BAR (base); +#line 30 "StatusBar.vala" + gdk_draw_rectangle (GDK_DRAWABLE (GTK_WIDGET (self)->window), gtk_widget_get_style (GTK_WIDGET (self))->bg_gc[(gint) GTK_STATE_NORMAL], TRUE, GTK_WIDGET (self)->allocation.x, GTK_WIDGET (self)->allocation.y, GTK_WIDGET (self)->allocation.width, GTK_WIDGET (self)->allocation.height); +#line 33 "StatusBar.vala" + time = model_time_system_get_time_string (self->priv->provider, self->priv->current_position); +#line 35 "StatusBar.vala" + layout = gtk_widget_create_pango_layout (GTK_WIDGET (self), time); +#line 36 "StatusBar.vala" + gdk_draw_layout (GDK_DRAWABLE (GTK_WIDGET (self)->window), gtk_widget_get_style (GTK_WIDGET (self))->white_gc, GTK_WIDGET (self)->allocation.x + 4, GTK_WIDGET (self)->allocation.y + 2, layout); +#line 357 "StatusBar.c" + result = TRUE; + _g_free0 (time); + _g_object_unref0 (layout); +#line 38 "StatusBar.vala" + return result; +#line 363 "StatusBar.c" +} + + +static void view_status_bar_class_init (ViewStatusBarClass * klass) { + view_status_bar_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ViewStatusBarPrivate)); + GTK_WIDGET_CLASS (klass)->expose_event = view_status_bar_real_expose_event; + G_OBJECT_CLASS (klass)->finalize = view_status_bar_finalize; +} + + +static void view_status_bar_instance_init (ViewStatusBar * self) { + self->priv = VIEW_STATUS_BAR_GET_PRIVATE (self); + self->priv->current_position = (gint64) 0; +} + + +static void view_status_bar_finalize (GObject* obj) { + ViewStatusBar * self; + self = VIEW_STATUS_BAR (obj); + _g_object_unref0 (self->priv->provider); + G_OBJECT_CLASS (view_status_bar_parent_class)->finalize (obj); +} + + +GType view_status_bar_get_type (void) { + static volatile gsize view_status_bar_type_id__volatile = 0; + if (g_once_init_enter (&view_status_bar_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ViewStatusBarClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) view_status_bar_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ViewStatusBar), 0, (GInstanceInitFunc) view_status_bar_instance_init, NULL }; + GType view_status_bar_type_id; + view_status_bar_type_id = g_type_register_static (GTK_TYPE_DRAWING_AREA, "ViewStatusBar", &g_define_type_info, 0); + g_once_init_leave (&view_status_bar_type_id__volatile, view_status_bar_type_id); + } + return view_status_bar_type_id__volatile; +} + + + + diff --git a/src/marina/marina/StatusBar.o b/src/marina/marina/StatusBar.o new file mode 100644 index 0000000..edfc5f6 Binary files /dev/null and b/src/marina/marina/StatusBar.o differ diff --git a/src/marina/marina/TimeSystem.c b/src/marina/marina/TimeSystem.c new file mode 100644 index 0000000..163403d --- /dev/null +++ b/src/marina/marina/TimeSystem.c @@ -0,0 +1,1709 @@ +/* TimeSystem.c generated by valac, the Vala compiler + * generated from TimeSystem.vala, do not modify */ + +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include + + +#define MODEL_TYPE_TIME_SYSTEM (model_time_system_get_type ()) +#define MODEL_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TIME_SYSTEM, ModelTimeSystem)) +#define MODEL_IS_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TIME_SYSTEM)) +#define MODEL_TIME_SYSTEM_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MODEL_TYPE_TIME_SYSTEM, ModelTimeSystemIface)) + +typedef struct _ModelTimeSystem ModelTimeSystem; +typedef struct _ModelTimeSystemIface ModelTimeSystemIface; + +#define MODEL_TYPE_TIME_SYSTEM_BASE (model_time_system_base_get_type ()) +#define MODEL_TIME_SYSTEM_BASE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TIME_SYSTEM_BASE, ModelTimeSystemBase)) +#define MODEL_TIME_SYSTEM_BASE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TIME_SYSTEM_BASE, ModelTimeSystemBaseClass)) +#define MODEL_IS_TIME_SYSTEM_BASE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TIME_SYSTEM_BASE)) +#define MODEL_IS_TIME_SYSTEM_BASE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TIME_SYSTEM_BASE)) +#define MODEL_TIME_SYSTEM_BASE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TIME_SYSTEM_BASE, ModelTimeSystemBaseClass)) + +typedef struct _ModelTimeSystemBase ModelTimeSystemBase; +typedef struct _ModelTimeSystemBaseClass ModelTimeSystemBaseClass; +typedef struct _ModelTimeSystemBasePrivate ModelTimeSystemBasePrivate; + +#define MODEL_TYPE_TIMECODE_TIME_SYSTEM (model_timecode_time_system_get_type ()) +#define MODEL_TIMECODE_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TIMECODE_TIME_SYSTEM, ModelTimecodeTimeSystem)) +#define MODEL_TIMECODE_TIME_SYSTEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TIMECODE_TIME_SYSTEM, ModelTimecodeTimeSystemClass)) +#define MODEL_IS_TIMECODE_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TIMECODE_TIME_SYSTEM)) +#define MODEL_IS_TIMECODE_TIME_SYSTEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TIMECODE_TIME_SYSTEM)) +#define MODEL_TIMECODE_TIME_SYSTEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TIMECODE_TIME_SYSTEM, ModelTimecodeTimeSystemClass)) + +typedef struct _ModelTimecodeTimeSystem ModelTimecodeTimeSystem; +typedef struct _ModelTimecodeTimeSystemClass ModelTimecodeTimeSystemClass; +typedef struct _ModelTimecodeTimeSystemPrivate ModelTimecodeTimeSystemPrivate; + +#define TYPE_FRACTION (fraction_get_type ()) +typedef struct _Fraction Fraction; +#define _g_free0(var) (var = (g_free (var), NULL)) + +#define TYPE_TIME_CODE (time_code_get_type ()) +typedef struct _TimeCode TimeCode; + +#define MODEL_TYPE_TEMPO_INFORMATION (model_tempo_information_get_type ()) +#define MODEL_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformation)) +#define MODEL_IS_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TEMPO_INFORMATION)) +#define MODEL_TEMPO_INFORMATION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformationIface)) + +typedef struct _ModelTempoInformation ModelTempoInformation; +typedef struct _ModelTempoInformationIface ModelTempoInformationIface; + +#define MODEL_TYPE_BAR_BEAT_TIME_SYSTEM (model_bar_beat_time_system_get_type ()) +#define MODEL_BAR_BEAT_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_BAR_BEAT_TIME_SYSTEM, ModelBarBeatTimeSystem)) +#define MODEL_BAR_BEAT_TIME_SYSTEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_BAR_BEAT_TIME_SYSTEM, ModelBarBeatTimeSystemClass)) +#define MODEL_IS_BAR_BEAT_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_BAR_BEAT_TIME_SYSTEM)) +#define MODEL_IS_BAR_BEAT_TIME_SYSTEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_BAR_BEAT_TIME_SYSTEM)) +#define MODEL_BAR_BEAT_TIME_SYSTEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_BAR_BEAT_TIME_SYSTEM, ModelBarBeatTimeSystemClass)) + +typedef struct _ModelBarBeatTimeSystem ModelBarBeatTimeSystem; +typedef struct _ModelBarBeatTimeSystemClass ModelBarBeatTimeSystemClass; +typedef struct _ModelBarBeatTimeSystemPrivate ModelBarBeatTimeSystemPrivate; + +#define LOGGING_TYPE_FACILITY (logging_facility_get_type ()) + +#define LOGGING_TYPE_LEVEL (logging_level_get_type ()) + +struct _ModelTimeSystemIface { + GTypeInterface parent_iface; + void (*calculate_pixel_step) (ModelTimeSystem* self, float inc, float pixel_min, float pixel_div); + gint64 (*xpos_to_time) (ModelTimeSystem* self, gint x); + gint64 (*xsize_to_time) (ModelTimeSystem* self, gint x); + gint (*time_to_xpos) (ModelTimeSystem* self, gint64 time); + gint64 (*get_pixel_snap_time) (ModelTimeSystem* self); + gint (*time_to_xsize) (ModelTimeSystem* self, gint64 time); + float (*get_pixel_percentage) (ModelTimeSystem* self); + gint (*get_start_token) (ModelTimeSystem* self, gint xsize); + gint (*get_next_position) (ModelTimeSystem* self, gint token); + gint (*get_pixel_height) (ModelTimeSystem* self, gint token); + char* (*get_display_string) (ModelTimeSystem* self, gint token); + gint (*frame_to_xsize) (ModelTimeSystem* self, gint frame); + gint (*xsize_to_frame) (ModelTimeSystem* self, gint xsize); + char* (*get_time_string) (ModelTimeSystem* self, gint64 time); + char* (*get_time_duration) (ModelTimeSystem* self, gint64 time); +}; + +struct _ModelTimeSystemBase { + GObject parent_instance; + ModelTimeSystemBasePrivate * priv; + float pixel_percentage; + float pixels_per_second; + gint64 pixel_snap_time; +}; + +struct _ModelTimeSystemBaseClass { + GObjectClass parent_class; + gint* (*get_timeline_seconds) (ModelTimeSystemBase* self, int* result_length1); + gint (*correct_sub_second_value) (ModelTimeSystemBase* self, float seconds, gint div, gint fps); +}; + +struct _Fraction { + gint numerator; + gint denominator; +}; + +struct _ModelTimecodeTimeSystem { + ModelTimeSystemBase parent_instance; + ModelTimecodeTimeSystemPrivate * priv; + Fraction frame_rate_fraction; +}; + +struct _ModelTimecodeTimeSystemClass { + ModelTimeSystemBaseClass parent_class; +}; + +struct _ModelTimecodeTimeSystemPrivate { + float pixels_per_frame; + gint small_pixel_frames; + gint medium_pixel_frames; + gint large_pixel_frames; +}; + +struct _TimeCode { + gint hour; + gint minute; + gint second; + gint frame; + gboolean drop_code; +}; + +struct _ModelTempoInformationIface { + GTypeInterface parent_iface; + void (*get_time_signature) (ModelTempoInformation* self, Fraction* result); + gint (*get_bpm) (ModelTempoInformation* self); +}; + +struct _ModelBarBeatTimeSystem { + ModelTimeSystemBase parent_instance; + ModelBarBeatTimeSystemPrivate * priv; +}; + +struct _ModelBarBeatTimeSystemClass { + ModelTimeSystemBaseClass parent_class; +}; + +struct _ModelBarBeatTimeSystemPrivate { + float pixels_per_sixteenth; + gint small_pixel_sixteenth; + gint medium_pixel_sixteenth; + gint large_pixel_sixteenth; + gint* timeline_bars; + gint timeline_bars_length1; + gint _timeline_bars_size_; + gint bpm; + Fraction time_signature; + float bars_per_minute; + float bars_per_second; + gint sixteenths_per_bar; + gint sixteenths_per_beat; +}; + +typedef enum { + LOGGING_FACILITY_SIGNAL_HANDLERS, + LOGGING_FACILITY_DEVELOPER_WARNINGS, + LOGGING_FACILITY_GRAPH, + LOGGING_FACILITY_LOADING, + LOGGING_FACILITY_IMPORT, + LOGGING_FACILITY_SINGLEDECODEBIN +} LoggingFacility; + +typedef enum { + LOGGING_LEVEL_CRITICAL, + LOGGING_LEVEL_HIGH, + LOGGING_LEVEL_MEDIUM, + LOGGING_LEVEL_LOW, + LOGGING_LEVEL_INFO, + LOGGING_LEVEL_VERBOSE +} LoggingLevel; + + +static gpointer model_time_system_base_parent_class = NULL; +static gpointer model_timecode_time_system_parent_class = NULL; +static ModelTimeSystemIface* model_timecode_time_system_model_time_system_parent_iface = NULL; +static gpointer model_bar_beat_time_system_parent_class = NULL; +static ModelTimeSystemIface* model_bar_beat_time_system_model_time_system_parent_iface = NULL; + +GType model_time_system_get_type (void); +void model_time_system_calculate_pixel_step (ModelTimeSystem* self, float inc, float pixel_min, float pixel_div); +gint64 model_time_system_xpos_to_time (ModelTimeSystem* self, gint x); +gint64 model_time_system_xsize_to_time (ModelTimeSystem* self, gint x); +gint model_time_system_time_to_xpos (ModelTimeSystem* self, gint64 time); +gint64 model_time_system_get_pixel_snap_time (ModelTimeSystem* self); +gint model_time_system_time_to_xsize (ModelTimeSystem* self, gint64 time); +float model_time_system_get_pixel_percentage (ModelTimeSystem* self); +gint model_time_system_get_start_token (ModelTimeSystem* self, gint xsize); +gint model_time_system_get_next_position (ModelTimeSystem* self, gint token); +gint model_time_system_get_pixel_height (ModelTimeSystem* self, gint token); +char* model_time_system_get_display_string (ModelTimeSystem* self, gint token); +gint model_time_system_frame_to_xsize (ModelTimeSystem* self, gint frame); +gint model_time_system_xsize_to_frame (ModelTimeSystem* self, gint xsize); +char* model_time_system_get_time_string (ModelTimeSystem* self, gint64 time); +char* model_time_system_get_time_duration (ModelTimeSystem* self, gint64 time); +GType model_time_system_base_get_type (void); +enum { + MODEL_TIME_SYSTEM_BASE_DUMMY_PROPERTY +}; +#define MODEL_TIME_SYSTEM_BASE_PIXEL_SNAP_INTERVAL 10 +#define MODEL_TIME_SYSTEM_BASE_BORDER 4 +static gint* model_time_system_base_get_timeline_seconds (ModelTimeSystemBase* self, int* result_length1); +static gint* model_time_system_base_real_get_timeline_seconds (ModelTimeSystemBase* self, int* result_length1); +static gint model_time_system_base_correct_sub_second_value (ModelTimeSystemBase* self, float seconds, gint div, gint fps); +static gint model_time_system_base_real_correct_sub_second_value (ModelTimeSystemBase* self, float seconds, gint div, gint fps); +gint model_time_system_base_correct_seconds_value (ModelTimeSystemBase* self, float seconds, gint div, gint fps); +gint64 model_time_system_base_get_pixel_snap_time (ModelTimeSystemBase* self); +float model_time_system_base_get_pixel_percentage (ModelTimeSystemBase* self); +gint64 model_time_system_base_xsize_to_time (ModelTimeSystemBase* self, gint size); +gint64 model_time_system_base_xpos_to_time (ModelTimeSystemBase* self, gint x); +gint model_time_system_base_time_to_xsize (ModelTimeSystemBase* self, gint64 time); +gint model_time_system_base_time_to_xpos (ModelTimeSystemBase* self, gint64 time); +ModelTimeSystemBase* model_time_system_base_construct (GType object_type); +static void model_time_system_base_finalize (GObject* obj); +GType model_timecode_time_system_get_type (void); +GType fraction_get_type (void); +Fraction* fraction_dup (const Fraction* self); +void fraction_free (Fraction* self); +#define MODEL_TIMECODE_TIME_SYSTEM_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_TIMECODE_TIME_SYSTEM, ModelTimecodeTimeSystemPrivate)) +enum { + MODEL_TIMECODE_TIME_SYSTEM_DUMMY_PROPERTY +}; +void fraction_init (Fraction *self, gint numerator, gint denominator); +static gint model_timecode_time_system_real_correct_sub_second_value (ModelTimeSystemBase* base, float seconds, gint div, gint fps); +gint time_to_frame_with_rate (gint64 time, Fraction* rate); +char* frame_to_string (gint frame, Fraction* rate); +static char* model_timecode_time_system_real_get_time_string (ModelTimeSystem* base, gint64 the_time); +static char* model_timecode_time_system_real_get_time_duration (ModelTimeSystem* base, gint64 the_time); +gint fraction_nearest_int (Fraction *self); +static void model_timecode_time_system_real_calculate_pixel_step (ModelTimeSystem* base, float inc, float pixel_min, float pixel_div); +static gint model_timecode_time_system_real_frame_to_xsize (ModelTimeSystem* base, gint frame); +static gint model_timecode_time_system_real_xsize_to_frame (ModelTimeSystem* base, gint xsize); +static gint model_timecode_time_system_real_get_start_token (ModelTimeSystem* base, gint xsize); +static gint model_timecode_time_system_real_get_next_position (ModelTimeSystem* base, gint token); +GType time_code_get_type (void); +TimeCode* time_code_dup (const TimeCode* self); +void time_code_free (TimeCode* self); +void frame_to_time (gint frame, Fraction* rate, TimeCode* result); +char* time_code_to_string (TimeCode *self); +static char* model_timecode_time_system_real_get_display_string (ModelTimeSystem* base, gint frame); +static gint model_timecode_time_system_real_get_pixel_height (ModelTimeSystem* base, gint frame); +static gint* model_timecode_time_system_real_get_timeline_seconds (ModelTimeSystemBase* base, int* result_length1); +ModelTimecodeTimeSystem* model_timecode_time_system_new (void); +ModelTimecodeTimeSystem* model_timecode_time_system_construct (GType object_type); +static void model_timecode_time_system_finalize (GObject* obj); +GType model_tempo_information_get_type (void); +void model_tempo_information_get_time_signature (ModelTempoInformation* self, Fraction* result); +gint model_tempo_information_get_bpm (ModelTempoInformation* self); +GType model_bar_beat_time_system_get_type (void); +#define MODEL_BAR_BEAT_TIME_SYSTEM_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_BAR_BEAT_TIME_SYSTEM, ModelBarBeatTimeSystemPrivate)) +enum { + MODEL_BAR_BEAT_TIME_SYSTEM_DUMMY_PROPERTY +}; +static void model_bar_beat_time_system_on_bpm_changed (ModelBarBeatTimeSystem* self, gint bpm); +static void _model_bar_beat_time_system_on_bpm_changed_model_tempo_information_bpm_changed (ModelTempoInformation* _sender, gint bpm, gpointer self); +static void model_bar_beat_time_system_on_time_signature_changed (ModelBarBeatTimeSystem* self, Fraction* time_signature); +static void _model_bar_beat_time_system_on_time_signature_changed_model_tempo_information_time_signature_changed (ModelTempoInformation* _sender, Fraction* time_signature, gpointer self); +static void model_bar_beat_time_system_set_constants (ModelBarBeatTimeSystem* self); +ModelBarBeatTimeSystem* model_bar_beat_time_system_new (ModelTempoInformation* tempo_information); +ModelBarBeatTimeSystem* model_bar_beat_time_system_construct (GType object_type, ModelTempoInformation* tempo_information); +GType logging_facility_get_type (void); +GType logging_level_get_type (void); +void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message); +static gint model_bar_beat_time_system_real_correct_sub_second_value (ModelTimeSystemBase* base, float bars, gint div, gint unused); +static char* model_bar_beat_time_system_beats_to_string (ModelBarBeatTimeSystem* self, gint total_sixteenths, gboolean maximum_resolution, gboolean zero_based); +static char* model_bar_beat_time_system_real_get_time_string (ModelTimeSystem* base, gint64 the_time); +static char* model_bar_beat_time_system_real_get_time_duration (ModelTimeSystem* base, gint64 the_time); +static void model_bar_beat_time_system_real_calculate_pixel_step (ModelTimeSystem* base, float inc, float pixel_min, float pixel_div); +static gint model_bar_beat_time_system_real_frame_to_xsize (ModelTimeSystem* base, gint frame); +static gint model_bar_beat_time_system_real_xsize_to_frame (ModelTimeSystem* base, gint xsize); +static gint model_bar_beat_time_system_real_get_start_token (ModelTimeSystem* base, gint xsize); +static gint model_bar_beat_time_system_real_get_next_position (ModelTimeSystem* base, gint token); +static char* model_bar_beat_time_system_real_get_display_string (ModelTimeSystem* base, gint frame); +static gint model_bar_beat_time_system_real_get_pixel_height (ModelTimeSystem* base, gint frame); +static gint* _vala_array_dup1 (gint* self, int length); +static gint* model_bar_beat_time_system_real_get_timeline_seconds (ModelTimeSystemBase* base, int* result_length1); +static void model_bar_beat_time_system_finalize (GObject* obj); + + +static void g_cclosure_user_marshal_VOID__BOXED (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data); + +#line 12 "TimeSystem.vala" +void model_time_system_calculate_pixel_step (ModelTimeSystem* self, float inc, float pixel_min, float pixel_div) { +#line 12 "TimeSystem.vala" + MODEL_TIME_SYSTEM_GET_INTERFACE (self)->calculate_pixel_step (self, inc, pixel_min, pixel_div); +#line 305 "TimeSystem.c" +} + + +#line 13 "TimeSystem.vala" +gint64 model_time_system_xpos_to_time (ModelTimeSystem* self, gint x) { +#line 13 "TimeSystem.vala" + return MODEL_TIME_SYSTEM_GET_INTERFACE (self)->xpos_to_time (self, x); +#line 313 "TimeSystem.c" +} + + +#line 14 "TimeSystem.vala" +gint64 model_time_system_xsize_to_time (ModelTimeSystem* self, gint x) { +#line 14 "TimeSystem.vala" + return MODEL_TIME_SYSTEM_GET_INTERFACE (self)->xsize_to_time (self, x); +#line 321 "TimeSystem.c" +} + + +#line 15 "TimeSystem.vala" +gint model_time_system_time_to_xpos (ModelTimeSystem* self, gint64 time) { +#line 15 "TimeSystem.vala" + return MODEL_TIME_SYSTEM_GET_INTERFACE (self)->time_to_xpos (self, time); +#line 329 "TimeSystem.c" +} + + +#line 16 "TimeSystem.vala" +gint64 model_time_system_get_pixel_snap_time (ModelTimeSystem* self) { +#line 16 "TimeSystem.vala" + return MODEL_TIME_SYSTEM_GET_INTERFACE (self)->get_pixel_snap_time (self); +#line 337 "TimeSystem.c" +} + + +#line 17 "TimeSystem.vala" +gint model_time_system_time_to_xsize (ModelTimeSystem* self, gint64 time) { +#line 17 "TimeSystem.vala" + return MODEL_TIME_SYSTEM_GET_INTERFACE (self)->time_to_xsize (self, time); +#line 345 "TimeSystem.c" +} + + +#line 18 "TimeSystem.vala" +float model_time_system_get_pixel_percentage (ModelTimeSystem* self) { +#line 18 "TimeSystem.vala" + return MODEL_TIME_SYSTEM_GET_INTERFACE (self)->get_pixel_percentage (self); +#line 353 "TimeSystem.c" +} + + +#line 19 "TimeSystem.vala" +gint model_time_system_get_start_token (ModelTimeSystem* self, gint xsize) { +#line 19 "TimeSystem.vala" + return MODEL_TIME_SYSTEM_GET_INTERFACE (self)->get_start_token (self, xsize); +#line 361 "TimeSystem.c" +} + + +#line 20 "TimeSystem.vala" +gint model_time_system_get_next_position (ModelTimeSystem* self, gint token) { +#line 20 "TimeSystem.vala" + return MODEL_TIME_SYSTEM_GET_INTERFACE (self)->get_next_position (self, token); +#line 369 "TimeSystem.c" +} + + +#line 21 "TimeSystem.vala" +gint model_time_system_get_pixel_height (ModelTimeSystem* self, gint token) { +#line 21 "TimeSystem.vala" + return MODEL_TIME_SYSTEM_GET_INTERFACE (self)->get_pixel_height (self, token); +#line 377 "TimeSystem.c" +} + + +#line 22 "TimeSystem.vala" +char* model_time_system_get_display_string (ModelTimeSystem* self, gint token) { +#line 22 "TimeSystem.vala" + return MODEL_TIME_SYSTEM_GET_INTERFACE (self)->get_display_string (self, token); +#line 385 "TimeSystem.c" +} + + +#line 23 "TimeSystem.vala" +gint model_time_system_frame_to_xsize (ModelTimeSystem* self, gint frame) { +#line 23 "TimeSystem.vala" + return MODEL_TIME_SYSTEM_GET_INTERFACE (self)->frame_to_xsize (self, frame); +#line 393 "TimeSystem.c" +} + + +#line 24 "TimeSystem.vala" +gint model_time_system_xsize_to_frame (ModelTimeSystem* self, gint xsize) { +#line 24 "TimeSystem.vala" + return MODEL_TIME_SYSTEM_GET_INTERFACE (self)->xsize_to_frame (self, xsize); +#line 401 "TimeSystem.c" +} + + +#line 25 "TimeSystem.vala" +char* model_time_system_get_time_string (ModelTimeSystem* self, gint64 time) { +#line 25 "TimeSystem.vala" + return MODEL_TIME_SYSTEM_GET_INTERFACE (self)->get_time_string (self, time); +#line 409 "TimeSystem.c" +} + + +#line 26 "TimeSystem.vala" +char* model_time_system_get_time_duration (ModelTimeSystem* self, gint64 time) { +#line 26 "TimeSystem.vala" + return MODEL_TIME_SYSTEM_GET_INTERFACE (self)->get_time_duration (self, time); +#line 417 "TimeSystem.c" +} + + +static void model_time_system_base_init (ModelTimeSystemIface * iface) { + static gboolean initialized = FALSE; + if (!initialized) { + initialized = TRUE; + g_signal_new ("geometry_changed", MODEL_TYPE_TIME_SYSTEM, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); + } +} + + +GType model_time_system_get_type (void) { + static volatile gsize model_time_system_type_id__volatile = 0; + if (g_once_init_enter (&model_time_system_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelTimeSystemIface), (GBaseInitFunc) model_time_system_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL }; + GType model_time_system_type_id; + model_time_system_type_id = g_type_register_static (G_TYPE_INTERFACE, "ModelTimeSystem", &g_define_type_info, 0); + g_type_interface_add_prerequisite (model_time_system_type_id, G_TYPE_OBJECT); + g_once_init_leave (&model_time_system_type_id__volatile, model_time_system_type_id); + } + return model_time_system_type_id__volatile; +} + + +#line 39 "TimeSystem.vala" +static gint* model_time_system_base_real_get_timeline_seconds (ModelTimeSystemBase* self, int* result_length1) { +#line 445 "TimeSystem.c" + g_return_val_if_fail (MODEL_IS_TIME_SYSTEM_BASE (self), NULL); + g_critical ("Type `%s' does not implement abstract method `model_time_system_base_get_timeline_seconds'", g_type_name (G_TYPE_FROM_INSTANCE (self))); + return NULL; +} + + +#line 39 "TimeSystem.vala" +gint* model_time_system_base_get_timeline_seconds (ModelTimeSystemBase* self, int* result_length1) { +#line 39 "TimeSystem.vala" + return MODEL_TIME_SYSTEM_BASE_GET_CLASS (self)->get_timeline_seconds (self, result_length1); +#line 456 "TimeSystem.c" +} + + +#line 40 "TimeSystem.vala" +static gint model_time_system_base_real_correct_sub_second_value (ModelTimeSystemBase* self, float seconds, gint div, gint fps) { +#line 462 "TimeSystem.c" + g_return_val_if_fail (MODEL_IS_TIME_SYSTEM_BASE (self), 0); + g_critical ("Type `%s' does not implement abstract method `model_time_system_base_correct_sub_second_value'", g_type_name (G_TYPE_FROM_INSTANCE (self))); + return 0; +} + + +#line 40 "TimeSystem.vala" +gint model_time_system_base_correct_sub_second_value (ModelTimeSystemBase* self, float seconds, gint div, gint fps) { +#line 40 "TimeSystem.vala" + return MODEL_TIME_SYSTEM_BASE_GET_CLASS (self)->correct_sub_second_value (self, seconds, div, fps); +#line 473 "TimeSystem.c" +} + + +#line 42 "TimeSystem.vala" +gint model_time_system_base_correct_seconds_value (ModelTimeSystemBase* self, float seconds, gint div, gint fps) { +#line 479 "TimeSystem.c" + gint result = 0; + gint i = 0; + gint secs; + gint* _tmp1_; + gint _timeline_seconds_size_; + gint timeline_seconds_length1; + gint _tmp0_; + gint* timeline_seconds; +#line 42 "TimeSystem.vala" + g_return_val_if_fail (MODEL_IS_TIME_SYSTEM_BASE (self), 0); +#line 43 "TimeSystem.vala" + if (seconds < 1.0f) { +#line 492 "TimeSystem.c" + result = model_time_system_base_correct_sub_second_value (self, seconds, div, fps); +#line 44 "TimeSystem.vala" + return result; +#line 496 "TimeSystem.c" + } +#line 48 "TimeSystem.vala" + secs = (gint) seconds; +#line 500 "TimeSystem.c" + timeline_seconds = (_tmp1_ = model_time_system_base_get_timeline_seconds (self, &_tmp0_), timeline_seconds_length1 = _tmp0_, _timeline_seconds_size_ = timeline_seconds_length1, _tmp1_); + { + gboolean _tmp2_; +#line 50 "TimeSystem.vala" + i = timeline_seconds_length1 - 1; +#line 50 "TimeSystem.vala" + _tmp2_ = TRUE; +#line 50 "TimeSystem.vala" + while (TRUE) { +#line 510 "TimeSystem.c" + gboolean _tmp3_ = FALSE; +#line 50 "TimeSystem.vala" + if (!_tmp2_) { +#line 50 "TimeSystem.vala" + i--; +#line 516 "TimeSystem.c" + } +#line 50 "TimeSystem.vala" + _tmp2_ = FALSE; +#line 50 "TimeSystem.vala" + if (!(i > 0)) { +#line 50 "TimeSystem.vala" + break; +#line 524 "TimeSystem.c" + } +#line 51 "TimeSystem.vala" + if (secs <= timeline_seconds[i]) { +#line 52 "TimeSystem.vala" + _tmp3_ = secs >= timeline_seconds[i - 1]; +#line 530 "TimeSystem.c" + } else { +#line 51 "TimeSystem.vala" + _tmp3_ = FALSE; +#line 534 "TimeSystem.c" + } +#line 51 "TimeSystem.vala" + if (_tmp3_) { +#line 53 "TimeSystem.vala" + if ((div % (timeline_seconds[i] * fps)) == 0) { +#line 54 "TimeSystem.vala" + break; +#line 542 "TimeSystem.c" + } +#line 56 "TimeSystem.vala" + if ((div % (timeline_seconds[i - 1] * fps)) == 0) { +#line 57 "TimeSystem.vala" + i--; +#line 58 "TimeSystem.vala" + break; +#line 550 "TimeSystem.c" + } + } + } + } + result = timeline_seconds[i] * fps; + timeline_seconds = (g_free (timeline_seconds), NULL); +#line 62 "TimeSystem.vala" + return result; +#line 559 "TimeSystem.c" +} + + +#line 65 "TimeSystem.vala" +gint64 model_time_system_base_get_pixel_snap_time (ModelTimeSystemBase* self) { +#line 565 "TimeSystem.c" + gint64 result = 0LL; +#line 65 "TimeSystem.vala" + g_return_val_if_fail (MODEL_IS_TIME_SYSTEM_BASE (self), 0LL); +#line 569 "TimeSystem.c" + result = self->pixel_snap_time; +#line 66 "TimeSystem.vala" + return result; +#line 573 "TimeSystem.c" +} + + +#line 69 "TimeSystem.vala" +float model_time_system_base_get_pixel_percentage (ModelTimeSystemBase* self) { +#line 579 "TimeSystem.c" + float result = 0.0F; +#line 69 "TimeSystem.vala" + g_return_val_if_fail (MODEL_IS_TIME_SYSTEM_BASE (self), 0.0F); +#line 583 "TimeSystem.c" + result = self->pixel_percentage; +#line 70 "TimeSystem.vala" + return result; +#line 587 "TimeSystem.c" +} + + +#line 73 "TimeSystem.vala" +gint64 model_time_system_base_xpos_to_time (ModelTimeSystemBase* self, gint x) { +#line 593 "TimeSystem.c" + gint64 result = 0LL; +#line 73 "TimeSystem.vala" + g_return_val_if_fail (MODEL_IS_TIME_SYSTEM_BASE (self), 0LL); +#line 597 "TimeSystem.c" + result = model_time_system_base_xsize_to_time (self, x - MODEL_TIME_SYSTEM_BASE_BORDER); +#line 74 "TimeSystem.vala" + return result; +#line 601 "TimeSystem.c" +} + + +#line 77 "TimeSystem.vala" +gint64 model_time_system_base_xsize_to_time (ModelTimeSystemBase* self, gint size) { +#line 607 "TimeSystem.c" + gint64 result = 0LL; +#line 77 "TimeSystem.vala" + g_return_val_if_fail (MODEL_IS_TIME_SYSTEM_BASE (self), 0LL); +#line 611 "TimeSystem.c" + result = (gint64) (((float) (size * GST_SECOND)) / self->pixels_per_second); +#line 78 "TimeSystem.vala" + return result; +#line 615 "TimeSystem.c" +} + + +#line 81 "TimeSystem.vala" +gint model_time_system_base_time_to_xsize (ModelTimeSystemBase* self, gint64 time) { +#line 621 "TimeSystem.c" + gint result = 0; +#line 81 "TimeSystem.vala" + g_return_val_if_fail (MODEL_IS_TIME_SYSTEM_BASE (self), 0); +#line 625 "TimeSystem.c" + result = (gint) ((time * self->pixels_per_second) / GST_SECOND); +#line 82 "TimeSystem.vala" + return result; +#line 629 "TimeSystem.c" +} + + +#line 85 "TimeSystem.vala" +gint model_time_system_base_time_to_xpos (ModelTimeSystemBase* self, gint64 time) { +#line 635 "TimeSystem.c" + gint result = 0; + gint pos; +#line 85 "TimeSystem.vala" + g_return_val_if_fail (MODEL_IS_TIME_SYSTEM_BASE (self), 0); +#line 86 "TimeSystem.vala" + pos = model_time_system_base_time_to_xsize (self, time) + MODEL_TIME_SYSTEM_BASE_BORDER; +#line 88 "TimeSystem.vala" + if (model_time_system_base_xpos_to_time (self, pos) != time) { +#line 89 "TimeSystem.vala" + pos++; +#line 646 "TimeSystem.c" + } + result = pos; +#line 90 "TimeSystem.vala" + return result; +#line 651 "TimeSystem.c" +} + + +#line 29 "TimeSystem.vala" +ModelTimeSystemBase* model_time_system_base_construct (GType object_type) { +#line 657 "TimeSystem.c" + ModelTimeSystemBase * self; +#line 29 "TimeSystem.vala" + self = (ModelTimeSystemBase*) g_object_new (object_type, NULL); +#line 661 "TimeSystem.c" + return self; +} + + +static void model_time_system_base_class_init (ModelTimeSystemBaseClass * klass) { + model_time_system_base_parent_class = g_type_class_peek_parent (klass); + MODEL_TIME_SYSTEM_BASE_CLASS (klass)->get_timeline_seconds = model_time_system_base_real_get_timeline_seconds; + MODEL_TIME_SYSTEM_BASE_CLASS (klass)->correct_sub_second_value = model_time_system_base_real_correct_sub_second_value; + G_OBJECT_CLASS (klass)->finalize = model_time_system_base_finalize; +} + + +static void model_time_system_base_instance_init (ModelTimeSystemBase * self) { + self->pixel_percentage = 0.0f; +} + + +static void model_time_system_base_finalize (GObject* obj) { + ModelTimeSystemBase * self; + self = MODEL_TIME_SYSTEM_BASE (obj); + G_OBJECT_CLASS (model_time_system_base_parent_class)->finalize (obj); +} + + +GType model_time_system_base_get_type (void) { + static volatile gsize model_time_system_base_type_id__volatile = 0; + if (g_once_init_enter (&model_time_system_base_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelTimeSystemBaseClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_time_system_base_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelTimeSystemBase), 0, (GInstanceInitFunc) model_time_system_base_instance_init, NULL }; + GType model_time_system_base_type_id; + model_time_system_base_type_id = g_type_register_static (G_TYPE_OBJECT, "ModelTimeSystemBase", &g_define_type_info, G_TYPE_FLAG_ABSTRACT); + g_once_init_leave (&model_time_system_base_type_id__volatile, model_time_system_base_type_id); + } + return model_time_system_base_type_id__volatile; +} + + +#line 103 "TimeSystem.vala" +static gint model_timecode_time_system_real_correct_sub_second_value (ModelTimeSystemBase* base, float seconds, gint div, gint fps) { +#line 700 "TimeSystem.c" + ModelTimecodeTimeSystem * self; + gint result = 0; + gint frames; + gint mod; + self = MODEL_TIMECODE_TIME_SYSTEM (base); +#line 104 "TimeSystem.vala" + frames = (gint) (fps * seconds); +#line 105 "TimeSystem.vala" + if (frames == 0) { +#line 710 "TimeSystem.c" + result = 1; +#line 106 "TimeSystem.vala" + return result; +#line 714 "TimeSystem.c" + } +#line 109 "TimeSystem.vala" + if (div == 0) { +#line 110 "TimeSystem.vala" + div = fps; +#line 720 "TimeSystem.c" + } +#line 113 "TimeSystem.vala" + mod = div % frames; +#line 114 "TimeSystem.vala" + while (TRUE) { +#line 114 "TimeSystem.vala" + if (!(mod != 0)) { +#line 114 "TimeSystem.vala" + break; +#line 730 "TimeSystem.c" + } +#line 115 "TimeSystem.vala" + mod = div % (frames = frames + 1); +#line 734 "TimeSystem.c" + } + result = frames; +#line 117 "TimeSystem.vala" + return result; +#line 739 "TimeSystem.c" +} + + +#line 120 "TimeSystem.vala" +static char* model_timecode_time_system_real_get_time_string (ModelTimeSystem* base, gint64 the_time) { +#line 745 "TimeSystem.c" + ModelTimecodeTimeSystem * self; + char* result = NULL; + char* time; + gint frame; + char* _tmp0_; + self = MODEL_TIMECODE_TIME_SYSTEM (base); + time = NULL; +#line 123 "TimeSystem.vala" + frame = time_to_frame_with_rate (the_time, &self->frame_rate_fraction); +#line 124 "TimeSystem.vala" + time = (_tmp0_ = frame_to_string (frame, &self->frame_rate_fraction), _g_free0 (time), _tmp0_); +#line 757 "TimeSystem.c" + result = time; +#line 126 "TimeSystem.vala" + return result; +#line 761 "TimeSystem.c" +} + + +#line 129 "TimeSystem.vala" +static char* model_timecode_time_system_real_get_time_duration (ModelTimeSystem* base, gint64 the_time) { +#line 767 "TimeSystem.c" + ModelTimecodeTimeSystem * self; + char* result = NULL; + self = MODEL_TIMECODE_TIME_SYSTEM (base); + result = model_time_system_get_time_string (MODEL_TIME_SYSTEM (self), the_time); +#line 131 "TimeSystem.vala" + return result; +#line 774 "TimeSystem.c" +} + + +#line 133 "TimeSystem.vala" +static void model_timecode_time_system_real_calculate_pixel_step (ModelTimeSystem* base, float inc, float pixel_min, float pixel_div) { +#line 780 "TimeSystem.c" + ModelTimecodeTimeSystem * self; + gint pixels_per_large; + gint pixels_per_medium; + gint pixels_per_small; + gint fps; + self = MODEL_TIMECODE_TIME_SYSTEM (base); +#line 134 "TimeSystem.vala" + pixels_per_large = 300; +#line 135 "TimeSystem.vala" + pixels_per_medium = 50; +#line 136 "TimeSystem.vala" + pixels_per_small = 20; +#line 138 "TimeSystem.vala" + MODEL_TIME_SYSTEM_BASE (self)->pixel_percentage = MODEL_TIME_SYSTEM_BASE (self)->pixel_percentage + inc; +#line 139 "TimeSystem.vala" + if (MODEL_TIME_SYSTEM_BASE (self)->pixel_percentage < 0.0f) { +#line 140 "TimeSystem.vala" + MODEL_TIME_SYSTEM_BASE (self)->pixel_percentage = 0.0f; +#line 799 "TimeSystem.c" + } else { +#line 141 "TimeSystem.vala" + if (MODEL_TIME_SYSTEM_BASE (self)->pixel_percentage > 1.0f) { +#line 142 "TimeSystem.vala" + MODEL_TIME_SYSTEM_BASE (self)->pixel_percentage = 1.0f; +#line 805 "TimeSystem.c" + } + } +#line 144 "TimeSystem.vala" + MODEL_TIME_SYSTEM_BASE (self)->pixels_per_second = pixel_min * powf (pixel_div, MODEL_TIME_SYSTEM_BASE (self)->pixel_percentage); +#line 145 "TimeSystem.vala" + fps = fraction_nearest_int (&self->frame_rate_fraction); +#line 146 "TimeSystem.vala" + self->priv->large_pixel_frames = model_time_system_base_correct_seconds_value (MODEL_TIME_SYSTEM_BASE (self), pixels_per_large / MODEL_TIME_SYSTEM_BASE (self)->pixels_per_second, 0, fps); +#line 147 "TimeSystem.vala" + self->priv->medium_pixel_frames = model_time_system_base_correct_seconds_value (MODEL_TIME_SYSTEM_BASE (self), pixels_per_medium / MODEL_TIME_SYSTEM_BASE (self)->pixels_per_second, self->priv->large_pixel_frames, fps); +#line 149 "TimeSystem.vala" + self->priv->small_pixel_frames = model_time_system_base_correct_seconds_value (MODEL_TIME_SYSTEM_BASE (self), pixels_per_small / MODEL_TIME_SYSTEM_BASE (self)->pixels_per_second, self->priv->medium_pixel_frames, fps); +#line 152 "TimeSystem.vala" + if (self->priv->small_pixel_frames == self->priv->medium_pixel_frames) { +#line 820 "TimeSystem.c" + gint i; +#line 153 "TimeSystem.vala" + i = self->priv->medium_pixel_frames; +#line 155 "TimeSystem.vala" + while (TRUE) { +#line 155 "TimeSystem.vala" + if (!((i = i - 1) > 0)) { +#line 155 "TimeSystem.vala" + break; +#line 830 "TimeSystem.c" + } +#line 156 "TimeSystem.vala" + if ((self->priv->medium_pixel_frames % i) == 0) { +#line 157 "TimeSystem.vala" + self->priv->small_pixel_frames = i; +#line 158 "TimeSystem.vala" + break; +#line 838 "TimeSystem.c" + } + } + } +#line 163 "TimeSystem.vala" + self->priv->pixels_per_frame = MODEL_TIME_SYSTEM_BASE (self)->pixels_per_second / ((float) fps); +#line 164 "TimeSystem.vala" + MODEL_TIME_SYSTEM_BASE (self)->pixel_snap_time = model_time_system_xsize_to_time (MODEL_TIME_SYSTEM (self), MODEL_TIME_SYSTEM_BASE_PIXEL_SNAP_INTERVAL); +#line 846 "TimeSystem.c" +} + + +#line 167 "TimeSystem.vala" +static gint model_timecode_time_system_real_frame_to_xsize (ModelTimeSystem* base, gint frame) { +#line 852 "TimeSystem.c" + ModelTimecodeTimeSystem * self; + gint result = 0; + self = MODEL_TIMECODE_TIME_SYSTEM (base); + result = (gint) (frame * self->priv->pixels_per_frame); +#line 168 "TimeSystem.vala" + return result; +#line 859 "TimeSystem.c" +} + + +#line 171 "TimeSystem.vala" +static gint model_timecode_time_system_real_xsize_to_frame (ModelTimeSystem* base, gint xsize) { +#line 865 "TimeSystem.c" + ModelTimecodeTimeSystem * self; + gint result = 0; + self = MODEL_TIMECODE_TIME_SYSTEM (base); + result = (gint) (xsize / self->priv->pixels_per_frame); +#line 172 "TimeSystem.vala" + return result; +#line 872 "TimeSystem.c" +} + + +#line 175 "TimeSystem.vala" +static gint model_timecode_time_system_real_get_start_token (ModelTimeSystem* base, gint xsize) { +#line 878 "TimeSystem.c" + ModelTimecodeTimeSystem * self; + gint result = 0; + gint start_frame; + self = MODEL_TIMECODE_TIME_SYSTEM (base); +#line 176 "TimeSystem.vala" + start_frame = model_time_system_xsize_to_frame (MODEL_TIME_SYSTEM (self), xsize); +#line 885 "TimeSystem.c" + result = self->priv->large_pixel_frames * (start_frame / self->priv->large_pixel_frames); +#line 177 "TimeSystem.vala" + return result; +#line 889 "TimeSystem.c" +} + + +#line 180 "TimeSystem.vala" +static gint model_timecode_time_system_real_get_next_position (ModelTimeSystem* base, gint token) { +#line 895 "TimeSystem.c" + ModelTimecodeTimeSystem * self; + gint result = 0; + self = MODEL_TIMECODE_TIME_SYSTEM (base); + result = token + self->priv->small_pixel_frames; +#line 181 "TimeSystem.vala" + return result; +#line 902 "TimeSystem.c" +} + + +#line 184 "TimeSystem.vala" +static char* model_timecode_time_system_real_get_display_string (ModelTimeSystem* base, gint frame) { +#line 908 "TimeSystem.c" + ModelTimecodeTimeSystem * self; + char* result = NULL; + self = MODEL_TIMECODE_TIME_SYSTEM (base); +#line 185 "TimeSystem.vala" + if ((frame % self->priv->large_pixel_frames) == 0) { +#line 914 "TimeSystem.c" + TimeCode _tmp1_; + TimeCode _tmp0_ = {0}; + result = time_code_to_string ((_tmp1_ = (frame_to_time (frame, &self->frame_rate_fraction, &_tmp0_), _tmp0_), &_tmp1_)); +#line 186 "TimeSystem.vala" + return result; +#line 920 "TimeSystem.c" + } + result = NULL; +#line 188 "TimeSystem.vala" + return result; +#line 925 "TimeSystem.c" +} + + +#line 191 "TimeSystem.vala" +static gint model_timecode_time_system_real_get_pixel_height (ModelTimeSystem* base, gint frame) { +#line 931 "TimeSystem.c" + ModelTimecodeTimeSystem * self; + gint result = 0; + self = MODEL_TIMECODE_TIME_SYSTEM (base); +#line 192 "TimeSystem.vala" + if ((frame % self->priv->medium_pixel_frames) == 0) { +#line 937 "TimeSystem.c" + gboolean _tmp0_ = FALSE; +#line 193 "TimeSystem.vala" + if (self->priv->medium_pixel_frames == self->priv->small_pixel_frames) { +#line 941 "TimeSystem.c" + gboolean _tmp1_ = FALSE; +#line 194 "TimeSystem.vala" + if (self->priv->medium_pixel_frames != self->priv->large_pixel_frames) { +#line 195 "TimeSystem.vala" + _tmp1_ = (frame % self->priv->large_pixel_frames) != 0; +#line 947 "TimeSystem.c" + } else { +#line 194 "TimeSystem.vala" + _tmp1_ = FALSE; +#line 951 "TimeSystem.c" + } +#line 194 "TimeSystem.vala" + _tmp0_ = _tmp1_; +#line 955 "TimeSystem.c" + } else { +#line 193 "TimeSystem.vala" + _tmp0_ = FALSE; +#line 959 "TimeSystem.c" + } +#line 193 "TimeSystem.vala" + if (_tmp0_) { +#line 963 "TimeSystem.c" + result = 2; +#line 196 "TimeSystem.vala" + return result; +#line 967 "TimeSystem.c" + } else { + result = 6; +#line 199 "TimeSystem.vala" + return result; +#line 972 "TimeSystem.c" + } + } else { + result = 2; +#line 202 "TimeSystem.vala" + return result; +#line 978 "TimeSystem.c" + } +} + + +#line 206 "TimeSystem.vala" +static gint* model_timecode_time_system_real_get_timeline_seconds (ModelTimeSystemBase* base, int* result_length1) { +#line 985 "TimeSystem.c" + ModelTimecodeTimeSystem * self; + gint* result = NULL; + gint* _tmp0_ = NULL; + gint* _tmp1_; + self = MODEL_TIMECODE_TIME_SYSTEM (base); + result = (_tmp1_ = (_tmp0_ = g_new0 (gint, 15), _tmp0_[0] = 1, _tmp0_[1] = 2, _tmp0_[2] = 5, _tmp0_[3] = 10, _tmp0_[4] = 15, _tmp0_[5] = 20, _tmp0_[6] = 30, _tmp0_[7] = 60, _tmp0_[8] = 120, _tmp0_[9] = 300, _tmp0_[10] = 600, _tmp0_[11] = 900, _tmp0_[12] = 1200, _tmp0_[13] = 1800, _tmp0_[14] = 3600, _tmp0_), *result_length1 = 15, _tmp1_); +#line 207 "TimeSystem.vala" + return result; +#line 994 "TimeSystem.c" +} + + +#line 94 "TimeSystem.vala" +ModelTimecodeTimeSystem* model_timecode_time_system_construct (GType object_type) { +#line 1000 "TimeSystem.c" + ModelTimecodeTimeSystem * self; +#line 94 "TimeSystem.vala" + self = (ModelTimecodeTimeSystem*) model_time_system_base_construct (object_type); +#line 1004 "TimeSystem.c" + return self; +} + + +#line 94 "TimeSystem.vala" +ModelTimecodeTimeSystem* model_timecode_time_system_new (void) { +#line 94 "TimeSystem.vala" + return model_timecode_time_system_construct (MODEL_TYPE_TIMECODE_TIME_SYSTEM); +#line 1013 "TimeSystem.c" +} + + +static void model_timecode_time_system_class_init (ModelTimecodeTimeSystemClass * klass) { + model_timecode_time_system_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ModelTimecodeTimeSystemPrivate)); + MODEL_TIME_SYSTEM_BASE_CLASS (klass)->correct_sub_second_value = model_timecode_time_system_real_correct_sub_second_value; + MODEL_TIME_SYSTEM_BASE_CLASS (klass)->get_timeline_seconds = model_timecode_time_system_real_get_timeline_seconds; + G_OBJECT_CLASS (klass)->finalize = model_timecode_time_system_finalize; +} + + +static void model_timecode_time_system_model_time_system_interface_init (ModelTimeSystemIface * iface) { + model_timecode_time_system_model_time_system_parent_iface = g_type_interface_peek_parent (iface); + iface->get_time_string = model_timecode_time_system_real_get_time_string; + iface->get_time_duration = model_timecode_time_system_real_get_time_duration; + iface->calculate_pixel_step = model_timecode_time_system_real_calculate_pixel_step; + iface->frame_to_xsize = model_timecode_time_system_real_frame_to_xsize; + iface->xsize_to_frame = model_timecode_time_system_real_xsize_to_frame; + iface->get_start_token = model_timecode_time_system_real_get_start_token; + iface->get_next_position = model_timecode_time_system_real_get_next_position; + iface->get_display_string = model_timecode_time_system_real_get_display_string; + iface->get_pixel_height = model_timecode_time_system_real_get_pixel_height; + iface->xpos_to_time = (gint64 (*)(ModelTimeSystem* ,gint)) model_time_system_base_xpos_to_time; + iface->xsize_to_time = (gint64 (*)(ModelTimeSystem* ,gint)) model_time_system_base_xsize_to_time; + iface->time_to_xpos = (gint (*)(ModelTimeSystem* ,gint64)) model_time_system_base_time_to_xpos; + iface->get_pixel_snap_time = (gint64 (*)(ModelTimeSystem*)) model_time_system_base_get_pixel_snap_time; + iface->time_to_xsize = (gint (*)(ModelTimeSystem* ,gint64)) model_time_system_base_time_to_xsize; + iface->get_pixel_percentage = (float (*)(ModelTimeSystem*)) model_time_system_base_get_pixel_percentage; +} + + +static void model_timecode_time_system_instance_init (ModelTimecodeTimeSystem * self) { + Fraction _tmp0_ = {0}; + self->priv = MODEL_TIMECODE_TIME_SYSTEM_GET_PRIVATE (self); + self->priv->small_pixel_frames = 0; + self->priv->medium_pixel_frames = 0; + self->priv->large_pixel_frames = 0; + self->frame_rate_fraction = (fraction_init (&_tmp0_, 30000, 1001), _tmp0_); +} + + +static void model_timecode_time_system_finalize (GObject* obj) { + ModelTimecodeTimeSystem * self; + self = MODEL_TIMECODE_TIME_SYSTEM (obj); + G_OBJECT_CLASS (model_timecode_time_system_parent_class)->finalize (obj); +} + + +GType model_timecode_time_system_get_type (void) { + static volatile gsize model_timecode_time_system_type_id__volatile = 0; + if (g_once_init_enter (&model_timecode_time_system_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelTimecodeTimeSystemClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_timecode_time_system_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelTimecodeTimeSystem), 0, (GInstanceInitFunc) model_timecode_time_system_instance_init, NULL }; + static const GInterfaceInfo model_time_system_info = { (GInterfaceInitFunc) model_timecode_time_system_model_time_system_interface_init, (GInterfaceFinalizeFunc) NULL, NULL}; + GType model_timecode_time_system_type_id; + model_timecode_time_system_type_id = g_type_register_static (MODEL_TYPE_TIME_SYSTEM_BASE, "ModelTimecodeTimeSystem", &g_define_type_info, 0); + g_type_add_interface_static (model_timecode_time_system_type_id, MODEL_TYPE_TIME_SYSTEM, &model_time_system_info); + g_once_init_leave (&model_timecode_time_system_type_id__volatile, model_timecode_time_system_type_id); + } + return model_timecode_time_system_type_id__volatile; +} + + +#line 212 "TimeSystem.vala" +void model_tempo_information_get_time_signature (ModelTempoInformation* self, Fraction* result) { +#line 212 "TimeSystem.vala" + MODEL_TEMPO_INFORMATION_GET_INTERFACE (self)->get_time_signature (self, result); +#line 1081 "TimeSystem.c" +} + + +#line 213 "TimeSystem.vala" +gint model_tempo_information_get_bpm (ModelTempoInformation* self) { +#line 213 "TimeSystem.vala" + return MODEL_TEMPO_INFORMATION_GET_INTERFACE (self)->get_bpm (self); +#line 1089 "TimeSystem.c" +} + + +static void model_tempo_information_base_init (ModelTempoInformationIface * iface) { + static gboolean initialized = FALSE; + if (!initialized) { + initialized = TRUE; + g_signal_new ("time_signature_changed", MODEL_TYPE_TEMPO_INFORMATION, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__BOXED, G_TYPE_NONE, 1, TYPE_FRACTION); + g_signal_new ("bpm_changed", MODEL_TYPE_TEMPO_INFORMATION, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT); + } +} + + +GType model_tempo_information_get_type (void) { + static volatile gsize model_tempo_information_type_id__volatile = 0; + if (g_once_init_enter (&model_tempo_information_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelTempoInformationIface), (GBaseInitFunc) model_tempo_information_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL }; + GType model_tempo_information_type_id; + model_tempo_information_type_id = g_type_register_static (G_TYPE_INTERFACE, "ModelTempoInformation", &g_define_type_info, 0); + g_once_init_leave (&model_tempo_information_type_id__volatile, model_tempo_information_type_id); + } + return model_tempo_information_type_id__volatile; +} + + +#line 249 "TimeSystem.vala" +static void _model_bar_beat_time_system_on_bpm_changed_model_tempo_information_bpm_changed (ModelTempoInformation* _sender, gint bpm, gpointer self) { +#line 1117 "TimeSystem.c" + model_bar_beat_time_system_on_bpm_changed (self, bpm); +} + + +#line 243 "TimeSystem.vala" +static void _model_bar_beat_time_system_on_time_signature_changed_model_tempo_information_time_signature_changed (ModelTempoInformation* _sender, Fraction* time_signature, gpointer self) { +#line 1124 "TimeSystem.c" + model_bar_beat_time_system_on_time_signature_changed (self, time_signature); +} + + +#line 235 "TimeSystem.vala" +ModelBarBeatTimeSystem* model_bar_beat_time_system_construct (GType object_type, ModelTempoInformation* tempo_information) { +#line 1131 "TimeSystem.c" + ModelBarBeatTimeSystem * self; + Fraction _tmp0_ = {0}; +#line 235 "TimeSystem.vala" + g_return_val_if_fail (MODEL_IS_TEMPO_INFORMATION (tempo_information), NULL); +#line 235 "TimeSystem.vala" + self = (ModelBarBeatTimeSystem*) model_time_system_base_construct (object_type); +#line 236 "TimeSystem.vala" + self->priv->bpm = model_tempo_information_get_bpm (tempo_information); +#line 237 "TimeSystem.vala" + self->priv->time_signature = (model_tempo_information_get_time_signature (tempo_information, &_tmp0_), _tmp0_); +#line 238 "TimeSystem.vala" + g_signal_connect_object (tempo_information, "bpm-changed", (GCallback) _model_bar_beat_time_system_on_bpm_changed_model_tempo_information_bpm_changed, self, 0); +#line 239 "TimeSystem.vala" + g_signal_connect_object (tempo_information, "time-signature-changed", (GCallback) _model_bar_beat_time_system_on_time_signature_changed_model_tempo_information_time_signature_changed, self, 0); +#line 240 "TimeSystem.vala" + model_bar_beat_time_system_set_constants (self); +#line 1148 "TimeSystem.c" + return self; +} + + +#line 235 "TimeSystem.vala" +ModelBarBeatTimeSystem* model_bar_beat_time_system_new (ModelTempoInformation* tempo_information) { +#line 235 "TimeSystem.vala" + return model_bar_beat_time_system_construct (MODEL_TYPE_BAR_BEAT_TIME_SYSTEM, tempo_information); +#line 1157 "TimeSystem.c" +} + + +#line 243 "TimeSystem.vala" +static void model_bar_beat_time_system_on_time_signature_changed (ModelBarBeatTimeSystem* self, Fraction* time_signature) { +#line 243 "TimeSystem.vala" + g_return_if_fail (MODEL_IS_BAR_BEAT_TIME_SYSTEM (self)); +#line 244 "TimeSystem.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_time_signature_changed"); +#line 245 "TimeSystem.vala" + self->priv->time_signature = *time_signature; +#line 246 "TimeSystem.vala" + model_bar_beat_time_system_set_constants (self); +#line 1171 "TimeSystem.c" +} + + +#line 249 "TimeSystem.vala" +static void model_bar_beat_time_system_on_bpm_changed (ModelBarBeatTimeSystem* self, gint bpm) { +#line 249 "TimeSystem.vala" + g_return_if_fail (MODEL_IS_BAR_BEAT_TIME_SYSTEM (self)); +#line 250 "TimeSystem.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_bpm_changed"); +#line 251 "TimeSystem.vala" + self->priv->bpm = bpm; +#line 252 "TimeSystem.vala" + model_bar_beat_time_system_set_constants (self); +#line 1185 "TimeSystem.c" +} + + +#line 255 "TimeSystem.vala" +static void model_bar_beat_time_system_set_constants (ModelBarBeatTimeSystem* self) { +#line 255 "TimeSystem.vala" + g_return_if_fail (MODEL_IS_BAR_BEAT_TIME_SYSTEM (self)); +#line 256 "TimeSystem.vala" + self->priv->bars_per_minute = self->priv->bpm / ((float) self->priv->time_signature.numerator); +#line 257 "TimeSystem.vala" + self->priv->bars_per_second = self->priv->bars_per_minute / 60.0f; +#line 259 "TimeSystem.vala" + self->priv->sixteenths_per_beat = 16 / self->priv->time_signature.denominator; +#line 260 "TimeSystem.vala" + self->priv->sixteenths_per_bar = self->priv->time_signature.numerator * self->priv->sixteenths_per_beat; +#line 261 "TimeSystem.vala" + g_signal_emit_by_name (MODEL_TIME_SYSTEM (self), "geometry-changed"); +#line 1203 "TimeSystem.c" +} + + +#line 264 "TimeSystem.vala" +static gint model_bar_beat_time_system_real_correct_sub_second_value (ModelTimeSystemBase* base, float bars, gint div, gint unused) { +#line 1209 "TimeSystem.c" + ModelBarBeatTimeSystem * self; + gint result = 0; + gint sixteenths; + self = MODEL_BAR_BEAT_TIME_SYSTEM (base); +#line 265 "TimeSystem.vala" + sixteenths = (gint) (self->priv->sixteenths_per_bar * bars); +#line 267 "TimeSystem.vala" + if (sixteenths == 0) { +#line 1218 "TimeSystem.c" + result = 1; +#line 268 "TimeSystem.vala" + return result; +#line 1222 "TimeSystem.c" + } +#line 271 "TimeSystem.vala" + if (sixteenths > self->priv->sixteenths_per_beat) { +#line 1226 "TimeSystem.c" + result = self->priv->sixteenths_per_beat; +#line 272 "TimeSystem.vala" + return result; +#line 1230 "TimeSystem.c" + } +#line 275 "TimeSystem.vala" + if (sixteenths > 2) { +#line 1234 "TimeSystem.c" + result = 2; +#line 276 "TimeSystem.vala" + return result; +#line 1238 "TimeSystem.c" + } + result = 1; +#line 279 "TimeSystem.vala" + return result; +#line 1243 "TimeSystem.c" +} + + +#line 282 "TimeSystem.vala" +static char* model_bar_beat_time_system_beats_to_string (ModelBarBeatTimeSystem* self, gint total_sixteenths, gboolean maximum_resolution, gboolean zero_based) { +#line 1249 "TimeSystem.c" + char* result = NULL; + gint number_of_measures; + gint number_of_beats; + gint number_of_sixteenths; + float pixels_per_bar; + float pixels_per_large_gap; + gboolean _tmp0_ = FALSE; +#line 282 "TimeSystem.vala" + g_return_val_if_fail (MODEL_IS_BAR_BEAT_TIME_SYSTEM (self), NULL); +#line 284 "TimeSystem.vala" + number_of_measures = (total_sixteenths / self->priv->sixteenths_per_beat) / self->priv->time_signature.numerator; +#line 287 "TimeSystem.vala" + number_of_beats = (total_sixteenths / self->priv->sixteenths_per_beat) % self->priv->time_signature.numerator; +#line 288 "TimeSystem.vala" + number_of_sixteenths = total_sixteenths % self->priv->sixteenths_per_beat; +#line 289 "TimeSystem.vala" + if (!zero_based) { +#line 290 "TimeSystem.vala" + number_of_measures = number_of_measures + 1; +#line 291 "TimeSystem.vala" + number_of_beats = number_of_beats + 1; +#line 292 "TimeSystem.vala" + number_of_sixteenths = number_of_sixteenths + 1; +#line 1273 "TimeSystem.c" + } +#line 294 "TimeSystem.vala" + pixels_per_bar = MODEL_TIME_SYSTEM_BASE (self)->pixels_per_second / self->priv->bars_per_second; +#line 295 "TimeSystem.vala" + pixels_per_large_gap = self->priv->large_pixel_sixteenth * self->priv->pixels_per_sixteenth; +#line 296 "TimeSystem.vala" + if (maximum_resolution) { +#line 296 "TimeSystem.vala" + _tmp0_ = TRUE; +#line 1283 "TimeSystem.c" + } else { + gboolean _tmp1_ = FALSE; +#line 297 "TimeSystem.vala" + if (pixels_per_large_gap < (self->priv->pixels_per_sixteenth * self->priv->sixteenths_per_beat)) { +#line 298 "TimeSystem.vala" + _tmp1_ = number_of_sixteenths > 1; +#line 1290 "TimeSystem.c" + } else { +#line 297 "TimeSystem.vala" + _tmp1_ = FALSE; +#line 1294 "TimeSystem.c" + } +#line 297 "TimeSystem.vala" + _tmp0_ = _tmp1_; +#line 1298 "TimeSystem.c" + } +#line 296 "TimeSystem.vala" + if (_tmp0_) { +#line 1302 "TimeSystem.c" + result = g_strdup_printf ("%d.%d.%d", number_of_measures, number_of_beats, number_of_sixteenths); +#line 299 "TimeSystem.vala" + return result; +#line 1306 "TimeSystem.c" + } else { + gboolean _tmp2_ = FALSE; +#line 300 "TimeSystem.vala" + if (pixels_per_large_gap < pixels_per_bar) { +#line 300 "TimeSystem.vala" + _tmp2_ = number_of_beats > 1; +#line 1313 "TimeSystem.c" + } else { +#line 300 "TimeSystem.vala" + _tmp2_ = FALSE; +#line 1317 "TimeSystem.c" + } +#line 300 "TimeSystem.vala" + if (_tmp2_) { +#line 1321 "TimeSystem.c" + result = g_strdup_printf ("%d.%d", number_of_measures, number_of_beats); +#line 301 "TimeSystem.vala" + return result; +#line 1325 "TimeSystem.c" + } else { + result = g_strdup_printf ("%d", number_of_measures); +#line 303 "TimeSystem.vala" + return result; +#line 1330 "TimeSystem.c" + } + } +} + + +#line 307 "TimeSystem.vala" +static char* model_bar_beat_time_system_real_get_time_string (ModelTimeSystem* base, gint64 the_time) { +#line 1338 "TimeSystem.c" + ModelBarBeatTimeSystem * self; + char* result = NULL; + double beats_per_second; + double sixteenths_per_second; + double sixteenths_per_nanosecond; + gint total_beats; + self = MODEL_BAR_BEAT_TIME_SYSTEM (base); +#line 308 "TimeSystem.vala" + beats_per_second = self->priv->bpm / 60.0; +#line 309 "TimeSystem.vala" + sixteenths_per_second = self->priv->sixteenths_per_beat * beats_per_second; +#line 310 "TimeSystem.vala" + sixteenths_per_nanosecond = sixteenths_per_second / GST_SECOND; +#line 311 "TimeSystem.vala" + total_beats = (gint) (the_time * sixteenths_per_nanosecond); +#line 1354 "TimeSystem.c" + result = model_bar_beat_time_system_beats_to_string (self, total_beats, TRUE, FALSE); +#line 312 "TimeSystem.vala" + return result; +#line 1358 "TimeSystem.c" +} + + +#line 315 "TimeSystem.vala" +static char* model_bar_beat_time_system_real_get_time_duration (ModelTimeSystem* base, gint64 the_time) { +#line 1364 "TimeSystem.c" + ModelBarBeatTimeSystem * self; + char* result = NULL; + double beats_per_second; + double sixteenths_per_second; + double sixteenths_per_nanosecond; + gint total_beats; + gboolean _tmp0_ = FALSE; + self = MODEL_BAR_BEAT_TIME_SYSTEM (base); +#line 316 "TimeSystem.vala" + beats_per_second = self->priv->bpm / 60.0; +#line 317 "TimeSystem.vala" + sixteenths_per_second = self->priv->sixteenths_per_beat * beats_per_second; +#line 318 "TimeSystem.vala" + sixteenths_per_nanosecond = sixteenths_per_second / GST_SECOND; +#line 319 "TimeSystem.vala" + total_beats = (gint) (the_time * sixteenths_per_nanosecond); +#line 320 "TimeSystem.vala" + if (total_beats == 0) { +#line 320 "TimeSystem.vala" + _tmp0_ = the_time > 0; +#line 1385 "TimeSystem.c" + } else { +#line 320 "TimeSystem.vala" + _tmp0_ = FALSE; +#line 1389 "TimeSystem.c" + } +#line 320 "TimeSystem.vala" + if (_tmp0_) { +#line 322 "TimeSystem.vala" + total_beats = 1; +#line 1395 "TimeSystem.c" + } + result = model_bar_beat_time_system_beats_to_string (self, total_beats, TRUE, TRUE); +#line 324 "TimeSystem.vala" + return result; +#line 1400 "TimeSystem.c" +} + + +#line 327 "TimeSystem.vala" +static void model_bar_beat_time_system_real_calculate_pixel_step (ModelTimeSystem* base, float inc, float pixel_min, float pixel_div) { +#line 1406 "TimeSystem.c" + ModelBarBeatTimeSystem * self; + gint pixels_per_large; + gint pixels_per_medium; + gint pixels_per_small; + float pixels_per_bar; + self = MODEL_BAR_BEAT_TIME_SYSTEM (base); +#line 328 "TimeSystem.vala" + pixels_per_large = 80; +#line 329 "TimeSystem.vala" + pixels_per_medium = 40; +#line 330 "TimeSystem.vala" + pixels_per_small = 20; +#line 332 "TimeSystem.vala" + MODEL_TIME_SYSTEM_BASE (self)->pixel_percentage = MODEL_TIME_SYSTEM_BASE (self)->pixel_percentage + inc; +#line 333 "TimeSystem.vala" + if (MODEL_TIME_SYSTEM_BASE (self)->pixel_percentage < 0.0f) { +#line 334 "TimeSystem.vala" + MODEL_TIME_SYSTEM_BASE (self)->pixel_percentage = 0.0f; +#line 1425 "TimeSystem.c" + } else { +#line 335 "TimeSystem.vala" + if (MODEL_TIME_SYSTEM_BASE (self)->pixel_percentage > 1.0f) { +#line 336 "TimeSystem.vala" + MODEL_TIME_SYSTEM_BASE (self)->pixel_percentage = 1.0f; +#line 1431 "TimeSystem.c" + } + } +#line 339 "TimeSystem.vala" + MODEL_TIME_SYSTEM_BASE (self)->pixels_per_second = pixel_min * powf (pixel_div, MODEL_TIME_SYSTEM_BASE (self)->pixel_percentage); +#line 340 "TimeSystem.vala" + pixels_per_bar = MODEL_TIME_SYSTEM_BASE (self)->pixels_per_second / self->priv->bars_per_second; +#line 341 "TimeSystem.vala" + self->priv->large_pixel_sixteenth = model_time_system_base_correct_seconds_value (MODEL_TIME_SYSTEM_BASE (self), pixels_per_large / pixels_per_bar, 0, self->priv->sixteenths_per_bar); +#line 344 "TimeSystem.vala" + self->priv->medium_pixel_sixteenth = model_time_system_base_correct_seconds_value (MODEL_TIME_SYSTEM_BASE (self), pixels_per_medium / pixels_per_bar, self->priv->large_pixel_sixteenth, self->priv->sixteenths_per_bar); +#line 346 "TimeSystem.vala" + self->priv->small_pixel_sixteenth = model_time_system_base_correct_seconds_value (MODEL_TIME_SYSTEM_BASE (self), pixels_per_small / pixels_per_bar, self->priv->medium_pixel_sixteenth, self->priv->sixteenths_per_bar); +#line 348 "TimeSystem.vala" + if (self->priv->small_pixel_sixteenth == self->priv->medium_pixel_sixteenth) { +#line 1446 "TimeSystem.c" + gint i; +#line 349 "TimeSystem.vala" + i = self->priv->medium_pixel_sixteenth; +#line 351 "TimeSystem.vala" + while (TRUE) { +#line 351 "TimeSystem.vala" + if (!((i = i - 1) > 0)) { +#line 351 "TimeSystem.vala" + break; +#line 1456 "TimeSystem.c" + } +#line 352 "TimeSystem.vala" + if ((self->priv->medium_pixel_sixteenth % i) == 0) { +#line 353 "TimeSystem.vala" + self->priv->small_pixel_sixteenth = i; +#line 354 "TimeSystem.vala" + break; +#line 1464 "TimeSystem.c" + } + } + } +#line 359 "TimeSystem.vala" + self->priv->pixels_per_sixteenth = pixels_per_bar / ((float) self->priv->sixteenths_per_bar); +#line 360 "TimeSystem.vala" + MODEL_TIME_SYSTEM_BASE (self)->pixel_snap_time = model_time_system_xsize_to_time (MODEL_TIME_SYSTEM (self), MODEL_TIME_SYSTEM_BASE_PIXEL_SNAP_INTERVAL); +#line 1472 "TimeSystem.c" +} + + +#line 363 "TimeSystem.vala" +static gint model_bar_beat_time_system_real_frame_to_xsize (ModelTimeSystem* base, gint frame) { +#line 1478 "TimeSystem.c" + ModelBarBeatTimeSystem * self; + gint result = 0; + self = MODEL_BAR_BEAT_TIME_SYSTEM (base); + result = (gint) (frame * self->priv->pixels_per_sixteenth); +#line 364 "TimeSystem.vala" + return result; +#line 1485 "TimeSystem.c" +} + + +#line 367 "TimeSystem.vala" +static gint model_bar_beat_time_system_real_xsize_to_frame (ModelTimeSystem* base, gint xsize) { +#line 1491 "TimeSystem.c" + ModelBarBeatTimeSystem * self; + gint result = 0; + self = MODEL_BAR_BEAT_TIME_SYSTEM (base); + result = (gint) (xsize / self->priv->pixels_per_sixteenth); +#line 368 "TimeSystem.vala" + return result; +#line 1498 "TimeSystem.c" +} + + +#line 371 "TimeSystem.vala" +static gint model_bar_beat_time_system_real_get_start_token (ModelTimeSystem* base, gint xsize) { +#line 1504 "TimeSystem.c" + ModelBarBeatTimeSystem * self; + gint result = 0; + gint start_frame; + self = MODEL_BAR_BEAT_TIME_SYSTEM (base); +#line 372 "TimeSystem.vala" + start_frame = model_time_system_xsize_to_frame (MODEL_TIME_SYSTEM (self), xsize); +#line 1511 "TimeSystem.c" + result = self->priv->large_pixel_sixteenth * (start_frame / self->priv->large_pixel_sixteenth); +#line 373 "TimeSystem.vala" + return result; +#line 1515 "TimeSystem.c" +} + + +#line 376 "TimeSystem.vala" +static gint model_bar_beat_time_system_real_get_next_position (ModelTimeSystem* base, gint token) { +#line 1521 "TimeSystem.c" + ModelBarBeatTimeSystem * self; + gint result = 0; + self = MODEL_BAR_BEAT_TIME_SYSTEM (base); + result = token + self->priv->small_pixel_sixteenth; +#line 377 "TimeSystem.vala" + return result; +#line 1528 "TimeSystem.c" +} + + +#line 380 "TimeSystem.vala" +static char* model_bar_beat_time_system_real_get_display_string (ModelTimeSystem* base, gint frame) { +#line 1534 "TimeSystem.c" + ModelBarBeatTimeSystem * self; + char* result = NULL; + self = MODEL_BAR_BEAT_TIME_SYSTEM (base); +#line 381 "TimeSystem.vala" + if ((frame % self->priv->large_pixel_sixteenth) == 0) { +#line 1540 "TimeSystem.c" + result = model_bar_beat_time_system_beats_to_string (self, frame, FALSE, FALSE); +#line 382 "TimeSystem.vala" + return result; +#line 1544 "TimeSystem.c" + } + result = NULL; +#line 384 "TimeSystem.vala" + return result; +#line 1549 "TimeSystem.c" +} + + +#line 387 "TimeSystem.vala" +static gint model_bar_beat_time_system_real_get_pixel_height (ModelTimeSystem* base, gint frame) { +#line 1555 "TimeSystem.c" + ModelBarBeatTimeSystem * self; + gint result = 0; + self = MODEL_BAR_BEAT_TIME_SYSTEM (base); +#line 388 "TimeSystem.vala" + if ((frame % self->priv->medium_pixel_sixteenth) == 0) { +#line 1561 "TimeSystem.c" + gboolean _tmp0_ = FALSE; +#line 389 "TimeSystem.vala" + if (self->priv->medium_pixel_sixteenth == self->priv->small_pixel_sixteenth) { +#line 1565 "TimeSystem.c" + gboolean _tmp1_ = FALSE; +#line 390 "TimeSystem.vala" + if (self->priv->medium_pixel_sixteenth != self->priv->large_pixel_sixteenth) { +#line 391 "TimeSystem.vala" + _tmp1_ = (frame % self->priv->large_pixel_sixteenth) != 0; +#line 1571 "TimeSystem.c" + } else { +#line 390 "TimeSystem.vala" + _tmp1_ = FALSE; +#line 1575 "TimeSystem.c" + } +#line 390 "TimeSystem.vala" + _tmp0_ = _tmp1_; +#line 1579 "TimeSystem.c" + } else { +#line 389 "TimeSystem.vala" + _tmp0_ = FALSE; +#line 1583 "TimeSystem.c" + } +#line 389 "TimeSystem.vala" + if (_tmp0_) { +#line 1587 "TimeSystem.c" + result = 2; +#line 392 "TimeSystem.vala" + return result; +#line 1591 "TimeSystem.c" + } else { + result = 6; +#line 395 "TimeSystem.vala" + return result; +#line 1596 "TimeSystem.c" + } + } else { + result = 2; +#line 398 "TimeSystem.vala" + return result; +#line 1602 "TimeSystem.c" + } +} + + +static gint* _vala_array_dup1 (gint* self, int length) { + return g_memdup (self, length * sizeof (gint)); +} + + +#line 402 "TimeSystem.vala" +static gint* model_bar_beat_time_system_real_get_timeline_seconds (ModelTimeSystemBase* base, int* result_length1) { +#line 1614 "TimeSystem.c" + ModelBarBeatTimeSystem * self; + gint* result = NULL; + gint* _tmp0_; + gint* _tmp1_; + self = MODEL_BAR_BEAT_TIME_SYSTEM (base); + result = (_tmp1_ = (_tmp0_ = self->priv->timeline_bars, (_tmp0_ == NULL) ? ((gpointer) _tmp0_) : _vala_array_dup1 (_tmp0_, self->priv->timeline_bars_length1)), *result_length1 = self->priv->timeline_bars_length1, _tmp1_); +#line 403 "TimeSystem.vala" + return result; +#line 1623 "TimeSystem.c" +} + + +static void model_bar_beat_time_system_class_init (ModelBarBeatTimeSystemClass * klass) { + model_bar_beat_time_system_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ModelBarBeatTimeSystemPrivate)); + MODEL_TIME_SYSTEM_BASE_CLASS (klass)->correct_sub_second_value = model_bar_beat_time_system_real_correct_sub_second_value; + MODEL_TIME_SYSTEM_BASE_CLASS (klass)->get_timeline_seconds = model_bar_beat_time_system_real_get_timeline_seconds; + G_OBJECT_CLASS (klass)->finalize = model_bar_beat_time_system_finalize; +} + + +static void model_bar_beat_time_system_model_time_system_interface_init (ModelTimeSystemIface * iface) { + model_bar_beat_time_system_model_time_system_parent_iface = g_type_interface_peek_parent (iface); + iface->get_time_string = model_bar_beat_time_system_real_get_time_string; + iface->get_time_duration = model_bar_beat_time_system_real_get_time_duration; + iface->calculate_pixel_step = model_bar_beat_time_system_real_calculate_pixel_step; + iface->frame_to_xsize = model_bar_beat_time_system_real_frame_to_xsize; + iface->xsize_to_frame = model_bar_beat_time_system_real_xsize_to_frame; + iface->get_start_token = model_bar_beat_time_system_real_get_start_token; + iface->get_next_position = model_bar_beat_time_system_real_get_next_position; + iface->get_display_string = model_bar_beat_time_system_real_get_display_string; + iface->get_pixel_height = model_bar_beat_time_system_real_get_pixel_height; + iface->xpos_to_time = (gint64 (*)(ModelTimeSystem* ,gint)) model_time_system_base_xpos_to_time; + iface->xsize_to_time = (gint64 (*)(ModelTimeSystem* ,gint)) model_time_system_base_xsize_to_time; + iface->time_to_xpos = (gint (*)(ModelTimeSystem* ,gint64)) model_time_system_base_time_to_xpos; + iface->get_pixel_snap_time = (gint64 (*)(ModelTimeSystem*)) model_time_system_base_get_pixel_snap_time; + iface->time_to_xsize = (gint (*)(ModelTimeSystem* ,gint64)) model_time_system_base_time_to_xsize; + iface->get_pixel_percentage = (float (*)(ModelTimeSystem*)) model_time_system_base_get_pixel_percentage; +} + + +static void model_bar_beat_time_system_instance_init (ModelBarBeatTimeSystem * self) { + gint* _tmp1_ = NULL; + self->priv = MODEL_BAR_BEAT_TIME_SYSTEM_GET_PRIVATE (self); + self->priv->small_pixel_sixteenth = 0; + self->priv->medium_pixel_sixteenth = 0; + self->priv->large_pixel_sixteenth = 0; + self->priv->timeline_bars = (_tmp1_ = g_new0 (gint, 15), _tmp1_[0] = 1, _tmp1_[1] = 2, _tmp1_[2] = 4, _tmp1_[3] = 8, _tmp1_[4] = 16, _tmp1_[5] = 24, _tmp1_[6] = 32, _tmp1_[7] = 64, _tmp1_[8] = 128, _tmp1_[9] = 256, _tmp1_[10] = 512, _tmp1_[11] = 768, _tmp1_[12] = 1024, _tmp1_[13] = 2048, _tmp1_[14] = 3192, _tmp1_); + self->priv->timeline_bars_length1 = 15; + self->priv->_timeline_bars_size_ = self->priv->timeline_bars_length1; +} + + +static void model_bar_beat_time_system_finalize (GObject* obj) { + ModelBarBeatTimeSystem * self; + self = MODEL_BAR_BEAT_TIME_SYSTEM (obj); + self->priv->timeline_bars = (g_free (self->priv->timeline_bars), NULL); + G_OBJECT_CLASS (model_bar_beat_time_system_parent_class)->finalize (obj); +} + + +GType model_bar_beat_time_system_get_type (void) { + static volatile gsize model_bar_beat_time_system_type_id__volatile = 0; + if (g_once_init_enter (&model_bar_beat_time_system_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelBarBeatTimeSystemClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_bar_beat_time_system_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelBarBeatTimeSystem), 0, (GInstanceInitFunc) model_bar_beat_time_system_instance_init, NULL }; + static const GInterfaceInfo model_time_system_info = { (GInterfaceInitFunc) model_bar_beat_time_system_model_time_system_interface_init, (GInterfaceFinalizeFunc) NULL, NULL}; + GType model_bar_beat_time_system_type_id; + model_bar_beat_time_system_type_id = g_type_register_static (MODEL_TYPE_TIME_SYSTEM_BASE, "ModelBarBeatTimeSystem", &g_define_type_info, 0); + g_type_add_interface_static (model_bar_beat_time_system_type_id, MODEL_TYPE_TIME_SYSTEM, &model_time_system_info); + g_once_init_leave (&model_bar_beat_time_system_type_id__volatile, model_bar_beat_time_system_type_id); + } + return model_bar_beat_time_system_type_id__volatile; +} + + + +static void g_cclosure_user_marshal_VOID__BOXED (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) { + typedef void (*GMarshalFunc_VOID__BOXED) (gpointer data1, gpointer arg_1, gpointer data2); + register GMarshalFunc_VOID__BOXED callback; + register GCClosure * cc; + register gpointer data1, data2; + cc = (GCClosure *) closure; + g_return_if_fail (n_param_values == 2); + if (G_CCLOSURE_SWAP_DATA (closure)) { + data1 = closure->data; + data2 = param_values->data[0].v_pointer; + } else { + data1 = param_values->data[0].v_pointer; + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__BOXED) (marshal_data ? marshal_data : cc->callback); + callback (data1, g_value_get_boxed (param_values + 1), data2); +} + + + diff --git a/src/marina/marina/TimeSystem.o b/src/marina/marina/TimeSystem.o new file mode 100644 index 0000000..6a04e49 Binary files /dev/null and b/src/marina/marina/TimeSystem.o differ diff --git a/src/marina/marina/TrackView.c b/src/marina/marina/TrackView.c new file mode 100644 index 0000000..ec56a4f --- /dev/null +++ b/src/marina/marina/TrackView.c @@ -0,0 +1,860 @@ +/* TrackView.c generated by valac, the Vala compiler + * generated from TrackView.vala, do not modify */ + +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#define TYPE_TRACK_VIEW (track_view_get_type ()) +#define TRACK_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRACK_VIEW, TrackView)) +#define IS_TRACK_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRACK_VIEW)) +#define TRACK_VIEW_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_TRACK_VIEW, TrackViewIface)) + +typedef struct _TrackView TrackView; +typedef struct _TrackViewIface TrackViewIface; + +#define TYPE_CLIP_VIEW (clip_view_get_type ()) +#define CLIP_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CLIP_VIEW, ClipView)) +#define CLIP_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CLIP_VIEW, ClipViewClass)) +#define IS_CLIP_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CLIP_VIEW)) +#define IS_CLIP_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CLIP_VIEW)) +#define CLIP_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CLIP_VIEW, ClipViewClass)) + +typedef struct _ClipView ClipView; +typedef struct _ClipViewClass ClipViewClass; + +#define MODEL_TYPE_TRACK (model_track_get_type ()) +#define MODEL_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TRACK, ModelTrack)) +#define MODEL_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TRACK, ModelTrackClass)) +#define MODEL_IS_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TRACK)) +#define MODEL_IS_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TRACK)) +#define MODEL_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TRACK, ModelTrackClass)) + +typedef struct _ModelTrack ModelTrack; +typedef struct _ModelTrackClass ModelTrackClass; + +#define TYPE_TRACK_VIEW_CONCRETE (track_view_concrete_get_type ()) +#define TRACK_VIEW_CONCRETE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRACK_VIEW_CONCRETE, TrackViewConcrete)) +#define TRACK_VIEW_CONCRETE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TRACK_VIEW_CONCRETE, TrackViewConcreteClass)) +#define IS_TRACK_VIEW_CONCRETE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRACK_VIEW_CONCRETE)) +#define IS_TRACK_VIEW_CONCRETE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TRACK_VIEW_CONCRETE)) +#define TRACK_VIEW_CONCRETE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TRACK_VIEW_CONCRETE, TrackViewConcreteClass)) + +typedef struct _TrackViewConcrete TrackViewConcrete; +typedef struct _TrackViewConcreteClass TrackViewConcreteClass; +typedef struct _TrackViewConcretePrivate TrackViewConcretePrivate; + +#define TYPE_TIME_LINE (time_line_get_type ()) +#define TIME_LINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TIME_LINE, TimeLine)) +#define TIME_LINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TIME_LINE, TimeLineClass)) +#define IS_TIME_LINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TIME_LINE)) +#define IS_TIME_LINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TIME_LINE)) +#define TIME_LINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TIME_LINE, TimeLineClass)) + +typedef struct _TimeLine TimeLine; +typedef struct _TimeLineClass TimeLineClass; + +#define TYPE_TRANSPORT_DELEGATE (transport_delegate_get_type ()) +#define TRANSPORT_DELEGATE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRANSPORT_DELEGATE, TransportDelegate)) +#define IS_TRANSPORT_DELEGATE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRANSPORT_DELEGATE)) +#define TRANSPORT_DELEGATE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_TRANSPORT_DELEGATE, TransportDelegateIface)) + +typedef struct _TransportDelegate TransportDelegate; +typedef struct _TransportDelegateIface TransportDelegateIface; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) + +#define MODEL_TYPE_CLIP (model_clip_get_type ()) +#define MODEL_CLIP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP, ModelClip)) +#define MODEL_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP, ModelClipClass)) +#define MODEL_IS_CLIP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP)) +#define MODEL_IS_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP)) +#define MODEL_CLIP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP, ModelClipClass)) + +typedef struct _ModelClip ModelClip; +typedef struct _ModelClipClass ModelClipClass; + +#define LOGGING_TYPE_FACILITY (logging_facility_get_type ()) + +#define LOGGING_TYPE_LEVEL (logging_level_get_type ()) +typedef struct _TimeLinePrivate TimeLinePrivate; + +#define MODEL_TYPE_PROJECT (model_project_get_type ()) +#define MODEL_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT, ModelProject)) +#define MODEL_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT, ModelProjectClass)) +#define MODEL_IS_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT)) +#define MODEL_IS_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT)) +#define MODEL_PROJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT, ModelProjectClass)) + +typedef struct _ModelProject ModelProject; +typedef struct _ModelProjectClass ModelProjectClass; + +#define MODEL_TYPE_TIME_SYSTEM (model_time_system_get_type ()) +#define MODEL_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TIME_SYSTEM, ModelTimeSystem)) +#define MODEL_IS_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TIME_SYSTEM)) +#define MODEL_TIME_SYSTEM_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MODEL_TYPE_TIME_SYSTEM, ModelTimeSystemIface)) + +typedef struct _ModelTimeSystem ModelTimeSystem; +typedef struct _ModelTimeSystemIface ModelTimeSystemIface; + +#define VIEW_TYPE_RULER (view_ruler_get_type ()) +#define VIEW_RULER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_RULER, ViewRuler)) +#define VIEW_RULER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_RULER, ViewRulerClass)) +#define VIEW_IS_RULER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_RULER)) +#define VIEW_IS_RULER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_RULER)) +#define VIEW_RULER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_RULER, ViewRulerClass)) + +typedef struct _ViewRuler ViewRuler; +typedef struct _ViewRulerClass ViewRulerClass; + +#define TYPE_CLIPBOARD (clipboard_get_type ()) +#define CLIPBOARD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CLIPBOARD, Clipboard)) +#define CLIPBOARD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CLIPBOARD, ClipboardClass)) +#define IS_CLIPBOARD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CLIPBOARD)) +#define IS_CLIPBOARD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CLIPBOARD)) +#define CLIPBOARD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CLIPBOARD, ClipboardClass)) + +typedef struct _Clipboard Clipboard; +typedef struct _ClipboardClass ClipboardClass; +typedef struct _ClipViewPrivate ClipViewPrivate; +#define _g_list_free0(var) ((var == NULL) ? NULL : (var = (g_list_free (var), NULL))) + +struct _TrackViewIface { + GTypeInterface parent_iface; + void (*move_to_top) (TrackView* self, ClipView* clip_view); + void (*resize) (TrackView* self); + ModelTrack* (*get_track) (TrackView* self); + gint (*get_track_height) (TrackView* self); + GtkWidget* (*find_child) (TrackView* self, double x, double y); + void (*select_all) (TrackView* self); +}; + +struct _TrackViewConcrete { + GtkFixed parent_instance; + TrackViewConcretePrivate * priv; +}; + +struct _TrackViewConcreteClass { + GtkFixedClass parent_class; +}; + +struct _TransportDelegateIface { + GTypeInterface parent_iface; + gboolean (*is_playing) (TransportDelegate* self); + gboolean (*is_recording) (TransportDelegate* self); + gboolean (*is_stopped) (TransportDelegate* self); +}; + +struct _TrackViewConcretePrivate { + ModelTrack* track; + TimeLine* timeline; + TransportDelegate* transport_delegate; +}; + +typedef enum { + LOGGING_FACILITY_SIGNAL_HANDLERS, + LOGGING_FACILITY_DEVELOPER_WARNINGS, + LOGGING_FACILITY_GRAPH, + LOGGING_FACILITY_LOADING, + LOGGING_FACILITY_IMPORT, + LOGGING_FACILITY_SINGLEDECODEBIN +} LoggingFacility; + +typedef enum { + LOGGING_LEVEL_CRITICAL, + LOGGING_LEVEL_HIGH, + LOGGING_LEVEL_MEDIUM, + LOGGING_LEVEL_LOW, + LOGGING_LEVEL_INFO, + LOGGING_LEVEL_VERBOSE +} LoggingLevel; + +struct _ModelTimeSystemIface { + GTypeInterface parent_iface; + void (*calculate_pixel_step) (ModelTimeSystem* self, float inc, float pixel_min, float pixel_div); + gint64 (*xpos_to_time) (ModelTimeSystem* self, gint x); + gint64 (*xsize_to_time) (ModelTimeSystem* self, gint x); + gint (*time_to_xpos) (ModelTimeSystem* self, gint64 time); + gint64 (*get_pixel_snap_time) (ModelTimeSystem* self); + gint (*time_to_xsize) (ModelTimeSystem* self, gint64 time); + float (*get_pixel_percentage) (ModelTimeSystem* self); + gint (*get_start_token) (ModelTimeSystem* self, gint xsize); + gint (*get_next_position) (ModelTimeSystem* self, gint token); + gint (*get_pixel_height) (ModelTimeSystem* self, gint token); + char* (*get_display_string) (ModelTimeSystem* self, gint token); + gint (*frame_to_xsize) (ModelTimeSystem* self, gint frame); + gint (*xsize_to_frame) (ModelTimeSystem* self, gint xsize); + char* (*get_time_string) (ModelTimeSystem* self, gint64 time); + char* (*get_time_duration) (ModelTimeSystem* self, gint64 time); +}; + +struct _TimeLine { + GtkEventBox parent_instance; + TimeLinePrivate * priv; + ModelProject* project; + ModelTimeSystem* provider; + ViewRuler* ruler; + GeeArrayList* tracks; + GeeArrayList* selected_clips; + Clipboard* clipboard; +}; + +struct _TimeLineClass { + GtkEventBoxClass parent_class; +}; + +struct _ClipView { + GtkDrawingArea parent_instance; + ClipViewPrivate * priv; + ModelClip* clip; + gint64 initial_time; + gboolean is_selected; + gint height; +}; + +struct _ClipViewClass { + GtkDrawingAreaClass parent_class; +}; + + +static gpointer track_view_concrete_parent_class = NULL; +static TrackViewIface* track_view_concrete_track_view_parent_iface = NULL; + +GType clip_view_get_type (void); +GType model_track_get_type (void); +GType track_view_get_type (void); +GType track_view_concrete_get_type (void); +GType time_line_get_type (void); +GType transport_delegate_get_type (void); +#define TRACK_VIEW_CONCRETE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_TRACK_VIEW_CONCRETE, TrackViewConcretePrivate)) +enum { + TRACK_VIEW_CONCRETE_DUMMY_PROPERTY +}; +#define TRACK_VIEW_CONCRETE_clip_height 64 +#define TIME_LINE_BORDER 4 +#define TRACK_VIEW_CONCRETE_TrackHeight (TRACK_VIEW_CONCRETE_clip_height + (TIME_LINE_BORDER * 2)) +GType model_clip_get_type (void); +static void track_view_concrete_on_clip_added (TrackViewConcrete* self, ModelTrack* t, ModelClip* clip, gboolean select); +static void _track_view_concrete_on_clip_added_model_track_clip_added (ModelTrack* _sender, ModelClip* clip, gboolean select, gpointer self); +static void track_view_concrete_on_clip_removed (TrackViewConcrete* self, ModelClip* clip); +static void _track_view_concrete_on_clip_removed_model_track_clip_removed (ModelTrack* _sender, ModelClip* clip, gpointer self); +TrackViewConcrete* track_view_concrete_new (TransportDelegate* transport_delegate, ModelTrack* track, TimeLine* timeline); +TrackViewConcrete* track_view_concrete_construct (GType object_type, TransportDelegate* transport_delegate, ModelTrack* track, TimeLine* timeline); +static void track_view_concrete_real_size_request (GtkWidget* base, GtkRequisition* requisition); +GType logging_facility_get_type (void); +GType logging_level_get_type (void); +void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message); +static void track_view_concrete_set_clip_pos (TrackViewConcrete* self, ClipView* view); +static void track_view_concrete_on_clip_moved (TrackViewConcrete* self, ClipView* clip); +void model_track_delete_clip (ModelTrack* self, ModelClip* clip); +static void track_view_concrete_clear_drag (TrackViewConcrete* self); +static void track_view_concrete_on_clip_deleted (TrackViewConcrete* self, ModelClip* clip); +GType model_project_get_type (void); +GType model_time_system_get_type (void); +GType view_ruler_get_type (void); +gpointer clipboard_ref (gpointer instance); +void clipboard_unref (gpointer instance); +GParamSpec* param_spec_clipboard (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void value_set_clipboard (GValue* value, gpointer v_object); +void value_take_clipboard (GValue* value, gpointer v_object); +gpointer value_get_clipboard (const GValue* value); +GType clipboard_get_type (void); +ClipView* clip_view_new (TransportDelegate* transport_delegate, ModelClip* clip, ModelTimeSystem* time_provider, gint height); +ClipView* clip_view_construct (GType object_type, TransportDelegate* transport_delegate, ModelClip* clip, ModelTimeSystem* time_provider, gint height); +static void _track_view_concrete_on_clip_moved_clip_view_clip_moved (ClipView* _sender, ClipView* clip, gpointer self); +static void _track_view_concrete_on_clip_deleted_clip_view_clip_deleted (ClipView* _sender, ModelClip* clip, gpointer self); +static void track_view_concrete_on_move_begin (TrackViewConcrete* self, ClipView* clip_view, gboolean do_copy); +static void _track_view_concrete_on_move_begin_clip_view_move_begin (ClipView* _sender, ClipView* clip_view, gboolean copy, gpointer self); +static void track_view_concrete_on_trim_begin (TrackViewConcrete* self, ClipView* clip_view); +static void _track_view_concrete_on_trim_begin_clip_view_trim_begin (ClipView* _sender, ClipView* clip_view, GdkWindowEdge edge, gpointer self); +gint model_time_system_time_to_xpos (ModelTimeSystem* self, gint64 time); +gint64 model_clip_get_start (ModelClip* self); +static void track_view_concrete_real_move_to_top (TrackView* base, ClipView* clip_view); +void track_view_move_to_top (TrackView* self, ClipView* clip_view); +void clip_view_on_clip_moved (ClipView* self, ModelClip* clip); +static void track_view_concrete_real_resize (TrackView* base); +void time_line_deselect_all_clips (TimeLine* self); +static gboolean track_view_concrete_real_button_press_event (GtkWidget* base, GdkEventButton* e); +static ModelTrack* track_view_concrete_real_get_track (TrackView* base); +static gint track_view_concrete_real_get_track_height (TrackView* base); +static GtkWidget* track_view_concrete_real_find_child (TrackView* base, double x, double y); +void clip_view_select (ClipView* self); +static void track_view_concrete_real_select_all (TrackView* base); +static void track_view_concrete_finalize (GObject* obj); + + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 44 "TrackView.vala" +static void _track_view_concrete_on_clip_added_model_track_clip_added (ModelTrack* _sender, ModelClip* clip, gboolean select, gpointer self) { +#line 307 "TrackView.c" + track_view_concrete_on_clip_added (self, _sender, clip, select); +} + + +#line 101 "TrackView.vala" +static void _track_view_concrete_on_clip_removed_model_track_clip_removed (ModelTrack* _sender, ModelClip* clip, gpointer self) { +#line 314 "TrackView.c" + track_view_concrete_on_clip_removed (self, clip); +} + + +#line 17 "TrackView.vala" +TrackViewConcrete* track_view_concrete_construct (GType object_type, TransportDelegate* transport_delegate, ModelTrack* track, TimeLine* timeline) { +#line 321 "TrackView.c" + TrackViewConcrete * self; + ModelTrack* _tmp0_; + TimeLine* _tmp1_; + TransportDelegate* _tmp2_; +#line 17 "TrackView.vala" + g_return_val_if_fail (IS_TRANSPORT_DELEGATE (transport_delegate), NULL); +#line 17 "TrackView.vala" + g_return_val_if_fail (MODEL_IS_TRACK (track), NULL); +#line 17 "TrackView.vala" + g_return_val_if_fail (IS_TIME_LINE (timeline), NULL); +#line 332 "TrackView.c" + self = g_object_newv (object_type, 0, NULL); +#line 19 "TrackView.vala" + self->priv->track = (_tmp0_ = _g_object_ref0 (track), _g_object_unref0 (self->priv->track), _tmp0_); +#line 20 "TrackView.vala" + self->priv->timeline = (_tmp1_ = _g_object_ref0 (timeline), _g_object_unref0 (self->priv->timeline), _tmp1_); +#line 21 "TrackView.vala" + self->priv->transport_delegate = (_tmp2_ = _g_object_ref0 (transport_delegate), _g_object_unref0 (self->priv->transport_delegate), _tmp2_); +#line 23 "TrackView.vala" + g_signal_connect_object (track, "clip-added", (GCallback) _track_view_concrete_on_clip_added_model_track_clip_added, self, 0); +#line 24 "TrackView.vala" + g_signal_connect_object (track, "clip-removed", (GCallback) _track_view_concrete_on_clip_removed_model_track_clip_removed, self, 0); +#line 344 "TrackView.c" + return self; +} + + +#line 17 "TrackView.vala" +TrackViewConcrete* track_view_concrete_new (TransportDelegate* transport_delegate, ModelTrack* track, TimeLine* timeline) { +#line 17 "TrackView.vala" + return track_view_concrete_construct (TYPE_TRACK_VIEW_CONCRETE, transport_delegate, track, timeline); +#line 353 "TrackView.c" +} + + +#line 27 "TrackView.vala" +static void track_view_concrete_real_size_request (GtkWidget* base, GtkRequisition* requisition) { +#line 359 "TrackView.c" + TrackViewConcrete * self; + self = TRACK_VIEW_CONCRETE (base); +#line 28 "TrackView.vala" + GTK_WIDGET_CLASS (track_view_concrete_parent_class)->size_request (GTK_WIDGET (GTK_FIXED (self)), requisition); +#line 29 "TrackView.vala" + (*requisition).height = TRACK_VIEW_CONCRETE_TrackHeight; +#line 30 "TrackView.vala" + (*requisition).width = (*requisition).width + TIME_LINE_BORDER; +#line 368 "TrackView.c" +} + + +#line 33 "TrackView.vala" +static void track_view_concrete_on_clip_moved (TrackViewConcrete* self, ClipView* clip) { +#line 33 "TrackView.vala" + g_return_if_fail (IS_TRACK_VIEW_CONCRETE (self)); +#line 33 "TrackView.vala" + g_return_if_fail (IS_CLIP_VIEW (clip)); +#line 34 "TrackView.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_moved"); +#line 35 "TrackView.vala" + track_view_concrete_set_clip_pos (self, clip); +#line 382 "TrackView.c" +} + + +#line 38 "TrackView.vala" +static void track_view_concrete_on_clip_deleted (TrackViewConcrete* self, ModelClip* clip) { +#line 38 "TrackView.vala" + g_return_if_fail (IS_TRACK_VIEW_CONCRETE (self)); +#line 38 "TrackView.vala" + g_return_if_fail (MODEL_IS_CLIP (clip)); +#line 39 "TrackView.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_deleted"); +#line 40 "TrackView.vala" + model_track_delete_clip (self->priv->track, clip); +#line 41 "TrackView.vala" + track_view_concrete_clear_drag (self); +#line 398 "TrackView.c" +} + + +#line 33 "TrackView.vala" +static void _track_view_concrete_on_clip_moved_clip_view_clip_moved (ClipView* _sender, ClipView* clip, gpointer self) { +#line 404 "TrackView.c" + track_view_concrete_on_clip_moved (self, clip); +} + + +#line 38 "TrackView.vala" +static void _track_view_concrete_on_clip_deleted_clip_view_clip_deleted (ClipView* _sender, ModelClip* clip, gpointer self) { +#line 411 "TrackView.c" + track_view_concrete_on_clip_deleted (self, clip); +} + + +#line 82 "TrackView.vala" +static void _track_view_concrete_on_move_begin_clip_view_move_begin (ClipView* _sender, ClipView* clip_view, gboolean copy, gpointer self) { +#line 418 "TrackView.c" + track_view_concrete_on_move_begin (self, clip_view, copy); +} + + +#line 77 "TrackView.vala" +static void _track_view_concrete_on_trim_begin_clip_view_trim_begin (ClipView* _sender, ClipView* clip_view, GdkWindowEdge edge, gpointer self) { +#line 425 "TrackView.c" + track_view_concrete_on_trim_begin (self, clip_view); +} + + +#line 44 "TrackView.vala" +static void track_view_concrete_on_clip_added (TrackViewConcrete* self, ModelTrack* t, ModelClip* clip, gboolean select) { +#line 432 "TrackView.c" + ClipView* view; +#line 44 "TrackView.vala" + g_return_if_fail (IS_TRACK_VIEW_CONCRETE (self)); +#line 44 "TrackView.vala" + g_return_if_fail (MODEL_IS_TRACK (t)); +#line 44 "TrackView.vala" + g_return_if_fail (MODEL_IS_CLIP (clip)); +#line 45 "TrackView.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_added"); +#line 46 "TrackView.vala" + view = g_object_ref_sink (clip_view_new (self->priv->transport_delegate, clip, self->priv->timeline->provider, TRACK_VIEW_CONCRETE_clip_height)); +#line 47 "TrackView.vala" + g_signal_connect_object (view, "clip-moved", (GCallback) _track_view_concrete_on_clip_moved_clip_view_clip_moved, self, 0); +#line 48 "TrackView.vala" + g_signal_connect_object (view, "clip-deleted", (GCallback) _track_view_concrete_on_clip_deleted_clip_view_clip_deleted, self, 0); +#line 49 "TrackView.vala" + g_signal_connect_object (view, "move-begin", (GCallback) _track_view_concrete_on_move_begin_clip_view_move_begin, self, 0); +#line 50 "TrackView.vala" + g_signal_connect_object (view, "trim-begin", (GCallback) _track_view_concrete_on_trim_begin_clip_view_trim_begin, self, 0); +#line 52 "TrackView.vala" + gtk_fixed_put (GTK_FIXED (self), GTK_WIDGET (view), model_time_system_time_to_xpos (self->priv->timeline->provider, model_clip_get_start (clip)), TIME_LINE_BORDER); +#line 53 "TrackView.vala" + gtk_widget_show (GTK_WIDGET (view)); +#line 55 "TrackView.vala" + g_signal_emit_by_name (self->priv->timeline, "track-changed"); +#line 56 "TrackView.vala" + g_signal_emit_by_name (TRACK_VIEW (self), "clip-view-added", view); +#line 57 "TrackView.vala" + if (select) { +#line 58 "TrackView.vala" + g_signal_emit_by_name (view, "selection-request", view, FALSE); +#line 464 "TrackView.c" + } + _g_object_unref0 (view); +} + + +#line 64 "TrackView.vala" +static void track_view_concrete_real_move_to_top (TrackView* base, ClipView* clip_view) { +#line 472 "TrackView.c" + TrackViewConcrete * self; + self = TRACK_VIEW_CONCRETE (base); +#line 64 "TrackView.vala" + g_return_if_fail (IS_CLIP_VIEW (clip_view)); +#line 70 "TrackView.vala" + gtk_container_remove (GTK_CONTAINER (self), GTK_WIDGET (clip_view)); +#line 71 "TrackView.vala" + gtk_fixed_put (GTK_FIXED (self), GTK_WIDGET (clip_view), model_time_system_time_to_xpos (self->priv->timeline->provider, model_clip_get_start (clip_view->clip)), TIME_LINE_BORDER); +#line 74 "TrackView.vala" + gtk_widget_show (GTK_WIDGET (clip_view)); +#line 483 "TrackView.c" +} + + +#line 77 "TrackView.vala" +static void track_view_concrete_on_trim_begin (TrackViewConcrete* self, ClipView* clip_view) { +#line 77 "TrackView.vala" + g_return_if_fail (IS_TRACK_VIEW_CONCRETE (self)); +#line 77 "TrackView.vala" + g_return_if_fail (IS_CLIP_VIEW (clip_view)); +#line 78 "TrackView.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_trim_begin"); +#line 79 "TrackView.vala" + track_view_move_to_top (TRACK_VIEW (self), clip_view); +#line 497 "TrackView.c" +} + + +#line 82 "TrackView.vala" +static void track_view_concrete_on_move_begin (TrackViewConcrete* self, ClipView* clip_view, gboolean do_copy) { +#line 82 "TrackView.vala" + g_return_if_fail (IS_TRACK_VIEW_CONCRETE (self)); +#line 82 "TrackView.vala" + g_return_if_fail (IS_CLIP_VIEW (clip_view)); +#line 83 "TrackView.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_move_begin"); +#line 84 "TrackView.vala" + track_view_move_to_top (TRACK_VIEW (self), clip_view); +#line 511 "TrackView.c" +} + + +#line 87 "TrackView.vala" +static void track_view_concrete_set_clip_pos (TrackViewConcrete* self, ClipView* view) { +#line 87 "TrackView.vala" + g_return_if_fail (IS_TRACK_VIEW_CONCRETE (self)); +#line 87 "TrackView.vala" + g_return_if_fail (IS_CLIP_VIEW (view)); +#line 88 "TrackView.vala" + gtk_fixed_move (GTK_FIXED (self), GTK_WIDGET (view), model_time_system_time_to_xpos (self->priv->timeline->provider, model_clip_get_start (view->clip)), TIME_LINE_BORDER); +#line 89 "TrackView.vala" + gtk_widget_queue_draw (GTK_WIDGET (self)); +#line 525 "TrackView.c" +} + + +#line 92 "TrackView.vala" +static void track_view_concrete_real_resize (TrackView* base) { +#line 531 "TrackView.c" + TrackViewConcrete * self; + self = TRACK_VIEW_CONCRETE (base); + { + GList* w_collection; + GList* w_it; +#line 93 "TrackView.vala" + w_collection = gtk_container_get_children (GTK_CONTAINER (self)); +#line 539 "TrackView.c" + for (w_it = w_collection; w_it != NULL; w_it = w_it->next) { + GtkWidget* w; +#line 93 "TrackView.vala" + w = _g_object_ref0 ((GtkWidget*) w_it->data); +#line 544 "TrackView.c" + { + GtkWidget* _tmp0_; + ClipView* view; +#line 94 "TrackView.vala" + view = _g_object_ref0 ((_tmp0_ = w, IS_CLIP_VIEW (_tmp0_) ? ((ClipView*) _tmp0_) : NULL)); +#line 95 "TrackView.vala" + if (view != NULL) { +#line 96 "TrackView.vala" + clip_view_on_clip_moved (view, view->clip); +#line 554 "TrackView.c" + } + _g_object_unref0 (w); + _g_object_unref0 (view); + } + } +#line 93 "TrackView.vala" + _g_list_free0 (w_collection); +#line 562 "TrackView.c" + } +} + + +#line 101 "TrackView.vala" +static void track_view_concrete_on_clip_removed (TrackViewConcrete* self, ModelClip* clip) { +#line 101 "TrackView.vala" + g_return_if_fail (IS_TRACK_VIEW_CONCRETE (self)); +#line 101 "TrackView.vala" + g_return_if_fail (MODEL_IS_CLIP (clip)); +#line 102 "TrackView.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_removed"); +#line 575 "TrackView.c" + { + GList* w_collection; + GList* w_it; +#line 103 "TrackView.vala" + w_collection = gtk_container_get_children (GTK_CONTAINER (self)); +#line 581 "TrackView.c" + for (w_it = w_collection; w_it != NULL; w_it = w_it->next) { + GtkWidget* w; +#line 103 "TrackView.vala" + w = _g_object_ref0 ((GtkWidget*) w_it->data); +#line 586 "TrackView.c" + { + GtkWidget* _tmp0_; + ClipView* view; +#line 104 "TrackView.vala" + view = _g_object_ref0 ((_tmp0_ = w, IS_CLIP_VIEW (_tmp0_) ? ((ClipView*) _tmp0_) : NULL)); +#line 105 "TrackView.vala" + if (view->clip == clip) { +#line 594 "TrackView.c" + guint _tmp1_; +#line 106 "TrackView.vala" + g_signal_parse_name ("clip-moved", TYPE_CLIP_VIEW, &_tmp1_, NULL, FALSE); +#line 106 "TrackView.vala" + g_signal_handlers_disconnect_matched (view, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp1_, 0, NULL, (GCallback) _track_view_concrete_on_clip_moved_clip_view_clip_moved, self); +#line 107 "TrackView.vala" + gtk_container_remove (GTK_CONTAINER (self), GTK_WIDGET (view)); +#line 108 "TrackView.vala" + g_signal_emit_by_name (self->priv->timeline, "track-changed"); +#line 604 "TrackView.c" + _g_object_unref0 (w); + _g_object_unref0 (view); + _g_list_free0 (w_collection); +#line 109 "TrackView.vala" + return; +#line 610 "TrackView.c" + } + _g_object_unref0 (w); + _g_object_unref0 (view); + } + } +#line 103 "TrackView.vala" + _g_list_free0 (w_collection); +#line 618 "TrackView.c" + } +} + + +#line 124 "TrackView.vala" +static gboolean track_view_concrete_real_button_press_event (GtkWidget* base, GdkEventButton* e) { +#line 625 "TrackView.c" + TrackViewConcrete * self; + gboolean result = FALSE; + gboolean _tmp0_ = FALSE; + gboolean _tmp1_ = FALSE; + gboolean _tmp2_ = FALSE; + self = TRACK_VIEW_CONCRETE (base); +#line 125 "TrackView.vala" + if ((*e).type != GDK_BUTTON_PRESS) { +#line 126 "TrackView.vala" + _tmp1_ = (*e).type != GDK_2BUTTON_PRESS; +#line 636 "TrackView.c" + } else { +#line 125 "TrackView.vala" + _tmp1_ = FALSE; +#line 640 "TrackView.c" + } +#line 125 "TrackView.vala" + if (_tmp1_) { +#line 127 "TrackView.vala" + _tmp0_ = (*e).type != GDK_3BUTTON_PRESS; +#line 646 "TrackView.c" + } else { +#line 125 "TrackView.vala" + _tmp0_ = FALSE; +#line 650 "TrackView.c" + } +#line 125 "TrackView.vala" + if (_tmp0_) { +#line 654 "TrackView.c" + result = FALSE; +#line 128 "TrackView.vala" + return result; +#line 658 "TrackView.c" + } +#line 130 "TrackView.vala" + if ((*e).button == 1) { +#line 130 "TrackView.vala" + _tmp2_ = TRUE; +#line 664 "TrackView.c" + } else { +#line 131 "TrackView.vala" + _tmp2_ = (*e).button == 3; +#line 668 "TrackView.c" + } +#line 130 "TrackView.vala" + if (_tmp2_) { +#line 150 "TrackView.vala" + time_line_deselect_all_clips (self->priv->timeline); +#line 674 "TrackView.c" + } + result = FALSE; +#line 155 "TrackView.vala" + return result; +#line 679 "TrackView.c" +} + + +#line 169 "TrackView.vala" +static void track_view_concrete_clear_drag (TrackViewConcrete* self) { +#line 169 "TrackView.vala" + g_return_if_fail (IS_TRACK_VIEW_CONCRETE (self)); +#line 170 "TrackView.vala" + gdk_window_set_cursor (GTK_WIDGET (self)->window, NULL); +#line 171 "TrackView.vala" + gtk_widget_queue_draw (GTK_WIDGET (self)); +#line 691 "TrackView.c" +} + + +#line 174 "TrackView.vala" +static ModelTrack* track_view_concrete_real_get_track (TrackView* base) { +#line 697 "TrackView.c" + TrackViewConcrete * self; + ModelTrack* result = NULL; + self = TRACK_VIEW_CONCRETE (base); + result = _g_object_ref0 (self->priv->track); +#line 175 "TrackView.vala" + return result; +#line 704 "TrackView.c" +} + + +#line 178 "TrackView.vala" +static gint track_view_concrete_real_get_track_height (TrackView* base) { +#line 710 "TrackView.c" + TrackViewConcrete * self; + gint result = 0; + self = TRACK_VIEW_CONCRETE (base); + result = TRACK_VIEW_CONCRETE_TrackHeight; +#line 179 "TrackView.vala" + return result; +#line 717 "TrackView.c" +} + + +#line 182 "TrackView.vala" +static GtkWidget* track_view_concrete_real_find_child (TrackView* base, double x, double y) { +#line 723 "TrackView.c" + TrackViewConcrete * self; + GtkWidget* result = NULL; + self = TRACK_VIEW_CONCRETE (base); + { + GList* w_collection; + GList* w_it; +#line 183 "TrackView.vala" + w_collection = gtk_container_get_children (GTK_CONTAINER (self)); +#line 732 "TrackView.c" + for (w_it = w_collection; w_it != NULL; w_it = w_it->next) { + GtkWidget* w; +#line 183 "TrackView.vala" + w = _g_object_ref0 ((GtkWidget*) w_it->data); +#line 737 "TrackView.c" + { + gboolean _tmp0_ = FALSE; +#line 184 "TrackView.vala" + if (w->allocation.x <= x) { +#line 184 "TrackView.vala" + _tmp0_ = x < (w->allocation.x + w->allocation.width); +#line 744 "TrackView.c" + } else { +#line 184 "TrackView.vala" + _tmp0_ = FALSE; +#line 748 "TrackView.c" + } +#line 184 "TrackView.vala" + if (_tmp0_) { +#line 752 "TrackView.c" + result = w; + _g_list_free0 (w_collection); +#line 185 "TrackView.vala" + return result; +#line 757 "TrackView.c" + } + _g_object_unref0 (w); + } + } +#line 183 "TrackView.vala" + _g_list_free0 (w_collection); +#line 764 "TrackView.c" + } + result = NULL; +#line 188 "TrackView.vala" + return result; +#line 769 "TrackView.c" +} + + +#line 191 "TrackView.vala" +static void track_view_concrete_real_select_all (TrackView* base) { +#line 775 "TrackView.c" + TrackViewConcrete * self; + self = TRACK_VIEW_CONCRETE (base); + { + GList* child_collection; + GList* child_it; +#line 192 "TrackView.vala" + child_collection = gtk_container_get_children (GTK_CONTAINER (self)); +#line 783 "TrackView.c" + for (child_it = child_collection; child_it != NULL; child_it = child_it->next) { + GtkWidget* child; +#line 192 "TrackView.vala" + child = _g_object_ref0 ((GtkWidget*) child_it->data); +#line 788 "TrackView.c" + { + GtkWidget* _tmp0_; + ClipView* clip_view; +#line 193 "TrackView.vala" + clip_view = _g_object_ref0 ((_tmp0_ = child, IS_CLIP_VIEW (_tmp0_) ? ((ClipView*) _tmp0_) : NULL)); +#line 194 "TrackView.vala" + if (clip_view != NULL) { +#line 195 "TrackView.vala" + clip_view_select (clip_view); +#line 798 "TrackView.c" + } + _g_object_unref0 (child); + _g_object_unref0 (clip_view); + } + } +#line 192 "TrackView.vala" + _g_list_free0 (child_collection); +#line 806 "TrackView.c" + } +} + + +static void track_view_concrete_class_init (TrackViewConcreteClass * klass) { + track_view_concrete_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (TrackViewConcretePrivate)); + GTK_WIDGET_CLASS (klass)->size_request = track_view_concrete_real_size_request; + GTK_WIDGET_CLASS (klass)->button_press_event = track_view_concrete_real_button_press_event; + G_OBJECT_CLASS (klass)->finalize = track_view_concrete_finalize; +} + + +static void track_view_concrete_track_view_interface_init (TrackViewIface * iface) { + track_view_concrete_track_view_parent_iface = g_type_interface_peek_parent (iface); + iface->move_to_top = track_view_concrete_real_move_to_top; + iface->resize = track_view_concrete_real_resize; + iface->get_track = track_view_concrete_real_get_track; + iface->get_track_height = track_view_concrete_real_get_track_height; + iface->find_child = track_view_concrete_real_find_child; + iface->select_all = track_view_concrete_real_select_all; +} + + +static void track_view_concrete_instance_init (TrackViewConcrete * self) { + self->priv = TRACK_VIEW_CONCRETE_GET_PRIVATE (self); +} + + +static void track_view_concrete_finalize (GObject* obj) { + TrackViewConcrete * self; + self = TRACK_VIEW_CONCRETE (obj); + _g_object_unref0 (self->priv->track); + _g_object_unref0 (self->priv->timeline); + _g_object_unref0 (self->priv->transport_delegate); + G_OBJECT_CLASS (track_view_concrete_parent_class)->finalize (obj); +} + + +GType track_view_concrete_get_type (void) { + static volatile gsize track_view_concrete_type_id__volatile = 0; + if (g_once_init_enter (&track_view_concrete_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (TrackViewConcreteClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) track_view_concrete_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (TrackViewConcrete), 0, (GInstanceInitFunc) track_view_concrete_instance_init, NULL }; + static const GInterfaceInfo track_view_info = { (GInterfaceInitFunc) track_view_concrete_track_view_interface_init, (GInterfaceFinalizeFunc) NULL, NULL}; + GType track_view_concrete_type_id; + track_view_concrete_type_id = g_type_register_static (GTK_TYPE_FIXED, "TrackViewConcrete", &g_define_type_info, 0); + g_type_add_interface_static (track_view_concrete_type_id, TYPE_TRACK_VIEW, &track_view_info); + g_once_init_leave (&track_view_concrete_type_id__volatile, track_view_concrete_type_id); + } + return track_view_concrete_type_id__volatile; +} + + + + diff --git a/src/marina/marina/TrackView.o b/src/marina/marina/TrackView.o new file mode 100644 index 0000000..8b41084 Binary files /dev/null and b/src/marina/marina/TrackView.o differ diff --git a/src/marina/marina/TransportDelegate.c b/src/marina/marina/TransportDelegate.c new file mode 100644 index 0000000..11e7530 --- /dev/null +++ b/src/marina/marina/TransportDelegate.c @@ -0,0 +1,84 @@ +/* TransportDelegate.c generated by valac, the Vala compiler + * generated from TransportDelegate.vala, do not modify */ + +/* Copyright 2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include + + +#define TYPE_TRANSPORT_DELEGATE (transport_delegate_get_type ()) +#define TRANSPORT_DELEGATE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRANSPORT_DELEGATE, TransportDelegate)) +#define IS_TRANSPORT_DELEGATE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRANSPORT_DELEGATE)) +#define TRANSPORT_DELEGATE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_TRANSPORT_DELEGATE, TransportDelegateIface)) + +typedef struct _TransportDelegate TransportDelegate; +typedef struct _TransportDelegateIface TransportDelegateIface; + +struct _TransportDelegateIface { + GTypeInterface parent_iface; + gboolean (*is_playing) (TransportDelegate* self); + gboolean (*is_recording) (TransportDelegate* self); + gboolean (*is_stopped) (TransportDelegate* self); +}; + + + +GType transport_delegate_get_type (void); +gboolean transport_delegate_is_playing (TransportDelegate* self); +gboolean transport_delegate_is_recording (TransportDelegate* self); +gboolean transport_delegate_is_stopped (TransportDelegate* self); + + + +#line 8 "TransportDelegate.vala" +gboolean transport_delegate_is_playing (TransportDelegate* self) { +#line 8 "TransportDelegate.vala" + return TRANSPORT_DELEGATE_GET_INTERFACE (self)->is_playing (self); +#line 43 "TransportDelegate.c" +} + + +#line 9 "TransportDelegate.vala" +gboolean transport_delegate_is_recording (TransportDelegate* self) { +#line 9 "TransportDelegate.vala" + return TRANSPORT_DELEGATE_GET_INTERFACE (self)->is_recording (self); +#line 51 "TransportDelegate.c" +} + + +#line 10 "TransportDelegate.vala" +gboolean transport_delegate_is_stopped (TransportDelegate* self) { +#line 10 "TransportDelegate.vala" + return TRANSPORT_DELEGATE_GET_INTERFACE (self)->is_stopped (self); +#line 59 "TransportDelegate.c" +} + + +static void transport_delegate_base_init (TransportDelegateIface * iface) { + static gboolean initialized = FALSE; + if (!initialized) { + initialized = TRUE; + } +} + + +GType transport_delegate_get_type (void) { + static volatile gsize transport_delegate_type_id__volatile = 0; + if (g_once_init_enter (&transport_delegate_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (TransportDelegateIface), (GBaseInitFunc) transport_delegate_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL }; + GType transport_delegate_type_id; + transport_delegate_type_id = g_type_register_static (G_TYPE_INTERFACE, "TransportDelegate", &g_define_type_info, 0); + g_type_interface_add_prerequisite (transport_delegate_type_id, G_TYPE_OBJECT); + g_once_init_leave (&transport_delegate_type_id__volatile, transport_delegate_type_id); + } + return transport_delegate_type_id__volatile; +} + + + + diff --git a/src/marina/marina/TransportDelegate.o b/src/marina/marina/TransportDelegate.o new file mode 100644 index 0000000..e40ba40 Binary files /dev/null and b/src/marina/marina/TransportDelegate.o differ diff --git a/src/marina/marina/UndoManager.c b/src/marina/marina/UndoManager.c new file mode 100644 index 0000000..e692b6f --- /dev/null +++ b/src/marina/marina/UndoManager.c @@ -0,0 +1,586 @@ +/* UndoManager.c generated by valac, the Vala compiler + * generated from UndoManager.vala, do not modify */ + +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include + + +#define MODEL_TYPE_UNDO_MANAGER (model_undo_manager_get_type ()) +#define MODEL_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManager)) +#define MODEL_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass)) +#define MODEL_IS_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_UNDO_MANAGER)) +#define MODEL_IS_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_UNDO_MANAGER)) +#define MODEL_UNDO_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass)) + +typedef struct _ModelUndoManager ModelUndoManager; +typedef struct _ModelUndoManagerClass ModelUndoManagerClass; +typedef struct _ModelUndoManagerPrivate ModelUndoManagerPrivate; + +#define MODEL_TYPE_COMMAND (model_command_get_type ()) +#define MODEL_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_COMMAND, ModelCommand)) +#define MODEL_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_COMMAND, ModelCommandClass)) +#define MODEL_IS_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_COMMAND)) +#define MODEL_IS_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_COMMAND)) +#define MODEL_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_COMMAND, ModelCommandClass)) + +typedef struct _ModelCommand ModelCommand; +typedef struct _ModelCommandClass ModelCommandClass; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) + +#define MODEL_TYPE_TRANSACTION_COMMAND (model_transaction_command_get_type ()) +#define MODEL_TRANSACTION_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TRANSACTION_COMMAND, ModelTransactionCommand)) +#define MODEL_TRANSACTION_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TRANSACTION_COMMAND, ModelTransactionCommandClass)) +#define MODEL_IS_TRANSACTION_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TRANSACTION_COMMAND)) +#define MODEL_IS_TRANSACTION_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TRANSACTION_COMMAND)) +#define MODEL_TRANSACTION_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TRANSACTION_COMMAND, ModelTransactionCommandClass)) + +typedef struct _ModelTransactionCommand ModelTransactionCommand; +typedef struct _ModelTransactionCommandClass ModelTransactionCommandClass; +#define _model_command_unref0(var) ((var == NULL) ? NULL : (var = (model_command_unref (var), NULL))) +typedef struct _ModelParamSpecUndoManager ModelParamSpecUndoManager; + +struct _ModelUndoManager { + GTypeInstance parent_instance; + volatile int ref_count; + ModelUndoManagerPrivate * priv; +}; + +struct _ModelUndoManagerClass { + GTypeClass parent_class; + void (*finalize) (ModelUndoManager *self); +}; + +struct _ModelUndoManagerPrivate { + gint saved_index; + gboolean _in_undo; + GeeArrayList* command_list; +}; + +struct _ModelParamSpecUndoManager { + GParamSpec parent_instance; +}; + + +static gpointer model_undo_manager_parent_class = NULL; + +gpointer model_undo_manager_ref (gpointer instance); +void model_undo_manager_unref (gpointer instance); +GParamSpec* model_param_spec_undo_manager (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_undo_manager (GValue* value, gpointer v_object); +void model_value_take_undo_manager (GValue* value, gpointer v_object); +gpointer model_value_get_undo_manager (const GValue* value); +GType model_undo_manager_get_type (void); +gpointer model_command_ref (gpointer instance); +void model_command_unref (gpointer instance); +GParamSpec* model_param_spec_command (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_command (GValue* value, gpointer v_object); +void model_value_take_command (GValue* value, gpointer v_object); +gpointer model_value_get_command (const GValue* value); +GType model_command_get_type (void); +#define MODEL_UNDO_MANAGER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerPrivate)) +enum { + MODEL_UNDO_MANAGER_DUMMY_PROPERTY +}; +ModelUndoManager* model_undo_manager_new (void); +ModelUndoManager* model_undo_manager_construct (GType object_type); +void model_undo_manager_reset (ModelUndoManager* self); +void model_undo_manager_mark_clean (ModelUndoManager* self); +ModelTransactionCommand* model_transaction_command_new (gboolean open, const char* transaction_description); +ModelTransactionCommand* model_transaction_command_construct (GType object_type, gboolean open, const char* transaction_description); +GType model_transaction_command_get_type (void); +void model_undo_manager_start_transaction (ModelUndoManager* self, const char* description); +void model_undo_manager_end_transaction (ModelUndoManager* self, const char* description); +gboolean model_undo_manager_get_in_undo (ModelUndoManager* self); +void model_command_apply (ModelCommand* self); +static ModelCommand* model_undo_manager_get_current_command (ModelUndoManager* self); +gboolean model_command_merge (ModelCommand* self, ModelCommand* command); +gboolean model_undo_manager_get_can_undo (ModelUndoManager* self); +void model_undo_manager_do_command (ModelUndoManager* self, ModelCommand* the_command); +static void model_undo_manager_set_in_undo (ModelUndoManager* self, gboolean value); +gboolean model_transaction_command_in_transaction (ModelTransactionCommand* self); +void model_command_undo (ModelCommand* self); +gboolean model_undo_manager_get_is_dirty (ModelUndoManager* self); +void model_undo_manager_undo (ModelUndoManager* self); +char* model_command_description (ModelCommand* self); +char* model_undo_manager_get_undo_title (ModelUndoManager* self); +static void model_undo_manager_finalize (ModelUndoManager* obj); + + + +#line 19 "UndoManager.vala" +ModelUndoManager* model_undo_manager_construct (GType object_type) { +#line 123 "UndoManager.c" + ModelUndoManager* self; + self = (ModelUndoManager*) g_type_create_instance (object_type); + return self; +} + + +#line 19 "UndoManager.vala" +ModelUndoManager* model_undo_manager_new (void) { +#line 19 "UndoManager.vala" + return model_undo_manager_construct (MODEL_TYPE_UNDO_MANAGER); +#line 134 "UndoManager.c" +} + + +#line 22 "UndoManager.vala" +void model_undo_manager_reset (ModelUndoManager* self) { +#line 22 "UndoManager.vala" + g_return_if_fail (MODEL_IS_UNDO_MANAGER (self)); +#line 23 "UndoManager.vala" + gee_abstract_collection_clear (GEE_ABSTRACT_COLLECTION (self->priv->command_list)); +#line 24 "UndoManager.vala" + self->priv->saved_index = 0; +#line 25 "UndoManager.vala" + g_signal_emit_by_name (self, "undo-changed", FALSE); +#line 148 "UndoManager.c" +} + + +#line 28 "UndoManager.vala" +void model_undo_manager_mark_clean (ModelUndoManager* self) { +#line 28 "UndoManager.vala" + g_return_if_fail (MODEL_IS_UNDO_MANAGER (self)); +#line 29 "UndoManager.vala" + self->priv->saved_index = gee_collection_get_size (GEE_COLLECTION (self->priv->command_list)); +#line 30 "UndoManager.vala" + g_signal_emit_by_name (self, "dirty-changed", FALSE); +#line 160 "UndoManager.c" +} + + +#line 33 "UndoManager.vala" +void model_undo_manager_start_transaction (ModelUndoManager* self, const char* description) { +#line 166 "UndoManager.c" + ModelTransactionCommand* command; +#line 33 "UndoManager.vala" + g_return_if_fail (MODEL_IS_UNDO_MANAGER (self)); +#line 33 "UndoManager.vala" + g_return_if_fail (description != NULL); +#line 34 "UndoManager.vala" + command = model_transaction_command_new (FALSE, description); +#line 35 "UndoManager.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->command_list), MODEL_COMMAND (command)); +#line 36 "UndoManager.vala" + g_signal_emit_by_name (self, "undo-changed", TRUE); +#line 178 "UndoManager.c" + _model_command_unref0 (command); +} + + +#line 39 "UndoManager.vala" +void model_undo_manager_end_transaction (ModelUndoManager* self, const char* description) { +#line 185 "UndoManager.c" + ModelTransactionCommand* command; +#line 39 "UndoManager.vala" + g_return_if_fail (MODEL_IS_UNDO_MANAGER (self)); +#line 39 "UndoManager.vala" + g_return_if_fail (description != NULL); +#line 40 "UndoManager.vala" + command = model_transaction_command_new (TRUE, description); +#line 41 "UndoManager.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->command_list), MODEL_COMMAND (command)); +#line 42 "UndoManager.vala" + g_signal_emit_by_name (self, "undo-changed", TRUE); +#line 197 "UndoManager.c" + _model_command_unref0 (command); +} + + +#line 45 "UndoManager.vala" +void model_undo_manager_do_command (ModelUndoManager* self, ModelCommand* the_command) { +#line 45 "UndoManager.vala" + g_return_if_fail (MODEL_IS_UNDO_MANAGER (self)); +#line 45 "UndoManager.vala" + g_return_if_fail (MODEL_IS_COMMAND (the_command)); +#line 46 "UndoManager.vala" + if (!model_undo_manager_get_in_undo (self)) { +#line 210 "UndoManager.c" + ModelCommand* current_command; + gboolean _tmp0_ = FALSE; +#line 47 "UndoManager.vala" + model_command_apply (the_command); +#line 48 "UndoManager.vala" + current_command = model_undo_manager_get_current_command (self); +#line 49 "UndoManager.vala" + if (current_command == NULL) { +#line 49 "UndoManager.vala" + _tmp0_ = TRUE; +#line 221 "UndoManager.c" + } else { +#line 49 "UndoManager.vala" + _tmp0_ = !model_command_merge (current_command, the_command); +#line 225 "UndoManager.c" + } +#line 49 "UndoManager.vala" + if (_tmp0_) { +#line 50 "UndoManager.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->command_list), the_command); +#line 231 "UndoManager.c" + } +#line 52 "UndoManager.vala" + g_signal_emit_by_name (self, "dirty-changed", TRUE); +#line 53 "UndoManager.vala" + g_signal_emit_by_name (self, "undo-changed", model_undo_manager_get_can_undo (self)); +#line 237 "UndoManager.c" + _model_command_unref0 (current_command); + } +} + + +#line 57 "UndoManager.vala" +static ModelCommand* model_undo_manager_get_current_command (ModelUndoManager* self) { +#line 245 "UndoManager.c" + ModelCommand* result = NULL; + gint index; +#line 57 "UndoManager.vala" + g_return_val_if_fail (MODEL_IS_UNDO_MANAGER (self), NULL); +#line 58 "UndoManager.vala" + index = gee_collection_get_size (GEE_COLLECTION (self->priv->command_list)) - 1; +#line 59 "UndoManager.vala" + if (index >= 0) { +#line 254 "UndoManager.c" + result = (ModelCommand*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->priv->command_list), index); +#line 60 "UndoManager.vala" + return result; +#line 258 "UndoManager.c" + } else { + result = NULL; +#line 62 "UndoManager.vala" + return result; +#line 263 "UndoManager.c" + } +} + + +static gpointer _model_command_ref0 (gpointer self) { + return self ? model_command_ref (self) : NULL; +} + + +#line 66 "UndoManager.vala" +void model_undo_manager_undo (ModelUndoManager* self) { +#line 275 "UndoManager.c" + gint in_transaction; +#line 66 "UndoManager.vala" + g_return_if_fail (MODEL_IS_UNDO_MANAGER (self)); +#line 67 "UndoManager.vala" + g_assert (model_undo_manager_get_in_undo (self) == FALSE); +#line 68 "UndoManager.vala" + model_undo_manager_set_in_undo (self, TRUE); +#line 69 "UndoManager.vala" + in_transaction = 0; +#line 285 "UndoManager.c" + { + gboolean _tmp0_; +#line 70 "UndoManager.vala" + _tmp0_ = TRUE; +#line 70 "UndoManager.vala" + while (TRUE) { +#line 292 "UndoManager.c" + ModelCommand* the_command; +#line 70 "UndoManager.vala" + if (!_tmp0_) { +#line 87 "UndoManager.vala" + if (!(in_transaction > 0)) { +#line 87 "UndoManager.vala" + break; +#line 300 "UndoManager.c" + } + } +#line 70 "UndoManager.vala" + _tmp0_ = FALSE; +#line 71 "UndoManager.vala" + the_command = model_undo_manager_get_current_command (self); +#line 72 "UndoManager.vala" + if (the_command != NULL) { +#line 309 "UndoManager.c" + ModelCommand* _tmp1_; + ModelTransactionCommand* transaction_command; +#line 73 "UndoManager.vala" + gee_abstract_collection_remove (GEE_ABSTRACT_COLLECTION (self->priv->command_list), the_command); +#line 74 "UndoManager.vala" + transaction_command = _model_command_ref0 ((_tmp1_ = the_command, MODEL_IS_TRANSACTION_COMMAND (_tmp1_) ? ((ModelTransactionCommand*) _tmp1_) : NULL)); +#line 75 "UndoManager.vala" + if (transaction_command != NULL) { +#line 76 "UndoManager.vala" + if (model_transaction_command_in_transaction (transaction_command)) { +#line 77 "UndoManager.vala" + in_transaction++; +#line 322 "UndoManager.c" + } else { +#line 79 "UndoManager.vala" + in_transaction--; +#line 326 "UndoManager.c" + } + } else { +#line 82 "UndoManager.vala" + model_command_undo (the_command); +#line 331 "UndoManager.c" + } + _model_command_unref0 (transaction_command); + } else { + _model_command_unref0 (the_command); +#line 85 "UndoManager.vala" + break; +#line 338 "UndoManager.c" + } + _model_command_unref0 (the_command); + } + } +#line 88 "UndoManager.vala" + g_signal_emit_by_name (self, "dirty-changed", model_undo_manager_get_is_dirty (self)); +#line 89 "UndoManager.vala" + g_signal_emit_by_name (self, "undo-changed", model_undo_manager_get_can_undo (self)); +#line 90 "UndoManager.vala" + model_undo_manager_set_in_undo (self, FALSE); +#line 349 "UndoManager.c" +} + + +#line 93 "UndoManager.vala" +char* model_undo_manager_get_undo_title (ModelUndoManager* self) { +#line 355 "UndoManager.c" + char* result = NULL; + ModelCommand* the_command; +#line 93 "UndoManager.vala" + g_return_val_if_fail (MODEL_IS_UNDO_MANAGER (self), NULL); +#line 94 "UndoManager.vala" + the_command = model_undo_manager_get_current_command (self); +#line 95 "UndoManager.vala" + if (the_command != NULL) { +#line 364 "UndoManager.c" + result = model_command_description (the_command); + _model_command_unref0 (the_command); +#line 96 "UndoManager.vala" + return result; +#line 369 "UndoManager.c" + } else { + result = g_strdup (""); + _model_command_unref0 (the_command); +#line 98 "UndoManager.vala" + return result; +#line 375 "UndoManager.c" + } + _model_command_unref0 (the_command); +} + + +gboolean model_undo_manager_get_is_dirty (ModelUndoManager* self) { + gboolean result; + g_return_val_if_fail (MODEL_IS_UNDO_MANAGER (self), FALSE); + result = self->priv->saved_index != gee_collection_get_size (GEE_COLLECTION (self->priv->command_list)); +#line 12 "UndoManager.vala" + return result; +#line 387 "UndoManager.c" +} + + +gboolean model_undo_manager_get_can_undo (ModelUndoManager* self) { + gboolean result; + g_return_val_if_fail (MODEL_IS_UNDO_MANAGER (self), FALSE); + result = gee_collection_get_size (GEE_COLLECTION (self->priv->command_list)) > 0; +#line 13 "UndoManager.vala" + return result; +#line 397 "UndoManager.c" +} + + +gboolean model_undo_manager_get_in_undo (ModelUndoManager* self) { + gboolean result; + g_return_val_if_fail (MODEL_IS_UNDO_MANAGER (self), FALSE); + result = self->priv->_in_undo; +#line 14 "UndoManager.vala" + return result; +#line 407 "UndoManager.c" +} + + +static void model_undo_manager_set_in_undo (ModelUndoManager* self, gboolean value) { + g_return_if_fail (MODEL_IS_UNDO_MANAGER (self)); +#line 14 "UndoManager.vala" + self->priv->_in_undo = value; +#line 415 "UndoManager.c" +} + + +static void model_value_undo_manager_init (GValue* value) { + value->data[0].v_pointer = NULL; +} + + +static void model_value_undo_manager_free_value (GValue* value) { + if (value->data[0].v_pointer) { + model_undo_manager_unref (value->data[0].v_pointer); + } +} + + +static void model_value_undo_manager_copy_value (const GValue* src_value, GValue* dest_value) { + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = model_undo_manager_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + + +static gpointer model_value_undo_manager_peek_pointer (const GValue* value) { + return value->data[0].v_pointer; +} + + +static gchar* model_value_undo_manager_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + if (collect_values[0].v_pointer) { + ModelUndoManager* object; + object = collect_values[0].v_pointer; + if (object->parent_instance.g_class == NULL) { + return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) { + return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } + value->data[0].v_pointer = model_undo_manager_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + + +static gchar* model_value_undo_manager_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + ModelUndoManager** object_p; + object_p = collect_values[0].v_pointer; + if (!object_p) { + return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); + } + if (!value->data[0].v_pointer) { + *object_p = NULL; + } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) { + *object_p = value->data[0].v_pointer; + } else { + *object_p = model_undo_manager_ref (value->data[0].v_pointer); + } + return NULL; +} + + +GParamSpec* model_param_spec_undo_manager (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) { + ModelParamSpecUndoManager* spec; + g_return_val_if_fail (g_type_is_a (object_type, MODEL_TYPE_UNDO_MANAGER), NULL); + spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags); + G_PARAM_SPEC (spec)->value_type = object_type; + return G_PARAM_SPEC (spec); +} + + +gpointer model_value_get_undo_manager (const GValue* value) { + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_UNDO_MANAGER), NULL); + return value->data[0].v_pointer; +} + + +void model_value_set_undo_manager (GValue* value, gpointer v_object) { + ModelUndoManager* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_UNDO_MANAGER)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_UNDO_MANAGER)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + model_undo_manager_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + model_undo_manager_unref (old); + } +} + + +void model_value_take_undo_manager (GValue* value, gpointer v_object) { + ModelUndoManager* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_UNDO_MANAGER)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_UNDO_MANAGER)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + model_undo_manager_unref (old); + } +} + + +static void model_undo_manager_class_init (ModelUndoManagerClass * klass) { + model_undo_manager_parent_class = g_type_class_peek_parent (klass); + MODEL_UNDO_MANAGER_CLASS (klass)->finalize = model_undo_manager_finalize; + g_type_class_add_private (klass, sizeof (ModelUndoManagerPrivate)); + g_signal_new ("undo_changed", MODEL_TYPE_UNDO_MANAGER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1, G_TYPE_BOOLEAN); + g_signal_new ("dirty_changed", MODEL_TYPE_UNDO_MANAGER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1, G_TYPE_BOOLEAN); +} + + +static void model_undo_manager_instance_init (ModelUndoManager * self) { + self->priv = MODEL_UNDO_MANAGER_GET_PRIVATE (self); + self->priv->saved_index = 0; + self->priv->_in_undo = FALSE; + self->priv->command_list = gee_array_list_new (MODEL_TYPE_COMMAND, (GBoxedCopyFunc) model_command_ref, model_command_unref, NULL); + self->ref_count = 1; +} + + +static void model_undo_manager_finalize (ModelUndoManager* obj) { + ModelUndoManager * self; + self = MODEL_UNDO_MANAGER (obj); + _g_object_unref0 (self->priv->command_list); +} + + +GType model_undo_manager_get_type (void) { + static volatile gsize model_undo_manager_type_id__volatile = 0; + if (g_once_init_enter (&model_undo_manager_type_id__volatile)) { + static const GTypeValueTable g_define_type_value_table = { model_value_undo_manager_init, model_value_undo_manager_free_value, model_value_undo_manager_copy_value, model_value_undo_manager_peek_pointer, "p", model_value_undo_manager_collect_value, "p", model_value_undo_manager_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (ModelUndoManagerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_undo_manager_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelUndoManager), 0, (GInstanceInitFunc) model_undo_manager_instance_init, &g_define_type_value_table }; + static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) }; + GType model_undo_manager_type_id; + model_undo_manager_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ModelUndoManager", &g_define_type_info, &g_define_type_fundamental_info, 0); + g_once_init_leave (&model_undo_manager_type_id__volatile, model_undo_manager_type_id); + } + return model_undo_manager_type_id__volatile; +} + + +gpointer model_undo_manager_ref (gpointer instance) { + ModelUndoManager* self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + + +void model_undo_manager_unref (gpointer instance) { + ModelUndoManager* self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + MODEL_UNDO_MANAGER_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + + + + diff --git a/src/marina/marina/UndoManager.o b/src/marina/marina/UndoManager.o new file mode 100644 index 0000000..f64dd91 Binary files /dev/null and b/src/marina/marina/UndoManager.o differ diff --git a/src/marina/marina/clip.c b/src/marina/marina/clip.c new file mode 100644 index 0000000..155620d --- /dev/null +++ b/src/marina/marina/clip.c @@ -0,0 +1,2749 @@ +/* clip.c generated by valac, the Vala compiler + * generated from clip.vala, do not modify */ + +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#define MODEL_TYPE_MEDIA_TYPE (model_media_type_get_type ()) + +#define MODEL_TYPE_GAP (model_gap_get_type ()) +#define MODEL_GAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_GAP, ModelGap)) +#define MODEL_GAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_GAP, ModelGapClass)) +#define MODEL_IS_GAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_GAP)) +#define MODEL_IS_GAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_GAP)) +#define MODEL_GAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_GAP, ModelGapClass)) + +typedef struct _ModelGap ModelGap; +typedef struct _ModelGapClass ModelGapClass; +typedef struct _ModelGapPrivate ModelGapPrivate; +typedef struct _ModelParamSpecGap ModelParamSpecGap; + +#define MODEL_TYPE_CLIP_FILE (model_clip_file_get_type ()) +#define MODEL_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFile)) +#define MODEL_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) +#define MODEL_IS_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE)) +#define MODEL_IS_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE)) +#define MODEL_CLIP_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) + +typedef struct _ModelClipFile ModelClipFile; +typedef struct _ModelClipFileClass ModelClipFileClass; +typedef struct _ModelClipFilePrivate ModelClipFilePrivate; +#define _g_free0(var) (var = (g_free (var), NULL)) +#define _gst_caps_unref0(var) ((var == NULL) ? NULL : (var = (gst_caps_unref (var), NULL))) +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) + +#define LOGGING_TYPE_FACILITY (logging_facility_get_type ()) + +#define LOGGING_TYPE_LEVEL (logging_level_get_type ()) +#define _gst_structure_free0(var) ((var == NULL) ? NULL : (var = (gst_structure_free (var), NULL))) + +#define TYPE_FRACTION (fraction_get_type ()) +typedef struct _Fraction Fraction; + +#define MODEL_TYPE_FETCHER (model_fetcher_get_type ()) +#define MODEL_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_FETCHER, ModelFetcher)) +#define MODEL_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_FETCHER, ModelFetcherClass)) +#define MODEL_IS_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_FETCHER)) +#define MODEL_IS_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_FETCHER)) +#define MODEL_FETCHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_FETCHER, ModelFetcherClass)) + +typedef struct _ModelFetcher ModelFetcher; +typedef struct _ModelFetcherClass ModelFetcherClass; +typedef struct _ModelFetcherPrivate ModelFetcherPrivate; +#define _gst_object_unref0(var) ((var == NULL) ? NULL : (var = (gst_object_unref (var), NULL))) +#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL))) + +#define MODEL_TYPE_CLIP_FETCHER (model_clip_fetcher_get_type ()) +#define MODEL_CLIP_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcher)) +#define MODEL_CLIP_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcherClass)) +#define MODEL_IS_CLIP_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FETCHER)) +#define MODEL_IS_CLIP_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FETCHER)) +#define MODEL_CLIP_FETCHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcherClass)) + +typedef struct _ModelClipFetcher ModelClipFetcher; +typedef struct _ModelClipFetcherClass ModelClipFetcherClass; +typedef struct _ModelClipFetcherPrivate ModelClipFetcherPrivate; + +#define MODEL_TYPE_THUMBNAIL_FETCHER (model_thumbnail_fetcher_get_type ()) +#define MODEL_THUMBNAIL_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_THUMBNAIL_FETCHER, ModelThumbnailFetcher)) +#define MODEL_THUMBNAIL_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_THUMBNAIL_FETCHER, ModelThumbnailFetcherClass)) +#define MODEL_IS_THUMBNAIL_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_THUMBNAIL_FETCHER)) +#define MODEL_IS_THUMBNAIL_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_THUMBNAIL_FETCHER)) +#define MODEL_THUMBNAIL_FETCHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_THUMBNAIL_FETCHER, ModelThumbnailFetcherClass)) + +typedef struct _ModelThumbnailFetcher ModelThumbnailFetcher; +typedef struct _ModelThumbnailFetcherClass ModelThumbnailFetcherClass; +typedef struct _ModelThumbnailFetcherPrivate ModelThumbnailFetcherPrivate; + +#define TYPE_THUMBNAIL_SINK (thumbnail_sink_get_type ()) +#define THUMBNAIL_SINK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_THUMBNAIL_SINK, ThumbnailSink)) +#define THUMBNAIL_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_THUMBNAIL_SINK, ThumbnailSinkClass)) +#define IS_THUMBNAIL_SINK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_THUMBNAIL_SINK)) +#define IS_THUMBNAIL_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_THUMBNAIL_SINK)) +#define THUMBNAIL_SINK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_THUMBNAIL_SINK, ThumbnailSinkClass)) + +typedef struct _ThumbnailSink ThumbnailSink; +typedef struct _ThumbnailSinkClass ThumbnailSinkClass; + +#define TYPE_SINGLE_DECODE_BIN (single_decode_bin_get_type ()) +#define SINGLE_DECODE_BIN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SINGLE_DECODE_BIN, SingleDecodeBin)) +#define SINGLE_DECODE_BIN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SINGLE_DECODE_BIN, SingleDecodeBinClass)) +#define IS_SINGLE_DECODE_BIN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SINGLE_DECODE_BIN)) +#define IS_SINGLE_DECODE_BIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SINGLE_DECODE_BIN)) +#define SINGLE_DECODE_BIN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SINGLE_DECODE_BIN, SingleDecodeBinClass)) + +typedef struct _SingleDecodeBin SingleDecodeBin; +typedef struct _SingleDecodeBinClass SingleDecodeBinClass; + +#define MODEL_TYPE_CLIP (model_clip_get_type ()) +#define MODEL_CLIP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP, ModelClip)) +#define MODEL_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP, ModelClipClass)) +#define MODEL_IS_CLIP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP)) +#define MODEL_IS_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP)) +#define MODEL_CLIP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP, ModelClipClass)) + +typedef struct _ModelClip ModelClip; +typedef struct _ModelClipClass ModelClipClass; +typedef struct _ModelClipPrivate ModelClipPrivate; + +#define MODEL_TYPE_FETCHER_COMPLETION (model_fetcher_completion_get_type ()) +#define MODEL_FETCHER_COMPLETION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_FETCHER_COMPLETION, ModelFetcherCompletion)) +#define MODEL_FETCHER_COMPLETION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_FETCHER_COMPLETION, ModelFetcherCompletionClass)) +#define MODEL_IS_FETCHER_COMPLETION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_FETCHER_COMPLETION)) +#define MODEL_IS_FETCHER_COMPLETION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_FETCHER_COMPLETION)) +#define MODEL_FETCHER_COMPLETION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_FETCHER_COMPLETION, ModelFetcherCompletionClass)) + +typedef struct _ModelFetcherCompletion ModelFetcherCompletion; +typedef struct _ModelFetcherCompletionClass ModelFetcherCompletionClass; +typedef struct _ModelFetcherCompletionPrivate ModelFetcherCompletionPrivate; +typedef struct _ModelParamSpecFetcherCompletion ModelParamSpecFetcherCompletion; + +typedef enum { + MODEL_MEDIA_TYPE_AUDIO, + MODEL_MEDIA_TYPE_VIDEO +} ModelMediaType; + +struct _ModelGap { + GTypeInstance parent_instance; + volatile int ref_count; + ModelGapPrivate * priv; + gint64 start; + gint64 end; +}; + +struct _ModelGapClass { + GTypeClass parent_class; + void (*finalize) (ModelGap *self); +}; + +struct _ModelParamSpecGap { + GParamSpec parent_instance; +}; + +struct _ModelClipFile { + GObject parent_instance; + ModelClipFilePrivate * priv; + char* filename; + GstCaps* video_caps; + GstCaps* audio_caps; + GdkPixbuf* thumbnail; +}; + +struct _ModelClipFileClass { + GObjectClass parent_class; +}; + +struct _ModelClipFilePrivate { + gint64 _length; + gboolean online; +}; + +typedef enum { + LOGGING_FACILITY_SIGNAL_HANDLERS, + LOGGING_FACILITY_DEVELOPER_WARNINGS, + LOGGING_FACILITY_GRAPH, + LOGGING_FACILITY_LOADING, + LOGGING_FACILITY_IMPORT, + LOGGING_FACILITY_SINGLEDECODEBIN +} LoggingFacility; + +typedef enum { + LOGGING_LEVEL_CRITICAL, + LOGGING_LEVEL_HIGH, + LOGGING_LEVEL_MEDIUM, + LOGGING_LEVEL_LOW, + LOGGING_LEVEL_INFO, + LOGGING_LEVEL_VERBOSE +} LoggingLevel; + +struct _Fraction { + gint numerator; + gint denominator; +}; + +struct _ModelFetcher { + GObject parent_instance; + ModelFetcherPrivate * priv; + GstElement* filesrc; + GstElement* decodebin; + GstPipeline* pipeline; + ModelClipFile* clipfile; + char* error_string; +}; + +struct _ModelFetcherClass { + GObjectClass parent_class; + void (*on_pad_added) (ModelFetcher* self, GstPad* pad); + void (*on_state_change) (ModelFetcher* self, GstBus* bus, GstMessage* message); +}; + +struct _ModelClipFetcher { + ModelFetcher parent_instance; + ModelClipFetcherPrivate * priv; +}; + +struct _ModelClipFetcherClass { + ModelFetcherClass parent_class; +}; + +struct _ModelThumbnailFetcher { + ModelFetcher parent_instance; + ModelThumbnailFetcherPrivate * priv; +}; + +struct _ModelThumbnailFetcherClass { + ModelFetcherClass parent_class; +}; + +struct _ModelThumbnailFetcherPrivate { + ThumbnailSink* thumbnail_sink; + GstElement* colorspace; + gint64 seek_position; + gboolean done_seek; + gboolean have_thumbnail; +}; + +struct _ModelClip { + GObject parent_instance; + ModelClipPrivate * priv; + ModelClipFile* clipfile; + ModelMediaType type; + gboolean is_recording; + char* name; +}; + +struct _ModelClipClass { + GObjectClass parent_class; +}; + +struct _ModelClipPrivate { + gint64 _start; + gint64 _media_start; + gint64 _duration; + gboolean connected; +}; + +struct _ModelFetcherCompletion { + GTypeInstance parent_instance; + volatile int ref_count; + ModelFetcherCompletionPrivate * priv; +}; + +struct _ModelFetcherCompletionClass { + GTypeClass parent_class; + void (*finalize) (ModelFetcherCompletion *self); + void (*complete) (ModelFetcherCompletion* self, ModelFetcher* fetcher); +}; + +struct _ModelParamSpecFetcherCompletion { + GParamSpec parent_instance; +}; + + +static gpointer model_gap_parent_class = NULL; +static gpointer model_clip_file_parent_class = NULL; +static gpointer model_fetcher_parent_class = NULL; +static gpointer model_clip_fetcher_parent_class = NULL; +static gpointer model_thumbnail_fetcher_parent_class = NULL; +static gpointer model_clip_parent_class = NULL; +static gpointer model_fetcher_completion_parent_class = NULL; + +GType model_media_type_get_type (void); +gpointer model_gap_ref (gpointer instance); +void model_gap_unref (gpointer instance); +GParamSpec* model_param_spec_gap (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_gap (GValue* value, gpointer v_object); +void model_value_take_gap (GValue* value, gpointer v_object); +gpointer model_value_get_gap (const GValue* value); +GType model_gap_get_type (void); +enum { + MODEL_GAP_DUMMY_PROPERTY +}; +ModelGap* model_gap_new (gint64 start, gint64 end); +ModelGap* model_gap_construct (GType object_type, gint64 start, gint64 end); +gboolean model_gap_is_empty (ModelGap* self); +ModelGap* model_gap_intersect (ModelGap* self, ModelGap* g); +static void model_gap_finalize (ModelGap* obj); +GType model_clip_file_get_type (void); +#define MODEL_CLIP_FILE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_CLIP_FILE, ModelClipFilePrivate)) +enum { + MODEL_CLIP_FILE_DUMMY_PROPERTY, + MODEL_CLIP_FILE_LENGTH +}; +void model_clip_file_set_length (ModelClipFile* self, gint64 value); +ModelClipFile* model_clip_file_new (const char* filename, gint64 length); +ModelClipFile* model_clip_file_construct (GType object_type, const char* filename, gint64 length); +gboolean model_clip_file_is_online (ModelClipFile* self); +GType logging_facility_get_type (void); +GType logging_level_get_type (void); +void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message); +void model_clip_file_set_online (ModelClipFile* self, gboolean o); +void model_clip_file_set_thumbnail (ModelClipFile* self, GdkPixbuf* b); +gboolean model_clip_file_has_caps_structure (ModelClipFile* self, ModelMediaType m); +gboolean model_clip_file_is_of_type (ModelClipFile* self, ModelMediaType t); +static gboolean model_clip_file_get_caps_structure (ModelClipFile* self, ModelMediaType m, GstStructure** s); +GType fraction_get_type (void); +Fraction* fraction_dup (const Fraction* self); +void fraction_free (Fraction* self); +gboolean model_clip_file_get_frame_rate (ModelClipFile* self, Fraction* rate); +gboolean model_clip_file_get_dimensions (ModelClipFile* self, gint* w, gint* h); +gboolean model_clip_file_get_sample_rate (ModelClipFile* self, gint* rate); +gboolean model_clip_file_get_video_format (ModelClipFile* self, guint32* fourcc); +gboolean model_clip_file_get_num_channels (ModelClipFile* self, gint* channels); +gboolean model_clip_file_get_num_channels_string (ModelClipFile* self, char** s); +gint64 model_clip_file_get_length (ModelClipFile* self); +static void model_clip_file_finalize (GObject* obj); +static void model_clip_file_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec); +static void model_clip_file_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec); +GType model_fetcher_get_type (void); +enum { + MODEL_FETCHER_DUMMY_PROPERTY +}; +void model_fetcher_on_pad_added (ModelFetcher* self, GstPad* pad); +static void model_fetcher_real_on_pad_added (ModelFetcher* self, GstPad* pad); +void model_fetcher_on_state_change (ModelFetcher* self, GstBus* bus, GstMessage* message); +static void model_fetcher_real_on_state_change (ModelFetcher* self, GstBus* bus, GstMessage* message); +void model_fetcher_do_error (ModelFetcher* self, const char* _error_); +void model_fetcher_on_warning (ModelFetcher* self, GstBus* bus, GstMessage* message); +void model_fetcher_on_error (ModelFetcher* self, GstBus* bus, GstMessage* message); +ModelFetcher* model_fetcher_construct (GType object_type); +static void model_fetcher_finalize (GObject* obj); +GType model_clip_fetcher_get_type (void); +enum { + MODEL_CLIP_FETCHER_DUMMY_PROPERTY +}; +static void _model_clip_file_set_online_model_clip_fetcher_clipfile_online (ModelClipFetcher* _sender, gboolean online, gpointer self); +GstElement* make_element (const char* name, GError** error); +static void _model_fetcher_on_pad_added_gst_element_pad_added (GstElement* _sender, GstPad* pad, gpointer self); +static void _model_fetcher_on_state_change_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self); +static void _model_fetcher_on_error_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self); +static void _model_fetcher_on_warning_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self); +ModelClipFetcher* model_clip_fetcher_new (const char* filename, GError** error); +ModelClipFetcher* model_clip_fetcher_construct (GType object_type, const char* filename, GError** error); +char* model_clip_fetcher_get_filename (ModelClipFetcher* self); +static void model_clip_fetcher_real_on_pad_added (ModelFetcher* base, GstPad* pad); +static GstPad* model_clip_fetcher_get_pad (ModelClipFetcher* self, const char* prefix); +static void model_clip_fetcher_real_on_state_change (ModelFetcher* base, GstBus* bus, GstMessage* message); +GType model_thumbnail_fetcher_get_type (void); +GType thumbnail_sink_get_type (void); +#define MODEL_THUMBNAIL_FETCHER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_THUMBNAIL_FETCHER, ModelThumbnailFetcherPrivate)) +enum { + MODEL_THUMBNAIL_FETCHER_DUMMY_PROPERTY +}; +SingleDecodeBin* single_decode_bin_new (GstCaps* caps, const char* name, const char* uri, GError** error); +SingleDecodeBin* single_decode_bin_construct (GType object_type, GstCaps* caps, const char* name, const char* uri, GError** error); +GType single_decode_bin_get_type (void); +ThumbnailSink* thumbnail_sink_new (void); +ThumbnailSink* thumbnail_sink_construct (GType object_type); +static void model_thumbnail_fetcher_on_have_thumbnail (ModelThumbnailFetcher* self, GdkPixbuf* buf); +static void _model_thumbnail_fetcher_on_have_thumbnail_thumbnail_sink_have_thumbnail (ThumbnailSink* _sender, GdkPixbuf* b, gpointer self); +ModelThumbnailFetcher* model_thumbnail_fetcher_new (ModelClipFile* f, gint64 time, GError** error); +ModelThumbnailFetcher* model_thumbnail_fetcher_construct (GType object_type, ModelClipFile* f, gint64 time, GError** error); +static void model_thumbnail_fetcher_real_on_pad_added (ModelFetcher* base, GstPad* pad); +static void model_thumbnail_fetcher_real_on_state_change (ModelFetcher* base, GstBus* bus, GstMessage* message); +static void model_thumbnail_fetcher_finalize (GObject* obj); +GType model_clip_get_type (void); +#define MODEL_CLIP_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_CLIP, ModelClipPrivate)) +enum { + MODEL_CLIP_DUMMY_PROPERTY, + MODEL_CLIP_START, + MODEL_CLIP_MEDIA_START, + MODEL_CLIP_DURATION, + MODEL_CLIP_END +}; +void model_clip_set_media_start_duration (ModelClip* self, gint64 media_start, gint64 duration); +void model_clip_set_start (ModelClip* self, gint64 value); +static void model_clip_on_clipfile_updated (ModelClip* self, ModelClipFile* f); +static void _model_clip_on_clipfile_updated_model_clip_file_updated (ModelClipFile* _sender, gpointer self); +ModelClip* model_clip_new (ModelClipFile* clipfile, ModelMediaType t, const char* name, gint64 start, gint64 media_start, gint64 duration, gboolean is_recording); +ModelClip* model_clip_construct (GType object_type, ModelClipFile* clipfile, ModelMediaType t, const char* name, gint64 start, gint64 media_start, gint64 duration, gboolean is_recording); +void model_clip_gnonlin_connect (ModelClip* self); +void model_clip_gnonlin_disconnect (ModelClip* self); +gint64 model_clip_get_media_start (ModelClip* self); +gint64 model_clip_get_duration (ModelClip* self); +gint64 model_clip_get_start (ModelClip* self); +gboolean model_clip_overlap_pos (ModelClip* self, gint64 start, gint64 length); +gboolean time_in_range (gint64 time, gint64 center, gint64 delta); +gint64 model_clip_get_end (ModelClip* self); +gint64 model_clip_snap (ModelClip* self, ModelClip* other, gint64 pad); +gboolean model_clip_snap_coord (ModelClip* self, gint64* s, gint64 span); +ModelClip* model_clip_copy (ModelClip* self); +gboolean model_clip_is_trimmed (ModelClip* self); +void model_clip_set_duration (ModelClip* self, gint64 value); +void model_clip_trim (ModelClip* self, gint64 delta, GdkWindowEdge edge); +void model_clip_save (ModelClip* self, FILE* f, gint id); +static void model_clip_finalize (GObject* obj); +static void model_clip_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec); +static void model_clip_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec); +gpointer model_fetcher_completion_ref (gpointer instance); +void model_fetcher_completion_unref (gpointer instance); +GParamSpec* model_param_spec_fetcher_completion (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_fetcher_completion (GValue* value, gpointer v_object); +void model_value_take_fetcher_completion (GValue* value, gpointer v_object); +gpointer model_value_get_fetcher_completion (const GValue* value); +GType model_fetcher_completion_get_type (void); +enum { + MODEL_FETCHER_COMPLETION_DUMMY_PROPERTY +}; +ModelFetcherCompletion* model_fetcher_completion_new (void); +ModelFetcherCompletion* model_fetcher_completion_construct (GType object_type); +void model_fetcher_completion_complete (ModelFetcherCompletion* self, ModelFetcher* fetcher); +static void model_fetcher_completion_real_complete (ModelFetcherCompletion* self, ModelFetcher* fetcher); +static void model_fetcher_completion_finalize (ModelFetcherCompletion* obj); + + +static void g_cclosure_user_marshal_VOID__INT64 (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data); + +GType model_media_type_get_type (void) { + static volatile gsize model_media_type_type_id__volatile = 0; + if (g_once_init_enter (&model_media_type_type_id__volatile)) { + static const GEnumValue values[] = {{MODEL_MEDIA_TYPE_AUDIO, "MODEL_MEDIA_TYPE_AUDIO", "audio"}, {MODEL_MEDIA_TYPE_VIDEO, "MODEL_MEDIA_TYPE_VIDEO", "video"}, {0, NULL, NULL}}; + GType model_media_type_type_id; + model_media_type_type_id = g_enum_register_static ("ModelMediaType", values); + g_once_init_leave (&model_media_type_type_id__volatile, model_media_type_type_id); + } + return model_media_type_type_id__volatile; +} + + +#line 20 "clip.vala" +ModelGap* model_gap_construct (GType object_type, gint64 start, gint64 end) { +#line 447 "clip.c" + ModelGap* self; + self = (ModelGap*) g_type_create_instance (object_type); +#line 21 "clip.vala" + self->start = start; +#line 22 "clip.vala" + self->end = end; +#line 454 "clip.c" + return self; +} + + +#line 20 "clip.vala" +ModelGap* model_gap_new (gint64 start, gint64 end) { +#line 20 "clip.vala" + return model_gap_construct (MODEL_TYPE_GAP, start, end); +#line 463 "clip.c" +} + + +#line 25 "clip.vala" +gboolean model_gap_is_empty (ModelGap* self) { +#line 469 "clip.c" + gboolean result = FALSE; +#line 25 "clip.vala" + g_return_val_if_fail (MODEL_IS_GAP (self), FALSE); +#line 473 "clip.c" + result = self->start >= self->end; +#line 26 "clip.vala" + return result; +#line 477 "clip.c" +} + + +#line 29 "clip.vala" +ModelGap* model_gap_intersect (ModelGap* self, ModelGap* g) { +#line 483 "clip.c" + ModelGap* result = NULL; +#line 29 "clip.vala" + g_return_val_if_fail (MODEL_IS_GAP (self), NULL); +#line 29 "clip.vala" + g_return_val_if_fail (MODEL_IS_GAP (g), NULL); +#line 489 "clip.c" + result = model_gap_new (MAX (self->start, g->start), MIN (self->end, g->end)); +#line 30 "clip.vala" + return result; +#line 493 "clip.c" +} + + +static void model_value_gap_init (GValue* value) { + value->data[0].v_pointer = NULL; +} + + +static void model_value_gap_free_value (GValue* value) { + if (value->data[0].v_pointer) { + model_gap_unref (value->data[0].v_pointer); + } +} + + +static void model_value_gap_copy_value (const GValue* src_value, GValue* dest_value) { + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = model_gap_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + + +static gpointer model_value_gap_peek_pointer (const GValue* value) { + return value->data[0].v_pointer; +} + + +static gchar* model_value_gap_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + if (collect_values[0].v_pointer) { + ModelGap* object; + object = collect_values[0].v_pointer; + if (object->parent_instance.g_class == NULL) { + return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) { + return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } + value->data[0].v_pointer = model_gap_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + + +static gchar* model_value_gap_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + ModelGap** object_p; + object_p = collect_values[0].v_pointer; + if (!object_p) { + return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); + } + if (!value->data[0].v_pointer) { + *object_p = NULL; + } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) { + *object_p = value->data[0].v_pointer; + } else { + *object_p = model_gap_ref (value->data[0].v_pointer); + } + return NULL; +} + + +GParamSpec* model_param_spec_gap (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) { + ModelParamSpecGap* spec; + g_return_val_if_fail (g_type_is_a (object_type, MODEL_TYPE_GAP), NULL); + spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags); + G_PARAM_SPEC (spec)->value_type = object_type; + return G_PARAM_SPEC (spec); +} + + +gpointer model_value_get_gap (const GValue* value) { + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_GAP), NULL); + return value->data[0].v_pointer; +} + + +void model_value_set_gap (GValue* value, gpointer v_object) { + ModelGap* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_GAP)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_GAP)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + model_gap_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + model_gap_unref (old); + } +} + + +void model_value_take_gap (GValue* value, gpointer v_object) { + ModelGap* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_GAP)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_GAP)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + model_gap_unref (old); + } +} + + +static void model_gap_class_init (ModelGapClass * klass) { + model_gap_parent_class = g_type_class_peek_parent (klass); + MODEL_GAP_CLASS (klass)->finalize = model_gap_finalize; +} + + +static void model_gap_instance_init (ModelGap * self) { + self->ref_count = 1; +} + + +static void model_gap_finalize (ModelGap* obj) { + ModelGap * self; + self = MODEL_GAP (obj); +} + + +GType model_gap_get_type (void) { + static volatile gsize model_gap_type_id__volatile = 0; + if (g_once_init_enter (&model_gap_type_id__volatile)) { + static const GTypeValueTable g_define_type_value_table = { model_value_gap_init, model_value_gap_free_value, model_value_gap_copy_value, model_value_gap_peek_pointer, "p", model_value_gap_collect_value, "p", model_value_gap_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (ModelGapClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_gap_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelGap), 0, (GInstanceInitFunc) model_gap_instance_init, &g_define_type_value_table }; + static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) }; + GType model_gap_type_id; + model_gap_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ModelGap", &g_define_type_info, &g_define_type_fundamental_info, 0); + g_once_init_leave (&model_gap_type_id__volatile, model_gap_type_id); + } + return model_gap_type_id__volatile; +} + + +gpointer model_gap_ref (gpointer instance) { + ModelGap* self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + + +void model_gap_unref (gpointer instance) { + ModelGap* self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + MODEL_GAP_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + + +#line 58 "clip.vala" +ModelClipFile* model_clip_file_construct (GType object_type, const char* filename, gint64 length) { +#line 658 "clip.c" + ModelClipFile * self; + char* _tmp0_; +#line 58 "clip.vala" + g_return_val_if_fail (filename != NULL, NULL); +#line 58 "clip.vala" + self = (ModelClipFile*) g_object_new (object_type, NULL); +#line 59 "clip.vala" + self->filename = (_tmp0_ = g_strdup (filename), _g_free0 (self->filename), _tmp0_); +#line 60 "clip.vala" + model_clip_file_set_length (self, length); +#line 61 "clip.vala" + self->priv->online = FALSE; +#line 671 "clip.c" + return self; +} + + +#line 58 "clip.vala" +ModelClipFile* model_clip_file_new (const char* filename, gint64 length) { +#line 58 "clip.vala" + return model_clip_file_construct (MODEL_TYPE_CLIP_FILE, filename, length); +#line 680 "clip.c" +} + + +#line 64 "clip.vala" +gboolean model_clip_file_is_online (ModelClipFile* self) { +#line 686 "clip.c" + gboolean result = FALSE; +#line 64 "clip.vala" + g_return_val_if_fail (MODEL_IS_CLIP_FILE (self), FALSE); +#line 690 "clip.c" + result = self->priv->online; +#line 65 "clip.vala" + return result; +#line 694 "clip.c" +} + + +#line 68 "clip.vala" +void model_clip_file_set_online (ModelClipFile* self, gboolean o) { +#line 68 "clip.vala" + g_return_if_fail (MODEL_IS_CLIP_FILE (self)); +#line 69 "clip.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "set_online"); +#line 70 "clip.vala" + self->priv->online = o; +#line 71 "clip.vala" + g_signal_emit_by_name (self, "updated"); +#line 708 "clip.c" +} + + +#line 74 "clip.vala" +void model_clip_file_set_thumbnail (ModelClipFile* self, GdkPixbuf* b) { +#line 714 "clip.c" + GdkPixbuf* _tmp0_; +#line 74 "clip.vala" + g_return_if_fail (MODEL_IS_CLIP_FILE (self)); +#line 74 "clip.vala" + g_return_if_fail (GDK_IS_PIXBUF (b)); +#line 79 "clip.vala" + self->thumbnail = (_tmp0_ = gdk_pixbuf_scale_simple (b, 64, 44, GDK_INTERP_BILINEAR), _g_object_unref0 (self->thumbnail), _tmp0_); +#line 722 "clip.c" +} + + +#line 82 "clip.vala" +gboolean model_clip_file_has_caps_structure (ModelClipFile* self, ModelMediaType m) { +#line 728 "clip.c" + gboolean result = FALSE; +#line 82 "clip.vala" + g_return_val_if_fail (MODEL_IS_CLIP_FILE (self), FALSE); +#line 83 "clip.vala" + if (m == MODEL_MEDIA_TYPE_AUDIO) { +#line 734 "clip.c" + gboolean _tmp0_ = FALSE; +#line 84 "clip.vala" + if (self->audio_caps == NULL) { +#line 84 "clip.vala" + _tmp0_ = TRUE; +#line 740 "clip.c" + } else { +#line 84 "clip.vala" + _tmp0_ = gst_caps_get_size (self->audio_caps) < 1; +#line 744 "clip.c" + } +#line 84 "clip.vala" + if (_tmp0_) { +#line 748 "clip.c" + result = FALSE; +#line 85 "clip.vala" + return result; +#line 752 "clip.c" + } + } else { +#line 86 "clip.vala" + if (m == MODEL_MEDIA_TYPE_VIDEO) { +#line 757 "clip.c" + gboolean _tmp1_ = FALSE; +#line 87 "clip.vala" + if (self->video_caps == NULL) { +#line 87 "clip.vala" + _tmp1_ = TRUE; +#line 763 "clip.c" + } else { +#line 87 "clip.vala" + _tmp1_ = gst_caps_get_size (self->video_caps) < 1; +#line 767 "clip.c" + } +#line 87 "clip.vala" + if (_tmp1_) { +#line 771 "clip.c" + result = FALSE; +#line 88 "clip.vala" + return result; +#line 775 "clip.c" + } + } + } + result = TRUE; +#line 90 "clip.vala" + return result; +#line 782 "clip.c" +} + + +#line 93 "clip.vala" +gboolean model_clip_file_is_of_type (ModelClipFile* self, ModelMediaType t) { +#line 788 "clip.c" + gboolean result = FALSE; +#line 93 "clip.vala" + g_return_val_if_fail (MODEL_IS_CLIP_FILE (self), FALSE); +#line 94 "clip.vala" + if (t == MODEL_MEDIA_TYPE_VIDEO) { +#line 794 "clip.c" + result = self->video_caps != NULL; +#line 95 "clip.vala" + return result; +#line 798 "clip.c" + } + result = self->audio_caps != NULL; +#line 96 "clip.vala" + return result; +#line 803 "clip.c" +} + + +static gpointer _gst_structure_copy0 (gpointer self) { + return self ? gst_structure_copy (self) : NULL; +} + + +#line 99 "clip.vala" +static gboolean model_clip_file_get_caps_structure (ModelClipFile* self, ModelMediaType m, GstStructure** s) { +#line 814 "clip.c" + gboolean result = FALSE; +#line 99 "clip.vala" + g_return_val_if_fail (MODEL_IS_CLIP_FILE (self), FALSE); +#line 818 "clip.c" + if (s != NULL) { + *s = NULL; + } +#line 100 "clip.vala" + if (!model_clip_file_has_caps_structure (self, m)) { +#line 824 "clip.c" + result = FALSE; +#line 101 "clip.vala" + return result; +#line 828 "clip.c" + } +#line 102 "clip.vala" + if (m == MODEL_MEDIA_TYPE_AUDIO) { +#line 832 "clip.c" + GstStructure* _tmp0_; +#line 103 "clip.vala" + *s = (_tmp0_ = _gst_structure_copy0 (gst_caps_get_structure (self->audio_caps, (guint) 0)), _gst_structure_free0 (*s), _tmp0_); +#line 836 "clip.c" + } else { +#line 104 "clip.vala" + if (m == MODEL_MEDIA_TYPE_VIDEO) { +#line 840 "clip.c" + GstStructure* _tmp1_; +#line 105 "clip.vala" + *s = (_tmp1_ = _gst_structure_copy0 (gst_caps_get_structure (self->video_caps, (guint) 0)), _gst_structure_free0 (*s), _tmp1_); +#line 844 "clip.c" + } + } + result = TRUE; +#line 107 "clip.vala" + return result; +#line 850 "clip.c" +} + + +#line 110 "clip.vala" +gboolean model_clip_file_get_frame_rate (ModelClipFile* self, Fraction* rate) { +#line 856 "clip.c" + gboolean result = FALSE; + GstStructure* structure; + GstStructure* _tmp2_; + gboolean _tmp1_; + GstStructure* _tmp0_ = NULL; +#line 110 "clip.vala" + g_return_val_if_fail (MODEL_IS_CLIP_FILE (self), FALSE); +#line 864 "clip.c" + structure = NULL; +#line 112 "clip.vala" + if (!(_tmp1_ = model_clip_file_get_caps_structure (self, MODEL_MEDIA_TYPE_VIDEO, &_tmp0_), structure = (_tmp2_ = _tmp0_, _gst_structure_free0 (structure), _tmp2_), _tmp1_)) { +#line 868 "clip.c" + result = FALSE; + _gst_structure_free0 (structure); +#line 113 "clip.vala" + return result; +#line 873 "clip.c" + } + result = gst_structure_get_fraction (structure, "framerate", &(*rate).numerator, &(*rate).denominator); + _gst_structure_free0 (structure); +#line 114 "clip.vala" + return result; +#line 879 "clip.c" +} + + +#line 117 "clip.vala" +gboolean model_clip_file_get_dimensions (ModelClipFile* self, gint* w, gint* h) { +#line 885 "clip.c" + gboolean result = FALSE; + GstStructure* s; + GstStructure* _tmp2_; + gboolean _tmp1_; + GstStructure* _tmp0_ = NULL; + gboolean _tmp3_ = FALSE; +#line 117 "clip.vala" + g_return_val_if_fail (MODEL_IS_CLIP_FILE (self), FALSE); +#line 894 "clip.c" + s = NULL; +#line 120 "clip.vala" + if (!(_tmp1_ = model_clip_file_get_caps_structure (self, MODEL_MEDIA_TYPE_VIDEO, &_tmp0_), s = (_tmp2_ = _tmp0_, _gst_structure_free0 (s), _tmp2_), _tmp1_)) { +#line 898 "clip.c" + result = FALSE; + _gst_structure_free0 (s); +#line 121 "clip.vala" + return result; +#line 903 "clip.c" + } +#line 123 "clip.vala" + if (gst_structure_get_int (s, "width", w)) { +#line 123 "clip.vala" + _tmp3_ = gst_structure_get_int (s, "height", h); +#line 909 "clip.c" + } else { +#line 123 "clip.vala" + _tmp3_ = FALSE; +#line 913 "clip.c" + } + result = _tmp3_; + _gst_structure_free0 (s); +#line 123 "clip.vala" + return result; +#line 919 "clip.c" +} + + +#line 126 "clip.vala" +gboolean model_clip_file_get_sample_rate (ModelClipFile* self, gint* rate) { +#line 925 "clip.c" + gboolean result = FALSE; + GstStructure* s; + GstStructure* _tmp2_; + gboolean _tmp1_; + GstStructure* _tmp0_ = NULL; +#line 126 "clip.vala" + g_return_val_if_fail (MODEL_IS_CLIP_FILE (self), FALSE); +#line 933 "clip.c" + s = NULL; +#line 128 "clip.vala" + if (!(_tmp1_ = model_clip_file_get_caps_structure (self, MODEL_MEDIA_TYPE_AUDIO, &_tmp0_), s = (_tmp2_ = _tmp0_, _gst_structure_free0 (s), _tmp2_), _tmp1_)) { +#line 937 "clip.c" + result = FALSE; + _gst_structure_free0 (s); +#line 129 "clip.vala" + return result; +#line 942 "clip.c" + } + result = gst_structure_get_int (s, "rate", rate); + _gst_structure_free0 (s); +#line 131 "clip.vala" + return result; +#line 948 "clip.c" +} + + +#line 134 "clip.vala" +gboolean model_clip_file_get_video_format (ModelClipFile* self, guint32* fourcc) { +#line 954 "clip.c" + gboolean result = FALSE; + GstStructure* s; + GstStructure* _tmp2_; + gboolean _tmp1_; + GstStructure* _tmp0_ = NULL; +#line 134 "clip.vala" + g_return_val_if_fail (MODEL_IS_CLIP_FILE (self), FALSE); +#line 962 "clip.c" + s = NULL; +#line 137 "clip.vala" + if (!(_tmp1_ = model_clip_file_get_caps_structure (self, MODEL_MEDIA_TYPE_VIDEO, &_tmp0_), s = (_tmp2_ = _tmp0_, _gst_structure_free0 (s), _tmp2_), _tmp1_)) { +#line 966 "clip.c" + result = FALSE; + _gst_structure_free0 (s); +#line 138 "clip.vala" + return result; +#line 971 "clip.c" + } + result = gst_structure_get_fourcc (s, "format", fourcc); + _gst_structure_free0 (s); +#line 140 "clip.vala" + return result; +#line 977 "clip.c" +} + + +#line 143 "clip.vala" +gboolean model_clip_file_get_num_channels (ModelClipFile* self, gint* channels) { +#line 983 "clip.c" + gboolean result = FALSE; + GstStructure* s; + GstStructure* _tmp2_; + gboolean _tmp1_; + GstStructure* _tmp0_ = NULL; +#line 143 "clip.vala" + g_return_val_if_fail (MODEL_IS_CLIP_FILE (self), FALSE); +#line 991 "clip.c" + s = NULL; +#line 145 "clip.vala" + if (!(_tmp1_ = model_clip_file_get_caps_structure (self, MODEL_MEDIA_TYPE_AUDIO, &_tmp0_), s = (_tmp2_ = _tmp0_, _gst_structure_free0 (s), _tmp2_), _tmp1_)) { +#line 995 "clip.c" + result = FALSE; + _gst_structure_free0 (s); +#line 146 "clip.vala" + return result; +#line 1000 "clip.c" + } + result = gst_structure_get_int (s, "channels", channels); + _gst_structure_free0 (s); +#line 149 "clip.vala" + return result; +#line 1006 "clip.c" +} + + +#line 152 "clip.vala" +gboolean model_clip_file_get_num_channels_string (ModelClipFile* self, char** s) { +#line 1012 "clip.c" + gboolean result = FALSE; + gint i = 0; +#line 152 "clip.vala" + g_return_val_if_fail (MODEL_IS_CLIP_FILE (self), FALSE); +#line 1017 "clip.c" + if (s != NULL) { + *s = NULL; + } +#line 154 "clip.vala" + if (!model_clip_file_get_num_channels (self, &i)) { +#line 1023 "clip.c" + result = FALSE; +#line 155 "clip.vala" + return result; +#line 1027 "clip.c" + } +#line 157 "clip.vala" + if (i == 1) { +#line 1031 "clip.c" + char* _tmp0_; +#line 158 "clip.vala" + *s = (_tmp0_ = g_strdup ("Mono"), _g_free0 (*s), _tmp0_); +#line 1035 "clip.c" + } else { +#line 159 "clip.vala" + if (i == 2) { +#line 1039 "clip.c" + char* _tmp1_; +#line 160 "clip.vala" + *s = (_tmp1_ = g_strdup ("Stereo"), _g_free0 (*s), _tmp1_); +#line 1043 "clip.c" + } else { +#line 161 "clip.vala" + if ((i % 2) == 0) { +#line 1047 "clip.c" + char* _tmp2_; +#line 162 "clip.vala" + *s = (_tmp2_ = g_strdup_printf ("Surround %d.1", i - 1), _g_free0 (*s), _tmp2_); +#line 1051 "clip.c" + } else { + char* _tmp3_; +#line 164 "clip.vala" + *s = (_tmp3_ = g_strdup_printf ("%d", i), _g_free0 (*s), _tmp3_); +#line 1056 "clip.c" + } + } + } + result = TRUE; +#line 165 "clip.vala" + return result; +#line 1063 "clip.c" +} + + +gint64 model_clip_file_get_length (ModelClipFile* self) { + gint64 result; + g_return_val_if_fail (MODEL_IS_CLIP_FILE (self), 0LL); +#line 39 "clip.vala" + if (!self->priv->online) { +#line 40 "clip.vala" + g_warning ("clip.vala:40: retrieving length while clip offline"); +#line 1074 "clip.c" + } + result = self->priv->_length; +#line 42 "clip.vala" + return result; +#line 1079 "clip.c" +} + + +void model_clip_file_set_length (ModelClipFile* self, gint64 value) { + g_return_if_fail (MODEL_IS_CLIP_FILE (self)); +#line 46 "clip.vala" + self->priv->_length = value; +#line 1087 "clip.c" + g_object_notify ((GObject *) self, "length"); +} + + +static void model_clip_file_class_init (ModelClipFileClass * klass) { + model_clip_file_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ModelClipFilePrivate)); + G_OBJECT_CLASS (klass)->get_property = model_clip_file_get_property; + G_OBJECT_CLASS (klass)->set_property = model_clip_file_set_property; + G_OBJECT_CLASS (klass)->finalize = model_clip_file_finalize; + g_object_class_install_property (G_OBJECT_CLASS (klass), MODEL_CLIP_FILE_LENGTH, g_param_spec_int64 ("length", "length", "length", G_MININT64, G_MAXINT64, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE)); + g_signal_new ("updated", MODEL_TYPE_CLIP_FILE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); +} + + +static void model_clip_file_instance_init (ModelClipFile * self) { + self->priv = MODEL_CLIP_FILE_GET_PRIVATE (self); + self->thumbnail = NULL; +} + + +static void model_clip_file_finalize (GObject* obj) { + ModelClipFile * self; + self = MODEL_CLIP_FILE (obj); + _g_free0 (self->filename); + _gst_caps_unref0 (self->video_caps); + _gst_caps_unref0 (self->audio_caps); + _g_object_unref0 (self->thumbnail); + G_OBJECT_CLASS (model_clip_file_parent_class)->finalize (obj); +} + + +GType model_clip_file_get_type (void) { + static volatile gsize model_clip_file_type_id__volatile = 0; + if (g_once_init_enter (&model_clip_file_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelClipFileClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_clip_file_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelClipFile), 0, (GInstanceInitFunc) model_clip_file_instance_init, NULL }; + GType model_clip_file_type_id; + model_clip_file_type_id = g_type_register_static (G_TYPE_OBJECT, "ModelClipFile", &g_define_type_info, 0); + g_once_init_leave (&model_clip_file_type_id__volatile, model_clip_file_type_id); + } + return model_clip_file_type_id__volatile; +} + + +static void model_clip_file_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) { + ModelClipFile * self; + self = MODEL_CLIP_FILE (object); + switch (property_id) { + case MODEL_CLIP_FILE_LENGTH: + g_value_set_int64 (value, model_clip_file_get_length (self)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + + +static void model_clip_file_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) { + ModelClipFile * self; + self = MODEL_CLIP_FILE (object); + switch (property_id) { + case MODEL_CLIP_FILE_LENGTH: + model_clip_file_set_length (self, g_value_get_int64 (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + + +#line 177 "clip.vala" +static void model_fetcher_real_on_pad_added (ModelFetcher* self, GstPad* pad) { +#line 1162 "clip.c" + g_return_if_fail (MODEL_IS_FETCHER (self)); + g_critical ("Type `%s' does not implement abstract method `model_fetcher_on_pad_added'", g_type_name (G_TYPE_FROM_INSTANCE (self))); + return; +} + + +#line 177 "clip.vala" +void model_fetcher_on_pad_added (ModelFetcher* self, GstPad* pad) { +#line 177 "clip.vala" + MODEL_FETCHER_GET_CLASS (self)->on_pad_added (self, pad); +#line 1173 "clip.c" +} + + +#line 178 "clip.vala" +static void model_fetcher_real_on_state_change (ModelFetcher* self, GstBus* bus, GstMessage* message) { +#line 1179 "clip.c" + g_return_if_fail (MODEL_IS_FETCHER (self)); + g_critical ("Type `%s' does not implement abstract method `model_fetcher_on_state_change'", g_type_name (G_TYPE_FROM_INSTANCE (self))); + return; +} + + +#line 178 "clip.vala" +void model_fetcher_on_state_change (ModelFetcher* self, GstBus* bus, GstMessage* message) { +#line 178 "clip.vala" + MODEL_FETCHER_GET_CLASS (self)->on_state_change (self, bus, message); +#line 1190 "clip.c" +} + + +#line 182 "clip.vala" +void model_fetcher_do_error (ModelFetcher* self, const char* _error_) { +#line 1196 "clip.c" + char* _tmp0_; +#line 182 "clip.vala" + g_return_if_fail (MODEL_IS_FETCHER (self)); +#line 182 "clip.vala" + g_return_if_fail (_error_ != NULL); +#line 183 "clip.vala" + self->error_string = (_tmp0_ = g_strdup (_error_), _g_free0 (self->error_string), _tmp0_); +#line 184 "clip.vala" + gst_element_set_state (GST_ELEMENT (self->pipeline), GST_STATE_NULL); +#line 1206 "clip.c" +} + + +#line 187 "clip.vala" +void model_fetcher_on_warning (ModelFetcher* self, GstBus* bus, GstMessage* message) { +#line 1212 "clip.c" + GError* _error_; + char* text; + char* _tmp3_; + char* _tmp2_ = NULL; + GError* _tmp1_; + GError* _tmp0_ = NULL; +#line 187 "clip.vala" + g_return_if_fail (MODEL_IS_FETCHER (self)); +#line 187 "clip.vala" + g_return_if_fail (GST_IS_BUS (bus)); +#line 187 "clip.vala" + g_return_if_fail (GST_IS_MESSAGE (message)); +#line 188 "clip.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_warning"); +#line 1227 "clip.c" + _error_ = NULL; + text = NULL; +#line 191 "clip.vala" + (gst_message_parse_warning (message, &_tmp0_, &_tmp2_), _error_ = (_tmp1_ = _tmp0_, _g_error_free0 (_error_), _tmp1_)); +#line 191 "clip.vala" + text = (_tmp3_ = _tmp2_, _g_free0 (text), _tmp3_); +#line 192 "clip.vala" + g_warning ("clip.vala:192: %s", text); +#line 1236 "clip.c" + _g_error_free0 (_error_); + _g_free0 (text); +} + + +#line 195 "clip.vala" +void model_fetcher_on_error (ModelFetcher* self, GstBus* bus, GstMessage* message) { +#line 1244 "clip.c" + GError* _error_; + char* text; + char* _tmp3_; + char* _tmp2_ = NULL; + GError* _tmp1_; + GError* _tmp0_ = NULL; +#line 195 "clip.vala" + g_return_if_fail (MODEL_IS_FETCHER (self)); +#line 195 "clip.vala" + g_return_if_fail (GST_IS_BUS (bus)); +#line 195 "clip.vala" + g_return_if_fail (GST_IS_MESSAGE (message)); +#line 196 "clip.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_error"); +#line 1259 "clip.c" + _error_ = NULL; + text = NULL; +#line 199 "clip.vala" + (gst_message_parse_error (message, &_tmp0_, &_tmp2_), _error_ = (_tmp1_ = _tmp0_, _g_error_free0 (_error_), _tmp1_)); +#line 199 "clip.vala" + text = (_tmp3_ = _tmp2_, _g_free0 (text), _tmp3_); +#line 200 "clip.vala" + model_fetcher_do_error (self, text); +#line 1268 "clip.c" + _g_error_free0 (_error_); + _g_free0 (text); +} + + +#line 169 "clip.vala" +ModelFetcher* model_fetcher_construct (GType object_type) { +#line 1276 "clip.c" + ModelFetcher * self; +#line 169 "clip.vala" + self = (ModelFetcher*) g_object_new (object_type, NULL); +#line 1280 "clip.c" + return self; +} + + +static void model_fetcher_class_init (ModelFetcherClass * klass) { + model_fetcher_parent_class = g_type_class_peek_parent (klass); + MODEL_FETCHER_CLASS (klass)->on_pad_added = model_fetcher_real_on_pad_added; + MODEL_FETCHER_CLASS (klass)->on_state_change = model_fetcher_real_on_state_change; + G_OBJECT_CLASS (klass)->finalize = model_fetcher_finalize; + g_signal_new ("ready", MODEL_TYPE_FETCHER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_FETCHER); +} + + +static void model_fetcher_instance_init (ModelFetcher * self) { +} + + +static void model_fetcher_finalize (GObject* obj) { + ModelFetcher * self; + self = MODEL_FETCHER (obj); + _gst_object_unref0 (self->filesrc); + _gst_object_unref0 (self->decodebin); + _gst_object_unref0 (self->pipeline); + _g_object_unref0 (self->clipfile); + _g_free0 (self->error_string); + G_OBJECT_CLASS (model_fetcher_parent_class)->finalize (obj); +} + + +GType model_fetcher_get_type (void) { + static volatile gsize model_fetcher_type_id__volatile = 0; + if (g_once_init_enter (&model_fetcher_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelFetcherClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_fetcher_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelFetcher), 0, (GInstanceInitFunc) model_fetcher_instance_init, NULL }; + GType model_fetcher_type_id; + model_fetcher_type_id = g_type_register_static (G_TYPE_OBJECT, "ModelFetcher", &g_define_type_info, G_TYPE_FLAG_ABSTRACT); + g_once_init_leave (&model_fetcher_type_id__volatile, model_fetcher_type_id); + } + return model_fetcher_type_id__volatile; +} + + +#line 68 "clip.vala" +static void _model_clip_file_set_online_model_clip_fetcher_clipfile_online (ModelClipFetcher* _sender, gboolean online, gpointer self) { +#line 1324 "clip.c" + model_clip_file_set_online (self, online); +} + + +static gpointer _gst_object_ref0 (gpointer self) { + return self ? gst_object_ref (self) : NULL; +} + + +#line 177 "clip.vala" +static void _model_fetcher_on_pad_added_gst_element_pad_added (GstElement* _sender, GstPad* pad, gpointer self) { +#line 1336 "clip.c" + model_fetcher_on_pad_added (self, pad); +} + + +#line 178 "clip.vala" +static void _model_fetcher_on_state_change_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self) { +#line 1343 "clip.c" + model_fetcher_on_state_change (self, _sender, message); +} + + +#line 195 "clip.vala" +static void _model_fetcher_on_error_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self) { +#line 1350 "clip.c" + model_fetcher_on_error (self, _sender, message); +} + + +#line 187 "clip.vala" +static void _model_fetcher_on_warning_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self) { +#line 1357 "clip.c" + model_fetcher_on_warning (self, _sender, message); +} + + +#line 207 "clip.vala" +ModelClipFetcher* model_clip_fetcher_construct (GType object_type, const char* filename, GError** error) { +#line 1364 "clip.c" + GError * _inner_error_; + ModelClipFetcher * self; + ModelClipFile* _tmp1_; + ModelClipFile* *_tmp0_; + GstElement* _tmp2_; + GstElement* _tmp4_; + GstElement* *_tmp3_; + GstElement* _tmp5_; + GstElement* _tmp7_; + GstElement* *_tmp6_; + GstPipeline* _tmp9_; + GstPipeline* *_tmp8_; + GstBus* bus; + char* _tmp11_; + char* *_tmp10_; +#line 207 "clip.vala" + g_return_val_if_fail (filename != NULL, NULL); +#line 1382 "clip.c" + _inner_error_ = NULL; +#line 207 "clip.vala" + self = (ModelClipFetcher*) model_fetcher_construct (object_type); +#line 208 "clip.vala" + _tmp0_ = &MODEL_FETCHER (self)->clipfile; +#line 208 "clip.vala" + (*_tmp0_) = (_tmp1_ = model_clip_file_new (filename, 0), _g_object_unref0 ((*_tmp0_)), _tmp1_); +#line 210 "clip.vala" + g_signal_connect_object (self, "clipfile-online", (GCallback) _model_clip_file_set_online_model_clip_fetcher_clipfile_online, MODEL_FETCHER (self)->clipfile, 0); +#line 212 "clip.vala" + _tmp2_ = make_element ("filesrc", &_inner_error_); +#line 1394 "clip.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 212 "clip.vala" + _tmp3_ = &MODEL_FETCHER (self)->filesrc; +#line 212 "clip.vala" + (*_tmp3_) = (_tmp4_ = _tmp2_, _gst_object_unref0 ((*_tmp3_)), _tmp4_); +#line 213 "clip.vala" + g_object_set (G_OBJECT (MODEL_FETCHER (self)->filesrc), "location", filename, NULL); +#line 215 "clip.vala" + _tmp5_ = make_element ("decodebin", &_inner_error_); +#line 1408 "clip.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 215 "clip.vala" + _tmp6_ = &MODEL_FETCHER (self)->decodebin; +#line 215 "clip.vala" + (*_tmp6_) = (_tmp7_ = GST_ELEMENT (GST_BIN (_tmp5_)), _gst_object_unref0 ((*_tmp6_)), _tmp7_); +#line 216 "clip.vala" + _tmp8_ = &MODEL_FETCHER (self)->pipeline; +#line 216 "clip.vala" + (*_tmp8_) = (_tmp9_ = (GstPipeline*) gst_pipeline_new ("pipeline"), _gst_object_unref0 ((*_tmp8_)), _tmp9_); +#line 217 "clip.vala" + gst_pipeline_set_auto_flush_bus (MODEL_FETCHER (self)->pipeline, FALSE); +#line 218 "clip.vala" + if (MODEL_FETCHER (self)->pipeline == NULL) { +#line 219 "clip.vala" + g_error ("clip.vala:219: can't construct pipeline"); +#line 1428 "clip.c" + } +#line 220 "clip.vala" + gst_bin_add_many (GST_BIN (MODEL_FETCHER (self)->pipeline), _gst_object_ref0 (MODEL_FETCHER (self)->filesrc), _gst_object_ref0 (MODEL_FETCHER (self)->decodebin), NULL); +#line 222 "clip.vala" + if (!gst_element_link (MODEL_FETCHER (self)->filesrc, MODEL_FETCHER (self)->decodebin)) { +#line 223 "clip.vala" + g_error ("clip.vala:223: can't link filesrc"); +#line 1436 "clip.c" + } +#line 224 "clip.vala" + g_signal_connect_object (MODEL_FETCHER (self)->decodebin, "pad-added", (GCallback) _model_fetcher_on_pad_added_gst_element_pad_added, MODEL_FETCHER (self), 0); +#line 226 "clip.vala" + bus = gst_pipeline_get_bus (MODEL_FETCHER (self)->pipeline); +#line 228 "clip.vala" + gst_bus_add_signal_watch (bus); +#line 229 "clip.vala" + g_signal_connect_object (bus, "message::state-changed", (GCallback) _model_fetcher_on_state_change_gst_bus_message, MODEL_FETCHER (self), 0); +#line 230 "clip.vala" + g_signal_connect_object (bus, "message::error", (GCallback) _model_fetcher_on_error_gst_bus_message, MODEL_FETCHER (self), 0); +#line 231 "clip.vala" + g_signal_connect_object (bus, "message::warning", (GCallback) _model_fetcher_on_warning_gst_bus_message, MODEL_FETCHER (self), 0); +#line 233 "clip.vala" + _tmp10_ = &MODEL_FETCHER (self)->error_string; +#line 233 "clip.vala" + (*_tmp10_) = (_tmp11_ = NULL, _g_free0 ((*_tmp10_)), _tmp11_); +#line 234 "clip.vala" + gst_element_set_state (GST_ELEMENT (MODEL_FETCHER (self)->pipeline), GST_STATE_PLAYING); +#line 1456 "clip.c" + _gst_object_unref0 (bus); + return self; +} + + +#line 207 "clip.vala" +ModelClipFetcher* model_clip_fetcher_new (const char* filename, GError** error) { +#line 207 "clip.vala" + return model_clip_fetcher_construct (MODEL_TYPE_CLIP_FETCHER, filename, error); +#line 1466 "clip.c" +} + + +#line 237 "clip.vala" +char* model_clip_fetcher_get_filename (ModelClipFetcher* self) { +#line 1472 "clip.c" + char* result = NULL; +#line 237 "clip.vala" + g_return_val_if_fail (MODEL_IS_CLIP_FETCHER (self), NULL); +#line 1476 "clip.c" + result = g_strdup (MODEL_FETCHER (self)->clipfile->filename); +#line 237 "clip.vala" + return result; +#line 1480 "clip.c" +} + + +#line 239 "clip.vala" +static void model_clip_fetcher_real_on_pad_added (ModelFetcher* base, GstPad* pad) { +#line 1486 "clip.c" + ModelClipFetcher * self; + GError * _inner_error_; + GstPad* fake_pad; + GstElement* fake_sink; + self = MODEL_CLIP_FETCHER (base); +#line 239 "clip.vala" + g_return_if_fail (GST_IS_PAD (pad)); +#line 1494 "clip.c" + _inner_error_ = NULL; +#line 240 "clip.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_pad_added"); +#line 1498 "clip.c" + fake_pad = NULL; + fake_sink = NULL; + { + char* _tmp2_; + GstCaps* _tmp1_; + GstCaps* _tmp0_ = NULL; + gboolean _tmp3_; +#line 244 "clip.vala" + if ((_tmp3_ = g_str_has_prefix (_tmp2_ = gst_caps_to_string (_tmp1_ = (g_object_get (pad, "caps", &_tmp0_, NULL), _tmp0_)), "video"), _g_free0 (_tmp2_), _gst_caps_unref0 (_tmp1_), _tmp3_)) { +#line 1508 "clip.c" + GstElement* _tmp4_; + GstElement* _tmp5_; + GstPad* _tmp6_; +#line 245 "clip.vala" + _tmp4_ = make_element ("fakesink", &_inner_error_); +#line 1514 "clip.c" + if (_inner_error_ != NULL) { + goto __catch4_g_error; + } +#line 245 "clip.vala" + fake_sink = (_tmp5_ = _tmp4_, _gst_object_unref0 (fake_sink), _tmp5_); +#line 246 "clip.vala" + gst_bin_add (GST_BIN (MODEL_FETCHER (self)->pipeline), _gst_object_ref0 (fake_sink)); +#line 247 "clip.vala" + fake_pad = (_tmp6_ = gst_element_get_static_pad (fake_sink, "sink"), _gst_object_unref0 (fake_pad), _tmp6_); +#line 249 "clip.vala" + if (!gst_element_sync_state_with_parent (fake_sink)) { +#line 250 "clip.vala" + g_error ("clip.vala:250: could not sync state with parent"); +#line 1528 "clip.c" + } + } else { + GstElement* _tmp7_; + GstElement* _tmp8_; + GstPad* _tmp9_; +#line 253 "clip.vala" + _tmp7_ = make_element ("fakesink", &_inner_error_); +#line 1536 "clip.c" + if (_inner_error_ != NULL) { + goto __catch4_g_error; + } +#line 253 "clip.vala" + fake_sink = (_tmp8_ = _tmp7_, _gst_object_unref0 (fake_sink), _tmp8_); +#line 254 "clip.vala" + gst_bin_add (GST_BIN (MODEL_FETCHER (self)->pipeline), _gst_object_ref0 (fake_sink)); +#line 255 "clip.vala" + fake_pad = (_tmp9_ = gst_element_get_static_pad (fake_sink, "sink"), _gst_object_unref0 (fake_pad), _tmp9_); +#line 257 "clip.vala" + if (!gst_element_sync_state_with_parent (fake_sink)) { +#line 258 "clip.vala" + g_error ("clip.vala:258: could not sync state with parent"); +#line 1550 "clip.c" + } + } +#line 261 "clip.vala" + gst_pad_link (pad, fake_pad); +#line 1555 "clip.c" + } + goto __finally4; + __catch4_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { + _g_error_free0 (e); + } + } + __finally4: + if (_inner_error_ != NULL) { + _gst_object_unref0 (fake_pad); + _gst_object_unref0 (fake_sink); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } + _gst_object_unref0 (fake_pad); + _gst_object_unref0 (fake_sink); +} + + +#line 267 "clip.vala" +static GstPad* model_clip_fetcher_get_pad (ModelClipFetcher* self, const char* prefix) { +#line 1582 "clip.c" + GstPad* result = NULL; +#line 267 "clip.vala" + g_return_val_if_fail (MODEL_IS_CLIP_FETCHER (self), NULL); +#line 267 "clip.vala" + g_return_val_if_fail (prefix != NULL, NULL); +#line 1588 "clip.c" + { + GList* pad_collection; + GList* pad_it; +#line 268 "clip.vala" + pad_collection = MODEL_FETCHER (self)->decodebin->pads; +#line 1594 "clip.c" + for (pad_it = pad_collection; pad_it != NULL; pad_it = pad_it->next) { + GstPad* pad; +#line 268 "clip.vala" + pad = _gst_object_ref0 ((GstPad*) pad_it->data); +#line 1599 "clip.c" + { + GstCaps* _tmp1_; + GstCaps* _tmp0_ = NULL; + char* _tmp2_; + char* caps; +#line 269 "clip.vala" + caps = (_tmp2_ = gst_caps_to_string (_tmp1_ = (g_object_get (pad, "caps", &_tmp0_, NULL), _tmp0_)), _gst_caps_unref0 (_tmp1_), _tmp2_); +#line 270 "clip.vala" + if (g_str_has_prefix (caps, prefix)) { +#line 1609 "clip.c" + result = pad; + _g_free0 (caps); +#line 271 "clip.vala" + return result; +#line 1614 "clip.c" + } + _gst_object_unref0 (pad); + _g_free0 (caps); + } + } + } + result = NULL; +#line 274 "clip.vala" + return result; +#line 1624 "clip.c" +} + + +#line 277 "clip.vala" +static void model_clip_fetcher_real_on_state_change (ModelFetcher* base, GstBus* bus, GstMessage* message) { +#line 1630 "clip.c" + ModelClipFetcher * self; + GstState old_state = 0; + GstState new_state = 0; + GstState pending = 0; + self = MODEL_CLIP_FETCHER (base); +#line 277 "clip.vala" + g_return_if_fail (GST_IS_BUS (bus)); +#line 277 "clip.vala" + g_return_if_fail (GST_IS_MESSAGE (message)); +#line 278 "clip.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_state_change"); +#line 279 "clip.vala" + if (message->src != GST_OBJECT (MODEL_FETCHER (self)->pipeline)) { +#line 280 "clip.vala" + return; +#line 1646 "clip.c" + } +#line 286 "clip.vala" + gst_message_parse_state_changed (message, &old_state, &new_state, &pending); +#line 287 "clip.vala" + if (new_state == old_state) { +#line 288 "clip.vala" + return; +#line 1654 "clip.c" + } +#line 290 "clip.vala" + if (new_state == GST_STATE_PLAYING) { +#line 1658 "clip.c" + GstPad* pad; + GstPad* _tmp3_; + GstFormat format; + gint64 length = 0LL; + gboolean _tmp7_ = FALSE; +#line 291 "clip.vala" + pad = model_clip_fetcher_get_pad (self, "video"); +#line 292 "clip.vala" + if (pad != NULL) { +#line 1668 "clip.c" + GstCaps* _tmp2_; + GstCaps* *_tmp1_; + GstCaps* _tmp0_ = NULL; +#line 293 "clip.vala" + _tmp1_ = &MODEL_FETCHER (self)->clipfile->video_caps; +#line 293 "clip.vala" + (*_tmp1_) = (_tmp2_ = (g_object_get (pad, "caps", &_tmp0_, NULL), _tmp0_), _gst_caps_unref0 ((*_tmp1_)), _tmp2_); +#line 1676 "clip.c" + } +#line 296 "clip.vala" + pad = (_tmp3_ = model_clip_fetcher_get_pad (self, "audio"), _gst_object_unref0 (pad), _tmp3_); +#line 297 "clip.vala" + if (pad != NULL) { +#line 1682 "clip.c" + GstCaps* _tmp6_; + GstCaps* *_tmp5_; + GstCaps* _tmp4_ = NULL; +#line 298 "clip.vala" + _tmp5_ = &MODEL_FETCHER (self)->clipfile->audio_caps; +#line 298 "clip.vala" + (*_tmp5_) = (_tmp6_ = (g_object_get (pad, "caps", &_tmp4_, NULL), _tmp4_), _gst_caps_unref0 ((*_tmp5_)), _tmp6_); +#line 1690 "clip.c" + } +#line 301 "clip.vala" + format = GST_FORMAT_TIME; +#line 303 "clip.vala" + if (!gst_element_query_duration (GST_ELEMENT (MODEL_FETCHER (self)->pipeline), &format, &length)) { +#line 303 "clip.vala" + _tmp7_ = TRUE; +#line 1698 "clip.c" + } else { +#line 304 "clip.vala" + _tmp7_ = format != GST_FORMAT_TIME; +#line 1702 "clip.c" + } +#line 303 "clip.vala" + if (_tmp7_) { +#line 305 "clip.vala" + model_fetcher_do_error (MODEL_FETCHER (self), "Can't fetch length"); +#line 1708 "clip.c" + _gst_object_unref0 (pad); +#line 306 "clip.vala" + return; +#line 1712 "clip.c" + } +#line 308 "clip.vala" + model_clip_file_set_length (MODEL_FETCHER (self)->clipfile, length); +#line 310 "clip.vala" + g_signal_emit_by_name (self, "clipfile-online", TRUE); +#line 311 "clip.vala" + gst_element_set_state (GST_ELEMENT (MODEL_FETCHER (self)->pipeline), GST_STATE_NULL); +#line 1720 "clip.c" + _gst_object_unref0 (pad); + } else { +#line 312 "clip.vala" + if (new_state == GST_STATE_NULL) { +#line 313 "clip.vala" + g_signal_emit_by_name (MODEL_FETCHER (self), "ready", MODEL_FETCHER (self)); +#line 1727 "clip.c" + } + } +} + + +static void model_clip_fetcher_class_init (ModelClipFetcherClass * klass) { + model_clip_fetcher_parent_class = g_type_class_peek_parent (klass); + MODEL_FETCHER_CLASS (klass)->on_pad_added = model_clip_fetcher_real_on_pad_added; + MODEL_FETCHER_CLASS (klass)->on_state_change = model_clip_fetcher_real_on_state_change; + g_signal_new ("clipfile_online", MODEL_TYPE_CLIP_FETCHER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1, G_TYPE_BOOLEAN); +} + + +static void model_clip_fetcher_instance_init (ModelClipFetcher * self) { +} + + +GType model_clip_fetcher_get_type (void) { + static volatile gsize model_clip_fetcher_type_id__volatile = 0; + if (g_once_init_enter (&model_clip_fetcher_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelClipFetcherClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_clip_fetcher_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelClipFetcher), 0, (GInstanceInitFunc) model_clip_fetcher_instance_init, NULL }; + GType model_clip_fetcher_type_id; + model_clip_fetcher_type_id = g_type_register_static (MODEL_TYPE_FETCHER, "ModelClipFetcher", &g_define_type_info, 0); + g_once_init_leave (&model_clip_fetcher_type_id__volatile, model_clip_fetcher_type_id); + } + return model_clip_fetcher_type_id__volatile; +} + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 359 "clip.vala" +static void _model_thumbnail_fetcher_on_have_thumbnail_thumbnail_sink_have_thumbnail (ThumbnailSink* _sender, GdkPixbuf* b, gpointer self) { +#line 1764 "clip.c" + model_thumbnail_fetcher_on_have_thumbnail (self, b); +} + + +#line 325 "clip.vala" +ModelThumbnailFetcher* model_thumbnail_fetcher_construct (GType object_type, ModelClipFile* f, gint64 time, GError** error) { +#line 1771 "clip.c" + GError * _inner_error_; + ModelThumbnailFetcher * self; + ModelClipFile* _tmp1_; + ModelClipFile* *_tmp0_; + GstCaps* _tmp2_; + SingleDecodeBin* _tmp3_; + SingleDecodeBin* single_bin; + GstPipeline* _tmp5_; + GstPipeline* *_tmp4_; + ThumbnailSink* _tmp6_; + GstElement* _tmp7_; + GstElement* _tmp8_; + GstBus* bus; +#line 325 "clip.vala" + g_return_val_if_fail (MODEL_IS_CLIP_FILE (f), NULL); +#line 1787 "clip.c" + _inner_error_ = NULL; +#line 325 "clip.vala" + self = (ModelThumbnailFetcher*) model_fetcher_construct (object_type); +#line 326 "clip.vala" + _tmp0_ = &MODEL_FETCHER (self)->clipfile; +#line 326 "clip.vala" + (*_tmp0_) = (_tmp1_ = _g_object_ref0 (f), _g_object_unref0 ((*_tmp0_)), _tmp1_); +#line 327 "clip.vala" + self->priv->seek_position = time; +#line 329 "clip.vala" + single_bin = (_tmp3_ = single_decode_bin_new (_tmp2_ = gst_caps_from_string ("video/x-raw-rgb; video/x-raw-yuv"), "singledecoder", f->filename, &_inner_error_), _gst_caps_unref0 (_tmp2_), _tmp3_); +#line 1799 "clip.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 333 "clip.vala" + _tmp4_ = &MODEL_FETCHER (self)->pipeline; +#line 333 "clip.vala" + (*_tmp4_) = (_tmp5_ = (GstPipeline*) gst_pipeline_new ("pipeline"), _gst_object_unref0 ((*_tmp4_)), _tmp5_); +#line 334 "clip.vala" + gst_pipeline_set_auto_flush_bus (MODEL_FETCHER (self)->pipeline, FALSE); +#line 336 "clip.vala" + self->priv->thumbnail_sink = (_tmp6_ = thumbnail_sink_new (), _gst_object_unref0 (self->priv->thumbnail_sink), _tmp6_); +#line 337 "clip.vala" + g_signal_connect_object (self->priv->thumbnail_sink, "have-thumbnail", (GCallback) _model_thumbnail_fetcher_on_have_thumbnail_thumbnail_sink_have_thumbnail, self, 0); +#line 339 "clip.vala" + _tmp7_ = make_element ("ffmpegcolorspace", &_inner_error_); +#line 1817 "clip.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + _gst_object_unref0 (single_bin); + g_object_unref (self); + return NULL; + } +#line 339 "clip.vala" + self->priv->colorspace = (_tmp8_ = _tmp7_, _gst_object_unref0 (self->priv->colorspace), _tmp8_); +#line 341 "clip.vala" + gst_bin_add_many (GST_BIN (MODEL_FETCHER (self)->pipeline), _gst_object_ref0 (GST_ELEMENT (single_bin)), _gst_object_ref0 (GST_ELEMENT (self->priv->thumbnail_sink)), _gst_object_ref0 (self->priv->colorspace), NULL); +#line 343 "clip.vala" + g_signal_connect_object (GST_ELEMENT (single_bin), "pad-added", (GCallback) _model_fetcher_on_pad_added_gst_element_pad_added, MODEL_FETCHER (self), 0); +#line 345 "clip.vala" + gst_element_link (self->priv->colorspace, GST_ELEMENT (self->priv->thumbnail_sink)); +#line 347 "clip.vala" + bus = gst_pipeline_get_bus (MODEL_FETCHER (self)->pipeline); +#line 349 "clip.vala" + gst_bus_add_signal_watch (bus); +#line 350 "clip.vala" + g_signal_connect_object (bus, "message::state-changed", (GCallback) _model_fetcher_on_state_change_gst_bus_message, MODEL_FETCHER (self), 0); +#line 351 "clip.vala" + g_signal_connect_object (bus, "message::error", (GCallback) _model_fetcher_on_error_gst_bus_message, MODEL_FETCHER (self), 0); +#line 352 "clip.vala" + g_signal_connect_object (bus, "message::warning", (GCallback) _model_fetcher_on_warning_gst_bus_message, MODEL_FETCHER (self), 0); +#line 354 "clip.vala" + self->priv->have_thumbnail = FALSE; +#line 355 "clip.vala" + self->priv->done_seek = FALSE; +#line 356 "clip.vala" + gst_element_set_state (GST_ELEMENT (MODEL_FETCHER (self)->pipeline), GST_STATE_PAUSED); +#line 1848 "clip.c" + _gst_object_unref0 (single_bin); + _gst_object_unref0 (bus); + return self; +} + + +#line 325 "clip.vala" +ModelThumbnailFetcher* model_thumbnail_fetcher_new (ModelClipFile* f, gint64 time, GError** error) { +#line 325 "clip.vala" + return model_thumbnail_fetcher_construct (MODEL_TYPE_THUMBNAIL_FETCHER, f, time, error); +#line 1859 "clip.c" +} + + +#line 359 "clip.vala" +static void model_thumbnail_fetcher_on_have_thumbnail (ModelThumbnailFetcher* self, GdkPixbuf* buf) { +#line 359 "clip.vala" + g_return_if_fail (MODEL_IS_THUMBNAIL_FETCHER (self)); +#line 359 "clip.vala" + g_return_if_fail (GDK_IS_PIXBUF (buf)); +#line 360 "clip.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_have_thumbnail"); +#line 361 "clip.vala" + if (self->priv->done_seek) { +#line 362 "clip.vala" + self->priv->have_thumbnail = TRUE; +#line 363 "clip.vala" + model_clip_file_set_thumbnail (MODEL_FETCHER (self)->clipfile, buf); +#line 1877 "clip.c" + } +} + + +#line 367 "clip.vala" +static void model_thumbnail_fetcher_real_on_pad_added (ModelFetcher* base, GstPad* pad) { +#line 1884 "clip.c" + ModelThumbnailFetcher * self; + GstCaps* c; + char* _tmp0_; + gboolean _tmp1_; + self = MODEL_THUMBNAIL_FETCHER (base); +#line 367 "clip.vala" + g_return_if_fail (GST_IS_PAD (pad)); +#line 368 "clip.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_pad_added"); +#line 369 "clip.vala" + c = gst_pad_get_caps (pad); +#line 371 "clip.vala" + if ((_tmp1_ = g_str_has_prefix (_tmp0_ = gst_caps_to_string (c), "video"), _g_free0 (_tmp0_), _tmp1_)) { +#line 1898 "clip.c" + GstPad* _tmp2_; +#line 372 "clip.vala" + gst_pad_link (pad, _tmp2_ = gst_element_get_static_pad (self->priv->colorspace, "sink")); +#line 1902 "clip.c" + _gst_object_unref0 (_tmp2_); + } + _gst_caps_unref0 (c); +} + + +#line 376 "clip.vala" +static void model_thumbnail_fetcher_real_on_state_change (ModelFetcher* base, GstBus* bus, GstMessage* message) { +#line 1911 "clip.c" + ModelThumbnailFetcher * self; + GstState new_state = 0; + GstState old_state = 0; + GstState pending_state = 0; + gboolean _tmp0_ = FALSE; + self = MODEL_THUMBNAIL_FETCHER (base); +#line 376 "clip.vala" + g_return_if_fail (GST_IS_BUS (bus)); +#line 376 "clip.vala" + g_return_if_fail (GST_IS_MESSAGE (message)); +#line 377 "clip.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_state_change"); +#line 378 "clip.vala" + if (message->src != GST_OBJECT (MODEL_FETCHER (self)->pipeline)) { +#line 379 "clip.vala" + return; +#line 1928 "clip.c" + } +#line 385 "clip.vala" + gst_message_parse_state_changed (message, &old_state, &new_state, &pending_state); +#line 386 "clip.vala" + if (new_state == old_state) { +#line 387 "clip.vala" + _tmp0_ = new_state != GST_STATE_PAUSED; +#line 1936 "clip.c" + } else { +#line 386 "clip.vala" + _tmp0_ = FALSE; +#line 1940 "clip.c" + } +#line 386 "clip.vala" + if (_tmp0_) { +#line 388 "clip.vala" + return; +#line 1946 "clip.c" + } +#line 390 "clip.vala" + if (new_state == GST_STATE_PAUSED) { +#line 391 "clip.vala" + if (!self->priv->done_seek) { +#line 392 "clip.vala" + self->priv->done_seek = TRUE; +#line 393 "clip.vala" + gst_element_seek_simple (GST_ELEMENT (MODEL_FETCHER (self)->pipeline), GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH, self->priv->seek_position); +#line 1956 "clip.c" + } else { +#line 395 "clip.vala" + if (self->priv->have_thumbnail) { +#line 396 "clip.vala" + gst_element_set_state (GST_ELEMENT (MODEL_FETCHER (self)->pipeline), GST_STATE_NULL); +#line 1962 "clip.c" + } + } + } else { +#line 398 "clip.vala" + if (new_state == GST_STATE_NULL) { +#line 399 "clip.vala" + g_signal_emit_by_name (MODEL_FETCHER (self), "ready", MODEL_FETCHER (self)); +#line 1970 "clip.c" + } + } +} + + +static void model_thumbnail_fetcher_class_init (ModelThumbnailFetcherClass * klass) { + model_thumbnail_fetcher_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ModelThumbnailFetcherPrivate)); + MODEL_FETCHER_CLASS (klass)->on_pad_added = model_thumbnail_fetcher_real_on_pad_added; + MODEL_FETCHER_CLASS (klass)->on_state_change = model_thumbnail_fetcher_real_on_state_change; + G_OBJECT_CLASS (klass)->finalize = model_thumbnail_fetcher_finalize; +} + + +static void model_thumbnail_fetcher_instance_init (ModelThumbnailFetcher * self) { + self->priv = MODEL_THUMBNAIL_FETCHER_GET_PRIVATE (self); +} + + +static void model_thumbnail_fetcher_finalize (GObject* obj) { + ModelThumbnailFetcher * self; + self = MODEL_THUMBNAIL_FETCHER (obj); + _gst_object_unref0 (self->priv->thumbnail_sink); + _gst_object_unref0 (self->priv->colorspace); + G_OBJECT_CLASS (model_thumbnail_fetcher_parent_class)->finalize (obj); +} + + +GType model_thumbnail_fetcher_get_type (void) { + static volatile gsize model_thumbnail_fetcher_type_id__volatile = 0; + if (g_once_init_enter (&model_thumbnail_fetcher_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelThumbnailFetcherClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_thumbnail_fetcher_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelThumbnailFetcher), 0, (GInstanceInitFunc) model_thumbnail_fetcher_instance_init, NULL }; + GType model_thumbnail_fetcher_type_id; + model_thumbnail_fetcher_type_id = g_type_register_static (MODEL_TYPE_FETCHER, "ModelThumbnailFetcher", &g_define_type_info, 0); + g_once_init_leave (&model_thumbnail_fetcher_type_id__volatile, model_thumbnail_fetcher_type_id); + } + return model_thumbnail_fetcher_type_id__volatile; +} + + +#line 488 "clip.vala" +static void _model_clip_on_clipfile_updated_model_clip_file_updated (ModelClipFile* _sender, gpointer self) { +#line 2013 "clip.c" + model_clip_on_clipfile_updated (self, _sender); +} + + +#line 473 "clip.vala" +ModelClip* model_clip_construct (GType object_type, ModelClipFile* clipfile, ModelMediaType t, const char* name, gint64 start, gint64 media_start, gint64 duration, gboolean is_recording) { +#line 2020 "clip.c" + ModelClip * self; + ModelClipFile* _tmp0_; + char* _tmp1_; +#line 473 "clip.vala" + g_return_val_if_fail (MODEL_IS_CLIP_FILE (clipfile), NULL); +#line 473 "clip.vala" + g_return_val_if_fail (name != NULL, NULL); +#line 473 "clip.vala" + self = (ModelClip*) g_object_new (object_type, NULL); +#line 475 "clip.vala" + self->is_recording = is_recording; +#line 476 "clip.vala" + self->clipfile = (_tmp0_ = _g_object_ref0 (clipfile), _g_object_unref0 (self->clipfile), _tmp0_); +#line 477 "clip.vala" + self->type = t; +#line 478 "clip.vala" + self->name = (_tmp1_ = g_strdup (name), _g_free0 (self->name), _tmp1_); +#line 479 "clip.vala" + self->priv->connected = model_clip_file_is_online (clipfile); +#line 480 "clip.vala" + model_clip_set_media_start_duration (self, media_start, duration); +#line 481 "clip.vala" + model_clip_set_start (self, start); +#line 482 "clip.vala" + g_signal_connect_object (clipfile, "updated", (GCallback) _model_clip_on_clipfile_updated_model_clip_file_updated, self, 0); +#line 2046 "clip.c" + return self; +} + + +#line 473 "clip.vala" +ModelClip* model_clip_new (ModelClipFile* clipfile, ModelMediaType t, const char* name, gint64 start, gint64 media_start, gint64 duration, gboolean is_recording) { +#line 473 "clip.vala" + return model_clip_construct (MODEL_TYPE_CLIP, clipfile, t, name, start, media_start, duration, is_recording); +#line 2055 "clip.c" +} + + +#line 485 "clip.vala" +void model_clip_gnonlin_connect (ModelClip* self) { +#line 485 "clip.vala" + g_return_if_fail (MODEL_IS_CLIP (self)); +#line 485 "clip.vala" + self->priv->connected = TRUE; +#line 2065 "clip.c" +} + + +#line 486 "clip.vala" +void model_clip_gnonlin_disconnect (ModelClip* self) { +#line 486 "clip.vala" + g_return_if_fail (MODEL_IS_CLIP (self)); +#line 486 "clip.vala" + self->priv->connected = FALSE; +#line 2075 "clip.c" +} + + +#line 488 "clip.vala" +static void model_clip_on_clipfile_updated (ModelClip* self, ModelClipFile* f) { +#line 488 "clip.vala" + g_return_if_fail (MODEL_IS_CLIP (self)); +#line 488 "clip.vala" + g_return_if_fail (MODEL_IS_CLIP_FILE (f)); +#line 489 "clip.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clipfile_updated"); +#line 490 "clip.vala" + if (model_clip_file_is_online (f)) { +#line 491 "clip.vala" + if (!self->priv->connected) { +#line 492 "clip.vala" + self->priv->connected = TRUE; +#line 496 "clip.vala" + model_clip_set_media_start_duration (self, model_clip_get_media_start (self), model_clip_get_duration (self)); +#line 498 "clip.vala" + model_clip_set_start (self, model_clip_get_start (self)); +#line 2097 "clip.c" + } + } else { +#line 501 "clip.vala" + if (self->priv->connected) { +#line 502 "clip.vala" + self->priv->connected = FALSE; +#line 2104 "clip.c" + } + } +#line 505 "clip.vala" + g_signal_emit_by_name (self, "updated", self); +#line 2109 "clip.c" +} + + +#line 508 "clip.vala" +gboolean model_clip_overlap_pos (ModelClip* self, gint64 start, gint64 length) { +#line 2115 "clip.c" + gboolean result = FALSE; + gboolean _tmp0_ = FALSE; +#line 508 "clip.vala" + g_return_val_if_fail (MODEL_IS_CLIP (self), FALSE); +#line 509 "clip.vala" + if (start < (model_clip_get_start (self) + model_clip_get_duration (self))) { +#line 510 "clip.vala" + _tmp0_ = model_clip_get_start (self) < (start + length); +#line 2124 "clip.c" + } else { +#line 509 "clip.vala" + _tmp0_ = FALSE; +#line 2128 "clip.c" + } + result = _tmp0_; +#line 509 "clip.vala" + return result; +#line 2133 "clip.c" +} + + +#line 513 "clip.vala" +gint64 model_clip_snap (ModelClip* self, ModelClip* other, gint64 pad) { +#line 2139 "clip.c" + gint64 result = 0LL; +#line 513 "clip.vala" + g_return_val_if_fail (MODEL_IS_CLIP (self), 0LL); +#line 513 "clip.vala" + g_return_val_if_fail (MODEL_IS_CLIP (other), 0LL); +#line 514 "clip.vala" + if (time_in_range (model_clip_get_start (self), model_clip_get_start (other), pad)) { +#line 2147 "clip.c" + result = model_clip_get_start (other); +#line 515 "clip.vala" + return result; +#line 2151 "clip.c" + } else { +#line 516 "clip.vala" + if (time_in_range (model_clip_get_start (self), model_clip_get_end (other), pad)) { +#line 2155 "clip.c" + result = model_clip_get_end (other); +#line 517 "clip.vala" + return result; +#line 2159 "clip.c" + } else { +#line 518 "clip.vala" + if (time_in_range (model_clip_get_end (self), model_clip_get_start (other), pad)) { +#line 2163 "clip.c" + result = model_clip_get_start (other) - model_clip_get_duration (self); +#line 519 "clip.vala" + return result; +#line 2167 "clip.c" + } else { +#line 520 "clip.vala" + if (time_in_range (model_clip_get_end (self), model_clip_get_end (other), pad)) { +#line 2171 "clip.c" + result = model_clip_get_end (other) - model_clip_get_duration (self); +#line 521 "clip.vala" + return result; +#line 2175 "clip.c" + } + } + } + } + result = model_clip_get_start (self); +#line 523 "clip.vala" + return result; +#line 2183 "clip.c" +} + + +#line 526 "clip.vala" +gboolean model_clip_snap_coord (ModelClip* self, gint64* s, gint64 span) { +#line 2189 "clip.c" + gboolean result = FALSE; +#line 526 "clip.vala" + g_return_val_if_fail (MODEL_IS_CLIP (self), FALSE); +#line 527 "clip.vala" + if (time_in_range (*s, model_clip_get_start (self), span)) { +#line 528 "clip.vala" + *s = model_clip_get_start (self); +#line 2197 "clip.c" + result = TRUE; +#line 529 "clip.vala" + return result; +#line 2201 "clip.c" + } else { +#line 530 "clip.vala" + if (time_in_range (*s, model_clip_get_end (self), span)) { +#line 531 "clip.vala" + *s = model_clip_get_end (self); +#line 2207 "clip.c" + result = TRUE; +#line 532 "clip.vala" + return result; +#line 2211 "clip.c" + } + } + result = FALSE; +#line 534 "clip.vala" + return result; +#line 2217 "clip.c" +} + + +#line 537 "clip.vala" +ModelClip* model_clip_copy (ModelClip* self) { +#line 2223 "clip.c" + ModelClip* result = NULL; +#line 537 "clip.vala" + g_return_val_if_fail (MODEL_IS_CLIP (self), NULL); +#line 2227 "clip.c" + result = model_clip_new (self->clipfile, self->type, self->name, model_clip_get_start (self), model_clip_get_media_start (self), model_clip_get_duration (self), FALSE); +#line 538 "clip.vala" + return result; +#line 2231 "clip.c" +} + + +#line 541 "clip.vala" +gboolean model_clip_is_trimmed (ModelClip* self) { +#line 2237 "clip.c" + gboolean result = FALSE; +#line 541 "clip.vala" + g_return_val_if_fail (MODEL_IS_CLIP (self), FALSE); +#line 542 "clip.vala" + if (!model_clip_file_is_online (self->clipfile)) { +#line 2243 "clip.c" + result = FALSE; +#line 543 "clip.vala" + return result; +#line 2247 "clip.c" + } + result = model_clip_get_duration (self) != model_clip_file_get_length (self->clipfile); +#line 544 "clip.vala" + return result; +#line 2252 "clip.c" +} + + +#line 547 "clip.vala" +void model_clip_trim (ModelClip* self, gint64 delta, GdkWindowEdge edge) { +#line 547 "clip.vala" + g_return_if_fail (MODEL_IS_CLIP (self)); +#line 548 "clip.vala" + switch (edge) { +#line 2262 "clip.c" + case GDK_WINDOW_EDGE_WEST: + { +#line 550 "clip.vala" + if ((model_clip_get_media_start (self) + delta) < 0) { +#line 551 "clip.vala" + delta = -model_clip_get_media_start (self); +#line 2269 "clip.c" + } +#line 554 "clip.vala" + if ((model_clip_get_duration (self) - delta) < 0) { +#line 555 "clip.vala" + delta = model_clip_get_duration (self); +#line 2275 "clip.c" + } +#line 558 "clip.vala" + model_clip_set_start (self, model_clip_get_start (self) + delta); +#line 559 "clip.vala" + model_clip_set_media_start_duration (self, model_clip_get_media_start (self) + delta, model_clip_get_duration (self) - delta); +#line 560 "clip.vala" + break; +#line 2283 "clip.c" + } + case GDK_WINDOW_EDGE_EAST: + { +#line 562 "clip.vala" + model_clip_set_duration (self, model_clip_get_duration (self) + delta); +#line 563 "clip.vala" + break; +#line 2291 "clip.c" + } + } +} + + +#line 567 "clip.vala" +void model_clip_set_media_start_duration (ModelClip* self, gint64 media_start, gint64 duration) { +#line 2299 "clip.c" + gboolean _tmp0_ = FALSE; +#line 567 "clip.vala" + g_return_if_fail (MODEL_IS_CLIP (self)); +#line 568 "clip.vala" + if (media_start < 0) { +#line 569 "clip.vala" + media_start = (gint64) 0; +#line 2307 "clip.c" + } +#line 572 "clip.vala" + if (duration < 0) { +#line 573 "clip.vala" + duration = (gint64) 0; +#line 2313 "clip.c" + } +#line 576 "clip.vala" + if (model_clip_file_is_online (self->clipfile)) { +#line 576 "clip.vala" + _tmp0_ = (media_start + duration) > model_clip_file_get_length (self->clipfile); +#line 2319 "clip.c" + } else { +#line 576 "clip.vala" + _tmp0_ = FALSE; +#line 2323 "clip.c" + } +#line 576 "clip.vala" + if (_tmp0_) { +#line 578 "clip.vala" + media_start = model_clip_file_get_length (self->clipfile) - duration; +#line 2329 "clip.c" + } +#line 581 "clip.vala" + self->priv->_media_start = media_start; +#line 582 "clip.vala" + self->priv->_duration = duration; +#line 584 "clip.vala" + if (self->priv->connected) { +#line 585 "clip.vala" + g_signal_emit_by_name (self, "media-start-changed", self->priv->_media_start); +#line 586 "clip.vala" + g_signal_emit_by_name (self, "duration-changed", self->priv->_duration); +#line 2341 "clip.c" + } +#line 589 "clip.vala" + g_signal_emit_by_name (self, "moved", self); +#line 2345 "clip.c" +} + + +#line 592 "clip.vala" +void model_clip_save (ModelClip* self, FILE* f, gint id) { +#line 592 "clip.vala" + g_return_if_fail (MODEL_IS_CLIP (self)); +#line 592 "clip.vala" + g_return_if_fail (f != NULL); +#line 593 "clip.vala" + fprintf (f, " \n", id, self->name, model_clip_get_start (self), model_clip_get_media_start (self), model_clip_get_duration (self)); +#line 2357 "clip.c" +} + + +gint64 model_clip_get_start (ModelClip* self) { + gint64 result; + g_return_val_if_fail (MODEL_IS_CLIP (self), 0LL); + result = self->priv->_start; +#line 414 "clip.vala" + return result; +#line 2367 "clip.c" +} + + +void model_clip_set_start (ModelClip* self, gint64 value) { + g_return_if_fail (MODEL_IS_CLIP (self)); +#line 418 "clip.vala" + self->priv->_start = value; +#line 419 "clip.vala" + if (self->priv->connected) { +#line 420 "clip.vala" + g_signal_emit_by_name (self, "start-changed", self->priv->_start); +#line 2379 "clip.c" + } +#line 422 "clip.vala" + g_signal_emit_by_name (self, "moved", self); +#line 2383 "clip.c" + g_object_notify ((GObject *) self, "start"); +} + + +gint64 model_clip_get_media_start (ModelClip* self) { + gint64 result; + g_return_val_if_fail (MODEL_IS_CLIP (self), 0LL); + result = self->priv->_media_start; +#line 429 "clip.vala" + return result; +#line 2394 "clip.c" +} + + +gint64 model_clip_get_duration (ModelClip* self) { + gint64 result; + g_return_val_if_fail (MODEL_IS_CLIP (self), 0LL); + result = self->priv->_duration; +#line 436 "clip.vala" + return result; +#line 2404 "clip.c" +} + + +void model_clip_set_duration (ModelClip* self, gint64 value) { + g_return_if_fail (MODEL_IS_CLIP (self)); +#line 440 "clip.vala" + if (value < 0) { +#line 442 "clip.vala" + value = (gint64) 0; +#line 2414 "clip.c" + } +#line 445 "clip.vala" + if (!self->is_recording) { +#line 446 "clip.vala" + if ((value + self->priv->_media_start) > model_clip_file_get_length (self->clipfile)) { +#line 448 "clip.vala" + value = model_clip_file_get_length (self->clipfile) - model_clip_get_media_start (self); +#line 2422 "clip.c" + } + } +#line 452 "clip.vala" + self->priv->_duration = value; +#line 453 "clip.vala" + if (self->priv->connected) { +#line 454 "clip.vala" + g_signal_emit_by_name (self, "duration-changed", self->priv->_duration); +#line 2431 "clip.c" + } +#line 456 "clip.vala" + g_signal_emit_by_name (self, "moved", self); +#line 2435 "clip.c" + g_object_notify ((GObject *) self, "duration"); +} + + +gint64 model_clip_get_end (ModelClip* self) { + gint64 result; + g_return_val_if_fail (MODEL_IS_CLIP (self), 0LL); + result = model_clip_get_start (self) + model_clip_get_duration (self); +#line 463 "clip.vala" + return result; +#line 2446 "clip.c" +} + + +static void model_clip_class_init (ModelClipClass * klass) { + model_clip_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ModelClipPrivate)); + G_OBJECT_CLASS (klass)->get_property = model_clip_get_property; + G_OBJECT_CLASS (klass)->set_property = model_clip_set_property; + G_OBJECT_CLASS (klass)->finalize = model_clip_finalize; + g_object_class_install_property (G_OBJECT_CLASS (klass), MODEL_CLIP_START, g_param_spec_int64 ("start", "start", "start", G_MININT64, G_MAXINT64, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE)); + g_object_class_install_property (G_OBJECT_CLASS (klass), MODEL_CLIP_MEDIA_START, g_param_spec_int64 ("media-start", "media-start", "media-start", G_MININT64, G_MAXINT64, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE)); + g_object_class_install_property (G_OBJECT_CLASS (klass), MODEL_CLIP_DURATION, g_param_spec_int64 ("duration", "duration", "duration", G_MININT64, G_MAXINT64, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE)); + g_object_class_install_property (G_OBJECT_CLASS (klass), MODEL_CLIP_END, g_param_spec_int64 ("end", "end", "end", G_MININT64, G_MAXINT64, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE)); + g_signal_new ("moved", MODEL_TYPE_CLIP, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_CLIP); + g_signal_new ("updated", MODEL_TYPE_CLIP, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_CLIP); + g_signal_new ("media_start_changed", MODEL_TYPE_CLIP, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__INT64, G_TYPE_NONE, 1, G_TYPE_INT64); + g_signal_new ("duration_changed", MODEL_TYPE_CLIP, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__INT64, G_TYPE_NONE, 1, G_TYPE_INT64); + g_signal_new ("start_changed", MODEL_TYPE_CLIP, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__INT64, G_TYPE_NONE, 1, G_TYPE_INT64); + g_signal_new ("removed", MODEL_TYPE_CLIP, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_CLIP); +} + + +static void model_clip_instance_init (ModelClip * self) { + self->priv = MODEL_CLIP_GET_PRIVATE (self); +} + + +static void model_clip_finalize (GObject* obj) { + ModelClip * self; + self = MODEL_CLIP (obj); + _g_object_unref0 (self->clipfile); + _g_free0 (self->name); + G_OBJECT_CLASS (model_clip_parent_class)->finalize (obj); +} + + +GType model_clip_get_type (void) { + static volatile gsize model_clip_type_id__volatile = 0; + if (g_once_init_enter (&model_clip_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelClipClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_clip_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelClip), 0, (GInstanceInitFunc) model_clip_instance_init, NULL }; + GType model_clip_type_id; + model_clip_type_id = g_type_register_static (G_TYPE_OBJECT, "ModelClip", &g_define_type_info, 0); + g_once_init_leave (&model_clip_type_id__volatile, model_clip_type_id); + } + return model_clip_type_id__volatile; +} + + +static void model_clip_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) { + ModelClip * self; + self = MODEL_CLIP (object); + switch (property_id) { + case MODEL_CLIP_START: + g_value_set_int64 (value, model_clip_get_start (self)); + break; + case MODEL_CLIP_MEDIA_START: + g_value_set_int64 (value, model_clip_get_media_start (self)); + break; + case MODEL_CLIP_DURATION: + g_value_set_int64 (value, model_clip_get_duration (self)); + break; + case MODEL_CLIP_END: + g_value_set_int64 (value, model_clip_get_end (self)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + + +static void model_clip_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) { + ModelClip * self; + self = MODEL_CLIP (object); + switch (property_id) { + case MODEL_CLIP_START: + model_clip_set_start (self, g_value_get_int64 (value)); + break; + case MODEL_CLIP_DURATION: + model_clip_set_duration (self, g_value_get_int64 (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + + +#line 601 "clip.vala" +ModelFetcherCompletion* model_fetcher_completion_construct (GType object_type) { +#line 2537 "clip.c" + ModelFetcherCompletion* self; + self = (ModelFetcherCompletion*) g_type_create_instance (object_type); + return self; +} + + +#line 601 "clip.vala" +ModelFetcherCompletion* model_fetcher_completion_new (void) { +#line 601 "clip.vala" + return model_fetcher_completion_construct (MODEL_TYPE_FETCHER_COMPLETION); +#line 2548 "clip.c" +} + + +#line 604 "clip.vala" +static void model_fetcher_completion_real_complete (ModelFetcherCompletion* self, ModelFetcher* fetcher) { +#line 604 "clip.vala" + g_return_if_fail (MODEL_IS_FETCHER_COMPLETION (self)); +#line 604 "clip.vala" + g_return_if_fail (MODEL_IS_FETCHER (fetcher)); +#line 2558 "clip.c" +} + + +#line 604 "clip.vala" +void model_fetcher_completion_complete (ModelFetcherCompletion* self, ModelFetcher* fetcher) { +#line 604 "clip.vala" + MODEL_FETCHER_COMPLETION_GET_CLASS (self)->complete (self, fetcher); +#line 2566 "clip.c" +} + + +static void model_value_fetcher_completion_init (GValue* value) { + value->data[0].v_pointer = NULL; +} + + +static void model_value_fetcher_completion_free_value (GValue* value) { + if (value->data[0].v_pointer) { + model_fetcher_completion_unref (value->data[0].v_pointer); + } +} + + +static void model_value_fetcher_completion_copy_value (const GValue* src_value, GValue* dest_value) { + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = model_fetcher_completion_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + + +static gpointer model_value_fetcher_completion_peek_pointer (const GValue* value) { + return value->data[0].v_pointer; +} + + +static gchar* model_value_fetcher_completion_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + if (collect_values[0].v_pointer) { + ModelFetcherCompletion* object; + object = collect_values[0].v_pointer; + if (object->parent_instance.g_class == NULL) { + return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) { + return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } + value->data[0].v_pointer = model_fetcher_completion_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + + +static gchar* model_value_fetcher_completion_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + ModelFetcherCompletion** object_p; + object_p = collect_values[0].v_pointer; + if (!object_p) { + return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); + } + if (!value->data[0].v_pointer) { + *object_p = NULL; + } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) { + *object_p = value->data[0].v_pointer; + } else { + *object_p = model_fetcher_completion_ref (value->data[0].v_pointer); + } + return NULL; +} + + +GParamSpec* model_param_spec_fetcher_completion (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) { + ModelParamSpecFetcherCompletion* spec; + g_return_val_if_fail (g_type_is_a (object_type, MODEL_TYPE_FETCHER_COMPLETION), NULL); + spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags); + G_PARAM_SPEC (spec)->value_type = object_type; + return G_PARAM_SPEC (spec); +} + + +gpointer model_value_get_fetcher_completion (const GValue* value) { + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_FETCHER_COMPLETION), NULL); + return value->data[0].v_pointer; +} + + +void model_value_set_fetcher_completion (GValue* value, gpointer v_object) { + ModelFetcherCompletion* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_FETCHER_COMPLETION)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_FETCHER_COMPLETION)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + model_fetcher_completion_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + model_fetcher_completion_unref (old); + } +} + + +void model_value_take_fetcher_completion (GValue* value, gpointer v_object) { + ModelFetcherCompletion* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_FETCHER_COMPLETION)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_FETCHER_COMPLETION)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + model_fetcher_completion_unref (old); + } +} + + +static void model_fetcher_completion_class_init (ModelFetcherCompletionClass * klass) { + model_fetcher_completion_parent_class = g_type_class_peek_parent (klass); + MODEL_FETCHER_COMPLETION_CLASS (klass)->finalize = model_fetcher_completion_finalize; + MODEL_FETCHER_COMPLETION_CLASS (klass)->complete = model_fetcher_completion_real_complete; +} + + +static void model_fetcher_completion_instance_init (ModelFetcherCompletion * self) { + self->ref_count = 1; +} + + +static void model_fetcher_completion_finalize (ModelFetcherCompletion* obj) { + ModelFetcherCompletion * self; + self = MODEL_FETCHER_COMPLETION (obj); +} + + +GType model_fetcher_completion_get_type (void) { + static volatile gsize model_fetcher_completion_type_id__volatile = 0; + if (g_once_init_enter (&model_fetcher_completion_type_id__volatile)) { + static const GTypeValueTable g_define_type_value_table = { model_value_fetcher_completion_init, model_value_fetcher_completion_free_value, model_value_fetcher_completion_copy_value, model_value_fetcher_completion_peek_pointer, "p", model_value_fetcher_completion_collect_value, "p", model_value_fetcher_completion_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (ModelFetcherCompletionClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_fetcher_completion_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelFetcherCompletion), 0, (GInstanceInitFunc) model_fetcher_completion_instance_init, &g_define_type_value_table }; + static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) }; + GType model_fetcher_completion_type_id; + model_fetcher_completion_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ModelFetcherCompletion", &g_define_type_info, &g_define_type_fundamental_info, 0); + g_once_init_leave (&model_fetcher_completion_type_id__volatile, model_fetcher_completion_type_id); + } + return model_fetcher_completion_type_id__volatile; +} + + +gpointer model_fetcher_completion_ref (gpointer instance) { + ModelFetcherCompletion* self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + + +void model_fetcher_completion_unref (gpointer instance) { + ModelFetcherCompletion* self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + MODEL_FETCHER_COMPLETION_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + + + +static void g_cclosure_user_marshal_VOID__INT64 (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) { + typedef void (*GMarshalFunc_VOID__INT64) (gpointer data1, gint64 arg_1, gpointer data2); + register GMarshalFunc_VOID__INT64 callback; + register GCClosure * cc; + register gpointer data1, data2; + cc = (GCClosure *) closure; + g_return_if_fail (n_param_values == 2); + if (G_CCLOSURE_SWAP_DATA (closure)) { + data1 = closure->data; + data2 = param_values->data[0].v_pointer; + } else { + data1 = param_values->data[0].v_pointer; + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__INT64) (marshal_data ? marshal_data : cc->callback); + callback (data1, g_value_get_int64 (param_values + 1), data2); +} + + + diff --git a/src/marina/marina/clip.o b/src/marina/marina/clip.o new file mode 100644 index 0000000..ab17fb1 Binary files /dev/null and b/src/marina/marina/clip.o differ diff --git a/src/marina/marina/command.c b/src/marina/marina/command.c new file mode 100644 index 0000000..39837b2 --- /dev/null +++ b/src/marina/marina/command.c @@ -0,0 +1,2462 @@ +/* command.c generated by valac, the Vala compiler + * generated from command.vala, do not modify */ + +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + + +#define MODEL_TYPE_COMMAND (model_command_get_type ()) +#define MODEL_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_COMMAND, ModelCommand)) +#define MODEL_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_COMMAND, ModelCommandClass)) +#define MODEL_IS_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_COMMAND)) +#define MODEL_IS_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_COMMAND)) +#define MODEL_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_COMMAND, ModelCommandClass)) + +typedef struct _ModelCommand ModelCommand; +typedef struct _ModelCommandClass ModelCommandClass; +typedef struct _ModelCommandPrivate ModelCommandPrivate; +typedef struct _ModelParamSpecCommand ModelParamSpecCommand; + +#define MODEL_TYPE_PARAMETER (model_parameter_get_type ()) + +#define MODEL_TYPE_PARAMETER_COMMAND (model_parameter_command_get_type ()) +#define MODEL_PARAMETER_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PARAMETER_COMMAND, ModelParameterCommand)) +#define MODEL_PARAMETER_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PARAMETER_COMMAND, ModelParameterCommandClass)) +#define MODEL_IS_PARAMETER_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PARAMETER_COMMAND)) +#define MODEL_IS_PARAMETER_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PARAMETER_COMMAND)) +#define MODEL_PARAMETER_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PARAMETER_COMMAND, ModelParameterCommandClass)) + +typedef struct _ModelParameterCommand ModelParameterCommand; +typedef struct _ModelParameterCommandClass ModelParameterCommandClass; +typedef struct _ModelParameterCommandPrivate ModelParameterCommandPrivate; + +#define MODEL_TYPE_TRACK (model_track_get_type ()) +#define MODEL_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TRACK, ModelTrack)) +#define MODEL_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TRACK, ModelTrackClass)) +#define MODEL_IS_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TRACK)) +#define MODEL_IS_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TRACK)) +#define MODEL_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TRACK, ModelTrackClass)) + +typedef struct _ModelTrack ModelTrack; +typedef struct _ModelTrackClass ModelTrackClass; + +#define MODEL_TYPE_AUDIO_TRACK (model_audio_track_get_type ()) +#define MODEL_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrack)) +#define MODEL_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrackClass)) +#define MODEL_IS_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_AUDIO_TRACK)) +#define MODEL_IS_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_AUDIO_TRACK)) +#define MODEL_AUDIO_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrackClass)) + +typedef struct _ModelAudioTrack ModelAudioTrack; +typedef struct _ModelAudioTrackClass ModelAudioTrackClass; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +#define _model_command_unref0(var) ((var == NULL) ? NULL : (var = (model_command_unref (var), NULL))) + +#define MODEL_TYPE_CLIP_COMMAND (model_clip_command_get_type ()) +#define MODEL_CLIP_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_COMMAND, ModelClipCommand)) +#define MODEL_CLIP_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_COMMAND, ModelClipCommandClass)) +#define MODEL_IS_CLIP_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_COMMAND)) +#define MODEL_IS_CLIP_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_COMMAND)) +#define MODEL_CLIP_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_COMMAND, ModelClipCommandClass)) + +typedef struct _ModelClipCommand ModelClipCommand; +typedef struct _ModelClipCommandClass ModelClipCommandClass; +typedef struct _ModelClipCommandPrivate ModelClipCommandPrivate; + +#define MODEL_TYPE_CLIP (model_clip_get_type ()) +#define MODEL_CLIP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP, ModelClip)) +#define MODEL_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP, ModelClipClass)) +#define MODEL_IS_CLIP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP)) +#define MODEL_IS_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP)) +#define MODEL_CLIP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP, ModelClipClass)) + +typedef struct _ModelClip ModelClip; +typedef struct _ModelClipClass ModelClipClass; + +#define MODEL_CLIP_COMMAND_TYPE_ACTION (model_clip_command_action_get_type ()) + +#define MODEL_TYPE_CLIP_ADD_COMMAND (model_clip_add_command_get_type ()) +#define MODEL_CLIP_ADD_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_ADD_COMMAND, ModelClipAddCommand)) +#define MODEL_CLIP_ADD_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_ADD_COMMAND, ModelClipAddCommandClass)) +#define MODEL_IS_CLIP_ADD_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_ADD_COMMAND)) +#define MODEL_IS_CLIP_ADD_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_ADD_COMMAND)) +#define MODEL_CLIP_ADD_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_ADD_COMMAND, ModelClipAddCommandClass)) + +typedef struct _ModelClipAddCommand ModelClipAddCommand; +typedef struct _ModelClipAddCommandClass ModelClipAddCommandClass; +typedef struct _ModelClipAddCommandPrivate ModelClipAddCommandPrivate; + +#define MODEL_TYPE_CLIP_SPLIT_COMMAND (model_clip_split_command_get_type ()) +#define MODEL_CLIP_SPLIT_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_SPLIT_COMMAND, ModelClipSplitCommand)) +#define MODEL_CLIP_SPLIT_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_SPLIT_COMMAND, ModelClipSplitCommandClass)) +#define MODEL_IS_CLIP_SPLIT_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_SPLIT_COMMAND)) +#define MODEL_IS_CLIP_SPLIT_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_SPLIT_COMMAND)) +#define MODEL_CLIP_SPLIT_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_SPLIT_COMMAND, ModelClipSplitCommandClass)) + +typedef struct _ModelClipSplitCommand ModelClipSplitCommand; +typedef struct _ModelClipSplitCommandClass ModelClipSplitCommandClass; +typedef struct _ModelClipSplitCommandPrivate ModelClipSplitCommandPrivate; + +#define MODEL_CLIP_SPLIT_COMMAND_TYPE_ACTION (model_clip_split_command_action_get_type ()) + +#define MODEL_TYPE_CLIP_FILE_DELETE_COMMAND (model_clip_file_delete_command_get_type ()) +#define MODEL_CLIP_FILE_DELETE_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND, ModelClipFileDeleteCommand)) +#define MODEL_CLIP_FILE_DELETE_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND, ModelClipFileDeleteCommandClass)) +#define MODEL_IS_CLIP_FILE_DELETE_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND)) +#define MODEL_IS_CLIP_FILE_DELETE_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND)) +#define MODEL_CLIP_FILE_DELETE_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND, ModelClipFileDeleteCommandClass)) + +typedef struct _ModelClipFileDeleteCommand ModelClipFileDeleteCommand; +typedef struct _ModelClipFileDeleteCommandClass ModelClipFileDeleteCommandClass; +typedef struct _ModelClipFileDeleteCommandPrivate ModelClipFileDeleteCommandPrivate; + +#define MODEL_TYPE_CLIP_FILE (model_clip_file_get_type ()) +#define MODEL_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFile)) +#define MODEL_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) +#define MODEL_IS_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE)) +#define MODEL_IS_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE)) +#define MODEL_CLIP_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) + +typedef struct _ModelClipFile ModelClipFile; +typedef struct _ModelClipFileClass ModelClipFileClass; + +#define MODEL_TYPE_PROJECT (model_project_get_type ()) +#define MODEL_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT, ModelProject)) +#define MODEL_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT, ModelProjectClass)) +#define MODEL_IS_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT)) +#define MODEL_IS_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT)) +#define MODEL_PROJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT, ModelProjectClass)) + +typedef struct _ModelProject ModelProject; +typedef struct _ModelProjectClass ModelProjectClass; +#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL))) + +#define MODEL_TYPE_CLIP_TRIM_COMMAND (model_clip_trim_command_get_type ()) +#define MODEL_CLIP_TRIM_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_TRIM_COMMAND, ModelClipTrimCommand)) +#define MODEL_CLIP_TRIM_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_TRIM_COMMAND, ModelClipTrimCommandClass)) +#define MODEL_IS_CLIP_TRIM_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_TRIM_COMMAND)) +#define MODEL_IS_CLIP_TRIM_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_TRIM_COMMAND)) +#define MODEL_CLIP_TRIM_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_TRIM_COMMAND, ModelClipTrimCommandClass)) + +typedef struct _ModelClipTrimCommand ModelClipTrimCommand; +typedef struct _ModelClipTrimCommandClass ModelClipTrimCommandClass; +typedef struct _ModelClipTrimCommandPrivate ModelClipTrimCommandPrivate; + +#define MODEL_TYPE_CLIP_REVERT_COMMAND (model_clip_revert_command_get_type ()) +#define MODEL_CLIP_REVERT_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_REVERT_COMMAND, ModelClipRevertCommand)) +#define MODEL_CLIP_REVERT_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_REVERT_COMMAND, ModelClipRevertCommandClass)) +#define MODEL_IS_CLIP_REVERT_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_REVERT_COMMAND)) +#define MODEL_IS_CLIP_REVERT_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_REVERT_COMMAND)) +#define MODEL_CLIP_REVERT_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_REVERT_COMMAND, ModelClipRevertCommandClass)) + +typedef struct _ModelClipRevertCommand ModelClipRevertCommand; +typedef struct _ModelClipRevertCommandClass ModelClipRevertCommandClass; +typedef struct _ModelClipRevertCommandPrivate ModelClipRevertCommandPrivate; + +#define MODEL_TYPE_TIME_SIGNATURE_COMMAND (model_time_signature_command_get_type ()) +#define MODEL_TIME_SIGNATURE_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TIME_SIGNATURE_COMMAND, ModelTimeSignatureCommand)) +#define MODEL_TIME_SIGNATURE_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TIME_SIGNATURE_COMMAND, ModelTimeSignatureCommandClass)) +#define MODEL_IS_TIME_SIGNATURE_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TIME_SIGNATURE_COMMAND)) +#define MODEL_IS_TIME_SIGNATURE_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TIME_SIGNATURE_COMMAND)) +#define MODEL_TIME_SIGNATURE_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TIME_SIGNATURE_COMMAND, ModelTimeSignatureCommandClass)) + +typedef struct _ModelTimeSignatureCommand ModelTimeSignatureCommand; +typedef struct _ModelTimeSignatureCommandClass ModelTimeSignatureCommandClass; +typedef struct _ModelTimeSignatureCommandPrivate ModelTimeSignatureCommandPrivate; + +#define TYPE_FRACTION (fraction_get_type ()) +typedef struct _Fraction Fraction; + +#define MODEL_TYPE_TEMPO_INFORMATION (model_tempo_information_get_type ()) +#define MODEL_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformation)) +#define MODEL_IS_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TEMPO_INFORMATION)) +#define MODEL_TEMPO_INFORMATION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformationIface)) + +typedef struct _ModelTempoInformation ModelTempoInformation; +typedef struct _ModelTempoInformationIface ModelTempoInformationIface; + +#define MODEL_TYPE_BPM_COMMAND (model_bpm_command_get_type ()) +#define MODEL_BPM_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_BPM_COMMAND, ModelBpmCommand)) +#define MODEL_BPM_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_BPM_COMMAND, ModelBpmCommandClass)) +#define MODEL_IS_BPM_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_BPM_COMMAND)) +#define MODEL_IS_BPM_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_BPM_COMMAND)) +#define MODEL_BPM_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_BPM_COMMAND, ModelBpmCommandClass)) + +typedef struct _ModelBpmCommand ModelBpmCommand; +typedef struct _ModelBpmCommandClass ModelBpmCommandClass; +typedef struct _ModelBpmCommandPrivate ModelBpmCommandPrivate; + +#define MODEL_TYPE_ADD_CLIP_COMMAND (model_add_clip_command_get_type ()) +#define MODEL_ADD_CLIP_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_ADD_CLIP_COMMAND, ModelAddClipCommand)) +#define MODEL_ADD_CLIP_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_ADD_CLIP_COMMAND, ModelAddClipCommandClass)) +#define MODEL_IS_ADD_CLIP_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_ADD_CLIP_COMMAND)) +#define MODEL_IS_ADD_CLIP_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_ADD_CLIP_COMMAND)) +#define MODEL_ADD_CLIP_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_ADD_CLIP_COMMAND, ModelAddClipCommandClass)) + +typedef struct _ModelAddClipCommand ModelAddClipCommand; +typedef struct _ModelAddClipCommandClass ModelAddClipCommandClass; +typedef struct _ModelAddClipCommandPrivate ModelAddClipCommandPrivate; + +#define MODEL_TYPE_TRANSACTION_COMMAND (model_transaction_command_get_type ()) +#define MODEL_TRANSACTION_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TRANSACTION_COMMAND, ModelTransactionCommand)) +#define MODEL_TRANSACTION_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TRANSACTION_COMMAND, ModelTransactionCommandClass)) +#define MODEL_IS_TRANSACTION_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TRANSACTION_COMMAND)) +#define MODEL_IS_TRANSACTION_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TRANSACTION_COMMAND)) +#define MODEL_TRANSACTION_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TRANSACTION_COMMAND, ModelTransactionCommandClass)) + +typedef struct _ModelTransactionCommand ModelTransactionCommand; +typedef struct _ModelTransactionCommandClass ModelTransactionCommandClass; +typedef struct _ModelTransactionCommandPrivate ModelTransactionCommandPrivate; +#define _g_free0(var) (var = (g_free (var), NULL)) + +struct _ModelCommand { + GTypeInstance parent_instance; + volatile int ref_count; + ModelCommandPrivate * priv; +}; + +struct _ModelCommandClass { + GTypeClass parent_class; + void (*finalize) (ModelCommand *self); + void (*apply) (ModelCommand* self); + void (*undo) (ModelCommand* self); + gboolean (*merge) (ModelCommand* self, ModelCommand* command); + char* (*description) (ModelCommand* self); +}; + +struct _ModelParamSpecCommand { + GParamSpec parent_instance; +}; + +typedef enum { + MODEL_PARAMETER_PAN, + MODEL_PARAMETER_VOLUME +} ModelParameter; + +struct _ModelParameterCommand { + ModelCommand parent_instance; + ModelParameterCommandPrivate * priv; +}; + +struct _ModelParameterCommandClass { + ModelCommandClass parent_class; +}; + +struct _ModelParameterCommandPrivate { + ModelAudioTrack* target; + ModelParameter parameter; + double delta; +}; + +struct _ModelClipCommand { + ModelCommand parent_instance; + ModelClipCommandPrivate * priv; +}; + +struct _ModelClipCommandClass { + ModelCommandClass parent_class; +}; + +typedef enum { + MODEL_CLIP_COMMAND_ACTION_APPEND, + MODEL_CLIP_COMMAND_ACTION_DELETE +} ModelClipCommandAction; + +struct _ModelClipCommandPrivate { + ModelTrack* track; + ModelClip* clip; + gint64 time; + ModelClipCommandAction action; + gint index; + gboolean select; +}; + +struct _ModelClipAddCommand { + ModelCommand parent_instance; + ModelClipAddCommandPrivate * priv; +}; + +struct _ModelClipAddCommandClass { + ModelCommandClass parent_class; +}; + +struct _ModelClipAddCommandPrivate { + ModelTrack* track; + ModelClip* clip; + gint64 delta; +}; + +struct _ModelClipSplitCommand { + ModelCommand parent_instance; + ModelClipSplitCommandPrivate * priv; +}; + +struct _ModelClipSplitCommandClass { + ModelCommandClass parent_class; +}; + +struct _ModelClipSplitCommandPrivate { + ModelTrack* track; + gint64 time; + gboolean do_split; +}; + +typedef enum { + MODEL_CLIP_SPLIT_COMMAND_ACTION_SPLIT, + MODEL_CLIP_SPLIT_COMMAND_ACTION_JOIN +} ModelClipSplitCommandAction; + +struct _ModelClipFileDeleteCommand { + ModelCommand parent_instance; + ModelClipFileDeleteCommandPrivate * priv; +}; + +struct _ModelClipFileDeleteCommandClass { + ModelCommandClass parent_class; +}; + +struct _ModelClipFileDeleteCommandPrivate { + ModelClipFile* clipfile; + ModelProject* project; +}; + +struct _ModelClipTrimCommand { + ModelCommand parent_instance; + ModelClipTrimCommandPrivate * priv; +}; + +struct _ModelClipTrimCommandClass { + ModelCommandClass parent_class; +}; + +struct _ModelClipTrimCommandPrivate { + ModelTrack* track; + ModelClip* clip; + gint64 delta; + GdkWindowEdge edge; +}; + +struct _ModelClipRevertCommand { + ModelCommand parent_instance; + ModelClipRevertCommandPrivate * priv; +}; + +struct _ModelClipRevertCommandClass { + ModelCommandClass parent_class; +}; + +struct _ModelClipRevertCommandPrivate { + ModelTrack* track; + ModelClip* clip; + gint64 left_delta; + gint64 right_delta; +}; + +struct _ModelTimeSignatureCommand { + ModelCommand parent_instance; + ModelTimeSignatureCommandPrivate * priv; +}; + +struct _ModelTimeSignatureCommandClass { + ModelCommandClass parent_class; +}; + +struct _Fraction { + gint numerator; + gint denominator; +}; + +struct _ModelTimeSignatureCommandPrivate { + Fraction new_time_signature; + Fraction old_time_signature; + ModelProject* project; +}; + +struct _ModelTempoInformationIface { + GTypeInterface parent_iface; + void (*get_time_signature) (ModelTempoInformation* self, Fraction* result); + gint (*get_bpm) (ModelTempoInformation* self); +}; + +struct _ModelBpmCommand { + ModelCommand parent_instance; + ModelBpmCommandPrivate * priv; +}; + +struct _ModelBpmCommandClass { + ModelCommandClass parent_class; +}; + +struct _ModelBpmCommandPrivate { + gint delta; + ModelProject* project; +}; + +struct _ModelAddClipCommand { + ModelCommand parent_instance; + ModelAddClipCommandPrivate * priv; +}; + +struct _ModelAddClipCommandClass { + ModelCommandClass parent_class; +}; + +struct _ModelAddClipCommandPrivate { + ModelClipFile* clip_file; + ModelProject* project; +}; + +struct _ModelTransactionCommand { + ModelCommand parent_instance; + ModelTransactionCommandPrivate * priv; +}; + +struct _ModelTransactionCommandClass { + ModelCommandClass parent_class; +}; + +struct _ModelTransactionCommandPrivate { + gboolean open; + char* transaction_description; +}; + + +static gpointer model_command_parent_class = NULL; +static gpointer model_parameter_command_parent_class = NULL; +static gpointer model_clip_command_parent_class = NULL; +static gpointer model_clip_add_command_parent_class = NULL; +static gpointer model_clip_split_command_parent_class = NULL; +static gpointer model_clip_file_delete_command_parent_class = NULL; +static gpointer model_clip_trim_command_parent_class = NULL; +static gpointer model_clip_revert_command_parent_class = NULL; +static gpointer model_time_signature_command_parent_class = NULL; +static gpointer model_bpm_command_parent_class = NULL; +static gpointer model_add_clip_command_parent_class = NULL; +static gpointer model_transaction_command_parent_class = NULL; + +gpointer model_command_ref (gpointer instance); +void model_command_unref (gpointer instance); +GParamSpec* model_param_spec_command (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_command (GValue* value, gpointer v_object); +void model_value_take_command (GValue* value, gpointer v_object); +gpointer model_value_get_command (const GValue* value); +GType model_command_get_type (void); +enum { + MODEL_COMMAND_DUMMY_PROPERTY +}; +void model_command_apply (ModelCommand* self); +static void model_command_real_apply (ModelCommand* self); +void model_command_undo (ModelCommand* self); +static void model_command_real_undo (ModelCommand* self); +gboolean model_command_merge (ModelCommand* self, ModelCommand* command); +static gboolean model_command_real_merge (ModelCommand* self, ModelCommand* command); +char* model_command_description (ModelCommand* self); +static char* model_command_real_description (ModelCommand* self); +ModelCommand* model_command_construct (GType object_type); +static void model_command_finalize (ModelCommand* obj); +GType model_parameter_get_type (void); +GType model_parameter_command_get_type (void); +GType model_track_get_type (void); +GType model_audio_track_get_type (void); +#define MODEL_PARAMETER_COMMAND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_PARAMETER_COMMAND, ModelParameterCommandPrivate)) +enum { + MODEL_PARAMETER_COMMAND_DUMMY_PROPERTY +}; +ModelParameterCommand* model_parameter_command_new (ModelAudioTrack* target, ModelParameter parameter, double new_value, double old_value); +ModelParameterCommand* model_parameter_command_construct (GType object_type, ModelAudioTrack* target, ModelParameter parameter, double new_value, double old_value); +void _model_audio_track_set_pan (ModelAudioTrack* self, double new_value); +double model_audio_track_get_pan (ModelAudioTrack* self); +void _model_audio_track_set_volume (ModelAudioTrack* self, double new_volume); +double model_audio_track_get_volume (ModelAudioTrack* self); +static void model_parameter_command_change_parameter (ModelParameterCommand* self, double amount); +static void model_parameter_command_real_apply (ModelCommand* base); +static void model_parameter_command_real_undo (ModelCommand* base); +static gboolean model_parameter_command_real_merge (ModelCommand* base, ModelCommand* command); +static char* model_parameter_command_real_description (ModelCommand* base); +static void model_parameter_command_finalize (ModelCommand* obj); +GType model_clip_command_get_type (void); +GType model_clip_get_type (void); +GType model_clip_command_action_get_type (void); +#define MODEL_CLIP_COMMAND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_CLIP_COMMAND, ModelClipCommandPrivate)) +enum { + MODEL_CLIP_COMMAND_DUMMY_PROPERTY +}; +gint model_track_get_clip_index (ModelTrack* self, ModelClip* c); +ModelClipCommand* model_clip_command_new (ModelClipCommandAction action, ModelTrack* track, ModelClip* clip, gint64 time, gboolean select); +ModelClipCommand* model_clip_command_construct (GType object_type, ModelClipCommandAction action, ModelTrack* track, ModelClip* clip, gint64 time, gboolean select); +void _model_track_append_at_time (ModelTrack* self, ModelClip* c, gint64 time, gboolean select); +void _model_track_delete_clip (ModelTrack* self, ModelClip* clip); +static void model_clip_command_real_apply (ModelCommand* base); +void model_track_add (ModelTrack* self, ModelClip* c, gint64 pos, gboolean select); +static void model_clip_command_real_undo (ModelCommand* base); +static gboolean model_clip_command_real_merge (ModelCommand* base, ModelCommand* command); +static char* model_clip_command_real_description (ModelCommand* base); +static void model_clip_command_finalize (ModelCommand* obj); +GType model_clip_add_command_get_type (void); +#define MODEL_CLIP_ADD_COMMAND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_CLIP_ADD_COMMAND, ModelClipAddCommandPrivate)) +enum { + MODEL_CLIP_ADD_COMMAND_DUMMY_PROPERTY +}; +ModelClipAddCommand* model_clip_add_command_new (ModelTrack* track, ModelClip* clip, gint64 original_time, gint64 new_start); +ModelClipAddCommand* model_clip_add_command_construct (GType object_type, ModelTrack* track, ModelClip* clip, gint64 original_time, gint64 new_start); +void _model_track_move (ModelTrack* self, ModelClip* c, gint64 pos); +gint64 model_clip_get_start (ModelClip* self); +static void model_clip_add_command_real_apply (ModelCommand* base); +void model_track_remove_clip_from_array (ModelTrack* self, ModelClip* pos); +static void model_clip_add_command_real_undo (ModelCommand* base); +static gboolean model_clip_add_command_real_merge (ModelCommand* base, ModelCommand* command); +static char* model_clip_add_command_real_description (ModelCommand* base); +static void model_clip_add_command_finalize (ModelCommand* obj); +GType model_clip_split_command_get_type (void); +#define MODEL_CLIP_SPLIT_COMMAND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_CLIP_SPLIT_COMMAND, ModelClipSplitCommandPrivate)) +enum { + MODEL_CLIP_SPLIT_COMMAND_DUMMY_PROPERTY +}; +GType model_clip_split_command_action_get_type (void); +ModelClipSplitCommand* model_clip_split_command_new (ModelClipSplitCommandAction action, ModelTrack* track, gint64 time); +ModelClipSplitCommand* model_clip_split_command_construct (GType object_type, ModelClipSplitCommandAction action, ModelTrack* track, gint64 time); +void _model_track_split_at (ModelTrack* self, gint64 position); +void _model_track_join (ModelTrack* self, gint64 position); +static void model_clip_split_command_real_apply (ModelCommand* base); +static void model_clip_split_command_real_undo (ModelCommand* base); +static gboolean model_clip_split_command_real_merge (ModelCommand* base, ModelCommand* command); +static char* model_clip_split_command_real_description (ModelCommand* base); +static void model_clip_split_command_finalize (ModelCommand* obj); +GType model_clip_file_delete_command_get_type (void); +GType model_clip_file_get_type (void); +GType model_project_get_type (void); +#define MODEL_CLIP_FILE_DELETE_COMMAND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND, ModelClipFileDeleteCommandPrivate)) +enum { + MODEL_CLIP_FILE_DELETE_COMMAND_DUMMY_PROPERTY +}; +ModelClipFileDeleteCommand* model_clip_file_delete_command_new (ModelProject* p, ModelClipFile* cf); +ModelClipFileDeleteCommand* model_clip_file_delete_command_construct (GType object_type, ModelProject* p, ModelClipFile* cf); +void _model_project_remove_clipfile (ModelProject* self, ModelClipFile* cf); +static void model_clip_file_delete_command_real_apply (ModelCommand* base); +void _model_project_add_clipfile (ModelProject* self, ModelClipFile* clipfile, GError** error); +static void model_clip_file_delete_command_real_undo (ModelCommand* base); +static gboolean model_clip_file_delete_command_real_merge (ModelCommand* base, ModelCommand* command); +static char* model_clip_file_delete_command_real_description (ModelCommand* base); +static void model_clip_file_delete_command_finalize (ModelCommand* obj); +GType model_clip_trim_command_get_type (void); +#define MODEL_CLIP_TRIM_COMMAND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_CLIP_TRIM_COMMAND, ModelClipTrimCommandPrivate)) +enum { + MODEL_CLIP_TRIM_COMMAND_DUMMY_PROPERTY +}; +ModelClipTrimCommand* model_clip_trim_command_new (ModelTrack* track, ModelClip* clip, gint64 delta, GdkWindowEdge edge); +ModelClipTrimCommand* model_clip_trim_command_construct (GType object_type, ModelTrack* track, ModelClip* clip, gint64 delta, GdkWindowEdge edge); +void _model_track_trim (ModelTrack* self, ModelClip* clip, gint64 delta, GdkWindowEdge edge); +static void model_clip_trim_command_real_apply (ModelCommand* base); +static void model_clip_trim_command_real_undo (ModelCommand* base); +static gboolean model_clip_trim_command_real_merge (ModelCommand* base, ModelCommand* command); +static char* model_clip_trim_command_real_description (ModelCommand* base); +static void model_clip_trim_command_finalize (ModelCommand* obj); +GType model_clip_revert_command_get_type (void); +#define MODEL_CLIP_REVERT_COMMAND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_CLIP_REVERT_COMMAND, ModelClipRevertCommandPrivate)) +enum { + MODEL_CLIP_REVERT_COMMAND_DUMMY_PROPERTY +}; +ModelClipRevertCommand* model_clip_revert_command_new (ModelTrack* track, ModelClip* clip); +ModelClipRevertCommand* model_clip_revert_command_construct (GType object_type, ModelTrack* track, ModelClip* clip); +gint64 model_clip_get_end (ModelClip* self); +gint64 model_clip_get_media_start (ModelClip* self); +void _model_track_revert_to_original (ModelTrack* self, ModelClip* c); +static void model_clip_revert_command_real_apply (ModelCommand* base); +static void model_clip_revert_command_real_undo (ModelCommand* base); +static gboolean model_clip_revert_command_real_merge (ModelCommand* base, ModelCommand* command); +static char* model_clip_revert_command_real_description (ModelCommand* base); +static void model_clip_revert_command_finalize (ModelCommand* obj); +GType model_time_signature_command_get_type (void); +GType fraction_get_type (void); +Fraction* fraction_dup (const Fraction* self); +void fraction_free (Fraction* self); +#define MODEL_TIME_SIGNATURE_COMMAND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_TIME_SIGNATURE_COMMAND, ModelTimeSignatureCommandPrivate)) +enum { + MODEL_TIME_SIGNATURE_COMMAND_DUMMY_PROPERTY +}; +GType model_tempo_information_get_type (void); +void model_tempo_information_get_time_signature (ModelTempoInformation* self, Fraction* result); +ModelTimeSignatureCommand* model_time_signature_command_new (ModelProject* project, Fraction* new_time_signature); +ModelTimeSignatureCommand* model_time_signature_command_construct (GType object_type, ModelProject* project, Fraction* new_time_signature); +void _model_project_set_time_signature (ModelProject* self, Fraction* time_signature); +static void model_time_signature_command_real_apply (ModelCommand* base); +static void model_time_signature_command_real_undo (ModelCommand* base); +static gboolean model_time_signature_command_real_merge (ModelCommand* base, ModelCommand* command); +static char* model_time_signature_command_real_description (ModelCommand* base); +static void model_time_signature_command_finalize (ModelCommand* obj); +GType model_bpm_command_get_type (void); +#define MODEL_BPM_COMMAND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_BPM_COMMAND, ModelBpmCommandPrivate)) +enum { + MODEL_BPM_COMMAND_DUMMY_PROPERTY +}; +gint model_tempo_information_get_bpm (ModelTempoInformation* self); +ModelBpmCommand* model_bpm_command_new (ModelProject* project, gint new_bpm); +ModelBpmCommand* model_bpm_command_construct (GType object_type, ModelProject* project, gint new_bpm); +void _model_project_set_bpm (ModelProject* self, gint bpm); +static void model_bpm_command_real_apply (ModelCommand* base); +static void model_bpm_command_real_undo (ModelCommand* base); +static gboolean model_bpm_command_real_merge (ModelCommand* base, ModelCommand* command); +static char* model_bpm_command_real_description (ModelCommand* base); +static void model_bpm_command_finalize (ModelCommand* obj); +GType model_add_clip_command_get_type (void); +#define MODEL_ADD_CLIP_COMMAND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_ADD_CLIP_COMMAND, ModelAddClipCommandPrivate)) +enum { + MODEL_ADD_CLIP_COMMAND_DUMMY_PROPERTY +}; +ModelAddClipCommand* model_add_clip_command_new (ModelProject* project, ModelClipFile* clip_file); +ModelAddClipCommand* model_add_clip_command_construct (GType object_type, ModelProject* project, ModelClipFile* clip_file); +static void model_add_clip_command_real_apply (ModelCommand* base); +static void model_add_clip_command_real_undo (ModelCommand* base); +static gboolean model_add_clip_command_real_merge (ModelCommand* base, ModelCommand* command); +static char* model_add_clip_command_real_description (ModelCommand* base); +static void model_add_clip_command_finalize (ModelCommand* obj); +GType model_transaction_command_get_type (void); +#define MODEL_TRANSACTION_COMMAND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_TRANSACTION_COMMAND, ModelTransactionCommandPrivate)) +enum { + MODEL_TRANSACTION_COMMAND_DUMMY_PROPERTY +}; +ModelTransactionCommand* model_transaction_command_new (gboolean open, const char* transaction_description); +ModelTransactionCommand* model_transaction_command_construct (GType object_type, gboolean open, const char* transaction_description); +gboolean model_transaction_command_in_transaction (ModelTransactionCommand* self); +static void model_transaction_command_real_apply (ModelCommand* base); +static void model_transaction_command_real_undo (ModelCommand* base); +static gboolean model_transaction_command_real_merge (ModelCommand* base, ModelCommand* command); +static char* model_transaction_command_real_description (ModelCommand* base); +static void model_transaction_command_finalize (ModelCommand* obj); + + + +#line 9 "command.vala" +static void model_command_real_apply (ModelCommand* self) { +#line 644 "command.c" + g_return_if_fail (MODEL_IS_COMMAND (self)); + g_critical ("Type `%s' does not implement abstract method `model_command_apply'", g_type_name (G_TYPE_FROM_INSTANCE (self))); + return; +} + + +#line 9 "command.vala" +void model_command_apply (ModelCommand* self) { +#line 9 "command.vala" + MODEL_COMMAND_GET_CLASS (self)->apply (self); +#line 655 "command.c" +} + + +#line 10 "command.vala" +static void model_command_real_undo (ModelCommand* self) { +#line 661 "command.c" + g_return_if_fail (MODEL_IS_COMMAND (self)); + g_critical ("Type `%s' does not implement abstract method `model_command_undo'", g_type_name (G_TYPE_FROM_INSTANCE (self))); + return; +} + + +#line 10 "command.vala" +void model_command_undo (ModelCommand* self) { +#line 10 "command.vala" + MODEL_COMMAND_GET_CLASS (self)->undo (self); +#line 672 "command.c" +} + + +#line 11 "command.vala" +static gboolean model_command_real_merge (ModelCommand* self, ModelCommand* command) { +#line 678 "command.c" + g_return_val_if_fail (MODEL_IS_COMMAND (self), FALSE); + g_critical ("Type `%s' does not implement abstract method `model_command_merge'", g_type_name (G_TYPE_FROM_INSTANCE (self))); + return FALSE; +} + + +#line 11 "command.vala" +gboolean model_command_merge (ModelCommand* self, ModelCommand* command) { +#line 11 "command.vala" + return MODEL_COMMAND_GET_CLASS (self)->merge (self, command); +#line 689 "command.c" +} + + +#line 12 "command.vala" +static char* model_command_real_description (ModelCommand* self) { +#line 695 "command.c" + g_return_val_if_fail (MODEL_IS_COMMAND (self), NULL); + g_critical ("Type `%s' does not implement abstract method `model_command_description'", g_type_name (G_TYPE_FROM_INSTANCE (self))); + return NULL; +} + + +#line 12 "command.vala" +char* model_command_description (ModelCommand* self) { +#line 12 "command.vala" + return MODEL_COMMAND_GET_CLASS (self)->description (self); +#line 706 "command.c" +} + + +#line 8 "command.vala" +ModelCommand* model_command_construct (GType object_type) { +#line 712 "command.c" + ModelCommand* self; + self = (ModelCommand*) g_type_create_instance (object_type); + return self; +} + + +static void model_value_command_init (GValue* value) { + value->data[0].v_pointer = NULL; +} + + +static void model_value_command_free_value (GValue* value) { + if (value->data[0].v_pointer) { + model_command_unref (value->data[0].v_pointer); + } +} + + +static void model_value_command_copy_value (const GValue* src_value, GValue* dest_value) { + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = model_command_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + + +static gpointer model_value_command_peek_pointer (const GValue* value) { + return value->data[0].v_pointer; +} + + +static gchar* model_value_command_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + if (collect_values[0].v_pointer) { + ModelCommand* object; + object = collect_values[0].v_pointer; + if (object->parent_instance.g_class == NULL) { + return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) { + return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } + value->data[0].v_pointer = model_command_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + + +static gchar* model_value_command_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + ModelCommand** object_p; + object_p = collect_values[0].v_pointer; + if (!object_p) { + return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); + } + if (!value->data[0].v_pointer) { + *object_p = NULL; + } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) { + *object_p = value->data[0].v_pointer; + } else { + *object_p = model_command_ref (value->data[0].v_pointer); + } + return NULL; +} + + +GParamSpec* model_param_spec_command (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) { + ModelParamSpecCommand* spec; + g_return_val_if_fail (g_type_is_a (object_type, MODEL_TYPE_COMMAND), NULL); + spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags); + G_PARAM_SPEC (spec)->value_type = object_type; + return G_PARAM_SPEC (spec); +} + + +gpointer model_value_get_command (const GValue* value) { + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_COMMAND), NULL); + return value->data[0].v_pointer; +} + + +void model_value_set_command (GValue* value, gpointer v_object) { + ModelCommand* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_COMMAND)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_COMMAND)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + model_command_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + model_command_unref (old); + } +} + + +void model_value_take_command (GValue* value, gpointer v_object) { + ModelCommand* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_COMMAND)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_COMMAND)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + model_command_unref (old); + } +} + + +static void model_command_class_init (ModelCommandClass * klass) { + model_command_parent_class = g_type_class_peek_parent (klass); + MODEL_COMMAND_CLASS (klass)->finalize = model_command_finalize; + MODEL_COMMAND_CLASS (klass)->apply = model_command_real_apply; + MODEL_COMMAND_CLASS (klass)->undo = model_command_real_undo; + MODEL_COMMAND_CLASS (klass)->merge = model_command_real_merge; + MODEL_COMMAND_CLASS (klass)->description = model_command_real_description; +} + + +static void model_command_instance_init (ModelCommand * self) { + self->ref_count = 1; +} + + +static void model_command_finalize (ModelCommand* obj) { + ModelCommand * self; + self = MODEL_COMMAND (obj); +} + + +GType model_command_get_type (void) { + static volatile gsize model_command_type_id__volatile = 0; + if (g_once_init_enter (&model_command_type_id__volatile)) { + static const GTypeValueTable g_define_type_value_table = { model_value_command_init, model_value_command_free_value, model_value_command_copy_value, model_value_command_peek_pointer, "p", model_value_command_collect_value, "p", model_value_command_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (ModelCommandClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_command_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelCommand), 0, (GInstanceInitFunc) model_command_instance_init, &g_define_type_value_table }; + static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) }; + GType model_command_type_id; + model_command_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ModelCommand", &g_define_type_info, &g_define_type_fundamental_info, G_TYPE_FLAG_ABSTRACT); + g_once_init_leave (&model_command_type_id__volatile, model_command_type_id); + } + return model_command_type_id__volatile; +} + + +gpointer model_command_ref (gpointer instance) { + ModelCommand* self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + + +void model_command_unref (gpointer instance) { + ModelCommand* self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + MODEL_COMMAND_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + + +GType model_parameter_get_type (void) { + static volatile gsize model_parameter_type_id__volatile = 0; + if (g_once_init_enter (&model_parameter_type_id__volatile)) { + static const GEnumValue values[] = {{MODEL_PARAMETER_PAN, "MODEL_PARAMETER_PAN", "pan"}, {MODEL_PARAMETER_VOLUME, "MODEL_PARAMETER_VOLUME", "volume"}, {0, NULL, NULL}}; + GType model_parameter_type_id; + model_parameter_type_id = g_enum_register_static ("ModelParameter", values); + g_once_init_leave (&model_parameter_type_id__volatile, model_parameter_type_id); + } + return model_parameter_type_id__volatile; +} + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 22 "command.vala" +ModelParameterCommand* model_parameter_command_construct (GType object_type, ModelAudioTrack* target, ModelParameter parameter, double new_value, double old_value) { +#line 901 "command.c" + ModelParameterCommand* self; + ModelAudioTrack* _tmp0_; +#line 22 "command.vala" + g_return_val_if_fail (MODEL_IS_AUDIO_TRACK (target), NULL); +#line 22 "command.vala" + self = (ModelParameterCommand*) model_command_construct (object_type); +#line 24 "command.vala" + self->priv->target = (_tmp0_ = _g_object_ref0 (target), _g_object_unref0 (self->priv->target), _tmp0_); +#line 25 "command.vala" + self->priv->parameter = parameter; +#line 26 "command.vala" + self->priv->delta = new_value - old_value; +#line 914 "command.c" + return self; +} + + +#line 22 "command.vala" +ModelParameterCommand* model_parameter_command_new (ModelAudioTrack* target, ModelParameter parameter, double new_value, double old_value) { +#line 22 "command.vala" + return model_parameter_command_construct (MODEL_TYPE_PARAMETER_COMMAND, target, parameter, new_value, old_value); +#line 923 "command.c" +} + + +#line 29 "command.vala" +static void model_parameter_command_change_parameter (ModelParameterCommand* self, double amount) { +#line 29 "command.vala" + g_return_if_fail (MODEL_IS_PARAMETER_COMMAND (self)); +#line 30 "command.vala" + switch (self->priv->parameter) { +#line 933 "command.c" + case MODEL_PARAMETER_PAN: + { +#line 32 "command.vala" + _model_audio_track_set_pan (self->priv->target, model_audio_track_get_pan (self->priv->target) + amount); +#line 33 "command.vala" + break; +#line 940 "command.c" + } + case MODEL_PARAMETER_VOLUME: + { +#line 35 "command.vala" + _model_audio_track_set_volume (self->priv->target, model_audio_track_get_volume (self->priv->target) + amount); +#line 36 "command.vala" + break; +#line 948 "command.c" + } + } +} + + +#line 40 "command.vala" +static void model_parameter_command_real_apply (ModelCommand* base) { +#line 956 "command.c" + ModelParameterCommand * self; + self = MODEL_PARAMETER_COMMAND (base); +#line 41 "command.vala" + model_parameter_command_change_parameter (self, self->priv->delta); +#line 961 "command.c" +} + + +#line 44 "command.vala" +static void model_parameter_command_real_undo (ModelCommand* base) { +#line 967 "command.c" + ModelParameterCommand * self; + self = MODEL_PARAMETER_COMMAND (base); +#line 45 "command.vala" + model_parameter_command_change_parameter (self, -self->priv->delta); +#line 972 "command.c" +} + + +static gpointer _model_command_ref0 (gpointer self) { + return self ? model_command_ref (self) : NULL; +} + + +#line 48 "command.vala" +static gboolean model_parameter_command_real_merge (ModelCommand* base, ModelCommand* command) { +#line 983 "command.c" + ModelParameterCommand * self; + gboolean result = FALSE; + ModelCommand* _tmp0_; + ModelParameterCommand* parameter_command; + gboolean _tmp1_ = FALSE; + self = MODEL_PARAMETER_COMMAND (base); +#line 48 "command.vala" + g_return_val_if_fail (MODEL_IS_COMMAND (command), FALSE); +#line 49 "command.vala" + parameter_command = _model_command_ref0 ((_tmp0_ = command, MODEL_IS_PARAMETER_COMMAND (_tmp0_) ? ((ModelParameterCommand*) _tmp0_) : NULL)); +#line 50 "command.vala" + if (parameter_command != NULL) { +#line 50 "command.vala" + _tmp1_ = parameter_command->priv->parameter == self->priv->parameter; +#line 998 "command.c" + } else { +#line 50 "command.vala" + _tmp1_ = FALSE; +#line 1002 "command.c" + } +#line 50 "command.vala" + if (_tmp1_) { +#line 51 "command.vala" + self->priv->delta = self->priv->delta + parameter_command->priv->delta; +#line 1008 "command.c" + result = TRUE; + _model_command_unref0 (parameter_command); +#line 52 "command.vala" + return result; +#line 1013 "command.c" + } + result = FALSE; + _model_command_unref0 (parameter_command); +#line 54 "command.vala" + return result; +#line 1019 "command.c" +} + + +#line 57 "command.vala" +static char* model_parameter_command_real_description (ModelCommand* base) { +#line 1025 "command.c" + ModelParameterCommand * self; + char* result = NULL; + self = MODEL_PARAMETER_COMMAND (base); +#line 58 "command.vala" + switch (self->priv->parameter) { +#line 1031 "command.c" + case MODEL_PARAMETER_PAN: + { + result = g_strdup ("Adjust Pan"); +#line 60 "command.vala" + return result; +#line 1037 "command.c" + } + case MODEL_PARAMETER_VOLUME: + { + result = g_strdup ("Adjust Level"); +#line 62 "command.vala" + return result; +#line 1044 "command.c" + } + default: + { +#line 64 "command.vala" + g_assert (FALSE); +#line 1050 "command.c" + result = g_strdup (""); +#line 65 "command.vala" + return result; +#line 1054 "command.c" + } + } +} + + +static void model_parameter_command_class_init (ModelParameterCommandClass * klass) { + model_parameter_command_parent_class = g_type_class_peek_parent (klass); + MODEL_COMMAND_CLASS (klass)->finalize = model_parameter_command_finalize; + g_type_class_add_private (klass, sizeof (ModelParameterCommandPrivate)); + MODEL_COMMAND_CLASS (klass)->apply = model_parameter_command_real_apply; + MODEL_COMMAND_CLASS (klass)->undo = model_parameter_command_real_undo; + MODEL_COMMAND_CLASS (klass)->merge = model_parameter_command_real_merge; + MODEL_COMMAND_CLASS (klass)->description = model_parameter_command_real_description; +} + + +static void model_parameter_command_instance_init (ModelParameterCommand * self) { + self->priv = MODEL_PARAMETER_COMMAND_GET_PRIVATE (self); +} + + +static void model_parameter_command_finalize (ModelCommand* obj) { + ModelParameterCommand * self; + self = MODEL_PARAMETER_COMMAND (obj); + _g_object_unref0 (self->priv->target); + MODEL_COMMAND_CLASS (model_parameter_command_parent_class)->finalize (obj); +} + + +GType model_parameter_command_get_type (void) { + static volatile gsize model_parameter_command_type_id__volatile = 0; + if (g_once_init_enter (&model_parameter_command_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelParameterCommandClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_parameter_command_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelParameterCommand), 0, (GInstanceInitFunc) model_parameter_command_instance_init, NULL }; + GType model_parameter_command_type_id; + model_parameter_command_type_id = g_type_register_static (MODEL_TYPE_COMMAND, "ModelParameterCommand", &g_define_type_info, 0); + g_once_init_leave (&model_parameter_command_type_id__volatile, model_parameter_command_type_id); + } + return model_parameter_command_type_id__volatile; +} + + +GType model_clip_command_action_get_type (void) { + static volatile gsize model_clip_command_action_type_id__volatile = 0; + if (g_once_init_enter (&model_clip_command_action_type_id__volatile)) { + static const GEnumValue values[] = {{MODEL_CLIP_COMMAND_ACTION_APPEND, "MODEL_CLIP_COMMAND_ACTION_APPEND", "append"}, {MODEL_CLIP_COMMAND_ACTION_DELETE, "MODEL_CLIP_COMMAND_ACTION_DELETE", "delete"}, {0, NULL, NULL}}; + GType model_clip_command_action_type_id; + model_clip_command_action_type_id = g_enum_register_static ("ModelClipCommandAction", values); + g_once_init_leave (&model_clip_command_action_type_id__volatile, model_clip_command_action_type_id); + } + return model_clip_command_action_type_id__volatile; +} + + +#line 79 "command.vala" +ModelClipCommand* model_clip_command_construct (GType object_type, ModelClipCommandAction action, ModelTrack* track, ModelClip* clip, gint64 time, gboolean select) { +#line 1110 "command.c" + ModelClipCommand* self; + ModelTrack* _tmp0_; + ModelClip* _tmp1_; +#line 79 "command.vala" + g_return_val_if_fail (MODEL_IS_TRACK (track), NULL); +#line 79 "command.vala" + g_return_val_if_fail (MODEL_IS_CLIP (clip), NULL); +#line 79 "command.vala" + self = (ModelClipCommand*) model_command_construct (object_type); +#line 80 "command.vala" + self->priv->track = (_tmp0_ = _g_object_ref0 (track), _g_object_unref0 (self->priv->track), _tmp0_); +#line 81 "command.vala" + self->priv->clip = (_tmp1_ = _g_object_ref0 (clip), _g_object_unref0 (self->priv->clip), _tmp1_); +#line 82 "command.vala" + self->priv->time = time; +#line 83 "command.vala" + self->priv->action = action; +#line 84 "command.vala" + self->priv->select = select; +#line 85 "command.vala" + self->priv->index = model_track_get_clip_index (track, clip); +#line 1132 "command.c" + return self; +} + + +#line 79 "command.vala" +ModelClipCommand* model_clip_command_new (ModelClipCommandAction action, ModelTrack* track, ModelClip* clip, gint64 time, gboolean select) { +#line 79 "command.vala" + return model_clip_command_construct (MODEL_TYPE_CLIP_COMMAND, action, track, clip, time, select); +#line 1141 "command.c" +} + + +#line 88 "command.vala" +static void model_clip_command_real_apply (ModelCommand* base) { +#line 1147 "command.c" + ModelClipCommand * self; + self = MODEL_CLIP_COMMAND (base); +#line 89 "command.vala" + switch (self->priv->action) { +#line 1152 "command.c" + case MODEL_CLIP_COMMAND_ACTION_APPEND: + { +#line 91 "command.vala" + _model_track_append_at_time (self->priv->track, self->priv->clip, self->priv->time, self->priv->select); +#line 92 "command.vala" + break; +#line 1159 "command.c" + } + case MODEL_CLIP_COMMAND_ACTION_DELETE: + { +#line 94 "command.vala" + _model_track_delete_clip (self->priv->track, self->priv->clip); +#line 95 "command.vala" + break; +#line 1167 "command.c" + } + default: + { +#line 97 "command.vala" + g_assert (FALSE); +#line 98 "command.vala" + break; +#line 1175 "command.c" + } + } +} + + +#line 102 "command.vala" +static void model_clip_command_real_undo (ModelCommand* base) { +#line 1183 "command.c" + ModelClipCommand * self; + self = MODEL_CLIP_COMMAND (base); +#line 103 "command.vala" + switch (self->priv->action) { +#line 1188 "command.c" + case MODEL_CLIP_COMMAND_ACTION_APPEND: + { +#line 105 "command.vala" + _model_track_delete_clip (self->priv->track, self->priv->clip); +#line 106 "command.vala" + break; +#line 1195 "command.c" + } + case MODEL_CLIP_COMMAND_ACTION_DELETE: + { +#line 108 "command.vala" + model_track_add (self->priv->track, self->priv->clip, self->priv->time, FALSE); +#line 109 "command.vala" + break; +#line 1203 "command.c" + } + default: + { +#line 111 "command.vala" + g_assert (FALSE); +#line 112 "command.vala" + break; +#line 1211 "command.c" + } + } +} + + +#line 116 "command.vala" +static gboolean model_clip_command_real_merge (ModelCommand* base, ModelCommand* command) { +#line 1219 "command.c" + ModelClipCommand * self; + gboolean result = FALSE; + self = MODEL_CLIP_COMMAND (base); +#line 116 "command.vala" + g_return_val_if_fail (MODEL_IS_COMMAND (command), FALSE); +#line 1225 "command.c" + result = FALSE; +#line 117 "command.vala" + return result; +#line 1229 "command.c" +} + + +#line 120 "command.vala" +static char* model_clip_command_real_description (ModelCommand* base) { +#line 1235 "command.c" + ModelClipCommand * self; + char* result = NULL; + self = MODEL_CLIP_COMMAND (base); +#line 121 "command.vala" + switch (self->priv->action) { +#line 1241 "command.c" + case MODEL_CLIP_COMMAND_ACTION_APPEND: + { + result = g_strdup ("Create Clip"); +#line 123 "command.vala" + return result; +#line 1247 "command.c" + } + case MODEL_CLIP_COMMAND_ACTION_DELETE: + { + result = g_strdup ("Delete Clip"); +#line 125 "command.vala" + return result; +#line 1254 "command.c" + } + default: + { +#line 127 "command.vala" + g_assert (FALSE); +#line 1260 "command.c" + result = g_strdup (""); +#line 128 "command.vala" + return result; +#line 1264 "command.c" + } + } +} + + +static void model_clip_command_class_init (ModelClipCommandClass * klass) { + model_clip_command_parent_class = g_type_class_peek_parent (klass); + MODEL_COMMAND_CLASS (klass)->finalize = model_clip_command_finalize; + g_type_class_add_private (klass, sizeof (ModelClipCommandPrivate)); + MODEL_COMMAND_CLASS (klass)->apply = model_clip_command_real_apply; + MODEL_COMMAND_CLASS (klass)->undo = model_clip_command_real_undo; + MODEL_COMMAND_CLASS (klass)->merge = model_clip_command_real_merge; + MODEL_COMMAND_CLASS (klass)->description = model_clip_command_real_description; +} + + +static void model_clip_command_instance_init (ModelClipCommand * self) { + self->priv = MODEL_CLIP_COMMAND_GET_PRIVATE (self); +} + + +static void model_clip_command_finalize (ModelCommand* obj) { + ModelClipCommand * self; + self = MODEL_CLIP_COMMAND (obj); + _g_object_unref0 (self->priv->track); + _g_object_unref0 (self->priv->clip); + MODEL_COMMAND_CLASS (model_clip_command_parent_class)->finalize (obj); +} + + +GType model_clip_command_get_type (void) { + static volatile gsize model_clip_command_type_id__volatile = 0; + if (g_once_init_enter (&model_clip_command_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelClipCommandClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_clip_command_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelClipCommand), 0, (GInstanceInitFunc) model_clip_command_instance_init, NULL }; + GType model_clip_command_type_id; + model_clip_command_type_id = g_type_register_static (MODEL_TYPE_COMMAND, "ModelClipCommand", &g_define_type_info, 0); + g_once_init_leave (&model_clip_command_type_id__volatile, model_clip_command_type_id); + } + return model_clip_command_type_id__volatile; +} + + +#line 138 "command.vala" +ModelClipAddCommand* model_clip_add_command_construct (GType object_type, ModelTrack* track, ModelClip* clip, gint64 original_time, gint64 new_start) { +#line 1309 "command.c" + ModelClipAddCommand* self; + ModelTrack* _tmp0_; + ModelClip* _tmp1_; +#line 138 "command.vala" + g_return_val_if_fail (MODEL_IS_TRACK (track), NULL); +#line 138 "command.vala" + g_return_val_if_fail (MODEL_IS_CLIP (clip), NULL); +#line 138 "command.vala" + self = (ModelClipAddCommand*) model_command_construct (object_type); +#line 140 "command.vala" + self->priv->track = (_tmp0_ = _g_object_ref0 (track), _g_object_unref0 (self->priv->track), _tmp0_); +#line 141 "command.vala" + self->priv->clip = (_tmp1_ = _g_object_ref0 (clip), _g_object_unref0 (self->priv->clip), _tmp1_); +#line 142 "command.vala" + self->priv->delta = new_start - original_time; +#line 1325 "command.c" + return self; +} + + +#line 138 "command.vala" +ModelClipAddCommand* model_clip_add_command_new (ModelTrack* track, ModelClip* clip, gint64 original_time, gint64 new_start) { +#line 138 "command.vala" + return model_clip_add_command_construct (MODEL_TYPE_CLIP_ADD_COMMAND, track, clip, original_time, new_start); +#line 1334 "command.c" +} + + +#line 145 "command.vala" +static void model_clip_add_command_real_apply (ModelCommand* base) { +#line 1340 "command.c" + ModelClipAddCommand * self; + self = MODEL_CLIP_ADD_COMMAND (base); +#line 146 "command.vala" + _model_track_move (self->priv->track, self->priv->clip, model_clip_get_start (self->priv->clip)); +#line 1345 "command.c" +} + + +#line 149 "command.vala" +static void model_clip_add_command_real_undo (ModelCommand* base) { +#line 1351 "command.c" + ModelClipAddCommand * self; + self = MODEL_CLIP_ADD_COMMAND (base); +#line 150 "command.vala" + model_track_remove_clip_from_array (self->priv->track, self->priv->clip); +#line 151 "command.vala" + _model_track_move (self->priv->track, self->priv->clip, model_clip_get_start (self->priv->clip) - self->priv->delta); +#line 1358 "command.c" +} + + +#line 154 "command.vala" +static gboolean model_clip_add_command_real_merge (ModelCommand* base, ModelCommand* command) { +#line 1364 "command.c" + ModelClipAddCommand * self; + gboolean result = FALSE; + self = MODEL_CLIP_ADD_COMMAND (base); +#line 154 "command.vala" + g_return_val_if_fail (MODEL_IS_COMMAND (command), FALSE); +#line 1370 "command.c" + result = FALSE; +#line 155 "command.vala" + return result; +#line 1374 "command.c" +} + + +#line 158 "command.vala" +static char* model_clip_add_command_real_description (ModelCommand* base) { +#line 1380 "command.c" + ModelClipAddCommand * self; + char* result = NULL; + self = MODEL_CLIP_ADD_COMMAND (base); + result = g_strdup ("Move Clip"); +#line 159 "command.vala" + return result; +#line 1387 "command.c" +} + + +static void model_clip_add_command_class_init (ModelClipAddCommandClass * klass) { + model_clip_add_command_parent_class = g_type_class_peek_parent (klass); + MODEL_COMMAND_CLASS (klass)->finalize = model_clip_add_command_finalize; + g_type_class_add_private (klass, sizeof (ModelClipAddCommandPrivate)); + MODEL_COMMAND_CLASS (klass)->apply = model_clip_add_command_real_apply; + MODEL_COMMAND_CLASS (klass)->undo = model_clip_add_command_real_undo; + MODEL_COMMAND_CLASS (klass)->merge = model_clip_add_command_real_merge; + MODEL_COMMAND_CLASS (klass)->description = model_clip_add_command_real_description; +} + + +static void model_clip_add_command_instance_init (ModelClipAddCommand * self) { + self->priv = MODEL_CLIP_ADD_COMMAND_GET_PRIVATE (self); +} + + +static void model_clip_add_command_finalize (ModelCommand* obj) { + ModelClipAddCommand * self; + self = MODEL_CLIP_ADD_COMMAND (obj); + _g_object_unref0 (self->priv->track); + _g_object_unref0 (self->priv->clip); + MODEL_COMMAND_CLASS (model_clip_add_command_parent_class)->finalize (obj); +} + + +GType model_clip_add_command_get_type (void) { + static volatile gsize model_clip_add_command_type_id__volatile = 0; + if (g_once_init_enter (&model_clip_add_command_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelClipAddCommandClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_clip_add_command_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelClipAddCommand), 0, (GInstanceInitFunc) model_clip_add_command_instance_init, NULL }; + GType model_clip_add_command_type_id; + model_clip_add_command_type_id = g_type_register_static (MODEL_TYPE_COMMAND, "ModelClipAddCommand", &g_define_type_info, 0); + g_once_init_leave (&model_clip_add_command_type_id__volatile, model_clip_add_command_type_id); + } + return model_clip_add_command_type_id__volatile; +} + + +GType model_clip_split_command_action_get_type (void) { + static volatile gsize model_clip_split_command_action_type_id__volatile = 0; + if (g_once_init_enter (&model_clip_split_command_action_type_id__volatile)) { + static const GEnumValue values[] = {{MODEL_CLIP_SPLIT_COMMAND_ACTION_SPLIT, "MODEL_CLIP_SPLIT_COMMAND_ACTION_SPLIT", "split"}, {MODEL_CLIP_SPLIT_COMMAND_ACTION_JOIN, "MODEL_CLIP_SPLIT_COMMAND_ACTION_JOIN", "join"}, {0, NULL, NULL}}; + GType model_clip_split_command_action_type_id; + model_clip_split_command_action_type_id = g_enum_register_static ("ModelClipSplitCommandAction", values); + g_once_init_leave (&model_clip_split_command_action_type_id__volatile, model_clip_split_command_action_type_id); + } + return model_clip_split_command_action_type_id__volatile; +} + + +#line 170 "command.vala" +ModelClipSplitCommand* model_clip_split_command_construct (GType object_type, ModelClipSplitCommandAction action, ModelTrack* track, gint64 time) { +#line 1442 "command.c" + ModelClipSplitCommand* self; + ModelTrack* _tmp0_; +#line 170 "command.vala" + g_return_val_if_fail (MODEL_IS_TRACK (track), NULL); +#line 170 "command.vala" + self = (ModelClipSplitCommand*) model_command_construct (object_type); +#line 171 "command.vala" + self->priv->track = (_tmp0_ = _g_object_ref0 (track), _g_object_unref0 (self->priv->track), _tmp0_); +#line 172 "command.vala" + self->priv->time = time; +#line 173 "command.vala" + self->priv->do_split = action == MODEL_CLIP_SPLIT_COMMAND_ACTION_SPLIT; +#line 1455 "command.c" + return self; +} + + +#line 170 "command.vala" +ModelClipSplitCommand* model_clip_split_command_new (ModelClipSplitCommandAction action, ModelTrack* track, gint64 time) { +#line 170 "command.vala" + return model_clip_split_command_construct (MODEL_TYPE_CLIP_SPLIT_COMMAND, action, track, time); +#line 1464 "command.c" +} + + +#line 176 "command.vala" +static void model_clip_split_command_real_apply (ModelCommand* base) { +#line 1470 "command.c" + ModelClipSplitCommand * self; + self = MODEL_CLIP_SPLIT_COMMAND (base); +#line 177 "command.vala" + if (self->priv->do_split) { +#line 178 "command.vala" + _model_track_split_at (self->priv->track, self->priv->time); +#line 1477 "command.c" + } else { +#line 180 "command.vala" + _model_track_join (self->priv->track, self->priv->time); +#line 1481 "command.c" + } +} + + +#line 184 "command.vala" +static void model_clip_split_command_real_undo (ModelCommand* base) { +#line 1488 "command.c" + ModelClipSplitCommand * self; + self = MODEL_CLIP_SPLIT_COMMAND (base); +#line 185 "command.vala" + if (self->priv->do_split) { +#line 186 "command.vala" + _model_track_join (self->priv->track, self->priv->time); +#line 1495 "command.c" + } else { +#line 188 "command.vala" + _model_track_split_at (self->priv->track, self->priv->time); +#line 1499 "command.c" + } +} + + +#line 192 "command.vala" +static gboolean model_clip_split_command_real_merge (ModelCommand* base, ModelCommand* command) { +#line 1506 "command.c" + ModelClipSplitCommand * self; + gboolean result = FALSE; + self = MODEL_CLIP_SPLIT_COMMAND (base); +#line 192 "command.vala" + g_return_val_if_fail (MODEL_IS_COMMAND (command), FALSE); +#line 1512 "command.c" + result = FALSE; +#line 193 "command.vala" + return result; +#line 1516 "command.c" +} + + +#line 196 "command.vala" +static char* model_clip_split_command_real_description (ModelCommand* base) { +#line 1522 "command.c" + ModelClipSplitCommand * self; + char* result = NULL; + self = MODEL_CLIP_SPLIT_COMMAND (base); +#line 197 "command.vala" + if (self->priv->do_split) { +#line 1528 "command.c" + result = g_strdup ("Split Clip"); +#line 198 "command.vala" + return result; +#line 1532 "command.c" + } else { + result = g_strdup ("Join Clip"); +#line 200 "command.vala" + return result; +#line 1537 "command.c" + } +} + + +static void model_clip_split_command_class_init (ModelClipSplitCommandClass * klass) { + model_clip_split_command_parent_class = g_type_class_peek_parent (klass); + MODEL_COMMAND_CLASS (klass)->finalize = model_clip_split_command_finalize; + g_type_class_add_private (klass, sizeof (ModelClipSplitCommandPrivate)); + MODEL_COMMAND_CLASS (klass)->apply = model_clip_split_command_real_apply; + MODEL_COMMAND_CLASS (klass)->undo = model_clip_split_command_real_undo; + MODEL_COMMAND_CLASS (klass)->merge = model_clip_split_command_real_merge; + MODEL_COMMAND_CLASS (klass)->description = model_clip_split_command_real_description; +} + + +static void model_clip_split_command_instance_init (ModelClipSplitCommand * self) { + self->priv = MODEL_CLIP_SPLIT_COMMAND_GET_PRIVATE (self); +} + + +static void model_clip_split_command_finalize (ModelCommand* obj) { + ModelClipSplitCommand * self; + self = MODEL_CLIP_SPLIT_COMMAND (obj); + _g_object_unref0 (self->priv->track); + MODEL_COMMAND_CLASS (model_clip_split_command_parent_class)->finalize (obj); +} + + +GType model_clip_split_command_get_type (void) { + static volatile gsize model_clip_split_command_type_id__volatile = 0; + if (g_once_init_enter (&model_clip_split_command_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelClipSplitCommandClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_clip_split_command_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelClipSplitCommand), 0, (GInstanceInitFunc) model_clip_split_command_instance_init, NULL }; + GType model_clip_split_command_type_id; + model_clip_split_command_type_id = g_type_register_static (MODEL_TYPE_COMMAND, "ModelClipSplitCommand", &g_define_type_info, 0); + g_once_init_leave (&model_clip_split_command_type_id__volatile, model_clip_split_command_type_id); + } + return model_clip_split_command_type_id__volatile; +} + + +#line 209 "command.vala" +ModelClipFileDeleteCommand* model_clip_file_delete_command_construct (GType object_type, ModelProject* p, ModelClipFile* cf) { +#line 1580 "command.c" + ModelClipFileDeleteCommand* self; + ModelClipFile* _tmp0_; + ModelProject* _tmp1_; +#line 209 "command.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (p), NULL); +#line 209 "command.vala" + g_return_val_if_fail (MODEL_IS_CLIP_FILE (cf), NULL); +#line 209 "command.vala" + self = (ModelClipFileDeleteCommand*) model_command_construct (object_type); +#line 210 "command.vala" + self->priv->clipfile = (_tmp0_ = _g_object_ref0 (cf), _g_object_unref0 (self->priv->clipfile), _tmp0_); +#line 211 "command.vala" + self->priv->project = (_tmp1_ = _g_object_ref0 (p), _g_object_unref0 (self->priv->project), _tmp1_); +#line 1594 "command.c" + return self; +} + + +#line 209 "command.vala" +ModelClipFileDeleteCommand* model_clip_file_delete_command_new (ModelProject* p, ModelClipFile* cf) { +#line 209 "command.vala" + return model_clip_file_delete_command_construct (MODEL_TYPE_CLIP_FILE_DELETE_COMMAND, p, cf); +#line 1603 "command.c" +} + + +#line 214 "command.vala" +static void model_clip_file_delete_command_real_apply (ModelCommand* base) { +#line 1609 "command.c" + ModelClipFileDeleteCommand * self; + self = MODEL_CLIP_FILE_DELETE_COMMAND (base); +#line 215 "command.vala" + _model_project_remove_clipfile (self->priv->project, self->priv->clipfile); +#line 1614 "command.c" +} + + +#line 218 "command.vala" +static void model_clip_file_delete_command_real_undo (ModelCommand* base) { +#line 1620 "command.c" + ModelClipFileDeleteCommand * self; + GError * _inner_error_; + self = MODEL_CLIP_FILE_DELETE_COMMAND (base); + _inner_error_ = NULL; + { +#line 220 "command.vala" + _model_project_add_clipfile (self->priv->project, self->priv->clipfile, &_inner_error_); +#line 1628 "command.c" + if (_inner_error_ != NULL) { + goto __catch5_g_error; + } + } + goto __finally5; + __catch5_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { +#line 222 "command.vala" + g_signal_emit_by_name (self->priv->project, "error-occurred", "Could not add clipfile.", e->message); +#line 1642 "command.c" + _g_error_free0 (e); + } + } + __finally5: + if (_inner_error_ != NULL) { + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } +} + + +#line 226 "command.vala" +static gboolean model_clip_file_delete_command_real_merge (ModelCommand* base, ModelCommand* command) { +#line 1657 "command.c" + ModelClipFileDeleteCommand * self; + gboolean result = FALSE; + self = MODEL_CLIP_FILE_DELETE_COMMAND (base); +#line 226 "command.vala" + g_return_val_if_fail (MODEL_IS_COMMAND (command), FALSE); +#line 1663 "command.c" + result = FALSE; +#line 227 "command.vala" + return result; +#line 1667 "command.c" +} + + +#line 230 "command.vala" +static char* model_clip_file_delete_command_real_description (ModelCommand* base) { +#line 1673 "command.c" + ModelClipFileDeleteCommand * self; + char* result = NULL; + self = MODEL_CLIP_FILE_DELETE_COMMAND (base); + result = g_strdup ("Delete from Library"); +#line 231 "command.vala" + return result; +#line 1680 "command.c" +} + + +static void model_clip_file_delete_command_class_init (ModelClipFileDeleteCommandClass * klass) { + model_clip_file_delete_command_parent_class = g_type_class_peek_parent (klass); + MODEL_COMMAND_CLASS (klass)->finalize = model_clip_file_delete_command_finalize; + g_type_class_add_private (klass, sizeof (ModelClipFileDeleteCommandPrivate)); + MODEL_COMMAND_CLASS (klass)->apply = model_clip_file_delete_command_real_apply; + MODEL_COMMAND_CLASS (klass)->undo = model_clip_file_delete_command_real_undo; + MODEL_COMMAND_CLASS (klass)->merge = model_clip_file_delete_command_real_merge; + MODEL_COMMAND_CLASS (klass)->description = model_clip_file_delete_command_real_description; +} + + +static void model_clip_file_delete_command_instance_init (ModelClipFileDeleteCommand * self) { + self->priv = MODEL_CLIP_FILE_DELETE_COMMAND_GET_PRIVATE (self); +} + + +static void model_clip_file_delete_command_finalize (ModelCommand* obj) { + ModelClipFileDeleteCommand * self; + self = MODEL_CLIP_FILE_DELETE_COMMAND (obj); + _g_object_unref0 (self->priv->clipfile); + _g_object_unref0 (self->priv->project); + MODEL_COMMAND_CLASS (model_clip_file_delete_command_parent_class)->finalize (obj); +} + + +GType model_clip_file_delete_command_get_type (void) { + static volatile gsize model_clip_file_delete_command_type_id__volatile = 0; + if (g_once_init_enter (&model_clip_file_delete_command_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelClipFileDeleteCommandClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_clip_file_delete_command_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelClipFileDeleteCommand), 0, (GInstanceInitFunc) model_clip_file_delete_command_instance_init, NULL }; + GType model_clip_file_delete_command_type_id; + model_clip_file_delete_command_type_id = g_type_register_static (MODEL_TYPE_COMMAND, "ModelClipFileDeleteCommand", &g_define_type_info, 0); + g_once_init_leave (&model_clip_file_delete_command_type_id__volatile, model_clip_file_delete_command_type_id); + } + return model_clip_file_delete_command_type_id__volatile; +} + + +#line 241 "command.vala" +ModelClipTrimCommand* model_clip_trim_command_construct (GType object_type, ModelTrack* track, ModelClip* clip, gint64 delta, GdkWindowEdge edge) { +#line 1723 "command.c" + ModelClipTrimCommand* self; + ModelTrack* _tmp0_; + ModelClip* _tmp1_; +#line 241 "command.vala" + g_return_val_if_fail (MODEL_IS_TRACK (track), NULL); +#line 241 "command.vala" + g_return_val_if_fail (MODEL_IS_CLIP (clip), NULL); +#line 241 "command.vala" + self = (ModelClipTrimCommand*) model_command_construct (object_type); +#line 242 "command.vala" + self->priv->track = (_tmp0_ = _g_object_ref0 (track), _g_object_unref0 (self->priv->track), _tmp0_); +#line 243 "command.vala" + self->priv->clip = (_tmp1_ = _g_object_ref0 (clip), _g_object_unref0 (self->priv->clip), _tmp1_); +#line 244 "command.vala" + self->priv->delta = delta; +#line 245 "command.vala" + self->priv->edge = edge; +#line 1741 "command.c" + return self; +} + + +#line 241 "command.vala" +ModelClipTrimCommand* model_clip_trim_command_new (ModelTrack* track, ModelClip* clip, gint64 delta, GdkWindowEdge edge) { +#line 241 "command.vala" + return model_clip_trim_command_construct (MODEL_TYPE_CLIP_TRIM_COMMAND, track, clip, delta, edge); +#line 1750 "command.c" +} + + +#line 248 "command.vala" +static void model_clip_trim_command_real_apply (ModelCommand* base) { +#line 1756 "command.c" + ModelClipTrimCommand * self; + self = MODEL_CLIP_TRIM_COMMAND (base); +#line 249 "command.vala" + _model_track_trim (self->priv->track, self->priv->clip, self->priv->delta, self->priv->edge); +#line 1761 "command.c" +} + + +#line 252 "command.vala" +static void model_clip_trim_command_real_undo (ModelCommand* base) { +#line 1767 "command.c" + ModelClipTrimCommand * self; + self = MODEL_CLIP_TRIM_COMMAND (base); +#line 253 "command.vala" + _model_track_trim (self->priv->track, self->priv->clip, -self->priv->delta, self->priv->edge); +#line 1772 "command.c" +} + + +#line 256 "command.vala" +static gboolean model_clip_trim_command_real_merge (ModelCommand* base, ModelCommand* command) { +#line 1778 "command.c" + ModelClipTrimCommand * self; + gboolean result = FALSE; + self = MODEL_CLIP_TRIM_COMMAND (base); +#line 256 "command.vala" + g_return_val_if_fail (MODEL_IS_COMMAND (command), FALSE); +#line 1784 "command.c" + result = FALSE; +#line 257 "command.vala" + return result; +#line 1788 "command.c" +} + + +#line 260 "command.vala" +static char* model_clip_trim_command_real_description (ModelCommand* base) { +#line 1794 "command.c" + ModelClipTrimCommand * self; + char* result = NULL; + self = MODEL_CLIP_TRIM_COMMAND (base); + result = g_strdup ("Trim To Playhead"); +#line 261 "command.vala" + return result; +#line 1801 "command.c" +} + + +static void model_clip_trim_command_class_init (ModelClipTrimCommandClass * klass) { + model_clip_trim_command_parent_class = g_type_class_peek_parent (klass); + MODEL_COMMAND_CLASS (klass)->finalize = model_clip_trim_command_finalize; + g_type_class_add_private (klass, sizeof (ModelClipTrimCommandPrivate)); + MODEL_COMMAND_CLASS (klass)->apply = model_clip_trim_command_real_apply; + MODEL_COMMAND_CLASS (klass)->undo = model_clip_trim_command_real_undo; + MODEL_COMMAND_CLASS (klass)->merge = model_clip_trim_command_real_merge; + MODEL_COMMAND_CLASS (klass)->description = model_clip_trim_command_real_description; +} + + +static void model_clip_trim_command_instance_init (ModelClipTrimCommand * self) { + self->priv = MODEL_CLIP_TRIM_COMMAND_GET_PRIVATE (self); +} + + +static void model_clip_trim_command_finalize (ModelCommand* obj) { + ModelClipTrimCommand * self; + self = MODEL_CLIP_TRIM_COMMAND (obj); + _g_object_unref0 (self->priv->track); + _g_object_unref0 (self->priv->clip); + MODEL_COMMAND_CLASS (model_clip_trim_command_parent_class)->finalize (obj); +} + + +GType model_clip_trim_command_get_type (void) { + static volatile gsize model_clip_trim_command_type_id__volatile = 0; + if (g_once_init_enter (&model_clip_trim_command_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelClipTrimCommandClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_clip_trim_command_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelClipTrimCommand), 0, (GInstanceInitFunc) model_clip_trim_command_instance_init, NULL }; + GType model_clip_trim_command_type_id; + model_clip_trim_command_type_id = g_type_register_static (MODEL_TYPE_COMMAND, "ModelClipTrimCommand", &g_define_type_info, 0); + g_once_init_leave (&model_clip_trim_command_type_id__volatile, model_clip_trim_command_type_id); + } + return model_clip_trim_command_type_id__volatile; +} + + +#line 271 "command.vala" +ModelClipRevertCommand* model_clip_revert_command_construct (GType object_type, ModelTrack* track, ModelClip* clip) { +#line 1844 "command.c" + ModelClipRevertCommand* self; + ModelTrack* _tmp0_; + ModelClip* _tmp1_; +#line 271 "command.vala" + g_return_val_if_fail (MODEL_IS_TRACK (track), NULL); +#line 271 "command.vala" + g_return_val_if_fail (MODEL_IS_CLIP (clip), NULL); +#line 271 "command.vala" + self = (ModelClipRevertCommand*) model_command_construct (object_type); +#line 272 "command.vala" + self->priv->track = (_tmp0_ = _g_object_ref0 (track), _g_object_unref0 (self->priv->track), _tmp0_); +#line 273 "command.vala" + self->priv->clip = (_tmp1_ = _g_object_ref0 (clip), _g_object_unref0 (self->priv->clip), _tmp1_); +#line 1858 "command.c" + return self; +} + + +#line 271 "command.vala" +ModelClipRevertCommand* model_clip_revert_command_new (ModelTrack* track, ModelClip* clip) { +#line 271 "command.vala" + return model_clip_revert_command_construct (MODEL_TYPE_CLIP_REVERT_COMMAND, track, clip); +#line 1867 "command.c" +} + + +#line 276 "command.vala" +static void model_clip_revert_command_real_apply (ModelCommand* base) { +#line 1873 "command.c" + ModelClipRevertCommand * self; + self = MODEL_CLIP_REVERT_COMMAND (base); +#line 277 "command.vala" + self->priv->right_delta = model_clip_get_end (self->priv->clip); +#line 278 "command.vala" + self->priv->left_delta = model_clip_get_media_start (self->priv->clip); +#line 279 "command.vala" + _model_track_revert_to_original (self->priv->track, self->priv->clip); +#line 280 "command.vala" + self->priv->left_delta = self->priv->left_delta - model_clip_get_media_start (self->priv->clip); +#line 281 "command.vala" + self->priv->right_delta = (model_clip_get_end (self->priv->clip) - self->priv->right_delta) - self->priv->left_delta; +#line 1886 "command.c" +} + + +#line 284 "command.vala" +static void model_clip_revert_command_real_undo (ModelCommand* base) { +#line 1892 "command.c" + ModelClipRevertCommand * self; + self = MODEL_CLIP_REVERT_COMMAND (base); +#line 285 "command.vala" + _model_track_trim (self->priv->track, self->priv->clip, -self->priv->left_delta, GDK_WINDOW_EDGE_WEST); +#line 286 "command.vala" + _model_track_trim (self->priv->track, self->priv->clip, -self->priv->right_delta, GDK_WINDOW_EDGE_EAST); +#line 1899 "command.c" +} + + +#line 289 "command.vala" +static gboolean model_clip_revert_command_real_merge (ModelCommand* base, ModelCommand* command) { +#line 1905 "command.c" + ModelClipRevertCommand * self; + gboolean result = FALSE; + self = MODEL_CLIP_REVERT_COMMAND (base); +#line 289 "command.vala" + g_return_val_if_fail (MODEL_IS_COMMAND (command), FALSE); +#line 1911 "command.c" + result = FALSE; +#line 290 "command.vala" + return result; +#line 1915 "command.c" +} + + +#line 293 "command.vala" +static char* model_clip_revert_command_real_description (ModelCommand* base) { +#line 1921 "command.c" + ModelClipRevertCommand * self; + char* result = NULL; + self = MODEL_CLIP_REVERT_COMMAND (base); + result = g_strdup ("Revert To Original"); +#line 294 "command.vala" + return result; +#line 1928 "command.c" +} + + +static void model_clip_revert_command_class_init (ModelClipRevertCommandClass * klass) { + model_clip_revert_command_parent_class = g_type_class_peek_parent (klass); + MODEL_COMMAND_CLASS (klass)->finalize = model_clip_revert_command_finalize; + g_type_class_add_private (klass, sizeof (ModelClipRevertCommandPrivate)); + MODEL_COMMAND_CLASS (klass)->apply = model_clip_revert_command_real_apply; + MODEL_COMMAND_CLASS (klass)->undo = model_clip_revert_command_real_undo; + MODEL_COMMAND_CLASS (klass)->merge = model_clip_revert_command_real_merge; + MODEL_COMMAND_CLASS (klass)->description = model_clip_revert_command_real_description; +} + + +static void model_clip_revert_command_instance_init (ModelClipRevertCommand * self) { + self->priv = MODEL_CLIP_REVERT_COMMAND_GET_PRIVATE (self); +} + + +static void model_clip_revert_command_finalize (ModelCommand* obj) { + ModelClipRevertCommand * self; + self = MODEL_CLIP_REVERT_COMMAND (obj); + _g_object_unref0 (self->priv->track); + _g_object_unref0 (self->priv->clip); + MODEL_COMMAND_CLASS (model_clip_revert_command_parent_class)->finalize (obj); +} + + +GType model_clip_revert_command_get_type (void) { + static volatile gsize model_clip_revert_command_type_id__volatile = 0; + if (g_once_init_enter (&model_clip_revert_command_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelClipRevertCommandClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_clip_revert_command_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelClipRevertCommand), 0, (GInstanceInitFunc) model_clip_revert_command_instance_init, NULL }; + GType model_clip_revert_command_type_id; + model_clip_revert_command_type_id = g_type_register_static (MODEL_TYPE_COMMAND, "ModelClipRevertCommand", &g_define_type_info, 0); + g_once_init_leave (&model_clip_revert_command_type_id__volatile, model_clip_revert_command_type_id); + } + return model_clip_revert_command_type_id__volatile; +} + + +#line 303 "command.vala" +ModelTimeSignatureCommand* model_time_signature_command_construct (GType object_type, ModelProject* project, Fraction* new_time_signature) { +#line 1971 "command.c" + ModelTimeSignatureCommand* self; + ModelProject* _tmp0_; + Fraction _tmp1_ = {0}; +#line 303 "command.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (project), NULL); +#line 303 "command.vala" + self = (ModelTimeSignatureCommand*) model_command_construct (object_type); +#line 304 "command.vala" + self->priv->project = (_tmp0_ = _g_object_ref0 (project), _g_object_unref0 (self->priv->project), _tmp0_); +#line 305 "command.vala" + self->priv->new_time_signature = *new_time_signature; +#line 306 "command.vala" + self->priv->old_time_signature = (model_tempo_information_get_time_signature (MODEL_TEMPO_INFORMATION (project), &_tmp1_), _tmp1_); +#line 1985 "command.c" + return self; +} + + +#line 303 "command.vala" +ModelTimeSignatureCommand* model_time_signature_command_new (ModelProject* project, Fraction* new_time_signature) { +#line 303 "command.vala" + return model_time_signature_command_construct (MODEL_TYPE_TIME_SIGNATURE_COMMAND, project, new_time_signature); +#line 1994 "command.c" +} + + +#line 309 "command.vala" +static void model_time_signature_command_real_apply (ModelCommand* base) { +#line 2000 "command.c" + ModelTimeSignatureCommand * self; + self = MODEL_TIME_SIGNATURE_COMMAND (base); +#line 310 "command.vala" + _model_project_set_time_signature (self->priv->project, &self->priv->new_time_signature); +#line 2005 "command.c" +} + + +#line 313 "command.vala" +static void model_time_signature_command_real_undo (ModelCommand* base) { +#line 2011 "command.c" + ModelTimeSignatureCommand * self; + self = MODEL_TIME_SIGNATURE_COMMAND (base); +#line 314 "command.vala" + _model_project_set_time_signature (self->priv->project, &self->priv->old_time_signature); +#line 2016 "command.c" +} + + +#line 317 "command.vala" +static gboolean model_time_signature_command_real_merge (ModelCommand* base, ModelCommand* command) { +#line 2022 "command.c" + ModelTimeSignatureCommand * self; + gboolean result = FALSE; + self = MODEL_TIME_SIGNATURE_COMMAND (base); +#line 317 "command.vala" + g_return_val_if_fail (MODEL_IS_COMMAND (command), FALSE); +#line 2028 "command.c" + result = FALSE; +#line 318 "command.vala" + return result; +#line 2032 "command.c" +} + + +#line 321 "command.vala" +static char* model_time_signature_command_real_description (ModelCommand* base) { +#line 2038 "command.c" + ModelTimeSignatureCommand * self; + char* result = NULL; + self = MODEL_TIME_SIGNATURE_COMMAND (base); + result = g_strdup ("Set Time Signature"); +#line 322 "command.vala" + return result; +#line 2045 "command.c" +} + + +static void model_time_signature_command_class_init (ModelTimeSignatureCommandClass * klass) { + model_time_signature_command_parent_class = g_type_class_peek_parent (klass); + MODEL_COMMAND_CLASS (klass)->finalize = model_time_signature_command_finalize; + g_type_class_add_private (klass, sizeof (ModelTimeSignatureCommandPrivate)); + MODEL_COMMAND_CLASS (klass)->apply = model_time_signature_command_real_apply; + MODEL_COMMAND_CLASS (klass)->undo = model_time_signature_command_real_undo; + MODEL_COMMAND_CLASS (klass)->merge = model_time_signature_command_real_merge; + MODEL_COMMAND_CLASS (klass)->description = model_time_signature_command_real_description; +} + + +static void model_time_signature_command_instance_init (ModelTimeSignatureCommand * self) { + self->priv = MODEL_TIME_SIGNATURE_COMMAND_GET_PRIVATE (self); +} + + +static void model_time_signature_command_finalize (ModelCommand* obj) { + ModelTimeSignatureCommand * self; + self = MODEL_TIME_SIGNATURE_COMMAND (obj); + _g_object_unref0 (self->priv->project); + MODEL_COMMAND_CLASS (model_time_signature_command_parent_class)->finalize (obj); +} + + +GType model_time_signature_command_get_type (void) { + static volatile gsize model_time_signature_command_type_id__volatile = 0; + if (g_once_init_enter (&model_time_signature_command_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelTimeSignatureCommandClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_time_signature_command_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelTimeSignatureCommand), 0, (GInstanceInitFunc) model_time_signature_command_instance_init, NULL }; + GType model_time_signature_command_type_id; + model_time_signature_command_type_id = g_type_register_static (MODEL_TYPE_COMMAND, "ModelTimeSignatureCommand", &g_define_type_info, 0); + g_once_init_leave (&model_time_signature_command_type_id__volatile, model_time_signature_command_type_id); + } + return model_time_signature_command_type_id__volatile; +} + + +#line 330 "command.vala" +ModelBpmCommand* model_bpm_command_construct (GType object_type, ModelProject* project, gint new_bpm) { +#line 2087 "command.c" + ModelBpmCommand* self; + ModelProject* _tmp0_; +#line 330 "command.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (project), NULL); +#line 330 "command.vala" + self = (ModelBpmCommand*) model_command_construct (object_type); +#line 331 "command.vala" + self->priv->delta = new_bpm - model_tempo_information_get_bpm (MODEL_TEMPO_INFORMATION (project)); +#line 332 "command.vala" + self->priv->project = (_tmp0_ = _g_object_ref0 (project), _g_object_unref0 (self->priv->project), _tmp0_); +#line 2098 "command.c" + return self; +} + + +#line 330 "command.vala" +ModelBpmCommand* model_bpm_command_new (ModelProject* project, gint new_bpm) { +#line 330 "command.vala" + return model_bpm_command_construct (MODEL_TYPE_BPM_COMMAND, project, new_bpm); +#line 2107 "command.c" +} + + +#line 335 "command.vala" +static void model_bpm_command_real_apply (ModelCommand* base) { +#line 2113 "command.c" + ModelBpmCommand * self; + self = MODEL_BPM_COMMAND (base); +#line 336 "command.vala" + _model_project_set_bpm (self->priv->project, model_tempo_information_get_bpm (MODEL_TEMPO_INFORMATION (self->priv->project)) + self->priv->delta); +#line 2118 "command.c" +} + + +#line 339 "command.vala" +static void model_bpm_command_real_undo (ModelCommand* base) { +#line 2124 "command.c" + ModelBpmCommand * self; + self = MODEL_BPM_COMMAND (base); +#line 340 "command.vala" + _model_project_set_bpm (self->priv->project, model_tempo_information_get_bpm (MODEL_TEMPO_INFORMATION (self->priv->project)) - self->priv->delta); +#line 2129 "command.c" +} + + +#line 343 "command.vala" +static gboolean model_bpm_command_real_merge (ModelCommand* base, ModelCommand* command) { +#line 2135 "command.c" + ModelBpmCommand * self; + gboolean result = FALSE; + self = MODEL_BPM_COMMAND (base); +#line 343 "command.vala" + g_return_val_if_fail (MODEL_IS_COMMAND (command), FALSE); +#line 2141 "command.c" + result = FALSE; +#line 344 "command.vala" + return result; +#line 2145 "command.c" +} + + +#line 347 "command.vala" +static char* model_bpm_command_real_description (ModelCommand* base) { +#line 2151 "command.c" + ModelBpmCommand * self; + char* result = NULL; + self = MODEL_BPM_COMMAND (base); + result = g_strdup ("Set Tempo"); +#line 348 "command.vala" + return result; +#line 2158 "command.c" +} + + +static void model_bpm_command_class_init (ModelBpmCommandClass * klass) { + model_bpm_command_parent_class = g_type_class_peek_parent (klass); + MODEL_COMMAND_CLASS (klass)->finalize = model_bpm_command_finalize; + g_type_class_add_private (klass, sizeof (ModelBpmCommandPrivate)); + MODEL_COMMAND_CLASS (klass)->apply = model_bpm_command_real_apply; + MODEL_COMMAND_CLASS (klass)->undo = model_bpm_command_real_undo; + MODEL_COMMAND_CLASS (klass)->merge = model_bpm_command_real_merge; + MODEL_COMMAND_CLASS (klass)->description = model_bpm_command_real_description; +} + + +static void model_bpm_command_instance_init (ModelBpmCommand * self) { + self->priv = MODEL_BPM_COMMAND_GET_PRIVATE (self); +} + + +static void model_bpm_command_finalize (ModelCommand* obj) { + ModelBpmCommand * self; + self = MODEL_BPM_COMMAND (obj); + _g_object_unref0 (self->priv->project); + MODEL_COMMAND_CLASS (model_bpm_command_parent_class)->finalize (obj); +} + + +GType model_bpm_command_get_type (void) { + static volatile gsize model_bpm_command_type_id__volatile = 0; + if (g_once_init_enter (&model_bpm_command_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelBpmCommandClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_bpm_command_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelBpmCommand), 0, (GInstanceInitFunc) model_bpm_command_instance_init, NULL }; + GType model_bpm_command_type_id; + model_bpm_command_type_id = g_type_register_static (MODEL_TYPE_COMMAND, "ModelBpmCommand", &g_define_type_info, 0); + g_once_init_leave (&model_bpm_command_type_id__volatile, model_bpm_command_type_id); + } + return model_bpm_command_type_id__volatile; +} + + +#line 356 "command.vala" +ModelAddClipCommand* model_add_clip_command_construct (GType object_type, ModelProject* project, ModelClipFile* clip_file) { +#line 2200 "command.c" + ModelAddClipCommand* self; + ModelProject* _tmp0_; + ModelClipFile* _tmp1_; +#line 356 "command.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (project), NULL); +#line 356 "command.vala" + g_return_val_if_fail (MODEL_IS_CLIP_FILE (clip_file), NULL); +#line 356 "command.vala" + self = (ModelAddClipCommand*) model_command_construct (object_type); +#line 357 "command.vala" + self->priv->project = (_tmp0_ = _g_object_ref0 (project), _g_object_unref0 (self->priv->project), _tmp0_); +#line 358 "command.vala" + self->priv->clip_file = (_tmp1_ = _g_object_ref0 (clip_file), _g_object_unref0 (self->priv->clip_file), _tmp1_); +#line 2214 "command.c" + return self; +} + + +#line 356 "command.vala" +ModelAddClipCommand* model_add_clip_command_new (ModelProject* project, ModelClipFile* clip_file) { +#line 356 "command.vala" + return model_add_clip_command_construct (MODEL_TYPE_ADD_CLIP_COMMAND, project, clip_file); +#line 2223 "command.c" +} + + +#line 361 "command.vala" +static void model_add_clip_command_real_apply (ModelCommand* base) { +#line 2229 "command.c" + ModelAddClipCommand * self; + GError * _inner_error_; + self = MODEL_ADD_CLIP_COMMAND (base); + _inner_error_ = NULL; + { +#line 363 "command.vala" + _model_project_add_clipfile (self->priv->project, self->priv->clip_file, &_inner_error_); +#line 2237 "command.c" + if (_inner_error_ != NULL) { + goto __catch6_g_error; + } + } + goto __finally6; + __catch6_g_error: + { + GError * _error_; + _error_ = _inner_error_; + _inner_error_ = NULL; + { +#line 365 "command.vala" + g_signal_emit_by_name (self->priv->project, "error-occurred", "Error importing", "An error occurred importing this file."); +#line 2251 "command.c" + _g_error_free0 (_error_); + } + } + __finally6: + if (_inner_error_ != NULL) { + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } +} + + +#line 369 "command.vala" +static void model_add_clip_command_real_undo (ModelCommand* base) { +#line 2266 "command.c" + ModelAddClipCommand * self; + self = MODEL_ADD_CLIP_COMMAND (base); +#line 370 "command.vala" + _model_project_remove_clipfile (self->priv->project, self->priv->clip_file); +#line 2271 "command.c" +} + + +#line 373 "command.vala" +static gboolean model_add_clip_command_real_merge (ModelCommand* base, ModelCommand* command) { +#line 2277 "command.c" + ModelAddClipCommand * self; + gboolean result = FALSE; + self = MODEL_ADD_CLIP_COMMAND (base); +#line 373 "command.vala" + g_return_val_if_fail (MODEL_IS_COMMAND (command), FALSE); +#line 2283 "command.c" + result = FALSE; +#line 374 "command.vala" + return result; +#line 2287 "command.c" +} + + +#line 377 "command.vala" +static char* model_add_clip_command_real_description (ModelCommand* base) { +#line 2293 "command.c" + ModelAddClipCommand * self; + char* result = NULL; + self = MODEL_ADD_CLIP_COMMAND (base); + result = g_strdup ("Add Clip To Library"); +#line 378 "command.vala" + return result; +#line 2300 "command.c" +} + + +static void model_add_clip_command_class_init (ModelAddClipCommandClass * klass) { + model_add_clip_command_parent_class = g_type_class_peek_parent (klass); + MODEL_COMMAND_CLASS (klass)->finalize = model_add_clip_command_finalize; + g_type_class_add_private (klass, sizeof (ModelAddClipCommandPrivate)); + MODEL_COMMAND_CLASS (klass)->apply = model_add_clip_command_real_apply; + MODEL_COMMAND_CLASS (klass)->undo = model_add_clip_command_real_undo; + MODEL_COMMAND_CLASS (klass)->merge = model_add_clip_command_real_merge; + MODEL_COMMAND_CLASS (klass)->description = model_add_clip_command_real_description; +} + + +static void model_add_clip_command_instance_init (ModelAddClipCommand * self) { + self->priv = MODEL_ADD_CLIP_COMMAND_GET_PRIVATE (self); +} + + +static void model_add_clip_command_finalize (ModelCommand* obj) { + ModelAddClipCommand * self; + self = MODEL_ADD_CLIP_COMMAND (obj); + _g_object_unref0 (self->priv->clip_file); + _g_object_unref0 (self->priv->project); + MODEL_COMMAND_CLASS (model_add_clip_command_parent_class)->finalize (obj); +} + + +GType model_add_clip_command_get_type (void) { + static volatile gsize model_add_clip_command_type_id__volatile = 0; + if (g_once_init_enter (&model_add_clip_command_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelAddClipCommandClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_add_clip_command_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelAddClipCommand), 0, (GInstanceInitFunc) model_add_clip_command_instance_init, NULL }; + GType model_add_clip_command_type_id; + model_add_clip_command_type_id = g_type_register_static (MODEL_TYPE_COMMAND, "ModelAddClipCommand", &g_define_type_info, 0); + g_once_init_leave (&model_add_clip_command_type_id__volatile, model_add_clip_command_type_id); + } + return model_add_clip_command_type_id__volatile; +} + + +#line 386 "command.vala" +ModelTransactionCommand* model_transaction_command_construct (GType object_type, gboolean open, const char* transaction_description) { +#line 2343 "command.c" + ModelTransactionCommand* self; + char* _tmp0_; +#line 386 "command.vala" + g_return_val_if_fail (transaction_description != NULL, NULL); +#line 386 "command.vala" + self = (ModelTransactionCommand*) model_command_construct (object_type); +#line 387 "command.vala" + self->priv->open = open; +#line 388 "command.vala" + self->priv->transaction_description = (_tmp0_ = g_strdup (transaction_description), _g_free0 (self->priv->transaction_description), _tmp0_); +#line 2354 "command.c" + return self; +} + + +#line 386 "command.vala" +ModelTransactionCommand* model_transaction_command_new (gboolean open, const char* transaction_description) { +#line 386 "command.vala" + return model_transaction_command_construct (MODEL_TYPE_TRANSACTION_COMMAND, open, transaction_description); +#line 2363 "command.c" +} + + +#line 391 "command.vala" +gboolean model_transaction_command_in_transaction (ModelTransactionCommand* self) { +#line 2369 "command.c" + gboolean result = FALSE; +#line 391 "command.vala" + g_return_val_if_fail (MODEL_IS_TRANSACTION_COMMAND (self), FALSE); +#line 2373 "command.c" + result = self->priv->open; +#line 392 "command.vala" + return result; +#line 2377 "command.c" +} + + +#line 395 "command.vala" +static void model_transaction_command_real_apply (ModelCommand* base) { +#line 2383 "command.c" + ModelTransactionCommand * self; + self = MODEL_TRANSACTION_COMMAND (base); +} + + +#line 398 "command.vala" +static void model_transaction_command_real_undo (ModelCommand* base) { +#line 2391 "command.c" + ModelTransactionCommand * self; + self = MODEL_TRANSACTION_COMMAND (base); +} + + +#line 401 "command.vala" +static gboolean model_transaction_command_real_merge (ModelCommand* base, ModelCommand* command) { +#line 2399 "command.c" + ModelTransactionCommand * self; + gboolean result = FALSE; + self = MODEL_TRANSACTION_COMMAND (base); +#line 401 "command.vala" + g_return_val_if_fail (MODEL_IS_COMMAND (command), FALSE); +#line 2405 "command.c" + result = FALSE; +#line 402 "command.vala" + return result; +#line 2409 "command.c" +} + + +#line 405 "command.vala" +static char* model_transaction_command_real_description (ModelCommand* base) { +#line 2415 "command.c" + ModelTransactionCommand * self; + char* result = NULL; + self = MODEL_TRANSACTION_COMMAND (base); + result = g_strdup (self->priv->transaction_description); +#line 406 "command.vala" + return result; +#line 2422 "command.c" +} + + +static void model_transaction_command_class_init (ModelTransactionCommandClass * klass) { + model_transaction_command_parent_class = g_type_class_peek_parent (klass); + MODEL_COMMAND_CLASS (klass)->finalize = model_transaction_command_finalize; + g_type_class_add_private (klass, sizeof (ModelTransactionCommandPrivate)); + MODEL_COMMAND_CLASS (klass)->apply = model_transaction_command_real_apply; + MODEL_COMMAND_CLASS (klass)->undo = model_transaction_command_real_undo; + MODEL_COMMAND_CLASS (klass)->merge = model_transaction_command_real_merge; + MODEL_COMMAND_CLASS (klass)->description = model_transaction_command_real_description; +} + + +static void model_transaction_command_instance_init (ModelTransactionCommand * self) { + self->priv = MODEL_TRANSACTION_COMMAND_GET_PRIVATE (self); +} + + +static void model_transaction_command_finalize (ModelCommand* obj) { + ModelTransactionCommand * self; + self = MODEL_TRANSACTION_COMMAND (obj); + _g_free0 (self->priv->transaction_description); + MODEL_COMMAND_CLASS (model_transaction_command_parent_class)->finalize (obj); +} + + +GType model_transaction_command_get_type (void) { + static volatile gsize model_transaction_command_type_id__volatile = 0; + if (g_once_init_enter (&model_transaction_command_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelTransactionCommandClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_transaction_command_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelTransactionCommand), 0, (GInstanceInitFunc) model_transaction_command_instance_init, NULL }; + GType model_transaction_command_type_id; + model_transaction_command_type_id = g_type_register_static (MODEL_TYPE_COMMAND, "ModelTransactionCommand", &g_define_type_info, 0); + g_once_init_leave (&model_transaction_command_type_id__volatile, model_transaction_command_type_id); + } + return model_transaction_command_type_id__volatile; +} + + + + diff --git a/src/marina/marina/command.o b/src/marina/marina/command.o new file mode 100644 index 0000000..e4baa65 Binary files /dev/null and b/src/marina/marina/command.o differ diff --git a/src/marina/marina/import.c b/src/marina/marina/import.c new file mode 100644 index 0000000..3798054 --- /dev/null +++ b/src/marina/marina/import.c @@ -0,0 +1,1919 @@ +/* import.c generated by valac, the Vala compiler + * generated from import.vala, do not modify */ + +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#define TYPE_MULTI_FILE_PROGRESS_INTERFACE (multi_file_progress_interface_get_type ()) +#define MULTI_FILE_PROGRESS_INTERFACE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MULTI_FILE_PROGRESS_INTERFACE, MultiFileProgressInterface)) +#define IS_MULTI_FILE_PROGRESS_INTERFACE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MULTI_FILE_PROGRESS_INTERFACE)) +#define MULTI_FILE_PROGRESS_INTERFACE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_MULTI_FILE_PROGRESS_INTERFACE, MultiFileProgressInterfaceIface)) + +typedef struct _MultiFileProgressInterface MultiFileProgressInterface; +typedef struct _MultiFileProgressInterfaceIface MultiFileProgressInterfaceIface; + +#define MODEL_TYPE_CLIP_IMPORTER (model_clip_importer_get_type ()) +#define MODEL_CLIP_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_IMPORTER, ModelClipImporter)) +#define MODEL_CLIP_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_IMPORTER, ModelClipImporterClass)) +#define MODEL_IS_CLIP_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_IMPORTER)) +#define MODEL_IS_CLIP_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_IMPORTER)) +#define MODEL_CLIP_IMPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_IMPORTER, ModelClipImporterClass)) + +typedef struct _ModelClipImporter ModelClipImporter; +typedef struct _ModelClipImporterClass ModelClipImporterClass; +typedef struct _ModelClipImporterPrivate ModelClipImporterPrivate; + +#define MODEL_CLIP_IMPORTER_TYPE_IMPORT_STATE (model_clip_importer_import_state_get_type ()) + +#define MODEL_TYPE_FETCHER (model_fetcher_get_type ()) +#define MODEL_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_FETCHER, ModelFetcher)) +#define MODEL_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_FETCHER, ModelFetcherClass)) +#define MODEL_IS_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_FETCHER)) +#define MODEL_IS_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_FETCHER)) +#define MODEL_FETCHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_FETCHER, ModelFetcherClass)) + +typedef struct _ModelFetcher ModelFetcher; +typedef struct _ModelFetcherClass ModelFetcherClass; + +#define MODEL_TYPE_CLIP_FETCHER (model_clip_fetcher_get_type ()) +#define MODEL_CLIP_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcher)) +#define MODEL_CLIP_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcherClass)) +#define MODEL_IS_CLIP_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FETCHER)) +#define MODEL_IS_CLIP_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FETCHER)) +#define MODEL_CLIP_FETCHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcherClass)) + +typedef struct _ModelClipFetcher ModelClipFetcher; +typedef struct _ModelClipFetcherClass ModelClipFetcherClass; +#define _g_free0(var) (var = (g_free (var), NULL)) +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +#define _gst_object_unref0(var) ((var == NULL) ? NULL : (var = (gst_object_unref (var), NULL))) + +#define LOGGING_TYPE_FACILITY (logging_facility_get_type ()) + +#define LOGGING_TYPE_LEVEL (logging_level_get_type ()) +typedef struct _ModelFetcherPrivate ModelFetcherPrivate; + +#define MODEL_TYPE_CLIP_FILE (model_clip_file_get_type ()) +#define MODEL_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFile)) +#define MODEL_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) +#define MODEL_IS_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE)) +#define MODEL_IS_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE)) +#define MODEL_CLIP_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) + +typedef struct _ModelClipFile ModelClipFile; +typedef struct _ModelClipFileClass ModelClipFileClass; +typedef struct _ModelClipFilePrivate ModelClipFilePrivate; +#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL))) + +#define MODEL_TYPE_MEDIA_TYPE (model_media_type_get_type ()) + +#define TYPE_SINGLE_DECODE_BIN (single_decode_bin_get_type ()) +#define SINGLE_DECODE_BIN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SINGLE_DECODE_BIN, SingleDecodeBin)) +#define SINGLE_DECODE_BIN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SINGLE_DECODE_BIN, SingleDecodeBinClass)) +#define IS_SINGLE_DECODE_BIN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SINGLE_DECODE_BIN)) +#define IS_SINGLE_DECODE_BIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SINGLE_DECODE_BIN)) +#define SINGLE_DECODE_BIN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SINGLE_DECODE_BIN, SingleDecodeBinClass)) + +typedef struct _SingleDecodeBin SingleDecodeBin; +typedef struct _SingleDecodeBinClass SingleDecodeBinClass; +#define _gst_caps_unref0(var) ((var == NULL) ? NULL : (var = (gst_caps_unref (var), NULL))) + +#define MODEL_TYPE_LIBRARY_IMPORTER (model_library_importer_get_type ()) +#define MODEL_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporter)) +#define MODEL_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass)) +#define MODEL_IS_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_LIBRARY_IMPORTER)) +#define MODEL_IS_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_LIBRARY_IMPORTER)) +#define MODEL_LIBRARY_IMPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass)) + +typedef struct _ModelLibraryImporter ModelLibraryImporter; +typedef struct _ModelLibraryImporterClass ModelLibraryImporterClass; +typedef struct _ModelLibraryImporterPrivate ModelLibraryImporterPrivate; + +#define MODEL_TYPE_PROJECT (model_project_get_type ()) +#define MODEL_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT, ModelProject)) +#define MODEL_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT, ModelProjectClass)) +#define MODEL_IS_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT)) +#define MODEL_IS_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT)) +#define MODEL_PROJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT, ModelProjectClass)) + +typedef struct _ModelProject ModelProject; +typedef struct _ModelProjectClass ModelProjectClass; + +#define MODEL_TYPE_TIMELINE_IMPORTER (model_timeline_importer_get_type ()) +#define MODEL_TIMELINE_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TIMELINE_IMPORTER, ModelTimelineImporter)) +#define MODEL_TIMELINE_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TIMELINE_IMPORTER, ModelTimelineImporterClass)) +#define MODEL_IS_TIMELINE_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TIMELINE_IMPORTER)) +#define MODEL_IS_TIMELINE_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TIMELINE_IMPORTER)) +#define MODEL_TIMELINE_IMPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TIMELINE_IMPORTER, ModelTimelineImporterClass)) + +typedef struct _ModelTimelineImporter ModelTimelineImporter; +typedef struct _ModelTimelineImporterClass ModelTimelineImporterClass; +typedef struct _ModelTimelineImporterPrivate ModelTimelineImporterPrivate; + +#define MODEL_TYPE_TRACK (model_track_get_type ()) +#define MODEL_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TRACK, ModelTrack)) +#define MODEL_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TRACK, ModelTrackClass)) +#define MODEL_IS_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TRACK)) +#define MODEL_IS_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TRACK)) +#define MODEL_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TRACK, ModelTrackClass)) + +typedef struct _ModelTrack ModelTrack; +typedef struct _ModelTrackClass ModelTrackClass; + +#define MODEL_TYPE_VIDEO_TRACK (model_video_track_get_type ()) +#define MODEL_VIDEO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_VIDEO_TRACK, ModelVideoTrack)) +#define MODEL_VIDEO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_VIDEO_TRACK, ModelVideoTrackClass)) +#define MODEL_IS_VIDEO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_VIDEO_TRACK)) +#define MODEL_IS_VIDEO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_VIDEO_TRACK)) +#define MODEL_VIDEO_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_VIDEO_TRACK, ModelVideoTrackClass)) + +typedef struct _ModelVideoTrack ModelVideoTrack; +typedef struct _ModelVideoTrackClass ModelVideoTrackClass; + +#define MODEL_TYPE_AUDIO_TRACK (model_audio_track_get_type ()) +#define MODEL_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrack)) +#define MODEL_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrackClass)) +#define MODEL_IS_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_AUDIO_TRACK)) +#define MODEL_IS_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_AUDIO_TRACK)) +#define MODEL_AUDIO_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrackClass)) + +typedef struct _ModelAudioTrack ModelAudioTrack; +typedef struct _ModelAudioTrackClass ModelAudioTrackClass; + +#define MODEL_TYPE_TEMPO_INFORMATION (model_tempo_information_get_type ()) +#define MODEL_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformation)) +#define MODEL_IS_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TEMPO_INFORMATION)) +#define MODEL_TEMPO_INFORMATION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformationIface)) + +typedef struct _ModelTempoInformation ModelTempoInformation; +typedef struct _ModelTempoInformationIface ModelTempoInformationIface; + +#define TYPE_FRACTION (fraction_get_type ()) +typedef struct _Fraction Fraction; +typedef struct _ModelProjectPrivate ModelProjectPrivate; + +#define TYPE_TIME_CODE (time_code_get_type ()) +typedef struct _TimeCode TimeCode; + +#define VIEW_TYPE_MEDIA_ENGINE (view_media_engine_get_type ()) +#define VIEW_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngine)) +#define VIEW_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass)) +#define VIEW_IS_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_ENGINE)) +#define VIEW_IS_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_ENGINE)) +#define VIEW_MEDIA_ENGINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass)) + +typedef struct _ViewMediaEngine ViewMediaEngine; +typedef struct _ViewMediaEngineClass ViewMediaEngineClass; + +#define MODEL_TYPE_PROJECT_LOADER (model_project_loader_get_type ()) +#define MODEL_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoader)) +#define MODEL_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass)) +#define MODEL_IS_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT_LOADER)) +#define MODEL_IS_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT_LOADER)) +#define MODEL_PROJECT_LOADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass)) + +typedef struct _ModelProjectLoader ModelProjectLoader; +typedef struct _ModelProjectLoaderClass ModelProjectLoaderClass; + +#define MODEL_TYPE_UNDO_MANAGER (model_undo_manager_get_type ()) +#define MODEL_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManager)) +#define MODEL_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass)) +#define MODEL_IS_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_UNDO_MANAGER)) +#define MODEL_IS_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_UNDO_MANAGER)) +#define MODEL_UNDO_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass)) + +typedef struct _ModelUndoManager ModelUndoManager; +typedef struct _ModelUndoManagerClass ModelUndoManagerClass; + +struct _MultiFileProgressInterfaceIface { + GTypeInterface parent_iface; + void (*cancel) (MultiFileProgressInterface* self); + void (*complete) (MultiFileProgressInterface* self); +}; + +struct _ModelClipImporter { + GObject parent_instance; + ModelClipImporterPrivate * priv; +}; + +struct _ModelClipImporterClass { + GObjectClass parent_class; +}; + +typedef enum { + MODEL_CLIP_IMPORTER_IMPORT_STATE_FETCHING, + MODEL_CLIP_IMPORTER_IMPORT_STATE_IMPORTING, + MODEL_CLIP_IMPORTER_IMPORT_STATE_CANCELLED +} ModelClipImporterImportState; + +struct _ModelClipImporterPrivate { + char* import_directory; + ModelClipImporterImportState import_state; + gboolean import_done; + gboolean all_done; + ModelClipFetcher* our_fetcher; + GstPad* video_pad; + GstPad* audio_pad; + GstPipeline* pipeline; + GstElement* filesink; + GstElement* video_convert; + GstElement* audio_convert; + GstElement* mux; + GstBin* video_decoder; + GstBin* audio_decoder; + gint current_file_importing; + gint64 current_time; + gint64 total_time; + gint64 previous_time; + GeeArrayList* filenames; + GeeArrayList* queued_fetchers; + GeeArrayList* queued_filenames; + GeeArrayList* no_import_formats; +}; + +typedef enum { + LOGGING_FACILITY_SIGNAL_HANDLERS, + LOGGING_FACILITY_DEVELOPER_WARNINGS, + LOGGING_FACILITY_GRAPH, + LOGGING_FACILITY_LOADING, + LOGGING_FACILITY_IMPORT, + LOGGING_FACILITY_SINGLEDECODEBIN +} LoggingFacility; + +typedef enum { + LOGGING_LEVEL_CRITICAL, + LOGGING_LEVEL_HIGH, + LOGGING_LEVEL_MEDIUM, + LOGGING_LEVEL_LOW, + LOGGING_LEVEL_INFO, + LOGGING_LEVEL_VERBOSE +} LoggingLevel; + +struct _ModelFetcher { + GObject parent_instance; + ModelFetcherPrivate * priv; + GstElement* filesrc; + GstElement* decodebin; + GstPipeline* pipeline; + ModelClipFile* clipfile; + char* error_string; +}; + +struct _ModelFetcherClass { + GObjectClass parent_class; + void (*on_pad_added) (ModelFetcher* self, GstPad* pad); + void (*on_state_change) (ModelFetcher* self, GstBus* bus, GstMessage* message); +}; + +struct _ModelClipFile { + GObject parent_instance; + ModelClipFilePrivate * priv; + char* filename; + GstCaps* video_caps; + GstCaps* audio_caps; + GdkPixbuf* thumbnail; +}; + +struct _ModelClipFileClass { + GObjectClass parent_class; +}; + +typedef enum { + MODEL_MEDIA_TYPE_AUDIO, + MODEL_MEDIA_TYPE_VIDEO +} ModelMediaType; + +struct _ModelLibraryImporter { + GObject parent_instance; + ModelLibraryImporterPrivate * priv; + ModelProject* project; + ModelClipImporter* importer; +}; + +struct _ModelLibraryImporterClass { + GObjectClass parent_class; + void (*append_existing_clipfile) (ModelLibraryImporter* self, ModelClipFile* f); + void (*on_clip_complete) (ModelLibraryImporter* self, ModelClipFile* f); +}; + +struct _ModelTimelineImporter { + ModelLibraryImporter parent_instance; + ModelTimelineImporterPrivate * priv; +}; + +struct _ModelTimelineImporterClass { + ModelLibraryImporterClass parent_class; +}; + +struct _ModelTimelineImporterPrivate { + ModelTrack* track; + gint64 time_to_add; + gboolean both_tracks; +}; + +struct _Fraction { + gint numerator; + gint denominator; +}; + +struct _ModelTempoInformationIface { + GTypeInterface parent_iface; + void (*get_time_signature) (ModelTempoInformation* self, Fraction* result); + gint (*get_bpm) (ModelTempoInformation* self); +}; + +struct _TimeCode { + gint hour; + gint minute; + gint second; + gint frame; + gboolean drop_code; +}; + +struct _ModelProject { + GObject parent_instance; + ModelProjectPrivate * priv; + GeeArrayList* tracks; + GeeArrayList* inactive_tracks; + GeeArrayList* clipfiles; + ViewMediaEngine* media_engine; + char* project_file; + ModelProjectLoader* loader; + ModelUndoManager* undo_manager; + ModelLibraryImporter* importer; + Fraction default_framerate; + gboolean click_during_play; + gboolean click_during_record; + double click_volume; + gboolean library_visible; + gint library_width; + gboolean snap_to_clip; +}; + +struct _ModelProjectClass { + GObjectClass parent_class; + void (*get_clip_time) (ModelProject* self, ModelClipFile* f, TimeCode* result); + char* (*get_project_file) (ModelProject* self); + void (*do_append) (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, const char* name, gint64 insert_time); + void (*add_track) (ModelProject* self, ModelTrack* track); + void (*insert_track) (ModelProject* self, gint index, ModelTrack* track); + void (*load) (ModelProject* self, const char* fname); + void (*save) (ModelProject* self, const char* filename); + char* (*get_app_name) (ModelProject* self); + void (*load_complete) (ModelProject* self); +}; + + +static gpointer model_clip_importer_parent_class = NULL; +static MultiFileProgressInterfaceIface* model_clip_importer_multi_file_progress_interface_parent_iface = NULL; +static gpointer model_library_importer_parent_class = NULL; +static gpointer model_timeline_importer_parent_class = NULL; + +GType multi_file_progress_interface_get_type (void); +GType model_clip_importer_get_type (void); +static GType model_clip_importer_import_state_get_type (void) G_GNUC_UNUSED; +GType model_fetcher_get_type (void); +GType model_clip_fetcher_get_type (void); +#define MODEL_CLIP_IMPORTER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_CLIP_IMPORTER, ModelClipImporterPrivate)) +enum { + MODEL_CLIP_IMPORTER_DUMMY_PROPERTY +}; +ModelClipImporter* model_clip_importer_new (void); +ModelClipImporter* model_clip_importer_construct (GType object_type); +void model_clip_importer_add_filename (ModelClipImporter* self, const char* filename); +static gboolean model_clip_importer_on_timer_callback (ModelClipImporter* self); +static gboolean _model_clip_importer_on_timer_callback_gsource_func (gpointer self); +static void model_clip_importer_start_import (ModelClipImporter* self); +static void model_clip_importer_real_cancel (MultiFileProgressInterface* base); +static void model_clip_importer_process_curr_file (ModelClipImporter* self, GError** error); +void model_clip_importer_start (ModelClipImporter* self, GError** error); +GType logging_facility_get_type (void); +GType logging_level_get_type (void); +void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message); +ModelClipFetcher* model_clip_fetcher_new (const char* filename, GError** error); +ModelClipFetcher* model_clip_fetcher_construct (GType object_type, const char* filename, GError** error); +static void model_clip_importer_on_fetcher_ready (ModelClipImporter* self, ModelFetcher* f); +static void _model_clip_importer_on_fetcher_ready_model_fetcher_ready (ModelFetcher* _sender, ModelFetcher* fetcher, gpointer self); +static void model_clip_importer_do_import (ModelClipImporter* self, ModelClipFetcher* f, GError** error); +static void model_clip_importer_real_complete (MultiFileProgressInterface* base); +char* append_extension (const char* path, const char* extension); +GType model_clip_file_get_type (void); +gint64 model_clip_file_get_length (ModelClipFile* self); +static void model_clip_importer_do_import_complete (ModelClipImporter* self, GError** error); +static gboolean model_clip_importer_need_to_import (ModelClipImporter* self, ModelFetcher* f); +gboolean md5_checksum_on_file (const char* filename, char** checksum); +char* isolate_filename (const char* path); +gboolean get_file_md5_checksum (const char* filename, char** checksum); +void save_file_md5_checksum (const char* filename, const char* checksum); +static void model_clip_importer_on_state_changed (ModelClipImporter* self, GstBus* b, GstMessage* m); +static void _model_clip_importer_on_state_changed_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self); +static void model_clip_importer_on_eos (ModelClipImporter* self); +static void _model_clip_importer_on_eos_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self); +static void model_clip_importer_on_error (ModelClipImporter* self, GstBus* bus, GstMessage* message); +static void _model_clip_importer_on_error_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self); +static void model_clip_importer_on_warning (ModelClipImporter* self, GstBus* bus, GstMessage* message); +static void _model_clip_importer_on_warning_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self); +GstElement* make_element (const char* name, GError** error); +GType model_media_type_get_type (void); +gboolean model_clip_file_is_of_type (ModelClipFile* self, ModelMediaType t); +SingleDecodeBin* single_decode_bin_new (GstCaps* caps, const char* name, const char* uri, GError** error); +SingleDecodeBin* single_decode_bin_construct (GType object_type, GstCaps* caps, const char* name, const char* uri, GError** error); +GType single_decode_bin_get_type (void); +static void model_clip_importer_on_pad_added (ModelClipImporter* self, GstPad* p); +static void _model_clip_importer_on_pad_added_gst_element_pad_added (GstElement* _sender, GstPad* pad, gpointer self); +static void model_clip_importer_finalize (GObject* obj); +GType model_library_importer_get_type (void); +GType model_project_get_type (void); +enum { + MODEL_LIBRARY_IMPORTER_DUMMY_PROPERTY +}; +void model_library_importer_on_clip_complete (ModelLibraryImporter* self, ModelClipFile* f); +static void _model_library_importer_on_clip_complete_model_clip_importer_clip_complete (ModelClipImporter* _sender, ModelClipFile* f, gpointer self); +static void model_library_importer_on_error_occurred (ModelLibraryImporter* self, const char* _error_); +static void _model_library_importer_on_error_occurred_model_clip_importer_error_occurred (ModelClipImporter* _sender, const char* _error_, gpointer self); +static void model_library_importer_on_importer_started (ModelLibraryImporter* self, ModelClipImporter* i, gint num); +static void _model_library_importer_on_importer_started_model_clip_importer_importing_started (ModelClipImporter* _sender, gint num_clips, gpointer self); +ModelLibraryImporter* model_library_importer_new (ModelProject* p); +ModelLibraryImporter* model_library_importer_construct (GType object_type, ModelProject* p); +void model_library_importer_append_existing_clipfile (ModelLibraryImporter* self, ModelClipFile* f); +static void model_library_importer_real_append_existing_clipfile (ModelLibraryImporter* self, ModelClipFile* f); +ModelClipFile* model_project_find_clipfile (ModelProject* self, const char* filename); +void model_project_add_clipfile (ModelProject* self, ModelClipFile* clipfile); +static void model_library_importer_real_on_clip_complete (ModelLibraryImporter* self, ModelClipFile* f); +void model_library_importer_add_file (ModelLibraryImporter* self, const char* filename, GError** error); +void model_library_importer_start (ModelLibraryImporter* self, GError** error); +static void model_library_importer_finalize (GObject* obj); +GType model_timeline_importer_get_type (void); +GType model_track_get_type (void); +#define MODEL_TIMELINE_IMPORTER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_TIMELINE_IMPORTER, ModelTimelineImporterPrivate)) +enum { + MODEL_TIMELINE_IMPORTER_DUMMY_PROPERTY +}; +ModelTimelineImporter* model_timeline_importer_new (ModelTrack* track, ModelProject* p, gint64 time_to_add, gboolean both_tracks); +ModelTimelineImporter* model_timeline_importer_construct (GType object_type, ModelTrack* track, ModelProject* p, gint64 time_to_add, gboolean both_tracks); +GType model_video_track_get_type (void); +GType model_audio_track_get_type (void); +ModelAudioTrack* model_project_find_audio_track (ModelProject* self); +ModelVideoTrack* model_project_find_video_track (ModelProject* self); +void model_project_add (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, gint64 time); +static void model_timeline_importer_add_to_both (ModelTimelineImporter* self, ModelClipFile* clip_file); +GType fraction_get_type (void); +Fraction* fraction_dup (const Fraction* self); +void fraction_free (Fraction* self); +GType model_tempo_information_get_type (void); +GType time_code_get_type (void); +TimeCode* time_code_dup (const TimeCode* self); +void time_code_free (TimeCode* self); +GType view_media_engine_get_type (void); +GType model_project_loader_get_type (void); +gpointer model_undo_manager_ref (gpointer instance); +void model_undo_manager_unref (gpointer instance); +GParamSpec* model_param_spec_undo_manager (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_undo_manager (GValue* value, gpointer v_object); +void model_value_take_undo_manager (GValue* value, gpointer v_object); +gpointer model_value_get_undo_manager (const GValue* value); +GType model_undo_manager_get_type (void); +void model_undo_manager_start_transaction (ModelUndoManager* self, const char* description); +void model_undo_manager_end_transaction (ModelUndoManager* self, const char* description); +static void model_timeline_importer_real_append_existing_clipfile (ModelLibraryImporter* base, ModelClipFile* f); +static void model_timeline_importer_real_on_clip_complete (ModelLibraryImporter* base, ModelClipFile* f); +static void model_timeline_importer_finalize (GObject* obj); +static int _vala_strcmp0 (const char * str1, const char * str2); + + +static void g_cclosure_user_marshal_VOID__OBJECT_INT (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data); + +static GType model_clip_importer_import_state_get_type (void) { + static volatile gsize model_clip_importer_import_state_type_id__volatile = 0; + if (g_once_init_enter (&model_clip_importer_import_state_type_id__volatile)) { + static const GEnumValue values[] = {{MODEL_CLIP_IMPORTER_IMPORT_STATE_FETCHING, "MODEL_CLIP_IMPORTER_IMPORT_STATE_FETCHING", "fetching"}, {MODEL_CLIP_IMPORTER_IMPORT_STATE_IMPORTING, "MODEL_CLIP_IMPORTER_IMPORT_STATE_IMPORTING", "importing"}, {MODEL_CLIP_IMPORTER_IMPORT_STATE_CANCELLED, "MODEL_CLIP_IMPORTER_IMPORT_STATE_CANCELLED", "cancelled"}, {0, NULL, NULL}}; + GType model_clip_importer_import_state_type_id; + model_clip_importer_import_state_type_id = g_enum_register_static ("ModelClipImporterImportState", values); + g_once_init_leave (&model_clip_importer_import_state_type_id__volatile, model_clip_importer_import_state_type_id); + } + return model_clip_importer_import_state_type_id__volatile; +} + + +#line 52 "import.vala" +ModelClipImporter* model_clip_importer_construct (GType object_type) { +#line 516 "import.c" + ModelClipImporter * self; + char* _tmp0_; + char* _tmp1_; +#line 52 "import.vala" + self = (ModelClipImporter*) g_object_new (object_type, NULL); +#line 53 "import.vala" + self->priv->import_directory = (_tmp0_ = g_strdup (g_get_home_dir ()), _g_free0 (self->priv->import_directory), _tmp0_); +#line 54 "import.vala" + self->priv->import_directory = (_tmp1_ = g_strconcat (self->priv->import_directory, "/.lombard_fillmore_import/", NULL), _g_free0 (self->priv->import_directory), _tmp1_); +#line 56 "import.vala" + g_mkdir (self->priv->import_directory, 0777); +#line 58 "import.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->no_import_formats), "YUY2"); +#line 59 "import.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->no_import_formats), "Y41B"); +#line 61 "import.vala" + self->priv->import_state = MODEL_CLIP_IMPORTER_IMPORT_STATE_FETCHING; +#line 534 "import.c" + return self; +} + + +#line 52 "import.vala" +ModelClipImporter* model_clip_importer_new (void) { +#line 52 "import.vala" + return model_clip_importer_construct (MODEL_TYPE_CLIP_IMPORTER); +#line 543 "import.c" +} + + +#line 64 "import.vala" +void model_clip_importer_add_filename (ModelClipImporter* self, const char* filename) { +#line 64 "import.vala" + g_return_if_fail (MODEL_IS_CLIP_IMPORTER (self)); +#line 64 "import.vala" + g_return_if_fail (filename != NULL); +#line 65 "import.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->filenames), filename); +#line 555 "import.c" +} + + +#line 68 "import.vala" +static gboolean model_clip_importer_on_timer_callback (ModelClipImporter* self) { +#line 561 "import.c" + gboolean result = FALSE; + gint64 time = 0LL; + GstFormat format; + gboolean _tmp0_ = FALSE; +#line 68 "import.vala" + g_return_val_if_fail (MODEL_IS_CLIP_IMPORTER (self), FALSE); +#line 70 "import.vala" + format = GST_FORMAT_TIME; +#line 72 "import.vala" + if (self->priv->all_done) { +#line 572 "import.c" + result = FALSE; +#line 73 "import.vala" + return result; +#line 576 "import.c" + } +#line 75 "import.vala" + if (gst_element_query_position (GST_ELEMENT (self->priv->pipeline), &format, &time)) { +#line 76 "import.vala" + _tmp0_ = format == GST_FORMAT_TIME; +#line 582 "import.c" + } else { +#line 75 "import.vala" + _tmp0_ = FALSE; +#line 586 "import.c" + } +#line 75 "import.vala" + if (_tmp0_) { +#line 77 "import.vala" + if (time > self->priv->previous_time) { +#line 78 "import.vala" + self->priv->current_time = self->priv->current_time + (time - self->priv->previous_time); +#line 594 "import.c" + } +#line 79 "import.vala" + self->priv->previous_time = time; +#line 80 "import.vala" + if (self->priv->current_time >= self->priv->total_time) { +#line 81 "import.vala" + g_signal_emit_by_name (MULTI_FILE_PROGRESS_INTERFACE (self), "fraction-updated", 1.0); +#line 602 "import.c" + result = FALSE; +#line 82 "import.vala" + return result; +#line 606 "import.c" + } else { +#line 84 "import.vala" + g_signal_emit_by_name (MULTI_FILE_PROGRESS_INTERFACE (self), "fraction-updated", self->priv->current_time / ((double) self->priv->total_time)); +#line 610 "import.c" + } + } + result = TRUE; +#line 86 "import.vala" + return result; +#line 616 "import.c" +} + + +#line 68 "import.vala" +static gboolean _model_clip_importer_on_timer_callback_gsource_func (gpointer self) { +#line 622 "import.c" + gboolean result; + result = model_clip_importer_on_timer_callback (self); + return result; +} + + +#line 89 "import.vala" +static void model_clip_importer_start_import (ModelClipImporter* self) { +#line 89 "import.vala" + g_return_if_fail (MODEL_IS_CLIP_IMPORTER (self)); +#line 90 "import.vala" + self->priv->import_state = MODEL_CLIP_IMPORTER_IMPORT_STATE_IMPORTING; +#line 91 "import.vala" + self->priv->current_file_importing = 0; +#line 92 "import.vala" + g_signal_emit_by_name (self, "importing-started", gee_collection_get_size (GEE_COLLECTION (self->priv->queued_fetchers))); +#line 93 "import.vala" + g_timeout_add_full (G_PRIORITY_DEFAULT, (guint) 50, _model_clip_importer_on_timer_callback_gsource_func, g_object_ref (self), g_object_unref); +#line 641 "import.c" +} + + +#line 96 "import.vala" +static void model_clip_importer_real_cancel (MultiFileProgressInterface* base) { +#line 647 "import.c" + ModelClipImporter * self; + self = MODEL_CLIP_IMPORTER (base); +#line 97 "import.vala" + self->priv->all_done = TRUE; +#line 98 "import.vala" + self->priv->import_state = MODEL_CLIP_IMPORTER_IMPORT_STATE_CANCELLED; +#line 99 "import.vala" + if (self->priv->pipeline != NULL) { +#line 100 "import.vala" + gst_element_set_state (GST_ELEMENT (self->priv->pipeline), GST_STATE_NULL); +#line 658 "import.c" + } +} + + +#line 104 "import.vala" +void model_clip_importer_start (ModelClipImporter* self, GError** error) { +#line 665 "import.c" + GError * _inner_error_; +#line 104 "import.vala" + g_return_if_fail (MODEL_IS_CLIP_IMPORTER (self)); +#line 669 "import.c" + _inner_error_ = NULL; +#line 105 "import.vala" + model_clip_importer_process_curr_file (self, &_inner_error_); +#line 673 "import.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + return; + } +} + + +#line 173 "import.vala" +static void _model_clip_importer_on_fetcher_ready_model_fetcher_ready (ModelFetcher* _sender, ModelFetcher* fetcher, gpointer self) { +#line 683 "import.c" + model_clip_importer_on_fetcher_ready (self, fetcher); +} + + +#line 108 "import.vala" +static void model_clip_importer_process_curr_file (ModelClipImporter* self, GError** error) { +#line 690 "import.c" + GError * _inner_error_; +#line 108 "import.vala" + g_return_if_fail (MODEL_IS_CLIP_IMPORTER (self)); +#line 694 "import.c" + _inner_error_ = NULL; +#line 109 "import.vala" + if (self->priv->import_state == MODEL_CLIP_IMPORTER_IMPORT_STATE_FETCHING) { +#line 110 "import.vala" + if (self->priv->current_file_importing == gee_collection_get_size (GEE_COLLECTION (self->priv->filenames))) { +#line 111 "import.vala" + if (gee_collection_get_size (GEE_COLLECTION (self->priv->queued_fetchers)) == 0) { +#line 112 "import.vala" + g_signal_emit_by_name (MULTI_FILE_PROGRESS_INTERFACE (self), "done"); +#line 704 "import.c" + } else { +#line 114 "import.vala" + model_clip_importer_start_import (self); +#line 708 "import.c" + } + } else { + char* _tmp1_; + char* _tmp0_; + char* _tmp2_; + ModelClipFetcher* _tmp3_; + ModelClipFetcher* _tmp4_; + ModelClipFetcher* _tmp5_; +#line 116 "import.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_IMPORT, LOGGING_LEVEL_VERBOSE, _tmp1_ = g_strdup_printf ("fetching %s", _tmp0_ = (char*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->priv->filenames), self->priv->current_file_importing))); +#line 719 "import.c" + _g_free0 (_tmp1_); + _g_free0 (_tmp0_); +#line 118 "import.vala" + _tmp4_ = (_tmp3_ = model_clip_fetcher_new (_tmp2_ = (char*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->priv->filenames), self->priv->current_file_importing), &_inner_error_), _g_free0 (_tmp2_), _tmp3_); +#line 724 "import.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + return; + } +#line 118 "import.vala" + self->priv->our_fetcher = (_tmp5_ = _tmp4_, _g_object_unref0 (self->priv->our_fetcher), _tmp5_); +#line 119 "import.vala" + g_signal_connect_object (MODEL_FETCHER (self->priv->our_fetcher), "ready", (GCallback) _model_clip_importer_on_fetcher_ready_model_fetcher_ready, self, 0); +#line 733 "import.c" + } + } +#line 123 "import.vala" + if (self->priv->import_state == MODEL_CLIP_IMPORTER_IMPORT_STATE_IMPORTING) { +#line 124 "import.vala" + if (self->priv->current_file_importing == gee_collection_get_size (GEE_COLLECTION (self->priv->queued_fetchers))) { +#line 125 "import.vala" + g_signal_emit_by_name (MULTI_FILE_PROGRESS_INTERFACE (self), "fraction-updated", 1.0); +#line 126 "import.vala" + self->priv->all_done = TRUE; +#line 744 "import.c" + } else { + ModelClipFetcher* _tmp6_; +#line 128 "import.vala" + model_clip_importer_do_import (self, _tmp6_ = (ModelClipFetcher*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->priv->queued_fetchers), self->priv->current_file_importing), &_inner_error_); +#line 749 "import.c" + _g_object_unref0 (_tmp6_); + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + return; + } + } + } +} + + +#line 133 "import.vala" +static void model_clip_importer_real_complete (MultiFileProgressInterface* base) { +#line 762 "import.c" + ModelClipImporter * self; + self = MODEL_CLIP_IMPORTER (base); +#line 134 "import.vala" + self->priv->all_done = TRUE; +#line 767 "import.c" +} + + +#line 137 "import.vala" +static void model_clip_importer_do_import_complete (ModelClipImporter* self, GError** error) { +#line 773 "import.c" + GError * _inner_error_; +#line 137 "import.vala" + g_return_if_fail (MODEL_IS_CLIP_IMPORTER (self)); +#line 777 "import.c" + _inner_error_ = NULL; +#line 138 "import.vala" + if (self->priv->import_state == MODEL_CLIP_IMPORTER_IMPORT_STATE_IMPORTING) { +#line 781 "import.c" + char* _tmp2_; + char* *_tmp1_; + char* _tmp0_; +#line 139 "import.vala" + _tmp1_ = &MODEL_FETCHER (self->priv->our_fetcher)->clipfile->filename; +#line 139 "import.vala" + (*_tmp1_) = (_tmp2_ = append_extension (_tmp0_ = (char*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->priv->queued_filenames), self->priv->current_file_importing), "mov"), _g_free0 ((*_tmp1_)), _tmp2_); +#line 789 "import.c" + _g_free0 (_tmp0_); +#line 141 "import.vala" + g_signal_emit_by_name (self, "clip-complete", MODEL_FETCHER (self->priv->our_fetcher)->clipfile); +#line 793 "import.c" + } else { +#line 143 "import.vala" + self->priv->total_time = self->priv->total_time + model_clip_file_get_length (MODEL_FETCHER (self->priv->our_fetcher)->clipfile); +#line 797 "import.c" + } +#line 145 "import.vala" + self->priv->current_file_importing++; +#line 147 "import.vala" + if (self->priv->current_file_importing <= gee_collection_get_size (GEE_COLLECTION (self->priv->filenames))) { +#line 148 "import.vala" + model_clip_importer_process_curr_file (self, &_inner_error_); +#line 805 "import.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + return; + } + } else { + char* _tmp3_; +#line 150 "import.vala" + g_warning ("import.vala:150: %s", _tmp3_ = g_strdup_printf ("do_import_complete: current_file_importing out of bounds! %d %d", self->priv->current_file_importing, gee_collection_get_size (GEE_COLLECTION (self->priv->filenames)))); +#line 814 "import.c" + _g_free0 (_tmp3_); + } +} + + +#line 154 "import.vala" +static gboolean model_clip_importer_need_to_import (ModelClipImporter* self, ModelFetcher* f) { +#line 822 "import.c" + gboolean result = FALSE; +#line 154 "import.vala" + g_return_val_if_fail (MODEL_IS_CLIP_IMPORTER (self), FALSE); +#line 154 "import.vala" + g_return_val_if_fail (MODEL_IS_FETCHER (f), FALSE); +#line 828 "import.c" + result = FALSE; +#line 156 "import.vala" + return result; +#line 832 "import.c" +} + + +#line 173 "import.vala" +static void model_clip_importer_on_fetcher_ready (ModelClipImporter* self, ModelFetcher* f) { +#line 838 "import.c" + GError * _inner_error_; +#line 173 "import.vala" + g_return_if_fail (MODEL_IS_CLIP_IMPORTER (self)); +#line 173 "import.vala" + g_return_if_fail (MODEL_IS_FETCHER (f)); +#line 844 "import.c" + _inner_error_ = NULL; +#line 174 "import.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_fetcher_ready"); +#line 848 "import.c" + { +#line 176 "import.vala" + if (f->error_string != NULL) { +#line 177 "import.vala" + g_signal_emit_by_name (self, "error-occurred", f->error_string); +#line 178 "import.vala" + model_clip_importer_do_import_complete (self, &_inner_error_); +#line 856 "import.c" + if (_inner_error_ != NULL) { + goto __catch7_g_error; + } +#line 179 "import.vala" + return; +#line 862 "import.c" + } +#line 182 "import.vala" + if (model_clip_importer_need_to_import (self, f)) { +#line 866 "import.c" + char* checksum; + char* _tmp2_; + gboolean _tmp1_; + char* _tmp0_ = NULL; + checksum = NULL; +#line 184 "import.vala" + if ((_tmp1_ = md5_checksum_on_file (f->clipfile->filename, &_tmp0_), checksum = (_tmp2_ = _tmp0_, _g_free0 (checksum), _tmp2_), _tmp1_)) { +#line 874 "import.c" + char* _tmp3_; + char* _tmp4_; + char* base_filename; + gint index; + char* new_filename; +#line 185 "import.vala" + base_filename = (_tmp4_ = g_strconcat (self->priv->import_directory, _tmp3_ = isolate_filename (f->clipfile->filename), NULL), _g_free0 (_tmp3_), _tmp4_); +#line 187 "import.vala" + index = 0; +#line 188 "import.vala" + new_filename = g_strdup (base_filename); +#line 189 "import.vala" + while (TRUE) { +#line 888 "import.c" + char* existing_checksum; + char* _tmp7_; + gboolean _tmp6_; + char* _tmp5_ = NULL; + existing_checksum = NULL; +#line 191 "import.vala" + if ((_tmp6_ = get_file_md5_checksum (new_filename, &_tmp5_), existing_checksum = (_tmp7_ = _tmp5_, _g_free0 (existing_checksum), _tmp7_), _tmp6_)) { +#line 896 "import.c" + char* _tmp10_; + char* _tmp9_; +#line 192 "import.vala" + if (_vala_strcmp0 (checksum, existing_checksum) == 0) { +#line 901 "import.c" + char* _tmp8_; +#line 194 "import.vala" + gee_abstract_list_set (GEE_ABSTRACT_LIST (self->priv->filenames), self->priv->current_file_importing, _tmp8_ = append_extension (new_filename, "mov")); +#line 905 "import.c" + _g_free0 (_tmp8_); +#line 196 "import.vala" + self->priv->current_file_importing--; +#line 197 "import.vala" + self->priv->total_time = self->priv->total_time - model_clip_file_get_length (f->clipfile); +#line 911 "import.c" + _g_free0 (existing_checksum); +#line 198 "import.vala" + break; +#line 915 "import.c" + } +#line 200 "import.vala" + index++; +#line 201 "import.vala" + new_filename = (_tmp10_ = g_strconcat (base_filename, _tmp9_ = g_strdup_printf ("%i", index), NULL), _g_free0 (new_filename), _tmp10_); +#line 921 "import.c" + _g_free0 (_tmp9_); + } else { + ModelFetcher* _tmp11_; +#line 204 "import.vala" + save_file_md5_checksum (new_filename, checksum); +#line 205 "import.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->queued_filenames), new_filename); +#line 206 "import.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->queued_fetchers), (_tmp11_ = f, MODEL_IS_CLIP_FETCHER (_tmp11_) ? ((ModelClipFetcher*) _tmp11_) : NULL)); +#line 931 "import.c" + _g_free0 (existing_checksum); +#line 207 "import.vala" + break; +#line 935 "import.c" + } + _g_free0 (existing_checksum); + } + _g_free0 (base_filename); + _g_free0 (new_filename); + } else { +#line 211 "import.vala" + g_error ("import.vala:211: Cannot get md5 checksum for file %s!", f->clipfile->filename); +#line 944 "import.c" + } + _g_free0 (checksum); + } else { +#line 213 "import.vala" + g_signal_emit_by_name (self, "clip-complete", f->clipfile); +#line 950 "import.c" + } +#line 215 "import.vala" + model_clip_importer_do_import_complete (self, &_inner_error_); +#line 954 "import.c" + if (_inner_error_ != NULL) { + goto __catch7_g_error; + } + } + goto __finally7; + __catch7_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { +#line 217 "import.vala" + g_signal_emit_by_name (self, "error-occurred", e->message); +#line 968 "import.c" + _g_error_free0 (e); + } + } + __finally7: + if (_inner_error_ != NULL) { + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } +} + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 325 "import.vala" +static void _model_clip_importer_on_state_changed_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self) { +#line 988 "import.c" + model_clip_importer_on_state_changed (self, _sender, message); +} + + +#line 369 "import.vala" +static void _model_clip_importer_on_eos_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self) { +#line 995 "import.c" + model_clip_importer_on_eos (self); +} + + +#line 308 "import.vala" +static void _model_clip_importer_on_error_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self) { +#line 1002 "import.c" + model_clip_importer_on_error (self, _sender, message); +} + + +#line 317 "import.vala" +static void _model_clip_importer_on_warning_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self) { +#line 1009 "import.c" + model_clip_importer_on_warning (self, _sender, message); +} + + +static gpointer _gst_object_ref0 (gpointer self) { + return self ? gst_object_ref (self) : NULL; +} + + +#line 285 "import.vala" +static void _model_clip_importer_on_pad_added_gst_element_pad_added (GstElement* _sender, GstPad* pad, gpointer self) { +#line 1021 "import.c" + model_clip_importer_on_pad_added (self, pad); +} + + +#line 221 "import.vala" +static void model_clip_importer_do_import (ModelClipImporter* self, ModelClipFetcher* f, GError** error) { +#line 1028 "import.c" + GError * _inner_error_; + ModelClipFetcher* _tmp0_; + GstPipeline* _tmp1_; + GstBus* bus; + GstElement* _tmp2_; + GstElement* _tmp3_; + GstElement* _tmp4_; + GstElement* _tmp5_; + char* _tmp7_; + char* _tmp6_; + char* _tmp21_; + char* _tmp20_; +#line 221 "import.vala" + g_return_if_fail (MODEL_IS_CLIP_IMPORTER (self)); +#line 221 "import.vala" + g_return_if_fail (MODEL_IS_CLIP_FETCHER (f)); +#line 1045 "import.c" + _inner_error_ = NULL; +#line 222 "import.vala" + g_signal_emit_by_name (MULTI_FILE_PROGRESS_INTERFACE (self), "file-updated", MODEL_FETCHER (f)->clipfile->filename, self->priv->current_file_importing); +#line 223 "import.vala" + self->priv->previous_time = (gint64) 0; +#line 225 "import.vala" + self->priv->our_fetcher = (_tmp0_ = _g_object_ref0 (f), _g_object_unref0 (self->priv->our_fetcher), _tmp0_); +#line 226 "import.vala" + self->priv->import_done = FALSE; +#line 227 "import.vala" + self->priv->pipeline = (_tmp1_ = (GstPipeline*) gst_pipeline_new ("pipeline"), _gst_object_unref0 (self->priv->pipeline), _tmp1_); +#line 228 "import.vala" + gst_pipeline_set_auto_flush_bus (self->priv->pipeline, FALSE); +#line 230 "import.vala" + bus = gst_pipeline_get_bus (self->priv->pipeline); +#line 231 "import.vala" + gst_bus_add_signal_watch (bus); +#line 233 "import.vala" + g_signal_connect_object (bus, "message::state-changed", (GCallback) _model_clip_importer_on_state_changed_gst_bus_message, self, 0); +#line 234 "import.vala" + g_signal_connect_object (bus, "message::eos", (GCallback) _model_clip_importer_on_eos_gst_bus_message, self, 0); +#line 235 "import.vala" + g_signal_connect_object (bus, "message::error", (GCallback) _model_clip_importer_on_error_gst_bus_message, self, 0); +#line 236 "import.vala" + g_signal_connect_object (bus, "message::warning", (GCallback) _model_clip_importer_on_warning_gst_bus_message, self, 0); +#line 238 "import.vala" + _tmp2_ = make_element ("qtmux", &_inner_error_); +#line 1073 "import.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + _gst_object_unref0 (bus); + return; + } +#line 238 "import.vala" + self->priv->mux = (_tmp3_ = _tmp2_, _gst_object_unref0 (self->priv->mux), _tmp3_); +#line 240 "import.vala" + _tmp4_ = make_element ("filesink", &_inner_error_); +#line 1083 "import.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + _gst_object_unref0 (bus); + return; + } +#line 240 "import.vala" + self->priv->filesink = (_tmp5_ = _tmp4_, _gst_object_unref0 (self->priv->filesink), _tmp5_); +#line 241 "import.vala" + g_object_set (G_OBJECT (self->priv->filesink), "location", _tmp7_ = append_extension (_tmp6_ = (char*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->priv->queued_filenames), self->priv->current_file_importing), "mov"), NULL); +#line 1093 "import.c" + _g_free0 (_tmp7_); + _g_free0 (_tmp6_); +#line 243 "import.vala" + gst_bin_add_many (GST_BIN (self->priv->pipeline), _gst_object_ref0 (self->priv->mux), _gst_object_ref0 (self->priv->filesink), NULL); +#line 245 "import.vala" + if (model_clip_file_is_of_type (MODEL_FETCHER (f)->clipfile, MODEL_MEDIA_TYPE_VIDEO)) { +#line 1100 "import.c" + GstElement* _tmp8_; + GstElement* _tmp9_; + GstCaps* _tmp10_; + SingleDecodeBin* _tmp11_; + SingleDecodeBin* _tmp12_; + GstBin* _tmp13_; +#line 246 "import.vala" + _tmp8_ = make_element ("ffmpegcolorspace", &_inner_error_); +#line 1109 "import.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + _gst_object_unref0 (bus); + return; + } +#line 246 "import.vala" + self->priv->video_convert = (_tmp9_ = _tmp8_, _gst_object_unref0 (self->priv->video_convert), _tmp9_); +#line 247 "import.vala" + gst_bin_add (GST_BIN (self->priv->pipeline), _gst_object_ref0 (self->priv->video_convert)); +#line 249 "import.vala" + _tmp12_ = (_tmp11_ = single_decode_bin_new (_tmp10_ = gst_caps_from_string ("video/x-raw-yuv"), "videodecodebin", MODEL_FETCHER (f)->clipfile->filename, &_inner_error_), _gst_caps_unref0 (_tmp10_), _tmp11_); +#line 1121 "import.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + _gst_object_unref0 (bus); + return; + } +#line 249 "import.vala" + self->priv->video_decoder = (_tmp13_ = GST_BIN (_tmp12_), _gst_object_unref0 (self->priv->video_decoder), _tmp13_); +#line 253 "import.vala" + g_signal_connect_object (GST_ELEMENT (self->priv->video_decoder), "pad-added", (GCallback) _model_clip_importer_on_pad_added_gst_element_pad_added, self, 0); +#line 255 "import.vala" + gst_bin_add (GST_BIN (self->priv->pipeline), _gst_object_ref0 (GST_ELEMENT (self->priv->video_decoder))); +#line 257 "import.vala" + if (!gst_element_link (self->priv->video_convert, self->priv->mux)) { +#line 258 "import.vala" + g_error ("import.vala:258: do_import: Cannot link video converter to mux!"); +#line 1137 "import.c" + } + } +#line 260 "import.vala" + if (model_clip_file_is_of_type (MODEL_FETCHER (f)->clipfile, MODEL_MEDIA_TYPE_AUDIO)) { +#line 1142 "import.c" + GstElement* _tmp14_; + GstElement* _tmp15_; + GstCaps* _tmp16_; + SingleDecodeBin* _tmp17_; + SingleDecodeBin* _tmp18_; + GstBin* _tmp19_; +#line 261 "import.vala" + _tmp14_ = make_element ("audioconvert", &_inner_error_); +#line 1151 "import.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + _gst_object_unref0 (bus); + return; + } +#line 261 "import.vala" + self->priv->audio_convert = (_tmp15_ = _tmp14_, _gst_object_unref0 (self->priv->audio_convert), _tmp15_); +#line 262 "import.vala" + gst_bin_add (GST_BIN (self->priv->pipeline), _gst_object_ref0 (self->priv->audio_convert)); +#line 266 "import.vala" + _tmp18_ = (_tmp17_ = single_decode_bin_new (_tmp16_ = gst_caps_from_string ("audio/x-raw-int"), "audiodecodebin", MODEL_FETCHER (f)->clipfile->filename, &_inner_error_), _gst_caps_unref0 (_tmp16_), _tmp17_); +#line 1163 "import.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + _gst_object_unref0 (bus); + return; + } +#line 266 "import.vala" + self->priv->audio_decoder = (_tmp19_ = GST_BIN (_tmp18_), _gst_object_unref0 (self->priv->audio_decoder), _tmp19_); +#line 269 "import.vala" + g_signal_connect_object (GST_ELEMENT (self->priv->audio_decoder), "pad-added", (GCallback) _model_clip_importer_on_pad_added_gst_element_pad_added, self, 0); +#line 271 "import.vala" + gst_bin_add (GST_BIN (self->priv->pipeline), _gst_object_ref0 (GST_ELEMENT (self->priv->audio_decoder))); +#line 273 "import.vala" + if (!gst_element_link (self->priv->audio_convert, self->priv->mux)) { +#line 274 "import.vala" + g_error ("import.vala:274: do_import: Cannot link audio convert to mux!"); +#line 1179 "import.c" + } + } +#line 277 "import.vala" + if (!gst_element_link (self->priv->mux, self->priv->filesink)) { +#line 278 "import.vala" + g_error ("import.vala:278: do_import: Cannot link mux to filesink!"); +#line 1186 "import.c" + } +#line 280 "import.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_IMPORT, LOGGING_LEVEL_VERBOSE, _tmp21_ = g_strdup_printf ("Starting import to %s...", _tmp20_ = (char*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->priv->queued_filenames), self->priv->current_file_importing))); +#line 1190 "import.c" + _g_free0 (_tmp21_); + _g_free0 (_tmp20_); +#line 282 "import.vala" + gst_element_set_state (GST_ELEMENT (self->priv->pipeline), GST_STATE_PLAYING); +#line 1195 "import.c" + _gst_object_unref0 (bus); +} + + +#line 285 "import.vala" +static void model_clip_importer_on_pad_added (ModelClipImporter* self, GstPad* p) { +#line 1202 "import.c" + GstCaps* _tmp1_; + GstCaps* _tmp0_ = NULL; + char* _tmp2_; + char* str; + GstPad* sink; +#line 285 "import.vala" + g_return_if_fail (MODEL_IS_CLIP_IMPORTER (self)); +#line 285 "import.vala" + g_return_if_fail (GST_IS_PAD (p)); +#line 286 "import.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_pad_added"); +#line 288 "import.vala" + str = (_tmp2_ = gst_caps_to_string (_tmp1_ = (g_object_get (p, "caps", &_tmp0_, NULL), _tmp0_)), _gst_caps_unref0 (_tmp1_), _tmp2_); +#line 289 "import.vala" + sink = NULL; +#line 291 "import.vala" + if (g_str_has_prefix (str, "video")) { +#line 1220 "import.c" + GstPad* _tmp3_; + GstPad* _tmp6_; + GstCaps* _tmp5_; + GstCaps* _tmp4_ = NULL; +#line 292 "import.vala" + self->priv->video_pad = (_tmp3_ = _gst_object_ref0 (p), _gst_object_unref0 (self->priv->video_pad), _tmp3_); +#line 293 "import.vala" + sink = (_tmp6_ = gst_element_get_compatible_pad (self->priv->video_convert, p, _tmp5_ = (g_object_get (p, "caps", &_tmp4_, NULL), _tmp4_)), _gst_object_unref0 (sink), _tmp6_); +#line 1229 "import.c" + _gst_caps_unref0 (_tmp5_); + } else { +#line 294 "import.vala" + if (g_str_has_prefix (str, "audio")) { +#line 1234 "import.c" + GstPad* _tmp7_; + GstPad* _tmp10_; + GstCaps* _tmp9_; + GstCaps* _tmp8_ = NULL; +#line 295 "import.vala" + self->priv->audio_pad = (_tmp7_ = _gst_object_ref0 (p), _gst_object_unref0 (self->priv->audio_pad), _tmp7_); +#line 296 "import.vala" + sink = (_tmp10_ = gst_element_get_compatible_pad (self->priv->audio_convert, p, _tmp9_ = (g_object_get (p, "caps", &_tmp8_, NULL), _tmp8_)), _gst_object_unref0 (sink), _tmp10_); +#line 1243 "import.c" + _gst_caps_unref0 (_tmp9_); + } else { + char* _tmp11_; +#line 299 "import.vala" + g_warning ("import.vala:299: %s", _tmp11_ = g_strdup_printf ("Unrecognized prefix %s", str)); +#line 1249 "import.c" + _g_free0 (_tmp11_); + _g_free0 (str); + _gst_object_unref0 (sink); +#line 300 "import.vala" + return; +#line 1255 "import.c" + } + } +#line 303 "import.vala" + if (gst_pad_link (p, sink) != GST_PAD_LINK_OK) { +#line 304 "import.vala" + g_error ("import.vala:304: Cannot link pad in importer!"); +#line 1262 "import.c" + } + _g_free0 (str); + _gst_object_unref0 (sink); +} + + +#line 308 "import.vala" +static void model_clip_importer_on_error (ModelClipImporter* self, GstBus* bus, GstMessage* message) { +#line 1271 "import.c" + GError* e; + char* text; + char* _tmp3_; + char* _tmp2_ = NULL; + GError* _tmp1_; + GError* _tmp0_ = NULL; +#line 308 "import.vala" + g_return_if_fail (MODEL_IS_CLIP_IMPORTER (self)); +#line 308 "import.vala" + g_return_if_fail (GST_IS_BUS (bus)); +#line 308 "import.vala" + g_return_if_fail (GST_IS_MESSAGE (message)); +#line 309 "import.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_error"); +#line 1286 "import.c" + e = NULL; + text = NULL; +#line 312 "import.vala" + (gst_message_parse_error (message, &_tmp0_, &_tmp2_), e = (_tmp1_ = _tmp0_, _g_error_free0 (e), _tmp1_)); +#line 312 "import.vala" + text = (_tmp3_ = _tmp2_, _g_free0 (text), _tmp3_); +#line 313 "import.vala" + g_warning ("import.vala:313: %s\n", text); +#line 314 "import.vala" + g_signal_emit_by_name (self, "error-occurred", text); +#line 1297 "import.c" + _g_error_free0 (e); + _g_free0 (text); +} + + +#line 317 "import.vala" +static void model_clip_importer_on_warning (ModelClipImporter* self, GstBus* bus, GstMessage* message) { +#line 1305 "import.c" + GError* e; + char* text; + char* _tmp3_; + char* _tmp2_ = NULL; + GError* _tmp1_; + GError* _tmp0_ = NULL; +#line 317 "import.vala" + g_return_if_fail (MODEL_IS_CLIP_IMPORTER (self)); +#line 317 "import.vala" + g_return_if_fail (GST_IS_BUS (bus)); +#line 317 "import.vala" + g_return_if_fail (GST_IS_MESSAGE (message)); +#line 318 "import.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_warning"); +#line 1320 "import.c" + e = NULL; + text = NULL; +#line 321 "import.vala" + (gst_message_parse_warning (message, &_tmp0_, &_tmp2_), e = (_tmp1_ = _tmp0_, _g_error_free0 (e), _tmp1_)); +#line 321 "import.vala" + text = (_tmp3_ = _tmp2_, _g_free0 (text), _tmp3_); +#line 322 "import.vala" + g_warning ("import.vala:322: %s", text); +#line 1329 "import.c" + _g_error_free0 (e); + _g_free0 (text); +} + + +#line 325 "import.vala" +static void model_clip_importer_on_state_changed (ModelClipImporter* self, GstBus* b, GstMessage* m) { +#line 1337 "import.c" + GError * _inner_error_; + GstState old_state = 0; + GstState new_state = 0; + GstState pending = 0; + char* _tmp0_; +#line 325 "import.vala" + g_return_if_fail (MODEL_IS_CLIP_IMPORTER (self)); +#line 325 "import.vala" + g_return_if_fail (GST_IS_BUS (b)); +#line 325 "import.vala" + g_return_if_fail (GST_IS_MESSAGE (m)); +#line 1349 "import.c" + _inner_error_ = NULL; +#line 326 "import.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_state_changed"); +#line 327 "import.vala" + if (m->src != GST_OBJECT (self->priv->pipeline)) { +#line 328 "import.vala" + return; +#line 1357 "import.c" + } +#line 334 "import.vala" + gst_message_parse_state_changed (m, &old_state, &new_state, &pending); +#line 336 "import.vala" + if (old_state == new_state) { +#line 337 "import.vala" + return; +#line 1365 "import.c" + } +#line 339 "import.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_IMPORT, LOGGING_LEVEL_VERBOSE, _tmp0_ = g_strdup_printf ("Import State in %s", gst_element_state_get_name (new_state))); +#line 1369 "import.c" + _g_free0 (_tmp0_); +#line 341 "import.vala" + if (new_state == GST_STATE_PAUSED) { +#line 342 "import.vala" + if (!self->priv->import_done) { +#line 1375 "import.c" + char* _tmp7_; +#line 343 "import.vala" + if (self->priv->video_pad != NULL) { +#line 1379 "import.c" + GstCaps* _tmp3_; + GstCaps* *_tmp2_; + GstCaps* _tmp1_ = NULL; +#line 344 "import.vala" + _tmp2_ = &MODEL_FETCHER (self->priv->our_fetcher)->clipfile->video_caps; +#line 344 "import.vala" + (*_tmp2_) = (_tmp3_ = (g_object_get (self->priv->video_pad, "caps", &_tmp1_, NULL), _tmp1_), _gst_caps_unref0 ((*_tmp2_)), _tmp3_); +#line 1387 "import.c" + } +#line 346 "import.vala" + if (self->priv->audio_pad != NULL) { +#line 1391 "import.c" + GstCaps* _tmp6_; + GstCaps* *_tmp5_; + GstCaps* _tmp4_ = NULL; +#line 347 "import.vala" + _tmp5_ = &MODEL_FETCHER (self->priv->our_fetcher)->clipfile->audio_caps; +#line 347 "import.vala" + (*_tmp5_) = (_tmp6_ = (g_object_get (self->priv->audio_pad, "caps", &_tmp4_, NULL), _tmp4_), _gst_caps_unref0 ((*_tmp5_)), _tmp6_); +#line 1399 "import.c" + } +#line 349 "import.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_IMPORT, LOGGING_LEVEL_VERBOSE, _tmp7_ = g_strdup_printf ("Got clipfile info for: %s", MODEL_FETCHER (self->priv->our_fetcher)->clipfile->filename)); +#line 1403 "import.c" + _g_free0 (_tmp7_); + } + } else { +#line 352 "import.vala" + if (new_state == GST_STATE_NULL) { +#line 353 "import.vala" + if (self->priv->import_state == MODEL_CLIP_IMPORTER_IMPORT_STATE_CANCELLED) { +#line 1411 "import.c" + char* _tmp9_; + char* _tmp8_; + char* _tmp11_; + char* _tmp10_; +#line 354 "import.vala" + g_remove (_tmp9_ = append_extension (_tmp8_ = (char*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->priv->queued_filenames), self->priv->current_file_importing), "mov")); +#line 1418 "import.c" + _g_free0 (_tmp9_); + _g_free0 (_tmp8_); +#line 356 "import.vala" + g_remove (_tmp11_ = append_extension (_tmp10_ = (char*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->priv->queued_filenames), self->priv->current_file_importing), "md5")); +#line 1423 "import.c" + _g_free0 (_tmp11_); + _g_free0 (_tmp10_); + } else { +#line 359 "import.vala" + if (self->priv->import_done) { +#line 1429 "import.c" + { +#line 361 "import.vala" + model_clip_importer_do_import_complete (self, &_inner_error_); +#line 1433 "import.c" + if (_inner_error_ != NULL) { + goto __catch8_g_error; + } + } + goto __finally8; + __catch8_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { +#line 363 "import.vala" + g_signal_emit_by_name (self, "error-occurred", e->message); +#line 1447 "import.c" + _g_error_free0 (e); + } + } + __finally8: + if (_inner_error_ != NULL) { + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } + } + } + } + } +} + + +#line 369 "import.vala" +static void model_clip_importer_on_eos (ModelClipImporter* self) { +#line 369 "import.vala" + g_return_if_fail (MODEL_IS_CLIP_IMPORTER (self)); +#line 370 "import.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_eos"); +#line 371 "import.vala" + self->priv->import_done = TRUE; +#line 372 "import.vala" + gst_element_set_state (GST_ELEMENT (self->priv->pipeline), GST_STATE_NULL); +#line 1474 "import.c" +} + + +static void model_clip_importer_class_init (ModelClipImporterClass * klass) { + model_clip_importer_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ModelClipImporterPrivate)); + G_OBJECT_CLASS (klass)->finalize = model_clip_importer_finalize; + g_signal_new ("clip_complete", MODEL_TYPE_CLIP_IMPORTER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_CLIP_FILE); + g_signal_new ("importing_started", MODEL_TYPE_CLIP_IMPORTER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT); + g_signal_new ("error_occurred", MODEL_TYPE_CLIP_IMPORTER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING); +} + + +static void model_clip_importer_multi_file_progress_interface_interface_init (MultiFileProgressInterfaceIface * iface) { + model_clip_importer_multi_file_progress_interface_parent_iface = g_type_interface_peek_parent (iface); + iface->cancel = model_clip_importer_real_cancel; + iface->complete = model_clip_importer_real_complete; +} + + +static void model_clip_importer_instance_init (ModelClipImporter * self) { + self->priv = MODEL_CLIP_IMPORTER_GET_PRIVATE (self); + self->priv->pipeline = NULL; + self->priv->current_file_importing = 0; + self->priv->filenames = gee_array_list_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL); + self->priv->queued_fetchers = gee_array_list_new (MODEL_TYPE_CLIP_FETCHER, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL); + self->priv->queued_filenames = gee_array_list_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL); + self->priv->no_import_formats = gee_array_list_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL); +} + + +static void model_clip_importer_finalize (GObject* obj) { + ModelClipImporter * self; + self = MODEL_CLIP_IMPORTER (obj); + _g_free0 (self->priv->import_directory); + _g_object_unref0 (self->priv->our_fetcher); + _gst_object_unref0 (self->priv->video_pad); + _gst_object_unref0 (self->priv->audio_pad); + _gst_object_unref0 (self->priv->pipeline); + _gst_object_unref0 (self->priv->filesink); + _gst_object_unref0 (self->priv->video_convert); + _gst_object_unref0 (self->priv->audio_convert); + _gst_object_unref0 (self->priv->mux); + _gst_object_unref0 (self->priv->video_decoder); + _gst_object_unref0 (self->priv->audio_decoder); + _g_object_unref0 (self->priv->filenames); + _g_object_unref0 (self->priv->queued_fetchers); + _g_object_unref0 (self->priv->queued_filenames); + _g_object_unref0 (self->priv->no_import_formats); + G_OBJECT_CLASS (model_clip_importer_parent_class)->finalize (obj); +} + + +GType model_clip_importer_get_type (void) { + static volatile gsize model_clip_importer_type_id__volatile = 0; + if (g_once_init_enter (&model_clip_importer_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelClipImporterClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_clip_importer_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelClipImporter), 0, (GInstanceInitFunc) model_clip_importer_instance_init, NULL }; + static const GInterfaceInfo multi_file_progress_interface_info = { (GInterfaceInitFunc) model_clip_importer_multi_file_progress_interface_interface_init, (GInterfaceFinalizeFunc) NULL, NULL}; + GType model_clip_importer_type_id; + model_clip_importer_type_id = g_type_register_static (G_TYPE_OBJECT, "ModelClipImporter", &g_define_type_info, 0); + g_type_add_interface_static (model_clip_importer_type_id, TYPE_MULTI_FILE_PROGRESS_INTERFACE, &multi_file_progress_interface_info); + g_once_init_leave (&model_clip_importer_type_id__volatile, model_clip_importer_type_id); + } + return model_clip_importer_type_id__volatile; +} + + +#line 406 "import.vala" +static void _model_library_importer_on_clip_complete_model_clip_importer_clip_complete (ModelClipImporter* _sender, ModelClipFile* f, gpointer self) { +#line 1544 "import.c" + model_library_importer_on_clip_complete (self, f); +} + + +#line 396 "import.vala" +static void _model_library_importer_on_error_occurred_model_clip_importer_error_occurred (ModelClipImporter* _sender, const char* _error_, gpointer self) { +#line 1551 "import.c" + model_library_importer_on_error_occurred (self, _error_); +} + + +#line 391 "import.vala" +static void _model_library_importer_on_importer_started_model_clip_importer_importing_started (ModelClipImporter* _sender, gint num_clips, gpointer self) { +#line 1558 "import.c" + model_library_importer_on_importer_started (self, _sender, num_clips); +} + + +#line 382 "import.vala" +ModelLibraryImporter* model_library_importer_construct (GType object_type, ModelProject* p) { +#line 1565 "import.c" + ModelLibraryImporter * self; + ModelProject* _tmp0_; + ModelClipImporter* _tmp1_; +#line 382 "import.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (p), NULL); +#line 382 "import.vala" + self = (ModelLibraryImporter*) g_object_new (object_type, NULL); +#line 383 "import.vala" + self->project = (_tmp0_ = _g_object_ref0 (p), _g_object_unref0 (self->project), _tmp0_); +#line 385 "import.vala" + self->importer = (_tmp1_ = model_clip_importer_new (), _g_object_unref0 (self->importer), _tmp1_); +#line 386 "import.vala" + g_signal_connect_object (self->importer, "clip-complete", (GCallback) _model_library_importer_on_clip_complete_model_clip_importer_clip_complete, self, 0); +#line 387 "import.vala" + g_signal_connect_object (self->importer, "error-occurred", (GCallback) _model_library_importer_on_error_occurred_model_clip_importer_error_occurred, self, 0); +#line 388 "import.vala" + g_signal_connect_object (self->importer, "importing-started", (GCallback) _model_library_importer_on_importer_started_model_clip_importer_importing_started, self, 0); +#line 1583 "import.c" + return self; +} + + +#line 382 "import.vala" +ModelLibraryImporter* model_library_importer_new (ModelProject* p) { +#line 382 "import.vala" + return model_library_importer_construct (MODEL_TYPE_LIBRARY_IMPORTER, p); +#line 1592 "import.c" +} + + +#line 391 "import.vala" +static void model_library_importer_on_importer_started (ModelLibraryImporter* self, ModelClipImporter* i, gint num) { +#line 391 "import.vala" + g_return_if_fail (MODEL_IS_LIBRARY_IMPORTER (self)); +#line 391 "import.vala" + g_return_if_fail (MODEL_IS_CLIP_IMPORTER (i)); +#line 392 "import.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_importer_started"); +#line 393 "import.vala" + g_signal_emit_by_name (self, "started", i, num); +#line 1606 "import.c" +} + + +#line 396 "import.vala" +static void model_library_importer_on_error_occurred (ModelLibraryImporter* self, const char* _error_) { +#line 396 "import.vala" + g_return_if_fail (MODEL_IS_LIBRARY_IMPORTER (self)); +#line 396 "import.vala" + g_return_if_fail (_error_ != NULL); +#line 397 "import.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_error_occurred"); +#line 398 "import.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_DEVELOPER_WARNINGS, LOGGING_LEVEL_INFO, _error_); +#line 399 "import.vala" + g_signal_emit_by_name (self->project, "error-occurred", "Error importing", "An error occurred importing this file."); +#line 1622 "import.c" +} + + +#line 402 "import.vala" +static void model_library_importer_real_append_existing_clipfile (ModelLibraryImporter* self, ModelClipFile* f) { +#line 402 "import.vala" + g_return_if_fail (MODEL_IS_LIBRARY_IMPORTER (self)); +#line 402 "import.vala" + g_return_if_fail (MODEL_IS_CLIP_FILE (f)); +#line 1632 "import.c" +} + + +#line 402 "import.vala" +void model_library_importer_append_existing_clipfile (ModelLibraryImporter* self, ModelClipFile* f) { +#line 402 "import.vala" + MODEL_LIBRARY_IMPORTER_GET_CLASS (self)->append_existing_clipfile (self, f); +#line 1640 "import.c" +} + + +#line 406 "import.vala" +static void model_library_importer_real_on_clip_complete (ModelLibraryImporter* self, ModelClipFile* f) { +#line 1646 "import.c" + ModelClipFile* cf; +#line 406 "import.vala" + g_return_if_fail (MODEL_IS_LIBRARY_IMPORTER (self)); +#line 406 "import.vala" + g_return_if_fail (MODEL_IS_CLIP_FILE (f)); +#line 407 "import.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_complete"); +#line 408 "import.vala" + cf = model_project_find_clipfile (self->project, f->filename); +#line 409 "import.vala" + if (cf == NULL) { +#line 410 "import.vala" + model_project_add_clipfile (self->project, f); +#line 1660 "import.c" + } + _g_object_unref0 (cf); +} + + +#line 406 "import.vala" +void model_library_importer_on_clip_complete (ModelLibraryImporter* self, ModelClipFile* f) { +#line 406 "import.vala" + MODEL_LIBRARY_IMPORTER_GET_CLASS (self)->on_clip_complete (self, f); +#line 1670 "import.c" +} + + +#line 414 "import.vala" +void model_library_importer_add_file (ModelLibraryImporter* self, const char* filename, GError** error) { +#line 1676 "import.c" + ModelClipFile* cf; +#line 414 "import.vala" + g_return_if_fail (MODEL_IS_LIBRARY_IMPORTER (self)); +#line 414 "import.vala" + g_return_if_fail (filename != NULL); +#line 415 "import.vala" + cf = model_project_find_clipfile (self->project, filename); +#line 417 "import.vala" + if (cf != NULL) { +#line 418 "import.vala" + model_library_importer_append_existing_clipfile (self, cf); +#line 1688 "import.c" + } else { +#line 420 "import.vala" + model_clip_importer_add_filename (self->importer, filename); +#line 1692 "import.c" + } + _g_object_unref0 (cf); +} + + +#line 423 "import.vala" +void model_library_importer_start (ModelLibraryImporter* self, GError** error) { +#line 1700 "import.c" + GError * _inner_error_; +#line 423 "import.vala" + g_return_if_fail (MODEL_IS_LIBRARY_IMPORTER (self)); +#line 1704 "import.c" + _inner_error_ = NULL; +#line 424 "import.vala" + model_clip_importer_start (self->importer, &_inner_error_); +#line 1708 "import.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + return; + } +} + + +static void model_library_importer_class_init (ModelLibraryImporterClass * klass) { + model_library_importer_parent_class = g_type_class_peek_parent (klass); + MODEL_LIBRARY_IMPORTER_CLASS (klass)->append_existing_clipfile = model_library_importer_real_append_existing_clipfile; + MODEL_LIBRARY_IMPORTER_CLASS (klass)->on_clip_complete = model_library_importer_real_on_clip_complete; + G_OBJECT_CLASS (klass)->finalize = model_library_importer_finalize; + g_signal_new ("started", MODEL_TYPE_LIBRARY_IMPORTER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__OBJECT_INT, G_TYPE_NONE, 2, MODEL_TYPE_CLIP_IMPORTER, G_TYPE_INT); +} + + +static void model_library_importer_instance_init (ModelLibraryImporter * self) { +} + + +static void model_library_importer_finalize (GObject* obj) { + ModelLibraryImporter * self; + self = MODEL_LIBRARY_IMPORTER (obj); + _g_object_unref0 (self->project); + _g_object_unref0 (self->importer); + G_OBJECT_CLASS (model_library_importer_parent_class)->finalize (obj); +} + + +GType model_library_importer_get_type (void) { + static volatile gsize model_library_importer_type_id__volatile = 0; + if (g_once_init_enter (&model_library_importer_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelLibraryImporterClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_library_importer_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelLibraryImporter), 0, (GInstanceInitFunc) model_library_importer_instance_init, NULL }; + GType model_library_importer_type_id; + model_library_importer_type_id = g_type_register_static (G_TYPE_OBJECT, "ModelLibraryImporter", &g_define_type_info, 0); + g_once_init_leave (&model_library_importer_type_id__volatile, model_library_importer_type_id); + } + return model_library_importer_type_id__volatile; +} + + +#line 433 "import.vala" +ModelTimelineImporter* model_timeline_importer_construct (GType object_type, ModelTrack* track, ModelProject* p, gint64 time_to_add, gboolean both_tracks) { +#line 1752 "import.c" + ModelTimelineImporter * self; + ModelTrack* _tmp0_; +#line 433 "import.vala" + g_return_val_if_fail (MODEL_IS_TRACK (track), NULL); +#line 433 "import.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (p), NULL); +#line 434 "import.vala" + self = (ModelTimelineImporter*) model_library_importer_construct (object_type, p); +#line 435 "import.vala" + self->priv->track = (_tmp0_ = _g_object_ref0 (track), _g_object_unref0 (self->priv->track), _tmp0_); +#line 436 "import.vala" + self->priv->time_to_add = time_to_add; +#line 437 "import.vala" + self->priv->both_tracks = both_tracks; +#line 1767 "import.c" + return self; +} + + +#line 433 "import.vala" +ModelTimelineImporter* model_timeline_importer_new (ModelTrack* track, ModelProject* p, gint64 time_to_add, gboolean both_tracks) { +#line 433 "import.vala" + return model_timeline_importer_construct (MODEL_TYPE_TIMELINE_IMPORTER, track, p, time_to_add, both_tracks); +#line 1776 "import.c" +} + + +#line 440 "import.vala" +static void model_timeline_importer_add_to_both (ModelTimelineImporter* self, ModelClipFile* clip_file) { +#line 440 "import.vala" + g_return_if_fail (MODEL_IS_TIMELINE_IMPORTER (self)); +#line 440 "import.vala" + g_return_if_fail (MODEL_IS_CLIP_FILE (clip_file)); +#line 441 "import.vala" + if (self->priv->both_tracks) { +#line 1788 "import.c" + ModelTrack* other_track; + other_track = NULL; +#line 443 "import.vala" + if (MODEL_IS_VIDEO_TRACK (self->priv->track)) { +#line 1793 "import.c" + ModelTrack* _tmp0_; +#line 444 "import.vala" + other_track = (_tmp0_ = MODEL_TRACK (model_project_find_audio_track (MODEL_LIBRARY_IMPORTER (self)->project)), _g_object_unref0 (other_track), _tmp0_); +#line 1797 "import.c" + } else { + ModelTrack* _tmp1_; +#line 446 "import.vala" + other_track = (_tmp1_ = MODEL_TRACK (model_project_find_video_track (MODEL_LIBRARY_IMPORTER (self)->project)), _g_object_unref0 (other_track), _tmp1_); +#line 1802 "import.c" + } +#line 448 "import.vala" + if (other_track != NULL) { +#line 449 "import.vala" + model_project_add (MODEL_LIBRARY_IMPORTER (self)->project, other_track, clip_file, self->priv->time_to_add); +#line 1808 "import.c" + } + _g_object_unref0 (other_track); + } +} + + +#line 454 "import.vala" +static void model_timeline_importer_real_append_existing_clipfile (ModelLibraryImporter* base, ModelClipFile* f) { +#line 1817 "import.c" + ModelTimelineImporter * self; + self = MODEL_TIMELINE_IMPORTER (base); +#line 454 "import.vala" + g_return_if_fail (MODEL_IS_CLIP_FILE (f)); +#line 455 "import.vala" + model_undo_manager_start_transaction (MODEL_LIBRARY_IMPORTER (self)->project->undo_manager, "Create Clip"); +#line 456 "import.vala" + model_project_add (MODEL_LIBRARY_IMPORTER (self)->project, self->priv->track, f, self->priv->time_to_add); +#line 457 "import.vala" + model_timeline_importer_add_to_both (self, f); +#line 458 "import.vala" + model_undo_manager_end_transaction (MODEL_LIBRARY_IMPORTER (self)->project->undo_manager, "Create Clip"); +#line 1830 "import.c" +} + + +#line 461 "import.vala" +static void model_timeline_importer_real_on_clip_complete (ModelLibraryImporter* base, ModelClipFile* f) { +#line 1836 "import.c" + ModelTimelineImporter * self; + self = MODEL_TIMELINE_IMPORTER (base); +#line 461 "import.vala" + g_return_if_fail (MODEL_IS_CLIP_FILE (f)); +#line 462 "import.vala" + model_undo_manager_start_transaction (MODEL_LIBRARY_IMPORTER (self)->project->undo_manager, "Create Clip"); +#line 463 "import.vala" + MODEL_LIBRARY_IMPORTER_CLASS (model_timeline_importer_parent_class)->on_clip_complete (MODEL_LIBRARY_IMPORTER (self), f); +#line 464 "import.vala" + model_project_add (MODEL_LIBRARY_IMPORTER (self)->project, self->priv->track, f, self->priv->time_to_add); +#line 465 "import.vala" + model_timeline_importer_add_to_both (self, f); +#line 466 "import.vala" + model_undo_manager_end_transaction (MODEL_LIBRARY_IMPORTER (self)->project->undo_manager, "Create Clip"); +#line 1851 "import.c" +} + + +static void model_timeline_importer_class_init (ModelTimelineImporterClass * klass) { + model_timeline_importer_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ModelTimelineImporterPrivate)); + MODEL_LIBRARY_IMPORTER_CLASS (klass)->append_existing_clipfile = model_timeline_importer_real_append_existing_clipfile; + MODEL_LIBRARY_IMPORTER_CLASS (klass)->on_clip_complete = model_timeline_importer_real_on_clip_complete; + G_OBJECT_CLASS (klass)->finalize = model_timeline_importer_finalize; +} + + +static void model_timeline_importer_instance_init (ModelTimelineImporter * self) { + self->priv = MODEL_TIMELINE_IMPORTER_GET_PRIVATE (self); +} + + +static void model_timeline_importer_finalize (GObject* obj) { + ModelTimelineImporter * self; + self = MODEL_TIMELINE_IMPORTER (obj); + _g_object_unref0 (self->priv->track); + G_OBJECT_CLASS (model_timeline_importer_parent_class)->finalize (obj); +} + + +GType model_timeline_importer_get_type (void) { + static volatile gsize model_timeline_importer_type_id__volatile = 0; + if (g_once_init_enter (&model_timeline_importer_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelTimelineImporterClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_timeline_importer_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelTimelineImporter), 0, (GInstanceInitFunc) model_timeline_importer_instance_init, NULL }; + GType model_timeline_importer_type_id; + model_timeline_importer_type_id = g_type_register_static (MODEL_TYPE_LIBRARY_IMPORTER, "ModelTimelineImporter", &g_define_type_info, 0); + g_once_init_leave (&model_timeline_importer_type_id__volatile, model_timeline_importer_type_id); + } + return model_timeline_importer_type_id__volatile; +} + + +static int _vala_strcmp0 (const char * str1, const char * str2) { + if (str1 == NULL) { + return -(str1 != str2); + } + if (str2 == NULL) { + return str1 != str2; + } + return strcmp (str1, str2); +} + + + +static void g_cclosure_user_marshal_VOID__OBJECT_INT (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) { + typedef void (*GMarshalFunc_VOID__OBJECT_INT) (gpointer data1, gpointer arg_1, gint arg_2, gpointer data2); + register GMarshalFunc_VOID__OBJECT_INT callback; + register GCClosure * cc; + register gpointer data1, data2; + cc = (GCClosure *) closure; + g_return_if_fail (n_param_values == 3); + if (G_CCLOSURE_SWAP_DATA (closure)) { + data1 = closure->data; + data2 = param_values->data[0].v_pointer; + } else { + data1 = param_values->data[0].v_pointer; + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__OBJECT_INT) (marshal_data ? marshal_data : cc->callback); + callback (data1, g_value_get_object (param_values + 1), g_value_get_int (param_values + 2), data2); +} + + + diff --git a/src/marina/marina/import.o b/src/marina/marina/import.o new file mode 100644 index 0000000..1909cb4 Binary files /dev/null and b/src/marina/marina/import.o differ diff --git a/src/marina/marina/marina.vapi b/src/marina/marina/marina.vapi new file mode 100644 index 0000000..da6402c --- /dev/null +++ b/src/marina/marina/marina.vapi @@ -0,0 +1,1033 @@ +/* marina.vapi generated by valac, do not modify. */ + +[CCode (cprefix = "View", lower_case_cprefix = "view_")] +namespace View { + [CCode (cheader_filename = "marina.h")] + public class AudioMeter : Gtk.DrawingArea { + public AudioMeter (Model.AudioTrack track); + public void on_channel_count_changed (int number_of_channels); + public bool on_expose_event (Gdk.EventExpose event); + public void on_level_changed (double level_left, double level_right); + } + [CCode (cheader_filename = "marina.h")] + public class AudioOutput : View.MediaConnector { + public AudioOutput (Gst.Caps caps) throws GLib.Error; + public override void connect (View.MediaEngine media_engine, Gst.Pipeline pipeline, Gst.Element[] elements); + public override void do_disconnect (View.MediaEngine media_engine, Gst.Pipeline pipeline, Gst.Element[] elements); + } + [CCode (cheader_filename = "marina.h")] + public class ClickTrack : GLib.Object { + public ClickTrack (View.MediaEngine engine, Model.Project project) throws GLib.Error; + } + [CCode (cheader_filename = "marina.h")] + public class MediaAudioTrack : View.MediaTrack { + public MediaAudioTrack (View.MediaEngine media_engine, Model.AudioTrack track) throws GLib.Error; + protected override Gst.Element empty_element () throws GLib.Error; + public override Gst.Element? get_element (); + public override void unlink_pad (Gst.Pad pad, Gst.Element track_element); + public signal void level_changed (double level_left, double level_right); + } + [CCode (cheader_filename = "marina.h")] + public abstract class MediaConnector : GLib.Object { + [CCode (cprefix = "VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_", cheader_filename = "marina.h")] + public enum MediaTypes { + Audio, + Video + } + protected int AudioIndex; + protected int VideoIndex; + protected MediaConnector (View.MediaConnector.MediaTypes media_types); + public abstract void connect (View.MediaEngine media_engine, Gst.Pipeline pipeline, Gst.Element[] elements); + public abstract void do_disconnect (View.MediaEngine media_engine, Gst.Pipeline pipeline, Gst.Element[] elements); + protected bool has_audio (); + protected bool has_video (); + } + [CCode (cheader_filename = "marina.h")] + public class MediaEngine : MultiFileProgressInterface, GLib.Object { + public Gst.Element adder; + public Gst.Element converter; + protected Gst.State gst_state; + public Gst.Pipeline pipeline; + protected PlayState play_state; + public bool playing; + public int64 position; + public Gst.Bin record_bin; + public Model.Clip record_region; + public Model.AudioTrack record_track; + public MediaEngine (Model.Project project, bool include_video) throws GLib.Error; + protected Gst.Caps build_audio_caps (int num_channels); + public static void can_run () throws GLib.Error; + public void close (); + public void connect_output (View.MediaConnector connector); + public void disconnect_output (View.MediaConnector connector); + protected virtual void do_null_state_export (int64 length); + public void do_play (PlayState new_state); + protected bool do_state_change (); + public Gst.Element get_audio_silence () throws GLib.Error; + public PlayState get_play_state (); + public Gst.Caps get_project_audio_caps (); + public Gst.Caps get_project_audio_export_caps (); + protected Gst.Caps get_record_audio_caps (); + public int get_sample_depth (); + public int get_sample_rate (); + public int get_sample_width (); + public void go (int64 pos); + public void on_callback_pulse (); + public void on_load_complete (); + public void on_track_added (Model.Track track); + public virtual void pause (); + public void post_record (); + public void record (Model.AudioTrack track); + public void set_gst_state (Gst.State state); + public void set_play_state (PlayState play_state); + public void start_export (string filename); + public void start_record (Model.Clip region) throws GLib.Error; + public signal void callback_pulse (); + public signal void error_occurred (string major_message, string? minor_message); + public signal void level_changed (Gst.Object source, double level_left, double level_right); + public signal void link_for_export (Gst.Element mux); + public signal void link_for_playback (Gst.Element mux); + public signal void playstate_changed (); + public signal void position_changed (int64 position); + public signal void post_export (bool canceled); + public signal void pre_export (int64 length); + public signal void prepare_window (); + public signal void record_completed (); + } + [CCode (cheader_filename = "marina.h")] + public abstract class MediaTrack : GLib.Object { + protected Gst.Bin composition; + protected Gst.Element default_source; + protected weak View.MediaEngine media_engine; + protected Gst.Element sink; + public MediaTrack (View.MediaEngine media_engine, Model.Track track) throws GLib.Error; + protected abstract Gst.Element empty_element () throws GLib.Error; + public abstract Gst.Element? get_element (); + public abstract void link_new_pad (Gst.Pad pad, Gst.Element track_element); + public abstract void unlink_pad (Gst.Pad pad, Gst.Element track_element); + public signal void error_occurred (string major_message, string? minor_message); + public signal void track_removed (View.MediaTrack track); + } + [CCode (cheader_filename = "marina.h")] + public class MediaVideoTrack : View.MediaTrack { + public MediaVideoTrack (View.MediaEngine media_engine, Model.Track track, Gst.Element converter) throws GLib.Error; + protected override Gst.Element empty_element () throws GLib.Error; + public override Gst.Element? get_element (); + public override void link_new_pad (Gst.Pad pad, Gst.Element track_element); + public override void unlink_pad (Gst.Pad pad, Gst.Element track_element); + } + [CCode (cheader_filename = "marina.h")] + public class OggVorbisExport : View.MediaConnector { + public OggVorbisExport (View.MediaConnector.MediaTypes media_types, string filename, Gst.Caps caps) throws GLib.Error; + public override void connect (View.MediaEngine media_engine, Gst.Pipeline pipeline, Gst.Element[] elements); + public override void do_disconnect (View.MediaEngine media_engine, Gst.Pipeline pipeline, Gst.Element[] elements); + public string get_filename (); + } + [CCode (cheader_filename = "marina.h")] + public class Ruler : Gtk.DrawingArea { + public Ruler (Model.TimeSystem provider, int height); + public override bool button_press_event (Gdk.EventButton event); + public override bool expose_event (Gdk.EventExpose event); + public override bool motion_notify_event (Gdk.EventMotion event); + public signal void position_changed (int x); + } + [CCode (cheader_filename = "marina.h")] + public class StatusBar : Gtk.DrawingArea { + public StatusBar (Model.Project p, Model.TimeSystem provider, int height); + public override bool expose_event (Gdk.EventExpose e); + public void on_position_changed (int64 new_position); + } + [CCode (cheader_filename = "marina.h")] + public class VideoOutput : View.MediaConnector { + public VideoOutput (Gtk.Widget output_widget) throws GLib.Error; + public override void connect (View.MediaEngine media_engine, Gst.Pipeline pipeline, Gst.Element[] elements); + public override void do_disconnect (View.MediaEngine media_engine, Gst.Pipeline pipeline, Gst.Element[] elements); + } +} +[CCode (cprefix = "Model", lower_case_cprefix = "model_")] +namespace Model { + [CCode (cheader_filename = "marina.h")] + public class AddClipCommand : Model.Command { + public AddClipCommand (Model.Project project, Model.ClipFile clip_file); + public override void apply (); + public override string description (); + public override bool merge (Model.Command command); + public override void undo (); + } + [CCode (cheader_filename = "marina.h")] + public class AudioTrack : Model.Track { + public const int INVALID_CHANNEL_COUNT; + public AudioTrack (Model.Project project, string display_name); + public void _set_pan (double new_value); + public void _set_volume (double new_volume); + public override bool check (Model.Clip clip); + public bool get_num_channels (out int num); + public double get_pan (); + public double get_volume (); + public override Model.MediaType media_type (); + protected override string name (); + public override void on_clip_updated (Model.Clip clip); + public void on_level_changed (double level_left, double level_right); + public void set_default_num_channels (int num); + public void set_pan (double new_value); + public void set_volume (double new_volume); + public override void write_attributes (GLib.FileStream f); + public signal void channel_count_changed (int channel_count); + public signal void level_changed (double level_left, double level_right); + public signal void parameter_changed (Model.Parameter parameter, double new_value); + } + [CCode (cheader_filename = "marina.h")] + public class BarBeatTimeSystem : Model.TimeSystem, Model.TimeSystemBase { + public BarBeatTimeSystem (Model.TempoInformation tempo_information); + } + [CCode (cheader_filename = "marina.h")] + public class BpmCommand : Model.Command { + public BpmCommand (Model.Project project, int new_bpm); + public override void apply (); + public override string description (); + public override bool merge (Model.Command command); + public override void undo (); + } + [CCode (cheader_filename = "marina.h")] + public class Clip : GLib.Object { + public Model.ClipFile clipfile; + public bool is_recording; + public string name; + public Model.MediaType type; + public Clip (Model.ClipFile clipfile, Model.MediaType t, string name, int64 start, int64 media_start, int64 duration, bool is_recording); + public Model.Clip copy (); + public void gnonlin_connect (); + public void gnonlin_disconnect (); + public bool is_trimmed (); + public bool overlap_pos (int64 start, int64 length); + public void save (GLib.FileStream f, int id); + public void set_media_start_duration (int64 media_start, int64 duration); + public int64 snap (Model.Clip other, int64 pad); + public bool snap_coord (out int64 s, int64 span); + public void trim (int64 delta, Gdk.WindowEdge edge); + public int64 duration { get; set; } + public int64 end { get; } + public int64 media_start { get; } + public int64 start { get; set; } + public signal void duration_changed (int64 duration); + public signal void media_start_changed (int64 media_start); + public signal void moved (Model.Clip clip); + public signal void removed (Model.Clip clip); + public signal void start_changed (int64 start); + public signal void updated (Model.Clip clip); + } + [CCode (cheader_filename = "marina.h")] + public class ClipAddCommand : Model.Command { + public ClipAddCommand (Model.Track track, Model.Clip clip, int64 original_time, int64 new_start); + public override void apply (); + public override string description (); + public override bool merge (Model.Command command); + public override void undo (); + } + [CCode (cheader_filename = "marina.h")] + public class ClipCommand : Model.Command { + [CCode (cprefix = "MODEL_CLIP_COMMAND_ACTION_", cheader_filename = "marina.h")] + public enum Action { + APPEND, + DELETE + } + public ClipCommand (Model.ClipCommand.Action action, Model.Track track, Model.Clip clip, int64 time, bool select); + public override void apply (); + public override string description (); + public override bool merge (Model.Command command); + public override void undo (); + } + [CCode (cheader_filename = "marina.h")] + public class ClipFetcher : Model.Fetcher { + public ClipFetcher (string filename) throws GLib.Error; + public string get_filename (); + protected override void on_pad_added (Gst.Pad pad); + protected override void on_state_change (Gst.Bus bus, Gst.Message message); + public signal void clipfile_online (bool online); + } + [CCode (cheader_filename = "marina.h")] + public class ClipFile : GLib.Object { + public Gst.Caps audio_caps; + public string filename; + public Gdk.Pixbuf thumbnail; + public Gst.Caps video_caps; + public ClipFile (string filename, int64 length = 0); + public bool get_dimensions (out int w, out int h); + public bool get_frame_rate (out Fraction rate); + public bool get_num_channels (out int channels); + public bool get_num_channels_string (out string s); + public bool get_sample_rate (out int rate); + public bool get_video_format (out uint32 fourcc); + public bool has_caps_structure (Model.MediaType m); + public bool is_of_type (Model.MediaType t); + public bool is_online (); + public void set_online (bool o); + public void set_thumbnail (Gdk.Pixbuf b); + public int64 length { get; set; } + public signal void updated (); + } + [CCode (cheader_filename = "marina.h")] + public class ClipFileDeleteCommand : Model.Command { + public ClipFileDeleteCommand (Model.Project p, Model.ClipFile cf); + public override void apply (); + public override string description (); + public override bool merge (Model.Command command); + public override void undo (); + } + [CCode (cheader_filename = "marina.h")] + public class ClipImporter : MultiFileProgressInterface, GLib.Object { + public ClipImporter (); + public void add_filename (string filename); + public void start () throws GLib.Error; + public signal void clip_complete (Model.ClipFile f); + public signal void error_occurred (string error); + public signal void importing_started (int num_clips); + } + [CCode (cheader_filename = "marina.h")] + public class ClipRevertCommand : Model.Command { + public ClipRevertCommand (Model.Track track, Model.Clip clip); + public override void apply (); + public override string description (); + public override bool merge (Model.Command command); + public override void undo (); + } + [CCode (cheader_filename = "marina.h")] + public class ClipSplitCommand : Model.Command { + [CCode (cprefix = "MODEL_CLIP_SPLIT_COMMAND_ACTION_", cheader_filename = "marina.h")] + public enum Action { + SPLIT, + JOIN + } + public ClipSplitCommand (Model.ClipSplitCommand.Action action, Model.Track track, int64 time); + public override void apply (); + public override string description (); + public override bool merge (Model.Command command); + public override void undo (); + } + [CCode (cheader_filename = "marina.h")] + public class ClipTrimCommand : Model.Command { + public ClipTrimCommand (Model.Track track, Model.Clip clip, int64 delta, Gdk.WindowEdge edge); + public override void apply (); + public override string description (); + public override bool merge (Model.Command command); + public override void undo (); + } + [CCode (ref_function = "model_command_ref", unref_function = "model_command_unref", cheader_filename = "marina.h")] + public abstract class Command { + public Command (); + public abstract void apply (); + public abstract string description (); + public abstract bool merge (Model.Command command); + public abstract void undo (); + } + [CCode (cheader_filename = "marina.h")] + public abstract class Fetcher : GLib.Object { + public Model.ClipFile clipfile; + protected Gst.Element decodebin; + public string error_string; + protected Gst.Element filesrc; + protected Gst.Pipeline pipeline; + public Fetcher (); + protected void do_error (string error); + protected void on_error (Gst.Bus bus, Gst.Message message); + protected abstract void on_pad_added (Gst.Pad pad); + protected abstract void on_state_change (Gst.Bus bus, Gst.Message message); + protected void on_warning (Gst.Bus bus, Gst.Message message); + public signal void ready (Model.Fetcher fetcher); + } + [CCode (ref_function = "model_fetcher_completion_ref", unref_function = "model_fetcher_completion_unref", cheader_filename = "marina.h")] + public class FetcherCompletion { + public FetcherCompletion (); + public virtual void complete (Model.Fetcher fetcher); + } + [CCode (ref_function = "model_gap_ref", unref_function = "model_gap_unref", cheader_filename = "marina.h")] + public class Gap { + public int64 end; + public int64 start; + public Gap (int64 start, int64 end); + public Model.Gap intersect (Model.Gap g); + public bool is_empty (); + } + [CCode (cheader_filename = "marina.h")] + public class LibraryImporter : GLib.Object { + public Model.ClipImporter importer; + protected Model.Project project; + public LibraryImporter (Model.Project p); + public void add_file (string filename) throws GLib.Error; + protected virtual void append_existing_clipfile (Model.ClipFile f); + protected virtual void on_clip_complete (Model.ClipFile f); + public void start () throws GLib.Error; + public signal void started (Model.ClipImporter i, int num); + } + [CCode (cheader_filename = "marina.h")] + public class LoaderHandler : GLib.Object { + public LoaderHandler (); + public virtual bool commit_click (string[] attr_names, string[] attr_values); + public virtual bool commit_clip (string[] attr_names, string[] attr_values); + public virtual bool commit_clipfile (string[] attr_names, string[] attr_values); + public virtual bool commit_library (string[] attr_names, string[] attr_values); + public virtual bool commit_library_preference (string[] attr_names, string[] attr_values); + public virtual bool commit_marina (string[] attr_names, string[] attr_values); + public virtual bool commit_tempo_entry (string[] attr_names, string[] attr_values); + public virtual bool commit_time_signature_entry (string[] attr_names, string[] attr_values); + public virtual bool commit_track (string[] attr_names, string[] attr_values); + public virtual void leave_clip (); + public virtual void leave_clipfile (); + public virtual void leave_library (); + public virtual void leave_marina (); + public virtual void leave_track (); + public signal void complete (); + public signal void load_error (string error_message); + } + [CCode (cheader_filename = "marina.h")] + public class MediaLoaderHandler : Model.LoaderHandler { + protected Model.Track current_track; + protected weak Model.Project the_project; + public MediaLoaderHandler (Model.Project the_project); + public override bool commit_click (string[] attr_names, string[] attr_values); + public override bool commit_clip (string[] attr_names, string[] attr_values); + public override bool commit_clipfile (string[] attr_names, string[] attr_values); + public override bool commit_library (string[] attr_names, string[] attr_values); + public override bool commit_library_preference (string[] attr_names, string[] attr_values); + public override bool commit_marina (string[] attr_names, string[] attr_values); + public override bool commit_tempo_entry (string[] attr_names, string[] attr_values); + public override bool commit_time_signature_entry (string[] attr_names, string[] attr_values); + public override bool commit_track (string[] attr_names, string[] attr_values); + public override void leave_library (); + public override void leave_track (); + } + [CCode (cheader_filename = "marina.h")] + public class ParameterCommand : Model.Command { + public ParameterCommand (Model.AudioTrack target, Model.Parameter parameter, double new_value, double old_value); + public override void apply (); + public override string description (); + public override bool merge (Model.Command command); + public override void undo (); + } + [CCode (cheader_filename = "marina.h")] + public abstract class Project : Model.TempoInformation, GLib.Object { + public static Fraction INVALID_FRAME_RATE; + public bool click_during_play; + public bool click_during_record; + public double click_volume; + protected Gee.ArrayList clipfiles; + public Fraction default_framerate; + public Model.LibraryImporter importer; + public Gee.ArrayList inactive_tracks; + public bool library_visible; + public int library_width; + public Model.ProjectLoader loader; + public View.MediaEngine media_engine; + protected string project_file; + public bool snap_to_clip; + public Gee.ArrayList tracks; + public Model.UndoManager undo_manager; + public const string FILLMORE_FILE_EXTENSION; + public const string FILLMORE_FILE_FILTER; + public const string LOMBARD_FILE_EXTENSION; + public const string LOMBARD_FILE_FILTER; + public const string[] authors; + public Project (string? filename, bool include_video) throws GLib.Error; + public void _add_clipfile (Model.ClipFile clipfile) throws GLib.Error; + public void _remove_clipfile (Model.ClipFile cf); + public void _set_bpm (int bpm); + public void _set_time_signature (Fraction time_signature); + public void add (Model.Track track, Model.ClipFile clipfile, int64 time); + public void add_clipfile (Model.ClipFile clipfile); + public void add_inactive_track (Model.Track track); + public virtual void add_track (Model.Track track); + public void append (Model.Track track, Model.ClipFile clipfile); + public bool can_delete_gap (Model.Gap gap); + public bool can_export (); + public bool can_trim (out bool left); + public void clear (); + public bool clipfile_on_track (string filename); + public void close (); + public void create_clip_fetcher (Model.FetcherCompletion fetcher_completion, string filename) throws GLib.Error; + public void create_clip_importer (Model.Track? track, bool timeline_add, int64 time_to_add, bool both_tracks, Gtk.Window? progress_window_parent, int number); + public void delete_gap (Model.Gap gap); + protected virtual void do_append (Model.Track track, Model.ClipFile clipfile, string name, int64 insert_time); + public void do_command (Model.Command the_command); + public Model.AudioTrack? find_audio_track (); + public Model.ClipFile? find_clipfile (string filename); + public Model.VideoTrack? find_video_track (); + public abstract string get_app_name (); + public string get_audio_path (); + public abstract TimeCode get_clip_time (Model.ClipFile f); + public Model.ClipFile? get_clipfile (int index); + public int get_clipfile_index (Model.ClipFile find); + public string get_file_display_name (); + public int get_file_version (); + public int64 get_length (); + public string get_license (); + public virtual string? get_project_file (); + public string get_version (); + public void go_end (); + public void go_next (); + public void go_previous (); + public void go_start (); + public virtual void insert_track (int index, Model.Track track); + public bool is_duplicate_track_name (Model.Track? track, string new_name); + public bool is_project_extension (string filename); + public virtual void load (string? fname); + public void on_clip_removed (Model.Track t, Model.Clip clip); + public void on_error_occurred (string major_error, string? minor_error); + public void on_importer_clip_complete (Model.ClipFetcher fetcher); + public void on_load_started (string filename); + public void on_playstate_changed (); + public bool playhead_on_clip (); + public bool playhead_on_contiguous_clip (); + public void print_graph (Gst.Bin bin, string file_name); + public void remove_clipfile (string filename); + public void remove_track (Model.Track track); + public void remove_track_at (int index); + public void reseek (); + public virtual void save (string? filename); + public void save_library (GLib.FileStream f); + public void set_bpm (int bpm); + public void set_default_framerate (Fraction rate); + public void set_name (string? filename); + public void set_time_signature (Fraction time_signature); + public int64 snap_clip (Model.Clip c, int64 span); + public void snap_coord (out int64 coord, int64 span); + public void split_at_playhead (); + public Model.Track? track_from_clip (Model.Clip clip); + public int64 transport_get_position (); + public void transport_go (int64 position); + public bool transport_is_playing (); + public bool transport_is_recording (); + public void trim_to_playhead (); + public void undo (); + public signal void cleared (); + public signal void clipfile_added (Model.ClipFile c); + public signal void clipfile_removed (Model.ClipFile clip_file); + public signal void closed (); + public signal void error_occurred (string major_message, string? minor_message); + public virtual signal void load_complete (); + public signal void load_error (string error); + public signal void name_changed (string? project_file); + public signal void playstate_changed (PlayState playstate); + public signal void track_added (Model.Track track); + public signal void track_removed (Model.Track track); + } + [CCode (cheader_filename = "marina.h")] + public class ProjectLoader : GLib.Object { + public ProjectLoader (Model.LoaderHandler loader_handler, string? file_name); + public void load (); + public signal void load_complete (); + public signal void load_error (string error); + public signal void load_started (string filename); + } + [CCode (cheader_filename = "marina.h")] + public class ThumbnailFetcher : Model.Fetcher { + public ThumbnailFetcher (Model.ClipFile f, int64 time) throws GLib.Error; + protected override void on_pad_added (Gst.Pad pad); + protected override void on_state_change (Gst.Bus bus, Gst.Message message); + } + [CCode (cheader_filename = "marina.h")] + public class TimeSignatureCommand : Model.Command { + public TimeSignatureCommand (Model.Project project, Fraction new_time_signature); + public override void apply (); + public override string description (); + public override bool merge (Model.Command command); + public override void undo (); + } + [CCode (cheader_filename = "marina.h")] + public abstract class TimeSystemBase : GLib.Object { + public float pixel_percentage; + public int64 pixel_snap_time; + public float pixels_per_second; + public const int PIXEL_SNAP_INTERVAL; + public TimeSystemBase (); + protected int correct_seconds_value (float seconds, int div, int fps); + public float get_pixel_percentage (); + public int64 get_pixel_snap_time (); + public int time_to_xpos (int64 time); + public int time_to_xsize (int64 time); + public int64 xpos_to_time (int x); + public int64 xsize_to_time (int size); + } + [CCode (cheader_filename = "marina.h")] + public class TimecodeTimeSystem : Model.TimeSystem, Model.TimeSystemBase { + public Fraction frame_rate_fraction; + public TimecodeTimeSystem (); + } + [CCode (cheader_filename = "marina.h")] + public class TimelineImporter : Model.LibraryImporter { + public TimelineImporter (Model.Track track, Model.Project p, int64 time_to_add, bool both_tracks); + protected override void append_existing_clipfile (Model.ClipFile f); + protected override void on_clip_complete (Model.ClipFile f); + } + [CCode (cheader_filename = "marina.h")] + public abstract class Track : GLib.Object { + public Gee.ArrayList clips; + public string display_name; + protected weak Model.Project project; + public Track (Model.Project project, string display_name); + public void _append_at_time (Model.Clip c, int64 time, bool select); + public void _delete_clip (Model.Clip clip); + public void _join (int64 position); + public void _move (Model.Clip c, int64 pos); + public void _revert_to_original (Model.Clip c); + public void _split_at (int64 position); + public void _trim (Model.Clip clip, int64 delta, Gdk.WindowEdge edge); + public void add (Model.Clip c, int64 pos, bool select); + public void append_at_time (Model.Clip c, int64 time, bool select); + public bool are_contiguous_clips (int64 position); + protected abstract bool check (Model.Clip clip); + public bool clip_is_near (Model.Clip clip, int64 range, out int64 adjustment); + public bool contains_clipfile (Model.ClipFile f); + public void delete_all_clips (); + public void delete_clip (Model.Clip clip); + public void delete_gap (Model.Gap g); + public void do_clip_paste (Model.Clip clip, int64 position); + public void find_containing_gap (int64 time, out Model.Gap g); + public Model.Gap find_first_gap (int64 start); + public Model.Clip? find_nearest_clip_edge (int64 time, out bool after); + public Model.Clip? find_overlapping_clip (int64 start, int64 length); + public Model.Clip? get_clip (int i); + public Model.Clip? get_clip_by_position (int64 pos); + public int get_clip_index (Model.Clip c); + public string get_display_name (); + public bool get_is_selected (); + public int64 get_length (); + public int64 get_time_from_pos (Model.Clip clip, bool after); + public void hide (); + public void join (int64 position); + public abstract Model.MediaType media_type (); + public void move (Model.Clip c, int64 pos, int64 original_time); + protected abstract string name (); + public int64 next_edit (int64 pos); + public virtual void on_clip_updated (Model.Clip clip); + public int64 previous_edit (int64 pos); + public void remove_clip_from_array (Model.Clip pos); + public void revert_to_original (Model.Clip clip); + public void save (GLib.FileStream f); + public void set_display_name (string new_display_name); + public void set_selected (bool is_selected); + public int64 snap_clip (Model.Clip c, int64 span); + public bool snap_coord (out int64 coord, int64 span); + public void split_at (int64 position); + public void trim (Model.Clip clip, int64 delta, Gdk.WindowEdge edge); + public virtual void write_attributes (GLib.FileStream f); + public signal void clip_added (Model.Clip clip, bool select); + public signal void clip_removed (Model.Clip clip); + public signal void error_occurred (string major_error, string? minor_error); + public signal void track_hidden (Model.Track track); + public signal void track_removed (Model.Track track); + public signal void track_renamed (Model.Track track); + public signal void track_selection_changed (Model.Track track); + } + [CCode (cheader_filename = "marina.h")] + public class TransactionCommand : Model.Command { + public TransactionCommand (bool open, string transaction_description); + public override void apply (); + public override string description (); + public bool in_transaction (); + public override bool merge (Model.Command command); + public override void undo (); + } + [CCode (ref_function = "model_undo_manager_ref", unref_function = "model_undo_manager_unref", cheader_filename = "marina.h")] + public class UndoManager { + public UndoManager (); + public void do_command (Model.Command the_command); + public void end_transaction (string description); + public string get_undo_title (); + public void mark_clean (); + public void reset (); + public void start_transaction (string description); + public void undo (); + public bool can_undo { get; } + public bool in_undo { get; set; } + public bool is_dirty { get; } + public signal void dirty_changed (bool is_dirty); + public signal void undo_changed (bool can_undo); + } + [CCode (cheader_filename = "marina.h")] + public class VideoTrack : Model.Track { + public VideoTrack (Model.Project project); + protected override bool check (Model.Clip clip); + public int get_current_frame (int64 time); + public bool get_framerate (out Fraction rate); + public override Model.MediaType media_type (); + protected override string name (); + public int64 next_frame (int64 position); + public int64 previous_frame (int64 position); + } + [CCode (ref_function = "model_xml_element_ref", unref_function = "model_xml_element_unref", cheader_filename = "marina.h")] + public class XmlElement { + public string[] attribute_names; + public string[] attribute_values; + public XmlElement (string name, string[] attribute_names, string[] attribute_values, Model.XmlElement? parent); + public void add_child (Model.XmlElement child_element); + public Gee.ArrayList children { get; } + public string name { get; set; } + public Model.XmlElement? parent { get; set; } + } + [CCode (ref_function = "model_xml_tree_loader_ref", unref_function = "model_xml_tree_loader_unref", cheader_filename = "marina.h")] + public class XmlTreeLoader { + public Model.XmlElement root; + public XmlTreeLoader (string document); + } + [CCode (cheader_filename = "marina.h")] + public interface TempoInformation { + public abstract int get_bpm (); + public abstract Fraction get_time_signature (); + public signal void bpm_changed (int bpm); + public signal void time_signature_changed (Fraction time_signature); + } + [CCode (cheader_filename = "marina.h")] + public interface TimeSystem : GLib.Object { + public abstract void calculate_pixel_step (float inc, float pixel_min, float pixel_div); + public abstract int frame_to_xsize (int frame); + public abstract string? get_display_string (int token); + public abstract int get_next_position (int token); + public abstract int get_pixel_height (int token); + public abstract float get_pixel_percentage (); + public abstract int64 get_pixel_snap_time (); + public abstract int get_start_token (int xsize); + public abstract string get_time_duration (int64 time); + public abstract string get_time_string (int64 time); + public abstract int time_to_xpos (int64 time); + public abstract int time_to_xsize (int64 time); + public abstract int64 xpos_to_time (int x); + public abstract int xsize_to_frame (int xsize); + public abstract int64 xsize_to_time (int x); + public signal void geometry_changed (); + } + [CCode (cprefix = "MODEL_MEDIA_TYPE_", cheader_filename = "marina.h")] + public enum MediaType { + AUDIO, + VIDEO + } + [CCode (cprefix = "MODEL_PARAMETER_", cheader_filename = "marina.h")] + public enum Parameter { + PAN, + VOLUME + } +} +[CCode (cprefix = "DialogUtils", lower_case_cprefix = "dialog_utils_")] +namespace DialogUtils { + [CCode (type_id = "DIALOG_UTILS_TYPE_FILTER_DESCRIPTION_STRUCT", cheader_filename = "marina.h")] + public struct filter_description_struct { + public string name; + public string extension; + } + [CCode (cheader_filename = "marina.h")] + public static Gtk.ResponseType add_cancel (string message); + [CCode (cheader_filename = "marina.h")] + public static bool confirm_replace (Gtk.Window? parent, string filename); + [CCode (cheader_filename = "marina.h")] + public static Gtk.ResponseType delete_cancel (string message); + [CCode (cheader_filename = "marina.h")] + public static Gtk.ResponseType delete_keep (string message); + [CCode (cheader_filename = "marina.h")] + public static void error (string major_message, string? minor_message); + [CCode (cheader_filename = "marina.h")] + public static bool open (Gtk.Window parent, DialogUtils.filter_description_struct[] filter_descriptions, bool allow_multiple, bool allow_all, out GLib.SList filenames); + [CCode (cheader_filename = "marina.h")] + public static bool save (Gtk.Window parent, string title, bool create_directory, DialogUtils.filter_description_struct[] filter_descriptions, ref string filename); + [CCode (cheader_filename = "marina.h")] + public static Gtk.ResponseType save_close_cancel (Gtk.Window? parent, string? title, string message); + [CCode (cheader_filename = "marina.h")] + public static void show_clip_properties (Gtk.Window parent, ClipView? selected_clip, Model.ClipFile? clip_file, Fraction? frames_per_second); + [CCode (cheader_filename = "marina.h")] + public static void warning (string major_message, string? minor_message); +} +[CCode (cprefix = "Logging", lower_case_cprefix = "logging_")] +namespace Logging { + [CCode (cprefix = "LOGGING_FACILITY_", cheader_filename = "marina.h")] + public enum Facility { + SIGNAL_HANDLERS, + DEVELOPER_WARNINGS, + GRAPH, + LOADING, + IMPORT, + SINGLEDECODEBIN + } + [CCode (cprefix = "LOGGING_LEVEL_", cheader_filename = "marina.h")] + public enum Level { + CRITICAL, + HIGH, + MEDIUM, + LOW, + INFO, + VERBOSE + } + [CCode (cheader_filename = "marina.h")] + public static void emit (GLib.Object object, Logging.Facility facility, Logging.Level level, string message); + [CCode (cheader_filename = "marina.h")] + public static void set_logging_level (Logging.Level new_level); +} +[CCode (cprefix = "PLAY_STATE_", cheader_filename = "marina.h")] +public enum PlayState { + STOPPED, + PRE_PLAY, + PLAYING, + PRE_RECORD_NULL, + PRE_RECORD, + RECORDING, + POST_RECORD, + PRE_EXPORT, + EXPORTING, + CANCEL_EXPORT, + LOADING, + CLOSING, + CLOSED +} +[CCode (cprefix = "GDK_", has_type_id = false, cheader_filename = "gdk/gdkkeysyms.h")] +public enum KeySyms { + Control_L, + Control_R, + Down, + equal, + Escape, + KP_Add, + KP_Enter, + KP_Subtract, + Left, + minus, + plus, + Return, + Right, + Shift_L, + Shift_R, + underscore, + Up +} +[CCode (cprefix = "MEDIA_ERROR_", cheader_filename = "marina.h")] +public errordomain MediaError { + MISSING_PLUGIN, +} +[CCode (ref_function = "app_dirs_ref", unref_function = "app_dirs_unref", cheader_filename = "marina.h")] +public class AppDirs { + public AppDirs (); + public static GLib.File get_exec_dir (); + public static GLib.File get_resources_dir (); + public static void init (string arg0, string program_name); + public static void terminate (); +} +[CCode (ref_function = "class_factory_ref", unref_function = "class_factory_unref", cheader_filename = "marina.h")] +public class ClassFactory { + public ClassFactory (); + public static ClassFactory get_class_factory (); + public virtual TrackView get_track_view (Model.Track track, TimeLine timeline); + public static void set_class_factory (ClassFactory class_factory); + public static void set_transport_delegate (TransportDelegate transport_delegate); +} +[CCode (cheader_filename = "marina.h")] +public class ClipLibraryView : Gtk.EventBox { + public static Gtk.Menu context_menu; + public ClipLibraryView (Model.Project p, Model.TimeSystem time_provider, string? drag_message, Gdk.DragAction actions); + public void delete_selection (); + public override void drag_data_received (Gdk.DragContext context, int x, int y, Gtk.SelectionData selection_data, uint drag_info, uint time); + public Gee.ArrayList get_selected_files (); + public bool has_selection (); + public void on_clipfile_removed (Model.ClipFile f); + public void select_all (); + public void unselect_all (); + public signal void selection_changed (bool selected); +} +[CCode (cheader_filename = "marina.h")] +public class MultiFileProgress : Gtk.Window { + public MultiFileProgress (Gtk.Window parent, int num_files, string dialog_title, MultiFileProgressInterface provider); +} +[CCode (ref_function = "track_clip_pair_ref", unref_function = "track_clip_pair_unref", cheader_filename = "marina.h")] +public class TrackClipPair { + public Model.Clip clip; + public Model.Track track; + public TrackClipPair (Model.Track track, Model.Clip clip); +} +[CCode (ref_function = "clipboard_ref", unref_function = "clipboard_unref", cheader_filename = "marina.h")] +public class Clipboard { + public Gee.ArrayList clips; + public Clipboard (); + public void paste (Model.Track selected_track, int64 time); + public void select (Gee.ArrayList selected_clips); +} +[CCode (cheader_filename = "marina.h")] +public class TimeLine : Gtk.EventBox { + public Clipboard clipboard; + public Model.Project project; + public weak Model.TimeSystem provider; + public View.Ruler ruler; + public Gee.ArrayList selected_clips; + public Gee.ArrayList tracks; + public const int BAR_HEIGHT; + public const int BORDER; + public const int RULER_HEIGHT; + public TimeLine (Model.Project p, Model.TimeSystem provider, Gdk.DragAction actions); + public override bool button_press_event (Gdk.EventButton event); + public override bool button_release_event (Gdk.EventButton event); + public void delete_selection (); + public void deselect_all_clips (); + public void do_clip_move (ClipView clip_view, int64 delta); + public void do_copy (); + public void do_cut (); + public void do_paste (int64 pos); + public override void drag_data_received (Gdk.DragContext context, int x, int y, Gtk.SelectionData selection_data, uint drag_info, uint time); + public override bool expose_event (Gdk.EventExpose event); + public Gtk.Widget? find_child (double x, double y); + public bool gap_selected (); + public bool is_clip_selected (); + public override bool motion_notify_event (Gdk.EventMotion event); + public void on_clip_view_added (ClipView clip_view); + public void on_ruler_position_changed (int x); + public void paste (); + public void select_all (); + public void update_pos (int event_x); + public void zoom (float inc); + public void zoom_to_project (double width); + public signal void selection_changed (bool selected); + public signal void track_changed (); + public signal void trackview_added (TrackView trackview); + public signal void trackview_removed (TrackView trackview); +} +[CCode (cheader_filename = "marina.h")] +public class GapView : Gtk.DrawingArea { + public Model.Gap gap; + public GapView (int64 start, int64 length, int width, int height); + public override bool expose_event (Gdk.EventExpose e); + public void remove (); + public void unselect (); + public signal void removed (GapView gap_view); + public signal void unselected (GapView gap_view); +} +[CCode (cheader_filename = "marina.h")] +public class ClipView : Gtk.DrawingArea { + public Model.Clip clip; + public static Gtk.Menu context_menu; + public int height; + public int64 initial_time; + public bool is_selected; + public const int SNAP_DELTA; + public ClipView (TransportDelegate transport_delegate, Model.Clip clip, Model.TimeSystem time_provider, int height); + public void adjust_size (int height); + public override bool button_press_event (Gdk.EventButton event); + public override bool button_release_event (Gdk.EventButton event); + public void delete_clip (); + public void draw (); + public override bool expose_event (Gdk.EventExpose event); + public override bool motion_notify_event (Gdk.EventMotion event); + public void on_clip_moved (Model.Clip clip); + public void select (); + public void snap (int64 amount); + public signal void clip_deleted (Model.Clip clip); + public signal void clip_moved (ClipView clip); + public signal void move_begin (ClipView clip_view, bool copy); + public signal void move_commit (ClipView clip_view, int64 delta); + public signal void move_request (ClipView clip_view, int64 delta); + public signal void selection_request (ClipView clip_view, bool extend_selection); + public signal void trim_begin (ClipView clip_view, Gdk.WindowEdge edge); + public signal void trim_commit (ClipView clip_view, Gdk.WindowEdge edge); +} +[CCode (cheader_filename = "marina.h")] +public interface TrackView : Gtk.Widget { + public abstract Gtk.Widget? find_child (double x, double y); + public abstract Model.Track get_track (); + public abstract int get_track_height (); + public abstract void move_to_top (ClipView clip_view); + public abstract void resize (); + public abstract void select_all (); + public signal void clip_view_added (ClipView clip_view); +} +[CCode (cheader_filename = "marina.h")] +public interface MultiFileProgressInterface : GLib.Object { + public abstract void cancel (); + public abstract void complete (); + public signal void done (); + public signal void file_updated (string filename, int index); + public signal void fraction_updated (double d); +} +[CCode (cheader_filename = "marina.h")] +public interface TransportDelegate : GLib.Object { + public abstract bool is_playing (); + public abstract bool is_recording (); + public abstract bool is_stopped (); +} +[CCode (type_id = "TYPE_FRACTION", cheader_filename = "marina.h")] +public struct Fraction { + public int numerator; + public int denominator; + public Fraction (int numerator, int denominator); + public bool equal (Fraction f); + public Fraction.from_string (string s); + public int nearest_int (); + public string to_string (); +} +[CCode (type_id = "TYPE_TIME_CODE", cheader_filename = "marina.h")] +public struct TimeCode { + public int hour; + public int minute; + public int second; + public int frame; + public bool drop_code; + public void get_from_length (int64 length); + public string to_string (); +} +[CCode (cheader_filename = "marina.h")] +public const int CHANNELS_PER_TRACK_PLAYBACK; +[CCode (cheader_filename = "marina.h")] +public const int CHANNELS_PER_TRACK_RECORD; +[CCode (cheader_filename = "marina.h")] +public const Gtk.TargetEntry[] drag_target_entries; +[CCode (cheader_filename = "marina.h")] +public static bool debug_enabled; +[CCode (cheader_filename = "marina.h")] +public static Gdk.ModifierType GDK_SHIFT_ALT_CONTROL_MASK; +[CCode (cheader_filename = "marina.h")] +public static float float_abs (float f); +[CCode (cheader_filename = "marina.h")] +public static bool float_within (double f, double epsilon); +[CCode (cheader_filename = "marina.h")] +public static int sign (int x); +[CCode (cheader_filename = "marina.h")] +public static string[] copy_array (string[] source); +[CCode (cheader_filename = "marina.h")] +public static void print_debug (string text); +[CCode (cheader_filename = "marina.h")] +public static bool time_in_range (int64 time, int64 center, int64 delta); +[CCode (cheader_filename = "marina.h")] +public static string isolate_filename (string path); +[CCode (cheader_filename = "marina.h")] +public static string get_file_extension (string path); +[CCode (cheader_filename = "marina.h")] +public static string append_extension (string path, string extension); +[CCode (cheader_filename = "marina.h")] +public static bool version_at_least (string v, string w); +[CCode (cheader_filename = "marina.h")] +public static bool get_file_md5_checksum (string filename, out string checksum); +[CCode (cheader_filename = "marina.h")] +public static void save_file_md5_checksum (string filename, string checksum); +[CCode (cheader_filename = "marina.h")] +public static bool md5_checksum_on_file (string filename, out string checksum); +[CCode (cheader_filename = "marina.h")] +public static Gdk.Color parse_color (string color); +[CCode (cheader_filename = "marina.h")] +public static Gtk.Widget get_widget (Gtk.UIManager manager, string name); +[CCode (cheader_filename = "marina.h")] +public static void draw_rounded_rectangle (Gdk.Window window, Gdk.Color color, bool filled, int x0, int y0, int width, int height); +[CCode (cheader_filename = "marina.h")] +public static void draw_right_rounded_rectangle (Gdk.Window window, Gdk.Color color, bool filled, int x0, int y0, int width, int height); +[CCode (cheader_filename = "marina.h")] +public static void draw_left_rounded_rectangle (Gdk.Window window, Gdk.Color color, bool filled, int x0, int y0, int width, int height); +[CCode (cheader_filename = "marina.h")] +public static void draw_square_rectangle (Gdk.Window window, Gdk.Color color, bool filled, int x, int y, int width, int height); +[CCode (cheader_filename = "marina.h")] +public static bool is_drop_frame_rate (Fraction r); +[CCode (cheader_filename = "marina.h")] +public static int64 frame_to_time_with_rate (int frame, Fraction rate); +[CCode (cheader_filename = "marina.h")] +public static int time_to_frame_with_rate (int64 time, Fraction rate); +[CCode (cheader_filename = "marina.h")] +public static TimeCode frame_to_time (int frame, Fraction rate); +[CCode (cheader_filename = "marina.h")] +public static string frame_to_string (int frame, Fraction rate); +[CCode (cheader_filename = "marina.h")] +public static string time_to_HHMMSS (int64 time); +[CCode (cheader_filename = "marina.h")] +public static string time_to_string (int64 time); +[CCode (cheader_filename = "marina.h")] +public static Gst.Element make_element_with_name (string element_name, string? display_name) throws GLib.Error; +[CCode (cheader_filename = "marina.h")] +public static Gst.Element make_element (string name) throws GLib.Error; diff --git a/src/marina/marina/project.c b/src/marina/marina/project.c new file mode 100644 index 0000000..80312c7 --- /dev/null +++ b/src/marina/marina/project.c @@ -0,0 +1,5147 @@ +/* project.c generated by valac, the Vala compiler + * generated from project.vala, do not modify */ + +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#define MODEL_TYPE_LOADER_HANDLER (model_loader_handler_get_type ()) +#define MODEL_LOADER_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_LOADER_HANDLER, ModelLoaderHandler)) +#define MODEL_LOADER_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_LOADER_HANDLER, ModelLoaderHandlerClass)) +#define MODEL_IS_LOADER_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_LOADER_HANDLER)) +#define MODEL_IS_LOADER_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_LOADER_HANDLER)) +#define MODEL_LOADER_HANDLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_LOADER_HANDLER, ModelLoaderHandlerClass)) + +typedef struct _ModelLoaderHandler ModelLoaderHandler; +typedef struct _ModelLoaderHandlerClass ModelLoaderHandlerClass; +typedef struct _ModelLoaderHandlerPrivate ModelLoaderHandlerPrivate; + +#define MODEL_TYPE_MEDIA_LOADER_HANDLER (model_media_loader_handler_get_type ()) +#define MODEL_MEDIA_LOADER_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_MEDIA_LOADER_HANDLER, ModelMediaLoaderHandler)) +#define MODEL_MEDIA_LOADER_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_MEDIA_LOADER_HANDLER, ModelMediaLoaderHandlerClass)) +#define MODEL_IS_MEDIA_LOADER_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_MEDIA_LOADER_HANDLER)) +#define MODEL_IS_MEDIA_LOADER_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_MEDIA_LOADER_HANDLER)) +#define MODEL_MEDIA_LOADER_HANDLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_MEDIA_LOADER_HANDLER, ModelMediaLoaderHandlerClass)) + +typedef struct _ModelMediaLoaderHandler ModelMediaLoaderHandler; +typedef struct _ModelMediaLoaderHandlerClass ModelMediaLoaderHandlerClass; +typedef struct _ModelMediaLoaderHandlerPrivate ModelMediaLoaderHandlerPrivate; + +#define MODEL_TYPE_PROJECT (model_project_get_type ()) +#define MODEL_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT, ModelProject)) +#define MODEL_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT, ModelProjectClass)) +#define MODEL_IS_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT)) +#define MODEL_IS_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT)) +#define MODEL_PROJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT, ModelProjectClass)) + +typedef struct _ModelProject ModelProject; +typedef struct _ModelProjectClass ModelProjectClass; + +#define MODEL_TYPE_TRACK (model_track_get_type ()) +#define MODEL_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TRACK, ModelTrack)) +#define MODEL_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TRACK, ModelTrackClass)) +#define MODEL_IS_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TRACK)) +#define MODEL_IS_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TRACK)) +#define MODEL_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TRACK, ModelTrackClass)) + +typedef struct _ModelTrack ModelTrack; +typedef struct _ModelTrackClass ModelTrackClass; + +#define MODEL_TYPE_FETCHER (model_fetcher_get_type ()) +#define MODEL_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_FETCHER, ModelFetcher)) +#define MODEL_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_FETCHER, ModelFetcherClass)) +#define MODEL_IS_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_FETCHER)) +#define MODEL_IS_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_FETCHER)) +#define MODEL_FETCHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_FETCHER, ModelFetcherClass)) + +typedef struct _ModelFetcher ModelFetcher; +typedef struct _ModelFetcherClass ModelFetcherClass; + +#define MODEL_TYPE_CLIP_FETCHER (model_clip_fetcher_get_type ()) +#define MODEL_CLIP_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcher)) +#define MODEL_CLIP_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcherClass)) +#define MODEL_IS_CLIP_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FETCHER)) +#define MODEL_IS_CLIP_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FETCHER)) +#define MODEL_CLIP_FETCHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcherClass)) + +typedef struct _ModelClipFetcher ModelClipFetcher; +typedef struct _ModelClipFetcherClass ModelClipFetcherClass; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +#define _g_free0(var) (var = (g_free (var), NULL)) + +#define TYPE_FRACTION (fraction_get_type ()) +typedef struct _Fraction Fraction; + +#define MODEL_TYPE_AUDIO_TRACK (model_audio_track_get_type ()) +#define MODEL_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrack)) +#define MODEL_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrackClass)) +#define MODEL_IS_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_AUDIO_TRACK)) +#define MODEL_IS_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_AUDIO_TRACK)) +#define MODEL_AUDIO_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrackClass)) + +typedef struct _ModelAudioTrack ModelAudioTrack; +typedef struct _ModelAudioTrackClass ModelAudioTrackClass; + +#define MODEL_TYPE_VIDEO_TRACK (model_video_track_get_type ()) +#define MODEL_VIDEO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_VIDEO_TRACK, ModelVideoTrack)) +#define MODEL_VIDEO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_VIDEO_TRACK, ModelVideoTrackClass)) +#define MODEL_IS_VIDEO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_VIDEO_TRACK)) +#define MODEL_IS_VIDEO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_VIDEO_TRACK)) +#define MODEL_VIDEO_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_VIDEO_TRACK, ModelVideoTrackClass)) + +typedef struct _ModelVideoTrack ModelVideoTrack; +typedef struct _ModelVideoTrackClass ModelVideoTrackClass; +typedef struct _ModelFetcherPrivate ModelFetcherPrivate; + +#define MODEL_TYPE_CLIP_FILE (model_clip_file_get_type ()) +#define MODEL_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFile)) +#define MODEL_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) +#define MODEL_IS_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE)) +#define MODEL_IS_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE)) +#define MODEL_CLIP_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) + +typedef struct _ModelClipFile ModelClipFile; +typedef struct _ModelClipFileClass ModelClipFileClass; + +#define MODEL_TYPE_MEDIA_TYPE (model_media_type_get_type ()) + +#define MODEL_TYPE_CLIP (model_clip_get_type ()) +#define MODEL_CLIP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP, ModelClip)) +#define MODEL_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP, ModelClipClass)) +#define MODEL_IS_CLIP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP)) +#define MODEL_IS_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP)) +#define MODEL_CLIP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP, ModelClipClass)) + +typedef struct _ModelClip ModelClip; +typedef struct _ModelClipClass ModelClipClass; + +#define LOGGING_TYPE_FACILITY (logging_facility_get_type ()) + +#define LOGGING_TYPE_LEVEL (logging_level_get_type ()) +typedef struct _ModelClipFilePrivate ModelClipFilePrivate; +#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL))) + +#define MODEL_TYPE_TEMPO_INFORMATION (model_tempo_information_get_type ()) +#define MODEL_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformation)) +#define MODEL_IS_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TEMPO_INFORMATION)) +#define MODEL_TEMPO_INFORMATION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformationIface)) + +typedef struct _ModelTempoInformation ModelTempoInformation; +typedef struct _ModelTempoInformationIface ModelTempoInformationIface; +typedef struct _ModelProjectPrivate ModelProjectPrivate; + +#define TYPE_TIME_CODE (time_code_get_type ()) +typedef struct _TimeCode TimeCode; + +#define VIEW_TYPE_MEDIA_ENGINE (view_media_engine_get_type ()) +#define VIEW_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngine)) +#define VIEW_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass)) +#define VIEW_IS_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_ENGINE)) +#define VIEW_IS_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_ENGINE)) +#define VIEW_MEDIA_ENGINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass)) + +typedef struct _ViewMediaEngine ViewMediaEngine; +typedef struct _ViewMediaEngineClass ViewMediaEngineClass; + +#define MODEL_TYPE_PROJECT_LOADER (model_project_loader_get_type ()) +#define MODEL_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoader)) +#define MODEL_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass)) +#define MODEL_IS_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT_LOADER)) +#define MODEL_IS_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT_LOADER)) +#define MODEL_PROJECT_LOADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass)) + +typedef struct _ModelProjectLoader ModelProjectLoader; +typedef struct _ModelProjectLoaderClass ModelProjectLoaderClass; + +#define MODEL_TYPE_UNDO_MANAGER (model_undo_manager_get_type ()) +#define MODEL_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManager)) +#define MODEL_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass)) +#define MODEL_IS_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_UNDO_MANAGER)) +#define MODEL_IS_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_UNDO_MANAGER)) +#define MODEL_UNDO_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass)) + +typedef struct _ModelUndoManager ModelUndoManager; +typedef struct _ModelUndoManagerClass ModelUndoManagerClass; + +#define MODEL_TYPE_LIBRARY_IMPORTER (model_library_importer_get_type ()) +#define MODEL_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporter)) +#define MODEL_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass)) +#define MODEL_IS_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_LIBRARY_IMPORTER)) +#define MODEL_IS_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_LIBRARY_IMPORTER)) +#define MODEL_LIBRARY_IMPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass)) + +typedef struct _ModelLibraryImporter ModelLibraryImporter; +typedef struct _ModelLibraryImporterClass ModelLibraryImporterClass; + +#define MODEL_TYPE_THUMBNAIL_FETCHER (model_thumbnail_fetcher_get_type ()) +#define MODEL_THUMBNAIL_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_THUMBNAIL_FETCHER, ModelThumbnailFetcher)) +#define MODEL_THUMBNAIL_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_THUMBNAIL_FETCHER, ModelThumbnailFetcherClass)) +#define MODEL_IS_THUMBNAIL_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_THUMBNAIL_FETCHER)) +#define MODEL_IS_THUMBNAIL_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_THUMBNAIL_FETCHER)) +#define MODEL_THUMBNAIL_FETCHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_THUMBNAIL_FETCHER, ModelThumbnailFetcherClass)) + +typedef struct _ModelThumbnailFetcher ModelThumbnailFetcher; +typedef struct _ModelThumbnailFetcherClass ModelThumbnailFetcherClass; + +#define MODEL_TYPE_FETCHER_COMPLETION (model_fetcher_completion_get_type ()) +#define MODEL_FETCHER_COMPLETION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_FETCHER_COMPLETION, ModelFetcherCompletion)) +#define MODEL_FETCHER_COMPLETION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_FETCHER_COMPLETION, ModelFetcherCompletionClass)) +#define MODEL_IS_FETCHER_COMPLETION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_FETCHER_COMPLETION)) +#define MODEL_IS_FETCHER_COMPLETION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_FETCHER_COMPLETION)) +#define MODEL_FETCHER_COMPLETION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_FETCHER_COMPLETION, ModelFetcherCompletionClass)) + +typedef struct _ModelFetcherCompletion ModelFetcherCompletion; +typedef struct _ModelFetcherCompletionClass ModelFetcherCompletionClass; +#define _model_fetcher_completion_unref0(var) ((var == NULL) ? NULL : (var = (model_fetcher_completion_unref (var), NULL))) +#define _model_undo_manager_unref0(var) ((var == NULL) ? NULL : (var = (model_undo_manager_unref (var), NULL))) + +#define TYPE_PLAY_STATE (play_state_get_type ()) +typedef struct _ModelTrackPrivate ModelTrackPrivate; + +#define MODEL_TYPE_GAP (model_gap_get_type ()) +#define MODEL_GAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_GAP, ModelGap)) +#define MODEL_GAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_GAP, ModelGapClass)) +#define MODEL_IS_GAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_GAP)) +#define MODEL_IS_GAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_GAP)) +#define MODEL_GAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_GAP, ModelGapClass)) + +typedef struct _ModelGap ModelGap; +typedef struct _ModelGapClass ModelGapClass; +typedef struct _ModelGapPrivate ModelGapPrivate; +#define _model_gap_unref0(var) ((var == NULL) ? NULL : (var = (model_gap_unref (var), NULL))) + +#define TYPE_MULTI_FILE_PROGRESS_INTERFACE (multi_file_progress_interface_get_type ()) +#define MULTI_FILE_PROGRESS_INTERFACE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MULTI_FILE_PROGRESS_INTERFACE, MultiFileProgressInterface)) +#define IS_MULTI_FILE_PROGRESS_INTERFACE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MULTI_FILE_PROGRESS_INTERFACE)) +#define MULTI_FILE_PROGRESS_INTERFACE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_MULTI_FILE_PROGRESS_INTERFACE, MultiFileProgressInterfaceIface)) + +typedef struct _MultiFileProgressInterface MultiFileProgressInterface; +typedef struct _MultiFileProgressInterfaceIface MultiFileProgressInterfaceIface; +typedef struct _ViewMediaEnginePrivate ViewMediaEnginePrivate; + +#define MODEL_TYPE_COMMAND (model_command_get_type ()) +#define MODEL_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_COMMAND, ModelCommand)) +#define MODEL_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_COMMAND, ModelCommandClass)) +#define MODEL_IS_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_COMMAND)) +#define MODEL_IS_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_COMMAND)) +#define MODEL_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_COMMAND, ModelCommandClass)) + +typedef struct _ModelCommand ModelCommand; +typedef struct _ModelCommandClass ModelCommandClass; + +#define MODEL_TYPE_ADD_CLIP_COMMAND (model_add_clip_command_get_type ()) +#define MODEL_ADD_CLIP_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_ADD_CLIP_COMMAND, ModelAddClipCommand)) +#define MODEL_ADD_CLIP_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_ADD_CLIP_COMMAND, ModelAddClipCommandClass)) +#define MODEL_IS_ADD_CLIP_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_ADD_CLIP_COMMAND)) +#define MODEL_IS_ADD_CLIP_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_ADD_CLIP_COMMAND)) +#define MODEL_ADD_CLIP_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_ADD_CLIP_COMMAND, ModelAddClipCommandClass)) + +typedef struct _ModelAddClipCommand ModelAddClipCommand; +typedef struct _ModelAddClipCommandClass ModelAddClipCommandClass; +#define _model_command_unref0(var) ((var == NULL) ? NULL : (var = (model_command_unref (var), NULL))) +typedef struct _ModelClipPrivate ModelClipPrivate; + +#define MODEL_TYPE_CLIP_FILE_DELETE_COMMAND (model_clip_file_delete_command_get_type ()) +#define MODEL_CLIP_FILE_DELETE_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND, ModelClipFileDeleteCommand)) +#define MODEL_CLIP_FILE_DELETE_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND, ModelClipFileDeleteCommandClass)) +#define MODEL_IS_CLIP_FILE_DELETE_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND)) +#define MODEL_IS_CLIP_FILE_DELETE_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND)) +#define MODEL_CLIP_FILE_DELETE_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE_DELETE_COMMAND, ModelClipFileDeleteCommandClass)) + +typedef struct _ModelClipFileDeleteCommand ModelClipFileDeleteCommand; +typedef struct _ModelClipFileDeleteCommandClass ModelClipFileDeleteCommandClass; +#define _fclose0(var) ((var == NULL) ? NULL : (var = (fclose (var), NULL))) + +#define MODEL_TYPE_TIMELINE_IMPORTER (model_timeline_importer_get_type ()) +#define MODEL_TIMELINE_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TIMELINE_IMPORTER, ModelTimelineImporter)) +#define MODEL_TIMELINE_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TIMELINE_IMPORTER, ModelTimelineImporterClass)) +#define MODEL_IS_TIMELINE_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TIMELINE_IMPORTER)) +#define MODEL_IS_TIMELINE_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TIMELINE_IMPORTER)) +#define MODEL_TIMELINE_IMPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TIMELINE_IMPORTER, ModelTimelineImporterClass)) + +typedef struct _ModelTimelineImporter ModelTimelineImporter; +typedef struct _ModelTimelineImporterClass ModelTimelineImporterClass; +typedef struct _ModelLibraryImporterPrivate ModelLibraryImporterPrivate; + +#define MODEL_TYPE_CLIP_IMPORTER (model_clip_importer_get_type ()) +#define MODEL_CLIP_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_IMPORTER, ModelClipImporter)) +#define MODEL_CLIP_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_IMPORTER, ModelClipImporterClass)) +#define MODEL_IS_CLIP_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_IMPORTER)) +#define MODEL_IS_CLIP_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_IMPORTER)) +#define MODEL_CLIP_IMPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_IMPORTER, ModelClipImporterClass)) + +typedef struct _ModelClipImporter ModelClipImporter; +typedef struct _ModelClipImporterClass ModelClipImporterClass; + +#define TYPE_MULTI_FILE_PROGRESS (multi_file_progress_get_type ()) +#define MULTI_FILE_PROGRESS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MULTI_FILE_PROGRESS, MultiFileProgress)) +#define MULTI_FILE_PROGRESS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_MULTI_FILE_PROGRESS, MultiFileProgressClass)) +#define IS_MULTI_FILE_PROGRESS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MULTI_FILE_PROGRESS)) +#define IS_MULTI_FILE_PROGRESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_MULTI_FILE_PROGRESS)) +#define MULTI_FILE_PROGRESS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_MULTI_FILE_PROGRESS, MultiFileProgressClass)) + +typedef struct _MultiFileProgress MultiFileProgress; +typedef struct _MultiFileProgressClass MultiFileProgressClass; + +#define MODEL_TYPE_TIME_SIGNATURE_COMMAND (model_time_signature_command_get_type ()) +#define MODEL_TIME_SIGNATURE_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TIME_SIGNATURE_COMMAND, ModelTimeSignatureCommand)) +#define MODEL_TIME_SIGNATURE_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TIME_SIGNATURE_COMMAND, ModelTimeSignatureCommandClass)) +#define MODEL_IS_TIME_SIGNATURE_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TIME_SIGNATURE_COMMAND)) +#define MODEL_IS_TIME_SIGNATURE_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TIME_SIGNATURE_COMMAND)) +#define MODEL_TIME_SIGNATURE_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TIME_SIGNATURE_COMMAND, ModelTimeSignatureCommandClass)) + +typedef struct _ModelTimeSignatureCommand ModelTimeSignatureCommand; +typedef struct _ModelTimeSignatureCommandClass ModelTimeSignatureCommandClass; + +#define MODEL_TYPE_BPM_COMMAND (model_bpm_command_get_type ()) +#define MODEL_BPM_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_BPM_COMMAND, ModelBpmCommand)) +#define MODEL_BPM_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_BPM_COMMAND, ModelBpmCommandClass)) +#define MODEL_IS_BPM_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_BPM_COMMAND)) +#define MODEL_IS_BPM_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_BPM_COMMAND)) +#define MODEL_BPM_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_BPM_COMMAND, ModelBpmCommandClass)) + +typedef struct _ModelBpmCommand ModelBpmCommand; +typedef struct _ModelBpmCommandClass ModelBpmCommandClass; + +struct _ModelLoaderHandler { + GObject parent_instance; + ModelLoaderHandlerPrivate * priv; +}; + +struct _ModelLoaderHandlerClass { + GObjectClass parent_class; + gboolean (*commit_library) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_marina) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_track) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_clip) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_clipfile) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_time_signature_entry) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_tempo_entry) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_click) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_library_preference) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + void (*leave_library) (ModelLoaderHandler* self); + void (*leave_marina) (ModelLoaderHandler* self); + void (*leave_track) (ModelLoaderHandler* self); + void (*leave_clip) (ModelLoaderHandler* self); + void (*leave_clipfile) (ModelLoaderHandler* self); +}; + +struct _ModelMediaLoaderHandler { + ModelLoaderHandler parent_instance; + ModelMediaLoaderHandlerPrivate * priv; + ModelProject* the_project; + ModelTrack* current_track; +}; + +struct _ModelMediaLoaderHandlerClass { + ModelLoaderHandlerClass parent_class; +}; + +struct _ModelMediaLoaderHandlerPrivate { + GeeArrayList* clipfetchers; + gint num_clipfiles_complete; +}; + +struct _Fraction { + gint numerator; + gint denominator; +}; + +struct _ModelFetcher { + GObject parent_instance; + ModelFetcherPrivate * priv; + GstElement* filesrc; + GstElement* decodebin; + GstPipeline* pipeline; + ModelClipFile* clipfile; + char* error_string; +}; + +struct _ModelFetcherClass { + GObjectClass parent_class; + void (*on_pad_added) (ModelFetcher* self, GstPad* pad); + void (*on_state_change) (ModelFetcher* self, GstBus* bus, GstMessage* message); +}; + +typedef enum { + MODEL_MEDIA_TYPE_AUDIO, + MODEL_MEDIA_TYPE_VIDEO +} ModelMediaType; + +typedef enum { + LOGGING_FACILITY_SIGNAL_HANDLERS, + LOGGING_FACILITY_DEVELOPER_WARNINGS, + LOGGING_FACILITY_GRAPH, + LOGGING_FACILITY_LOADING, + LOGGING_FACILITY_IMPORT, + LOGGING_FACILITY_SINGLEDECODEBIN +} LoggingFacility; + +typedef enum { + LOGGING_LEVEL_CRITICAL, + LOGGING_LEVEL_HIGH, + LOGGING_LEVEL_MEDIUM, + LOGGING_LEVEL_LOW, + LOGGING_LEVEL_INFO, + LOGGING_LEVEL_VERBOSE +} LoggingLevel; + +struct _ModelClipFile { + GObject parent_instance; + ModelClipFilePrivate * priv; + char* filename; + GstCaps* video_caps; + GstCaps* audio_caps; + GdkPixbuf* thumbnail; +}; + +struct _ModelClipFileClass { + GObjectClass parent_class; +}; + +struct _ModelTempoInformationIface { + GTypeInterface parent_iface; + void (*get_time_signature) (ModelTempoInformation* self, Fraction* result); + gint (*get_bpm) (ModelTempoInformation* self); +}; + +struct _TimeCode { + gint hour; + gint minute; + gint second; + gint frame; + gboolean drop_code; +}; + +struct _ModelProject { + GObject parent_instance; + ModelProjectPrivate * priv; + GeeArrayList* tracks; + GeeArrayList* inactive_tracks; + GeeArrayList* clipfiles; + ViewMediaEngine* media_engine; + char* project_file; + ModelProjectLoader* loader; + ModelUndoManager* undo_manager; + ModelLibraryImporter* importer; + Fraction default_framerate; + gboolean click_during_play; + gboolean click_during_record; + double click_volume; + gboolean library_visible; + gint library_width; + gboolean snap_to_clip; +}; + +struct _ModelProjectClass { + GObjectClass parent_class; + void (*get_clip_time) (ModelProject* self, ModelClipFile* f, TimeCode* result); + char* (*get_project_file) (ModelProject* self); + void (*do_append) (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, const char* name, gint64 insert_time); + void (*add_track) (ModelProject* self, ModelTrack* track); + void (*insert_track) (ModelProject* self, gint index, ModelTrack* track); + void (*load) (ModelProject* self, const char* fname); + void (*save) (ModelProject* self, const char* filename); + char* (*get_app_name) (ModelProject* self); + void (*load_complete) (ModelProject* self); +}; + +struct _ModelProjectPrivate { + GeeHashSet* pending; + GeeArrayList* pending_thumbs; + ModelFetcherCompletion* fetcher_completion; + gint tempo; + Fraction time_signature; +}; + +typedef enum { + PLAY_STATE_STOPPED, + PLAY_STATE_PRE_PLAY, + PLAY_STATE_PLAYING, + PLAY_STATE_PRE_RECORD_NULL, + PLAY_STATE_PRE_RECORD, + PLAY_STATE_RECORDING, + PLAY_STATE_POST_RECORD, + PLAY_STATE_PRE_EXPORT, + PLAY_STATE_EXPORTING, + PLAY_STATE_CANCEL_EXPORT, + PLAY_STATE_LOADING, + PLAY_STATE_CLOSING, + PLAY_STATE_CLOSED +} PlayState; + +struct _ModelTrack { + GObject parent_instance; + ModelTrackPrivate * priv; + ModelProject* project; + GeeArrayList* clips; + char* display_name; +}; + +struct _ModelTrackClass { + GObjectClass parent_class; + char* (*name) (ModelTrack* self); + ModelMediaType (*media_type) (ModelTrack* self); + gboolean (*check) (ModelTrack* self, ModelClip* clip); + void (*on_clip_updated) (ModelTrack* self, ModelClip* clip); + void (*write_attributes) (ModelTrack* self, FILE* f); +}; + +struct _ModelGap { + GTypeInstance parent_instance; + volatile int ref_count; + ModelGapPrivate * priv; + gint64 start; + gint64 end; +}; + +struct _ModelGapClass { + GTypeClass parent_class; + void (*finalize) (ModelGap *self); +}; + +struct _MultiFileProgressInterfaceIface { + GTypeInterface parent_iface; + void (*cancel) (MultiFileProgressInterface* self); + void (*complete) (MultiFileProgressInterface* self); +}; + +struct _ViewMediaEngine { + GObject parent_instance; + ViewMediaEnginePrivate * priv; + GstPipeline* pipeline; + GstBin* record_bin; + GstElement* converter; + GstElement* adder; + GstState gst_state; + PlayState play_state; + gint64 position; + gboolean playing; + ModelAudioTrack* record_track; + ModelClip* record_region; +}; + +struct _ViewMediaEngineClass { + GObjectClass parent_class; + void (*do_null_state_export) (ViewMediaEngine* self, gint64 length); + void (*pause) (ViewMediaEngine* self); +}; + +struct _ModelClip { + GObject parent_instance; + ModelClipPrivate * priv; + ModelClipFile* clipfile; + ModelMediaType type; + gboolean is_recording; + char* name; +}; + +struct _ModelClipClass { + GObjectClass parent_class; +}; + +struct _ModelLibraryImporter { + GObject parent_instance; + ModelLibraryImporterPrivate * priv; + ModelProject* project; + ModelClipImporter* importer; +}; + +struct _ModelLibraryImporterClass { + GObjectClass parent_class; + void (*append_existing_clipfile) (ModelLibraryImporter* self, ModelClipFile* f); + void (*on_clip_complete) (ModelLibraryImporter* self, ModelClipFile* f); +}; + + +static gpointer model_media_loader_handler_parent_class = NULL; +extern Fraction model_project_INVALID_FRAME_RATE; +Fraction model_project_INVALID_FRAME_RATE = {0}; +static gpointer model_project_parent_class = NULL; +static ModelTempoInformationIface* model_project_model_tempo_information_parent_iface = NULL; + +GType model_loader_handler_get_type (void); +GType model_media_loader_handler_get_type (void); +GType model_project_get_type (void); +GType model_track_get_type (void); +GType model_fetcher_get_type (void); +GType model_clip_fetcher_get_type (void); +#define MODEL_MEDIA_LOADER_HANDLER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_MEDIA_LOADER_HANDLER, ModelMediaLoaderHandlerPrivate)) +enum { + MODEL_MEDIA_LOADER_HANDLER_DUMMY_PROPERTY +}; +ModelLoaderHandler* model_loader_handler_new (void); +ModelLoaderHandler* model_loader_handler_construct (GType object_type); +ModelMediaLoaderHandler* model_media_loader_handler_new (ModelProject* the_project); +ModelMediaLoaderHandler* model_media_loader_handler_construct (GType object_type, ModelProject* the_project); +gint model_project_get_file_version (ModelProject* self); +static gboolean model_media_loader_handler_real_commit_marina (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +GType fraction_get_type (void); +Fraction* fraction_dup (const Fraction* self); +void fraction_free (Fraction* self); +void model_project_set_default_framerate (ModelProject* self, Fraction* rate); +void fraction_init (Fraction *self, gint numerator, gint denominator); +static gboolean model_media_loader_handler_real_commit_library (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +ModelAudioTrack* model_audio_track_new (ModelProject* project, const char* display_name); +ModelAudioTrack* model_audio_track_construct (GType object_type, ModelProject* project, const char* display_name); +GType model_audio_track_get_type (void); +void model_project_add_track (ModelProject* self, ModelTrack* track); +void _model_audio_track_set_pan (ModelAudioTrack* self, double new_value); +void _model_audio_track_set_volume (ModelAudioTrack* self, double new_volume); +void model_audio_track_set_default_num_channels (ModelAudioTrack* self, gint num); +ModelVideoTrack* model_video_track_new (ModelProject* project); +ModelVideoTrack* model_video_track_construct (GType object_type, ModelProject* project); +GType model_video_track_get_type (void); +gboolean model_loader_handler_commit_track (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +static gboolean model_media_loader_handler_real_commit_track (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +static void model_media_loader_handler_real_leave_track (ModelLoaderHandler* base); +GType model_clip_file_get_type (void); +GType model_media_type_get_type (void); +ModelMediaType model_track_media_type (ModelTrack* self); +ModelClip* model_clip_new (ModelClipFile* clipfile, ModelMediaType t, const char* name, gint64 start, gint64 media_start, gint64 duration, gboolean is_recording); +ModelClip* model_clip_construct (GType object_type, ModelClipFile* clipfile, ModelMediaType t, const char* name, gint64 start, gint64 media_start, gint64 duration, gboolean is_recording); +GType model_clip_get_type (void); +void model_track_add (ModelTrack* self, ModelClip* c, gint64 pos, gboolean select); +static gboolean model_media_loader_handler_real_commit_clip (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +GType logging_facility_get_type (void); +GType logging_level_get_type (void); +void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message); +void model_project_add_clipfile (ModelProject* self, ModelClipFile* clipfile); +static void model_media_loader_handler_fetcher_ready (ModelMediaLoaderHandler* self, ModelFetcher* f); +ModelClipFetcher* model_clip_fetcher_new (const char* filename, GError** error); +ModelClipFetcher* model_clip_fetcher_construct (GType object_type, const char* filename, GError** error); +static void _model_media_loader_handler_fetcher_ready_model_fetcher_ready (ModelFetcher* _sender, ModelFetcher* fetcher, gpointer self); +static gboolean model_media_loader_handler_real_commit_clipfile (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +void _model_project_set_bpm (ModelProject* self, gint bpm); +static gboolean model_media_loader_handler_real_commit_tempo_entry (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +void _model_project_set_time_signature (ModelProject* self, Fraction* time_signature); +void fraction_init_from_string (Fraction *self, const char* s); +static gboolean model_media_loader_handler_real_commit_time_signature_entry (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +GType model_tempo_information_get_type (void); +GType time_code_get_type (void); +TimeCode* time_code_dup (const TimeCode* self); +void time_code_free (TimeCode* self); +GType view_media_engine_get_type (void); +GType model_project_loader_get_type (void); +gpointer model_undo_manager_ref (gpointer instance); +void model_undo_manager_unref (gpointer instance); +GParamSpec* model_param_spec_undo_manager (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_undo_manager (GValue* value, gpointer v_object); +void model_value_take_undo_manager (GValue* value, gpointer v_object); +gpointer model_value_get_undo_manager (const GValue* value); +GType model_undo_manager_get_type (void); +GType model_library_importer_get_type (void); +static gboolean model_media_loader_handler_real_commit_click (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +static gboolean model_media_loader_handler_real_commit_library_preference (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +static void model_media_loader_handler_real_leave_library (ModelLoaderHandler* base); +static void model_media_loader_handler_finalize (GObject* obj); +GType model_thumbnail_fetcher_get_type (void); +gpointer model_fetcher_completion_ref (gpointer instance); +void model_fetcher_completion_unref (gpointer instance); +GParamSpec* model_param_spec_fetcher_completion (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_fetcher_completion (GValue* value, gpointer v_object); +void model_value_take_fetcher_completion (GValue* value, gpointer v_object); +gpointer model_value_get_fetcher_completion (const GValue* value); +GType model_fetcher_completion_get_type (void); +#define MODEL_PROJECT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_PROJECT, ModelProjectPrivate)) +enum { + MODEL_PROJECT_DUMMY_PROPERTY +}; +#define MODEL_PROJECT_FILLMORE_FILE_EXTENSION "fill" +#define MODEL_PROJECT_FILLMORE_FILE_FILTER "*." MODEL_PROJECT_FILLMORE_FILE_EXTENSION +#define MODEL_PROJECT_LOMBARD_FILE_EXTENSION "lom" +#define MODEL_PROJECT_LOMBARD_FILE_FILTER "*." MODEL_PROJECT_LOMBARD_FILE_EXTENSION +#define MODEL_PROJECT_license "\n" \ +"%s is free software; you can redistribute it and/or modify it under th" \ +"e \n" \ +"terms of the GNU Lesser General Public License as published by the Fre" \ +"e \n" \ +"Software Foundation; either version 2.1 of the License, or (at your op" \ +"tion) \n" \ +"any later version.\n" \ +"\n" \ +"%s is distributed in the hope that it will be useful, but WITHOUT \n" \ +"ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or " \ +"FITNESS\n" \ +"FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License f" \ +"or \n" \ +"more details.\n" \ +"\n" \ +"You should have received a copy of the GNU Lesser General Public Licen" \ +"se \n" \ +"along with %s; if not, write to the Free Software Foundation, Inc., \n" \ +"51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n" +void model_project_get_clip_time (ModelProject* self, ModelClipFile* f, TimeCode* result); +static void model_project_real_get_clip_time (ModelProject* self, ModelClipFile* f, TimeCode* result); +ModelUndoManager* model_undo_manager_new (void); +ModelUndoManager* model_undo_manager_construct (GType object_type); +ViewMediaEngine* view_media_engine_new (ModelProject* project, gboolean include_video, GError** error); +ViewMediaEngine* view_media_engine_construct (GType object_type, ModelProject* project, gboolean include_video, GError** error); +void view_media_engine_on_track_added (ViewMediaEngine* self, ModelTrack* track); +static void _view_media_engine_on_track_added_model_project_track_added (ModelProject* _sender, ModelTrack* track, gpointer self); +void model_project_on_playstate_changed (ModelProject* self); +static void _model_project_on_playstate_changed_view_media_engine_playstate_changed (ViewMediaEngine* _sender, gpointer self); +void model_project_on_error_occurred (ModelProject* self, const char* major_error, const char* minor_error); +static void _model_project_on_error_occurred_view_media_engine_error_occurred (ViewMediaEngine* _sender, const char* major_message, const char* minor_message, gpointer self); +ModelProject* model_project_construct (GType object_type, const char* filename, gboolean include_video, GError** error); +GType play_state_get_type (void); +PlayState view_media_engine_get_play_state (ViewMediaEngine* self); +static void model_project_ClearTrackMeters (ModelProject* self); +char* model_project_get_project_file (ModelProject* self); +static char* model_project_real_get_project_file (ModelProject* self); +ModelClipFile* model_project_get_clipfile (ModelProject* self, gint index); +gint model_project_get_clipfile_index (ModelProject* self, ModelClipFile* find); +ModelTrack* model_project_track_from_clip (ModelProject* self, ModelClip* clip); +void model_project_print_graph (ModelProject* self, GstBin* bin, const char* file_name); +gint64 model_track_get_length (ModelTrack* self); +gint64 model_project_get_length (ModelProject* self); +gint64 model_track_snap_clip (ModelTrack* self, ModelClip* c, gint64 span); +gint64 model_clip_get_start (ModelClip* self); +gint64 model_project_snap_clip (ModelProject* self, ModelClip* c, gint64 span); +gboolean model_track_snap_coord (ModelTrack* self, gint64* coord, gint64 span); +void model_project_snap_coord (ModelProject* self, gint64* coord, gint64 span); +gpointer model_gap_ref (gpointer instance); +void model_gap_unref (gpointer instance); +GParamSpec* model_param_spec_gap (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_gap (GValue* value, gpointer v_object); +void model_value_take_gap (GValue* value, gpointer v_object); +gpointer model_value_get_gap (const GValue* value); +GType model_gap_get_type (void); +ModelGap* model_gap_intersect (ModelGap* self, ModelGap* g); +ModelGap* model_track_find_first_gap (ModelTrack* self, gint64 start); +static ModelGap* model_project_get_gap_intersection (ModelProject* self, ModelGap* gap); +gboolean model_gap_is_empty (ModelGap* self); +gboolean model_project_can_delete_gap (ModelProject* self, ModelGap* gap); +void model_track_delete_gap (ModelTrack* self, ModelGap* g); +void model_project_delete_gap (ModelProject* self, ModelGap* gap); +gint64 model_clip_file_get_length (ModelClipFile* self); +void model_track_append_at_time (ModelTrack* self, ModelClip* c, gint64 time, gboolean select); +void model_project_do_append (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, const char* name, gint64 insert_time); +static void model_project_real_do_append (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, const char* name, gint64 insert_time); +char* isolate_filename (const char* path); +void model_project_append (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile); +void model_project_add (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, gint64 time); +void model_project_reseek (ModelProject* self); +void model_project_on_clip_removed (ModelProject* self, ModelTrack* t, ModelClip* clip); +void model_undo_manager_start_transaction (ModelUndoManager* self, const char* description); +ModelClip* model_track_get_clip_by_position (ModelTrack* self, gint64 pos); +gint64 model_project_transport_get_position (ModelProject* self); +void model_track_split_at (ModelTrack* self, gint64 position); +void model_undo_manager_end_transaction (ModelUndoManager* self, const char* description); +void model_project_split_at_playhead (ModelProject* self); +gint64 model_clip_get_end (ModelClip* self); +gint64 model_clip_get_duration (ModelClip* self); +gboolean model_project_can_trim (ModelProject* self, gboolean* left); +void model_track_trim (ModelTrack* self, ModelClip* clip, gint64 delta, GdkWindowEdge edge); +void model_project_transport_go (ModelProject* self, gint64 position); +void model_project_trim_to_playhead (ModelProject* self); +void view_media_engine_go (ViewMediaEngine* self, gint64 pos); +GType multi_file_progress_interface_get_type (void); +gboolean model_project_transport_is_playing (ModelProject* self); +gboolean model_project_transport_is_recording (ModelProject* self); +gboolean model_project_playhead_on_clip (ModelProject* self); +gboolean model_track_are_contiguous_clips (ModelTrack* self, gint64 position); +gboolean model_project_playhead_on_contiguous_clip (ModelProject* self); +char* model_track_get_display_name (ModelTrack* self); +gboolean model_project_is_duplicate_track_name (ModelProject* self, ModelTrack* track, const char* new_name); +static void _model_project_on_clip_removed_model_track_clip_removed (ModelTrack* _sender, ModelClip* clip, gpointer self); +static void _model_project_on_error_occurred_model_track_error_occurred (ModelTrack* _sender, const char* major_error, const char* minor_error, gpointer self); +static void model_project_real_add_track (ModelProject* self, ModelTrack* track); +void model_project_insert_track (ModelProject* self, gint index, ModelTrack* track); +static void model_project_real_insert_track (ModelProject* self, gint index, ModelTrack* track); +void model_track_hide (ModelTrack* self); +void model_project_add_inactive_track (ModelProject* self, ModelTrack* track); +void model_project_remove_track (ModelProject* self, ModelTrack* track); +void model_project_remove_track_at (ModelProject* self, gint index); +ModelAddClipCommand* model_add_clip_command_new (ModelProject* project, ModelClipFile* clip_file); +ModelAddClipCommand* model_add_clip_command_construct (GType object_type, ModelProject* project, ModelClipFile* clip_file); +gpointer model_command_ref (gpointer instance); +void model_command_unref (gpointer instance); +GParamSpec* model_param_spec_command (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_command (GValue* value, gpointer v_object); +void model_value_take_command (GValue* value, gpointer v_object); +gpointer model_value_get_command (const GValue* value); +GType model_command_get_type (void); +GType model_add_clip_command_get_type (void); +void model_project_do_command (ModelProject* self, ModelCommand* the_command); +gboolean model_clip_file_is_online (ModelClipFile* self); +gboolean model_clip_file_is_of_type (ModelClipFile* self, ModelMediaType t); +ModelThumbnailFetcher* model_thumbnail_fetcher_new (ModelClipFile* f, gint64 time, GError** error); +ModelThumbnailFetcher* model_thumbnail_fetcher_construct (GType object_type, ModelClipFile* f, gint64 time, GError** error); +static void model_project_on_thumbnail_ready (ModelProject* self, ModelFetcher* f); +static void _model_project_on_thumbnail_ready_model_fetcher_ready (ModelFetcher* _sender, ModelFetcher* fetcher, gpointer self); +void _model_project_add_clipfile (ModelProject* self, ModelClipFile* clipfile, GError** error); +ModelClipFile* model_project_find_clipfile (ModelProject* self, const char* filename); +gboolean model_project_clipfile_on_track (ModelProject* self, const char* filename); +void model_track_delete_clip (ModelTrack* self, ModelClip* clip); +static void model_project_delete_clipfile_from_tracks (ModelProject* self, ModelClipFile* cf); +void _model_project_remove_clipfile (ModelProject* self, ModelClipFile* cf); +ModelClipFileDeleteCommand* model_clip_file_delete_command_new (ModelProject* p, ModelClipFile* cf); +ModelClipFileDeleteCommand* model_clip_file_delete_command_construct (GType object_type, ModelProject* p, ModelClipFile* cf); +GType model_clip_file_delete_command_get_type (void); +void model_project_remove_clipfile (ModelProject* self, const char* filename); +void model_project_go_start (ModelProject* self); +void model_project_go_end (ModelProject* self); +gint64 model_track_previous_edit (ModelTrack* self, gint64 pos); +void model_project_go_previous (ModelProject* self); +gint64 model_track_next_edit (ModelTrack* self, gint64 pos); +void model_project_go_next (ModelProject* self); +void model_project_set_name (ModelProject* self, const char* filename); +char* model_project_get_app_name (ModelProject* self); +char* model_project_get_file_display_name (ModelProject* self); +void view_media_engine_set_gst_state (ViewMediaEngine* self, GstState state); +void model_track_delete_all_clips (ModelTrack* self); +void model_project_clear (ModelProject* self); +gboolean model_project_can_export (ModelProject* self); +void model_project_on_load_started (ModelProject* self, const char* filename); +static void model_project_on_load_error (ModelProject* self, const char* _error_); +void model_undo_manager_reset (ModelUndoManager* self); +static void model_project_on_load_complete (ModelProject* self); +ModelProjectLoader* model_project_loader_new (ModelLoaderHandler* loader_handler, const char* file_name); +ModelProjectLoader* model_project_loader_construct (GType object_type, ModelLoaderHandler* loader_handler, const char* file_name); +static void _model_project_on_load_started_model_project_loader_load_started (ModelProjectLoader* _sender, const char* filename, gpointer self); +static void _model_project_on_load_error_model_project_loader_load_error (ModelProjectLoader* _sender, const char* _error_, gpointer self); +static void _model_project_on_load_complete_model_project_loader_load_complete (ModelProjectLoader* _sender, gpointer self); +void view_media_engine_on_load_complete (ViewMediaEngine* self); +static void _view_media_engine_on_load_complete_model_project_loader_load_complete (ModelProjectLoader* _sender, gpointer self); +void view_media_engine_set_play_state (ViewMediaEngine* self, PlayState play_state); +void model_project_loader_load (ModelProjectLoader* self); +void model_project_load (ModelProject* self, const char* fname); +static void model_project_real_load (ModelProject* self, const char* fname); +gboolean model_video_track_get_framerate (ModelVideoTrack* self, Fraction* rate); +gboolean fraction_equal (Fraction *self, Fraction* f); +void model_project_save_library (ModelProject* self, FILE* f); +void model_track_save (ModelTrack* self, FILE* f); +char* fraction_to_string (Fraction *self); +void model_undo_manager_mark_clean (ModelUndoManager* self); +void model_project_save (ModelProject* self, const char* filename); +static void model_project_real_save (ModelProject* self, const char* filename); +void view_media_engine_close (ViewMediaEngine* self); +void model_project_close (ModelProject* self); +void model_fetcher_completion_complete (ModelFetcherCompletion* self, ModelFetcher* fetcher); +void model_project_on_importer_clip_complete (ModelProject* self, ModelClipFetcher* fetcher); +static void model_project_on_fetcher_ready (ModelProject* self, ModelFetcher* fetcher); +static void _model_project_on_fetcher_ready_model_fetcher_ready (ModelFetcher* _sender, ModelFetcher* fetcher, gpointer self); +void model_project_create_clip_fetcher (ModelProject* self, ModelFetcherCompletion* fetcher_completion, const char* filename, GError** error); +char* get_file_extension (const char* path); +gboolean model_project_is_project_extension (ModelProject* self, const char* filename); +void model_undo_manager_do_command (ModelUndoManager* self, ModelCommand* the_command); +void model_undo_manager_undo (ModelUndoManager* self); +void model_project_undo (ModelProject* self); +ModelTimelineImporter* model_timeline_importer_new (ModelTrack* track, ModelProject* p, gint64 time_to_add, gboolean both_tracks); +ModelTimelineImporter* model_timeline_importer_construct (GType object_type, ModelTrack* track, ModelProject* p, gint64 time_to_add, gboolean both_tracks); +GType model_timeline_importer_get_type (void); +ModelLibraryImporter* model_library_importer_new (ModelProject* p); +ModelLibraryImporter* model_library_importer_construct (GType object_type, ModelProject* p); +GType model_clip_importer_get_type (void); +MultiFileProgress* multi_file_progress_new (GtkWindow* parent, gint num_files, const char* dialog_title, MultiFileProgressInterface* provider); +MultiFileProgress* multi_file_progress_construct (GType object_type, GtkWindow* parent, gint num_files, const char* dialog_title, MultiFileProgressInterface* provider); +GType multi_file_progress_get_type (void); +void model_project_create_clip_importer (ModelProject* self, ModelTrack* track, gboolean timeline_add, gint64 time_to_add, gboolean both_tracks, GtkWindow* progress_window_parent, gint number); +char* model_project_get_version (ModelProject* self); +static char* model_project_real_get_app_name (ModelProject* self); +char* model_project_get_license (ModelProject* self); +ModelTimeSignatureCommand* model_time_signature_command_new (ModelProject* project, Fraction* new_time_signature); +ModelTimeSignatureCommand* model_time_signature_command_construct (GType object_type, ModelProject* project, Fraction* new_time_signature); +GType model_time_signature_command_get_type (void); +void model_project_set_time_signature (ModelProject* self, Fraction* time_signature); +static void model_project_real_get_time_signature (ModelTempoInformation* base, Fraction* result); +ModelBpmCommand* model_bpm_command_new (ModelProject* project, gint new_bpm); +ModelBpmCommand* model_bpm_command_construct (GType object_type, ModelProject* project, gint new_bpm); +GType model_bpm_command_get_type (void); +void model_project_set_bpm (ModelProject* self, gint bpm); +static gint model_project_real_get_bpm (ModelTempoInformation* base); +static char* model_project_get_path (ModelProject* self); +char* model_project_get_audio_path (ModelProject* self); +ModelVideoTrack* model_project_find_video_track (ModelProject* self); +ModelAudioTrack* model_project_find_audio_track (ModelProject* self); +void model_project_load_complete (ModelProject* self); +static void model_project_real_load_complete (ModelProject* self); +static void model_project_finalize (GObject* obj); +static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func); +static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func); +static gint _vala_array_length (gpointer array); +static int _vala_strcmp0 (const char * str1, const char * str2); + +const char* MODEL_PROJECT_authors[5] = {"Robert Powell ", "Adam Dingle ", "Andrew O'Mahony ", "Dru Moore ", NULL}; + +static void g_cclosure_user_marshal_VOID__STRING_STRING (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data); + +#line 19 "project.vala" +ModelMediaLoaderHandler* model_media_loader_handler_construct (GType object_type, ModelProject* the_project) { +#line 871 "project.c" + ModelMediaLoaderHandler * self; + ModelTrack* _tmp0_; +#line 19 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (the_project), NULL); +#line 19 "project.vala" + self = (ModelMediaLoaderHandler*) model_loader_handler_construct (object_type); +#line 20 "project.vala" + self->the_project = the_project; +#line 21 "project.vala" + self->current_track = (_tmp0_ = NULL, _g_object_unref0 (self->current_track), _tmp0_); +#line 882 "project.c" + return self; +} + + +#line 19 "project.vala" +ModelMediaLoaderHandler* model_media_loader_handler_new (ModelProject* the_project) { +#line 19 "project.vala" + return model_media_loader_handler_construct (MODEL_TYPE_MEDIA_LOADER_HANDLER, the_project); +#line 891 "project.c" +} + + +#line 24 "project.vala" +static gboolean model_media_loader_handler_real_commit_marina (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 897 "project.c" + ModelMediaLoaderHandler * self; + gboolean result = FALSE; + gint number_of_attributes; + gboolean _tmp0_ = FALSE; + self = MODEL_MEDIA_LOADER_HANDLER (base); +#line 25 "project.vala" + number_of_attributes = attr_names_length1; +#line 26 "project.vala" + if (number_of_attributes != 1) { +#line 26 "project.vala" + _tmp0_ = TRUE; +#line 909 "project.c" + } else { +#line 27 "project.vala" + _tmp0_ = _vala_strcmp0 (attr_names[0], "version") != 0; +#line 913 "project.c" + } +#line 26 "project.vala" + if (_tmp0_) { +#line 28 "project.vala" + g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "Missing version information"); +#line 919 "project.c" + result = FALSE; +#line 29 "project.vala" + return result; +#line 923 "project.c" + } +#line 32 "project.vala" + if (model_project_get_file_version (self->the_project) < atoi (attr_values[0])) { +#line 927 "project.c" + char* _tmp1_; +#line 33 "project.vala" + g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", _tmp1_ = g_strdup_printf ("Version mismatch! (File Version: %d, App Version: %d)", model_project_get_file_version (self->the_project), atoi (attr_values[0]))); +#line 931 "project.c" + _g_free0 (_tmp1_); + result = FALSE; +#line 35 "project.vala" + return result; +#line 936 "project.c" + } +#line 38 "project.vala" + self->priv->num_clipfiles_complete = 0; +#line 940 "project.c" + result = TRUE; +#line 39 "project.vala" + return result; +#line 944 "project.c" +} + + +#line 42 "project.vala" +static gboolean model_media_loader_handler_real_commit_library (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 950 "project.c" + ModelMediaLoaderHandler * self; + gboolean result = FALSE; + char** _tmp1_; + gint _arr_size_; + gint arr_length1; + char** _tmp0_; + char** arr; + Fraction _tmp3_; + Fraction _tmp2_ = {0}; + self = MODEL_MEDIA_LOADER_HANDLER (base); +#line 44 "project.vala" + if (attr_names_length1 != 1) { +#line 963 "project.c" + result = TRUE; +#line 45 "project.vala" + return result; +#line 967 "project.c" + } +#line 47 "project.vala" + if (_vala_strcmp0 (attr_names[0], "framerate") != 0) { +#line 48 "project.vala" + g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "Missing framerate tag"); +#line 973 "project.c" + result = FALSE; +#line 49 "project.vala" + return result; +#line 977 "project.c" + } + arr = (_tmp1_ = _tmp0_ = g_strsplit (attr_values[0], "/", 0), arr_length1 = _vala_array_length (_tmp0_), _arr_size_ = arr_length1, _tmp1_); +#line 53 "project.vala" + if (arr_length1 != 2) { +#line 54 "project.vala" + g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "Invalid framerate attribute"); +#line 984 "project.c" + result = FALSE; + arr = (_vala_array_free (arr, arr_length1, (GDestroyNotify) g_free), NULL); +#line 55 "project.vala" + return result; +#line 989 "project.c" + } +#line 58 "project.vala" + model_project_set_default_framerate (self->the_project, (_tmp3_ = (fraction_init (&_tmp2_, atoi (arr[0]), atoi (arr[1])), _tmp2_), &_tmp3_)); +#line 993 "project.c" + result = TRUE; + arr = (_vala_array_free (arr, arr_length1, (GDestroyNotify) g_free), NULL); +#line 59 "project.vala" + return result; +#line 998 "project.c" +} + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 62 "project.vala" +static gboolean model_media_loader_handler_real_commit_track (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 1009 "project.c" + ModelMediaLoaderHandler * self; + gboolean result = FALSE; + gint number_of_attributes; + char* name; + char* type; + self = MODEL_MEDIA_LOADER_HANDLER (base); +#line 63 "project.vala" + g_assert (self->current_track == NULL); +#line 65 "project.vala" + number_of_attributes = attr_names_length1; +#line 66 "project.vala" + name = NULL; +#line 67 "project.vala" + type = NULL; +#line 1024 "project.c" + { + gint i; +#line 68 "project.vala" + i = 0; +#line 1029 "project.c" + { + gboolean _tmp0_; +#line 68 "project.vala" + _tmp0_ = TRUE; +#line 68 "project.vala" + while (TRUE) { +#line 1036 "project.c" + GQuark _tmp4_; + const char* _tmp3_; + static GQuark _tmp4__label0 = 0; + static GQuark _tmp4__label1 = 0; +#line 68 "project.vala" + if (!_tmp0_) { +#line 68 "project.vala" + i = i + 1; +#line 1045 "project.c" + } +#line 68 "project.vala" + _tmp0_ = FALSE; +#line 68 "project.vala" + if (!(i < number_of_attributes)) { +#line 68 "project.vala" + break; +#line 1053 "project.c" + } + _tmp3_ = attr_names[i]; + _tmp4_ = (NULL == _tmp3_) ? 0 : g_quark_from_string (_tmp3_); + if (_tmp4_ == ((0 != _tmp4__label0) ? _tmp4__label0 : (_tmp4__label0 = g_quark_from_static_string ("type")))) + switch (0) { + default: + { + char* _tmp1_; +#line 71 "project.vala" + type = (_tmp1_ = g_strdup (attr_values[i]), _g_free0 (type), _tmp1_); +#line 72 "project.vala" + break; +#line 1066 "project.c" + } + } else if (_tmp4_ == ((0 != _tmp4__label1) ? _tmp4__label1 : (_tmp4__label1 = g_quark_from_static_string ("name")))) + switch (0) { + default: + { + char* _tmp2_; +#line 74 "project.vala" + name = (_tmp2_ = g_strdup (attr_values[i]), _g_free0 (name), _tmp2_); +#line 75 "project.vala" + break; +#line 1077 "project.c" + } + } else + switch (0) { + default: + { +#line 77 "project.vala" + break; +#line 1085 "project.c" + } + } + } + } + } +#line 81 "project.vala" + if (name == NULL) { +#line 82 "project.vala" + g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "Missing track name"); +#line 1095 "project.c" + result = FALSE; + _g_free0 (name); + _g_free0 (type); +#line 83 "project.vala" + return result; +#line 1101 "project.c" + } +#line 86 "project.vala" + if (type == NULL) { +#line 87 "project.vala" + g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "Missing track type"); +#line 1107 "project.c" + result = FALSE; + _g_free0 (name); + _g_free0 (type); +#line 88 "project.vala" + return result; +#line 1113 "project.c" + } +#line 91 "project.vala" + if (_vala_strcmp0 (type, "audio") == 0) { +#line 1117 "project.c" + ModelAudioTrack* audio_track; + ModelTrack* _tmp5_; +#line 92 "project.vala" + audio_track = model_audio_track_new (self->the_project, name); +#line 93 "project.vala" + self->current_track = (_tmp5_ = _g_object_ref0 (MODEL_TRACK (audio_track)), _g_object_unref0 (self->current_track), _tmp5_); +#line 94 "project.vala" + model_project_add_track (self->the_project, self->current_track); +#line 1126 "project.c" + { + gint i; +#line 96 "project.vala" + i = 0; +#line 1131 "project.c" + { + gboolean _tmp6_; +#line 96 "project.vala" + _tmp6_ = TRUE; +#line 96 "project.vala" + while (TRUE) { +#line 1138 "project.c" + GQuark _tmp8_; + const char* _tmp7_; + static GQuark _tmp8__label0 = 0; + static GQuark _tmp8__label1 = 0; + static GQuark _tmp8__label2 = 0; +#line 96 "project.vala" + if (!_tmp6_) { +#line 96 "project.vala" + i = i + 1; +#line 1148 "project.c" + } +#line 96 "project.vala" + _tmp6_ = FALSE; +#line 96 "project.vala" + if (!(i < number_of_attributes)) { +#line 96 "project.vala" + break; +#line 1156 "project.c" + } + _tmp7_ = attr_names[i]; + _tmp8_ = (NULL == _tmp7_) ? 0 : g_quark_from_string (_tmp7_); + if (_tmp8_ == ((0 != _tmp8__label0) ? _tmp8__label0 : (_tmp8__label0 = g_quark_from_static_string ("panorama")))) + switch (0) { + default: + { +#line 99 "project.vala" + _model_audio_track_set_pan (audio_track, g_ascii_strtod (attr_values[i], NULL)); +#line 100 "project.vala" + break; +#line 1168 "project.c" + } + } else if (_tmp8_ == ((0 != _tmp8__label1) ? _tmp8__label1 : (_tmp8__label1 = g_quark_from_static_string ("volume")))) + switch (0) { + default: + { +#line 102 "project.vala" + _model_audio_track_set_volume (audio_track, g_ascii_strtod (attr_values[i], NULL)); +#line 103 "project.vala" + break; +#line 1178 "project.c" + } + } else if (_tmp8_ == ((0 != _tmp8__label2) ? _tmp8__label2 : (_tmp8__label2 = g_quark_from_static_string ("channels")))) + switch (0) { + default: + { +#line 105 "project.vala" + model_audio_track_set_default_num_channels (audio_track, atoi (attr_values[i])); +#line 106 "project.vala" + break; +#line 1188 "project.c" + } + } else + switch (0) { + default: + { +#line 108 "project.vala" + break; +#line 1196 "project.c" + } + } + } + } + } + result = TRUE; + _g_object_unref0 (audio_track); + _g_free0 (name); + _g_free0 (type); +#line 111 "project.vala" + return result; +#line 1208 "project.c" + } else { +#line 112 "project.vala" + if (_vala_strcmp0 (type, "video") == 0) { +#line 1212 "project.c" + ModelTrack* _tmp9_; +#line 113 "project.vala" + self->current_track = (_tmp9_ = MODEL_TRACK (model_video_track_new (self->the_project)), _g_object_unref0 (self->current_track), _tmp9_); +#line 114 "project.vala" + model_project_add_track (self->the_project, self->current_track); +#line 1218 "project.c" + } + } + result = MODEL_LOADER_HANDLER_CLASS (model_media_loader_handler_parent_class)->commit_track (MODEL_LOADER_HANDLER (self), attr_names, attr_names_length1, attr_values, attr_values_length1); + _g_free0 (name); + _g_free0 (type); +#line 117 "project.vala" + return result; +#line 1226 "project.c" +} + + +#line 120 "project.vala" +static void model_media_loader_handler_real_leave_track (ModelLoaderHandler* base) { +#line 1232 "project.c" + ModelMediaLoaderHandler * self; + ModelTrack* _tmp0_; + self = MODEL_MEDIA_LOADER_HANDLER (base); +#line 121 "project.vala" + g_assert (self->current_track != NULL); +#line 122 "project.vala" + self->current_track = (_tmp0_ = NULL, _g_object_unref0 (self->current_track), _tmp0_); +#line 1240 "project.c" +} + + +#line 125 "project.vala" +static gboolean model_media_loader_handler_real_commit_clip (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 1246 "project.c" + ModelMediaLoaderHandler * self; + gboolean result = FALSE; + gint number_of_attributes; + gint id; + char* clip_name; + gint64 start; + gint64 media_start; + gint64 duration; + ModelClipFetcher* _tmp6_; + ModelClip* _tmp7_; + ModelClip* clip; + self = MODEL_MEDIA_LOADER_HANDLER (base); +#line 126 "project.vala" + g_assert (self->current_track != NULL); +#line 128 "project.vala" + number_of_attributes = attr_names_length1; +#line 129 "project.vala" + id = -1; +#line 130 "project.vala" + clip_name = NULL; +#line 131 "project.vala" + start = (gint64) (-1); +#line 132 "project.vala" + media_start = (gint64) (-1); +#line 133 "project.vala" + duration = (gint64) (-1); +#line 1273 "project.c" + { + gint i; +#line 134 "project.vala" + i = 0; +#line 1278 "project.c" + { + gboolean _tmp0_; +#line 134 "project.vala" + _tmp0_ = TRUE; +#line 134 "project.vala" + while (TRUE) { +#line 1285 "project.c" + GQuark _tmp4_; + const char* _tmp3_; + static GQuark _tmp4__label0 = 0; + static GQuark _tmp4__label1 = 0; + static GQuark _tmp4__label2 = 0; + static GQuark _tmp4__label3 = 0; + static GQuark _tmp4__label4 = 0; +#line 134 "project.vala" + if (!_tmp0_) { +#line 134 "project.vala" + i++; +#line 1297 "project.c" + } +#line 134 "project.vala" + _tmp0_ = FALSE; +#line 134 "project.vala" + if (!(i < number_of_attributes)) { +#line 134 "project.vala" + break; +#line 1305 "project.c" + } + _tmp3_ = attr_names[i]; + _tmp4_ = (NULL == _tmp3_) ? 0 : g_quark_from_string (_tmp3_); + if (_tmp4_ == ((0 != _tmp4__label0) ? _tmp4__label0 : (_tmp4__label0 = g_quark_from_static_string ("id")))) + switch (0) { + default: + { +#line 137 "project.vala" + id = atoi (attr_values[i]); +#line 138 "project.vala" + break; +#line 1317 "project.c" + } + } else if (_tmp4_ == ((0 != _tmp4__label1) ? _tmp4__label1 : (_tmp4__label1 = g_quark_from_static_string ("name")))) + switch (0) { + default: + { + char* _tmp1_; +#line 140 "project.vala" + clip_name = (_tmp1_ = g_strdup (attr_values[i]), _g_free0 (clip_name), _tmp1_); +#line 141 "project.vala" + break; +#line 1328 "project.c" + } + } else if (_tmp4_ == ((0 != _tmp4__label2) ? _tmp4__label2 : (_tmp4__label2 = g_quark_from_static_string ("start")))) + switch (0) { + default: + { +#line 143 "project.vala" + start = g_ascii_strtoll (attr_values[i], NULL, 0); +#line 144 "project.vala" + break; +#line 1338 "project.c" + } + } else if (_tmp4_ == ((0 != _tmp4__label3) ? _tmp4__label3 : (_tmp4__label3 = g_quark_from_static_string ("media-start")))) + switch (0) { + default: + { +#line 146 "project.vala" + media_start = g_ascii_strtoll (attr_values[i], NULL, 0); +#line 147 "project.vala" + break; +#line 1348 "project.c" + } + } else if (_tmp4_ == ((0 != _tmp4__label4) ? _tmp4__label4 : (_tmp4__label4 = g_quark_from_static_string ("duration")))) + switch (0) { + default: + { +#line 149 "project.vala" + duration = g_ascii_strtoll (attr_values[i], NULL, 0); +#line 150 "project.vala" + break; +#line 1358 "project.c" + } + } else + switch (0) { + default: + { + char* _tmp2_; +#line 153 "project.vala" + g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", _tmp2_ = g_strdup_printf ("Unknown attribute %s", attr_names[i])); +#line 1367 "project.c" + _g_free0 (_tmp2_); + result = FALSE; + _g_free0 (clip_name); +#line 154 "project.vala" + return result; +#line 1373 "project.c" + } + } + } + } + } +#line 158 "project.vala" + if (id == (-1)) { +#line 159 "project.vala" + g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "missing clip id"); +#line 1383 "project.c" + result = FALSE; + _g_free0 (clip_name); +#line 160 "project.vala" + return result; +#line 1388 "project.c" + } +#line 163 "project.vala" + if (clip_name == NULL) { +#line 164 "project.vala" + g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "missing clip_name"); +#line 1394 "project.c" + result = FALSE; + _g_free0 (clip_name); +#line 165 "project.vala" + return result; +#line 1399 "project.c" + } +#line 168 "project.vala" + if (start == (-1)) { +#line 169 "project.vala" + g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "missing start time"); +#line 1405 "project.c" + result = FALSE; + _g_free0 (clip_name); +#line 170 "project.vala" + return result; +#line 1410 "project.c" + } +#line 173 "project.vala" + if (media_start == (-1)) { +#line 174 "project.vala" + g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "missing media_start"); +#line 1416 "project.c" + result = FALSE; + _g_free0 (clip_name); +#line 175 "project.vala" + return result; +#line 1421 "project.c" + } +#line 178 "project.vala" + if (duration == (-1)) { +#line 179 "project.vala" + g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "missing duration"); +#line 1427 "project.c" + result = FALSE; + _g_free0 (clip_name); +#line 180 "project.vala" + return result; +#line 1432 "project.c" + } +#line 183 "project.vala" + if (id >= gee_collection_get_size (GEE_COLLECTION (self->priv->clipfetchers))) { +#line 1436 "project.c" + char* _tmp5_; +#line 184 "project.vala" + g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", _tmp5_ = g_strdup_printf ("clip file id %s was not loaded", clip_name)); +#line 1440 "project.c" + _g_free0 (_tmp5_); + result = FALSE; + _g_free0 (clip_name); +#line 185 "project.vala" + return result; +#line 1446 "project.c" + } +#line 188 "project.vala" + clip = (_tmp7_ = model_clip_new (MODEL_FETCHER (_tmp6_ = (ModelClipFetcher*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->priv->clipfetchers), id))->clipfile, model_track_media_type (self->current_track), clip_name, start, media_start, duration, FALSE), _g_object_unref0 (_tmp6_), _tmp7_); +#line 190 "project.vala" + model_track_add (self->current_track, clip, start, FALSE); +#line 1452 "project.c" + result = TRUE; + _g_free0 (clip_name); + _g_object_unref0 (clip); +#line 191 "project.vala" + return result; +#line 1458 "project.c" +} + + +#line 194 "project.vala" +static void model_media_loader_handler_fetcher_ready (ModelMediaLoaderHandler* self, ModelFetcher* f) { +#line 194 "project.vala" + g_return_if_fail (MODEL_IS_MEDIA_LOADER_HANDLER (self)); +#line 194 "project.vala" + g_return_if_fail (MODEL_IS_FETCHER (f)); +#line 195 "project.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "fetcher_ready"); +#line 196 "project.vala" + if (f->error_string != NULL) { +#line 1472 "project.c" + char* _tmp0_; +#line 197 "project.vala" + g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", _tmp0_ = g_strdup_printf ("Could not load %s.", f->clipfile->filename)); +#line 1476 "project.c" + _g_free0 (_tmp0_); +#line 198 "project.vala" + g_warning ("project.vala:198: Could not load %s: %s", f->clipfile->filename, f->error_string); +#line 1480 "project.c" + } +#line 200 "project.vala" + model_project_add_clipfile (self->the_project, f->clipfile); +#line 201 "project.vala" + self->priv->num_clipfiles_complete++; +#line 202 "project.vala" + if (self->priv->num_clipfiles_complete == gee_collection_get_size (GEE_COLLECTION (self->priv->clipfetchers))) { +#line 203 "project.vala" + g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "complete"); +#line 1490 "project.c" + } +} + + +#line 194 "project.vala" +static void _model_media_loader_handler_fetcher_ready_model_fetcher_ready (ModelFetcher* _sender, ModelFetcher* fetcher, gpointer self) { +#line 1497 "project.c" + model_media_loader_handler_fetcher_ready (self, fetcher); +} + + +#line 207 "project.vala" +static gboolean model_media_loader_handler_real_commit_clipfile (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 1504 "project.c" + ModelMediaLoaderHandler * self; + gboolean result = FALSE; + GError * _inner_error_; + char* filename; + gint id; + self = MODEL_MEDIA_LOADER_HANDLER (base); + _inner_error_ = NULL; +#line 208 "project.vala" + filename = NULL; +#line 209 "project.vala" + id = -1; +#line 1516 "project.c" + { + gint i; +#line 211 "project.vala" + i = 0; +#line 1521 "project.c" + { + gboolean _tmp0_; +#line 211 "project.vala" + _tmp0_ = TRUE; +#line 211 "project.vala" + while (TRUE) { +#line 211 "project.vala" + if (!_tmp0_) { +#line 211 "project.vala" + i++; +#line 1532 "project.c" + } +#line 211 "project.vala" + _tmp0_ = FALSE; +#line 211 "project.vala" + if (!(i < attr_names_length1)) { +#line 211 "project.vala" + break; +#line 1540 "project.c" + } +#line 212 "project.vala" + if (_vala_strcmp0 (attr_names[i], "filename") == 0) { +#line 1544 "project.c" + char* _tmp1_; +#line 213 "project.vala" + filename = (_tmp1_ = g_strdup (attr_values[i]), _g_free0 (filename), _tmp1_); +#line 1548 "project.c" + } else { +#line 214 "project.vala" + if (_vala_strcmp0 (attr_names[i], "id") == 0) { +#line 215 "project.vala" + id = atoi (attr_values[i]); +#line 1554 "project.c" + } + } + } + } + } +#line 219 "project.vala" + if (filename == NULL) { +#line 220 "project.vala" + g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "Invalid clipfile filename"); +#line 1564 "project.c" + result = FALSE; + _g_free0 (filename); +#line 221 "project.vala" + return result; +#line 1569 "project.c" + } +#line 224 "project.vala" + if (id < 0) { +#line 225 "project.vala" + g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "Invalid clipfile id"); +#line 1575 "project.c" + result = FALSE; + _g_free0 (filename); +#line 226 "project.vala" + return result; +#line 1580 "project.c" + } + { + ModelClipFetcher* fetcher; +#line 230 "project.vala" + fetcher = model_clip_fetcher_new (filename, &_inner_error_); +#line 1586 "project.c" + if (_inner_error_ != NULL) { + goto __catch14_g_error; + } +#line 231 "project.vala" + g_signal_connect_object (MODEL_FETCHER (fetcher), "ready", (GCallback) _model_media_loader_handler_fetcher_ready_model_fetcher_ready, self, 0); +#line 232 "project.vala" + gee_abstract_list_insert (GEE_ABSTRACT_LIST (self->priv->clipfetchers), id, fetcher); +#line 1594 "project.c" + _g_object_unref0 (fetcher); + } + goto __finally14; + __catch14_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { +#line 234 "project.vala" + g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", e->message); +#line 1606 "project.c" + result = FALSE; + _g_error_free0 (e); + _g_free0 (filename); +#line 235 "project.vala" + return result; +#line 1612 "project.c" + } + } + __finally14: + if (_inner_error_ != NULL) { + _g_free0 (filename); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return FALSE; + } + result = TRUE; + _g_free0 (filename); +#line 237 "project.vala" + return result; +#line 1626 "project.c" +} + + +#line 240 "project.vala" +static gboolean model_media_loader_handler_real_commit_tempo_entry (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 1632 "project.c" + ModelMediaLoaderHandler * self; + gboolean result = FALSE; + self = MODEL_MEDIA_LOADER_HANDLER (base); +#line 241 "project.vala" + if (_vala_strcmp0 (attr_names[0], "tempo") != 0) { +#line 242 "project.vala" + g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "Invalid attribute on tempo entry"); +#line 1640 "project.c" + result = FALSE; +#line 243 "project.vala" + return result; +#line 1644 "project.c" + } +#line 246 "project.vala" + _model_project_set_bpm (self->the_project, atoi (attr_values[0])); +#line 1648 "project.c" + result = TRUE; +#line 247 "project.vala" + return result; +#line 1652 "project.c" +} + + +#line 250 "project.vala" +static gboolean model_media_loader_handler_real_commit_time_signature_entry (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 1658 "project.c" + ModelMediaLoaderHandler * self; + gboolean result = FALSE; + Fraction _tmp1_; + Fraction _tmp0_ = {0}; + self = MODEL_MEDIA_LOADER_HANDLER (base); +#line 251 "project.vala" + if (_vala_strcmp0 (attr_names[0], "signature") != 0) { +#line 252 "project.vala" + g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", "Invalid attribute on time signature"); +#line 1668 "project.c" + result = FALSE; +#line 253 "project.vala" + return result; +#line 1672 "project.c" + } +#line 256 "project.vala" + _model_project_set_time_signature (self->the_project, (_tmp1_ = (fraction_init_from_string (&_tmp0_, attr_values[0]), _tmp0_), &_tmp1_)); +#line 1676 "project.c" + result = TRUE; +#line 257 "project.vala" + return result; +#line 1680 "project.c" +} + + +#line 260 "project.vala" +static gboolean model_media_loader_handler_real_commit_click (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 1686 "project.c" + ModelMediaLoaderHandler * self; + gboolean result = FALSE; + self = MODEL_MEDIA_LOADER_HANDLER (base); + { + gint i; +#line 261 "project.vala" + i = 0; +#line 1694 "project.c" + { + gboolean _tmp0_; +#line 261 "project.vala" + _tmp0_ = TRUE; +#line 261 "project.vala" + while (TRUE) { +#line 1701 "project.c" + GQuark _tmp3_; + const char* _tmp2_; + static GQuark _tmp3__label0 = 0; + static GQuark _tmp3__label1 = 0; + static GQuark _tmp3__label2 = 0; +#line 261 "project.vala" + if (!_tmp0_) { +#line 261 "project.vala" + i = i + 1; +#line 1711 "project.c" + } +#line 261 "project.vala" + _tmp0_ = FALSE; +#line 261 "project.vala" + if (!(i < attr_names_length1)) { +#line 261 "project.vala" + break; +#line 1719 "project.c" + } + _tmp2_ = attr_names[i]; + _tmp3_ = (NULL == _tmp2_) ? 0 : g_quark_from_string (_tmp2_); + if (_tmp3_ == ((0 != _tmp3__label0) ? _tmp3__label0 : (_tmp3__label0 = g_quark_from_static_string ("on_play")))) + switch (0) { + default: + { +#line 264 "project.vala" + self->the_project->click_during_play = _vala_strcmp0 (attr_values[i], "true") == 0; +#line 265 "project.vala" + break; +#line 1731 "project.c" + } + } else if (_tmp3_ == ((0 != _tmp3__label1) ? _tmp3__label1 : (_tmp3__label1 = g_quark_from_static_string ("on_record")))) + switch (0) { + default: + { +#line 267 "project.vala" + self->the_project->click_during_record = _vala_strcmp0 (attr_values[i], "true") == 0; +#line 268 "project.vala" + break; +#line 1741 "project.c" + } + } else if (_tmp3_ == ((0 != _tmp3__label2) ? _tmp3__label2 : (_tmp3__label2 = g_quark_from_static_string ("volume")))) + switch (0) { + default: + { +#line 270 "project.vala" + self->the_project->click_volume = g_ascii_strtod (attr_values[i], NULL); +#line 271 "project.vala" + break; +#line 1751 "project.c" + } + } else + switch (0) { + default: + { + char* _tmp1_; +#line 273 "project.vala" + g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", _tmp1_ = g_strdup_printf ("unknown attribute for click '%s'", attr_names[i])); +#line 1760 "project.c" + _g_free0 (_tmp1_); + result = FALSE; +#line 274 "project.vala" + return result; +#line 1765 "project.c" + } + } + } + } + } + result = TRUE; +#line 277 "project.vala" + return result; +#line 1774 "project.c" +} + + +#line 280 "project.vala" +static gboolean model_media_loader_handler_real_commit_library_preference (ModelLoaderHandler* base, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 1780 "project.c" + ModelMediaLoaderHandler * self; + gboolean result = FALSE; + self = MODEL_MEDIA_LOADER_HANDLER (base); + { + gint i; +#line 281 "project.vala" + i = 0; +#line 1788 "project.c" + { + gboolean _tmp0_; +#line 281 "project.vala" + _tmp0_ = TRUE; +#line 281 "project.vala" + while (TRUE) { +#line 1795 "project.c" + GQuark _tmp3_; + const char* _tmp2_; + static GQuark _tmp3__label0 = 0; + static GQuark _tmp3__label1 = 0; +#line 281 "project.vala" + if (!_tmp0_) { +#line 281 "project.vala" + i = i + 1; +#line 1804 "project.c" + } +#line 281 "project.vala" + _tmp0_ = FALSE; +#line 281 "project.vala" + if (!(i < attr_names_length1)) { +#line 281 "project.vala" + break; +#line 1812 "project.c" + } + _tmp2_ = attr_names[i]; + _tmp3_ = (NULL == _tmp2_) ? 0 : g_quark_from_string (_tmp2_); + if (_tmp3_ == ((0 != _tmp3__label0) ? _tmp3__label0 : (_tmp3__label0 = g_quark_from_static_string ("width")))) + switch (0) { + default: + { +#line 284 "project.vala" + self->the_project->library_width = atoi (attr_values[i]); +#line 285 "project.vala" + break; +#line 1824 "project.c" + } + } else if (_tmp3_ == ((0 != _tmp3__label1) ? _tmp3__label1 : (_tmp3__label1 = g_quark_from_static_string ("visible")))) + switch (0) { + default: + { +#line 287 "project.vala" + self->the_project->library_visible = _vala_strcmp0 (attr_values[i], "true") == 0; +#line 288 "project.vala" + break; +#line 1834 "project.c" + } + } else + switch (0) { + default: + { + char* _tmp1_; +#line 290 "project.vala" + g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "load-error", _tmp1_ = g_strdup_printf ("unknown attribute for library '%s'", attr_names[i])); +#line 1843 "project.c" + _g_free0 (_tmp1_); + result = FALSE; +#line 291 "project.vala" + return result; +#line 1848 "project.c" + } + } + } + } + } + result = TRUE; +#line 294 "project.vala" + return result; +#line 1857 "project.c" +} + + +#line 297 "project.vala" +static void model_media_loader_handler_real_leave_library (ModelLoaderHandler* base) { +#line 1863 "project.c" + ModelMediaLoaderHandler * self; + self = MODEL_MEDIA_LOADER_HANDLER (base); +#line 298 "project.vala" + if (gee_collection_get_size (GEE_COLLECTION (self->priv->clipfetchers)) == 0) { +#line 299 "project.vala" + g_signal_emit_by_name (MODEL_LOADER_HANDLER (self), "complete"); +#line 1870 "project.c" + } +} + + +static void model_media_loader_handler_class_init (ModelMediaLoaderHandlerClass * klass) { + model_media_loader_handler_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ModelMediaLoaderHandlerPrivate)); + MODEL_LOADER_HANDLER_CLASS (klass)->commit_marina = model_media_loader_handler_real_commit_marina; + MODEL_LOADER_HANDLER_CLASS (klass)->commit_library = model_media_loader_handler_real_commit_library; + MODEL_LOADER_HANDLER_CLASS (klass)->commit_track = model_media_loader_handler_real_commit_track; + MODEL_LOADER_HANDLER_CLASS (klass)->leave_track = model_media_loader_handler_real_leave_track; + MODEL_LOADER_HANDLER_CLASS (klass)->commit_clip = model_media_loader_handler_real_commit_clip; + MODEL_LOADER_HANDLER_CLASS (klass)->commit_clipfile = model_media_loader_handler_real_commit_clipfile; + MODEL_LOADER_HANDLER_CLASS (klass)->commit_tempo_entry = model_media_loader_handler_real_commit_tempo_entry; + MODEL_LOADER_HANDLER_CLASS (klass)->commit_time_signature_entry = model_media_loader_handler_real_commit_time_signature_entry; + MODEL_LOADER_HANDLER_CLASS (klass)->commit_click = model_media_loader_handler_real_commit_click; + MODEL_LOADER_HANDLER_CLASS (klass)->commit_library_preference = model_media_loader_handler_real_commit_library_preference; + MODEL_LOADER_HANDLER_CLASS (klass)->leave_library = model_media_loader_handler_real_leave_library; + G_OBJECT_CLASS (klass)->finalize = model_media_loader_handler_finalize; +} + + +static void model_media_loader_handler_instance_init (ModelMediaLoaderHandler * self) { + self->priv = MODEL_MEDIA_LOADER_HANDLER_GET_PRIVATE (self); + self->priv->clipfetchers = gee_array_list_new (MODEL_TYPE_CLIP_FETCHER, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL); +} + + +static void model_media_loader_handler_finalize (GObject* obj) { + ModelMediaLoaderHandler * self; + self = MODEL_MEDIA_LOADER_HANDLER (obj); + _g_object_unref0 (self->current_track); + _g_object_unref0 (self->priv->clipfetchers); + G_OBJECT_CLASS (model_media_loader_handler_parent_class)->finalize (obj); +} + + +GType model_media_loader_handler_get_type (void) { + static volatile gsize model_media_loader_handler_type_id__volatile = 0; + if (g_once_init_enter (&model_media_loader_handler_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelMediaLoaderHandlerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_media_loader_handler_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelMediaLoaderHandler), 0, (GInstanceInitFunc) model_media_loader_handler_instance_init, NULL }; + GType model_media_loader_handler_type_id; + model_media_loader_handler_type_id = g_type_register_static (MODEL_TYPE_LOADER_HANDLER, "ModelMediaLoaderHandler", &g_define_type_info, 0); + g_once_init_leave (&model_media_loader_handler_type_id__volatile, model_media_loader_handler_type_id); + } + return model_media_loader_handler_type_id__volatile; +} + + +#line 383 "project.vala" +static void model_project_real_get_clip_time (ModelProject* self, ModelClipFile* f, TimeCode* result) { +#line 1922 "project.c" + g_return_if_fail (MODEL_IS_PROJECT (self)); + g_critical ("Type `%s' does not implement abstract method `model_project_get_clip_time'", g_type_name (G_TYPE_FROM_INSTANCE (self))); + return; +} + + +#line 383 "project.vala" +void model_project_get_clip_time (ModelProject* self, ModelClipFile* f, TimeCode* result) { +#line 383 "project.vala" + MODEL_PROJECT_GET_CLASS (self)->get_clip_time (self, f, result); +#line 1933 "project.c" +} + + +#line 1145 "MediaEngine.vala" +static void _view_media_engine_on_track_added_model_project_track_added (ModelProject* _sender, ModelTrack* track, gpointer self) { +#line 1939 "project.c" + view_media_engine_on_track_added (self, track); +} + + +#line 397 "project.vala" +static void _model_project_on_playstate_changed_view_media_engine_playstate_changed (ViewMediaEngine* _sender, gpointer self) { +#line 1946 "project.c" + model_project_on_playstate_changed (self); +} + + +#line 924 "project.vala" +static void _model_project_on_error_occurred_view_media_engine_error_occurred (ViewMediaEngine* _sender, const char* major_message, const char* minor_message, gpointer self) { +#line 1953 "project.c" + model_project_on_error_occurred (self, major_message, minor_message); +} + + +#line 385 "project.vala" +ModelProject* model_project_construct (GType object_type, const char* filename, gboolean include_video, GError** error) { +#line 1960 "project.c" + GError * _inner_error_; + ModelProject * self; + ModelUndoManager* _tmp0_; + char* _tmp1_; + ViewMediaEngine* _tmp2_; + ViewMediaEngine* _tmp3_; + _inner_error_ = NULL; +#line 385 "project.vala" + self = (ModelProject*) g_object_new (object_type, NULL); +#line 386 "project.vala" + self->undo_manager = (_tmp0_ = model_undo_manager_new (), _model_undo_manager_unref0 (self->undo_manager), _tmp0_); +#line 387 "project.vala" + self->project_file = (_tmp1_ = g_strdup (filename), _g_free0 (self->project_file), _tmp1_); +#line 389 "project.vala" + _tmp2_ = view_media_engine_new (self, include_video, &_inner_error_); +#line 1976 "project.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + g_object_unref (self); + return NULL; + } +#line 389 "project.vala" + self->media_engine = (_tmp3_ = _tmp2_, _g_object_unref0 (self->media_engine), _tmp3_); +#line 390 "project.vala" + g_signal_connect_object (self, "track-added", (GCallback) _view_media_engine_on_track_added_model_project_track_added, self->media_engine, 0); +#line 391 "project.vala" + g_signal_connect_object (self->media_engine, "playstate-changed", (GCallback) _model_project_on_playstate_changed_view_media_engine_playstate_changed, self, 0); +#line 392 "project.vala" + g_signal_connect_object (self->media_engine, "error-occurred", (GCallback) _model_project_on_error_occurred_view_media_engine_error_occurred, self, 0); +#line 394 "project.vala" + model_project_set_default_framerate (self, &model_project_INVALID_FRAME_RATE); +#line 1992 "project.c" + return self; +} + + +#line 397 "project.vala" +void model_project_on_playstate_changed (ModelProject* self) { +#line 397 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 398 "project.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_playstate_changed"); +#line 399 "project.vala" + switch (view_media_engine_get_play_state (self->media_engine)) { +#line 2005 "project.c" + case PLAY_STATE_STOPPED: + { +#line 401 "project.vala" + model_project_ClearTrackMeters (self); +#line 402 "project.vala" + break; +#line 2012 "project.c" + } + case PLAY_STATE_CLOSED: + { +#line 404 "project.vala" + g_signal_emit_by_name (self, "closed"); +#line 405 "project.vala" + break; +#line 2020 "project.c" + } + } +#line 407 "project.vala" + g_signal_emit_by_name (self, "playstate-changed", view_media_engine_get_play_state (self->media_engine)); +#line 2025 "project.c" +} + + +#line 410 "project.vala" +static char* model_project_real_get_project_file (ModelProject* self) { +#line 2031 "project.c" + char* result = NULL; +#line 410 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL); +#line 2035 "project.c" + result = g_strdup (self->project_file); +#line 411 "project.vala" + return result; +#line 2039 "project.c" +} + + +#line 410 "project.vala" +char* model_project_get_project_file (ModelProject* self) { +#line 410 "project.vala" + return MODEL_PROJECT_GET_CLASS (self)->get_project_file (self); +#line 2047 "project.c" +} + + +#line 414 "project.vala" +ModelClipFile* model_project_get_clipfile (ModelProject* self, gint index) { +#line 2053 "project.c" + ModelClipFile* result = NULL; + gboolean _tmp0_ = FALSE; +#line 414 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL); +#line 415 "project.vala" + if (index < 0) { +#line 415 "project.vala" + _tmp0_ = TRUE; +#line 2062 "project.c" + } else { +#line 416 "project.vala" + _tmp0_ = index >= gee_collection_get_size (GEE_COLLECTION (self->clipfiles)); +#line 2066 "project.c" + } +#line 415 "project.vala" + if (_tmp0_) { +#line 2070 "project.c" + result = NULL; +#line 417 "project.vala" + return result; +#line 2074 "project.c" + } + result = (ModelClipFile*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clipfiles), index); +#line 418 "project.vala" + return result; +#line 2079 "project.c" +} + + +#line 421 "project.vala" +gint model_project_get_clipfile_index (ModelProject* self, ModelClipFile* find) { +#line 2085 "project.c" + gint result = 0; + gint i; +#line 421 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), 0); +#line 421 "project.vala" + g_return_val_if_fail (MODEL_IS_CLIP_FILE (find), 0); +#line 422 "project.vala" + i = 0; +#line 2094 "project.c" + { + GeeIterator* _f_it; + _f_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->clipfiles)); +#line 423 "project.vala" + while (TRUE) { +#line 2100 "project.c" + ModelClipFile* f; +#line 423 "project.vala" + if (!gee_iterator_next (_f_it)) { +#line 423 "project.vala" + break; +#line 2106 "project.c" + } +#line 423 "project.vala" + f = (ModelClipFile*) gee_iterator_get (_f_it); +#line 424 "project.vala" + if (f == find) { +#line 2112 "project.c" + result = i; + _g_object_unref0 (f); + _g_object_unref0 (_f_it); +#line 425 "project.vala" + return result; +#line 2118 "project.c" + } +#line 426 "project.vala" + i++; +#line 2122 "project.c" + _g_object_unref0 (f); + } + _g_object_unref0 (_f_it); + } + result = -1; +#line 428 "project.vala" + return result; +#line 2130 "project.c" +} + + +#line 431 "project.vala" +ModelTrack* model_project_track_from_clip (ModelProject* self, ModelClip* clip) { +#line 2136 "project.c" + ModelTrack* result = NULL; +#line 431 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL); +#line 431 "project.vala" + g_return_val_if_fail (MODEL_IS_CLIP (clip), NULL); +#line 2142 "project.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 432 "project.vala" + while (TRUE) { +#line 2148 "project.c" + ModelTrack* track; +#line 432 "project.vala" + if (!gee_iterator_next (_track_it)) { +#line 432 "project.vala" + break; +#line 2154 "project.c" + } +#line 432 "project.vala" + track = (ModelTrack*) gee_iterator_get (_track_it); +#line 2158 "project.c" + { + GeeIterator* _match_it; + _match_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (track->clips)); +#line 433 "project.vala" + while (TRUE) { +#line 2164 "project.c" + ModelClip* match; +#line 433 "project.vala" + if (!gee_iterator_next (_match_it)) { +#line 433 "project.vala" + break; +#line 2170 "project.c" + } +#line 433 "project.vala" + match = (ModelClip*) gee_iterator_get (_match_it); +#line 434 "project.vala" + if (match == clip) { +#line 2176 "project.c" + result = track; + _g_object_unref0 (match); + _g_object_unref0 (_match_it); + _g_object_unref0 (_track_it); +#line 435 "project.vala" + return result; +#line 2183 "project.c" + } + _g_object_unref0 (match); + } + _g_object_unref0 (_match_it); + } + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } + result = NULL; +#line 439 "project.vala" + return result; +#line 2196 "project.c" +} + + +#line 442 "project.vala" +void model_project_print_graph (ModelProject* self, GstBin* bin, const char* file_name) { +#line 442 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 442 "project.vala" + g_return_if_fail (GST_IS_BIN (bin)); +#line 442 "project.vala" + g_return_if_fail (file_name != NULL); +#line 443 "project.vala" + GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (bin, GST_DEBUG_GRAPH_SHOW_ALL, file_name); +#line 2210 "project.c" +} + + +#line 446 "project.vala" +gint64 model_project_get_length (ModelProject* self) { +#line 2216 "project.c" + gint64 result = 0LL; + gint64 max; +#line 446 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), 0LL); +#line 447 "project.vala" + max = (gint64) 0; +#line 2223 "project.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 448 "project.vala" + while (TRUE) { +#line 2229 "project.c" + ModelTrack* track; +#line 448 "project.vala" + if (!gee_iterator_next (_track_it)) { +#line 448 "project.vala" + break; +#line 2235 "project.c" + } +#line 448 "project.vala" + track = (ModelTrack*) gee_iterator_get (_track_it); +#line 449 "project.vala" + max = MAX (max, model_track_get_length (track)); +#line 2241 "project.c" + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } + result = max; +#line 451 "project.vala" + return result; +#line 2249 "project.c" +} + + +#line 454 "project.vala" +gint64 model_project_snap_clip (ModelProject* self, ModelClip* c, gint64 span) { +#line 2255 "project.c" + gint64 result = 0LL; +#line 454 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), 0LL); +#line 454 "project.vala" + g_return_val_if_fail (MODEL_IS_CLIP (c), 0LL); +#line 2261 "project.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 455 "project.vala" + while (TRUE) { +#line 2267 "project.c" + ModelTrack* track; + gint64 new_start; +#line 455 "project.vala" + if (!gee_iterator_next (_track_it)) { +#line 455 "project.vala" + break; +#line 2274 "project.c" + } +#line 455 "project.vala" + track = (ModelTrack*) gee_iterator_get (_track_it); +#line 456 "project.vala" + new_start = model_track_snap_clip (track, c, span); +#line 457 "project.vala" + if (new_start != model_clip_get_start (c)) { +#line 2282 "project.c" + result = new_start; + _g_object_unref0 (track); + _g_object_unref0 (_track_it); +#line 458 "project.vala" + return result; +#line 2288 "project.c" + } + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } + result = model_clip_get_start (c); +#line 461 "project.vala" + return result; +#line 2297 "project.c" +} + + +#line 464 "project.vala" +void model_project_snap_coord (ModelProject* self, gint64* coord, gint64 span) { +#line 464 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 2305 "project.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 465 "project.vala" + while (TRUE) { +#line 2311 "project.c" + ModelTrack* track; +#line 465 "project.vala" + if (!gee_iterator_next (_track_it)) { +#line 465 "project.vala" + break; +#line 2317 "project.c" + } +#line 465 "project.vala" + track = (ModelTrack*) gee_iterator_get (_track_it); +#line 466 "project.vala" + if (model_track_snap_coord (track, coord, span)) { +#line 2323 "project.c" + _g_object_unref0 (track); +#line 467 "project.vala" + break; +#line 2327 "project.c" + } + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } +} + + +static gpointer _model_gap_ref0 (gpointer self) { + return self ? model_gap_ref (self) : NULL; +} + + +#line 472 "project.vala" +static ModelGap* model_project_get_gap_intersection (ModelProject* self, ModelGap* gap) { +#line 2343 "project.c" + ModelGap* result = NULL; + ModelGap* intersection; +#line 472 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL); +#line 472 "project.vala" + g_return_val_if_fail (MODEL_IS_GAP (gap), NULL); +#line 473 "project.vala" + intersection = _model_gap_ref0 (gap); +#line 2352 "project.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 475 "project.vala" + while (TRUE) { +#line 2358 "project.c" + ModelTrack* track; + ModelGap* _tmp1_; + ModelGap* _tmp0_; +#line 475 "project.vala" + if (!gee_iterator_next (_track_it)) { +#line 475 "project.vala" + break; +#line 2366 "project.c" + } +#line 475 "project.vala" + track = (ModelTrack*) gee_iterator_get (_track_it); +#line 476 "project.vala" + intersection = (_tmp1_ = model_gap_intersect (intersection, _tmp0_ = model_track_find_first_gap (track, intersection->start)), _model_gap_unref0 (intersection), _tmp1_); +#line 2372 "project.c" + _model_gap_unref0 (_tmp0_); + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } + result = intersection; +#line 479 "project.vala" + return result; +#line 2381 "project.c" +} + + +#line 482 "project.vala" +gboolean model_project_can_delete_gap (ModelProject* self, ModelGap* gap) { +#line 2387 "project.c" + gboolean result = FALSE; + ModelGap* intersection; +#line 482 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), FALSE); +#line 482 "project.vala" + g_return_val_if_fail (MODEL_IS_GAP (gap), FALSE); +#line 483 "project.vala" + intersection = model_project_get_gap_intersection (self, gap); +#line 2396 "project.c" + result = !model_gap_is_empty (intersection); + _model_gap_unref0 (intersection); +#line 484 "project.vala" + return result; +#line 2401 "project.c" +} + + +#line 487 "project.vala" +void model_project_delete_gap (ModelProject* self, ModelGap* gap) { +#line 2407 "project.c" + ModelGap* intersection; +#line 487 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 487 "project.vala" + g_return_if_fail (MODEL_IS_GAP (gap)); +#line 488 "project.vala" + intersection = model_project_get_gap_intersection (self, gap); +#line 489 "project.vala" + g_assert (!model_gap_is_empty (intersection)); +#line 2417 "project.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 491 "project.vala" + while (TRUE) { +#line 2423 "project.c" + ModelTrack* track; +#line 491 "project.vala" + if (!gee_iterator_next (_track_it)) { +#line 491 "project.vala" + break; +#line 2429 "project.c" + } +#line 491 "project.vala" + track = (ModelTrack*) gee_iterator_get (_track_it); +#line 492 "project.vala" + model_track_delete_gap (track, intersection); +#line 2435 "project.c" + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } + _model_gap_unref0 (intersection); +} + + +#line 496 "project.vala" +static void model_project_real_do_append (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, const char* name, gint64 insert_time) { +#line 2446 "project.c" + ModelClip* clip; +#line 496 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 496 "project.vala" + g_return_if_fail (MODEL_IS_TRACK (track)); +#line 496 "project.vala" + g_return_if_fail (MODEL_IS_CLIP_FILE (clipfile)); +#line 496 "project.vala" + g_return_if_fail (name != NULL); +#line 498 "project.vala" + switch (model_track_media_type (track)) { +#line 2458 "project.c" + case MODEL_MEDIA_TYPE_AUDIO: + { +#line 500 "project.vala" + if (clipfile->audio_caps == NULL) { +#line 501 "project.vala" + return; +#line 2465 "project.c" + } +#line 503 "project.vala" + break; +#line 2469 "project.c" + } + case MODEL_MEDIA_TYPE_VIDEO: + { +#line 505 "project.vala" + if (clipfile->video_caps == NULL) { +#line 506 "project.vala" + return; +#line 2477 "project.c" + } +#line 508 "project.vala" + break; +#line 2481 "project.c" + } + } +#line 511 "project.vala" + clip = model_clip_new (clipfile, model_track_media_type (track), name, (gint64) 0, (gint64) 0, model_clip_file_get_length (clipfile), FALSE); +#line 512 "project.vala" + model_track_append_at_time (track, clip, insert_time, TRUE); +#line 2488 "project.c" + _g_object_unref0 (clip); +} + + +#line 496 "project.vala" +void model_project_do_append (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, const char* name, gint64 insert_time) { +#line 496 "project.vala" + MODEL_PROJECT_GET_CLASS (self)->do_append (self, track, clipfile, name, insert_time); +#line 2497 "project.c" +} + + +#line 515 "project.vala" +void model_project_append (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile) { +#line 2503 "project.c" + char* name; + gint64 insert_time; +#line 515 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 515 "project.vala" + g_return_if_fail (MODEL_IS_TRACK (track)); +#line 515 "project.vala" + g_return_if_fail (MODEL_IS_CLIP_FILE (clipfile)); +#line 516 "project.vala" + name = isolate_filename (clipfile->filename); +#line 517 "project.vala" + insert_time = (gint64) 0; +#line 2516 "project.c" + { + GeeIterator* _temp_track_it; + _temp_track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 519 "project.vala" + while (TRUE) { +#line 2522 "project.c" + ModelTrack* temp_track; +#line 519 "project.vala" + if (!gee_iterator_next (_temp_track_it)) { +#line 519 "project.vala" + break; +#line 2528 "project.c" + } +#line 519 "project.vala" + temp_track = (ModelTrack*) gee_iterator_get (_temp_track_it); +#line 520 "project.vala" + insert_time = MAX (insert_time, model_track_get_length (temp_track)); +#line 2534 "project.c" + _g_object_unref0 (temp_track); + } + _g_object_unref0 (_temp_track_it); + } +#line 522 "project.vala" + model_project_do_append (self, track, clipfile, name, insert_time); +#line 2541 "project.c" + _g_free0 (name); +} + + +#line 525 "project.vala" +void model_project_add (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, gint64 time) { +#line 2548 "project.c" + char* name; +#line 525 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 525 "project.vala" + g_return_if_fail (MODEL_IS_TRACK (track)); +#line 525 "project.vala" + g_return_if_fail (MODEL_IS_CLIP_FILE (clipfile)); +#line 526 "project.vala" + name = isolate_filename (clipfile->filename); +#line 527 "project.vala" + model_project_do_append (self, track, clipfile, name, time); +#line 2560 "project.c" + _g_free0 (name); +} + + +#line 530 "project.vala" +void model_project_on_clip_removed (ModelProject* self, ModelTrack* t, ModelClip* clip) { +#line 530 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 530 "project.vala" + g_return_if_fail (MODEL_IS_TRACK (t)); +#line 530 "project.vala" + g_return_if_fail (MODEL_IS_CLIP (clip)); +#line 531 "project.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_removed"); +#line 532 "project.vala" + model_project_reseek (self); +#line 2577 "project.c" +} + + +#line 535 "project.vala" +void model_project_split_at_playhead (ModelProject* self) { +#line 2583 "project.c" + char* description; +#line 535 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 536 "project.vala" + description = g_strdup ("Split At Playhead"); +#line 537 "project.vala" + model_undo_manager_start_transaction (self->undo_manager, description); +#line 2591 "project.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 538 "project.vala" + while (TRUE) { +#line 2597 "project.c" + ModelTrack* track; + ModelClip* _tmp0_; + gboolean _tmp1_; +#line 538 "project.vala" + if (!gee_iterator_next (_track_it)) { +#line 538 "project.vala" + break; +#line 2605 "project.c" + } +#line 538 "project.vala" + track = (ModelTrack*) gee_iterator_get (_track_it); +#line 539 "project.vala" + if ((_tmp1_ = (_tmp0_ = model_track_get_clip_by_position (track, model_project_transport_get_position (self))) != NULL, _g_object_unref0 (_tmp0_), _tmp1_)) { +#line 540 "project.vala" + model_track_split_at (track, model_project_transport_get_position (self)); +#line 2613 "project.c" + } + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } +#line 543 "project.vala" + model_undo_manager_end_transaction (self->undo_manager, description); +#line 2621 "project.c" + _g_free0 (description); +} + + +#line 546 "project.vala" +gboolean model_project_can_trim (ModelProject* self, gboolean* left) { +#line 2628 "project.c" + gboolean result = FALSE; + ModelClip* first_clip; + gint64 start; + gint64 end; + gboolean start_same; + gboolean end_same; + gboolean _tmp4_ = FALSE; + gboolean _tmp5_ = FALSE; +#line 546 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), FALSE); +#line 547 "project.vala" + first_clip = NULL; +#line 553 "project.vala" + start = (gint64) 0; +#line 554 "project.vala" + end = (gint64) 0; +#line 555 "project.vala" + start_same = TRUE; +#line 556 "project.vala" + end_same = TRUE; +#line 2649 "project.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 557 "project.vala" + while (TRUE) { +#line 2655 "project.c" + ModelTrack* track; + ModelClip* clip; + gboolean _tmp0_ = FALSE; +#line 557 "project.vala" + if (!gee_iterator_next (_track_it)) { +#line 557 "project.vala" + break; +#line 2663 "project.c" + } +#line 557 "project.vala" + track = (ModelTrack*) gee_iterator_get (_track_it); +#line 558 "project.vala" + clip = model_track_get_clip_by_position (track, model_project_transport_get_position (self)); +#line 559 "project.vala" + if (first_clip != NULL) { +#line 559 "project.vala" + _tmp0_ = clip != NULL; +#line 2673 "project.c" + } else { +#line 559 "project.vala" + _tmp0_ = FALSE; +#line 2677 "project.c" + } +#line 559 "project.vala" + if (_tmp0_) { +#line 2681 "project.c" + gboolean _tmp1_ = FALSE; + gboolean _tmp2_ = FALSE; +#line 560 "project.vala" + if (start_same) { +#line 560 "project.vala" + _tmp1_ = start == model_clip_get_start (clip); +#line 2688 "project.c" + } else { +#line 560 "project.vala" + _tmp1_ = FALSE; +#line 2692 "project.c" + } +#line 560 "project.vala" + start_same = _tmp1_; +#line 561 "project.vala" + if (end_same) { +#line 561 "project.vala" + _tmp2_ = end == model_clip_get_end (clip); +#line 2700 "project.c" + } else { +#line 561 "project.vala" + _tmp2_ = FALSE; +#line 2704 "project.c" + } +#line 561 "project.vala" + end_same = _tmp2_; +#line 2708 "project.c" + } else { +#line 562 "project.vala" + if (clip != NULL) { +#line 2712 "project.c" + ModelClip* _tmp3_; +#line 563 "project.vala" + first_clip = (_tmp3_ = _g_object_ref0 (clip), _g_object_unref0 (first_clip), _tmp3_); +#line 564 "project.vala" + start = model_clip_get_start (first_clip); +#line 565 "project.vala" + end = model_clip_get_end (first_clip); +#line 2720 "project.c" + } + } + _g_object_unref0 (track); + _g_object_unref0 (clip); + } + _g_object_unref0 (_track_it); + } +#line 569 "project.vala" + if (first_clip == NULL) { +#line 2730 "project.c" + result = FALSE; + _g_object_unref0 (first_clip); +#line 570 "project.vala" + return result; +#line 2735 "project.c" + } +#line 573 "project.vala" + if (start_same) { +#line 573 "project.vala" + _tmp4_ = !end_same; +#line 2741 "project.c" + } else { +#line 573 "project.vala" + _tmp4_ = FALSE; +#line 2745 "project.c" + } +#line 573 "project.vala" + if (_tmp4_) { +#line 574 "project.vala" + *left = TRUE; +#line 2751 "project.c" + result = TRUE; + _g_object_unref0 (first_clip); +#line 575 "project.vala" + return result; +#line 2756 "project.c" + } +#line 578 "project.vala" + if (!start_same) { +#line 578 "project.vala" + _tmp5_ = end_same; +#line 2762 "project.c" + } else { +#line 578 "project.vala" + _tmp5_ = FALSE; +#line 2766 "project.c" + } +#line 578 "project.vala" + if (_tmp5_) { +#line 579 "project.vala" + *left = FALSE; +#line 2772 "project.c" + result = TRUE; + _g_object_unref0 (first_clip); +#line 580 "project.vala" + return result; +#line 2777 "project.c" + } +#line 584 "project.vala" + *left = (model_project_transport_get_position (self) - model_clip_get_start (first_clip)) < (model_clip_get_duration (first_clip) / 2); +#line 2781 "project.c" + result = TRUE; + _g_object_unref0 (first_clip); +#line 585 "project.vala" + return result; +#line 2786 "project.c" +} + + +#line 588 "project.vala" +void model_project_trim_to_playhead (ModelProject* self) { +#line 2792 "project.c" + gboolean left = FALSE; + char* description; + ModelClip* first_clip; + gboolean _tmp1_ = FALSE; +#line 588 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 590 "project.vala" + if (!model_project_can_trim (self, &left)) { +#line 591 "project.vala" + return; +#line 2803 "project.c" + } +#line 593 "project.vala" + description = g_strdup ("Trim To Playhead"); +#line 594 "project.vala" + first_clip = NULL; +#line 595 "project.vala" + model_undo_manager_start_transaction (self->undo_manager, description); +#line 2811 "project.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 596 "project.vala" + while (TRUE) { +#line 2817 "project.c" + ModelTrack* track; + ModelClip* clip; +#line 596 "project.vala" + if (!gee_iterator_next (_track_it)) { +#line 596 "project.vala" + break; +#line 2824 "project.c" + } +#line 596 "project.vala" + track = (ModelTrack*) gee_iterator_get (_track_it); +#line 597 "project.vala" + clip = model_track_get_clip_by_position (track, model_project_transport_get_position (self)); +#line 598 "project.vala" + if (clip != NULL) { +#line 2832 "project.c" + gint64 delta = 0LL; + GdkWindowEdge _tmp0_ = 0; +#line 600 "project.vala" + if (left) { +#line 601 "project.vala" + delta = model_project_transport_get_position (self) - model_clip_get_start (clip); +#line 2839 "project.c" + } else { +#line 603 "project.vala" + delta = model_project_transport_get_position (self) - model_clip_get_end (clip); +#line 2843 "project.c" + } +#line 605 "project.vala" + if (left) { +#line 605 "project.vala" + _tmp0_ = GDK_WINDOW_EDGE_WEST; +#line 2849 "project.c" + } else { +#line 605 "project.vala" + _tmp0_ = GDK_WINDOW_EDGE_EAST; +#line 2853 "project.c" + } +#line 605 "project.vala" + model_track_trim (track, clip, delta, _tmp0_); +#line 2857 "project.c" + } + _g_object_unref0 (track); + _g_object_unref0 (clip); + } + _g_object_unref0 (_track_it); + } +#line 608 "project.vala" + model_undo_manager_end_transaction (self->undo_manager, description); +#line 610 "project.vala" + if (left) { +#line 610 "project.vala" + _tmp1_ = first_clip != NULL; +#line 2870 "project.c" + } else { +#line 610 "project.vala" + _tmp1_ = FALSE; +#line 2874 "project.c" + } +#line 610 "project.vala" + if (_tmp1_) { +#line 611 "project.vala" + model_project_transport_go (self, model_clip_get_start (first_clip)); +#line 2880 "project.c" + } + _g_free0 (description); + _g_object_unref0 (first_clip); +} + + +#line 615 "project.vala" +void model_project_transport_go (ModelProject* self, gint64 position) { +#line 615 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 616 "project.vala" + view_media_engine_go (self->media_engine, position); +#line 2893 "project.c" +} + + +#line 619 "project.vala" +gboolean model_project_transport_is_playing (ModelProject* self) { +#line 2899 "project.c" + gboolean result = FALSE; +#line 619 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), FALSE); +#line 2903 "project.c" + result = self->media_engine->playing; +#line 620 "project.vala" + return result; +#line 2907 "project.c" +} + + +#line 623 "project.vala" +gboolean model_project_transport_is_recording (ModelProject* self) { +#line 2913 "project.c" + gboolean result = FALSE; + gboolean _tmp0_ = FALSE; +#line 623 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), FALSE); +#line 624 "project.vala" + if (view_media_engine_get_play_state (self->media_engine) == PLAY_STATE_PRE_RECORD) { +#line 624 "project.vala" + _tmp0_ = TRUE; +#line 2922 "project.c" + } else { +#line 625 "project.vala" + _tmp0_ = view_media_engine_get_play_state (self->media_engine) == PLAY_STATE_RECORDING; +#line 2926 "project.c" + } + result = _tmp0_; +#line 624 "project.vala" + return result; +#line 2931 "project.c" +} + + +#line 628 "project.vala" +gboolean model_project_playhead_on_clip (ModelProject* self) { +#line 2937 "project.c" + gboolean result = FALSE; +#line 628 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), FALSE); +#line 2941 "project.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 629 "project.vala" + while (TRUE) { +#line 2947 "project.c" + ModelTrack* track; + ModelClip* _tmp0_; + gboolean _tmp1_; +#line 629 "project.vala" + if (!gee_iterator_next (_track_it)) { +#line 629 "project.vala" + break; +#line 2955 "project.c" + } +#line 629 "project.vala" + track = (ModelTrack*) gee_iterator_get (_track_it); +#line 630 "project.vala" + if ((_tmp1_ = (_tmp0_ = model_track_get_clip_by_position (track, model_project_transport_get_position (self))) != NULL, _g_object_unref0 (_tmp0_), _tmp1_)) { +#line 2961 "project.c" + result = TRUE; + _g_object_unref0 (track); + _g_object_unref0 (_track_it); +#line 631 "project.vala" + return result; +#line 2967 "project.c" + } + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } + result = FALSE; +#line 634 "project.vala" + return result; +#line 2976 "project.c" +} + + +#line 637 "project.vala" +gboolean model_project_playhead_on_contiguous_clip (ModelProject* self) { +#line 2982 "project.c" + gboolean result = FALSE; +#line 637 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), FALSE); +#line 2986 "project.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 638 "project.vala" + while (TRUE) { +#line 2992 "project.c" + ModelTrack* track; +#line 638 "project.vala" + if (!gee_iterator_next (_track_it)) { +#line 638 "project.vala" + break; +#line 2998 "project.c" + } +#line 638 "project.vala" + track = (ModelTrack*) gee_iterator_get (_track_it); +#line 639 "project.vala" + if (model_track_are_contiguous_clips (track, model_project_transport_get_position (self))) { +#line 3004 "project.c" + result = TRUE; + _g_object_unref0 (track); + _g_object_unref0 (_track_it); +#line 640 "project.vala" + return result; +#line 3010 "project.c" + } + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } + result = FALSE; +#line 643 "project.vala" + return result; +#line 3019 "project.c" +} + + +#line 646 "project.vala" +gboolean model_project_is_duplicate_track_name (ModelProject* self, ModelTrack* track, const char* new_name) { +#line 3025 "project.c" + gboolean result = FALSE; +#line 646 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), FALSE); +#line 646 "project.vala" + g_return_val_if_fail ((track == NULL) || MODEL_IS_TRACK (track), FALSE); +#line 646 "project.vala" + g_return_val_if_fail (new_name != NULL, FALSE); +#line 647 "project.vala" + g_assert (_vala_strcmp0 (new_name, "") != 0); +#line 3035 "project.c" + { + GeeIterator* _this_track_it; + _this_track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 648 "project.vala" + while (TRUE) { +#line 3041 "project.c" + ModelTrack* this_track; +#line 648 "project.vala" + if (!gee_iterator_next (_this_track_it)) { +#line 648 "project.vala" + break; +#line 3047 "project.c" + } +#line 648 "project.vala" + this_track = (ModelTrack*) gee_iterator_get (_this_track_it); +#line 649 "project.vala" + if (track != this_track) { +#line 3053 "project.c" + char* _tmp0_; + gboolean _tmp1_; +#line 650 "project.vala" + if ((_tmp1_ = _vala_strcmp0 (_tmp0_ = model_track_get_display_name (this_track), new_name) == 0, _g_free0 (_tmp0_), _tmp1_)) { +#line 3058 "project.c" + result = TRUE; + _g_object_unref0 (this_track); + _g_object_unref0 (_this_track_it); +#line 651 "project.vala" + return result; +#line 3064 "project.c" + } + } + _g_object_unref0 (this_track); + } + _g_object_unref0 (_this_track_it); + } + { + GeeIterator* _this_track_it; + _this_track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->inactive_tracks)); +#line 656 "project.vala" + while (TRUE) { +#line 3076 "project.c" + ModelTrack* this_track; +#line 656 "project.vala" + if (!gee_iterator_next (_this_track_it)) { +#line 656 "project.vala" + break; +#line 3082 "project.c" + } +#line 656 "project.vala" + this_track = (ModelTrack*) gee_iterator_get (_this_track_it); +#line 657 "project.vala" + if (track != this_track) { +#line 3088 "project.c" + char* _tmp2_; + gboolean _tmp3_; +#line 658 "project.vala" + if ((_tmp3_ = _vala_strcmp0 (_tmp2_ = model_track_get_display_name (this_track), new_name) == 0, _g_free0 (_tmp2_), _tmp3_)) { +#line 3093 "project.c" + result = TRUE; + _g_object_unref0 (this_track); + _g_object_unref0 (_this_track_it); +#line 659 "project.vala" + return result; +#line 3099 "project.c" + } + } + _g_object_unref0 (this_track); + } + _g_object_unref0 (_this_track_it); + } + result = FALSE; +#line 663 "project.vala" + return result; +#line 3109 "project.c" +} + + +#line 530 "project.vala" +static void _model_project_on_clip_removed_model_track_clip_removed (ModelTrack* _sender, ModelClip* clip, gpointer self) { +#line 3115 "project.c" + model_project_on_clip_removed (self, _sender, clip); +} + + +#line 924 "project.vala" +static void _model_project_on_error_occurred_model_track_error_occurred (ModelTrack* _sender, const char* major_error, const char* minor_error, gpointer self) { +#line 3122 "project.c" + model_project_on_error_occurred (self, major_error, minor_error); +} + + +#line 666 "project.vala" +static void model_project_real_add_track (ModelProject* self, ModelTrack* track) { +#line 666 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 666 "project.vala" + g_return_if_fail (MODEL_IS_TRACK (track)); +#line 667 "project.vala" + g_signal_connect_object (track, "clip-removed", (GCallback) _model_project_on_clip_removed_model_track_clip_removed, self, 0); +#line 668 "project.vala" + g_signal_connect_object (track, "error-occurred", (GCallback) _model_project_on_error_occurred_model_track_error_occurred, self, 0); +#line 669 "project.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->tracks), track); +#line 670 "project.vala" + g_signal_emit_by_name (self, "track-added", track); +#line 3141 "project.c" +} + + +#line 666 "project.vala" +void model_project_add_track (ModelProject* self, ModelTrack* track) { +#line 666 "project.vala" + MODEL_PROJECT_GET_CLASS (self)->add_track (self, track); +#line 3149 "project.c" +} + + +#line 672 "project.vala" +static void model_project_real_insert_track (ModelProject* self, gint index, ModelTrack* track) { +#line 672 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 672 "project.vala" + g_return_if_fail (MODEL_IS_TRACK (track)); +#line 673 "project.vala" + if (0 > index) { +#line 673 "project.vala" + index = 0; +#line 3163 "project.c" + } +#line 674 "project.vala" + if (gee_collection_get_size (GEE_COLLECTION (self->tracks)) <= index) { +#line 675 "project.vala" + model_project_add_track (self, track); +#line 3169 "project.c" + } else { +#line 678 "project.vala" + g_signal_connect_object (track, "clip-removed", (GCallback) _model_project_on_clip_removed_model_track_clip_removed, self, 0); +#line 679 "project.vala" + g_signal_connect_object (track, "error-occurred", (GCallback) _model_project_on_error_occurred_model_track_error_occurred, self, 0); +#line 680 "project.vala" + gee_abstract_list_insert (GEE_ABSTRACT_LIST (self->tracks), index, track); +#line 681 "project.vala" + g_signal_emit_by_name (self, "track-added", track); +#line 3179 "project.c" + } +} + + +#line 672 "project.vala" +void model_project_insert_track (ModelProject* self, gint index, ModelTrack* track) { +#line 672 "project.vala" + MODEL_PROJECT_GET_CLASS (self)->insert_track (self, index, track); +#line 3188 "project.c" +} + + +#line 685 "project.vala" +void model_project_add_inactive_track (ModelProject* self, ModelTrack* track) { +#line 685 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 685 "project.vala" + g_return_if_fail (MODEL_IS_TRACK (track)); +#line 686 "project.vala" + model_track_hide (track); +#line 687 "project.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->inactive_tracks), track); +#line 3202 "project.c" +} + + +#line 690 "project.vala" +void model_project_remove_track (ModelProject* self, ModelTrack* track) { +#line 690 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 690 "project.vala" + g_return_if_fail (MODEL_IS_TRACK (track)); +#line 691 "project.vala" + gst_element_set_state (GST_ELEMENT (self->media_engine->pipeline), GST_STATE_NULL); +#line 692 "project.vala" + g_signal_emit_by_name (track, "track-removed", track); +#line 693 "project.vala" + gee_abstract_collection_remove (GEE_ABSTRACT_COLLECTION (self->tracks), track); +#line 694 "project.vala" + g_signal_emit_by_name (self, "track-removed", track); +#line 3220 "project.c" +} + + +#line 697 "project.vala" +void model_project_remove_track_at (ModelProject* self, gint index) { +#line 3226 "project.c" + ModelTrack* _tmp0_; +#line 697 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 698 "project.vala" + model_project_remove_track (self, _tmp0_ = (ModelTrack*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->tracks), index)); +#line 3232 "project.c" + _g_object_unref0 (_tmp0_); +} + + +#line 701 "project.vala" +void model_project_add_clipfile (ModelProject* self, ModelClipFile* clipfile) { +#line 3239 "project.c" + ModelCommand* command; +#line 701 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 701 "project.vala" + g_return_if_fail (MODEL_IS_CLIP_FILE (clipfile)); +#line 702 "project.vala" + command = MODEL_COMMAND (model_add_clip_command_new (self, clipfile)); +#line 703 "project.vala" + model_project_do_command (self, command); +#line 3249 "project.c" + _model_command_unref0 (command); +} + + +#line 717 "project.vala" +static void _model_project_on_thumbnail_ready_model_fetcher_ready (ModelFetcher* _sender, ModelFetcher* fetcher, gpointer self) { +#line 3256 "project.c" + model_project_on_thumbnail_ready (self, fetcher); +} + + +#line 706 "project.vala" +void _model_project_add_clipfile (ModelProject* self, ModelClipFile* clipfile, GError** error) { +#line 3263 "project.c" + GError * _inner_error_; + gboolean _tmp0_ = FALSE; +#line 706 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 706 "project.vala" + g_return_if_fail (MODEL_IS_CLIP_FILE (clipfile)); +#line 3270 "project.c" + _inner_error_ = NULL; +#line 707 "project.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->clipfiles), clipfile); +#line 708 "project.vala" + if (model_clip_file_is_online (clipfile)) { +#line 708 "project.vala" + _tmp0_ = model_clip_file_is_of_type (clipfile, MODEL_MEDIA_TYPE_VIDEO); +#line 3278 "project.c" + } else { +#line 708 "project.vala" + _tmp0_ = FALSE; +#line 3282 "project.c" + } +#line 708 "project.vala" + if (_tmp0_) { +#line 3286 "project.c" + ModelThumbnailFetcher* fetcher; +#line 709 "project.vala" + fetcher = model_thumbnail_fetcher_new (clipfile, (gint64) 0, &_inner_error_); +#line 3290 "project.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + return; + } +#line 710 "project.vala" + g_signal_connect_object (MODEL_FETCHER (fetcher), "ready", (GCallback) _model_project_on_thumbnail_ready_model_fetcher_ready, self, 0); +#line 711 "project.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->pending_thumbs), fetcher); +#line 3299 "project.c" + _g_object_unref0 (fetcher); + } else { +#line 713 "project.vala" + g_signal_emit_by_name (self, "clipfile-added", clipfile); +#line 3304 "project.c" + } +} + + +#line 717 "project.vala" +static void model_project_on_thumbnail_ready (ModelProject* self, ModelFetcher* f) { +#line 3311 "project.c" + ModelFetcher* _tmp0_; +#line 717 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 717 "project.vala" + g_return_if_fail (MODEL_IS_FETCHER (f)); +#line 718 "project.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_thumbnail_ready"); +#line 719 "project.vala" + g_signal_emit_by_name (self, "clipfile-added", f->clipfile); +#line 720 "project.vala" + gee_abstract_collection_remove (GEE_ABSTRACT_COLLECTION (self->priv->pending_thumbs), (_tmp0_ = f, MODEL_IS_THUMBNAIL_FETCHER (_tmp0_) ? ((ModelThumbnailFetcher*) _tmp0_) : NULL)); +#line 3323 "project.c" +} + + +#line 723 "project.vala" +gboolean model_project_clipfile_on_track (ModelProject* self, const char* filename) { +#line 3329 "project.c" + gboolean result = FALSE; + ModelClipFile* cf; +#line 723 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), FALSE); +#line 723 "project.vala" + g_return_val_if_fail (filename != NULL, FALSE); +#line 724 "project.vala" + cf = model_project_find_clipfile (self, filename); +#line 3338 "project.c" + { + GeeIterator* _t_it; + _t_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 726 "project.vala" + while (TRUE) { +#line 3344 "project.c" + ModelTrack* t; +#line 726 "project.vala" + if (!gee_iterator_next (_t_it)) { +#line 726 "project.vala" + break; +#line 3350 "project.c" + } +#line 726 "project.vala" + t = (ModelTrack*) gee_iterator_get (_t_it); +#line 3354 "project.c" + { + GeeIterator* _c_it; + _c_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (t->clips)); +#line 727 "project.vala" + while (TRUE) { +#line 3360 "project.c" + ModelClip* c; +#line 727 "project.vala" + if (!gee_iterator_next (_c_it)) { +#line 727 "project.vala" + break; +#line 3366 "project.c" + } +#line 727 "project.vala" + c = (ModelClip*) gee_iterator_get (_c_it); +#line 728 "project.vala" + if (c->clipfile == cf) { +#line 3372 "project.c" + result = TRUE; + _g_object_unref0 (c); + _g_object_unref0 (_c_it); + _g_object_unref0 (t); + _g_object_unref0 (_t_it); + _g_object_unref0 (cf); +#line 729 "project.vala" + return result; +#line 3381 "project.c" + } + _g_object_unref0 (c); + } + _g_object_unref0 (_c_it); + } + _g_object_unref0 (t); + } + _g_object_unref0 (_t_it); + } + { + GeeIterator* _t_it; + _t_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->inactive_tracks)); +#line 733 "project.vala" + while (TRUE) { +#line 3396 "project.c" + ModelTrack* t; +#line 733 "project.vala" + if (!gee_iterator_next (_t_it)) { +#line 733 "project.vala" + break; +#line 3402 "project.c" + } +#line 733 "project.vala" + t = (ModelTrack*) gee_iterator_get (_t_it); +#line 3406 "project.c" + { + GeeIterator* _c_it; + _c_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (t->clips)); +#line 734 "project.vala" + while (TRUE) { +#line 3412 "project.c" + ModelClip* c; +#line 734 "project.vala" + if (!gee_iterator_next (_c_it)) { +#line 734 "project.vala" + break; +#line 3418 "project.c" + } +#line 734 "project.vala" + c = (ModelClip*) gee_iterator_get (_c_it); +#line 735 "project.vala" + if (c->clipfile == cf) { +#line 3424 "project.c" + result = TRUE; + _g_object_unref0 (c); + _g_object_unref0 (_c_it); + _g_object_unref0 (t); + _g_object_unref0 (_t_it); + _g_object_unref0 (cf); +#line 736 "project.vala" + return result; +#line 3433 "project.c" + } + _g_object_unref0 (c); + } + _g_object_unref0 (_c_it); + } + _g_object_unref0 (t); + } + _g_object_unref0 (_t_it); + } + result = FALSE; + _g_object_unref0 (cf); +#line 740 "project.vala" + return result; +#line 3447 "project.c" +} + + +#line 743 "project.vala" +static void model_project_delete_clipfile_from_tracks (ModelProject* self, ModelClipFile* cf) { +#line 743 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 743 "project.vala" + g_return_if_fail (MODEL_IS_CLIP_FILE (cf)); +#line 3457 "project.c" + { + GeeIterator* _t_it; + _t_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 744 "project.vala" + while (TRUE) { +#line 3463 "project.c" + ModelTrack* t; +#line 744 "project.vala" + if (!gee_iterator_next (_t_it)) { +#line 744 "project.vala" + break; +#line 3469 "project.c" + } +#line 744 "project.vala" + t = (ModelTrack*) gee_iterator_get (_t_it); +#line 3473 "project.c" + { + gint i; +#line 745 "project.vala" + i = 0; +#line 3478 "project.c" + { + gboolean _tmp0_; +#line 745 "project.vala" + _tmp0_ = TRUE; +#line 745 "project.vala" + while (TRUE) { +#line 3485 "project.c" + ModelClip* _tmp1_; + gboolean _tmp2_; +#line 745 "project.vala" + if (!_tmp0_) { +#line 745 "project.vala" + i++; +#line 3492 "project.c" + } +#line 745 "project.vala" + _tmp0_ = FALSE; +#line 745 "project.vala" + if (!(i < gee_collection_get_size (GEE_COLLECTION (t->clips)))) { +#line 745 "project.vala" + break; +#line 3500 "project.c" + } +#line 746 "project.vala" + if ((_tmp2_ = (_tmp1_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (t->clips), i))->clipfile == cf, _g_object_unref0 (_tmp1_), _tmp2_)) { +#line 3504 "project.c" + ModelClip* _tmp3_; +#line 747 "project.vala" + model_track_delete_clip (t, _tmp3_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (t->clips), i)); +#line 3508 "project.c" + _g_object_unref0 (_tmp3_); +#line 748 "project.vala" + i--; +#line 3512 "project.c" + } + } + } + } + _g_object_unref0 (t); + } + _g_object_unref0 (_t_it); + } + { + GeeIterator* _t_it; + _t_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->inactive_tracks)); +#line 753 "project.vala" + while (TRUE) { +#line 3526 "project.c" + ModelTrack* t; +#line 753 "project.vala" + if (!gee_iterator_next (_t_it)) { +#line 753 "project.vala" + break; +#line 3532 "project.c" + } +#line 753 "project.vala" + t = (ModelTrack*) gee_iterator_get (_t_it); +#line 3536 "project.c" + { + gint i; +#line 754 "project.vala" + i = 0; +#line 3541 "project.c" + { + gboolean _tmp4_; +#line 754 "project.vala" + _tmp4_ = TRUE; +#line 754 "project.vala" + while (TRUE) { +#line 3548 "project.c" + ModelClip* _tmp5_; + gboolean _tmp6_; +#line 754 "project.vala" + if (!_tmp4_) { +#line 754 "project.vala" + i++; +#line 3555 "project.c" + } +#line 754 "project.vala" + _tmp4_ = FALSE; +#line 754 "project.vala" + if (!(i < gee_collection_get_size (GEE_COLLECTION (t->clips)))) { +#line 754 "project.vala" + break; +#line 3563 "project.c" + } +#line 755 "project.vala" + if ((_tmp6_ = (_tmp5_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (t->clips), i))->clipfile == cf, _g_object_unref0 (_tmp5_), _tmp6_)) { +#line 3567 "project.c" + ModelClip* _tmp7_; +#line 756 "project.vala" + model_track_delete_clip (t, _tmp7_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (t->clips), i)); +#line 3571 "project.c" + _g_object_unref0 (_tmp7_); +#line 757 "project.vala" + i--; +#line 3575 "project.c" + } + } + } + } + _g_object_unref0 (t); + } + _g_object_unref0 (_t_it); + } +} + + +#line 763 "project.vala" +void _model_project_remove_clipfile (ModelProject* self, ModelClipFile* cf) { +#line 763 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 763 "project.vala" + g_return_if_fail (MODEL_IS_CLIP_FILE (cf)); +#line 764 "project.vala" + gee_abstract_collection_remove (GEE_ABSTRACT_COLLECTION (self->clipfiles), cf); +#line 765 "project.vala" + g_signal_emit_by_name (self, "clipfile-removed", cf); +#line 3597 "project.c" +} + + +#line 768 "project.vala" +void model_project_remove_clipfile (ModelProject* self, const char* filename) { +#line 3603 "project.c" + ModelClipFile* cf; +#line 768 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 768 "project.vala" + g_return_if_fail (filename != NULL); +#line 769 "project.vala" + cf = model_project_find_clipfile (self, filename); +#line 770 "project.vala" + if (cf != NULL) { +#line 3613 "project.c" + char* description; + ModelCommand* clipfile_delete; +#line 771 "project.vala" + description = g_strdup ("Delete From Library"); +#line 772 "project.vala" + model_undo_manager_start_transaction (self->undo_manager, description); +#line 774 "project.vala" + model_project_delete_clipfile_from_tracks (self, cf); +#line 776 "project.vala" + clipfile_delete = MODEL_COMMAND (model_clip_file_delete_command_new (self, cf)); +#line 777 "project.vala" + model_project_do_command (self, clipfile_delete); +#line 779 "project.vala" + model_undo_manager_end_transaction (self->undo_manager, description); +#line 3628 "project.c" + _g_free0 (description); + _model_command_unref0 (clipfile_delete); + } + _g_object_unref0 (cf); +} + + +#line 783 "project.vala" +ModelClipFile* model_project_find_clipfile (ModelProject* self, const char* filename) { +#line 3638 "project.c" + ModelClipFile* result = NULL; +#line 783 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL); +#line 783 "project.vala" + g_return_val_if_fail (filename != NULL, NULL); +#line 3644 "project.c" + { + GeeIterator* _cf_it; + _cf_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->clipfiles)); +#line 784 "project.vala" + while (TRUE) { +#line 3650 "project.c" + ModelClipFile* cf; +#line 784 "project.vala" + if (!gee_iterator_next (_cf_it)) { +#line 784 "project.vala" + break; +#line 3656 "project.c" + } +#line 784 "project.vala" + cf = (ModelClipFile*) gee_iterator_get (_cf_it); +#line 785 "project.vala" + if (_vala_strcmp0 (cf->filename, filename) == 0) { +#line 3662 "project.c" + result = cf; + _g_object_unref0 (_cf_it); +#line 786 "project.vala" + return result; +#line 3667 "project.c" + } + _g_object_unref0 (cf); + } + _g_object_unref0 (_cf_it); + } + result = NULL; +#line 787 "project.vala" + return result; +#line 3676 "project.c" +} + + +#line 790 "project.vala" +void model_project_reseek (ModelProject* self) { +#line 790 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 790 "project.vala" + model_project_transport_go (self, model_project_transport_get_position (self)); +#line 3686 "project.c" +} + + +#line 792 "project.vala" +void model_project_go_start (ModelProject* self) { +#line 792 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 792 "project.vala" + model_project_transport_go (self, (gint64) 0); +#line 3696 "project.c" +} + + +#line 794 "project.vala" +void model_project_go_end (ModelProject* self) { +#line 794 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 794 "project.vala" + model_project_transport_go (self, model_project_get_length (self)); +#line 3706 "project.c" +} + + +#line 796 "project.vala" +void model_project_go_previous (ModelProject* self) { +#line 3712 "project.c" + gint64 start_pos; + gint64 new_position; +#line 796 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 797 "project.vala" + start_pos = model_project_transport_get_position (self); +#line 801 "project.vala" + if (model_project_transport_is_playing (self)) { +#line 802 "project.vala" + start_pos = start_pos - ((gint64) (1 * GST_SECOND)); +#line 3723 "project.c" + } +#line 804 "project.vala" + new_position = (gint64) 0; +#line 3727 "project.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 805 "project.vala" + while (TRUE) { +#line 3733 "project.c" + ModelTrack* track; +#line 805 "project.vala" + if (!gee_iterator_next (_track_it)) { +#line 805 "project.vala" + break; +#line 3739 "project.c" + } +#line 805 "project.vala" + track = (ModelTrack*) gee_iterator_get (_track_it); +#line 806 "project.vala" + new_position = MAX (new_position, model_track_previous_edit (track, start_pos)); +#line 3745 "project.c" + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } +#line 808 "project.vala" + model_project_transport_go (self, new_position); +#line 3752 "project.c" +} + + +#line 812 "project.vala" +void model_project_go_next (ModelProject* self) { +#line 3758 "project.c" + gint64 start_pos; + gint64 new_position; +#line 812 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 813 "project.vala" + start_pos = model_project_transport_get_position (self); +#line 814 "project.vala" + new_position = model_project_get_length (self); +#line 3767 "project.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 815 "project.vala" + while (TRUE) { +#line 3773 "project.c" + ModelTrack* track; +#line 815 "project.vala" + if (!gee_iterator_next (_track_it)) { +#line 815 "project.vala" + break; +#line 3779 "project.c" + } +#line 815 "project.vala" + track = (ModelTrack*) gee_iterator_get (_track_it); +#line 816 "project.vala" + if (model_track_get_length (track) > start_pos) { +#line 817 "project.vala" + new_position = MIN (new_position, model_track_next_edit (track, start_pos)); +#line 3787 "project.c" + } + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } +#line 820 "project.vala" + model_project_transport_go (self, new_position); +#line 3795 "project.c" +} + + +#line 823 "project.vala" +gint64 model_project_transport_get_position (ModelProject* self) { +#line 3801 "project.c" + gint64 result = 0LL; +#line 823 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), 0LL); +#line 3805 "project.c" + result = self->media_engine->position; +#line 824 "project.vala" + return result; +#line 3809 "project.c" +} + + +#line 827 "project.vala" +void model_project_set_name (ModelProject* self, const char* filename) { +#line 827 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 828 "project.vala" + if (filename != NULL) { +#line 3819 "project.c" + char* _tmp0_; +#line 829 "project.vala" + self->project_file = (_tmp0_ = g_strdup (filename), _g_free0 (self->project_file), _tmp0_); +#line 3823 "project.c" + } +#line 831 "project.vala" + g_signal_emit_by_name (self, "name-changed", filename); +#line 3827 "project.c" +} + + +#line 834 "project.vala" +void model_project_set_default_framerate (ModelProject* self, Fraction* rate) { +#line 834 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 835 "project.vala" + self->default_framerate = *rate; +#line 3837 "project.c" +} + + +#line 1077 "glib-2.0.vapi" +static char* string_substring (const char* self, glong offset, glong len) { +#line 3843 "project.c" + char* result = NULL; + glong string_length; + const char* start; +#line 1077 "glib-2.0.vapi" + g_return_val_if_fail (self != NULL, NULL); +#line 1078 "glib-2.0.vapi" + string_length = g_utf8_strlen (self, -1); +#line 1079 "glib-2.0.vapi" + if (offset < 0) { +#line 1080 "glib-2.0.vapi" + offset = string_length + offset; +#line 1081 "glib-2.0.vapi" + g_return_val_if_fail (offset >= 0, NULL); +#line 3857 "project.c" + } else { +#line 1083 "glib-2.0.vapi" + g_return_val_if_fail (offset <= string_length, NULL); +#line 3861 "project.c" + } +#line 1085 "glib-2.0.vapi" + if (len < 0) { +#line 1086 "glib-2.0.vapi" + len = string_length - offset; +#line 3867 "project.c" + } +#line 1088 "glib-2.0.vapi" + g_return_val_if_fail ((offset + len) <= string_length, NULL); +#line 1089 "glib-2.0.vapi" + start = g_utf8_offset_to_pointer (self, offset); +#line 3873 "project.c" + result = g_strndup (start, ((gchar*) g_utf8_offset_to_pointer (start, len)) - ((gchar*) start)); +#line 1090 "glib-2.0.vapi" + return result; +#line 3877 "project.c" +} + + +static glong string_get_length (const char* self) { + glong result; + g_return_val_if_fail (self != NULL, 0L); + result = g_utf8_strlen (self, -1); +#line 1158 "glib-2.0.vapi" + return result; +#line 3887 "project.c" +} + + +#line 838 "project.vala" +char* model_project_get_file_display_name (ModelProject* self) { +#line 3893 "project.c" + char* result = NULL; + char* filename; +#line 838 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL); +#line 839 "project.vala" + filename = model_project_get_project_file (self); +#line 840 "project.vala" + if (filename == NULL) { +#line 3902 "project.c" + char* _tmp0_; + char* _tmp1_; + result = (_tmp1_ = g_strdup_printf ("Unsaved Project - %s", _tmp0_ = model_project_get_app_name (self)), _g_free0 (_tmp0_), _tmp1_); + _g_free0 (filename); +#line 841 "project.vala" + return result; +#line 3909 "project.c" + } else { + char* dir; + char* name; + char* home_path; + char* _tmp5_; + char* _tmp6_; +#line 844 "project.vala" + dir = g_path_get_dirname (filename); +#line 845 "project.vala" + name = g_path_get_basename (filename); +#line 846 "project.vala" + home_path = g_strdup (g_get_home_dir ()); +#line 848 "project.vala" + if (_vala_strcmp0 (dir, ".") == 0) { +#line 3924 "project.c" + char* _tmp2_; +#line 849 "project.vala" + dir = (_tmp2_ = g_get_current_dir (), _g_free0 (dir), _tmp2_); +#line 3928 "project.c" + } +#line 851 "project.vala" + if (g_str_has_prefix (dir, home_path)) { +#line 3932 "project.c" + char* _tmp4_; + char* _tmp3_; +#line 852 "project.vala" + dir = (_tmp4_ = g_strconcat ("~", _tmp3_ = string_substring (dir, string_get_length (home_path), -1), NULL), _g_free0 (dir), _tmp4_); +#line 3937 "project.c" + _g_free0 (_tmp3_); + } + result = (_tmp6_ = g_strdup_printf ("%s (%s) - %s", name, dir, _tmp5_ = model_project_get_app_name (self)), _g_free0 (_tmp5_), _tmp6_); + _g_free0 (dir); + _g_free0 (name); + _g_free0 (home_path); + _g_free0 (filename); +#line 853 "project.vala" + return result; +#line 3947 "project.c" + _g_free0 (dir); + _g_free0 (name); + _g_free0 (home_path); + } + _g_free0 (filename); +} + + +#line 857 "project.vala" +void model_project_clear (ModelProject* self) { +#line 857 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 858 "project.vala" + view_media_engine_set_gst_state (self->media_engine, GST_STATE_NULL); +#line 3962 "project.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 860 "project.vala" + while (TRUE) { +#line 3968 "project.c" + ModelTrack* track; +#line 860 "project.vala" + if (!gee_iterator_next (_track_it)) { +#line 860 "project.vala" + break; +#line 3974 "project.c" + } +#line 860 "project.vala" + track = (ModelTrack*) gee_iterator_get (_track_it); +#line 861 "project.vala" + model_track_delete_all_clips (track); +#line 862 "project.vala" + g_signal_emit_by_name (track, "track-removed", track); +#line 863 "project.vala" + g_signal_emit_by_name (self, "track-removed", track); +#line 3984 "project.c" + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } +#line 866 "project.vala" + gee_abstract_collection_clear (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 868 "project.vala" + gee_abstract_collection_clear (GEE_ABSTRACT_COLLECTION (self->clipfiles)); +#line 869 "project.vala" + model_project_set_name (self, NULL); +#line 870 "project.vala" + g_signal_emit_by_name (self, "cleared"); +#line 3997 "project.c" +} + + +#line 873 "project.vala" +gboolean model_project_can_export (ModelProject* self) { +#line 4003 "project.c" + gboolean result = FALSE; +#line 873 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), FALSE); +#line 874 "project.vala" + if (view_media_engine_get_play_state (self->media_engine) != PLAY_STATE_STOPPED) { +#line 4009 "project.c" + result = FALSE; +#line 875 "project.vala" + return result; +#line 4013 "project.c" + } + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 877 "project.vala" + while (TRUE) { +#line 4020 "project.c" + ModelTrack* track; +#line 877 "project.vala" + if (!gee_iterator_next (_track_it)) { +#line 877 "project.vala" + break; +#line 4026 "project.c" + } +#line 877 "project.vala" + track = (ModelTrack*) gee_iterator_get (_track_it); +#line 878 "project.vala" + if (model_track_get_length (track) > 0) { +#line 4032 "project.c" + result = TRUE; + _g_object_unref0 (track); + _g_object_unref0 (_track_it); +#line 879 "project.vala" + return result; +#line 4038 "project.c" + } + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } + result = FALSE; +#line 882 "project.vala" + return result; +#line 4047 "project.c" +} + + +#line 885 "project.vala" +void model_project_on_load_started (ModelProject* self, const char* filename) { +#line 4053 "project.c" + char* _tmp0_; +#line 885 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 885 "project.vala" + g_return_if_fail (filename != NULL); +#line 886 "project.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_load_started"); +#line 887 "project.vala" + self->project_file = (_tmp0_ = g_strdup (filename), _g_free0 (self->project_file), _tmp0_); +#line 4063 "project.c" +} + + +#line 890 "project.vala" +static void model_project_on_load_error (ModelProject* self, const char* _error_) { +#line 890 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 890 "project.vala" + g_return_if_fail (_error_ != NULL); +#line 891 "project.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_load_error"); +#line 892 "project.vala" + g_signal_emit_by_name (self, "load-error", _error_); +#line 4077 "project.c" +} + + +#line 895 "project.vala" +static void model_project_on_load_complete (ModelProject* self) { +#line 895 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 896 "project.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_load_complete"); +#line 897 "project.vala" + model_undo_manager_reset (self->undo_manager); +#line 898 "project.vala" + model_project_set_name (self, self->project_file); +#line 899 "project.vala" + g_signal_emit_by_name (self, "load-complete"); +#line 4093 "project.c" +} + + +#line 885 "project.vala" +static void _model_project_on_load_started_model_project_loader_load_started (ModelProjectLoader* _sender, const char* filename, gpointer self) { +#line 4099 "project.c" + model_project_on_load_started (self, filename); +} + + +#line 890 "project.vala" +static void _model_project_on_load_error_model_project_loader_load_error (ModelProjectLoader* _sender, const char* _error_, gpointer self) { +#line 4106 "project.c" + model_project_on_load_error (self, _error_); +} + + +#line 895 "project.vala" +static void _model_project_on_load_complete_model_project_loader_load_complete (ModelProjectLoader* _sender, gpointer self) { +#line 4113 "project.c" + model_project_on_load_complete (self); +} + + +#line 1041 "MediaEngine.vala" +static void _view_media_engine_on_load_complete_model_project_loader_load_complete (ModelProjectLoader* _sender, gpointer self) { +#line 4120 "project.c" + view_media_engine_on_load_complete (self); +} + + +#line 905 "project.vala" +static void model_project_real_load (ModelProject* self, const char* fname) { +#line 4127 "project.c" + ModelProjectLoader* _tmp1_; + ModelMediaLoaderHandler* _tmp0_; +#line 905 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 906 "project.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_LOADING, LOGGING_LEVEL_INFO, "loading project"); +#line 907 "project.vala" + model_project_clear (self); +#line 908 "project.vala" + model_project_set_name (self, NULL); +#line 909 "project.vala" + if (fname == NULL) { +#line 910 "project.vala" + return; +#line 4142 "project.c" + } +#line 913 "project.vala" + self->loader = (_tmp1_ = model_project_loader_new (MODEL_LOADER_HANDLER (_tmp0_ = model_media_loader_handler_new (self)), fname), _g_object_unref0 (self->loader), _tmp1_); +#line 4146 "project.c" + _g_object_unref0 (_tmp0_); +#line 915 "project.vala" + g_signal_connect_object (self->loader, "load-started", (GCallback) _model_project_on_load_started_model_project_loader_load_started, self, 0); +#line 916 "project.vala" + g_signal_connect_object (self->loader, "load-error", (GCallback) _model_project_on_load_error_model_project_loader_load_error, self, 0); +#line 917 "project.vala" + g_signal_connect_object (self->loader, "load-complete", (GCallback) _model_project_on_load_complete_model_project_loader_load_complete, self, 0); +#line 918 "project.vala" + g_signal_connect_object (self->loader, "load-complete", (GCallback) _view_media_engine_on_load_complete_model_project_loader_load_complete, self->media_engine, 0); +#line 919 "project.vala" + view_media_engine_set_play_state (self->media_engine, PLAY_STATE_LOADING); +#line 920 "project.vala" + gst_element_set_state (GST_ELEMENT (self->media_engine->pipeline), GST_STATE_NULL); +#line 921 "project.vala" + model_project_loader_load (self->loader); +#line 4162 "project.c" +} + + +#line 905 "project.vala" +void model_project_load (ModelProject* self, const char* fname) { +#line 905 "project.vala" + MODEL_PROJECT_GET_CLASS (self)->load (self, fname); +#line 4170 "project.c" +} + + +#line 924 "project.vala" +void model_project_on_error_occurred (ModelProject* self, const char* major_error, const char* minor_error) { +#line 924 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 924 "project.vala" + g_return_if_fail (major_error != NULL); +#line 925 "project.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_error_occurred"); +#line 926 "project.vala" + g_signal_emit_by_name (self, "error-occurred", major_error, minor_error); +#line 4184 "project.c" +} + + +#line 929 "project.vala" +gint model_project_get_file_version (ModelProject* self) { +#line 4190 "project.c" + gint result = 0; +#line 929 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), 0); +#line 4194 "project.c" + result = 4; +#line 930 "project.vala" + return result; +#line 4198 "project.c" +} + + +#line 933 "project.vala" +void model_project_save_library (ModelProject* self, FILE* f) { +#line 4204 "project.c" + Fraction r; +#line 933 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 933 "project.vala" + g_return_if_fail (f != NULL); +#line 934 "project.vala" + fprintf (f, " default_framerate; +#line 4214 "project.c" + { + GeeIterator* _t_it; + _t_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 938 "project.vala" + while (TRUE) { +#line 4220 "project.c" + ModelTrack* t; +#line 938 "project.vala" + if (!gee_iterator_next (_t_it)) { +#line 938 "project.vala" + break; +#line 4226 "project.c" + } +#line 938 "project.vala" + t = (ModelTrack*) gee_iterator_get (_t_it); +#line 939 "project.vala" + if (model_track_media_type (t) == MODEL_MEDIA_TYPE_VIDEO) { +#line 4232 "project.c" + ModelTrack* _tmp0_; + ModelVideoTrack* video_track; +#line 940 "project.vala" + video_track = _g_object_ref0 ((_tmp0_ = t, MODEL_IS_VIDEO_TRACK (_tmp0_) ? ((ModelVideoTrack*) _tmp0_) : NULL)); +#line 941 "project.vala" + if (model_video_track_get_framerate (video_track, &r)) { +#line 4239 "project.c" + _g_object_unref0 (video_track); + _g_object_unref0 (t); +#line 942 "project.vala" + break; +#line 4244 "project.c" + } + _g_object_unref0 (video_track); + } + _g_object_unref0 (t); + } + _g_object_unref0 (_t_it); + } +#line 945 "project.vala" + if (!fraction_equal (&r, &model_project_INVALID_FRAME_RATE)) { +#line 946 "project.vala" + fprintf (f, " framerate=\"%d/%d\"", r.numerator, r.denominator); +#line 4256 "project.c" + } +#line 948 "project.vala" + fprintf (f, ">\n"); +#line 4260 "project.c" + { + gint i; +#line 950 "project.vala" + i = 0; +#line 4265 "project.c" + { + gboolean _tmp1_; +#line 950 "project.vala" + _tmp1_ = TRUE; +#line 950 "project.vala" + while (TRUE) { +#line 4272 "project.c" + ModelClipFile* _tmp2_; +#line 950 "project.vala" + if (!_tmp1_) { +#line 950 "project.vala" + i++; +#line 4278 "project.c" + } +#line 950 "project.vala" + _tmp1_ = FALSE; +#line 950 "project.vala" + if (!(i < gee_collection_get_size (GEE_COLLECTION (self->clipfiles)))) { +#line 950 "project.vala" + break; +#line 4286 "project.c" + } +#line 951 "project.vala" + fprintf (f, " \n", (_tmp2_ = (ModelClipFile*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clipfiles), i))->filename, i); +#line 4290 "project.c" + _g_object_unref0 (_tmp2_); + } + } + } +#line 954 "project.vala" + fprintf (f, " \n"); +#line 4297 "project.c" +} + + +#line 957 "project.vala" +static void model_project_real_save (ModelProject* self, const char* filename) { +#line 4303 "project.c" + FILE* f; + const char* _tmp1_; + const char* _tmp2_; + const char* _tmp3_; + char* _tmp4_; +#line 957 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 958 "project.vala" + if (filename != NULL) { +#line 959 "project.vala" + model_project_set_name (self, filename); +#line 4315 "project.c" + } +#line 962 "project.vala" + f = fopen (self->project_file, "w"); +#line 963 "project.vala" + if (f == NULL) { +#line 4321 "project.c" + char* _tmp0_; +#line 964 "project.vala" + g_signal_emit_by_name (self, "error-occurred", "Could not save project", _tmp0_ = g_strdup_printf ("%s: %s", self->project_file, g_strerror (errno))); +#line 4325 "project.c" + _g_free0 (_tmp0_); + _fclose0 (f); +#line 966 "project.vala" + return; +#line 4330 "project.c" + } +#line 968 "project.vala" + fprintf (f, "\n", model_project_get_file_version (self)); +#line 970 "project.vala" + model_project_save_library (self, f); +#line 972 "project.vala" + fprintf (f, " \n"); +#line 4338 "project.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 973 "project.vala" + while (TRUE) { +#line 4344 "project.c" + ModelTrack* track; +#line 973 "project.vala" + if (!gee_iterator_next (_track_it)) { +#line 973 "project.vala" + break; +#line 4350 "project.c" + } +#line 973 "project.vala" + track = (ModelTrack*) gee_iterator_get (_track_it); +#line 974 "project.vala" + model_track_save (track, f); +#line 4356 "project.c" + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->inactive_tracks)); +#line 977 "project.vala" + while (TRUE) { +#line 4366 "project.c" + ModelTrack* track; +#line 977 "project.vala" + if (!gee_iterator_next (_track_it)) { +#line 977 "project.vala" + break; +#line 4372 "project.c" + } +#line 977 "project.vala" + track = (ModelTrack*) gee_iterator_get (_track_it); +#line 978 "project.vala" + model_track_save (track, f); +#line 4378 "project.c" + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } +#line 980 "project.vala" + fprintf (f, " \n"); +#line 981 "project.vala" + fprintf (f, " \n"); +#line 4387 "project.c" + _tmp1_ = NULL; +#line 983 "project.vala" + if (self->click_during_play) { +#line 983 "project.vala" + _tmp1_ = "true"; +#line 4393 "project.c" + } else { +#line 983 "project.vala" + _tmp1_ = "false"; +#line 4397 "project.c" + } + _tmp2_ = NULL; +#line 984 "project.vala" + if (self->click_during_record) { +#line 984 "project.vala" + _tmp2_ = "true"; +#line 4404 "project.c" + } else { +#line 984 "project.vala" + _tmp2_ = "false"; +#line 4408 "project.c" + } +#line 982 "project.vala" + fprintf (f, " \n", _tmp1_, _tmp2_, self->click_volume); +#line 4412 "project.c" + _tmp3_ = NULL; +#line 987 "project.vala" + if (self->library_visible) { +#line 987 "project.vala" + _tmp3_ = "true"; +#line 4418 "project.c" + } else { +#line 987 "project.vala" + _tmp3_ = "false"; +#line 4422 "project.c" + } +#line 986 "project.vala" + fprintf (f, " \n", self->library_width, _tmp3_); +#line 988 "project.vala" + fprintf (f, " \n"); +#line 989 "project.vala" + fprintf (f, " \n"); +#line 990 "project.vala" + fprintf (f, " \n"); +#line 991 "project.vala" + fprintf (f, " \n", self->priv->tempo); +#line 992 "project.vala" + fprintf (f, " \n"); +#line 993 "project.vala" + fprintf (f, " \n"); +#line 994 "project.vala" + fprintf (f, " \n", _tmp4_ = fraction_to_string (&self->priv->time_signature)); +#line 4440 "project.c" + _g_free0 (_tmp4_); +#line 995 "project.vala" + fprintf (f, " \n"); +#line 996 "project.vala" + fprintf (f, " \n"); +#line 998 "project.vala" + fprintf (f, "\n"); +#line 999 "project.vala" + fflush (f); +#line 1002 "project.vala" + model_undo_manager_mark_clean (self->undo_manager); +#line 4452 "project.c" + _fclose0 (f); +} + + +#line 957 "project.vala" +void model_project_save (ModelProject* self, const char* filename) { +#line 957 "project.vala" + MODEL_PROJECT_GET_CLASS (self)->save (self, filename); +#line 4461 "project.c" +} + + +#line 1005 "project.vala" +void model_project_close (ModelProject* self) { +#line 1005 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 1006 "project.vala" + view_media_engine_close (self->media_engine); +#line 4471 "project.c" +} + + +#line 1009 "project.vala" +void model_project_on_importer_clip_complete (ModelProject* self, ModelClipFetcher* fetcher) { +#line 1009 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 1009 "project.vala" + g_return_if_fail (MODEL_IS_CLIP_FETCHER (fetcher)); +#line 1010 "project.vala" + if (MODEL_FETCHER (fetcher)->error_string != NULL) { +#line 1011 "project.vala" + g_signal_emit_by_name (self, "error-occurred", "Error importing clip", MODEL_FETCHER (fetcher)->error_string); +#line 4485 "project.c" + } else { +#line 1013 "project.vala" + model_fetcher_completion_complete (self->priv->fetcher_completion, MODEL_FETCHER (fetcher)); +#line 4489 "project.c" + } +} + + +static gpointer _model_fetcher_completion_ref0 (gpointer self) { + return self ? model_fetcher_completion_ref (self) : NULL; +} + + +#line 1026 "project.vala" +static void _model_project_on_fetcher_ready_model_fetcher_ready (ModelFetcher* _sender, ModelFetcher* fetcher, gpointer self) { +#line 4501 "project.c" + model_project_on_fetcher_ready (self, fetcher); +} + + +#line 1017 "project.vala" +void model_project_create_clip_fetcher (ModelProject* self, ModelFetcherCompletion* fetcher_completion, const char* filename, GError** error) { +#line 4508 "project.c" + GError * _inner_error_; + ModelClipFetcher* fetcher; + ModelFetcherCompletion* _tmp0_; +#line 1017 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 1017 "project.vala" + g_return_if_fail (MODEL_IS_FETCHER_COMPLETION (fetcher_completion)); +#line 1017 "project.vala" + g_return_if_fail (filename != NULL); +#line 4518 "project.c" + _inner_error_ = NULL; +#line 1019 "project.vala" + fetcher = model_clip_fetcher_new (filename, &_inner_error_); +#line 4522 "project.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + return; + } +#line 1020 "project.vala" + self->priv->fetcher_completion = (_tmp0_ = _model_fetcher_completion_ref0 (fetcher_completion), _model_fetcher_completion_unref0 (self->priv->fetcher_completion), _tmp0_); +#line 1021 "project.vala" + g_signal_connect_object (MODEL_FETCHER (fetcher), "ready", (GCallback) _model_project_on_fetcher_ready_model_fetcher_ready, self, 0); +#line 1022 "project.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->pending), fetcher); +#line 4533 "project.c" + _g_object_unref0 (fetcher); +} + + +#line 1026 "project.vala" +static void model_project_on_fetcher_ready (ModelProject* self, ModelFetcher* fetcher) { +#line 4540 "project.c" + ModelFetcher* _tmp0_; +#line 1026 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 1026 "project.vala" + g_return_if_fail (MODEL_IS_FETCHER (fetcher)); +#line 1027 "project.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_fetcher_ready"); +#line 1028 "project.vala" + gee_abstract_collection_remove (GEE_ABSTRACT_COLLECTION (self->priv->pending), (_tmp0_ = fetcher, MODEL_IS_CLIP_FETCHER (_tmp0_) ? ((ModelClipFetcher*) _tmp0_) : NULL)); +#line 1029 "project.vala" + if (fetcher->error_string != NULL) { +#line 1030 "project.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_DEVELOPER_WARNINGS, LOGGING_LEVEL_INFO, fetcher->error_string); +#line 1031 "project.vala" + g_signal_emit_by_name (self, "error-occurred", "Error retrieving clip", fetcher->error_string); +#line 4556 "project.c" + } else { +#line 1033 "project.vala" + if (model_project_get_clipfile_index (self, fetcher->clipfile) == (-1)) { +#line 1034 "project.vala" + model_project_add_clipfile (self, fetcher->clipfile); +#line 4562 "project.c" + } +#line 1036 "project.vala" + model_fetcher_completion_complete (self->priv->fetcher_completion, fetcher); +#line 4566 "project.c" + } +} + + +#line 1040 "project.vala" +gboolean model_project_is_project_extension (ModelProject* self, const char* filename) { +#line 4573 "project.c" + gboolean result = FALSE; + char* extension; + gboolean _tmp0_ = FALSE; +#line 1040 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), FALSE); +#line 1040 "project.vala" + g_return_val_if_fail (filename != NULL, FALSE); +#line 1041 "project.vala" + extension = get_file_extension (filename); +#line 1042 "project.vala" + if (_vala_strcmp0 (extension, MODEL_PROJECT_LOMBARD_FILE_EXTENSION) == 0) { +#line 1042 "project.vala" + _tmp0_ = TRUE; +#line 4587 "project.c" + } else { +#line 1042 "project.vala" + _tmp0_ = _vala_strcmp0 (extension, MODEL_PROJECT_FILLMORE_FILE_EXTENSION) == 0; +#line 4591 "project.c" + } + result = _tmp0_; + _g_free0 (extension); +#line 1042 "project.vala" + return result; +#line 4597 "project.c" +} + + +#line 1045 "project.vala" +void model_project_do_command (ModelProject* self, ModelCommand* the_command) { +#line 1045 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 1045 "project.vala" + g_return_if_fail (MODEL_IS_COMMAND (the_command)); +#line 1046 "project.vala" + model_undo_manager_do_command (self->undo_manager, the_command); +#line 4609 "project.c" +} + + +#line 1049 "project.vala" +void model_project_undo (ModelProject* self) { +#line 1049 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 1050 "project.vala" + model_undo_manager_undo (self->undo_manager); +#line 4619 "project.c" +} + + +#line 1053 "project.vala" +static void model_project_ClearTrackMeters (ModelProject* self) { +#line 1053 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 4627 "project.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 1054 "project.vala" + while (TRUE) { +#line 4633 "project.c" + ModelTrack* track; + ModelTrack* _tmp0_; + ModelAudioTrack* audio_track; +#line 1054 "project.vala" + if (!gee_iterator_next (_track_it)) { +#line 1054 "project.vala" + break; +#line 4641 "project.c" + } +#line 1054 "project.vala" + track = (ModelTrack*) gee_iterator_get (_track_it); +#line 1055 "project.vala" + audio_track = _g_object_ref0 ((_tmp0_ = track, MODEL_IS_AUDIO_TRACK (_tmp0_) ? ((ModelAudioTrack*) _tmp0_) : NULL)); +#line 1056 "project.vala" + if (audio_track != NULL) { +#line 1057 "project.vala" + g_signal_emit_by_name (audio_track, "level-changed", (double) (-100), (double) (-100)); +#line 4651 "project.c" + } + _g_object_unref0 (track); + _g_object_unref0 (audio_track); + } + _g_object_unref0 (_track_it); + } +} + + +#line 1062 "project.vala" +void model_project_create_clip_importer (ModelProject* self, ModelTrack* track, gboolean timeline_add, gint64 time_to_add, gboolean both_tracks, GtkWindow* progress_window_parent, gint number) { +#line 1062 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 1062 "project.vala" + g_return_if_fail ((track == NULL) || MODEL_IS_TRACK (track)); +#line 1062 "project.vala" + g_return_if_fail ((progress_window_parent == NULL) || GTK_IS_WINDOW (progress_window_parent)); +#line 1064 "project.vala" + if (timeline_add) { +#line 4671 "project.c" + ModelLibraryImporter* _tmp0_; +#line 1065 "project.vala" + g_assert (track != NULL); +#line 1066 "project.vala" + self->importer = (_tmp0_ = MODEL_LIBRARY_IMPORTER (model_timeline_importer_new (track, self, time_to_add, both_tracks)), _g_object_unref0 (self->importer), _tmp0_); +#line 4677 "project.c" + } else { + ModelLibraryImporter* _tmp1_; +#line 1068 "project.vala" + self->importer = (_tmp1_ = model_library_importer_new (self), _g_object_unref0 (self->importer), _tmp1_); +#line 4682 "project.c" + } +#line 1070 "project.vala" + if (progress_window_parent != NULL) { +#line 4686 "project.c" + MultiFileProgress* _tmp2_; +#line 1071 "project.vala" + _tmp2_ = g_object_ref_sink (multi_file_progress_new (progress_window_parent, number, "Import", MULTI_FILE_PROGRESS_INTERFACE (self->importer->importer))); +#line 4690 "project.c" + _g_object_unref0 (_tmp2_); + } +} + + +#line 1077 "project.vala" +char* model_project_get_version (ModelProject* self) { +#line 4698 "project.c" + char* result = NULL; +#line 1077 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL); +#line 4702 "project.c" + result = g_strdup (_VERSION); +#line 1078 "project.vala" + return result; +#line 4706 "project.c" +} + + +#line 1081 "project.vala" +static char* model_project_real_get_app_name (ModelProject* self) { +#line 4712 "project.c" + g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL); + g_critical ("Type `%s' does not implement abstract method `model_project_get_app_name'", g_type_name (G_TYPE_FROM_INSTANCE (self))); + return NULL; +} + + +#line 1081 "project.vala" +char* model_project_get_app_name (ModelProject* self) { +#line 1081 "project.vala" + return MODEL_PROJECT_GET_CLASS (self)->get_app_name (self); +#line 4723 "project.c" +} + + +#line 1083 "project.vala" +char* model_project_get_license (ModelProject* self) { +#line 4729 "project.c" + char* result = NULL; + char* _tmp2_; + char* _tmp1_; + char* _tmp0_; + char* _tmp3_; +#line 1083 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL); +#line 4737 "project.c" + result = (_tmp3_ = g_strdup_printf (MODEL_PROJECT_license, _tmp0_ = model_project_get_app_name (self), _tmp1_ = model_project_get_app_name (self), _tmp2_ = model_project_get_app_name (self)), _g_free0 (_tmp2_), _g_free0 (_tmp1_), _g_free0 (_tmp0_), _tmp3_); +#line 1084 "project.vala" + return result; +#line 4741 "project.c" +} + + +#line 1087 "project.vala" +void model_project_set_time_signature (ModelProject* self, Fraction* time_signature) { +#line 4747 "project.c" + ModelTimeSignatureCommand* command; +#line 1087 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 1088 "project.vala" + command = model_time_signature_command_new (self, time_signature); +#line 1089 "project.vala" + model_undo_manager_do_command (self->undo_manager, MODEL_COMMAND (command)); +#line 4755 "project.c" + _model_command_unref0 (command); +} + + +#line 1092 "project.vala" +void _model_project_set_time_signature (ModelProject* self, Fraction* time_signature) { +#line 1092 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 1093 "project.vala" + self->priv->time_signature = *time_signature; +#line 1094 "project.vala" + g_signal_emit_by_name (MODEL_TEMPO_INFORMATION (self), "time-signature-changed", time_signature); +#line 4768 "project.c" +} + + +#line 1097 "project.vala" +static void model_project_real_get_time_signature (ModelTempoInformation* base, Fraction* result) { +#line 4774 "project.c" + ModelProject * self; + self = MODEL_PROJECT (base); + *result = self->priv->time_signature; +#line 1098 "project.vala" + return; +#line 4780 "project.c" +} + + +#line 1101 "project.vala" +void model_project_set_bpm (ModelProject* self, gint bpm) { +#line 4786 "project.c" + ModelBpmCommand* command; +#line 1101 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 1102 "project.vala" + command = model_bpm_command_new (self, bpm); +#line 1103 "project.vala" + model_undo_manager_do_command (self->undo_manager, MODEL_COMMAND (command)); +#line 4794 "project.c" + _model_command_unref0 (command); +} + + +#line 1106 "project.vala" +void _model_project_set_bpm (ModelProject* self, gint bpm) { +#line 1106 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 1107 "project.vala" + self->priv->tempo = bpm; +#line 1108 "project.vala" + g_signal_emit_by_name (MODEL_TEMPO_INFORMATION (self), "bpm-changed", bpm); +#line 4807 "project.c" +} + + +#line 1111 "project.vala" +static gint model_project_real_get_bpm (ModelTempoInformation* base) { +#line 4813 "project.c" + ModelProject * self; + gint result = 0; + self = MODEL_PROJECT (base); + result = self->priv->tempo; +#line 1112 "project.vala" + return result; +#line 4820 "project.c" +} + + +#line 1115 "project.vala" +char* model_project_get_audio_path (ModelProject* self) { +#line 4826 "project.c" + char* result = NULL; + char* path; + char* _tmp0_; +#line 1115 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL); +#line 1116 "project.vala" + path = model_project_get_path (self); +#line 4834 "project.c" + _tmp0_ = NULL; +#line 1117 "project.vala" + if (path == NULL) { +#line 4838 "project.c" + char* _tmp1_; +#line 1117 "project.vala" + _tmp0_ = (_tmp1_ = NULL, _g_free0 (_tmp0_), _tmp1_); +#line 4842 "project.c" + } else { + char* _tmp2_; +#line 1117 "project.vala" + _tmp0_ = (_tmp2_ = g_build_filename (path, "audio files", NULL), _g_free0 (_tmp0_), _tmp2_); +#line 4847 "project.c" + } + result = _tmp0_; + _g_free0 (path); +#line 1117 "project.vala" + return result; +#line 4853 "project.c" +} + + +#line 1120 "project.vala" +static char* model_project_get_path (ModelProject* self) { +#line 4859 "project.c" + char* result = NULL; + char* _tmp0_; +#line 1120 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL); +#line 4864 "project.c" + _tmp0_ = NULL; +#line 1121 "project.vala" + if (self->project_file == NULL) { +#line 4868 "project.c" + char* _tmp1_; +#line 1121 "project.vala" + _tmp0_ = (_tmp1_ = NULL, _g_free0 (_tmp0_), _tmp1_); +#line 4872 "project.c" + } else { + char* _tmp2_; +#line 1121 "project.vala" + _tmp0_ = (_tmp2_ = g_path_get_dirname (self->project_file), _g_free0 (_tmp0_), _tmp2_); +#line 4877 "project.c" + } + result = _tmp0_; +#line 1121 "project.vala" + return result; +#line 4882 "project.c" +} + + +#line 1124 "project.vala" +ModelVideoTrack* model_project_find_video_track (ModelProject* self) { +#line 4888 "project.c" + ModelVideoTrack* result = NULL; +#line 1124 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL); +#line 4892 "project.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 1125 "project.vala" + while (TRUE) { +#line 4898 "project.c" + ModelTrack* track; +#line 1125 "project.vala" + if (!gee_iterator_next (_track_it)) { +#line 1125 "project.vala" + break; +#line 4904 "project.c" + } +#line 1125 "project.vala" + track = (ModelTrack*) gee_iterator_get (_track_it); +#line 1126 "project.vala" + if (MODEL_IS_VIDEO_TRACK (track)) { +#line 4910 "project.c" + ModelTrack* _tmp0_; + result = _g_object_ref0 ((_tmp0_ = track, MODEL_IS_VIDEO_TRACK (_tmp0_) ? ((ModelVideoTrack*) _tmp0_) : NULL)); + _g_object_unref0 (track); + _g_object_unref0 (_track_it); +#line 1127 "project.vala" + return result; +#line 4917 "project.c" + } + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } + result = NULL; +#line 1130 "project.vala" + return result; +#line 4926 "project.c" +} + + +#line 1133 "project.vala" +ModelAudioTrack* model_project_find_audio_track (ModelProject* self) { +#line 4932 "project.c" + ModelAudioTrack* result = NULL; +#line 1133 "project.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (self), NULL); +#line 4936 "project.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 1134 "project.vala" + while (TRUE) { +#line 4942 "project.c" + ModelTrack* track; +#line 1134 "project.vala" + if (!gee_iterator_next (_track_it)) { +#line 1134 "project.vala" + break; +#line 4948 "project.c" + } +#line 1134 "project.vala" + track = (ModelTrack*) gee_iterator_get (_track_it); +#line 1135 "project.vala" + if (MODEL_IS_AUDIO_TRACK (track)) { +#line 4954 "project.c" + ModelTrack* _tmp0_; + result = _g_object_ref0 ((_tmp0_ = track, MODEL_IS_AUDIO_TRACK (_tmp0_) ? ((ModelAudioTrack*) _tmp0_) : NULL)); + _g_object_unref0 (track); + _g_object_unref0 (_track_it); +#line 1136 "project.vala" + return result; +#line 4961 "project.c" + } + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } + result = NULL; +#line 1139 "project.vala" + return result; +#line 4970 "project.c" +} + + +#line 370 "project.vala" +static void model_project_real_load_complete (ModelProject* self) { +#line 370 "project.vala" + g_return_if_fail (MODEL_IS_PROJECT (self)); +#line 4978 "project.c" +} + + +static void model_project_class_init (ModelProjectClass * klass) { + Fraction _tmp1_ = {0}; + model_project_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ModelProjectPrivate)); + MODEL_PROJECT_CLASS (klass)->get_clip_time = model_project_real_get_clip_time; + MODEL_PROJECT_CLASS (klass)->get_project_file = model_project_real_get_project_file; + MODEL_PROJECT_CLASS (klass)->do_append = model_project_real_do_append; + MODEL_PROJECT_CLASS (klass)->add_track = model_project_real_add_track; + MODEL_PROJECT_CLASS (klass)->insert_track = model_project_real_insert_track; + MODEL_PROJECT_CLASS (klass)->load = model_project_real_load; + MODEL_PROJECT_CLASS (klass)->save = model_project_real_save; + MODEL_PROJECT_CLASS (klass)->get_app_name = model_project_real_get_app_name; + MODEL_PROJECT_CLASS (klass)->load_complete = model_project_real_load_complete; + G_OBJECT_CLASS (klass)->finalize = model_project_finalize; + g_signal_new ("playstate_changed", MODEL_TYPE_PROJECT, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__ENUM, G_TYPE_NONE, 1, TYPE_PLAY_STATE); + g_signal_new ("name_changed", MODEL_TYPE_PROJECT, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING); + g_signal_new ("load_error", MODEL_TYPE_PROJECT, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING); + g_signal_new ("load_complete", MODEL_TYPE_PROJECT, G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (ModelProjectClass, load_complete), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); + g_signal_new ("closed", MODEL_TYPE_PROJECT, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); + g_signal_new ("track_added", MODEL_TYPE_PROJECT, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_TRACK); + g_signal_new ("track_removed", MODEL_TYPE_PROJECT, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_TRACK); + g_signal_new ("error_occurred", MODEL_TYPE_PROJECT, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__STRING_STRING, G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRING); + g_signal_new ("clipfile_added", MODEL_TYPE_PROJECT, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_CLIP_FILE); + g_signal_new ("clipfile_removed", MODEL_TYPE_PROJECT, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_CLIP_FILE); + g_signal_new ("cleared", MODEL_TYPE_PROJECT, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); + model_project_INVALID_FRAME_RATE = (fraction_init (&_tmp1_, -1, 1), _tmp1_); +} + + +static void model_project_model_tempo_information_interface_init (ModelTempoInformationIface * iface) { + model_project_model_tempo_information_parent_iface = g_type_interface_peek_parent (iface); + iface->get_time_signature = model_project_real_get_time_signature; + iface->get_bpm = model_project_real_get_bpm; +} + + +static void model_project_instance_init (ModelProject * self) { + Fraction _tmp0_ = {0}; + self->priv = MODEL_PROJECT_GET_PRIVATE (self); + self->tracks = gee_array_list_new (MODEL_TYPE_TRACK, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL); + self->inactive_tracks = gee_array_list_new (MODEL_TYPE_TRACK, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL); + self->priv->pending = gee_hash_set_new (MODEL_TYPE_CLIP_FETCHER, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL); + self->priv->pending_thumbs = gee_array_list_new (MODEL_TYPE_THUMBNAIL_FETCHER, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL); + self->clipfiles = gee_array_list_new (MODEL_TYPE_CLIP_FILE, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL); + self->priv->tempo = 120; + self->priv->time_signature = (fraction_init (&_tmp0_, 4, 4), _tmp0_); + self->click_during_play = FALSE; + self->click_during_record = TRUE; + self->click_volume = 0.8; + self->library_visible = TRUE; + self->library_width = 600; +} + + +static void model_project_finalize (GObject* obj) { + ModelProject * self; + self = MODEL_PROJECT (obj); + _g_object_unref0 (self->tracks); + _g_object_unref0 (self->inactive_tracks); + _g_object_unref0 (self->priv->pending); + _g_object_unref0 (self->priv->pending_thumbs); + _g_object_unref0 (self->clipfiles); + _g_object_unref0 (self->media_engine); + _g_free0 (self->project_file); + _g_object_unref0 (self->loader); + _model_fetcher_completion_unref0 (self->priv->fetcher_completion); + _model_undo_manager_unref0 (self->undo_manager); + _g_object_unref0 (self->importer); + G_OBJECT_CLASS (model_project_parent_class)->finalize (obj); +} + + +GType model_project_get_type (void) { + static volatile gsize model_project_type_id__volatile = 0; + if (g_once_init_enter (&model_project_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelProjectClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_project_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelProject), 0, (GInstanceInitFunc) model_project_instance_init, NULL }; + static const GInterfaceInfo model_tempo_information_info = { (GInterfaceInitFunc) model_project_model_tempo_information_interface_init, (GInterfaceFinalizeFunc) NULL, NULL}; + GType model_project_type_id; + model_project_type_id = g_type_register_static (G_TYPE_OBJECT, "ModelProject", &g_define_type_info, G_TYPE_FLAG_ABSTRACT); + g_type_add_interface_static (model_project_type_id, MODEL_TYPE_TEMPO_INFORMATION, &model_tempo_information_info); + g_once_init_leave (&model_project_type_id__volatile, model_project_type_id); + } + return model_project_type_id__volatile; +} + + +static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) { + if ((array != NULL) && (destroy_func != NULL)) { + int i; + for (i = 0; i < array_length; i = i + 1) { + if (((gpointer*) array)[i] != NULL) { + destroy_func (((gpointer*) array)[i]); + } + } + } +} + + +static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) { + _vala_array_destroy (array, array_length, destroy_func); + g_free (array); +} + + +static gint _vala_array_length (gpointer array) { + int length; + length = 0; + if (array) { + while (((gpointer*) array)[length]) { + length++; + } + } + return length; +} + + +static int _vala_strcmp0 (const char * str1, const char * str2) { + if (str1 == NULL) { + return -(str1 != str2); + } + if (str2 == NULL) { + return str1 != str2; + } + return strcmp (str1, str2); +} + + + +static void g_cclosure_user_marshal_VOID__STRING_STRING (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) { + typedef void (*GMarshalFunc_VOID__STRING_STRING) (gpointer data1, const char* arg_1, const char* arg_2, gpointer data2); + register GMarshalFunc_VOID__STRING_STRING callback; + register GCClosure * cc; + register gpointer data1, data2; + cc = (GCClosure *) closure; + g_return_if_fail (n_param_values == 3); + if (G_CCLOSURE_SWAP_DATA (closure)) { + data1 = closure->data; + data2 = param_values->data[0].v_pointer; + } else { + data1 = param_values->data[0].v_pointer; + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__STRING_STRING) (marshal_data ? marshal_data : cc->callback); + callback (data1, g_value_get_string (param_values + 1), g_value_get_string (param_values + 2), data2); +} + + + diff --git a/src/marina/marina/project.o b/src/marina/marina/project.o new file mode 100644 index 0000000..80fddf2 Binary files /dev/null and b/src/marina/marina/project.o differ diff --git a/src/marina/marina/singledecodebin.c b/src/marina/marina/singledecodebin.c new file mode 100644 index 0000000..f3fc84c --- /dev/null +++ b/src/marina/marina/singledecodebin.c @@ -0,0 +1,1345 @@ +/* singledecodebin.c generated by valac, the Vala compiler + * generated from singledecodebin.vala, do not modify */ + +/* Ported to Vala from singledecodebin.py in Pitivi: + * + * Copyright (c) 2005, Edward Hervey + * + * This program 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 program 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 program; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#include +#include +#include +#include +#include +#include + +#define _g_free0(var) (var = (g_free (var), NULL)) + +#define TYPE_SINGLE_DECODE_BIN (single_decode_bin_get_type ()) +#define SINGLE_DECODE_BIN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SINGLE_DECODE_BIN, SingleDecodeBin)) +#define SINGLE_DECODE_BIN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SINGLE_DECODE_BIN, SingleDecodeBinClass)) +#define IS_SINGLE_DECODE_BIN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SINGLE_DECODE_BIN)) +#define IS_SINGLE_DECODE_BIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SINGLE_DECODE_BIN)) +#define SINGLE_DECODE_BIN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SINGLE_DECODE_BIN, SingleDecodeBinClass)) + +typedef struct _SingleDecodeBin SingleDecodeBin; +typedef struct _SingleDecodeBinClass SingleDecodeBinClass; +typedef struct _SingleDecodeBinPrivate SingleDecodeBinPrivate; +#define _gst_caps_unref0(var) ((var == NULL) ? NULL : (var = (gst_caps_unref (var), NULL))) +#define _gst_object_unref0(var) ((var == NULL) ? NULL : (var = (gst_object_unref (var), NULL))) +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +#define __g_list_free_gst_object_unref0(var) ((var == NULL) ? NULL : (var = (_g_list_free_gst_object_unref (var), NULL))) + +#define LOGGING_TYPE_FACILITY (logging_facility_get_type ()) + +#define LOGGING_TYPE_LEVEL (logging_level_get_type ()) + +struct _SingleDecodeBin { + GstBin parent_instance; + SingleDecodeBinPrivate * priv; +}; + +struct _SingleDecodeBinClass { + GstBinClass parent_class; +}; + +struct _SingleDecodeBinPrivate { + GstCaps* caps; + GstElement* typefind; + GstGhostPad* srcpad; + GeeArrayList* dynamics; + GeeArrayList* validelements; + GstElementFactory** factories; + gint factories_length1; + gint _factories_size_; +}; + +typedef enum { + LOGGING_FACILITY_SIGNAL_HANDLERS, + LOGGING_FACILITY_DEVELOPER_WARNINGS, + LOGGING_FACILITY_GRAPH, + LOGGING_FACILITY_LOADING, + LOGGING_FACILITY_IMPORT, + LOGGING_FACILITY_SINGLEDECODEBIN +} LoggingFacility; + +typedef enum { + LOGGING_LEVEL_CRITICAL, + LOGGING_LEVEL_HIGH, + LOGGING_LEVEL_MEDIUM, + LOGGING_LEVEL_LOW, + LOGGING_LEVEL_INFO, + LOGGING_LEVEL_VERBOSE +} LoggingLevel; + + +static gpointer single_decode_bin_parent_class = NULL; + +void qsort (void* p, gsize num, gsize size, GCompareFunc func); +gboolean is_raw (GstCaps* caps); +GType single_decode_bin_get_type (void); +#define SINGLE_DECODE_BIN_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_SINGLE_DECODE_BIN, SingleDecodeBinPrivate)) +enum { + SINGLE_DECODE_BIN_DUMMY_PROPERTY +}; +#define SINGLE_DECODE_BIN_QUEUE_SIZE ((gint64) (1 * GST_SECOND)) +GstElement* make_element (const char* name, GError** error); +static void single_decode_bin_typefindHaveTypeCb (GstElement* t, gint probability, GstCaps* caps, SingleDecodeBin* data); +static GstElementFactory** single_decode_bin_getSortedFactoryList (SingleDecodeBin* self, int* result_length1); +SingleDecodeBin* single_decode_bin_new (GstCaps* caps, const char* name, const char* uri, GError** error); +SingleDecodeBin* single_decode_bin_construct (GType object_type, GstCaps* caps, const char* name, const char* uri, GError** error); +static void single_decode_bin_dynamicPadAddedCb (SingleDecodeBin* self, GstElement* element, GstPad* pad); +static void _single_decode_bin_dynamicPadAddedCb_gst_element_pad_added (GstElement* _sender, GstPad* pad, gpointer self); +static void single_decode_bin_dynamicNoMorePadsCb (SingleDecodeBin* self, GstElement* element); +static void _single_decode_bin_dynamicNoMorePadsCb_gst_element_no_more_pads (GstElement* _sender, gpointer self); +static void single_decode_bin_controlDynamicElement (SingleDecodeBin* self, GstElement* element); +static gint single_decode_bin_factory_compare (GstElementFactory** a, GstElementFactory** b); +static void _vala_array_add2 (GstElementFactory*** array, int* length, int* size, GstElementFactory* value); +static void _g_list_free_gst_object_unref (GList* self); +static GeeArrayList* single_decode_bin_findCompatibleFactory (SingleDecodeBin* self, GstCaps* caps); +static void _vala_array_add3 (GstPad*** array, int* length, int* size, GstPad* value); +static void _vala_array_add4 (GstPad*** array, int* length, int* size, GstPad* value); +GType logging_facility_get_type (void); +GType logging_level_get_type (void); +void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message); +static void single_decode_bin_closePadLink (SingleDecodeBin* self, GstElement* element, GstPad* pad, GstCaps* caps); +static void single_decode_bin_closeLink (SingleDecodeBin* self, GstElement* element); +static gboolean single_decode_bin_isDemuxer (SingleDecodeBin* self, GstElement* element); +static GstPad* single_decode_bin_plugDecodingQueue (SingleDecodeBin* self, GstPad* pad); +static GstElement* single_decode_bin_tryToLink1 (SingleDecodeBin* self, GstElement* source, GstPad* in_pad, GeeArrayList* factories); +static void single_decode_bin_wrapUp (SingleDecodeBin* self, GstElement* element, GstPad* pad); +static void single_decode_bin_markValidElements (SingleDecodeBin* self, GstElement* element); +static void single_decode_bin_removeUnusedElements (SingleDecodeBin* self, GstElement* element); +static void single_decode_bin_cleanUp (SingleDecodeBin* self); +static GstStateChangeReturn single_decode_bin_real_change_state (GstElement* base, GstStateChange transition); +static void single_decode_bin_finalize (GObject* obj); +static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func); +static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func); + + + +#line 29 "singledecodebin.vala" +gboolean is_raw (GstCaps* caps) { +#line 139 "singledecodebin.c" + gboolean result = FALSE; + char* rep; + char** _tmp1_; + gint _valid_size_; + gint valid_length1; + char** _tmp0_ = NULL; + char** valid; +#line 29 "singledecodebin.vala" + g_return_val_if_fail (GST_IS_CAPS (caps), FALSE); +#line 30 "singledecodebin.vala" + rep = gst_caps_to_string (caps); +#line 151 "singledecodebin.c" + valid = (_tmp1_ = (_tmp0_ = g_new0 (char*, 4 + 1), _tmp0_[0] = g_strdup ("video/x-raw"), _tmp0_[1] = g_strdup ("audio/x-raw"), _tmp0_[2] = g_strdup ("text/plain"), _tmp0_[3] = g_strdup ("text/x-pango-markup"), _tmp0_), valid_length1 = 4, _valid_size_ = valid_length1, _tmp1_); + { + char** val_collection; + int val_collection_length1; + int val_it; +#line 32 "singledecodebin.vala" + val_collection = valid; +#line 159 "singledecodebin.c" + val_collection_length1 = valid_length1; + for (val_it = 0; val_it < valid_length1; val_it = val_it + 1) { + char* val; + val = g_strdup (val_collection[val_it]); + { +#line 33 "singledecodebin.vala" + if (g_str_has_prefix (rep, val)) { +#line 167 "singledecodebin.c" + result = TRUE; + _g_free0 (val); + _g_free0 (rep); + valid = (_vala_array_free (valid, valid_length1, (GDestroyNotify) g_free), NULL); +#line 34 "singledecodebin.vala" + return result; +#line 174 "singledecodebin.c" + } + _g_free0 (val); + } + } + } + result = FALSE; + _g_free0 (rep); + valid = (_vala_array_free (valid, valid_length1, (GDestroyNotify) g_free), NULL); +#line 35 "singledecodebin.vala" + return result; +#line 185 "singledecodebin.c" +} + + +static gpointer _gst_caps_ref0 (gpointer self) { + return self ? gst_caps_ref (self) : NULL; +} + + +static gpointer _gst_object_ref0 (gpointer self) { + return self ? gst_object_ref (self) : NULL; +} + + +#line 61 "singledecodebin.vala" +SingleDecodeBin* single_decode_bin_construct (GType object_type, GstCaps* caps, const char* name, const char* uri, GError** error) { +#line 201 "singledecodebin.c" + GError * _inner_error_; + SingleDecodeBin * self; + GstCaps* _tmp0_; + GstCaps* _tmp3_; + GstElement* _tmp4_; + GstElementFactory** _tmp8_; + gint _tmp7_; +#line 61 "singledecodebin.vala" + g_return_val_if_fail ((caps == NULL) || GST_IS_CAPS (caps), NULL); +#line 61 "singledecodebin.vala" + g_return_val_if_fail (name != NULL, NULL); +#line 213 "singledecodebin.c" + _inner_error_ = NULL; + self = g_object_newv (object_type, 0, NULL); + _tmp0_ = NULL; +#line 62 "singledecodebin.vala" + if (caps == NULL) { +#line 219 "singledecodebin.c" + GstCaps* _tmp1_; +#line 62 "singledecodebin.vala" + _tmp0_ = (_tmp1_ = gst_caps_new_any (), _gst_caps_unref0 (_tmp0_), _tmp1_); +#line 223 "singledecodebin.c" + } else { + GstCaps* _tmp2_; +#line 62 "singledecodebin.vala" + _tmp0_ = (_tmp2_ = _gst_caps_ref0 (caps), _gst_caps_unref0 (_tmp0_), _tmp2_); +#line 228 "singledecodebin.c" + } +#line 62 "singledecodebin.vala" + self->priv->caps = (_tmp3_ = _gst_caps_ref0 (_tmp0_), _gst_caps_unref0 (self->priv->caps), _tmp3_); +#line 64 "singledecodebin.vala" + self->priv->typefind = (_tmp4_ = gst_element_factory_make ("typefind", "internal-typefind"), _gst_object_unref0 (self->priv->typefind), _tmp4_); +#line 65 "singledecodebin.vala" + gst_bin_add (GST_BIN (self), _gst_object_ref0 (self->priv->typefind)); +#line 67 "singledecodebin.vala" + if (uri != NULL) { +#line 238 "singledecodebin.c" + GstElement* file_src; +#line 68 "singledecodebin.vala" + file_src = make_element ("filesrc", &_inner_error_); +#line 242 "singledecodebin.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + _gst_caps_unref0 (_tmp0_); + gst_object_unref (self); + return NULL; + } +#line 70 "singledecodebin.vala" + g_object_set (G_OBJECT (file_src), "location", uri, NULL); +#line 71 "singledecodebin.vala" + gst_bin_add (GST_BIN (self), _gst_object_ref0 (file_src)); +#line 73 "singledecodebin.vala" + gst_element_link (file_src, self->priv->typefind); +#line 255 "singledecodebin.c" + _gst_object_unref0 (file_src); + } else { + GstPad* _tmp5_; + GstGhostPad* _tmp6_; + GstGhostPad* sinkpad; +#line 75 "singledecodebin.vala" + sinkpad = (_tmp6_ = (GstGhostPad*) gst_ghost_pad_new ("sink", _tmp5_ = gst_element_get_pad (self->priv->typefind, "sink")), _gst_object_unref0 (_tmp5_), _tmp6_); +#line 76 "singledecodebin.vala" + gst_pad_set_active (GST_PAD (sinkpad), TRUE); +#line 77 "singledecodebin.vala" + gst_element_add_pad (GST_ELEMENT (self), _gst_object_ref0 (GST_PAD (sinkpad))); +#line 267 "singledecodebin.c" + _gst_object_unref0 (sinkpad); + } +#line 79 "singledecodebin.vala" + g_signal_connect (self->priv->typefind, "have-type", (GCallback) single_decode_bin_typefindHaveTypeCb, self); +#line 81 "singledecodebin.vala" + self->priv->factories = (_tmp8_ = single_decode_bin_getSortedFactoryList (self, &_tmp7_), self->priv->factories = (_vala_array_free (self->priv->factories, self->priv->factories_length1, (GDestroyNotify) gst_object_unref), NULL), self->priv->factories_length1 = _tmp7_, self->priv->_factories_size_ = self->priv->factories_length1, _tmp8_); +#line 274 "singledecodebin.c" + _gst_caps_unref0 (_tmp0_); + return self; +} + + +#line 61 "singledecodebin.vala" +SingleDecodeBin* single_decode_bin_new (GstCaps* caps, const char* name, const char* uri, GError** error) { +#line 61 "singledecodebin.vala" + return single_decode_bin_construct (TYPE_SINGLE_DECODE_BIN, caps, name, uri, error); +#line 284 "singledecodebin.c" +} + + +#line 360 "singledecodebin.vala" +static void _single_decode_bin_dynamicPadAddedCb_gst_element_pad_added (GstElement* _sender, GstPad* pad, gpointer self) { +#line 290 "singledecodebin.c" + single_decode_bin_dynamicPadAddedCb (self, _sender, pad); +} + + +#line 366 "singledecodebin.vala" +static void _single_decode_bin_dynamicNoMorePadsCb_gst_element_no_more_pads (GstElement* _sender, gpointer self) { +#line 297 "singledecodebin.c" + single_decode_bin_dynamicNoMorePadsCb (self, _sender); +} + + +#line 86 "singledecodebin.vala" +static void single_decode_bin_controlDynamicElement (SingleDecodeBin* self, GstElement* element) { +#line 86 "singledecodebin.vala" + g_return_if_fail (IS_SINGLE_DECODE_BIN (self)); +#line 86 "singledecodebin.vala" + g_return_if_fail (GST_IS_ELEMENT (element)); +#line 87 "singledecodebin.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->dynamics), element); +#line 88 "singledecodebin.vala" + g_signal_connect_object (element, "pad-added", (GCallback) _single_decode_bin_dynamicPadAddedCb_gst_element_pad_added, self, 0); +#line 89 "singledecodebin.vala" + g_signal_connect_object (element, "no-more-pads", (GCallback) _single_decode_bin_dynamicNoMorePadsCb_gst_element_no_more_pads, self, 0); +#line 314 "singledecodebin.c" +} + + +#line 92 "singledecodebin.vala" +static gint single_decode_bin_factory_compare (GstElementFactory** a, GstElementFactory** b) { +#line 320 "singledecodebin.c" + gint result = 0; + GstPluginFeature* p1; + GstPluginFeature* p2; +#line 93 "singledecodebin.vala" + p1 = *((GstPluginFeature**) a); +#line 94 "singledecodebin.vala" + p2 = *((GstPluginFeature**) b); +#line 328 "singledecodebin.c" + result = (gint) (gst_plugin_feature_get_rank (GST_PLUGIN_FEATURE (p2)) - gst_plugin_feature_get_rank (GST_PLUGIN_FEATURE (p1))); +#line 95 "singledecodebin.vala" + return result; +#line 332 "singledecodebin.c" +} + + +#line 1144 "glib-2.0.vapi" +static gboolean string_contains (const char* self, const char* needle) { +#line 338 "singledecodebin.c" + gboolean result = FALSE; +#line 1144 "glib-2.0.vapi" + g_return_val_if_fail (self != NULL, FALSE); +#line 1144 "glib-2.0.vapi" + g_return_val_if_fail (needle != NULL, FALSE); +#line 344 "singledecodebin.c" + result = strstr (self, needle) != NULL; +#line 1145 "glib-2.0.vapi" + return result; +#line 348 "singledecodebin.c" +} + + +static void _vala_array_add2 (GstElementFactory*** array, int* length, int* size, GstElementFactory* value) { + if ((*length) == (*size)) { + *size = (*size) ? (2 * (*size)) : 4; + *array = g_renew (GstElementFactory*, *array, (*size) + 1); + } + (*array)[(*length)++] = value; + (*array)[*length] = NULL; +} + + +static void _g_list_free_gst_object_unref (GList* self) { + g_list_foreach (self, (GFunc) gst_object_unref, NULL); + g_list_free (self); +} + + +#line 99 "singledecodebin.vala" +static GstElementFactory** single_decode_bin_getSortedFactoryList (SingleDecodeBin* self, int* result_length1) { +#line 370 "singledecodebin.c" + GstElementFactory** result = NULL; + GstRegistry* registry; + GstElementFactory** _tmp0_; + gint _factories_size_; + gint factories_length1; + GstElementFactory** factories; + GstElementFactory** _tmp5_; +#line 99 "singledecodebin.vala" + g_return_val_if_fail (IS_SINGLE_DECODE_BIN (self), NULL); +#line 100 "singledecodebin.vala" + registry = _gst_object_ref0 (gst_registry_get_default ()); +#line 382 "singledecodebin.c" + factories = (_tmp0_ = g_new0 (GstElementFactory*, 0 + 1), factories_length1 = 0, _factories_size_ = factories_length1, _tmp0_); + { + GList* plugin_feature_collection; + GList* plugin_feature_it; +#line 103 "singledecodebin.vala" + plugin_feature_collection = gst_registry_get_feature_list (registry, GST_TYPE_ELEMENT_FACTORY); +#line 389 "singledecodebin.c" + for (plugin_feature_it = plugin_feature_collection; plugin_feature_it != NULL; plugin_feature_it = plugin_feature_it->next) { + GstPluginFeature* plugin_feature; +#line 103 "singledecodebin.vala" + plugin_feature = _gst_object_ref0 ((GstPluginFeature*) plugin_feature_it->data); +#line 394 "singledecodebin.c" + { + GstPluginFeature* _tmp1_; + GstElementFactory* factory; + gboolean _tmp2_ = FALSE; + char* klass; + gboolean _tmp3_ = FALSE; + gboolean _tmp4_ = FALSE; +#line 106 "singledecodebin.vala" + factory = _gst_object_ref0 ((_tmp1_ = plugin_feature, GST_IS_ELEMENT_FACTORY (_tmp1_) ? ((GstElementFactory*) _tmp1_) : NULL)); +#line 107 "singledecodebin.vala" + if (factory == NULL) { +#line 107 "singledecodebin.vala" + _tmp2_ = TRUE; +#line 408 "singledecodebin.c" + } else { +#line 107 "singledecodebin.vala" + _tmp2_ = gst_plugin_feature_get_rank (GST_PLUGIN_FEATURE (factory)) < 64; +#line 412 "singledecodebin.c" + } +#line 107 "singledecodebin.vala" + if (_tmp2_) { +#line 416 "singledecodebin.c" + _gst_object_unref0 (plugin_feature); + _gst_object_unref0 (factory); +#line 108 "singledecodebin.vala" + continue; +#line 421 "singledecodebin.c" + } +#line 109 "singledecodebin.vala" + klass = g_strdup (gst_element_factory_get_klass (factory)); +#line 110 "singledecodebin.vala" + if (string_contains (klass, "Demuxer")) { +#line 110 "singledecodebin.vala" + _tmp4_ = TRUE; +#line 429 "singledecodebin.c" + } else { +#line 110 "singledecodebin.vala" + _tmp4_ = string_contains (klass, "Decoder"); +#line 433 "singledecodebin.c" + } +#line 110 "singledecodebin.vala" + if (_tmp4_) { +#line 110 "singledecodebin.vala" + _tmp3_ = TRUE; +#line 439 "singledecodebin.c" + } else { +#line 110 "singledecodebin.vala" + _tmp3_ = string_contains (klass, "Parse"); +#line 443 "singledecodebin.c" + } +#line 110 "singledecodebin.vala" + if (_tmp3_) { +#line 111 "singledecodebin.vala" + _vala_array_add2 (&factories, &factories_length1, &_factories_size_, _gst_object_ref0 (factory)); +#line 449 "singledecodebin.c" + } + _gst_object_unref0 (plugin_feature); + _gst_object_unref0 (factory); + _g_free0 (klass); + } + } +#line 103 "singledecodebin.vala" + __g_list_free_gst_object_unref0 (plugin_feature_collection); +#line 458 "singledecodebin.c" + } +#line 114 "singledecodebin.vala" + qsort (factories, (gsize) factories_length1, (gsize) sizeof (GstElementFactory*), (GCompareFunc) single_decode_bin_factory_compare); +#line 462 "singledecodebin.c" + result = (_tmp5_ = factories, *result_length1 = factories_length1, _tmp5_); + _gst_object_unref0 (registry); +#line 116 "singledecodebin.vala" + return result; +#line 467 "singledecodebin.c" + _gst_object_unref0 (registry); + factories = (_vala_array_free (factories, factories_length1, (GDestroyNotify) gst_object_unref), NULL); +} + + +#line 121 "singledecodebin.vala" +static GeeArrayList* single_decode_bin_findCompatibleFactory (SingleDecodeBin* self, GstCaps* caps) { +#line 475 "singledecodebin.c" + GeeArrayList* result = NULL; + GeeArrayList* res; +#line 121 "singledecodebin.vala" + g_return_val_if_fail (IS_SINGLE_DECODE_BIN (self), NULL); +#line 121 "singledecodebin.vala" + g_return_val_if_fail (GST_IS_CAPS (caps), NULL); +#line 122 "singledecodebin.vala" + res = gee_array_list_new (GST_TYPE_ELEMENT_FACTORY, (GBoxedCopyFunc) gst_object_ref, gst_object_unref, NULL); +#line 484 "singledecodebin.c" + { + GstElementFactory** factory_collection; + int factory_collection_length1; + int factory_it; +#line 124 "singledecodebin.vala" + factory_collection = self->priv->factories; +#line 491 "singledecodebin.c" + factory_collection_length1 = self->priv->factories_length1; + for (factory_it = 0; factory_it < self->priv->factories_length1; factory_it = factory_it + 1) { + GstElementFactory* factory; + factory = _gst_object_ref0 (factory_collection[factory_it]); + { + GList* templates; +#line 125 "singledecodebin.vala" + templates = gst_element_factory_get_static_pad_templates (factory); +#line 500 "singledecodebin.c" + { + GList* template_collection; + GList* template_it; +#line 126 "singledecodebin.vala" + template_collection = templates; +#line 506 "singledecodebin.c" + for (template_it = template_collection; template_it != NULL; template_it = template_it->next) { + GstStaticPadTemplate template; +#line 126 "singledecodebin.vala" + template = *((GstStaticPadTemplate*) template_it->data); +#line 511 "singledecodebin.c" + { +#line 127 "singledecodebin.vala" + if (template.direction == GST_PAD_SINK) { +#line 515 "singledecodebin.c" + GstCaps* _tmp0_; + GstCaps* _tmp1_; + GstCaps* intersect; +#line 128 "singledecodebin.vala" + intersect = (_tmp1_ = gst_caps_intersect (caps, _tmp0_ = gst_static_caps_get (&template.static_caps)), _gst_caps_unref0 (_tmp0_), _tmp1_); +#line 129 "singledecodebin.vala" + if (!gst_caps_is_empty (intersect)) { +#line 130 "singledecodebin.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (res), factory); +#line 525 "singledecodebin.c" + _gst_caps_unref0 (intersect); +#line 131 "singledecodebin.vala" + break; +#line 529 "singledecodebin.c" + } + _gst_caps_unref0 (intersect); + } + } + } + } + _gst_object_unref0 (factory); + } + } + } + result = res; +#line 136 "singledecodebin.vala" + return result; +#line 543 "singledecodebin.c" +} + + +static void _vala_array_add3 (GstPad*** array, int* length, int* size, GstPad* value) { + if ((*length) == (*size)) { + *size = (*size) ? (2 * (*size)) : 4; + *array = g_renew (GstPad*, *array, (*size) + 1); + } + (*array)[(*length)++] = value; + (*array)[*length] = NULL; +} + + +static void _vala_array_add4 (GstPad*** array, int* length, int* size, GstPad* value) { + if ((*length) == (*size)) { + *size = (*size) ? (2 * (*size)) : 4; + *array = g_renew (GstPad*, *array, (*size) + 1); + } + (*array)[(*length)++] = value; + (*array)[*length] = NULL; +} + + +#line 142 "singledecodebin.vala" +static void single_decode_bin_closeLink (SingleDecodeBin* self, GstElement* element) { +#line 569 "singledecodebin.c" + GstPad** _tmp0_; + gint _to_connect_size_; + gint to_connect_length1; + GstPad** to_connect; + gboolean is_dynamic; +#line 142 "singledecodebin.vala" + g_return_if_fail (IS_SINGLE_DECODE_BIN (self)); +#line 142 "singledecodebin.vala" + g_return_if_fail (GST_IS_ELEMENT (element)); +#line 579 "singledecodebin.c" + to_connect = (_tmp0_ = g_new0 (GstPad*, 0 + 1), to_connect_length1 = 0, _to_connect_size_ = to_connect_length1, _tmp0_); +#line 144 "singledecodebin.vala" + is_dynamic = FALSE; +#line 583 "singledecodebin.c" + { + GList* template_collection; + GList* template_it; +#line 146 "singledecodebin.vala" + template_collection = gst_element_class_get_pad_template_list (GST_ELEMENT_CLASS (G_OBJECT_GET_CLASS (element))); +#line 589 "singledecodebin.c" + for (template_it = template_collection; template_it != NULL; template_it = template_it->next) { + GstPadTemplate* template; +#line 146 "singledecodebin.vala" + template = _gst_object_ref0 ((GstPadTemplate*) template_it->data); +#line 594 "singledecodebin.c" + { + GstPadDirection _tmp1_; + GstPadPresence _tmp2_; +#line 147 "singledecodebin.vala" + if ((g_object_get (template, "direction", &_tmp1_, NULL), _tmp1_) != GST_PAD_SRC) { +#line 600 "singledecodebin.c" + _gst_object_unref0 (template); +#line 148 "singledecodebin.vala" + continue; +#line 604 "singledecodebin.c" + } +#line 149 "singledecodebin.vala" + if ((g_object_get (template, "presence", &_tmp2_, NULL), _tmp2_) == GST_PAD_ALWAYS) { +#line 608 "singledecodebin.c" + char* _tmp4_; + char* _tmp3_ = NULL; + GstPad* _tmp5_; + GstPad* pad; +#line 150 "singledecodebin.vala" + pad = (_tmp5_ = gst_element_get_pad (element, _tmp4_ = (g_object_get (template, "name-template", &_tmp3_, NULL), _tmp3_)), _g_free0 (_tmp4_), _tmp5_); +#line 151 "singledecodebin.vala" + _vala_array_add3 (&to_connect, &to_connect_length1, &_to_connect_size_, _gst_object_ref0 (pad)); +#line 617 "singledecodebin.c" + _gst_object_unref0 (pad); + } else { + GstPadPresence _tmp6_; +#line 152 "singledecodebin.vala" + if ((g_object_get (template, "presence", &_tmp6_, NULL), _tmp6_) == GST_PAD_SOMETIMES) { +#line 623 "singledecodebin.c" + char* _tmp8_; + char* _tmp7_ = NULL; + GstPad* _tmp9_; + GstPad* pad; +#line 153 "singledecodebin.vala" + pad = (_tmp9_ = gst_element_get_pad (element, _tmp8_ = (g_object_get (template, "name-template", &_tmp7_, NULL), _tmp7_)), _g_free0 (_tmp8_), _tmp9_); +#line 154 "singledecodebin.vala" + if (pad != NULL) { +#line 155 "singledecodebin.vala" + _vala_array_add4 (&to_connect, &to_connect_length1, &_to_connect_size_, _gst_object_ref0 (pad)); +#line 634 "singledecodebin.c" + } else { +#line 156 "singledecodebin.vala" + is_dynamic = TRUE; +#line 638 "singledecodebin.c" + } + _gst_object_unref0 (pad); + } + } + _gst_object_unref0 (template); + } + } + } +#line 160 "singledecodebin.vala" + if (is_dynamic) { +#line 649 "singledecodebin.c" + char* _tmp11_; + char* _tmp10_; +#line 161 "singledecodebin.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_VERBOSE, _tmp11_ = g_strdup_printf ("%s is a dynamic element", _tmp10_ = gst_object_get_name (GST_OBJECT (element)))); +#line 654 "singledecodebin.c" + _g_free0 (_tmp11_); + _g_free0 (_tmp10_); +#line 163 "singledecodebin.vala" + single_decode_bin_controlDynamicElement (self, element); +#line 659 "singledecodebin.c" + } + { + GstPad** pad_collection; + int pad_collection_length1; + int pad_it; +#line 166 "singledecodebin.vala" + pad_collection = to_connect; +#line 667 "singledecodebin.c" + pad_collection_length1 = to_connect_length1; + for (pad_it = 0; pad_it < to_connect_length1; pad_it = pad_it + 1) { + GstPad* pad; + pad = _gst_object_ref0 (pad_collection[pad_it]); + { + GstCaps* _tmp12_; +#line 167 "singledecodebin.vala" + single_decode_bin_closePadLink (self, element, pad, _tmp12_ = gst_pad_get_caps (pad)); +#line 676 "singledecodebin.c" + _gst_caps_unref0 (_tmp12_); + _gst_object_unref0 (pad); + } + } + } + to_connect = (_vala_array_free (to_connect, to_connect_length1, (GDestroyNotify) gst_object_unref), NULL); +} + + +#line 170 "singledecodebin.vala" +static gboolean single_decode_bin_isDemuxer (SingleDecodeBin* self, GstElement* element) { +#line 688 "singledecodebin.c" + gboolean result = FALSE; + gint potential_src_pads; +#line 170 "singledecodebin.vala" + g_return_val_if_fail (IS_SINGLE_DECODE_BIN (self), FALSE); +#line 170 "singledecodebin.vala" + g_return_val_if_fail (GST_IS_ELEMENT (element), FALSE); +#line 171 "singledecodebin.vala" + if (!string_contains (gst_element_factory_get_klass (gst_element_get_factory (element)), "Demux")) { +#line 697 "singledecodebin.c" + result = FALSE; +#line 172 "singledecodebin.vala" + return result; +#line 701 "singledecodebin.c" + } +#line 174 "singledecodebin.vala" + potential_src_pads = 0; +#line 705 "singledecodebin.c" + { + GList* template_collection; + GList* template_it; +#line 175 "singledecodebin.vala" + template_collection = gst_element_class_get_pad_template_list (GST_ELEMENT_CLASS (G_OBJECT_GET_CLASS (element))); +#line 711 "singledecodebin.c" + for (template_it = template_collection; template_it != NULL; template_it = template_it->next) { + GstPadTemplate* template; +#line 175 "singledecodebin.vala" + template = _gst_object_ref0 ((GstPadTemplate*) template_it->data); +#line 716 "singledecodebin.c" + { + GstPadDirection _tmp0_; + gboolean _tmp1_ = FALSE; + GstPadPresence _tmp2_; +#line 176 "singledecodebin.vala" + if ((g_object_get (template, "direction", &_tmp0_, NULL), _tmp0_) != GST_PAD_SRC) { +#line 723 "singledecodebin.c" + _gst_object_unref0 (template); +#line 177 "singledecodebin.vala" + continue; +#line 727 "singledecodebin.c" + } +#line 179 "singledecodebin.vala" + if ((g_object_get (template, "presence", &_tmp2_, NULL), _tmp2_) == GST_PAD_REQUEST) { +#line 179 "singledecodebin.vala" + _tmp1_ = TRUE; +#line 733 "singledecodebin.c" + } else { + char* _tmp4_; + char* _tmp3_ = NULL; +#line 180 "singledecodebin.vala" + _tmp1_ = string_contains (_tmp4_ = (g_object_get (template, "name-template", &_tmp3_, NULL), _tmp3_), "%"); +#line 739 "singledecodebin.c" + _g_free0 (_tmp4_); + } +#line 179 "singledecodebin.vala" + if (_tmp1_) { +#line 181 "singledecodebin.vala" + potential_src_pads = potential_src_pads + 2; +#line 746 "singledecodebin.c" + _gst_object_unref0 (template); +#line 182 "singledecodebin.vala" + break; +#line 750 "singledecodebin.c" + } else { +#line 183 "singledecodebin.vala" + potential_src_pads = potential_src_pads + 1; +#line 754 "singledecodebin.c" + } + _gst_object_unref0 (template); + } + } + } + result = potential_src_pads > 1; +#line 186 "singledecodebin.vala" + return result; +#line 763 "singledecodebin.c" +} + + +#line 189 "singledecodebin.vala" +static GstPad* single_decode_bin_plugDecodingQueue (SingleDecodeBin* self, GstPad* pad) { +#line 769 "singledecodebin.c" + GstPad* result = NULL; + GstElement* queue; + GValue _tmp1_; + GValue _tmp0_ = {0}; + GstPad* _tmp2_; +#line 189 "singledecodebin.vala" + g_return_val_if_fail (IS_SINGLE_DECODE_BIN (self), NULL); +#line 189 "singledecodebin.vala" + g_return_val_if_fail (GST_IS_PAD (pad), NULL); +#line 190 "singledecodebin.vala" + queue = gst_element_factory_make ("queue", NULL); +#line 191 "singledecodebin.vala" + g_object_set_property (G_OBJECT (queue), "max_size_time", (_tmp1_ = (g_value_init (&_tmp0_, G_TYPE_INT64), g_value_set_int64 (&_tmp0_, SINGLE_DECODE_BIN_QUEUE_SIZE), _tmp0_), &_tmp1_)); +#line 192 "singledecodebin.vala" + gst_bin_add (GST_BIN (self), _gst_object_ref0 (queue)); +#line 193 "singledecodebin.vala" + gst_element_sync_state_with_parent (queue); +#line 194 "singledecodebin.vala" + gst_pad_link (pad, _tmp2_ = gst_element_get_pad (queue, "sink")); +#line 789 "singledecodebin.c" + _gst_object_unref0 (_tmp2_); + result = gst_element_get_pad (queue, "src"); + _gst_object_unref0 (queue); +#line 195 "singledecodebin.vala" + return result; +#line 795 "singledecodebin.c" +} + + +#line 200 "singledecodebin.vala" +static GstElement* single_decode_bin_tryToLink1 (SingleDecodeBin* self, GstElement* source, GstPad* in_pad, GeeArrayList* factories) { +#line 801 "singledecodebin.c" + GstElement* result = NULL; + GstPad* pad; + GstElement* _result_; +#line 200 "singledecodebin.vala" + g_return_val_if_fail (IS_SINGLE_DECODE_BIN (self), NULL); +#line 200 "singledecodebin.vala" + g_return_val_if_fail (GST_IS_ELEMENT (source), NULL); +#line 200 "singledecodebin.vala" + g_return_val_if_fail (GST_IS_PAD (in_pad), NULL); +#line 200 "singledecodebin.vala" + g_return_val_if_fail (GEE_IS_ARRAY_LIST (factories), NULL); +#line 202 "singledecodebin.vala" + pad = _gst_object_ref0 (in_pad); +#line 203 "singledecodebin.vala" + if (single_decode_bin_isDemuxer (self, source)) { +#line 817 "singledecodebin.c" + GstPad* _tmp0_; +#line 204 "singledecodebin.vala" + pad = (_tmp0_ = single_decode_bin_plugDecodingQueue (self, in_pad), _gst_object_unref0 (pad), _tmp0_); +#line 821 "singledecodebin.c" + } +#line 206 "singledecodebin.vala" + _result_ = NULL; +#line 825 "singledecodebin.c" + { + GeeIterator* _factory_it; + _factory_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (factories)); +#line 207 "singledecodebin.vala" + while (TRUE) { +#line 831 "singledecodebin.c" + GstElementFactory* factory; + GstElement* element; + GstPad* sinkpad; + GstElement* _tmp1_; +#line 207 "singledecodebin.vala" + if (!gee_iterator_next (_factory_it)) { +#line 207 "singledecodebin.vala" + break; +#line 840 "singledecodebin.c" + } +#line 207 "singledecodebin.vala" + factory = (GstElementFactory*) gee_iterator_get (_factory_it); +#line 208 "singledecodebin.vala" + element = gst_element_factory_create (factory, NULL); +#line 209 "singledecodebin.vala" + if (element == NULL) { +#line 210 "singledecodebin.vala" + g_warning ("singledecodebin.vala:210: couldn't create element from factory"); +#line 850 "singledecodebin.c" + _gst_object_unref0 (factory); + _gst_object_unref0 (element); +#line 211 "singledecodebin.vala" + continue; +#line 855 "singledecodebin.c" + } +#line 214 "singledecodebin.vala" + sinkpad = gst_element_get_pad (element, "sink"); +#line 215 "singledecodebin.vala" + if (sinkpad == NULL) { +#line 861 "singledecodebin.c" + _gst_object_unref0 (factory); + _gst_object_unref0 (element); + _gst_object_unref0 (sinkpad); +#line 216 "singledecodebin.vala" + continue; +#line 867 "singledecodebin.c" + } +#line 218 "singledecodebin.vala" + gst_bin_add (GST_BIN (self), _gst_object_ref0 (element)); +#line 219 "singledecodebin.vala" + gst_element_set_state (element, GST_STATE_READY); +#line 220 "singledecodebin.vala" + if (gst_pad_link (pad, sinkpad) != GST_PAD_LINK_OK) { +#line 221 "singledecodebin.vala" + gst_element_set_state (element, GST_STATE_NULL); +#line 222 "singledecodebin.vala" + gst_bin_remove (GST_BIN (self), element); +#line 879 "singledecodebin.c" + _gst_object_unref0 (factory); + _gst_object_unref0 (element); + _gst_object_unref0 (sinkpad); +#line 223 "singledecodebin.vala" + continue; +#line 885 "singledecodebin.c" + } +#line 226 "singledecodebin.vala" + single_decode_bin_closeLink (self, element); +#line 227 "singledecodebin.vala" + gst_element_set_state (element, GST_STATE_PAUSED); +#line 229 "singledecodebin.vala" + _result_ = (_tmp1_ = _gst_object_ref0 (element), _gst_object_unref0 (_result_), _tmp1_); +#line 893 "singledecodebin.c" + _gst_object_unref0 (factory); + _gst_object_unref0 (element); + _gst_object_unref0 (sinkpad); +#line 230 "singledecodebin.vala" + break; +#line 899 "singledecodebin.c" + } + _g_object_unref0 (_factory_it); + } + result = _result_; + _gst_object_unref0 (pad); +#line 233 "singledecodebin.vala" + return result; +#line 907 "singledecodebin.c" +} + + +#line 239 "singledecodebin.vala" +static void single_decode_bin_closePadLink (SingleDecodeBin* self, GstElement* element, GstPad* pad, GstCaps* caps) { +#line 913 "singledecodebin.c" + char* _tmp3_; + char* _tmp2_; + char* _tmp1_; + char* _tmp0_; + GstCaps* _tmp4_; + gboolean _tmp5_; +#line 239 "singledecodebin.vala" + g_return_if_fail (IS_SINGLE_DECODE_BIN (self)); +#line 239 "singledecodebin.vala" + g_return_if_fail (GST_IS_ELEMENT (element)); +#line 239 "singledecodebin.vala" + g_return_if_fail (GST_IS_PAD (pad)); +#line 239 "singledecodebin.vala" + g_return_if_fail (GST_IS_CAPS (caps)); +#line 240 "singledecodebin.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_VERBOSE, _tmp3_ = g_strdup_printf ("element:%s, pad:%s, caps:%s", _tmp0_ = gst_object_get_name (GST_OBJECT (element)), _tmp1_ = gst_object_get_name (GST_OBJECT (pad)), _tmp2_ = gst_caps_to_string (caps))); +#line 930 "singledecodebin.c" + _g_free0 (_tmp3_); + _g_free0 (_tmp2_); + _g_free0 (_tmp1_); + _g_free0 (_tmp0_); +#line 244 "singledecodebin.vala" + if (gst_caps_is_empty (caps)) { +#line 245 "singledecodebin.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_INFO, "unknown type"); +#line 246 "singledecodebin.vala" + return; +#line 941 "singledecodebin.c" + } +#line 248 "singledecodebin.vala" + if (gst_caps_is_any (caps)) { +#line 249 "singledecodebin.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_VERBOSE, "type is not known yet, waiting"); +#line 250 "singledecodebin.vala" + return; +#line 949 "singledecodebin.c" + } +#line 253 "singledecodebin.vala" + gst_pad_get_direction (pad); +#line 255 "singledecodebin.vala" + if ((_tmp5_ = !gst_caps_is_empty (_tmp4_ = gst_caps_intersect (caps, self->priv->caps)), _gst_caps_unref0 (_tmp4_), _tmp5_)) { +#line 257 "singledecodebin.vala" + if (self->priv->srcpad == NULL) { +#line 258 "singledecodebin.vala" + single_decode_bin_wrapUp (self, element, pad); +#line 959 "singledecodebin.c" + } + } else { +#line 259 "singledecodebin.vala" + if (is_raw (caps)) { +#line 260 "singledecodebin.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_VERBOSE, "We hit a raw caps which isn't the wanted one"); +#line 966 "singledecodebin.c" + } else { + GeeArrayList* facts; + GstElement* _tmp6_; +#line 265 "singledecodebin.vala" + if (gst_caps_get_size (caps) > 1) { +#line 266 "singledecodebin.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_VERBOSE, "many possible types, delaying"); +#line 268 "singledecodebin.vala" + return; +#line 976 "singledecodebin.c" + } +#line 270 "singledecodebin.vala" + facts = single_decode_bin_findCompatibleFactory (self, caps); +#line 271 "singledecodebin.vala" + if (gee_collection_get_size (GEE_COLLECTION (facts)) == 0) { +#line 272 "singledecodebin.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_VERBOSE, "unknown type"); +#line 984 "singledecodebin.c" + _g_object_unref0 (facts); +#line 274 "singledecodebin.vala" + return; +#line 988 "singledecodebin.c" + } +#line 276 "singledecodebin.vala" + _tmp6_ = single_decode_bin_tryToLink1 (self, element, pad, facts); +#line 992 "singledecodebin.c" + _gst_object_unref0 (_tmp6_); + _g_object_unref0 (facts); + } + } +} + + +#line 282 "singledecodebin.vala" +static void single_decode_bin_wrapUp (SingleDecodeBin* self, GstElement* element, GstPad* pad) { +#line 1002 "singledecodebin.c" + char* _tmp1_; + char* _tmp0_; + GstGhostPad* _tmp2_; +#line 282 "singledecodebin.vala" + g_return_if_fail (IS_SINGLE_DECODE_BIN (self)); +#line 282 "singledecodebin.vala" + g_return_if_fail (GST_IS_ELEMENT (element)); +#line 282 "singledecodebin.vala" + g_return_if_fail (GST_IS_PAD (pad)); +#line 283 "singledecodebin.vala" + if (self->priv->srcpad != NULL) { +#line 284 "singledecodebin.vala" + return; +#line 1016 "singledecodebin.c" + } +#line 285 "singledecodebin.vala" + single_decode_bin_markValidElements (self, element); +#line 286 "singledecodebin.vala" + single_decode_bin_removeUnusedElements (self, self->priv->typefind); +#line 287 "singledecodebin.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_VERBOSE, _tmp1_ = g_strdup_printf ("ghosting pad %s", _tmp0_ = gst_object_get_name (GST_OBJECT (pad)))); +#line 1024 "singledecodebin.c" + _g_free0 (_tmp1_); + _g_free0 (_tmp0_); +#line 289 "singledecodebin.vala" + self->priv->srcpad = (_tmp2_ = (GstGhostPad*) gst_ghost_pad_new ("src", pad), _gst_object_unref0 (self->priv->srcpad), _tmp2_); +#line 290 "singledecodebin.vala" + if (gst_caps_is_fixed (self->priv->caps)) { +#line 291 "singledecodebin.vala" + gst_pad_set_caps (GST_PAD (self->priv->srcpad), self->priv->caps); +#line 1033 "singledecodebin.c" + } +#line 293 "singledecodebin.vala" + gst_pad_set_active (GST_PAD (self->priv->srcpad), TRUE); +#line 295 "singledecodebin.vala" + gst_element_add_pad (GST_ELEMENT (self), _gst_object_ref0 (GST_PAD (self->priv->srcpad))); +#line 296 "singledecodebin.vala" + gst_element_post_message (GST_ELEMENT (self), gst_message_new_state_dirty (GST_OBJECT (self))); +#line 1041 "singledecodebin.c" +} + + +#line 300 "singledecodebin.vala" +static void single_decode_bin_markValidElements (SingleDecodeBin* self, GstElement* element) { +#line 1047 "singledecodebin.c" + char* _tmp1_; + char* _tmp0_; + GstPad* pad; + GstPad* _tmp2_; + GstElement* _tmp3_; + GstElement* parent; +#line 300 "singledecodebin.vala" + g_return_if_fail (IS_SINGLE_DECODE_BIN (self)); +#line 300 "singledecodebin.vala" + g_return_if_fail (GST_IS_ELEMENT (element)); +#line 301 "singledecodebin.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_VERBOSE, _tmp1_ = g_strdup_printf ("element:%s", _tmp0_ = gst_object_get_name (GST_OBJECT (element)))); +#line 1060 "singledecodebin.c" + _g_free0 (_tmp1_); + _g_free0 (_tmp0_); +#line 303 "singledecodebin.vala" + if (element == self->priv->typefind) { +#line 304 "singledecodebin.vala" + return; +#line 1067 "singledecodebin.c" + } +#line 305 "singledecodebin.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->validelements), element); +#line 308 "singledecodebin.vala" + pad = _gst_object_ref0 (GST_PAD ((GstPad*) g_list_first (element->sinkpads)->data)); +#line 309 "singledecodebin.vala" + parent = (_tmp3_ = _gst_object_ref0 (gst_pad_get_parent_element (_tmp2_ = gst_pad_get_peer (pad))), _gst_object_unref0 (_tmp2_), _tmp3_); +#line 310 "singledecodebin.vala" + single_decode_bin_markValidElements (self, parent); +#line 1077 "singledecodebin.c" + _gst_object_unref0 (pad); + _gst_object_unref0 (parent); +} + + +#line 314 "singledecodebin.vala" +static void single_decode_bin_removeUnusedElements (SingleDecodeBin* self, GstElement* element) { +#line 314 "singledecodebin.vala" + g_return_if_fail (IS_SINGLE_DECODE_BIN (self)); +#line 314 "singledecodebin.vala" + g_return_if_fail (GST_IS_ELEMENT (element)); +#line 1089 "singledecodebin.c" + { + GList* pad_collection; + GList* pad_it; +#line 315 "singledecodebin.vala" + pad_collection = element->srcpads; +#line 1095 "singledecodebin.c" + for (pad_it = pad_collection; pad_it != NULL; pad_it = pad_it->next) { + GstPad* pad; +#line 315 "singledecodebin.vala" + pad = _gst_object_ref0 ((GstPad*) pad_it->data); +#line 1100 "singledecodebin.c" + { +#line 316 "singledecodebin.vala" + if (gst_pad_is_linked (pad)) { +#line 1104 "singledecodebin.c" + GstPad* _tmp0_; + GstElement* _tmp1_; + GstElement* peer; +#line 317 "singledecodebin.vala" + peer = (_tmp1_ = _gst_object_ref0 (gst_pad_get_parent_element (_tmp0_ = gst_pad_get_peer (pad))), _gst_object_unref0 (_tmp0_), _tmp1_); +#line 318 "singledecodebin.vala" + single_decode_bin_removeUnusedElements (self, peer); +#line 319 "singledecodebin.vala" + if (!gee_abstract_collection_contains (GEE_ABSTRACT_COLLECTION (self->priv->validelements), peer)) { +#line 1114 "singledecodebin.c" + char* _tmp3_; + char* _tmp2_; + GstPad* _tmp4_; +#line 320 "singledecodebin.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_VERBOSE, _tmp3_ = g_strdup_printf ("removing %s", _tmp2_ = gst_object_get_name (GST_OBJECT (peer)))); +#line 1120 "singledecodebin.c" + _g_free0 (_tmp3_); + _g_free0 (_tmp2_); +#line 322 "singledecodebin.vala" + gst_pad_unlink (pad, _tmp4_ = gst_pad_get_peer (pad)); +#line 1125 "singledecodebin.c" + _gst_object_unref0 (_tmp4_); +#line 323 "singledecodebin.vala" + gst_element_set_state (peer, GST_STATE_NULL); +#line 324 "singledecodebin.vala" + gst_bin_remove (GST_BIN (self), peer); +#line 1131 "singledecodebin.c" + } + _gst_object_unref0 (peer); + } + _gst_object_unref0 (pad); + } + } + } +} + + +#line 329 "singledecodebin.vala" +static void single_decode_bin_cleanUp (SingleDecodeBin* self) { +#line 1144 "singledecodebin.c" + GstGhostPad* _tmp0_; + GeeArrayList* _tmp1_; +#line 329 "singledecodebin.vala" + g_return_if_fail (IS_SINGLE_DECODE_BIN (self)); +#line 330 "singledecodebin.vala" + if (self->priv->srcpad != NULL) { +#line 331 "singledecodebin.vala" + gst_element_remove_pad (GST_ELEMENT (self), GST_PAD (self->priv->srcpad)); +#line 1153 "singledecodebin.c" + } +#line 332 "singledecodebin.vala" + self->priv->srcpad = (_tmp0_ = NULL, _gst_object_unref0 (self->priv->srcpad), _tmp0_); +#line 1157 "singledecodebin.c" + { + GeeIterator* _element_it; + _element_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->priv->validelements)); +#line 333 "singledecodebin.vala" + while (TRUE) { +#line 1163 "singledecodebin.c" + GstElement* element; +#line 333 "singledecodebin.vala" + if (!gee_iterator_next (_element_it)) { +#line 333 "singledecodebin.vala" + break; +#line 1169 "singledecodebin.c" + } +#line 333 "singledecodebin.vala" + element = (GstElement*) gee_iterator_get (_element_it); +#line 334 "singledecodebin.vala" + gst_element_set_state (element, GST_STATE_NULL); +#line 335 "singledecodebin.vala" + gst_bin_remove (GST_BIN (self), element); +#line 1177 "singledecodebin.c" + _gst_object_unref0 (element); + } + _g_object_unref0 (_element_it); + } +#line 337 "singledecodebin.vala" + self->priv->validelements = (_tmp1_ = gee_array_list_new (GST_TYPE_ELEMENT, (GBoxedCopyFunc) gst_object_ref, gst_object_unref, NULL), _g_object_unref0 (self->priv->validelements), _tmp1_); +#line 1184 "singledecodebin.c" +} + + +#line 342 "singledecodebin.vala" +static GstStateChangeReturn single_decode_bin_real_change_state (GstElement* base, GstStateChange transition) { +#line 1190 "singledecodebin.c" + SingleDecodeBin * self; + GstStateChangeReturn result = 0; + GstStateChangeReturn res; + self = SINGLE_DECODE_BIN (base); +#line 343 "singledecodebin.vala" + res = GST_ELEMENT_CLASS (single_decode_bin_parent_class)->change_state (GST_ELEMENT (GST_BIN (self)), transition); +#line 344 "singledecodebin.vala" + if (transition == GST_STATE_CHANGE_PAUSED_TO_READY) { +#line 345 "singledecodebin.vala" + single_decode_bin_cleanUp (self); +#line 1201 "singledecodebin.c" + } + result = res; +#line 346 "singledecodebin.vala" + return result; +#line 1206 "singledecodebin.c" +} + + +#line 351 "singledecodebin.vala" +static void single_decode_bin_typefindHaveTypeCb (GstElement* t, gint probability, GstCaps* caps, SingleDecodeBin* data) { +#line 1212 "singledecodebin.c" + char* _tmp1_; + char* _tmp0_; + GstPad* _tmp2_; +#line 351 "singledecodebin.vala" + g_return_if_fail (GST_IS_ELEMENT (t)); +#line 351 "singledecodebin.vala" + g_return_if_fail (GST_IS_CAPS (caps)); +#line 351 "singledecodebin.vala" + g_return_if_fail (IS_SINGLE_DECODE_BIN (data)); +#line 353 "singledecodebin.vala" + logging_emit (G_OBJECT (data), LOGGING_FACILITY_SINGLEDECODEBIN, LOGGING_LEVEL_VERBOSE, _tmp1_ = g_strdup_printf ("probability:%d, caps:%s", probability, _tmp0_ = gst_caps_to_string (caps))); +#line 1224 "singledecodebin.c" + _g_free0 (_tmp1_); + _g_free0 (_tmp0_); +#line 355 "singledecodebin.vala" + single_decode_bin_closePadLink (data, t, _tmp2_ = gst_element_get_pad (t, "src"), caps); +#line 1229 "singledecodebin.c" + _gst_object_unref0 (_tmp2_); +} + + +#line 360 "singledecodebin.vala" +static void single_decode_bin_dynamicPadAddedCb (SingleDecodeBin* self, GstElement* element, GstPad* pad) { +#line 360 "singledecodebin.vala" + g_return_if_fail (IS_SINGLE_DECODE_BIN (self)); +#line 360 "singledecodebin.vala" + g_return_if_fail (GST_IS_ELEMENT (element)); +#line 360 "singledecodebin.vala" + g_return_if_fail (GST_IS_PAD (pad)); +#line 361 "singledecodebin.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "dynamicPadAddedCb"); +#line 362 "singledecodebin.vala" + if (self->priv->srcpad == NULL) { +#line 1246 "singledecodebin.c" + GstCaps* _tmp0_; +#line 363 "singledecodebin.vala" + single_decode_bin_closePadLink (self, element, pad, _tmp0_ = gst_pad_get_caps (pad)); +#line 1250 "singledecodebin.c" + _gst_caps_unref0 (_tmp0_); + } +} + + +#line 366 "singledecodebin.vala" +static void single_decode_bin_dynamicNoMorePadsCb (SingleDecodeBin* self, GstElement* element) { +#line 366 "singledecodebin.vala" + g_return_if_fail (IS_SINGLE_DECODE_BIN (self)); +#line 366 "singledecodebin.vala" + g_return_if_fail (GST_IS_ELEMENT (element)); +#line 367 "singledecodebin.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "dynamicNoMorePadsCb"); +#line 1264 "singledecodebin.c" +} + + +static void single_decode_bin_base_init (SingleDecodeBinClass * klass) { + { + GstPadTemplate* sink_pad; + GstPadTemplate* src_pad; +#line 52 "singledecodebin.vala" + sink_pad = gst_pad_template_new ("sinkpadtemplate", GST_PAD_SINK, GST_PAD_ALWAYS, gst_caps_new_any ()); +#line 54 "singledecodebin.vala" + src_pad = gst_pad_template_new ("srcpadtemplate", GST_PAD_SINK, GST_PAD_ALWAYS, gst_caps_new_any ()); +#line 57 "singledecodebin.vala" + gst_element_class_add_pad_template (GST_ELEMENT_CLASS (klass), src_pad); +#line 58 "singledecodebin.vala" + gst_element_class_add_pad_template (GST_ELEMENT_CLASS (klass), sink_pad); +#line 1280 "singledecodebin.c" + _gst_object_unref0 (sink_pad); + _gst_object_unref0 (src_pad); + } +} + + +static void single_decode_bin_class_init (SingleDecodeBinClass * klass) { + single_decode_bin_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (SingleDecodeBinPrivate)); + GST_ELEMENT_CLASS (klass)->change_state = single_decode_bin_real_change_state; + G_OBJECT_CLASS (klass)->finalize = single_decode_bin_finalize; +} + + +static void single_decode_bin_instance_init (SingleDecodeBin * self) { + self->priv = SINGLE_DECODE_BIN_GET_PRIVATE (self); + self->priv->dynamics = gee_array_list_new (GST_TYPE_ELEMENT, (GBoxedCopyFunc) gst_object_ref, gst_object_unref, NULL); + self->priv->validelements = gee_array_list_new (GST_TYPE_ELEMENT, (GBoxedCopyFunc) gst_object_ref, gst_object_unref, NULL); +} + + +static void single_decode_bin_finalize (GObject* obj) { + SingleDecodeBin * self; + self = SINGLE_DECODE_BIN (obj); + _gst_caps_unref0 (self->priv->caps); + _gst_object_unref0 (self->priv->typefind); + _gst_object_unref0 (self->priv->srcpad); + _g_object_unref0 (self->priv->dynamics); + _g_object_unref0 (self->priv->validelements); + self->priv->factories = (_vala_array_free (self->priv->factories, self->priv->factories_length1, (GDestroyNotify) gst_object_unref), NULL); + G_OBJECT_CLASS (single_decode_bin_parent_class)->finalize (obj); +} + + +GType single_decode_bin_get_type (void) { + static volatile gsize single_decode_bin_type_id__volatile = 0; + if (g_once_init_enter (&single_decode_bin_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (SingleDecodeBinClass), (GBaseInitFunc) single_decode_bin_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) single_decode_bin_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SingleDecodeBin), 0, (GInstanceInitFunc) single_decode_bin_instance_init, NULL }; + GType single_decode_bin_type_id; + single_decode_bin_type_id = g_type_register_static (GST_TYPE_BIN, "SingleDecodeBin", &g_define_type_info, 0); + g_once_init_leave (&single_decode_bin_type_id__volatile, single_decode_bin_type_id); + } + return single_decode_bin_type_id__volatile; +} + + +static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) { + if ((array != NULL) && (destroy_func != NULL)) { + int i; + for (i = 0; i < array_length; i = i + 1) { + if (((gpointer*) array)[i] != NULL) { + destroy_func (((gpointer*) array)[i]); + } + } + } +} + + +static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) { + _vala_array_destroy (array, array_length, destroy_func); + g_free (array); +} + + + + diff --git a/src/marina/marina/singledecodebin.o b/src/marina/marina/singledecodebin.o new file mode 100644 index 0000000..78f4b16 Binary files /dev/null and b/src/marina/marina/singledecodebin.o differ diff --git a/src/marina/marina/thumbnailsink.c b/src/marina/marina/thumbnailsink.c new file mode 100644 index 0000000..6d65eef --- /dev/null +++ b/src/marina/marina/thumbnailsink.c @@ -0,0 +1,269 @@ +/* thumbnailsink.c generated by valac, the Vala compiler + * generated from thumbnailsink.vala, do not modify */ + + +#include +#include +#include +#include +#include +#include +#include + + +#define TYPE_THUMBNAIL_SINK (thumbnail_sink_get_type ()) +#define THUMBNAIL_SINK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_THUMBNAIL_SINK, ThumbnailSink)) +#define THUMBNAIL_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_THUMBNAIL_SINK, ThumbnailSinkClass)) +#define IS_THUMBNAIL_SINK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_THUMBNAIL_SINK)) +#define IS_THUMBNAIL_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_THUMBNAIL_SINK)) +#define THUMBNAIL_SINK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_THUMBNAIL_SINK, ThumbnailSinkClass)) + +typedef struct _ThumbnailSink ThumbnailSink; +typedef struct _ThumbnailSinkClass ThumbnailSinkClass; +typedef struct _ThumbnailSinkPrivate ThumbnailSinkPrivate; +#define _gst_structure_free0(var) ((var == NULL) ? NULL : (var = (gst_structure_free (var), NULL))) +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +#define _gst_object_unref0(var) ((var == NULL) ? NULL : (var = (gst_object_unref (var), NULL))) + +struct _ThumbnailSink { + GstBaseSink parent_instance; + ThumbnailSinkPrivate * priv; +}; + +struct _ThumbnailSinkClass { + GstBaseSinkClass parent_class; +}; + +struct _ThumbnailSinkPrivate { + gint width; + gint height; +}; + + +static gpointer thumbnail_sink_parent_class = NULL; + +GType thumbnail_sink_get_type (void); +#define THUMBNAIL_SINK_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_THUMBNAIL_SINK, ThumbnailSinkPrivate)) +enum { + THUMBNAIL_SINK_DUMMY_PROPERTY +}; +#define THUMBNAIL_SINK_caps_string "video/x-raw-rgb,bpp = (int) 32, depth = (int) 32,\n" \ +" endianness = (int) BIG_ENDIAN,\n" \ +" blue_mask = (int) 0xFF000000,\n" \ +" green_mask = (int) 0x00FF0000,\n" \ +" red_mask = (int) 0x0000FF00,\n" \ +" width = (int) [ 1, max ],\n" \ +" height = (int) [ 1, max ],\n" \ +" framerate = (fraction) [ 0, max ]" +ThumbnailSink* thumbnail_sink_new (void); +ThumbnailSink* thumbnail_sink_construct (GType object_type); +static gboolean thumbnail_sink_real_set_caps (GstBaseSink* base, GstCaps* c); +static void thumbnail_sink_convert_pixbuf_to_rgb (ThumbnailSink* self, GdkPixbuf* buf); +static GstFlowReturn thumbnail_sink_real_preroll (GstBaseSink* base, GstBuffer* b); +static GObject * thumbnail_sink_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties); +static void thumbnail_sink_finalize (GObject* obj); + + + +#line 31 "thumbnailsink.vala" +ThumbnailSink* thumbnail_sink_construct (GType object_type) { +#line 64 "thumbnailsink.c" + ThumbnailSink * self; + self = g_object_newv (object_type, 0, NULL); +#line 32 "thumbnailsink.vala" + gst_base_sink_set_sync (GST_BASE_SINK (self), FALSE); +#line 69 "thumbnailsink.c" + return self; +} + + +#line 31 "thumbnailsink.vala" +ThumbnailSink* thumbnail_sink_new (void) { +#line 31 "thumbnailsink.vala" + return thumbnail_sink_construct (TYPE_THUMBNAIL_SINK); +#line 78 "thumbnailsink.c" +} + + +static gpointer _gst_structure_copy0 (gpointer self) { + return self ? gst_structure_copy (self) : NULL; +} + + +#line 35 "thumbnailsink.vala" +static gboolean thumbnail_sink_real_set_caps (GstBaseSink* base, GstCaps* c) { +#line 89 "thumbnailsink.c" + ThumbnailSink * self; + gboolean result = FALSE; + GstStructure* s; + gboolean _tmp0_ = FALSE; + self = THUMBNAIL_SINK (base); +#line 35 "thumbnailsink.vala" + g_return_val_if_fail (GST_IS_CAPS (c), FALSE); +#line 36 "thumbnailsink.vala" + if (gst_caps_get_size (c) < 1) { +#line 99 "thumbnailsink.c" + result = FALSE; +#line 37 "thumbnailsink.vala" + return result; +#line 103 "thumbnailsink.c" + } +#line 39 "thumbnailsink.vala" + s = _gst_structure_copy0 (gst_caps_get_structure (c, (guint) 0)); +#line 41 "thumbnailsink.vala" + if (!gst_structure_get_int (s, "width", &self->priv->width)) { +#line 41 "thumbnailsink.vala" + _tmp0_ = TRUE; +#line 111 "thumbnailsink.c" + } else { +#line 42 "thumbnailsink.vala" + _tmp0_ = !gst_structure_get_int (s, "height", &self->priv->height); +#line 115 "thumbnailsink.c" + } +#line 41 "thumbnailsink.vala" + if (_tmp0_) { +#line 119 "thumbnailsink.c" + result = FALSE; + _gst_structure_free0 (s); +#line 43 "thumbnailsink.vala" + return result; +#line 124 "thumbnailsink.c" + } + result = TRUE; + _gst_structure_free0 (s); +#line 44 "thumbnailsink.vala" + return result; +#line 130 "thumbnailsink.c" +} + + +#line 47 "thumbnailsink.vala" +static void thumbnail_sink_convert_pixbuf_to_rgb (ThumbnailSink* self, GdkPixbuf* buf) { +#line 136 "thumbnailsink.c" + guchar* data; + gint limit; +#line 47 "thumbnailsink.vala" + g_return_if_fail (IS_THUMBNAIL_SINK (self)); +#line 47 "thumbnailsink.vala" + g_return_if_fail (GDK_IS_PIXBUF (buf)); +#line 48 "thumbnailsink.vala" + data = gdk_pixbuf_get_pixels (buf); +#line 49 "thumbnailsink.vala" + limit = gdk_pixbuf_get_width (buf) * gdk_pixbuf_get_height (buf); +#line 51 "thumbnailsink.vala" + while (TRUE) { +#line 149 "thumbnailsink.c" + guchar temp; +#line 51 "thumbnailsink.vala" + if (!((limit--) != 0)) { +#line 51 "thumbnailsink.vala" + break; +#line 155 "thumbnailsink.c" + } +#line 52 "thumbnailsink.vala" + temp = data[0]; +#line 53 "thumbnailsink.vala" + data[0] = data[2]; +#line 54 "thumbnailsink.vala" + data[2] = temp; +#line 56 "thumbnailsink.vala" + data = data + 4; +#line 165 "thumbnailsink.c" + } +} + + +#line 60 "thumbnailsink.vala" +static GstFlowReturn thumbnail_sink_real_preroll (GstBaseSink* base, GstBuffer* b) { +#line 172 "thumbnailsink.c" + ThumbnailSink * self; + GstFlowReturn result = 0; + GdkPixbuf* buf; + self = THUMBNAIL_SINK (base); +#line 60 "thumbnailsink.vala" + g_return_val_if_fail (GST_IS_BUFFER (b), 0); +#line 61 "thumbnailsink.vala" + buf = gdk_pixbuf_new_from_data (b->data, GDK_COLORSPACE_RGB, TRUE, 8, self->priv->width, self->priv->height, self->priv->width * 4, NULL, NULL); +#line 63 "thumbnailsink.vala" + thumbnail_sink_convert_pixbuf_to_rgb (self, buf); +#line 65 "thumbnailsink.vala" + g_signal_emit_by_name (self, "have-thumbnail", buf); +#line 185 "thumbnailsink.c" + result = GST_FLOW_OK; + _g_object_unref0 (buf); +#line 66 "thumbnailsink.vala" + return result; +#line 190 "thumbnailsink.c" +} + + +static GObject * thumbnail_sink_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) { + GObject * obj; + GObjectClass * parent_class; + ThumbnailSink * self; + parent_class = G_OBJECT_CLASS (thumbnail_sink_parent_class); + obj = parent_class->constructor (type, n_construct_properties, construct_properties); + self = THUMBNAIL_SINK (obj); + { + } + return obj; +} + + +static void thumbnail_sink_base_init (ThumbnailSinkClass * klass) { + { + GstStaticPadTemplate pad = {0}; + GstPadTemplate* _tmp0_; +#line 18 "thumbnailsink.vala" + pad.name_template = "sink"; +#line 19 "thumbnailsink.vala" + pad.direction = GST_PAD_SINK; +#line 20 "thumbnailsink.vala" + pad.presence = GST_PAD_ALWAYS; +#line 21 "thumbnailsink.vala" + pad.static_caps.string = THUMBNAIL_SINK_caps_string; +#line 23 "thumbnailsink.vala" + gst_element_class_add_pad_template (GST_ELEMENT_CLASS (klass), _tmp0_ = gst_static_pad_template_get (&pad)); +#line 221 "thumbnailsink.c" + _gst_object_unref0 (_tmp0_); + } +} + + +static void thumbnail_sink_class_init (ThumbnailSinkClass * klass) { + thumbnail_sink_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ThumbnailSinkPrivate)); + GST_BASE_SINK_CLASS (klass)->set_caps = thumbnail_sink_real_set_caps; + GST_BASE_SINK_CLASS (klass)->preroll = thumbnail_sink_real_preroll; + G_OBJECT_CLASS (klass)->constructor = thumbnail_sink_constructor; + G_OBJECT_CLASS (klass)->finalize = thumbnail_sink_finalize; + g_signal_new ("have_thumbnail", TYPE_THUMBNAIL_SINK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GDK_TYPE_PIXBUF); +} + + +static void thumbnail_sink_instance_init (ThumbnailSink * self) { + self->priv = THUMBNAIL_SINK_GET_PRIVATE (self); +} + + +static void thumbnail_sink_finalize (GObject* obj) { + ThumbnailSink * self; + self = THUMBNAIL_SINK (obj); + G_OBJECT_CLASS (thumbnail_sink_parent_class)->finalize (obj); +} + + +GType thumbnail_sink_get_type (void) { + static volatile gsize thumbnail_sink_type_id__volatile = 0; + if (g_once_init_enter (&thumbnail_sink_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ThumbnailSinkClass), (GBaseInitFunc) thumbnail_sink_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) thumbnail_sink_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ThumbnailSink), 0, (GInstanceInitFunc) thumbnail_sink_instance_init, NULL }; + GType thumbnail_sink_type_id; + thumbnail_sink_type_id = g_type_register_static (GST_TYPE_BASE_SINK, "ThumbnailSink", &g_define_type_info, 0); + g_once_init_leave (&thumbnail_sink_type_id__volatile, thumbnail_sink_type_id); + } + return thumbnail_sink_type_id__volatile; +} + + + + diff --git a/src/marina/marina/thumbnailsink.o b/src/marina/marina/thumbnailsink.o new file mode 100644 index 0000000..a39a57b Binary files /dev/null and b/src/marina/marina/thumbnailsink.o differ diff --git a/src/marina/marina/timeline.c b/src/marina/marina/timeline.c new file mode 100644 index 0000000..3d62e24 --- /dev/null +++ b/src/marina/marina/timeline.c @@ -0,0 +1,2906 @@ +/* timeline.c generated by valac, the Vala compiler + * generated from timeline.vala, do not modify */ + +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#define TYPE_TRACK_CLIP_PAIR (track_clip_pair_get_type ()) +#define TRACK_CLIP_PAIR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRACK_CLIP_PAIR, TrackClipPair)) +#define TRACK_CLIP_PAIR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TRACK_CLIP_PAIR, TrackClipPairClass)) +#define IS_TRACK_CLIP_PAIR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRACK_CLIP_PAIR)) +#define IS_TRACK_CLIP_PAIR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TRACK_CLIP_PAIR)) +#define TRACK_CLIP_PAIR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TRACK_CLIP_PAIR, TrackClipPairClass)) + +typedef struct _TrackClipPair TrackClipPair; +typedef struct _TrackClipPairClass TrackClipPairClass; +typedef struct _TrackClipPairPrivate TrackClipPairPrivate; + +#define MODEL_TYPE_TRACK (model_track_get_type ()) +#define MODEL_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TRACK, ModelTrack)) +#define MODEL_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TRACK, ModelTrackClass)) +#define MODEL_IS_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TRACK)) +#define MODEL_IS_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TRACK)) +#define MODEL_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TRACK, ModelTrackClass)) + +typedef struct _ModelTrack ModelTrack; +typedef struct _ModelTrackClass ModelTrackClass; + +#define MODEL_TYPE_CLIP (model_clip_get_type ()) +#define MODEL_CLIP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP, ModelClip)) +#define MODEL_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP, ModelClipClass)) +#define MODEL_IS_CLIP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP)) +#define MODEL_IS_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP)) +#define MODEL_CLIP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP, ModelClipClass)) + +typedef struct _ModelClip ModelClip; +typedef struct _ModelClipClass ModelClipClass; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +typedef struct _ParamSpecTrackClipPair ParamSpecTrackClipPair; + +#define TYPE_CLIPBOARD (clipboard_get_type ()) +#define CLIPBOARD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CLIPBOARD, Clipboard)) +#define CLIPBOARD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CLIPBOARD, ClipboardClass)) +#define IS_CLIPBOARD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CLIPBOARD)) +#define IS_CLIPBOARD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CLIPBOARD)) +#define CLIPBOARD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CLIPBOARD, ClipboardClass)) + +typedef struct _Clipboard Clipboard; +typedef struct _ClipboardClass ClipboardClass; +typedef struct _ClipboardPrivate ClipboardPrivate; + +#define TYPE_CLIP_VIEW (clip_view_get_type ()) +#define CLIP_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CLIP_VIEW, ClipView)) +#define CLIP_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CLIP_VIEW, ClipViewClass)) +#define IS_CLIP_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CLIP_VIEW)) +#define IS_CLIP_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CLIP_VIEW)) +#define CLIP_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CLIP_VIEW, ClipViewClass)) + +typedef struct _ClipView ClipView; +typedef struct _ClipViewClass ClipViewClass; + +#define TYPE_TRACK_VIEW (track_view_get_type ()) +#define TRACK_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRACK_VIEW, TrackView)) +#define IS_TRACK_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRACK_VIEW)) +#define TRACK_VIEW_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_TRACK_VIEW, TrackViewIface)) + +typedef struct _TrackView TrackView; +typedef struct _TrackViewIface TrackViewIface; +typedef struct _ClipViewPrivate ClipViewPrivate; +#define _track_clip_pair_unref0(var) ((var == NULL) ? NULL : (var = (track_clip_pair_unref (var), NULL))) +typedef struct _ParamSpecClipboard ParamSpecClipboard; + +#define TYPE_TIME_LINE (time_line_get_type ()) +#define TIME_LINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TIME_LINE, TimeLine)) +#define TIME_LINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TIME_LINE, TimeLineClass)) +#define IS_TIME_LINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TIME_LINE)) +#define IS_TIME_LINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TIME_LINE)) +#define TIME_LINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TIME_LINE, TimeLineClass)) + +typedef struct _TimeLine TimeLine; +typedef struct _TimeLineClass TimeLineClass; +typedef struct _TimeLinePrivate TimeLinePrivate; + +#define MODEL_TYPE_PROJECT (model_project_get_type ()) +#define MODEL_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT, ModelProject)) +#define MODEL_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT, ModelProjectClass)) +#define MODEL_IS_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT)) +#define MODEL_IS_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT)) +#define MODEL_PROJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT, ModelProjectClass)) + +typedef struct _ModelProject ModelProject; +typedef struct _ModelProjectClass ModelProjectClass; + +#define MODEL_TYPE_TIME_SYSTEM (model_time_system_get_type ()) +#define MODEL_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TIME_SYSTEM, ModelTimeSystem)) +#define MODEL_IS_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TIME_SYSTEM)) +#define MODEL_TIME_SYSTEM_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MODEL_TYPE_TIME_SYSTEM, ModelTimeSystemIface)) + +typedef struct _ModelTimeSystem ModelTimeSystem; +typedef struct _ModelTimeSystemIface ModelTimeSystemIface; + +#define VIEW_TYPE_RULER (view_ruler_get_type ()) +#define VIEW_RULER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_RULER, ViewRuler)) +#define VIEW_RULER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_RULER, ViewRulerClass)) +#define VIEW_IS_RULER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_RULER)) +#define VIEW_IS_RULER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_RULER)) +#define VIEW_RULER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_RULER, ViewRulerClass)) + +typedef struct _ViewRuler ViewRuler; +typedef struct _ViewRulerClass ViewRulerClass; +#define _clipboard_unref0(var) ((var == NULL) ? NULL : (var = (clipboard_unref (var), NULL))) + +#define MODEL_TYPE_TEMPO_INFORMATION (model_tempo_information_get_type ()) +#define MODEL_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformation)) +#define MODEL_IS_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TEMPO_INFORMATION)) +#define MODEL_TEMPO_INFORMATION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformationIface)) + +typedef struct _ModelTempoInformation ModelTempoInformation; +typedef struct _ModelTempoInformationIface ModelTempoInformationIface; + +#define TYPE_FRACTION (fraction_get_type ()) +typedef struct _Fraction Fraction; +typedef struct _ModelProjectPrivate ModelProjectPrivate; + +#define MODEL_TYPE_CLIP_FILE (model_clip_file_get_type ()) +#define MODEL_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFile)) +#define MODEL_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) +#define MODEL_IS_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE)) +#define MODEL_IS_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE)) +#define MODEL_CLIP_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) + +typedef struct _ModelClipFile ModelClipFile; +typedef struct _ModelClipFileClass ModelClipFileClass; + +#define TYPE_TIME_CODE (time_code_get_type ()) +typedef struct _TimeCode TimeCode; + +#define VIEW_TYPE_MEDIA_ENGINE (view_media_engine_get_type ()) +#define VIEW_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngine)) +#define VIEW_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass)) +#define VIEW_IS_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_ENGINE)) +#define VIEW_IS_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_ENGINE)) +#define VIEW_MEDIA_ENGINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass)) + +typedef struct _ViewMediaEngine ViewMediaEngine; +typedef struct _ViewMediaEngineClass ViewMediaEngineClass; + +#define MODEL_TYPE_PROJECT_LOADER (model_project_loader_get_type ()) +#define MODEL_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoader)) +#define MODEL_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass)) +#define MODEL_IS_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT_LOADER)) +#define MODEL_IS_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT_LOADER)) +#define MODEL_PROJECT_LOADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass)) + +typedef struct _ModelProjectLoader ModelProjectLoader; +typedef struct _ModelProjectLoaderClass ModelProjectLoaderClass; + +#define MODEL_TYPE_UNDO_MANAGER (model_undo_manager_get_type ()) +#define MODEL_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManager)) +#define MODEL_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass)) +#define MODEL_IS_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_UNDO_MANAGER)) +#define MODEL_IS_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_UNDO_MANAGER)) +#define MODEL_UNDO_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass)) + +typedef struct _ModelUndoManager ModelUndoManager; +typedef struct _ModelUndoManagerClass ModelUndoManagerClass; + +#define MODEL_TYPE_LIBRARY_IMPORTER (model_library_importer_get_type ()) +#define MODEL_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporter)) +#define MODEL_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass)) +#define MODEL_IS_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_LIBRARY_IMPORTER)) +#define MODEL_IS_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_LIBRARY_IMPORTER)) +#define MODEL_LIBRARY_IMPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass)) + +typedef struct _ModelLibraryImporter ModelLibraryImporter; +typedef struct _ModelLibraryImporterClass ModelLibraryImporterClass; + +#define LOGGING_TYPE_FACILITY (logging_facility_get_type ()) + +#define LOGGING_TYPE_LEVEL (logging_level_get_type ()) + +#define TYPE_CLASS_FACTORY (class_factory_get_type ()) +#define CLASS_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CLASS_FACTORY, ClassFactory)) +#define CLASS_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CLASS_FACTORY, ClassFactoryClass)) +#define IS_CLASS_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CLASS_FACTORY)) +#define IS_CLASS_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CLASS_FACTORY)) +#define CLASS_FACTORY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CLASS_FACTORY, ClassFactoryClass)) + +typedef struct _ClassFactory ClassFactory; +typedef struct _ClassFactoryClass ClassFactoryClass; +#define _class_factory_unref0(var) ((var == NULL) ? NULL : (var = (class_factory_unref (var), NULL))) + +#define MODEL_TYPE_MEDIA_TYPE (model_media_type_get_type ()) +typedef struct _ModelClipPrivate ModelClipPrivate; +#define _g_free0(var) (var = (g_free (var), NULL)) +#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL))) +#define _g_list_free0(var) ((var == NULL) ? NULL : (var = (g_list_free (var), NULL))) + +struct _TrackClipPair { + GTypeInstance parent_instance; + volatile int ref_count; + TrackClipPairPrivate * priv; + ModelTrack* track; + ModelClip* clip; +}; + +struct _TrackClipPairClass { + GTypeClass parent_class; + void (*finalize) (TrackClipPair *self); +}; + +struct _ParamSpecTrackClipPair { + GParamSpec parent_instance; +}; + +struct _Clipboard { + GTypeInstance parent_instance; + volatile int ref_count; + ClipboardPrivate * priv; + GeeArrayList* clips; +}; + +struct _ClipboardClass { + GTypeClass parent_class; + void (*finalize) (Clipboard *self); +}; + +struct _ClipboardPrivate { + gint64 minimum_time; +}; + +struct _TrackViewIface { + GTypeInterface parent_iface; + void (*move_to_top) (TrackView* self, ClipView* clip_view); + void (*resize) (TrackView* self); + ModelTrack* (*get_track) (TrackView* self); + gint (*get_track_height) (TrackView* self); + GtkWidget* (*find_child) (TrackView* self, double x, double y); + void (*select_all) (TrackView* self); +}; + +struct _ClipView { + GtkDrawingArea parent_instance; + ClipViewPrivate * priv; + ModelClip* clip; + gint64 initial_time; + gboolean is_selected; + gint height; +}; + +struct _ClipViewClass { + GtkDrawingAreaClass parent_class; +}; + +struct _ParamSpecClipboard { + GParamSpec parent_instance; +}; + +struct _ModelTimeSystemIface { + GTypeInterface parent_iface; + void (*calculate_pixel_step) (ModelTimeSystem* self, float inc, float pixel_min, float pixel_div); + gint64 (*xpos_to_time) (ModelTimeSystem* self, gint x); + gint64 (*xsize_to_time) (ModelTimeSystem* self, gint x); + gint (*time_to_xpos) (ModelTimeSystem* self, gint64 time); + gint64 (*get_pixel_snap_time) (ModelTimeSystem* self); + gint (*time_to_xsize) (ModelTimeSystem* self, gint64 time); + float (*get_pixel_percentage) (ModelTimeSystem* self); + gint (*get_start_token) (ModelTimeSystem* self, gint xsize); + gint (*get_next_position) (ModelTimeSystem* self, gint token); + gint (*get_pixel_height) (ModelTimeSystem* self, gint token); + char* (*get_display_string) (ModelTimeSystem* self, gint token); + gint (*frame_to_xsize) (ModelTimeSystem* self, gint frame); + gint (*xsize_to_frame) (ModelTimeSystem* self, gint xsize); + char* (*get_time_string) (ModelTimeSystem* self, gint64 time); + char* (*get_time_duration) (ModelTimeSystem* self, gint64 time); +}; + +struct _TimeLine { + GtkEventBox parent_instance; + TimeLinePrivate * priv; + ModelProject* project; + ModelTimeSystem* provider; + ViewRuler* ruler; + GeeArrayList* tracks; + GeeArrayList* selected_clips; + Clipboard* clipboard; +}; + +struct _TimeLineClass { + GtkEventBoxClass parent_class; +}; + +struct _TimeLinePrivate { + GtkWidget* drag_widget; + gboolean copying; + GtkVBox* vbox; + float pixel_div; + float pixel_min; + float pixel_max; + GtkLabel* high_water; +}; + +struct _Fraction { + gint numerator; + gint denominator; +}; + +struct _ModelTempoInformationIface { + GTypeInterface parent_iface; + void (*get_time_signature) (ModelTempoInformation* self, Fraction* result); + gint (*get_bpm) (ModelTempoInformation* self); +}; + +struct _TimeCode { + gint hour; + gint minute; + gint second; + gint frame; + gboolean drop_code; +}; + +struct _ModelProject { + GObject parent_instance; + ModelProjectPrivate * priv; + GeeArrayList* tracks; + GeeArrayList* inactive_tracks; + GeeArrayList* clipfiles; + ViewMediaEngine* media_engine; + char* project_file; + ModelProjectLoader* loader; + ModelUndoManager* undo_manager; + ModelLibraryImporter* importer; + Fraction default_framerate; + gboolean click_during_play; + gboolean click_during_record; + double click_volume; + gboolean library_visible; + gint library_width; + gboolean snap_to_clip; +}; + +struct _ModelProjectClass { + GObjectClass parent_class; + void (*get_clip_time) (ModelProject* self, ModelClipFile* f, TimeCode* result); + char* (*get_project_file) (ModelProject* self); + void (*do_append) (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, const char* name, gint64 insert_time); + void (*add_track) (ModelProject* self, ModelTrack* track); + void (*insert_track) (ModelProject* self, gint index, ModelTrack* track); + void (*load) (ModelProject* self, const char* fname); + void (*save) (ModelProject* self, const char* filename); + char* (*get_app_name) (ModelProject* self); + void (*load_complete) (ModelProject* self); +}; + +typedef enum { + LOGGING_FACILITY_SIGNAL_HANDLERS, + LOGGING_FACILITY_DEVELOPER_WARNINGS, + LOGGING_FACILITY_GRAPH, + LOGGING_FACILITY_LOADING, + LOGGING_FACILITY_IMPORT, + LOGGING_FACILITY_SINGLEDECODEBIN +} LoggingFacility; + +typedef enum { + LOGGING_LEVEL_CRITICAL, + LOGGING_LEVEL_HIGH, + LOGGING_LEVEL_MEDIUM, + LOGGING_LEVEL_LOW, + LOGGING_LEVEL_INFO, + LOGGING_LEVEL_VERBOSE +} LoggingLevel; + +typedef enum { + MODEL_MEDIA_TYPE_AUDIO, + MODEL_MEDIA_TYPE_VIDEO +} ModelMediaType; + +struct _ModelClip { + GObject parent_instance; + ModelClipPrivate * priv; + ModelClipFile* clipfile; + ModelMediaType type; + gboolean is_recording; + char* name; +}; + +struct _ModelClipClass { + GObjectClass parent_class; +}; + + +static gpointer track_clip_pair_parent_class = NULL; +static gpointer clipboard_parent_class = NULL; +static gpointer time_line_parent_class = NULL; + +gpointer track_clip_pair_ref (gpointer instance); +void track_clip_pair_unref (gpointer instance); +GParamSpec* param_spec_track_clip_pair (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void value_set_track_clip_pair (GValue* value, gpointer v_object); +void value_take_track_clip_pair (GValue* value, gpointer v_object); +gpointer value_get_track_clip_pair (const GValue* value); +GType track_clip_pair_get_type (void); +GType model_track_get_type (void); +GType model_clip_get_type (void); +enum { + TRACK_CLIP_PAIR_DUMMY_PROPERTY +}; +TrackClipPair* track_clip_pair_new (ModelTrack* track, ModelClip* clip); +TrackClipPair* track_clip_pair_construct (GType object_type, ModelTrack* track, ModelClip* clip); +static void track_clip_pair_finalize (TrackClipPair* obj); +gpointer clipboard_ref (gpointer instance); +void clipboard_unref (gpointer instance); +GParamSpec* param_spec_clipboard (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void value_set_clipboard (GValue* value, gpointer v_object); +void value_take_clipboard (GValue* value, gpointer v_object); +gpointer value_get_clipboard (const GValue* value); +GType clipboard_get_type (void); +#define CLIPBOARD_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_CLIPBOARD, ClipboardPrivate)) +enum { + CLIPBOARD_DUMMY_PROPERTY +}; +GType clip_view_get_type (void); +GType track_view_get_type (void); +gint64 model_clip_get_start (ModelClip* self); +ModelTrack* track_view_get_track (TrackView* self); +void clipboard_select (Clipboard* self, GeeArrayList* selected_clips); +void model_track_do_clip_paste (ModelTrack* self, ModelClip* clip, gint64 position); +ModelClip* model_clip_copy (ModelClip* self); +void clipboard_paste (Clipboard* self, ModelTrack* selected_track, gint64 time); +Clipboard* clipboard_new (void); +Clipboard* clipboard_construct (GType object_type); +static void clipboard_finalize (Clipboard* obj); +GType time_line_get_type (void); +GType model_project_get_type (void); +GType model_time_system_get_type (void); +GType view_ruler_get_type (void); +#define TIME_LINE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_TIME_LINE, TimeLinePrivate)) +enum { + TIME_LINE_DUMMY_PROPERTY +}; +#define TIME_LINE_BAR_HEIGHT 32 +#define TIME_LINE_BORDER 4 +#define TIME_LINE_RULER_HEIGHT 32 +static void time_line_on_geometry_changed (TimeLine* self); +static void _time_line_on_geometry_changed_model_time_system_geometry_changed (ModelTimeSystem* _sender, gpointer self); +ViewRuler* view_ruler_new (ModelTimeSystem* provider, gint height); +ViewRuler* view_ruler_construct (GType object_type, ModelTimeSystem* provider, gint height); +void time_line_on_ruler_position_changed (TimeLine* self, gint x); +static void _time_line_on_ruler_position_changed_view_ruler_position_changed (ViewRuler* _sender, gint x, gpointer self); +static void time_line_on_track_added (TimeLine* self, ModelTrack* track); +static void _time_line_on_track_added_model_project_track_added (ModelProject* _sender, ModelTrack* track, gpointer self); +static void time_line_on_track_removed (TimeLine* self, ModelTrack* track); +static void _time_line_on_track_removed_model_project_track_removed (ModelProject* _sender, ModelTrack* track, gpointer self); +GType fraction_get_type (void); +Fraction* fraction_dup (const Fraction* self); +void fraction_free (Fraction* self); +GType model_tempo_information_get_type (void); +GType model_clip_file_get_type (void); +GType time_code_get_type (void); +TimeCode* time_code_dup (const TimeCode* self); +void time_code_free (TimeCode* self); +GType view_media_engine_get_type (void); +GType model_project_loader_get_type (void); +gpointer model_undo_manager_ref (gpointer instance); +void model_undo_manager_unref (gpointer instance); +GParamSpec* model_param_spec_undo_manager (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_undo_manager (GValue* value, gpointer v_object); +void model_value_take_undo_manager (GValue* value, gpointer v_object); +gpointer model_value_get_undo_manager (const GValue* value); +GType model_undo_manager_get_type (void); +GType model_library_importer_get_type (void); +static void time_line_on_position_changed (TimeLine* self); +static void _time_line_on_position_changed_view_media_engine_position_changed (ViewMediaEngine* _sender, gint64 position, gpointer self); +void parse_color (const char* color, GdkColor* result); +void model_time_system_calculate_pixel_step (ModelTimeSystem* self, float inc, float pixel_min, float pixel_div); +TimeLine* time_line_new (ModelProject* p, ModelTimeSystem* provider, GdkDragAction actions); +TimeLine* time_line_construct (GType object_type, ModelProject* p, ModelTimeSystem* provider, GdkDragAction actions); +gint64 model_project_get_length (ModelProject* self); +void time_line_zoom (TimeLine* self, float inc); +float model_time_system_get_pixel_percentage (ModelTimeSystem* self); +void time_line_zoom_to_project (TimeLine* self, double width); +void track_view_resize (TrackView* self); +gint64 model_project_transport_get_position (ModelProject* self); +GType logging_facility_get_type (void); +GType logging_level_get_type (void); +void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message); +gpointer class_factory_ref (gpointer instance); +void class_factory_unref (gpointer instance); +GParamSpec* param_spec_class_factory (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void value_set_class_factory (GValue* value, gpointer v_object); +void value_take_class_factory (GValue* value, gpointer v_object); +gpointer value_get_class_factory (const GValue* value); +GType class_factory_get_type (void); +ClassFactory* class_factory_get_class_factory (void); +TrackView* class_factory_get_track_view (ClassFactory* self, ModelTrack* track, TimeLine* timeline); +void time_line_on_clip_view_added (TimeLine* self, ClipView* clip_view); +static void _time_line_on_clip_view_added_track_view_clip_view_added (TrackView* _sender, ClipView* clip_view, gpointer self); +GType model_media_type_get_type (void); +ModelMediaType model_track_media_type (ModelTrack* self); +static void time_line_on_clip_view_selection_request (TimeLine* self, ClipView* clip_view, gboolean extend); +static void _time_line_on_clip_view_selection_request_clip_view_selection_request (ClipView* _sender, ClipView* clip_view, gboolean extend_selection, gpointer self); +static void time_line_on_clip_view_move_request (TimeLine* self, ClipView* clip_view, gint64 delta); +static void _time_line_on_clip_view_move_request_clip_view_move_request (ClipView* _sender, ClipView* clip_view, gint64 delta, gpointer self); +static void time_line_on_clip_view_move_commit (TimeLine* self, ClipView* clip_view, gint64 delta); +static void _time_line_on_clip_view_move_commit_clip_view_move_commit (ClipView* _sender, ClipView* clip_view, gint64 delta, gpointer self); +static void time_line_on_clip_view_move_begin (TimeLine* self, ClipView* clip_view, gboolean copy); +static void _time_line_on_clip_view_move_begin_clip_view_move_begin (ClipView* _sender, ClipView* clip_view, gboolean copy, gpointer self); +static void time_line_on_clip_view_trim_begin (TimeLine* self, ClipView* clip, GdkWindowEdge edge); +static void _time_line_on_clip_view_trim_begin_clip_view_trim_begin (ClipView* _sender, ClipView* clip_view, GdkWindowEdge edge, gpointer self); +static void time_line_on_clip_view_trim_commit (TimeLine* self, ClipView* clip_view, GdkWindowEdge edge); +static void _time_line_on_clip_view_trim_commit_clip_view_trim_commit (ClipView* _sender, ClipView* clip_view, GdkWindowEdge edge, gpointer self); +void time_line_deselect_all_clips (TimeLine* self); +void model_undo_manager_start_transaction (ModelUndoManager* self, const char* description); +gint64 model_clip_get_end (ModelClip* self); +void model_clip_gnonlin_disconnect (ModelClip* self); +void model_track_remove_clip_from_array (ModelTrack* self, ModelClip* pos); +void model_track_append_at_time (ModelTrack* self, ModelClip* c, gint64 time, gboolean select); +void track_view_move_to_top (TrackView* self, ClipView* clip_view); +gint64 model_clip_get_duration (ModelClip* self); +gboolean time_line_is_clip_selected (TimeLine* self); +void model_clip_gnonlin_connect (ModelClip* self); +void model_track_move (ModelTrack* self, ModelClip* c, gint64 pos, gint64 original_time); +void model_undo_manager_end_transaction (ModelUndoManager* self, const char* description); +void model_clip_trim (ModelClip* self, gint64 delta, GdkWindowEdge edge); +void model_track_trim (ModelTrack* self, ModelClip* clip, gint64 delta, GdkWindowEdge edge); +#define CLIP_VIEW_SNAP_DELTA 10 +gint model_time_system_time_to_xsize (ModelTimeSystem* self, gint64 time); +gint64 model_time_system_xsize_to_time (ModelTimeSystem* self, gint x); +gboolean model_track_clip_is_near (ModelTrack* self, ModelClip* clip, gint64 range, gint64* adjustment); +void clip_view_snap (ClipView* self, gint64 amount); +static void time_line_constrain_move (TimeLine* self, ClipView* clip_view, gint64* delta); +static gboolean time_line_move_allowed (TimeLine* self, gint64* move_distance); +static void time_line_move_the_clips (TimeLine* self, gint64 move_distance); +gint model_time_system_time_to_xpos (ModelTimeSystem* self, gint64 time); +void time_line_do_clip_move (TimeLine* self, ClipView* clip_view, gint64 delta); +void model_clip_set_start (ModelClip* self, gint64 value); +gboolean model_project_transport_is_recording (ModelProject* self); +void time_line_update_pos (TimeLine* self, gint event_x); +gboolean time_line_gap_selected (TimeLine* self); +void clip_view_delete_clip (ClipView* self); +void time_line_delete_selection (TimeLine* self); +void time_line_do_cut (TimeLine* self); +void time_line_do_copy (TimeLine* self); +void time_line_do_paste (TimeLine* self, gint64 pos); +void time_line_paste (TimeLine* self); +gboolean model_track_get_is_selected (ModelTrack* self); +static TrackView* time_line_find_video_track_view (TimeLine* self); +static TrackView* time_line_find_audio_track_view (TimeLine* self); +void track_view_select_all (TrackView* self); +void time_line_select_all (TimeLine* self); +static gboolean time_line_real_expose_event (GtkWidget* base, GdkEventExpose* event); +GtkWidget* time_line_find_child (TimeLine* self, double x, double y); +void dialog_utils_warning (const char* major_message, const char* minor_message); +GtkResponseType dialog_utils_add_cancel (const char* message); +void model_project_create_clip_importer (ModelProject* self, ModelTrack* track, gboolean timeline_add, gint64 time_to_add, gboolean both_tracks, GtkWindow* progress_window_parent, gint number); +gint64 model_time_system_xpos_to_time (ModelTimeSystem* self, gint x); +void model_library_importer_add_file (ModelLibraryImporter* self, const char* filename, GError** error); +void model_library_importer_start (ModelLibraryImporter* self, GError** error); +static void time_line_real_drag_data_received (GtkWidget* base, GdkDragContext* context, gint x, gint y, GtkSelectionData* selection_data, guint drag_info, guint time); +void model_project_snap_coord (ModelProject* self, gint64* coord, gint64 span); +gint64 model_time_system_get_pixel_snap_time (ModelTimeSystem* self); +void view_media_engine_go (ViewMediaEngine* self, gint64 pos); +static void time_line_deselect_all (TimeLine* self); +GtkWidget* track_view_find_child (TrackView* self, double x, double y); +void model_track_set_selected (ModelTrack* self, gboolean is_selected); +static gboolean time_line_real_button_press_event (GtkWidget* base, GdkEventButton* event); +static gboolean time_line_real_button_release_event (GtkWidget* base, GdkEventButton* event); +static gboolean time_line_real_motion_notify_event (GtkWidget* base, GdkEventMotion* event); +static void time_line_finalize (GObject* obj); +static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func); +static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func); +static gint _vala_array_length (gpointer array); + +extern const GtkTargetEntry drag_target_entries[1]; + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 10 "timeline.vala" +TrackClipPair* track_clip_pair_construct (GType object_type, ModelTrack* track, ModelClip* clip) { +#line 600 "timeline.c" + TrackClipPair* self; + ModelTrack* _tmp0_; + ModelClip* _tmp1_; +#line 10 "timeline.vala" + g_return_val_if_fail (MODEL_IS_TRACK (track), NULL); +#line 10 "timeline.vala" + g_return_val_if_fail (MODEL_IS_CLIP (clip), NULL); +#line 608 "timeline.c" + self = (TrackClipPair*) g_type_create_instance (object_type); +#line 11 "timeline.vala" + self->track = (_tmp0_ = _g_object_ref0 (track), _g_object_unref0 (self->track), _tmp0_); +#line 12 "timeline.vala" + self->clip = (_tmp1_ = _g_object_ref0 (clip), _g_object_unref0 (self->clip), _tmp1_); +#line 614 "timeline.c" + return self; +} + + +#line 10 "timeline.vala" +TrackClipPair* track_clip_pair_new (ModelTrack* track, ModelClip* clip) { +#line 10 "timeline.vala" + return track_clip_pair_construct (TYPE_TRACK_CLIP_PAIR, track, clip); +#line 623 "timeline.c" +} + + +static void value_track_clip_pair_init (GValue* value) { + value->data[0].v_pointer = NULL; +} + + +static void value_track_clip_pair_free_value (GValue* value) { + if (value->data[0].v_pointer) { + track_clip_pair_unref (value->data[0].v_pointer); + } +} + + +static void value_track_clip_pair_copy_value (const GValue* src_value, GValue* dest_value) { + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = track_clip_pair_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + + +static gpointer value_track_clip_pair_peek_pointer (const GValue* value) { + return value->data[0].v_pointer; +} + + +static gchar* value_track_clip_pair_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + if (collect_values[0].v_pointer) { + TrackClipPair* object; + object = collect_values[0].v_pointer; + if (object->parent_instance.g_class == NULL) { + return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) { + return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } + value->data[0].v_pointer = track_clip_pair_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + + +static gchar* value_track_clip_pair_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + TrackClipPair** object_p; + object_p = collect_values[0].v_pointer; + if (!object_p) { + return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); + } + if (!value->data[0].v_pointer) { + *object_p = NULL; + } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) { + *object_p = value->data[0].v_pointer; + } else { + *object_p = track_clip_pair_ref (value->data[0].v_pointer); + } + return NULL; +} + + +GParamSpec* param_spec_track_clip_pair (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) { + ParamSpecTrackClipPair* spec; + g_return_val_if_fail (g_type_is_a (object_type, TYPE_TRACK_CLIP_PAIR), NULL); + spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags); + G_PARAM_SPEC (spec)->value_type = object_type; + return G_PARAM_SPEC (spec); +} + + +gpointer value_get_track_clip_pair (const GValue* value) { + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TRACK_CLIP_PAIR), NULL); + return value->data[0].v_pointer; +} + + +void value_set_track_clip_pair (GValue* value, gpointer v_object) { + TrackClipPair* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TRACK_CLIP_PAIR)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_TRACK_CLIP_PAIR)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + track_clip_pair_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + track_clip_pair_unref (old); + } +} + + +void value_take_track_clip_pair (GValue* value, gpointer v_object) { + TrackClipPair* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TRACK_CLIP_PAIR)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_TRACK_CLIP_PAIR)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + track_clip_pair_unref (old); + } +} + + +static void track_clip_pair_class_init (TrackClipPairClass * klass) { + track_clip_pair_parent_class = g_type_class_peek_parent (klass); + TRACK_CLIP_PAIR_CLASS (klass)->finalize = track_clip_pair_finalize; +} + + +static void track_clip_pair_instance_init (TrackClipPair * self) { + self->ref_count = 1; +} + + +static void track_clip_pair_finalize (TrackClipPair* obj) { + TrackClipPair * self; + self = TRACK_CLIP_PAIR (obj); + _g_object_unref0 (self->track); + _g_object_unref0 (self->clip); +} + + +GType track_clip_pair_get_type (void) { + static volatile gsize track_clip_pair_type_id__volatile = 0; + if (g_once_init_enter (&track_clip_pair_type_id__volatile)) { + static const GTypeValueTable g_define_type_value_table = { value_track_clip_pair_init, value_track_clip_pair_free_value, value_track_clip_pair_copy_value, value_track_clip_pair_peek_pointer, "p", value_track_clip_pair_collect_value, "p", value_track_clip_pair_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (TrackClipPairClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) track_clip_pair_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (TrackClipPair), 0, (GInstanceInitFunc) track_clip_pair_instance_init, &g_define_type_value_table }; + static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) }; + GType track_clip_pair_type_id; + track_clip_pair_type_id = g_type_register_fundamental (g_type_fundamental_next (), "TrackClipPair", &g_define_type_info, &g_define_type_fundamental_info, 0); + g_once_init_leave (&track_clip_pair_type_id__volatile, track_clip_pair_type_id); + } + return track_clip_pair_type_id__volatile; +} + + +gpointer track_clip_pair_ref (gpointer instance) { + TrackClipPair* self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + + +void track_clip_pair_unref (gpointer instance) { + TrackClipPair* self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + TRACK_CLIP_PAIR_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + + +#line 22 "timeline.vala" +void clipboard_select (Clipboard* self, GeeArrayList* selected_clips) { +#line 22 "timeline.vala" + g_return_if_fail (IS_CLIPBOARD (self)); +#line 22 "timeline.vala" + g_return_if_fail (GEE_IS_ARRAY_LIST (selected_clips)); +#line 23 "timeline.vala" + gee_abstract_collection_clear (GEE_ABSTRACT_COLLECTION (self->clips)); +#line 24 "timeline.vala" + self->priv->minimum_time = (gint64) (-1); +#line 798 "timeline.c" + { + GeeIterator* _clip_view_it; + _clip_view_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (selected_clips)); +#line 25 "timeline.vala" + while (TRUE) { +#line 804 "timeline.c" + ClipView* clip_view; + GtkContainer* _tmp0_; + TrackView* track_view; + gboolean _tmp1_ = FALSE; + ModelTrack* _tmp2_; + TrackClipPair* _tmp3_; + TrackClipPair* track_clip_pair; +#line 25 "timeline.vala" + if (!gee_iterator_next (_clip_view_it)) { +#line 25 "timeline.vala" + break; +#line 816 "timeline.c" + } +#line 25 "timeline.vala" + clip_view = (ClipView*) gee_iterator_get (_clip_view_it); +#line 26 "timeline.vala" + track_view = _g_object_ref0 ((_tmp0_ = gtk_widget_get_parent (GTK_WIDGET (clip_view)), IS_TRACK_VIEW (_tmp0_) ? ((TrackView*) _tmp0_) : NULL)); +#line 27 "timeline.vala" + if (self->priv->minimum_time < 0) { +#line 27 "timeline.vala" + _tmp1_ = TRUE; +#line 826 "timeline.c" + } else { +#line 27 "timeline.vala" + _tmp1_ = model_clip_get_start (clip_view->clip) < self->priv->minimum_time; +#line 830 "timeline.c" + } +#line 27 "timeline.vala" + if (_tmp1_) { +#line 28 "timeline.vala" + self->priv->minimum_time = model_clip_get_start (clip_view->clip); +#line 836 "timeline.c" + } +#line 30 "timeline.vala" + track_clip_pair = (_tmp3_ = track_clip_pair_new (_tmp2_ = track_view_get_track (track_view), clip_view->clip), _g_object_unref0 (_tmp2_), _tmp3_); +#line 31 "timeline.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->clips), track_clip_pair); +#line 842 "timeline.c" + _g_object_unref0 (clip_view); + _g_object_unref0 (track_view); + _track_clip_pair_unref0 (track_clip_pair); + } + _g_object_unref0 (_clip_view_it); + } +} + + +#line 35 "timeline.vala" +void clipboard_paste (Clipboard* self, ModelTrack* selected_track, gint64 time) { +#line 35 "timeline.vala" + g_return_if_fail (IS_CLIPBOARD (self)); +#line 35 "timeline.vala" + g_return_if_fail (MODEL_IS_TRACK (selected_track)); +#line 36 "timeline.vala" + if (gee_collection_get_size (GEE_COLLECTION (self->clips)) != 1) { +#line 860 "timeline.c" + { + GeeIterator* _pair_it; + _pair_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->clips)); +#line 37 "timeline.vala" + while (TRUE) { +#line 866 "timeline.c" + TrackClipPair* pair; + ModelClip* _tmp0_; +#line 37 "timeline.vala" + if (!gee_iterator_next (_pair_it)) { +#line 37 "timeline.vala" + break; +#line 873 "timeline.c" + } +#line 37 "timeline.vala" + pair = (TrackClipPair*) gee_iterator_get (_pair_it); +#line 38 "timeline.vala" + model_track_do_clip_paste (pair->track, _tmp0_ = model_clip_copy (pair->clip), (time + model_clip_get_start (pair->clip)) - self->priv->minimum_time); +#line 879 "timeline.c" + _g_object_unref0 (_tmp0_); + _track_clip_pair_unref0 (pair); + } + _g_object_unref0 (_pair_it); + } + } else { + ModelClip* _tmp2_; + TrackClipPair* _tmp1_; +#line 41 "timeline.vala" + model_track_do_clip_paste (selected_track, _tmp2_ = model_clip_copy ((_tmp1_ = (TrackClipPair*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), 0))->clip), time); +#line 890 "timeline.c" + _g_object_unref0 (_tmp2_); + _track_clip_pair_unref0 (_tmp1_); + } +} + + +#line 18 "timeline.vala" +Clipboard* clipboard_construct (GType object_type) { +#line 899 "timeline.c" + Clipboard* self; + self = (Clipboard*) g_type_create_instance (object_type); + return self; +} + + +#line 18 "timeline.vala" +Clipboard* clipboard_new (void) { +#line 18 "timeline.vala" + return clipboard_construct (TYPE_CLIPBOARD); +#line 910 "timeline.c" +} + + +static void value_clipboard_init (GValue* value) { + value->data[0].v_pointer = NULL; +} + + +static void value_clipboard_free_value (GValue* value) { + if (value->data[0].v_pointer) { + clipboard_unref (value->data[0].v_pointer); + } +} + + +static void value_clipboard_copy_value (const GValue* src_value, GValue* dest_value) { + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = clipboard_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + + +static gpointer value_clipboard_peek_pointer (const GValue* value) { + return value->data[0].v_pointer; +} + + +static gchar* value_clipboard_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + if (collect_values[0].v_pointer) { + Clipboard* object; + object = collect_values[0].v_pointer; + if (object->parent_instance.g_class == NULL) { + return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) { + return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } + value->data[0].v_pointer = clipboard_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + + +static gchar* value_clipboard_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + Clipboard** object_p; + object_p = collect_values[0].v_pointer; + if (!object_p) { + return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); + } + if (!value->data[0].v_pointer) { + *object_p = NULL; + } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) { + *object_p = value->data[0].v_pointer; + } else { + *object_p = clipboard_ref (value->data[0].v_pointer); + } + return NULL; +} + + +GParamSpec* param_spec_clipboard (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) { + ParamSpecClipboard* spec; + g_return_val_if_fail (g_type_is_a (object_type, TYPE_CLIPBOARD), NULL); + spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags); + G_PARAM_SPEC (spec)->value_type = object_type; + return G_PARAM_SPEC (spec); +} + + +gpointer value_get_clipboard (const GValue* value) { + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_CLIPBOARD), NULL); + return value->data[0].v_pointer; +} + + +void value_set_clipboard (GValue* value, gpointer v_object) { + Clipboard* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_CLIPBOARD)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_CLIPBOARD)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + clipboard_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + clipboard_unref (old); + } +} + + +void value_take_clipboard (GValue* value, gpointer v_object) { + Clipboard* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_CLIPBOARD)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_CLIPBOARD)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + clipboard_unref (old); + } +} + + +static void clipboard_class_init (ClipboardClass * klass) { + clipboard_parent_class = g_type_class_peek_parent (klass); + CLIPBOARD_CLASS (klass)->finalize = clipboard_finalize; + g_type_class_add_private (klass, sizeof (ClipboardPrivate)); +} + + +static void clipboard_instance_init (Clipboard * self) { + self->priv = CLIPBOARD_GET_PRIVATE (self); + self->clips = gee_array_list_new (TYPE_TRACK_CLIP_PAIR, (GBoxedCopyFunc) track_clip_pair_ref, track_clip_pair_unref, NULL); + self->priv->minimum_time = (gint64) (-1); + self->ref_count = 1; +} + + +static void clipboard_finalize (Clipboard* obj) { + Clipboard * self; + self = CLIPBOARD (obj); + _g_object_unref0 (self->clips); +} + + +GType clipboard_get_type (void) { + static volatile gsize clipboard_type_id__volatile = 0; + if (g_once_init_enter (&clipboard_type_id__volatile)) { + static const GTypeValueTable g_define_type_value_table = { value_clipboard_init, value_clipboard_free_value, value_clipboard_copy_value, value_clipboard_peek_pointer, "p", value_clipboard_collect_value, "p", value_clipboard_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (ClipboardClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) clipboard_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Clipboard), 0, (GInstanceInitFunc) clipboard_instance_init, &g_define_type_value_table }; + static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) }; + GType clipboard_type_id; + clipboard_type_id = g_type_register_fundamental (g_type_fundamental_next (), "Clipboard", &g_define_type_info, &g_define_type_fundamental_info, 0); + g_once_init_leave (&clipboard_type_id__volatile, clipboard_type_id); + } + return clipboard_type_id__volatile; +} + + +gpointer clipboard_ref (gpointer instance) { + Clipboard* self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + + +void clipboard_unref (gpointer instance) { + Clipboard* self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + CLIPBOARD_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + + +#line 124 "timeline.vala" +static void _time_line_on_geometry_changed_model_time_system_geometry_changed (ModelTimeSystem* _sender, gpointer self) { +#line 1080 "timeline.c" + time_line_on_geometry_changed (self); +} + + +#line 368 "timeline.vala" +static void _time_line_on_ruler_position_changed_view_ruler_position_changed (ViewRuler* _sender, gint x, gpointer self) { +#line 1087 "timeline.c" + time_line_on_ruler_position_changed (self, x); +} + + +#line 135 "timeline.vala" +static void _time_line_on_track_added_model_project_track_added (ModelProject* _sender, ModelTrack* track, gpointer self) { +#line 1094 "timeline.c" + time_line_on_track_added (self, track); +} + + +#line 148 "timeline.vala" +static void _time_line_on_track_removed_model_project_track_removed (ModelProject* _sender, ModelTrack* track, gpointer self) { +#line 1101 "timeline.c" + time_line_on_track_removed (self, track); +} + + +#line 130 "timeline.vala" +static void _time_line_on_position_changed_view_media_engine_position_changed (ViewMediaEngine* _sender, gint64 position, gpointer self) { +#line 1108 "timeline.c" + time_line_on_position_changed (self); +} + + +#line 75 "timeline.vala" +TimeLine* time_line_construct (GType object_type, ModelProject* p, ModelTimeSystem* provider, GdkDragAction actions) { +#line 1115 "timeline.c" + TimeLine * self; + GtkWidget* _tmp0_; + ModelProject* _tmp1_; + GtkVBox* _tmp2_; + ViewRuler* _tmp3_; + GdkColor _tmp5_; + GdkColor _tmp4_ = {0}; + GdkColor _tmp7_; + GdkColor _tmp6_ = {0}; +#line 75 "timeline.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (p), NULL); +#line 75 "timeline.vala" + g_return_val_if_fail (MODEL_IS_TIME_SYSTEM (provider), NULL); +#line 1129 "timeline.c" + self = g_object_newv (object_type, 0, NULL); +#line 76 "timeline.vala" + gtk_widget_add_events (GTK_WIDGET (self), (gint) GDK_POINTER_MOTION_MASK); +#line 77 "timeline.vala" + self->priv->drag_widget = (_tmp0_ = NULL, _g_object_unref0 (self->priv->drag_widget), _tmp0_); +#line 78 "timeline.vala" + g_object_set (GTK_WIDGET (self), "can-focus", TRUE, NULL); +#line 79 "timeline.vala" + self->project = (_tmp1_ = _g_object_ref0 (p), _g_object_unref0 (self->project), _tmp1_); +#line 80 "timeline.vala" + self->provider = provider; +#line 81 "timeline.vala" + g_signal_connect_object (provider, "geometry-changed", (GCallback) _time_line_on_geometry_changed_model_time_system_geometry_changed, self, 0); +#line 83 "timeline.vala" + self->priv->vbox = (_tmp2_ = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (FALSE, 0)), _g_object_unref0 (self->priv->vbox), _tmp2_); +#line 84 "timeline.vala" + self->ruler = (_tmp3_ = g_object_ref_sink (view_ruler_new (provider, TIME_LINE_RULER_HEIGHT)), _g_object_unref0 (self->ruler), _tmp3_); +#line 85 "timeline.vala" + g_signal_connect_object (self->ruler, "position-changed", (GCallback) _time_line_on_ruler_position_changed_view_ruler_position_changed, self, 0); +#line 86 "timeline.vala" + gtk_box_pack_start (GTK_BOX (self->priv->vbox), GTK_WIDGET (self->ruler), FALSE, FALSE, (guint) 0); +#line 88 "timeline.vala" + g_signal_connect_object (self->project, "track-added", (GCallback) _time_line_on_track_added_model_project_track_added, self, 0); +#line 89 "timeline.vala" + g_signal_connect_object (self->project, "track-removed", (GCallback) _time_line_on_track_removed_model_project_track_removed, self, 0); +#line 90 "timeline.vala" + g_signal_connect_object (self->project->media_engine, "position-changed", (GCallback) _time_line_on_position_changed_view_media_engine_position_changed, self, 0); +#line 91 "timeline.vala" + gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (self->priv->vbox)); +#line 93 "timeline.vala" + gtk_widget_modify_bg (GTK_WIDGET (self), GTK_STATE_NORMAL, (_tmp5_ = (parse_color ("#444", &_tmp4_), _tmp4_), &_tmp5_)); +#line 94 "timeline.vala" + gtk_widget_modify_fg (GTK_WIDGET (self), GTK_STATE_NORMAL, (_tmp7_ = (parse_color ("#f00", &_tmp6_), _tmp6_), &_tmp7_)); +#line 96 "timeline.vala" + self->priv->pixel_div = self->priv->pixel_max / self->priv->pixel_min; +#line 97 "timeline.vala" + model_time_system_calculate_pixel_step (provider, 0.5f, self->priv->pixel_min, self->priv->pixel_div); +#line 98 "timeline.vala" + gtk_drag_dest_set (GTK_WIDGET (self), GTK_DEST_DEFAULT_ALL, drag_target_entries, G_N_ELEMENTS (drag_target_entries), actions); +#line 1169 "timeline.c" + return self; +} + + +#line 75 "timeline.vala" +TimeLine* time_line_new (ModelProject* p, ModelTimeSystem* provider, GdkDragAction actions) { +#line 75 "timeline.vala" + return time_line_construct (TYPE_TIME_LINE, p, provider, actions); +#line 1178 "timeline.c" +} + + +#line 101 "timeline.vala" +void time_line_zoom_to_project (TimeLine* self, double width) { +#line 1184 "timeline.c" + double numerator; + double denominator; +#line 101 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 102 "timeline.vala" + if (model_project_get_length (self->project) == 0) { +#line 103 "timeline.vala" + return; +#line 1193 "timeline.c" + } +#line 106 "timeline.vala" + width = width - 12.0; +#line 108 "timeline.vala" + numerator = log ((width * GST_SECOND) / (((double) model_project_get_length (self->project)) * ((double) self->priv->pixel_min))); +#line 110 "timeline.vala" + denominator = log ((double) self->priv->pixel_div); +#line 112 "timeline.vala" + time_line_zoom (self, ((float) (numerator / denominator)) - model_time_system_get_pixel_percentage (self->provider)); +#line 1203 "timeline.c" +} + + +#line 115 "timeline.vala" +void time_line_zoom (TimeLine* self, float inc) { +#line 115 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 116 "timeline.vala" + model_time_system_calculate_pixel_step (self->provider, inc, self->priv->pixel_min, self->priv->pixel_div); +#line 1213 "timeline.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 117 "timeline.vala" + while (TRUE) { +#line 1219 "timeline.c" + TrackView* track; +#line 117 "timeline.vala" + if (!gee_iterator_next (_track_it)) { +#line 117 "timeline.vala" + break; +#line 1225 "timeline.c" + } +#line 117 "timeline.vala" + track = (TrackView*) gee_iterator_get (_track_it); +#line 118 "timeline.vala" + track_view_resize (track); +#line 1231 "timeline.c" + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } +#line 120 "timeline.vala" + g_signal_emit_by_name (self->project->media_engine, "position-changed", model_project_transport_get_position (self->project)); +#line 121 "timeline.vala" + gtk_widget_queue_draw (GTK_WIDGET (self)); +#line 1240 "timeline.c" +} + + +#line 124 "timeline.vala" +static void time_line_on_geometry_changed (TimeLine* self) { +#line 124 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 125 "timeline.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_geometry_changed"); +#line 126 "timeline.vala" + model_time_system_calculate_pixel_step (self->provider, (float) 0, self->priv->pixel_min, self->priv->pixel_div); +#line 127 "timeline.vala" + gtk_widget_queue_draw (GTK_WIDGET (self->ruler)); +#line 1254 "timeline.c" +} + + +#line 130 "timeline.vala" +static void time_line_on_position_changed (TimeLine* self) { +#line 130 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 131 "timeline.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_position_changed"); +#line 132 "timeline.vala" + gtk_widget_queue_draw (GTK_WIDGET (self)); +#line 1266 "timeline.c" +} + + +#line 160 "timeline.vala" +static void _time_line_on_clip_view_added_track_view_clip_view_added (TrackView* _sender, ClipView* clip_view, gpointer self) { +#line 1272 "timeline.c" + time_line_on_clip_view_added (self, clip_view); +} + + +#line 135 "timeline.vala" +static void time_line_on_track_added (TimeLine* self, ModelTrack* track) { +#line 1279 "timeline.c" + ClassFactory* _tmp0_; + TrackView* _tmp1_; + TrackView* track_view; +#line 135 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 135 "timeline.vala" + g_return_if_fail (MODEL_IS_TRACK (track)); +#line 136 "timeline.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_track_added"); +#line 137 "timeline.vala" + track_view = (_tmp1_ = class_factory_get_track_view (_tmp0_ = class_factory_get_class_factory (), track, self), _class_factory_unref0 (_tmp0_), _tmp1_); +#line 138 "timeline.vala" + g_signal_connect_object (track_view, "clip-view-added", (GCallback) _time_line_on_clip_view_added_track_view_clip_view_added, self, 0); +#line 139 "timeline.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->tracks), track_view); +#line 140 "timeline.vala" + gtk_box_pack_start (GTK_BOX (self->priv->vbox), GTK_WIDGET (track_view), FALSE, FALSE, (guint) 0); +#line 141 "timeline.vala" + g_signal_emit_by_name (self, "trackview-added", track_view); +#line 142 "timeline.vala" + if (model_track_media_type (track) == MODEL_MEDIA_TYPE_VIDEO) { +#line 143 "timeline.vala" + gtk_box_reorder_child (GTK_BOX (self->priv->vbox), GTK_WIDGET (track_view), 1); +#line 1303 "timeline.c" + } +#line 145 "timeline.vala" + gtk_widget_show_all (GTK_WIDGET (self->priv->vbox)); +#line 1307 "timeline.c" + _g_object_unref0 (track_view); +} + + +#line 148 "timeline.vala" +static void time_line_on_track_removed (TimeLine* self, ModelTrack* track) { +#line 148 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 148 "timeline.vala" + g_return_if_fail (MODEL_IS_TRACK (track)); +#line 149 "timeline.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_track_removed"); +#line 1320 "timeline.c" + { + GeeIterator* _track_view_it; + _track_view_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 150 "timeline.vala" + while (TRUE) { +#line 1326 "timeline.c" + TrackView* track_view; + ModelTrack* _tmp0_; + gboolean _tmp1_; +#line 150 "timeline.vala" + if (!gee_iterator_next (_track_view_it)) { +#line 150 "timeline.vala" + break; +#line 1334 "timeline.c" + } +#line 150 "timeline.vala" + track_view = (TrackView*) gee_iterator_get (_track_view_it); +#line 151 "timeline.vala" + if ((_tmp1_ = (_tmp0_ = track_view_get_track (track_view)) == track, _g_object_unref0 (_tmp0_), _tmp1_)) { +#line 152 "timeline.vala" + g_signal_emit_by_name (self, "trackview-removed", track_view); +#line 153 "timeline.vala" + gtk_container_remove (GTK_CONTAINER (self->priv->vbox), GTK_WIDGET (track_view)); +#line 154 "timeline.vala" + gee_abstract_collection_remove (GEE_ABSTRACT_COLLECTION (self->tracks), track_view); +#line 1346 "timeline.c" + _g_object_unref0 (track_view); +#line 155 "timeline.vala" + break; +#line 1350 "timeline.c" + } + _g_object_unref0 (track_view); + } + _g_object_unref0 (_track_view_it); + } +} + + +#line 234 "timeline.vala" +static void _time_line_on_clip_view_selection_request_clip_view_selection_request (ClipView* _sender, ClipView* clip_view, gboolean extend_selection, gpointer self) { +#line 1361 "timeline.c" + time_line_on_clip_view_selection_request (self, clip_view, extend_selection); +} + + +#line 327 "timeline.vala" +static void _time_line_on_clip_view_move_request_clip_view_move_request (ClipView* _sender, ClipView* clip_view, gint64 delta, gpointer self) { +#line 1368 "timeline.c" + time_line_on_clip_view_move_request (self, clip_view, delta); +} + + +#line 267 "timeline.vala" +static void _time_line_on_clip_view_move_commit_clip_view_move_commit (ClipView* _sender, ClipView* clip_view, gint64 delta, gpointer self) { +#line 1375 "timeline.c" + time_line_on_clip_view_move_commit (self, clip_view, delta); +} + + +#line 177 "timeline.vala" +static void _time_line_on_clip_view_move_begin_clip_view_move_begin (ClipView* _sender, ClipView* clip_view, gboolean copy, gpointer self) { +#line 1382 "timeline.c" + time_line_on_clip_view_move_begin (self, clip_view, copy); +} + + +#line 219 "timeline.vala" +static void _time_line_on_clip_view_trim_begin_clip_view_trim_begin (ClipView* _sender, ClipView* clip_view, GdkWindowEdge edge, gpointer self) { +#line 1389 "timeline.c" + time_line_on_clip_view_trim_begin (self, clip_view, edge); +} + + +#line 288 "timeline.vala" +static void _time_line_on_clip_view_trim_commit_clip_view_trim_commit (ClipView* _sender, ClipView* clip_view, GdkWindowEdge edge, gpointer self) { +#line 1396 "timeline.c" + time_line_on_clip_view_trim_commit (self, clip_view, edge); +} + + +#line 160 "timeline.vala" +void time_line_on_clip_view_added (TimeLine* self, ClipView* clip_view) { +#line 160 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 160 "timeline.vala" + g_return_if_fail (IS_CLIP_VIEW (clip_view)); +#line 161 "timeline.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_clip_view_added"); +#line 162 "timeline.vala" + g_signal_connect_object (clip_view, "selection-request", (GCallback) _time_line_on_clip_view_selection_request_clip_view_selection_request, self, 0); +#line 163 "timeline.vala" + g_signal_connect_object (clip_view, "move-request", (GCallback) _time_line_on_clip_view_move_request_clip_view_move_request, self, 0); +#line 164 "timeline.vala" + g_signal_connect_object (clip_view, "move-commit", (GCallback) _time_line_on_clip_view_move_commit_clip_view_move_commit, self, 0); +#line 165 "timeline.vala" + g_signal_connect_object (clip_view, "move-begin", (GCallback) _time_line_on_clip_view_move_begin_clip_view_move_begin, self, 0); +#line 166 "timeline.vala" + g_signal_connect_object (clip_view, "trim-begin", (GCallback) _time_line_on_clip_view_trim_begin_clip_view_trim_begin, self, 0); +#line 167 "timeline.vala" + g_signal_connect_object (clip_view, "trim-commit", (GCallback) _time_line_on_clip_view_trim_commit_clip_view_trim_commit, self, 0); +#line 1421 "timeline.c" +} + + +#line 170 "timeline.vala" +void time_line_deselect_all_clips (TimeLine* self) { +#line 170 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 1429 "timeline.c" + { + GeeIterator* _selected_clip_view_it; + _selected_clip_view_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->selected_clips)); +#line 171 "timeline.vala" + while (TRUE) { +#line 1435 "timeline.c" + ClipView* selected_clip_view; +#line 171 "timeline.vala" + if (!gee_iterator_next (_selected_clip_view_it)) { +#line 171 "timeline.vala" + break; +#line 1441 "timeline.c" + } +#line 171 "timeline.vala" + selected_clip_view = (ClipView*) gee_iterator_get (_selected_clip_view_it); +#line 172 "timeline.vala" + selected_clip_view->is_selected = FALSE; +#line 1447 "timeline.c" + _g_object_unref0 (selected_clip_view); + } + _g_object_unref0 (_selected_clip_view_it); + } +#line 174 "timeline.vala" + gee_abstract_collection_clear (GEE_ABSTRACT_COLLECTION (self->selected_clips)); +#line 1454 "timeline.c" +} + + +#line 177 "timeline.vala" +static void time_line_on_clip_view_move_begin (TimeLine* self, ClipView* clip_view, gboolean copy) { +#line 1460 "timeline.c" + ClipView* max_clip; + GtkLabel* _tmp5_; + GtkWidget* _tmp6_; + GtkFixed* the_parent; +#line 177 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 177 "timeline.vala" + g_return_if_fail (IS_CLIP_VIEW (clip_view)); +#line 178 "timeline.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_view_move_begin"); +#line 179 "timeline.vala" + self->priv->copying = copy; +#line 180 "timeline.vala" + if (copy) { +#line 181 "timeline.vala" + model_undo_manager_start_transaction (self->project->undo_manager, "Copy Clip"); +#line 1477 "timeline.c" + } +#line 183 "timeline.vala" + max_clip = NULL; +#line 1481 "timeline.c" + { + GeeIterator* _selected_clip_it; + _selected_clip_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->selected_clips)); +#line 185 "timeline.vala" + while (TRUE) { +#line 1487 "timeline.c" + ClipView* selected_clip; + GtkWidget* _tmp2_; + TrackView* track_view; +#line 185 "timeline.vala" + if (!gee_iterator_next (_selected_clip_it)) { +#line 185 "timeline.vala" + break; +#line 1495 "timeline.c" + } +#line 185 "timeline.vala" + selected_clip = (ClipView*) gee_iterator_get (_selected_clip_it); +#line 186 "timeline.vala" + if (max_clip == NULL) { +#line 1501 "timeline.c" + ClipView* _tmp0_; +#line 187 "timeline.vala" + max_clip = (_tmp0_ = _g_object_ref0 (selected_clip), _g_object_unref0 (max_clip), _tmp0_); +#line 1505 "timeline.c" + } else { +#line 188 "timeline.vala" + if (model_clip_get_end (max_clip->clip) < model_clip_get_end (selected_clip->clip)) { +#line 1509 "timeline.c" + ClipView* _tmp1_; +#line 189 "timeline.vala" + max_clip = (_tmp1_ = _g_object_ref0 (selected_clip), _g_object_unref0 (max_clip), _tmp1_); +#line 1513 "timeline.c" + } + } +#line 191 "timeline.vala" + selected_clip->initial_time = model_clip_get_start (selected_clip->clip); +#line 192 "timeline.vala" + model_clip_gnonlin_disconnect (selected_clip->clip); +#line 193 "timeline.vala" + track_view = _g_object_ref0 ((_tmp2_ = gtk_widget_get_parent (GTK_WIDGET (selected_clip)), IS_TRACK_VIEW (_tmp2_) ? ((TrackView*) _tmp2_) : NULL)); +#line 194 "timeline.vala" + if (track_view != NULL) { +#line 1524 "timeline.c" + ModelTrack* _tmp3_; +#line 195 "timeline.vala" + model_track_remove_clip_from_array (_tmp3_ = track_view_get_track (track_view), selected_clip->clip); +#line 1528 "timeline.c" + _g_object_unref0 (_tmp3_); + } +#line 197 "timeline.vala" + if (copy) { +#line 1533 "timeline.c" + ModelClip* clip; + ModelTrack* _tmp4_; +#line 201 "timeline.vala" + clip = model_clip_copy (selected_clip->clip); +#line 202 "timeline.vala" + model_track_append_at_time (_tmp4_ = track_view_get_track (track_view), clip, model_clip_get_start (selected_clip->clip), FALSE); +#line 1540 "timeline.c" + _g_object_unref0 (_tmp4_); + _g_object_unref0 (clip); + } + _g_object_unref0 (selected_clip); + _g_object_unref0 (track_view); + } + _g_object_unref0 (_selected_clip_it); + } +#line 206 "timeline.vala" + self->priv->high_water = (_tmp5_ = g_object_ref_sink ((GtkLabel*) gtk_label_new (NULL)), _g_object_unref0 (self->priv->high_water), _tmp5_); +#line 207 "timeline.vala" + the_parent = _g_object_ref0 ((_tmp6_ = gtk_widget_get_parent (GTK_WIDGET (clip_view)), GTK_IS_FIXED (_tmp6_) ? ((GtkFixed*) _tmp6_) : NULL)); +#line 208 "timeline.vala" + gtk_fixed_put (the_parent, GTK_WIDGET (self->priv->high_water), GTK_WIDGET (max_clip)->allocation.x + GTK_WIDGET (max_clip)->allocation.width, GTK_WIDGET (max_clip)->allocation.y); +#line 1555 "timeline.c" + { + GeeIterator* _selected_clip_it; + _selected_clip_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->selected_clips)); +#line 213 "timeline.vala" + while (TRUE) { +#line 1561 "timeline.c" + ClipView* selected_clip; + GtkWidget* _tmp7_; + TrackView* track_view; +#line 213 "timeline.vala" + if (!gee_iterator_next (_selected_clip_it)) { +#line 213 "timeline.vala" + break; +#line 1569 "timeline.c" + } +#line 213 "timeline.vala" + selected_clip = (ClipView*) gee_iterator_get (_selected_clip_it); +#line 214 "timeline.vala" + track_view = _g_object_ref0 ((_tmp7_ = gtk_widget_get_parent (GTK_WIDGET (selected_clip)), IS_TRACK_VIEW (_tmp7_) ? ((TrackView*) _tmp7_) : NULL)); +#line 215 "timeline.vala" + track_view_move_to_top (track_view, selected_clip); +#line 1577 "timeline.c" + _g_object_unref0 (selected_clip); + _g_object_unref0 (track_view); + } + _g_object_unref0 (_selected_clip_it); + } + _g_object_unref0 (max_clip); + _g_object_unref0 (the_parent); +} + + +#line 219 "timeline.vala" +static void time_line_on_clip_view_trim_begin (TimeLine* self, ClipView* clip, GdkWindowEdge edge) { +#line 219 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 219 "timeline.vala" + g_return_if_fail (IS_CLIP_VIEW (clip)); +#line 220 "timeline.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_view_trim_begin"); +#line 221 "timeline.vala" + switch (edge) { +#line 1598 "timeline.c" + case GDK_WINDOW_EDGE_WEST: + { +#line 223 "timeline.vala" + clip->initial_time = model_clip_get_start (clip->clip); +#line 224 "timeline.vala" + break; +#line 1605 "timeline.c" + } + case GDK_WINDOW_EDGE_EAST: + { +#line 226 "timeline.vala" + clip->initial_time = model_clip_get_duration (clip->clip); +#line 227 "timeline.vala" + break; +#line 1613 "timeline.c" + } + default: + { +#line 229 "timeline.vala" + g_assert (FALSE); +#line 230 "timeline.vala" + break; +#line 1621 "timeline.c" + } + } +} + + +#line 234 "timeline.vala" +static void time_line_on_clip_view_selection_request (TimeLine* self, ClipView* clip_view, gboolean extend) { +#line 1629 "timeline.c" + gboolean in_selected_clips; +#line 234 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 234 "timeline.vala" + g_return_if_fail (IS_CLIP_VIEW (clip_view)); +#line 235 "timeline.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_view_selection_request"); +#line 241 "timeline.vala" + in_selected_clips = gee_abstract_collection_contains (GEE_ABSTRACT_COLLECTION (self->selected_clips), clip_view); +#line 242 "timeline.vala" + if (!extend) { +#line 243 "timeline.vala" + if (!in_selected_clips) { +#line 244 "timeline.vala" + time_line_deselect_all_clips (self); +#line 245 "timeline.vala" + clip_view->is_selected = TRUE; +#line 246 "timeline.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->selected_clips), clip_view); +#line 1649 "timeline.c" + } + } else { +#line 249 "timeline.vala" + if (gee_collection_get_size (GEE_COLLECTION (self->selected_clips)) > 1) { +#line 1654 "timeline.c" + gboolean _tmp0_ = FALSE; +#line 250 "timeline.vala" + if (in_selected_clips) { +#line 250 "timeline.vala" + _tmp0_ = clip_view->is_selected; +#line 1660 "timeline.c" + } else { +#line 250 "timeline.vala" + _tmp0_ = FALSE; +#line 1664 "timeline.c" + } +#line 250 "timeline.vala" + if (_tmp0_) { +#line 1668 "timeline.c" + GtkWidget* _tmp1_; +#line 251 "timeline.vala" + clip_view->is_selected = FALSE; +#line 253 "timeline.vala" + self->priv->drag_widget = (_tmp1_ = NULL, _g_object_unref0 (self->priv->drag_widget), _tmp1_); +#line 254 "timeline.vala" + gee_abstract_collection_remove (GEE_ABSTRACT_COLLECTION (self->selected_clips), clip_view); +#line 1676 "timeline.c" + } + } +#line 257 "timeline.vala" + if (!in_selected_clips) { +#line 258 "timeline.vala" + clip_view->is_selected = TRUE; +#line 259 "timeline.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->selected_clips), clip_view); +#line 1685 "timeline.c" + } + } +#line 262 "timeline.vala" + g_signal_emit_by_name (self, "track-changed"); +#line 263 "timeline.vala" + g_signal_emit_by_name (self, "selection-changed", time_line_is_clip_selected (self)); +#line 264 "timeline.vala" + gtk_widget_queue_draw (GTK_WIDGET (self)); +#line 1694 "timeline.c" +} + + +#line 267 "timeline.vala" +static void time_line_on_clip_view_move_commit (TimeLine* self, ClipView* clip_view, gint64 delta) { +#line 1700 "timeline.c" + GtkWidget* _tmp0_; + GtkFixed* fixed; + GtkLabel* _tmp1_; +#line 267 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 267 "timeline.vala" + g_return_if_fail (IS_CLIP_VIEW (clip_view)); +#line 268 "timeline.vala" + gdk_window_set_cursor (GTK_WIDGET (self)->window, NULL); +#line 269 "timeline.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_view_move_request"); +#line 270 "timeline.vala" + fixed = _g_object_ref0 ((_tmp0_ = gtk_widget_get_parent (GTK_WIDGET (self->priv->high_water)), GTK_IS_FIXED (_tmp0_) ? ((GtkFixed*) _tmp0_) : NULL)); +#line 271 "timeline.vala" + gtk_container_remove (GTK_CONTAINER (fixed), GTK_WIDGET (self->priv->high_water)); +#line 272 "timeline.vala" + self->priv->high_water = (_tmp1_ = NULL, _g_object_unref0 (self->priv->high_water), _tmp1_); +#line 274 "timeline.vala" + model_undo_manager_start_transaction (self->project->undo_manager, "Move Clip"); +#line 1720 "timeline.c" + { + GeeIterator* _selected_clip_view_it; + _selected_clip_view_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->selected_clips)); +#line 275 "timeline.vala" + while (TRUE) { +#line 1726 "timeline.c" + ClipView* selected_clip_view; + GtkWidget* _tmp2_; + TrackView* track_view; + ModelTrack* _tmp3_; +#line 275 "timeline.vala" + if (!gee_iterator_next (_selected_clip_view_it)) { +#line 275 "timeline.vala" + break; +#line 1735 "timeline.c" + } +#line 275 "timeline.vala" + selected_clip_view = (ClipView*) gee_iterator_get (_selected_clip_view_it); +#line 276 "timeline.vala" + track_view = _g_object_ref0 ((_tmp2_ = gtk_widget_get_parent (GTK_WIDGET (selected_clip_view)), IS_TRACK_VIEW (_tmp2_) ? ((TrackView*) _tmp2_) : NULL)); +#line 277 "timeline.vala" + model_clip_gnonlin_connect (selected_clip_view->clip); +#line 278 "timeline.vala" + model_track_move (_tmp3_ = track_view_get_track (track_view), selected_clip_view->clip, model_clip_get_start (selected_clip_view->clip), selected_clip_view->initial_time); +#line 1745 "timeline.c" + _g_object_unref0 (_tmp3_); + _g_object_unref0 (selected_clip_view); + _g_object_unref0 (track_view); + } + _g_object_unref0 (_selected_clip_view_it); + } +#line 281 "timeline.vala" + model_undo_manager_end_transaction (self->project->undo_manager, "Move Clip"); +#line 282 "timeline.vala" + if (self->priv->copying) { +#line 283 "timeline.vala" + self->priv->copying = FALSE; +#line 284 "timeline.vala" + model_undo_manager_end_transaction (self->project->undo_manager, "Copy Clip"); +#line 1760 "timeline.c" + } + _g_object_unref0 (fixed); +} + + +#line 288 "timeline.vala" +static void time_line_on_clip_view_trim_commit (TimeLine* self, ClipView* clip_view, GdkWindowEdge edge) { +#line 1768 "timeline.c" + GtkWidget* _tmp0_; + TrackView* track_view; + gint64 delta; + ModelTrack* _tmp1_; +#line 288 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 288 "timeline.vala" + g_return_if_fail (IS_CLIP_VIEW (clip_view)); +#line 289 "timeline.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_view_move_commit"); +#line 290 "timeline.vala" + gdk_window_set_cursor (GTK_WIDGET (self)->window, NULL); +#line 291 "timeline.vala" + track_view = _g_object_ref0 ((_tmp0_ = gtk_widget_get_parent (GTK_WIDGET (clip_view)), IS_TRACK_VIEW (_tmp0_) ? ((TrackView*) _tmp0_) : NULL)); +#line 292 "timeline.vala" + delta = (gint64) 0; +#line 293 "timeline.vala" + switch (edge) { +#line 1787 "timeline.c" + case GDK_WINDOW_EDGE_WEST: + { +#line 295 "timeline.vala" + delta = model_clip_get_start (clip_view->clip) - clip_view->initial_time; +#line 296 "timeline.vala" + break; +#line 1794 "timeline.c" + } + case GDK_WINDOW_EDGE_EAST: + { +#line 298 "timeline.vala" + delta = model_clip_get_duration (clip_view->clip) - clip_view->initial_time; +#line 299 "timeline.vala" + break; +#line 1802 "timeline.c" + } + default: + { +#line 301 "timeline.vala" + g_assert (FALSE); +#line 302 "timeline.vala" + break; +#line 1810 "timeline.c" + } + } +#line 305 "timeline.vala" + model_undo_manager_start_transaction (self->project->undo_manager, "Trim Clip"); +#line 306 "timeline.vala" + model_clip_trim (clip_view->clip, -delta, edge); +#line 307 "timeline.vala" + model_clip_gnonlin_connect (clip_view->clip); +#line 308 "timeline.vala" + model_track_trim (_tmp1_ = track_view_get_track (track_view), clip_view->clip, delta, edge); +#line 1821 "timeline.c" + _g_object_unref0 (_tmp1_); +#line 309 "timeline.vala" + model_undo_manager_end_transaction (self->project->undo_manager, "Trim Clip"); +#line 1825 "timeline.c" + _g_object_unref0 (track_view); +} + + +#line 312 "timeline.vala" +static void time_line_constrain_move (TimeLine* self, ClipView* clip_view, gint64* delta) { +#line 1832 "timeline.c" + gint min_delta; + gint delta_xsize; + TrackView* _tmp0_; + TrackView* track_view; + ModelTrack* track; +#line 312 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 312 "timeline.vala" + g_return_if_fail (IS_CLIP_VIEW (clip_view)); +#line 313 "timeline.vala" + min_delta = CLIP_VIEW_SNAP_DELTA; +#line 314 "timeline.vala" + delta_xsize = model_time_system_time_to_xsize (self->provider, *delta); +#line 315 "timeline.vala" + track_view = _g_object_ref0 ((_tmp0_ = TRACK_VIEW (gtk_widget_get_parent (GTK_WIDGET (clip_view))), IS_TRACK_VIEW (_tmp0_) ? ((TrackView*) _tmp0_) : NULL)); +#line 316 "timeline.vala" + track = track_view_get_track (track_view); +#line 317 "timeline.vala" + if (abs (delta_xsize) < min_delta) { +#line 1852 "timeline.c" + gint64 range; + gint64 adjustment = 0LL; +#line 318 "timeline.vala" + range = model_time_system_xsize_to_time (self->provider, min_delta); +#line 320 "timeline.vala" + if (model_track_clip_is_near (track, clip_view->clip, range, &adjustment)) { +#line 321 "timeline.vala" + *delta = adjustment; +#line 322 "timeline.vala" + clip_view_snap (clip_view, (gint64) model_time_system_time_to_xsize (self->provider, adjustment)); +#line 1863 "timeline.c" + } + } + _g_object_unref0 (track_view); + _g_object_unref0 (track); +} + + +#line 327 "timeline.vala" +static void time_line_on_clip_view_move_request (TimeLine* self, ClipView* clip_view, gint64 delta) { +#line 327 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 327 "timeline.vala" + g_return_if_fail (IS_CLIP_VIEW (clip_view)); +#line 328 "timeline.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_view_move_request"); +#line 329 "timeline.vala" + if (self->project->snap_to_clip) { +#line 330 "timeline.vala" + time_line_constrain_move (self, clip_view, &delta); +#line 1883 "timeline.c" + } +#line 332 "timeline.vala" + if (time_line_move_allowed (self, &delta)) { +#line 333 "timeline.vala" + time_line_move_the_clips (self, delta); +#line 1889 "timeline.c" + } +} + + +#line 337 "timeline.vala" +static gboolean time_line_move_allowed (TimeLine* self, gint64* move_distance) { +#line 1896 "timeline.c" + gboolean result = FALSE; + ClipView* max_clip; +#line 337 "timeline.vala" + g_return_val_if_fail (IS_TIME_LINE (self), FALSE); +#line 338 "timeline.vala" + if (self->priv->drag_widget == NULL) { +#line 1903 "timeline.c" + result = FALSE; +#line 339 "timeline.vala" + return result; +#line 1907 "timeline.c" + } +#line 342 "timeline.vala" + max_clip = NULL; +#line 1911 "timeline.c" + { + GeeIterator* _clip_view_it; + _clip_view_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->selected_clips)); +#line 344 "timeline.vala" + while (TRUE) { +#line 1917 "timeline.c" + ClipView* clip_view; + gint position; +#line 344 "timeline.vala" + if (!gee_iterator_next (_clip_view_it)) { +#line 344 "timeline.vala" + break; +#line 1924 "timeline.c" + } +#line 344 "timeline.vala" + clip_view = (ClipView*) gee_iterator_get (_clip_view_it); +#line 345 "timeline.vala" + if (max_clip == NULL) { +#line 1930 "timeline.c" + ClipView* _tmp0_; +#line 346 "timeline.vala" + max_clip = (_tmp0_ = _g_object_ref0 (clip_view), _g_object_unref0 (max_clip), _tmp0_); +#line 1934 "timeline.c" + } else { +#line 347 "timeline.vala" + if (model_clip_get_end (clip_view->clip) > model_clip_get_end (max_clip->clip)) { +#line 1938 "timeline.c" + ClipView* _tmp1_; +#line 348 "timeline.vala" + max_clip = (_tmp1_ = _g_object_ref0 (clip_view), _g_object_unref0 (max_clip), _tmp1_); +#line 1942 "timeline.c" + } + } +#line 350 "timeline.vala" + position = model_time_system_time_to_xpos (self->provider, model_clip_get_start (clip_view->clip) + (*move_distance)); +#line 351 "timeline.vala" + if (position < TIME_LINE_BORDER) { +#line 1949 "timeline.c" + result = FALSE; + _g_object_unref0 (clip_view); + _g_object_unref0 (_clip_view_it); + _g_object_unref0 (max_clip); +#line 352 "timeline.vala" + return result; +#line 1956 "timeline.c" + } + _g_object_unref0 (clip_view); + } + _g_object_unref0 (_clip_view_it); + } + result = TRUE; + _g_object_unref0 (max_clip); +#line 355 "timeline.vala" + return result; +#line 1966 "timeline.c" +} + + +#line 358 "timeline.vala" +static void time_line_move_the_clips (TimeLine* self, gint64 move_distance) { +#line 358 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 1974 "timeline.c" + { + GeeIterator* _clip_view_it; + _clip_view_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->selected_clips)); +#line 359 "timeline.vala" + while (TRUE) { +#line 1980 "timeline.c" + ClipView* clip_view; +#line 359 "timeline.vala" + if (!gee_iterator_next (_clip_view_it)) { +#line 359 "timeline.vala" + break; +#line 1986 "timeline.c" + } +#line 359 "timeline.vala" + clip_view = (ClipView*) gee_iterator_get (_clip_view_it); +#line 360 "timeline.vala" + time_line_do_clip_move (self, clip_view, move_distance); +#line 1992 "timeline.c" + _g_object_unref0 (clip_view); + } + _g_object_unref0 (_clip_view_it); + } +} + + +#line 364 "timeline.vala" +void time_line_do_clip_move (TimeLine* self, ClipView* clip_view, gint64 delta) { +#line 364 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 364 "timeline.vala" + g_return_if_fail (IS_CLIP_VIEW (clip_view)); +#line 365 "timeline.vala" + model_clip_set_start (clip_view->clip, model_clip_get_start (clip_view->clip) + delta); +#line 2008 "timeline.c" +} + + +#line 368 "timeline.vala" +void time_line_on_ruler_position_changed (TimeLine* self, gint x) { +#line 368 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 369 "timeline.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_ruler_position_changed"); +#line 370 "timeline.vala" + if (!model_project_transport_is_recording (self->project)) { +#line 371 "timeline.vala" + time_line_update_pos (self, x); +#line 2022 "timeline.c" + } +} + + +#line 375 "timeline.vala" +gboolean time_line_is_clip_selected (TimeLine* self) { +#line 2029 "timeline.c" + gboolean result = FALSE; +#line 375 "timeline.vala" + g_return_val_if_fail (IS_TIME_LINE (self), FALSE); +#line 2033 "timeline.c" + result = gee_collection_get_size (GEE_COLLECTION (self->selected_clips)) > 0; +#line 376 "timeline.vala" + return result; +#line 2037 "timeline.c" +} + + +#line 379 "timeline.vala" +gboolean time_line_gap_selected (TimeLine* self) { +#line 2043 "timeline.c" + gboolean result = FALSE; +#line 379 "timeline.vala" + g_return_val_if_fail (IS_TIME_LINE (self), FALSE); +#line 2047 "timeline.c" + result = FALSE; +#line 380 "timeline.vala" + return result; +#line 2051 "timeline.c" +} + + +#line 384 "timeline.vala" +void time_line_delete_selection (TimeLine* self) { +#line 2057 "timeline.c" + GtkWidget* _tmp0_; +#line 384 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 385 "timeline.vala" + model_undo_manager_start_transaction (self->project->undo_manager, "Delete Clips From Timeline"); +#line 386 "timeline.vala" + self->priv->drag_widget = (_tmp0_ = NULL, _g_object_unref0 (self->priv->drag_widget), _tmp0_); +#line 387 "timeline.vala" + if (time_line_is_clip_selected (self)) { +#line 388 "timeline.vala" + while (TRUE) { +#line 2069 "timeline.c" + ClipView* _tmp1_; + ClipView* _tmp2_; +#line 388 "timeline.vala" + if (!(gee_collection_get_size (GEE_COLLECTION (self->selected_clips)) > 0)) { +#line 388 "timeline.vala" + break; +#line 2076 "timeline.c" + } +#line 389 "timeline.vala" + clip_view_delete_clip (_tmp1_ = (ClipView*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->selected_clips), 0)); +#line 2080 "timeline.c" + _g_object_unref0 (_tmp1_); +#line 390 "timeline.vala" + _tmp2_ = (ClipView*) gee_abstract_list_remove_at (GEE_ABSTRACT_LIST (self->selected_clips), 0); +#line 2084 "timeline.c" + _g_object_unref0 (_tmp2_); + } +#line 392 "timeline.vala" + g_signal_emit_by_name (self, "track-changed"); +#line 2089 "timeline.c" + } else { + } +#line 409 "timeline.vala" + model_undo_manager_end_transaction (self->project->undo_manager, "Delete Clips From Timeline"); +#line 2094 "timeline.c" +} + + +#line 412 "timeline.vala" +void time_line_do_cut (TimeLine* self) { +#line 412 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 413 "timeline.vala" + clipboard_select (self->clipboard, self->selected_clips); +#line 414 "timeline.vala" + time_line_delete_selection (self); +#line 2106 "timeline.c" +} + + +#line 417 "timeline.vala" +void time_line_do_copy (TimeLine* self) { +#line 417 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 418 "timeline.vala" + clipboard_select (self->clipboard, self->selected_clips); +#line 419 "timeline.vala" + g_signal_emit_by_name (self, "selection-changed", TRUE); +#line 2118 "timeline.c" +} + + +#line 422 "timeline.vala" +void time_line_paste (TimeLine* self) { +#line 422 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 423 "timeline.vala" + time_line_do_paste (self, model_project_transport_get_position (self->project)); +#line 2128 "timeline.c" +} + + +#line 426 "timeline.vala" +void time_line_do_paste (TimeLine* self, gint64 pos) { +#line 2134 "timeline.c" + TrackView* view; + ModelTrack* _tmp9_; +#line 426 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 427 "timeline.vala" + view = NULL; +#line 2141 "timeline.c" + { + GeeIterator* _track_view_it; + _track_view_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 428 "timeline.vala" + while (TRUE) { +#line 2147 "timeline.c" + TrackView* track_view; + ModelTrack* _tmp0_; + gboolean _tmp1_; +#line 428 "timeline.vala" + if (!gee_iterator_next (_track_view_it)) { +#line 428 "timeline.vala" + break; +#line 2155 "timeline.c" + } +#line 428 "timeline.vala" + track_view = (TrackView*) gee_iterator_get (_track_view_it); +#line 429 "timeline.vala" + if ((_tmp1_ = model_track_get_is_selected (_tmp0_ = track_view_get_track (track_view)), _g_object_unref0 (_tmp0_), _tmp1_)) { +#line 2161 "timeline.c" + TrackView* _tmp2_; +#line 430 "timeline.vala" + view = (_tmp2_ = _g_object_ref0 (track_view), _g_object_unref0 (view), _tmp2_); +#line 2165 "timeline.c" + } + _g_object_unref0 (track_view); + } + _g_object_unref0 (_track_view_it); + } +#line 435 "timeline.vala" + if (view == NULL) { +#line 2173 "timeline.c" + TrackView* _tmp3_; + TrackClipPair* _tmp4_; + gboolean _tmp5_; + TrackView* _tmp8_; + _tmp3_ = NULL; +#line 436 "timeline.vala" + if ((_tmp5_ = (_tmp4_ = (TrackClipPair*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clipboard->clips), 0))->clip->type == MODEL_MEDIA_TYPE_VIDEO, _track_clip_pair_unref0 (_tmp4_), _tmp5_)) { +#line 2181 "timeline.c" + TrackView* _tmp6_; +#line 437 "timeline.vala" + _tmp3_ = (_tmp6_ = time_line_find_video_track_view (self), _g_object_unref0 (_tmp3_), _tmp6_); +#line 2185 "timeline.c" + } else { + TrackView* _tmp7_; +#line 437 "timeline.vala" + _tmp3_ = (_tmp7_ = time_line_find_audio_track_view (self), _g_object_unref0 (_tmp3_), _tmp7_); +#line 2190 "timeline.c" + } +#line 436 "timeline.vala" + view = (_tmp8_ = _g_object_ref0 (_tmp3_), _g_object_unref0 (view), _tmp8_); +#line 2194 "timeline.c" + _g_object_unref0 (_tmp3_); + } +#line 439 "timeline.vala" + model_undo_manager_start_transaction (self->project->undo_manager, "Paste"); +#line 440 "timeline.vala" + clipboard_paste (self->clipboard, _tmp9_ = track_view_get_track (view), pos); +#line 2201 "timeline.c" + _g_object_unref0 (_tmp9_); +#line 441 "timeline.vala" + model_undo_manager_end_transaction (self->project->undo_manager, "Paste"); +#line 442 "timeline.vala" + gtk_widget_queue_draw (GTK_WIDGET (self)); +#line 2207 "timeline.c" + _g_object_unref0 (view); +} + + +#line 445 "timeline.vala" +void time_line_select_all (TimeLine* self) { +#line 445 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 2216 "timeline.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 446 "timeline.vala" + while (TRUE) { +#line 2222 "timeline.c" + TrackView* track; +#line 446 "timeline.vala" + if (!gee_iterator_next (_track_it)) { +#line 446 "timeline.vala" + break; +#line 2228 "timeline.c" + } +#line 446 "timeline.vala" + track = (TrackView*) gee_iterator_get (_track_it); +#line 447 "timeline.vala" + track_view_select_all (track); +#line 2234 "timeline.c" + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } +} + + +#line 451 "timeline.vala" +static gboolean time_line_real_expose_event (GtkWidget* base, GdkEventExpose* event) { +#line 2244 "timeline.c" + TimeLine * self; + gboolean result = FALSE; + gint xpos; + self = TIME_LINE (base); +#line 452 "timeline.vala" + GTK_WIDGET_CLASS (time_line_parent_class)->expose_event (GTK_WIDGET (GTK_EVENT_BOX (self)), event); +#line 454 "timeline.vala" + xpos = model_time_system_time_to_xpos (self->provider, model_project_transport_get_position (self->project)); +#line 455 "timeline.vala" + gdk_draw_line (GDK_DRAWABLE (GTK_WIDGET (self)->window), gtk_widget_get_style (GTK_WIDGET (self))->fg_gc[(gint) GTK_STATE_NORMAL], xpos, 0, xpos, GTK_WIDGET (self)->allocation.height); +#line 2255 "timeline.c" + result = TRUE; +#line 459 "timeline.vala" + return result; +#line 2259 "timeline.c" +} + + +#line 462 "timeline.vala" +static void time_line_real_drag_data_received (GtkWidget* base, GdkDragContext* context, gint x, gint y, GtkSelectionData* selection_data, guint drag_info, guint time) { +#line 2265 "timeline.c" + TimeLine * self; + GError * _inner_error_; + char** _tmp1_; + gint _a_size_; + gint a_length1; + char** _tmp0_; + char** a; + ModelTrack* track; + GtkWidget* _tmp2_; + TrackView* track_view; + gboolean timeline_add; + self = TIME_LINE (base); +#line 462 "timeline.vala" + g_return_if_fail (GDK_IS_DRAG_CONTEXT (context)); +#line 462 "timeline.vala" + g_return_if_fail (selection_data != NULL); +#line 2282 "timeline.c" + _inner_error_ = NULL; +#line 465 "timeline.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_drag_data_received"); +#line 2286 "timeline.c" + a = (_tmp1_ = _tmp0_ = gtk_selection_data_get_uris (selection_data), a_length1 = _vala_array_length (_tmp0_), _a_size_ = a_length1, _tmp1_); +#line 467 "timeline.vala" + gtk_drag_finish (context, TRUE, FALSE, (guint32) time); +#line 469 "timeline.vala" + track = NULL; +#line 470 "timeline.vala" + track_view = (_tmp2_ = time_line_find_child (self, (double) x, (double) y), IS_TRACK_VIEW (_tmp2_) ? ((TrackView*) _tmp2_) : NULL); +#line 472 "timeline.vala" + if (track_view == NULL) { +#line 2296 "timeline.c" + a = (_vala_array_free (a, a_length1, (GDestroyNotify) g_free), NULL); + _g_object_unref0 (track); + _g_object_unref0 (track_view); +#line 473 "timeline.vala" + return; +#line 2302 "timeline.c" + } +#line 476 "timeline.vala" + timeline_add = TRUE; +#line 478 "timeline.vala" + if (a_length1 > 1) { +#line 479 "timeline.vala" + if (gtk_drag_get_source_widget (context) != NULL) { +#line 480 "timeline.vala" + dialog_utils_warning ("Cannot add files", "Files must be dropped onto the timeline individually."); +#line 2312 "timeline.c" + a = (_vala_array_free (a, a_length1, (GDestroyNotify) g_free), NULL); + _g_object_unref0 (track); + _g_object_unref0 (track_view); +#line 482 "timeline.vala" + return; +#line 2318 "timeline.c" + } +#line 485 "timeline.vala" + if (dialog_utils_add_cancel ("Files must be dropped onto the timeline individually.\n" "Do you wish to add these files to the library?") != GTK_RESPONSE_YES) { +#line 2322 "timeline.c" + a = (_vala_array_free (a, a_length1, (GDestroyNotify) g_free), NULL); + _g_object_unref0 (track); + _g_object_unref0 (track_view); +#line 488 "timeline.vala" + return; +#line 2328 "timeline.c" + } +#line 490 "timeline.vala" + timeline_add = FALSE; +#line 2332 "timeline.c" + } else { + ModelTrack* _tmp3_; +#line 492 "timeline.vala" + track = (_tmp3_ = track_view_get_track (track_view), _g_object_unref0 (track), _tmp3_); +#line 2337 "timeline.c" + } +#line 495 "timeline.vala" + model_project_create_clip_importer (self->project, track, timeline_add, model_time_system_xpos_to_time (self->provider, x), context->action == GDK_ACTION_COPY, GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (self))), a_length1); +#line 2341 "timeline.c" + { + { + char** s_collection; + int s_collection_length1; + int s_it; +#line 498 "timeline.vala" + s_collection = a; +#line 2349 "timeline.c" + s_collection_length1 = a_length1; + for (s_it = 0; s_it < a_length1; s_it = s_it + 1) { + char* s; + s = g_strdup (s_collection[s_it]); + { + char* filename; + filename = NULL; + { + char* _tmp4_; + char* _tmp5_; +#line 501 "timeline.vala" + _tmp4_ = g_filename_from_uri (s, NULL, &_inner_error_); +#line 2362 "timeline.c" + if (_inner_error_ != NULL) { + if (_inner_error_->domain == G_CONVERT_ERROR) { + goto __catch16_g_convert_error; + } + _g_free0 (s); + _g_free0 (filename); + a = (_vala_array_free (a, a_length1, (GDestroyNotify) g_free), NULL); + _g_object_unref0 (track); + _g_object_unref0 (track_view); + g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } +#line 501 "timeline.vala" + filename = (_tmp5_ = _tmp4_, _g_free0 (filename), _tmp5_); +#line 2378 "timeline.c" + } + goto __finally16; + __catch16_g_convert_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { + _g_error_free0 (e); + _g_free0 (s); + _g_free0 (filename); +#line 502 "timeline.vala" + continue; +#line 2392 "timeline.c" + } + } + __finally16: + if (_inner_error_ != NULL) { + _g_free0 (s); + _g_free0 (filename); + goto __catch15_g_error; + } +#line 503 "timeline.vala" + model_library_importer_add_file (self->project->importer, filename, &_inner_error_); +#line 2403 "timeline.c" + if (_inner_error_ != NULL) { + _g_free0 (s); + _g_free0 (filename); + goto __catch15_g_error; + } + _g_free0 (s); + _g_free0 (filename); + } + } + } +#line 505 "timeline.vala" + model_library_importer_start (self->project->importer, &_inner_error_); +#line 2416 "timeline.c" + if (_inner_error_ != NULL) { + goto __catch15_g_error; + } + } + goto __finally15; + __catch15_g_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { +#line 507 "timeline.vala" + g_signal_emit_by_name (self->project, "error-occurred", "Error importing", e->message); +#line 2430 "timeline.c" + _g_error_free0 (e); + } + } + __finally15: + if (_inner_error_ != NULL) { + a = (_vala_array_free (a, a_length1, (GDestroyNotify) g_free), NULL); + _g_object_unref0 (track); + _g_object_unref0 (track_view); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } + a = (_vala_array_free (a, a_length1, (GDestroyNotify) g_free), NULL); + _g_object_unref0 (track); + _g_object_unref0 (track_view); +} + + +#line 511 "timeline.vala" +void time_line_update_pos (TimeLine* self, gint event_x) { +#line 2451 "timeline.c" + gint64 time; +#line 511 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 512 "timeline.vala" + time = model_time_system_xpos_to_time (self->provider, event_x); +#line 513 "timeline.vala" + if (self->project->snap_to_clip) { +#line 514 "timeline.vala" + model_project_snap_coord (self->project, &time, model_time_system_get_pixel_snap_time (self->provider)); +#line 2461 "timeline.c" + } +#line 516 "timeline.vala" + view_media_engine_go (self->project->media_engine, time); +#line 2465 "timeline.c" +} + + +#line 519 "timeline.vala" +GtkWidget* time_line_find_child (TimeLine* self, double x, double y) { +#line 2471 "timeline.c" + GtkWidget* result = NULL; +#line 519 "timeline.vala" + g_return_val_if_fail (IS_TIME_LINE (self), NULL); +#line 2475 "timeline.c" + { + GList* w_collection; + GList* w_it; +#line 520 "timeline.vala" + w_collection = gtk_container_get_children (GTK_CONTAINER (self->priv->vbox)); +#line 2481 "timeline.c" + for (w_it = w_collection; w_it != NULL; w_it = w_it->next) { + GtkWidget* w; +#line 520 "timeline.vala" + w = _g_object_ref0 ((GtkWidget*) w_it->data); +#line 2486 "timeline.c" + { + gboolean _tmp0_ = FALSE; +#line 521 "timeline.vala" + if (w->allocation.y <= y) { +#line 521 "timeline.vala" + _tmp0_ = y < (w->allocation.y + w->allocation.height); +#line 2493 "timeline.c" + } else { +#line 521 "timeline.vala" + _tmp0_ = FALSE; +#line 2497 "timeline.c" + } +#line 521 "timeline.vala" + if (_tmp0_) { +#line 2501 "timeline.c" + result = w; + _g_list_free0 (w_collection); +#line 522 "timeline.vala" + return result; +#line 2506 "timeline.c" + } + _g_object_unref0 (w); + } + } +#line 520 "timeline.vala" + _g_list_free0 (w_collection); +#line 2513 "timeline.c" + } + result = NULL; +#line 524 "timeline.vala" + return result; +#line 2518 "timeline.c" +} + + +#line 527 "timeline.vala" +static void time_line_deselect_all (TimeLine* self) { +#line 527 "timeline.vala" + g_return_if_fail (IS_TIME_LINE (self)); +#line 2526 "timeline.c" + { + GeeIterator* _clip_view_it; + _clip_view_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->selected_clips)); +#line 528 "timeline.vala" + while (TRUE) { +#line 2532 "timeline.c" + ClipView* clip_view; +#line 528 "timeline.vala" + if (!gee_iterator_next (_clip_view_it)) { +#line 528 "timeline.vala" + break; +#line 2538 "timeline.c" + } +#line 528 "timeline.vala" + clip_view = (ClipView*) gee_iterator_get (_clip_view_it); +#line 529 "timeline.vala" + clip_view->is_selected = FALSE; +#line 2544 "timeline.c" + _g_object_unref0 (clip_view); + } + _g_object_unref0 (_clip_view_it); + } +#line 531 "timeline.vala" + gee_abstract_collection_clear (GEE_ABSTRACT_COLLECTION (self->selected_clips)); +#line 532 "timeline.vala" + g_signal_emit_by_name (self, "selection-changed", FALSE); +#line 2553 "timeline.c" +} + + +#line 535 "timeline.vala" +static gboolean time_line_real_button_press_event (GtkWidget* base, GdkEventButton* event) { +#line 2559 "timeline.c" + TimeLine * self; + gboolean result = FALSE; + GtkWidget* _tmp0_; + GtkWidget* child; + self = TIME_LINE (base); +#line 540 "timeline.vala" + self->priv->drag_widget = (_tmp0_ = NULL, _g_object_unref0 (self->priv->drag_widget), _tmp0_); +#line 541 "timeline.vala" + child = time_line_find_child (self, (*event).x, (*event).y); +#line 543 "timeline.vala" + if (VIEW_IS_RULER (child)) { +#line 2571 "timeline.c" + GtkWidget* _tmp1_; + ViewRuler* ruler; + gboolean _tmp2_; + GtkWidget* _tmp3_; +#line 544 "timeline.vala" + ruler = _g_object_ref0 ((_tmp1_ = child, VIEW_IS_RULER (_tmp1_) ? ((ViewRuler*) _tmp1_) : NULL)); +#line 545 "timeline.vala" + g_signal_emit_by_name (GTK_WIDGET (ruler), "button-press-event", event, &_tmp2_); +#line 545 "timeline.vala" + _tmp2_; +#line 546 "timeline.vala" + self->priv->drag_widget = (_tmp3_ = _g_object_ref0 (child), _g_object_unref0 (self->priv->drag_widget), _tmp3_); +#line 2584 "timeline.c" + _g_object_unref0 (ruler); + } else { +#line 547 "timeline.vala" + if (IS_TRACK_VIEW (child)) { +#line 2589 "timeline.c" + GtkWidget* _tmp4_; + TrackView* track_view; + GtkWidget* _tmp5_; +#line 548 "timeline.vala" + track_view = _g_object_ref0 ((_tmp4_ = child, IS_TRACK_VIEW (_tmp4_) ? ((TrackView*) _tmp4_) : NULL)); +#line 550 "timeline.vala" + self->priv->drag_widget = (_tmp5_ = track_view_find_child (track_view, (*event).x, (*event).y), _g_object_unref0 (self->priv->drag_widget), _tmp5_); +#line 551 "timeline.vala" + if (self->priv->drag_widget != NULL) { +#line 2599 "timeline.c" + gboolean _tmp6_; +#line 552 "timeline.vala" + g_signal_emit_by_name (self->priv->drag_widget, "button-press-event", event, &_tmp6_); +#line 552 "timeline.vala" + _tmp6_; +#line 2605 "timeline.c" + } else { + ModelTrack* _tmp7_; +#line 554 "timeline.vala" + time_line_deselect_all (self); +#line 556 "timeline.vala" + model_track_set_selected (_tmp7_ = track_view_get_track (track_view), TRUE); +#line 2612 "timeline.c" + _g_object_unref0 (_tmp7_); + } + _g_object_unref0 (track_view); + } else { +#line 559 "timeline.vala" + time_line_deselect_all (self); +#line 2619 "timeline.c" + } + } +#line 561 "timeline.vala" + gtk_widget_queue_draw (GTK_WIDGET (self)); +#line 2624 "timeline.c" + result = TRUE; + _g_object_unref0 (child); +#line 563 "timeline.vala" + return result; +#line 2629 "timeline.c" +} + + +#line 566 "timeline.vala" +static gboolean time_line_real_button_release_event (GtkWidget* base, GdkEventButton* event) { +#line 2635 "timeline.c" + TimeLine * self; + gboolean result = FALSE; + self = TIME_LINE (base); +#line 567 "timeline.vala" + if (self->priv->drag_widget != NULL) { +#line 2641 "timeline.c" + gboolean _tmp0_; + GtkWidget* _tmp1_; +#line 568 "timeline.vala" + g_signal_emit_by_name (self->priv->drag_widget, "button-release-event", event, &_tmp0_); +#line 568 "timeline.vala" + _tmp0_; +#line 569 "timeline.vala" + self->priv->drag_widget = (_tmp1_ = NULL, _g_object_unref0 (self->priv->drag_widget), _tmp1_); +#line 2650 "timeline.c" + } + result = TRUE; +#line 571 "timeline.vala" + return result; +#line 2655 "timeline.c" +} + + +#line 574 "timeline.vala" +static gboolean time_line_real_motion_notify_event (GtkWidget* base, GdkEventMotion* event) { +#line 2661 "timeline.c" + TimeLine * self; + gboolean result = FALSE; + self = TIME_LINE (base); +#line 575 "timeline.vala" + if (self->priv->drag_widget != NULL) { +#line 2667 "timeline.c" + gboolean _tmp0_; +#line 576 "timeline.vala" + g_signal_emit_by_name (self->priv->drag_widget, "motion-notify-event", event, &_tmp0_); +#line 576 "timeline.vala" + _tmp0_; +#line 2673 "timeline.c" + } else { + GtkWidget* widget; +#line 578 "timeline.vala" + widget = time_line_find_child (self, (*event).x, (*event).y); +#line 579 "timeline.vala" + if (IS_TRACK_VIEW (widget)) { +#line 2680 "timeline.c" + GtkWidget* _tmp1_; + TrackView* track_view; +#line 580 "timeline.vala" + track_view = _g_object_ref0 ((_tmp1_ = widget, IS_TRACK_VIEW (_tmp1_) ? ((TrackView*) _tmp1_) : NULL)); +#line 581 "timeline.vala" + if (track_view != NULL) { +#line 2687 "timeline.c" + GtkWidget* _tmp2_; + ClipView* clip_view; +#line 582 "timeline.vala" + clip_view = (_tmp2_ = track_view_find_child (track_view, (*event).x, (*event).y), IS_CLIP_VIEW (_tmp2_) ? ((ClipView*) _tmp2_) : NULL); +#line 583 "timeline.vala" + if (clip_view != NULL) { +#line 2694 "timeline.c" + gboolean _tmp3_; +#line 584 "timeline.vala" + g_signal_emit_by_name (GTK_WIDGET (clip_view), "motion-notify-event", event, &_tmp3_); +#line 584 "timeline.vala" + _tmp3_; +#line 2700 "timeline.c" + } else { +#line 586 "timeline.vala" + gdk_window_set_cursor (GTK_WIDGET (self)->window, NULL); +#line 2704 "timeline.c" + } + _g_object_unref0 (clip_view); + } + _g_object_unref0 (track_view); + } else { +#line 589 "timeline.vala" + if (VIEW_IS_RULER (widget)) { +#line 2712 "timeline.c" + gboolean _tmp4_; +#line 590 "timeline.vala" + g_signal_emit_by_name (widget, "motion-notify-event", event, &_tmp4_); +#line 590 "timeline.vala" + _tmp4_; +#line 2718 "timeline.c" + } else { +#line 592 "timeline.vala" + gdk_window_set_cursor (GTK_WIDGET (self)->window, NULL); +#line 2722 "timeline.c" + } + } + _g_object_unref0 (widget); + } + result = TRUE; +#line 595 "timeline.vala" + return result; +#line 2730 "timeline.c" +} + + +#line 598 "timeline.vala" +static TrackView* time_line_find_video_track_view (TimeLine* self) { +#line 2736 "timeline.c" + TrackView* result = NULL; +#line 598 "timeline.vala" + g_return_val_if_fail (IS_TIME_LINE (self), NULL); +#line 2740 "timeline.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 599 "timeline.vala" + while (TRUE) { +#line 2746 "timeline.c" + TrackView* track; + ModelTrack* _tmp0_; + gboolean _tmp1_; +#line 599 "timeline.vala" + if (!gee_iterator_next (_track_it)) { +#line 599 "timeline.vala" + break; +#line 2754 "timeline.c" + } +#line 599 "timeline.vala" + track = (TrackView*) gee_iterator_get (_track_it); +#line 600 "timeline.vala" + if ((_tmp1_ = model_track_media_type (_tmp0_ = track_view_get_track (track)) == MODEL_MEDIA_TYPE_VIDEO, _g_object_unref0 (_tmp0_), _tmp1_)) { +#line 2760 "timeline.c" + result = track; + _g_object_unref0 (_track_it); +#line 601 "timeline.vala" + return result; +#line 2765 "timeline.c" + } + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } + result = NULL; +#line 605 "timeline.vala" + return result; +#line 2774 "timeline.c" +} + + +#line 608 "timeline.vala" +static TrackView* time_line_find_audio_track_view (TimeLine* self) { +#line 2780 "timeline.c" + TrackView* result = NULL; +#line 608 "timeline.vala" + g_return_val_if_fail (IS_TIME_LINE (self), NULL); +#line 2784 "timeline.c" + { + GeeIterator* _track_it; + _track_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->tracks)); +#line 609 "timeline.vala" + while (TRUE) { +#line 2790 "timeline.c" + TrackView* track; + ModelTrack* _tmp0_; + gboolean _tmp1_; +#line 609 "timeline.vala" + if (!gee_iterator_next (_track_it)) { +#line 609 "timeline.vala" + break; +#line 2798 "timeline.c" + } +#line 609 "timeline.vala" + track = (TrackView*) gee_iterator_get (_track_it); +#line 610 "timeline.vala" + if ((_tmp1_ = model_track_media_type (_tmp0_ = track_view_get_track (track)) == MODEL_MEDIA_TYPE_AUDIO, _g_object_unref0 (_tmp0_), _tmp1_)) { +#line 2804 "timeline.c" + result = track; + _g_object_unref0 (_track_it); +#line 611 "timeline.vala" + return result; +#line 2809 "timeline.c" + } + _g_object_unref0 (track); + } + _g_object_unref0 (_track_it); + } + result = NULL; +#line 615 "timeline.vala" + return result; +#line 2818 "timeline.c" +} + + +static void time_line_class_init (TimeLineClass * klass) { + time_line_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (TimeLinePrivate)); + GTK_WIDGET_CLASS (klass)->expose_event = time_line_real_expose_event; + GTK_WIDGET_CLASS (klass)->drag_data_received = time_line_real_drag_data_received; + GTK_WIDGET_CLASS (klass)->button_press_event = time_line_real_button_press_event; + GTK_WIDGET_CLASS (klass)->button_release_event = time_line_real_button_release_event; + GTK_WIDGET_CLASS (klass)->motion_notify_event = time_line_real_motion_notify_event; + G_OBJECT_CLASS (klass)->finalize = time_line_finalize; + g_signal_new ("selection_changed", TYPE_TIME_LINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1, G_TYPE_BOOLEAN); + g_signal_new ("track_changed", TYPE_TIME_LINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); + g_signal_new ("trackview_added", TYPE_TIME_LINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, TYPE_TRACK_VIEW); + g_signal_new ("trackview_removed", TYPE_TIME_LINE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, TYPE_TRACK_VIEW); +} + + +static void time_line_instance_init (TimeLine * self) { + self->priv = TIME_LINE_GET_PRIVATE (self); + self->priv->drag_widget = NULL; + self->tracks = gee_array_list_new (TYPE_TRACK_VIEW, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL); + self->selected_clips = gee_array_list_new (TYPE_CLIP_VIEW, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL); + self->clipboard = clipboard_new (); + self->priv->pixel_min = 0.1f; + self->priv->pixel_max = 4505.0f; +} + + +static void time_line_finalize (GObject* obj) { + TimeLine * self; + self = TIME_LINE (obj); + _g_object_unref0 (self->project); + _g_object_unref0 (self->ruler); + _g_object_unref0 (self->priv->drag_widget); + _g_object_unref0 (self->tracks); + _g_object_unref0 (self->priv->vbox); + _g_object_unref0 (self->selected_clips); + _clipboard_unref0 (self->clipboard); + _g_object_unref0 (self->priv->high_water); + G_OBJECT_CLASS (time_line_parent_class)->finalize (obj); +} + + +GType time_line_get_type (void) { + static volatile gsize time_line_type_id__volatile = 0; + if (g_once_init_enter (&time_line_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (TimeLineClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) time_line_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (TimeLine), 0, (GInstanceInitFunc) time_line_instance_init, NULL }; + GType time_line_type_id; + time_line_type_id = g_type_register_static (GTK_TYPE_EVENT_BOX, "TimeLine", &g_define_type_info, 0); + g_once_init_leave (&time_line_type_id__volatile, time_line_type_id); + } + return time_line_type_id__volatile; +} + + +static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) { + if ((array != NULL) && (destroy_func != NULL)) { + int i; + for (i = 0; i < array_length; i = i + 1) { + if (((gpointer*) array)[i] != NULL) { + destroy_func (((gpointer*) array)[i]); + } + } + } +} + + +static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) { + _vala_array_destroy (array, array_length, destroy_func); + g_free (array); +} + + +static gint _vala_array_length (gpointer array) { + int length; + length = 0; + if (array) { + while (((gpointer*) array)[length]) { + length++; + } + } + return length; +} + + + + diff --git a/src/marina/marina/timeline.o b/src/marina/marina/timeline.o new file mode 100644 index 0000000..c3560b1 Binary files /dev/null and b/src/marina/marina/timeline.o differ diff --git a/src/marina/marina/track.c b/src/marina/marina/track.c new file mode 100644 index 0000000..5ac6967 --- /dev/null +++ b/src/marina/marina/track.c @@ -0,0 +1,2950 @@ +/* track.c generated by valac, the Vala compiler + * generated from track.vala, do not modify */ + +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#define MODEL_TYPE_TRACK (model_track_get_type ()) +#define MODEL_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TRACK, ModelTrack)) +#define MODEL_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TRACK, ModelTrackClass)) +#define MODEL_IS_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TRACK)) +#define MODEL_IS_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TRACK)) +#define MODEL_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TRACK, ModelTrackClass)) + +typedef struct _ModelTrack ModelTrack; +typedef struct _ModelTrackClass ModelTrackClass; +typedef struct _ModelTrackPrivate ModelTrackPrivate; + +#define MODEL_TYPE_MEDIA_TYPE (model_media_type_get_type ()) + +#define MODEL_TYPE_CLIP (model_clip_get_type ()) +#define MODEL_CLIP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP, ModelClip)) +#define MODEL_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP, ModelClipClass)) +#define MODEL_IS_CLIP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP)) +#define MODEL_IS_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP)) +#define MODEL_CLIP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP, ModelClipClass)) + +typedef struct _ModelClip ModelClip; +typedef struct _ModelClipClass ModelClipClass; + +#define MODEL_TYPE_PROJECT (model_project_get_type ()) +#define MODEL_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT, ModelProject)) +#define MODEL_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT, ModelProjectClass)) +#define MODEL_IS_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT)) +#define MODEL_IS_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT)) +#define MODEL_PROJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT, ModelProjectClass)) + +typedef struct _ModelProject ModelProject; +typedef struct _ModelProjectClass ModelProjectClass; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +#define _g_free0(var) (var = (g_free (var), NULL)) +typedef struct _ModelClipPrivate ModelClipPrivate; + +#define MODEL_TYPE_CLIP_FILE (model_clip_file_get_type ()) +#define MODEL_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFile)) +#define MODEL_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) +#define MODEL_IS_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE)) +#define MODEL_IS_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE)) +#define MODEL_CLIP_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) + +typedef struct _ModelClipFile ModelClipFile; +typedef struct _ModelClipFileClass ModelClipFileClass; + +#define MODEL_TYPE_GAP (model_gap_get_type ()) +#define MODEL_GAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_GAP, ModelGap)) +#define MODEL_GAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_GAP, ModelGapClass)) +#define MODEL_IS_GAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_GAP)) +#define MODEL_IS_GAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_GAP)) +#define MODEL_GAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_GAP, ModelGapClass)) + +typedef struct _ModelGap ModelGap; +typedef struct _ModelGapClass ModelGapClass; +#define _model_gap_unref0(var) ((var == NULL) ? NULL : (var = (model_gap_unref (var), NULL))) +typedef struct _ModelGapPrivate ModelGapPrivate; + +#define MODEL_TYPE_TEMPO_INFORMATION (model_tempo_information_get_type ()) +#define MODEL_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformation)) +#define MODEL_IS_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TEMPO_INFORMATION)) +#define MODEL_TEMPO_INFORMATION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformationIface)) + +typedef struct _ModelTempoInformation ModelTempoInformation; +typedef struct _ModelTempoInformationIface ModelTempoInformationIface; + +#define TYPE_FRACTION (fraction_get_type ()) +typedef struct _Fraction Fraction; +typedef struct _ModelProjectPrivate ModelProjectPrivate; + +#define TYPE_TIME_CODE (time_code_get_type ()) +typedef struct _TimeCode TimeCode; + +#define VIEW_TYPE_MEDIA_ENGINE (view_media_engine_get_type ()) +#define VIEW_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngine)) +#define VIEW_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass)) +#define VIEW_IS_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_ENGINE)) +#define VIEW_IS_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_ENGINE)) +#define VIEW_MEDIA_ENGINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass)) + +typedef struct _ViewMediaEngine ViewMediaEngine; +typedef struct _ViewMediaEngineClass ViewMediaEngineClass; + +#define MODEL_TYPE_PROJECT_LOADER (model_project_loader_get_type ()) +#define MODEL_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoader)) +#define MODEL_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass)) +#define MODEL_IS_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT_LOADER)) +#define MODEL_IS_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT_LOADER)) +#define MODEL_PROJECT_LOADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass)) + +typedef struct _ModelProjectLoader ModelProjectLoader; +typedef struct _ModelProjectLoaderClass ModelProjectLoaderClass; + +#define MODEL_TYPE_UNDO_MANAGER (model_undo_manager_get_type ()) +#define MODEL_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManager)) +#define MODEL_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass)) +#define MODEL_IS_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_UNDO_MANAGER)) +#define MODEL_IS_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_UNDO_MANAGER)) +#define MODEL_UNDO_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass)) + +typedef struct _ModelUndoManager ModelUndoManager; +typedef struct _ModelUndoManagerClass ModelUndoManagerClass; + +#define MODEL_TYPE_LIBRARY_IMPORTER (model_library_importer_get_type ()) +#define MODEL_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporter)) +#define MODEL_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass)) +#define MODEL_IS_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_LIBRARY_IMPORTER)) +#define MODEL_IS_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_LIBRARY_IMPORTER)) +#define MODEL_LIBRARY_IMPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass)) + +typedef struct _ModelLibraryImporter ModelLibraryImporter; +typedef struct _ModelLibraryImporterClass ModelLibraryImporterClass; + +#define MODEL_TYPE_COMMAND (model_command_get_type ()) +#define MODEL_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_COMMAND, ModelCommand)) +#define MODEL_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_COMMAND, ModelCommandClass)) +#define MODEL_IS_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_COMMAND)) +#define MODEL_IS_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_COMMAND)) +#define MODEL_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_COMMAND, ModelCommandClass)) + +typedef struct _ModelCommand ModelCommand; +typedef struct _ModelCommandClass ModelCommandClass; + +#define MODEL_TYPE_CLIP_ADD_COMMAND (model_clip_add_command_get_type ()) +#define MODEL_CLIP_ADD_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_ADD_COMMAND, ModelClipAddCommand)) +#define MODEL_CLIP_ADD_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_ADD_COMMAND, ModelClipAddCommandClass)) +#define MODEL_IS_CLIP_ADD_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_ADD_COMMAND)) +#define MODEL_IS_CLIP_ADD_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_ADD_COMMAND)) +#define MODEL_CLIP_ADD_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_ADD_COMMAND, ModelClipAddCommandClass)) + +typedef struct _ModelClipAddCommand ModelClipAddCommand; +typedef struct _ModelClipAddCommandClass ModelClipAddCommandClass; +#define _model_command_unref0(var) ((var == NULL) ? NULL : (var = (model_command_unref (var), NULL))) + +#define LOGGING_TYPE_FACILITY (logging_facility_get_type ()) + +#define LOGGING_TYPE_LEVEL (logging_level_get_type ()) + +#define MODEL_CLIP_COMMAND_TYPE_ACTION (model_clip_command_action_get_type ()) + +#define MODEL_TYPE_CLIP_COMMAND (model_clip_command_get_type ()) +#define MODEL_CLIP_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_COMMAND, ModelClipCommand)) +#define MODEL_CLIP_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_COMMAND, ModelClipCommandClass)) +#define MODEL_IS_CLIP_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_COMMAND)) +#define MODEL_IS_CLIP_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_COMMAND)) +#define MODEL_CLIP_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_COMMAND, ModelClipCommandClass)) + +typedef struct _ModelClipCommand ModelClipCommand; +typedef struct _ModelClipCommandClass ModelClipCommandClass; + +#define MODEL_TYPE_CLIP_REVERT_COMMAND (model_clip_revert_command_get_type ()) +#define MODEL_CLIP_REVERT_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_REVERT_COMMAND, ModelClipRevertCommand)) +#define MODEL_CLIP_REVERT_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_REVERT_COMMAND, ModelClipRevertCommandClass)) +#define MODEL_IS_CLIP_REVERT_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_REVERT_COMMAND)) +#define MODEL_IS_CLIP_REVERT_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_REVERT_COMMAND)) +#define MODEL_CLIP_REVERT_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_REVERT_COMMAND, ModelClipRevertCommandClass)) + +typedef struct _ModelClipRevertCommand ModelClipRevertCommand; +typedef struct _ModelClipRevertCommandClass ModelClipRevertCommandClass; + +#define MODEL_CLIP_SPLIT_COMMAND_TYPE_ACTION (model_clip_split_command_action_get_type ()) + +#define MODEL_TYPE_CLIP_SPLIT_COMMAND (model_clip_split_command_get_type ()) +#define MODEL_CLIP_SPLIT_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_SPLIT_COMMAND, ModelClipSplitCommand)) +#define MODEL_CLIP_SPLIT_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_SPLIT_COMMAND, ModelClipSplitCommandClass)) +#define MODEL_IS_CLIP_SPLIT_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_SPLIT_COMMAND)) +#define MODEL_IS_CLIP_SPLIT_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_SPLIT_COMMAND)) +#define MODEL_CLIP_SPLIT_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_SPLIT_COMMAND, ModelClipSplitCommandClass)) + +typedef struct _ModelClipSplitCommand ModelClipSplitCommand; +typedef struct _ModelClipSplitCommandClass ModelClipSplitCommandClass; + +#define MODEL_TYPE_CLIP_TRIM_COMMAND (model_clip_trim_command_get_type ()) +#define MODEL_CLIP_TRIM_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_TRIM_COMMAND, ModelClipTrimCommand)) +#define MODEL_CLIP_TRIM_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_TRIM_COMMAND, ModelClipTrimCommandClass)) +#define MODEL_IS_CLIP_TRIM_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_TRIM_COMMAND)) +#define MODEL_IS_CLIP_TRIM_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_TRIM_COMMAND)) +#define MODEL_CLIP_TRIM_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_TRIM_COMMAND, ModelClipTrimCommandClass)) + +typedef struct _ModelClipTrimCommand ModelClipTrimCommand; +typedef struct _ModelClipTrimCommandClass ModelClipTrimCommandClass; + +#define MODEL_TYPE_AUDIO_TRACK (model_audio_track_get_type ()) +#define MODEL_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrack)) +#define MODEL_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrackClass)) +#define MODEL_IS_AUDIO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_AUDIO_TRACK)) +#define MODEL_IS_AUDIO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_AUDIO_TRACK)) +#define MODEL_AUDIO_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrackClass)) + +typedef struct _ModelAudioTrack ModelAudioTrack; +typedef struct _ModelAudioTrackClass ModelAudioTrackClass; +typedef struct _ModelAudioTrackPrivate ModelAudioTrackPrivate; + +#define MODEL_TYPE_PARAMETER (model_parameter_get_type ()) + +#define MODEL_TYPE_PARAMETER_COMMAND (model_parameter_command_get_type ()) +#define MODEL_PARAMETER_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PARAMETER_COMMAND, ModelParameterCommand)) +#define MODEL_PARAMETER_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PARAMETER_COMMAND, ModelParameterCommandClass)) +#define MODEL_IS_PARAMETER_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PARAMETER_COMMAND)) +#define MODEL_IS_PARAMETER_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PARAMETER_COMMAND)) +#define MODEL_PARAMETER_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PARAMETER_COMMAND, ModelParameterCommandClass)) + +typedef struct _ModelParameterCommand ModelParameterCommand; +typedef struct _ModelParameterCommandClass ModelParameterCommandClass; + +typedef enum { + MODEL_MEDIA_TYPE_AUDIO, + MODEL_MEDIA_TYPE_VIDEO +} ModelMediaType; + +struct _ModelTrack { + GObject parent_instance; + ModelTrackPrivate * priv; + ModelProject* project; + GeeArrayList* clips; + char* display_name; +}; + +struct _ModelTrackClass { + GObjectClass parent_class; + char* (*name) (ModelTrack* self); + ModelMediaType (*media_type) (ModelTrack* self); + gboolean (*check) (ModelTrack* self, ModelClip* clip); + void (*on_clip_updated) (ModelTrack* self, ModelClip* clip); + void (*write_attributes) (ModelTrack* self, FILE* f); +}; + +struct _ModelTrackPrivate { + gboolean is_selected; +}; + +struct _ModelClip { + GObject parent_instance; + ModelClipPrivate * priv; + ModelClipFile* clipfile; + ModelMediaType type; + gboolean is_recording; + char* name; +}; + +struct _ModelClipClass { + GObjectClass parent_class; +}; + +struct _ModelGap { + GTypeInstance parent_instance; + volatile int ref_count; + ModelGapPrivate * priv; + gint64 start; + gint64 end; +}; + +struct _ModelGapClass { + GTypeClass parent_class; + void (*finalize) (ModelGap *self); +}; + +struct _Fraction { + gint numerator; + gint denominator; +}; + +struct _ModelTempoInformationIface { + GTypeInterface parent_iface; + void (*get_time_signature) (ModelTempoInformation* self, Fraction* result); + gint (*get_bpm) (ModelTempoInformation* self); +}; + +struct _TimeCode { + gint hour; + gint minute; + gint second; + gint frame; + gboolean drop_code; +}; + +struct _ModelProject { + GObject parent_instance; + ModelProjectPrivate * priv; + GeeArrayList* tracks; + GeeArrayList* inactive_tracks; + GeeArrayList* clipfiles; + ViewMediaEngine* media_engine; + char* project_file; + ModelProjectLoader* loader; + ModelUndoManager* undo_manager; + ModelLibraryImporter* importer; + Fraction default_framerate; + gboolean click_during_play; + gboolean click_during_record; + double click_volume; + gboolean library_visible; + gint library_width; + gboolean snap_to_clip; +}; + +struct _ModelProjectClass { + GObjectClass parent_class; + void (*get_clip_time) (ModelProject* self, ModelClipFile* f, TimeCode* result); + char* (*get_project_file) (ModelProject* self); + void (*do_append) (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, const char* name, gint64 insert_time); + void (*add_track) (ModelProject* self, ModelTrack* track); + void (*insert_track) (ModelProject* self, gint index, ModelTrack* track); + void (*load) (ModelProject* self, const char* fname); + void (*save) (ModelProject* self, const char* filename); + char* (*get_app_name) (ModelProject* self); + void (*load_complete) (ModelProject* self); +}; + +typedef enum { + LOGGING_FACILITY_SIGNAL_HANDLERS, + LOGGING_FACILITY_DEVELOPER_WARNINGS, + LOGGING_FACILITY_GRAPH, + LOGGING_FACILITY_LOADING, + LOGGING_FACILITY_IMPORT, + LOGGING_FACILITY_SINGLEDECODEBIN +} LoggingFacility; + +typedef enum { + LOGGING_LEVEL_CRITICAL, + LOGGING_LEVEL_HIGH, + LOGGING_LEVEL_MEDIUM, + LOGGING_LEVEL_LOW, + LOGGING_LEVEL_INFO, + LOGGING_LEVEL_VERBOSE +} LoggingLevel; + +typedef enum { + MODEL_CLIP_COMMAND_ACTION_APPEND, + MODEL_CLIP_COMMAND_ACTION_DELETE +} ModelClipCommandAction; + +typedef enum { + MODEL_CLIP_SPLIT_COMMAND_ACTION_SPLIT, + MODEL_CLIP_SPLIT_COMMAND_ACTION_JOIN +} ModelClipSplitCommandAction; + +struct _ModelAudioTrack { + ModelTrack parent_instance; + ModelAudioTrackPrivate * priv; +}; + +struct _ModelAudioTrackClass { + ModelTrackClass parent_class; +}; + +struct _ModelAudioTrackPrivate { + double pan; + double volume; + gint default_num_channels; +}; + +typedef enum { + MODEL_PARAMETER_PAN, + MODEL_PARAMETER_VOLUME +} ModelParameter; + + +static gpointer model_track_parent_class = NULL; +static gpointer model_audio_track_parent_class = NULL; + +GType model_track_get_type (void); +GType model_media_type_get_type (void); +GType model_clip_get_type (void); +GType model_project_get_type (void); +#define MODEL_TRACK_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_TRACK, ModelTrackPrivate)) +enum { + MODEL_TRACK_DUMMY_PROPERTY +}; +ModelTrack* model_track_construct (GType object_type, ModelProject* project, const char* display_name); +char* model_track_name (ModelTrack* self); +static char* model_track_real_name (ModelTrack* self); +ModelMediaType model_track_media_type (ModelTrack* self); +static ModelMediaType model_track_real_media_type (ModelTrack* self); +void model_track_hide (ModelTrack* self); +GType model_clip_file_get_type (void); +gboolean model_track_contains_clipfile (ModelTrack* self, ModelClipFile* f); +gboolean model_track_check (ModelTrack* self, ModelClip* clip); +static gboolean model_track_real_check (ModelTrack* self, ModelClip* clip); +gint64 model_clip_get_start (ModelClip* self); +gint64 model_clip_get_duration (ModelClip* self); +gint64 model_track_get_time_from_pos (ModelTrack* self, ModelClip* clip, gboolean after); +gint64 model_clip_get_end (ModelClip* self); +static gint model_track_get_clip_from_time (ModelTrack* self, gint64 time); +gint64 model_clip_snap (ModelClip* self, ModelClip* other, gint64 pad); +gint64 model_track_snap_clip (ModelTrack* self, ModelClip* c, gint64 span); +gboolean model_clip_snap_coord (ModelClip* self, gint64* s, gint64 span); +gboolean model_track_snap_coord (ModelTrack* self, gint64* coord, gint64 span); +gboolean model_track_clip_is_near (ModelTrack* self, ModelClip* clip, gint64 range, gint64* adjustment); +static gint model_track_get_insert_index (ModelTrack* self, gint64 time); +ModelGap* model_gap_new (gint64 start, gint64 end); +ModelGap* model_gap_construct (GType object_type, gint64 start, gint64 end); +gpointer model_gap_ref (gpointer instance); +void model_gap_unref (gpointer instance); +GParamSpec* model_param_spec_gap (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_gap (GValue* value, gpointer v_object); +void model_value_take_gap (GValue* value, gpointer v_object); +gpointer model_value_get_gap (const GValue* value); +GType model_gap_get_type (void); +ModelGap* model_track_find_first_gap (ModelTrack* self, gint64 start); +static gint model_track_get_gap_index (ModelTrack* self, gint64 time); +void model_track_find_containing_gap (ModelTrack* self, gint64 time, ModelGap** g); +gboolean model_clip_overlap_pos (ModelClip* self, gint64 start, gint64 length); +ModelClip* model_track_find_overlapping_clip (ModelTrack* self, gint64 start, gint64 length); +ModelClip* model_track_find_nearest_clip_edge (ModelTrack* self, gint64 time, gboolean* after); +gint64 model_clip_get_media_start (ModelClip* self); +ModelClip* model_clip_new (ModelClipFile* clipfile, ModelMediaType t, const char* name, gint64 start, gint64 media_start, gint64 duration, gboolean is_recording); +ModelClip* model_clip_construct (GType object_type, ModelClipFile* clipfile, ModelMediaType t, const char* name, gint64 start, gint64 media_start, gint64 duration, gboolean is_recording); +void model_track_append_at_time (ModelTrack* self, ModelClip* c, gint64 time, gboolean select); +void model_track_trim (ModelTrack* self, ModelClip* clip, gint64 delta, GdkWindowEdge edge); +GType fraction_get_type (void); +Fraction* fraction_dup (const Fraction* self); +void fraction_free (Fraction* self); +GType model_tempo_information_get_type (void); +GType time_code_get_type (void); +TimeCode* time_code_dup (const TimeCode* self); +void time_code_free (TimeCode* self); +GType view_media_engine_get_type (void); +GType model_project_loader_get_type (void); +gpointer model_undo_manager_ref (gpointer instance); +void model_undo_manager_unref (gpointer instance); +GParamSpec* model_param_spec_undo_manager (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_undo_manager (GValue* value, gpointer v_object); +void model_value_take_undo_manager (GValue* value, gpointer v_object); +gpointer model_value_get_undo_manager (const GValue* value); +GType model_undo_manager_get_type (void); +GType model_library_importer_get_type (void); +gboolean model_undo_manager_get_in_undo (ModelUndoManager* self); +void model_track_delete_clip (ModelTrack* self, ModelClip* clip); +static void model_track_do_clip_overwrite (ModelTrack* self, ModelClip* c); +ModelClipAddCommand* model_clip_add_command_new (ModelTrack* track, ModelClip* clip, gint64 original_time, gint64 new_start); +ModelClipAddCommand* model_clip_add_command_construct (GType object_type, ModelTrack* track, ModelClip* clip, gint64 original_time, gint64 new_start); +gpointer model_command_ref (gpointer instance); +void model_command_unref (gpointer instance); +GParamSpec* model_param_spec_command (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_command (GValue* value, gpointer v_object); +void model_value_take_command (GValue* value, gpointer v_object); +gpointer model_value_get_command (const GValue* value); +GType model_command_get_type (void); +GType model_clip_add_command_get_type (void); +void model_project_do_command (ModelProject* self, ModelCommand* the_command); +void model_track_move (ModelTrack* self, ModelClip* c, gint64 pos, gint64 original_time); +void model_clip_set_start (ModelClip* self, gint64 value); +static void model_track_insert_clip_into_array (ModelTrack* self, ModelClip* c, gint pos); +void model_project_reseek (ModelProject* self); +void _model_track_move (ModelTrack* self, ModelClip* c, gint64 pos); +void model_track_add (ModelTrack* self, ModelClip* c, gint64 pos, gboolean select); +GType logging_facility_get_type (void); +GType logging_level_get_type (void); +void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message); +void model_track_on_clip_updated (ModelTrack* self, ModelClip* clip); +static void model_track_real_on_clip_updated (ModelTrack* self, ModelClip* clip); +void model_track_do_clip_paste (ModelTrack* self, ModelClip* clip, gint64 position); +ModelClip* model_track_get_clip (ModelTrack* self, gint i); +gint model_track_get_clip_index (ModelTrack* self, ModelClip* c); +ModelClip* model_track_get_clip_by_position (ModelTrack* self, gint64 pos); +gint64 model_track_get_length (ModelTrack* self); +void _model_track_append_at_time (ModelTrack* self, ModelClip* c, gint64 time, gboolean select); +GType model_clip_command_action_get_type (void); +ModelClipCommand* model_clip_command_new (ModelClipCommandAction action, ModelTrack* track, ModelClip* clip, gint64 time, gboolean select); +ModelClipCommand* model_clip_command_construct (GType object_type, ModelClipCommandAction action, ModelTrack* track, ModelClip* clip, gint64 time, gboolean select); +GType model_clip_command_get_type (void); +void _model_track_delete_clip (ModelTrack* self, ModelClip* clip); +void model_track_delete_gap (ModelTrack* self, ModelGap* g); +void model_track_remove_clip_from_array (ModelTrack* self, ModelClip* pos); +static void _model_track_on_clip_updated_model_clip_updated (ModelClip* _sender, ModelClip* clip, gpointer self); +void view_media_engine_go (ViewMediaEngine* self, gint64 pos); +void model_track_delete_all_clips (ModelTrack* self); +ModelClipRevertCommand* model_clip_revert_command_new (ModelTrack* track, ModelClip* clip); +ModelClipRevertCommand* model_clip_revert_command_construct (GType object_type, ModelTrack* track, ModelClip* clip); +GType model_clip_revert_command_get_type (void); +void model_track_revert_to_original (ModelTrack* self, ModelClip* clip); +void model_clip_set_media_start_duration (ModelClip* self, gint64 media_start, gint64 duration); +gint64 model_clip_file_get_length (ModelClipFile* self); +void _model_track_revert_to_original (ModelTrack* self, ModelClip* c); +gboolean model_track_are_contiguous_clips (ModelTrack* self, gint64 position); +GType model_clip_split_command_action_get_type (void); +ModelClipSplitCommand* model_clip_split_command_new (ModelClipSplitCommandAction action, ModelTrack* track, gint64 time); +ModelClipSplitCommand* model_clip_split_command_construct (GType object_type, ModelClipSplitCommandAction action, ModelTrack* track, gint64 time); +GType model_clip_split_command_get_type (void); +void model_track_split_at (ModelTrack* self, gint64 position); +void model_clip_set_duration (ModelClip* self, gint64 value); +void _model_track_split_at (ModelTrack* self, gint64 position); +void model_track_join (ModelTrack* self, gint64 position); +void _model_track_join (ModelTrack* self, gint64 position); +ModelClipTrimCommand* model_clip_trim_command_new (ModelTrack* track, ModelClip* clip, gint64 delta, GdkWindowEdge edge); +ModelClipTrimCommand* model_clip_trim_command_construct (GType object_type, ModelTrack* track, ModelClip* clip, gint64 delta, GdkWindowEdge edge); +GType model_clip_trim_command_get_type (void); +void model_clip_trim (ModelClip* self, gint64 delta, GdkWindowEdge edge); +void _model_track_trim (ModelTrack* self, ModelClip* clip, gint64 delta, GdkWindowEdge edge); +gint64 model_track_previous_edit (ModelTrack* self, gint64 pos); +gint64 model_track_next_edit (ModelTrack* self, gint64 pos); +char* model_track_get_display_name (ModelTrack* self); +void model_track_write_attributes (ModelTrack* self, FILE* f); +static void model_track_real_write_attributes (ModelTrack* self, FILE* f); +void model_clip_save (ModelClip* self, FILE* f, gint id); +gint model_project_get_clipfile_index (ModelProject* self, ModelClipFile* find); +void model_track_save (ModelTrack* self, FILE* f); +void model_track_set_display_name (ModelTrack* self, const char* new_display_name); +void model_track_set_selected (ModelTrack* self, gboolean is_selected); +gboolean model_track_get_is_selected (ModelTrack* self); +static void model_track_finalize (GObject* obj); +GType model_audio_track_get_type (void); +#define MODEL_AUDIO_TRACK_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_AUDIO_TRACK, ModelAudioTrackPrivate)) +enum { + MODEL_AUDIO_TRACK_DUMMY_PROPERTY +}; +#define MODEL_AUDIO_TRACK_INVALID_CHANNEL_COUNT (-1) +void model_audio_track_set_default_num_channels (ModelAudioTrack* self, gint num); +void _model_audio_track_set_pan (ModelAudioTrack* self, double new_value); +void _model_audio_track_set_volume (ModelAudioTrack* self, double new_volume); +ModelAudioTrack* model_audio_track_new (ModelProject* project, const char* display_name); +ModelAudioTrack* model_audio_track_construct (GType object_type, ModelProject* project, const char* display_name); +static char* model_audio_track_real_name (ModelTrack* base); +static ModelMediaType model_audio_track_real_media_type (ModelTrack* base); +double model_audio_track_get_volume (ModelAudioTrack* self); +double model_audio_track_get_pan (ModelAudioTrack* self); +gboolean model_audio_track_get_num_channels (ModelAudioTrack* self, gint* num); +static void model_audio_track_real_write_attributes (ModelTrack* base, FILE* f); +gboolean float_within (double f, double epsilon); +GType model_parameter_get_type (void); +ModelParameterCommand* model_parameter_command_new (ModelAudioTrack* target, ModelParameter parameter, double new_value, double old_value); +ModelParameterCommand* model_parameter_command_construct (GType object_type, ModelAudioTrack* target, ModelParameter parameter, double new_value, double old_value); +GType model_parameter_command_get_type (void); +void model_audio_track_set_pan (ModelAudioTrack* self, double new_value); +void model_audio_track_set_volume (ModelAudioTrack* self, double new_volume); +gboolean model_clip_file_is_online (ModelClipFile* self); +gboolean model_clip_file_get_num_channels (ModelClipFile* self, gint* channels); +static gboolean model_audio_track_real_check (ModelTrack* base, ModelClip* clip); +void model_audio_track_on_level_changed (ModelAudioTrack* self, double level_left, double level_right); +static void model_audio_track_real_on_clip_updated (ModelTrack* base, ModelClip* clip); +static void model_audio_track_finalize (GObject* obj); +static int _vala_strcmp0 (const char * str1, const char * str2); + + +static void g_cclosure_user_marshal_VOID__OBJECT_BOOLEAN (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data); +static void g_cclosure_user_marshal_VOID__STRING_STRING (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data); +static void g_cclosure_user_marshal_VOID__ENUM_DOUBLE (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data); +static void g_cclosure_user_marshal_VOID__DOUBLE_DOUBLE (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data); + +#line 26 "track.vala" +ModelTrack* model_track_construct (GType object_type, ModelProject* project, const char* display_name) { +#line 564 "track.c" + ModelTrack * self; + char* _tmp0_; +#line 26 "track.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (project), NULL); +#line 26 "track.vala" + g_return_val_if_fail (display_name != NULL, NULL); +#line 26 "track.vala" + self = (ModelTrack*) g_object_new (object_type, NULL); +#line 27 "track.vala" + self->project = project; +#line 28 "track.vala" + self->display_name = (_tmp0_ = g_strdup (display_name), _g_free0 (self->display_name), _tmp0_); +#line 577 "track.c" + return self; +} + + +#line 31 "track.vala" +static char* model_track_real_name (ModelTrack* self) { +#line 584 "track.c" + g_return_val_if_fail (MODEL_IS_TRACK (self), NULL); + g_critical ("Type `%s' does not implement abstract method `model_track_name'", g_type_name (G_TYPE_FROM_INSTANCE (self))); + return NULL; +} + + +#line 31 "track.vala" +char* model_track_name (ModelTrack* self) { +#line 31 "track.vala" + return MODEL_TRACK_GET_CLASS (self)->name (self); +#line 595 "track.c" +} + + +#line 32 "track.vala" +static ModelMediaType model_track_real_media_type (ModelTrack* self) { +#line 601 "track.c" + g_return_val_if_fail (MODEL_IS_TRACK (self), 0); + g_critical ("Type `%s' does not implement abstract method `model_track_media_type'", g_type_name (G_TYPE_FROM_INSTANCE (self))); + return 0; +} + + +#line 32 "track.vala" +ModelMediaType model_track_media_type (ModelTrack* self) { +#line 32 "track.vala" + return MODEL_TRACK_GET_CLASS (self)->media_type (self); +#line 612 "track.c" +} + + +#line 34 "track.vala" +void model_track_hide (ModelTrack* self) { +#line 34 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 35 "track.vala" + g_signal_emit_by_name (self, "track-hidden", self); +#line 622 "track.c" +} + + +#line 38 "track.vala" +gboolean model_track_contains_clipfile (ModelTrack* self, ModelClipFile* f) { +#line 628 "track.c" + gboolean result = FALSE; +#line 38 "track.vala" + g_return_val_if_fail (MODEL_IS_TRACK (self), FALSE); +#line 38 "track.vala" + g_return_val_if_fail (MODEL_IS_CLIP_FILE (f), FALSE); +#line 634 "track.c" + { + GeeIterator* _c_it; + _c_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->clips)); +#line 39 "track.vala" + while (TRUE) { +#line 640 "track.c" + ModelClip* c; +#line 39 "track.vala" + if (!gee_iterator_next (_c_it)) { +#line 39 "track.vala" + break; +#line 646 "track.c" + } +#line 39 "track.vala" + c = (ModelClip*) gee_iterator_get (_c_it); +#line 40 "track.vala" + if (c->clipfile == f) { +#line 652 "track.c" + result = TRUE; + _g_object_unref0 (c); + _g_object_unref0 (_c_it); +#line 41 "track.vala" + return result; +#line 658 "track.c" + } + _g_object_unref0 (c); + } + _g_object_unref0 (_c_it); + } + result = FALSE; +#line 43 "track.vala" + return result; +#line 667 "track.c" +} + + +#line 46 "track.vala" +static gboolean model_track_real_check (ModelTrack* self, ModelClip* clip) { +#line 673 "track.c" + g_return_val_if_fail (MODEL_IS_TRACK (self), FALSE); + g_critical ("Type `%s' does not implement abstract method `model_track_check'", g_type_name (G_TYPE_FROM_INSTANCE (self))); + return FALSE; +} + + +#line 46 "track.vala" +gboolean model_track_check (ModelTrack* self, ModelClip* clip) { +#line 46 "track.vala" + return MODEL_TRACK_GET_CLASS (self)->check (self, clip); +#line 684 "track.c" +} + + +#line 48 "track.vala" +gint64 model_track_get_time_from_pos (ModelTrack* self, ModelClip* clip, gboolean after) { +#line 690 "track.c" + gint64 result = 0LL; +#line 48 "track.vala" + g_return_val_if_fail (MODEL_IS_TRACK (self), 0LL); +#line 48 "track.vala" + g_return_val_if_fail (MODEL_IS_CLIP (clip), 0LL); +#line 49 "track.vala" + if (after) { +#line 698 "track.c" + result = model_clip_get_start (clip) + model_clip_get_duration (clip); +#line 50 "track.vala" + return result; +#line 702 "track.c" + } else { + result = model_clip_get_start (clip); +#line 52 "track.vala" + return result; +#line 707 "track.c" + } +} + + +#line 55 "track.vala" +static gint model_track_get_clip_from_time (ModelTrack* self, gint64 time) { +#line 714 "track.c" + gint result = 0; +#line 55 "track.vala" + g_return_val_if_fail (MODEL_IS_TRACK (self), 0); +#line 718 "track.c" + { + gint i; +#line 56 "track.vala" + i = 0; +#line 723 "track.c" + { + gboolean _tmp0_; +#line 56 "track.vala" + _tmp0_ = TRUE; +#line 56 "track.vala" + while (TRUE) { +#line 730 "track.c" + gboolean _tmp1_ = FALSE; + ModelClip* _tmp2_; + gboolean _tmp3_; +#line 56 "track.vala" + if (!_tmp0_) { +#line 56 "track.vala" + i++; +#line 738 "track.c" + } +#line 56 "track.vala" + _tmp0_ = FALSE; +#line 56 "track.vala" + if (!(i < gee_collection_get_size (GEE_COLLECTION (self->clips)))) { +#line 56 "track.vala" + break; +#line 746 "track.c" + } +#line 57 "track.vala" + if ((_tmp3_ = time >= model_clip_get_start (_tmp2_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i)), _g_object_unref0 (_tmp2_), _tmp3_)) { +#line 750 "track.c" + ModelClip* _tmp4_; +#line 58 "track.vala" + _tmp1_ = time < model_clip_get_end (_tmp4_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i)); +#line 754 "track.c" + _g_object_unref0 (_tmp4_); + } else { +#line 57 "track.vala" + _tmp1_ = FALSE; +#line 759 "track.c" + } +#line 57 "track.vala" + if (_tmp1_) { +#line 763 "track.c" + result = i; +#line 59 "track.vala" + return result; +#line 767 "track.c" + } + } + } + } + result = -1; +#line 61 "track.vala" + return result; +#line 775 "track.c" +} + + +#line 64 "track.vala" +gint64 model_track_snap_clip (ModelTrack* self, ModelClip* c, gint64 span) { +#line 781 "track.c" + gint64 result = 0LL; +#line 64 "track.vala" + g_return_val_if_fail (MODEL_IS_TRACK (self), 0LL); +#line 64 "track.vala" + g_return_val_if_fail (MODEL_IS_CLIP (c), 0LL); +#line 787 "track.c" + { + GeeIterator* _cl_it; + _cl_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->clips)); +#line 65 "track.vala" + while (TRUE) { +#line 793 "track.c" + ModelClip* cl; + gint64 new_start; +#line 65 "track.vala" + if (!gee_iterator_next (_cl_it)) { +#line 65 "track.vala" + break; +#line 800 "track.c" + } +#line 65 "track.vala" + cl = (ModelClip*) gee_iterator_get (_cl_it); +#line 66 "track.vala" + new_start = model_clip_snap (c, cl, span); +#line 67 "track.vala" + if (new_start != model_clip_get_start (c)) { +#line 808 "track.c" + result = new_start; + _g_object_unref0 (cl); + _g_object_unref0 (_cl_it); +#line 68 "track.vala" + return result; +#line 814 "track.c" + } + _g_object_unref0 (cl); + } + _g_object_unref0 (_cl_it); + } + result = model_clip_get_start (c); +#line 71 "track.vala" + return result; +#line 823 "track.c" +} + + +#line 74 "track.vala" +gboolean model_track_snap_coord (ModelTrack* self, gint64* coord, gint64 span) { +#line 829 "track.c" + gboolean result = FALSE; +#line 74 "track.vala" + g_return_val_if_fail (MODEL_IS_TRACK (self), FALSE); +#line 833 "track.c" + { + GeeIterator* _c_it; + _c_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->clips)); +#line 75 "track.vala" + while (TRUE) { +#line 839 "track.c" + ModelClip* c; +#line 75 "track.vala" + if (!gee_iterator_next (_c_it)) { +#line 75 "track.vala" + break; +#line 845 "track.c" + } +#line 75 "track.vala" + c = (ModelClip*) gee_iterator_get (_c_it); +#line 76 "track.vala" + if (model_clip_snap_coord (c, coord, span)) { +#line 851 "track.c" + result = TRUE; + _g_object_unref0 (c); + _g_object_unref0 (_c_it); +#line 77 "track.vala" + return result; +#line 857 "track.c" + } + _g_object_unref0 (c); + } + _g_object_unref0 (_c_it); + } + result = FALSE; +#line 79 "track.vala" + return result; +#line 866 "track.c" +} + + +#line 82 "track.vala" +gboolean model_track_clip_is_near (ModelTrack* self, ModelClip* clip, gint64 range, gint64* adjustment) { +#line 872 "track.c" + gboolean result = FALSE; +#line 82 "track.vala" + g_return_val_if_fail (MODEL_IS_TRACK (self), FALSE); +#line 82 "track.vala" + g_return_val_if_fail (MODEL_IS_CLIP (clip), FALSE); +#line 878 "track.c" + { + GeeIterator* _potential_clip_it; + _potential_clip_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->clips)); +#line 83 "track.vala" + while (TRUE) { +#line 884 "track.c" + ModelClip* potential_clip; +#line 83 "track.vala" + if (!gee_iterator_next (_potential_clip_it)) { +#line 83 "track.vala" + break; +#line 890 "track.c" + } +#line 83 "track.vala" + potential_clip = (ModelClip*) gee_iterator_get (_potential_clip_it); +#line 84 "track.vala" + if (potential_clip != clip) { +#line 896 "track.c" + gint64 difference; +#line 85 "track.vala" + difference = model_clip_get_start (clip) - model_clip_get_end (potential_clip); +#line 86 "track.vala" + if (llabs (difference) < range) { +#line 87 "track.vala" + *adjustment = -difference; +#line 904 "track.c" + result = TRUE; + _g_object_unref0 (potential_clip); + _g_object_unref0 (_potential_clip_it); +#line 88 "track.vala" + return result; +#line 910 "track.c" + } +#line 91 "track.vala" + difference = model_clip_get_start (potential_clip) - model_clip_get_end (clip); +#line 92 "track.vala" + if (llabs (difference) < range) { +#line 93 "track.vala" + *adjustment = difference; +#line 918 "track.c" + result = TRUE; + _g_object_unref0 (potential_clip); + _g_object_unref0 (_potential_clip_it); +#line 94 "track.vala" + return result; +#line 924 "track.c" + } + } + _g_object_unref0 (potential_clip); + } + _g_object_unref0 (_potential_clip_it); + } + result = FALSE; +#line 98 "track.vala" + return result; +#line 934 "track.c" +} + + +#line 101 "track.vala" +static gint model_track_get_insert_index (ModelTrack* self, gint64 time) { +#line 940 "track.c" + gint result = 0; + gint end_ret; +#line 101 "track.vala" + g_return_val_if_fail (MODEL_IS_TRACK (self), 0); +#line 102 "track.vala" + end_ret = 0; +#line 947 "track.c" + { + gint i; +#line 103 "track.vala" + i = 0; +#line 952 "track.c" + { + gboolean _tmp0_; +#line 103 "track.vala" + _tmp0_ = TRUE; +#line 103 "track.vala" + while (TRUE) { +#line 959 "track.c" + ModelClip* c; +#line 103 "track.vala" + if (!_tmp0_) { +#line 103 "track.vala" + i++; +#line 965 "track.c" + } +#line 103 "track.vala" + _tmp0_ = FALSE; +#line 103 "track.vala" + if (!(i < gee_collection_get_size (GEE_COLLECTION (self->clips)))) { +#line 103 "track.vala" + break; +#line 973 "track.c" + } + c = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i); +#line 106 "track.vala" + if (time >= model_clip_get_start (c)) { +#line 107 "track.vala" + if (time < (model_clip_get_start (c) + (model_clip_get_duration (c) / 2))) { +#line 980 "track.c" + result = i; + _g_object_unref0 (c); +#line 108 "track.vala" + return result; +#line 985 "track.c" + } else { +#line 109 "track.vala" + if (time < (model_clip_get_start (c) + model_clip_get_duration (c))) { +#line 989 "track.c" + result = i + 1; + _g_object_unref0 (c); +#line 110 "track.vala" + return result; +#line 994 "track.c" + } else { +#line 112 "track.vala" + end_ret++; +#line 998 "track.c" + } + } + } + _g_object_unref0 (c); + } + } + } + result = end_ret; +#line 115 "track.vala" + return result; +#line 1009 "track.c" +} + + +#line 119 "track.vala" +ModelGap* model_track_find_first_gap (ModelTrack* self, gint64 start) { +#line 1015 "track.c" + ModelGap* result = NULL; + gint64 new_start; + gint64 new_end; +#line 119 "track.vala" + g_return_val_if_fail (MODEL_IS_TRACK (self), NULL); +#line 120 "track.vala" + new_start = (gint64) 0; +#line 121 "track.vala" + new_end = G_MAXINT64; +#line 1025 "track.c" + { + GeeIterator* _c_it; + _c_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->clips)); +#line 123 "track.vala" + while (TRUE) { +#line 1031 "track.c" + ModelClip* c; + gboolean _tmp0_ = FALSE; +#line 123 "track.vala" + if (!gee_iterator_next (_c_it)) { +#line 123 "track.vala" + break; +#line 1038 "track.c" + } +#line 123 "track.vala" + c = (ModelClip*) gee_iterator_get (_c_it); +#line 124 "track.vala" + if (model_clip_get_start (c) > new_start) { +#line 125 "track.vala" + _tmp0_ = model_clip_get_start (c) > start; +#line 1046 "track.c" + } else { +#line 124 "track.vala" + _tmp0_ = FALSE; +#line 1050 "track.c" + } +#line 124 "track.vala" + if (_tmp0_) { +#line 126 "track.vala" + new_end = model_clip_get_start (c); +#line 1056 "track.c" + _g_object_unref0 (c); +#line 127 "track.vala" + break; +#line 1060 "track.c" + } +#line 129 "track.vala" + new_start = model_clip_get_end (c); +#line 1064 "track.c" + _g_object_unref0 (c); + } + _g_object_unref0 (_c_it); + } + result = model_gap_new (new_start, new_end); +#line 131 "track.vala" + return result; +#line 1072 "track.c" +} + + +#line 135 "track.vala" +static gint model_track_get_gap_index (ModelTrack* self, gint64 time) { +#line 1078 "track.c" + gint result = 0; + gint i; +#line 135 "track.vala" + g_return_val_if_fail (MODEL_IS_TRACK (self), 0); +#line 136 "track.vala" + i = 0; +#line 137 "track.vala" + while (TRUE) { +#line 1087 "track.c" + ModelClip* _tmp0_; + gboolean _tmp1_; +#line 137 "track.vala" + if (!(i < gee_collection_get_size (GEE_COLLECTION (self->clips)))) { +#line 137 "track.vala" + break; +#line 1094 "track.c" + } +#line 138 "track.vala" + if ((_tmp1_ = time <= model_clip_get_start (_tmp0_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i)), _g_object_unref0 (_tmp0_), _tmp1_)) { +#line 139 "track.vala" + break; +#line 1100 "track.c" + } +#line 140 "track.vala" + i++; +#line 1104 "track.c" + } + result = i; +#line 142 "track.vala" + return result; +#line 1109 "track.c" +} + + +#line 147 "track.vala" +void model_track_find_containing_gap (ModelTrack* self, gint64 time, ModelGap** g) { +#line 1115 "track.c" + ModelGap* _tmp0_; + gint index; +#line 147 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 1120 "track.c" + if (g != NULL) { + *g = NULL; + } +#line 148 "track.vala" + *g = (_tmp0_ = model_gap_new ((gint64) 0, (gint64) 0), _model_gap_unref0 (*g), _tmp0_); +#line 150 "track.vala" + index = model_track_get_gap_index (self, time); +#line 151 "track.vala" + if (index < gee_collection_get_size (GEE_COLLECTION (self->clips))) { +#line 1130 "track.c" + gint64 _tmp1_ = 0LL; + ModelClip* _tmp3_; +#line 152 "track.vala" + if (index > 0) { +#line 1135 "track.c" + ModelClip* _tmp2_; +#line 152 "track.vala" + _tmp1_ = model_clip_get_end (_tmp2_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), index - 1)); +#line 1139 "track.c" + _g_object_unref0 (_tmp2_); + } else { +#line 152 "track.vala" + _tmp1_ = (gint64) 0; +#line 1144 "track.c" + } +#line 152 "track.vala" + (*g)->start = _tmp1_; +#line 153 "track.vala" + (*g)->end = model_clip_get_start (_tmp3_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), index)); +#line 1150 "track.c" + _g_object_unref0 (_tmp3_); + } +} + + +#line 157 "track.vala" +ModelClip* model_track_find_overlapping_clip (ModelTrack* self, gint64 start, gint64 length) { +#line 1158 "track.c" + ModelClip* result = NULL; +#line 157 "track.vala" + g_return_val_if_fail (MODEL_IS_TRACK (self), NULL); +#line 1162 "track.c" + { + gint i; +#line 158 "track.vala" + i = 0; +#line 1167 "track.c" + { + gboolean _tmp0_; +#line 158 "track.vala" + _tmp0_ = TRUE; +#line 158 "track.vala" + while (TRUE) { +#line 1174 "track.c" + ModelClip* c; +#line 158 "track.vala" + if (!_tmp0_) { +#line 158 "track.vala" + i++; +#line 1180 "track.c" + } +#line 158 "track.vala" + _tmp0_ = FALSE; +#line 158 "track.vala" + if (!(i < gee_collection_get_size (GEE_COLLECTION (self->clips)))) { +#line 158 "track.vala" + break; +#line 1188 "track.c" + } + c = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i); +#line 160 "track.vala" + if (model_clip_overlap_pos (c, start, length)) { +#line 1193 "track.c" + result = c; +#line 161 "track.vala" + return result; +#line 1197 "track.c" + } + _g_object_unref0 (c); + } + } + } + result = NULL; +#line 163 "track.vala" + return result; +#line 1206 "track.c" +} + + +#line 166 "track.vala" +ModelClip* model_track_find_nearest_clip_edge (ModelTrack* self, gint64 time, gboolean* after) { +#line 1212 "track.c" + ModelClip* result = NULL; + gint limit; + ModelClip* _tmp0_; + gint64 _tmp1_; + gint64 prev_time; +#line 166 "track.vala" + g_return_val_if_fail (MODEL_IS_TRACK (self), NULL); +#line 167 "track.vala" + limit = gee_collection_get_size (GEE_COLLECTION (self->clips)) * 2; +#line 168 "track.vala" + prev_time = (_tmp1_ = model_clip_get_start (_tmp0_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), 0)), _g_object_unref0 (_tmp0_), _tmp1_); +#line 1224 "track.c" + { + gint i; +#line 170 "track.vala" + i = 1; +#line 1229 "track.c" + { + gboolean _tmp2_; +#line 170 "track.vala" + _tmp2_ = TRUE; +#line 170 "track.vala" + while (TRUE) { +#line 1236 "track.c" + ModelClip* c; + gint64 t = 0LL; +#line 170 "track.vala" + if (!_tmp2_) { +#line 170 "track.vala" + i++; +#line 1243 "track.c" + } +#line 170 "track.vala" + _tmp2_ = FALSE; +#line 170 "track.vala" + if (!(i < limit)) { +#line 170 "track.vala" + break; +#line 1251 "track.c" + } + c = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i / 2); +#line 174 "track.vala" + if ((i % 2) == 0) { +#line 175 "track.vala" + t = model_clip_get_start (c); +#line 1258 "track.c" + } else { +#line 177 "track.vala" + t = model_clip_get_end (c); +#line 1262 "track.c" + } +#line 179 "track.vala" + if (t > time) { +#line 180 "track.vala" + if ((t - time) < (time - prev_time)) { +#line 181 "track.vala" + *after = (i % 2) != 0; +#line 1270 "track.c" + result = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i / 2); + _g_object_unref0 (c); +#line 182 "track.vala" + return result; +#line 1275 "track.c" + } else { +#line 184 "track.vala" + *after = (i % 2) == 0; +#line 1279 "track.c" + result = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), (i - 1) / 2); + _g_object_unref0 (c); +#line 185 "track.vala" + return result; +#line 1284 "track.c" + } + } +#line 188 "track.vala" + prev_time = t; +#line 1289 "track.c" + _g_object_unref0 (c); + } + } + } +#line 191 "track.vala" + *after = TRUE; +#line 1296 "track.c" + result = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), gee_collection_get_size (GEE_COLLECTION (self->clips)) - 1); +#line 192 "track.vala" + return result; +#line 1300 "track.c" +} + + +#line 195 "track.vala" +static void model_track_do_clip_overwrite (ModelTrack* self, ModelClip* c) { +#line 1306 "track.c" + gint start_index; + gint end_index; + gboolean _tmp11_ = FALSE; + gint i; +#line 195 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 195 "track.vala" + g_return_if_fail (MODEL_IS_CLIP (c)); +#line 196 "track.vala" + start_index = model_track_get_clip_from_time (self, model_clip_get_start (c)); +#line 197 "track.vala" + end_index = model_track_get_clip_from_time (self, model_clip_get_end (c)); +#line 199 "track.vala" + if (end_index >= 0) { +#line 1321 "track.c" + ModelClip* _tmp0_; + gint64 _tmp1_; + gint64 diff; +#line 200 "track.vala" + diff = (_tmp1_ = model_clip_get_end (c) - model_clip_get_start (_tmp0_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), end_index)), _g_object_unref0 (_tmp0_), _tmp1_); +#line 201 "track.vala" + if (end_index == start_index) { +#line 1329 "track.c" + ModelClip* _tmp2_; + gboolean _tmp3_; +#line 202 "track.vala" + if ((_tmp3_ = c == (_tmp2_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), end_index)), _g_object_unref0 (_tmp2_), _tmp3_)) { +#line 203 "track.vala" + return; +#line 1336 "track.c" + } +#line 206 "track.vala" + if (diff > 0) { +#line 1340 "track.c" + ModelClip* _tmp8_; + ModelClip* _tmp7_; + ModelClip* _tmp6_; + ModelClip* _tmp5_; + ModelClip* _tmp4_; + ModelClip* _tmp9_; + ModelClip* cl; +#line 207 "track.vala" + cl = (_tmp9_ = model_clip_new ((_tmp4_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), end_index))->clipfile, (_tmp5_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), end_index))->type, (_tmp6_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), end_index))->name, model_clip_get_end (c), model_clip_get_media_start (_tmp7_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), end_index)) + diff, model_clip_get_duration (_tmp8_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), end_index)) - diff, FALSE), _g_object_unref0 (_tmp8_), _g_object_unref0 (_tmp7_), _g_object_unref0 (_tmp6_), _g_object_unref0 (_tmp5_), _g_object_unref0 (_tmp4_), _tmp9_); +#line 211 "track.vala" + model_track_append_at_time (self, cl, model_clip_get_start (cl), FALSE); +#line 1352 "track.c" + _g_object_unref0 (cl); + } + } else { + ModelClip* _tmp10_; +#line 214 "track.vala" + model_track_trim (self, _tmp10_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), end_index), diff, GDK_WINDOW_EDGE_WEST); +#line 1359 "track.c" + _g_object_unref0 (_tmp10_); + } + } +#line 217 "track.vala" + if (start_index >= 0) { +#line 1365 "track.c" + ModelClip* _tmp12_; +#line 217 "track.vala" + _tmp11_ = (_tmp12_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), start_index)) != c; +#line 1369 "track.c" + _g_object_unref0 (_tmp12_); + } else { +#line 217 "track.vala" + _tmp11_ = FALSE; +#line 1374 "track.c" + } +#line 217 "track.vala" + if (_tmp11_) { +#line 1378 "track.c" + ModelClip* _tmp13_; + gint64 _tmp14_; + gint64 delta; + ModelClip* _tmp15_; +#line 218 "track.vala" + delta = (_tmp14_ = model_clip_get_end (_tmp13_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), start_index)) - model_clip_get_start (c), _g_object_unref0 (_tmp13_), _tmp14_); +#line 219 "track.vala" + model_track_trim (self, _tmp15_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), start_index), -delta, GDK_WINDOW_EDGE_EAST); +#line 1387 "track.c" + _g_object_unref0 (_tmp15_); + } +#line 222 "track.vala" + i = 0; +#line 226 "track.vala" + if (!model_undo_manager_get_in_undo (self->project->undo_manager)) { +#line 227 "track.vala" + while (TRUE) { +#line 1396 "track.c" + gboolean _tmp16_ = FALSE; + gboolean _tmp17_ = FALSE; + ModelClip* _tmp18_; + gboolean _tmp19_; +#line 227 "track.vala" + if (!(i < gee_collection_get_size (GEE_COLLECTION (self->clips)))) { +#line 227 "track.vala" + break; +#line 1405 "track.c" + } +#line 228 "track.vala" + if ((_tmp19_ = (_tmp18_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i)) != c, _g_object_unref0 (_tmp18_), _tmp19_)) { +#line 1409 "track.c" + ModelClip* _tmp20_; +#line 229 "track.vala" + _tmp17_ = model_clip_get_start (_tmp20_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i)) >= model_clip_get_start (c); +#line 1413 "track.c" + _g_object_unref0 (_tmp20_); + } else { +#line 228 "track.vala" + _tmp17_ = FALSE; +#line 1418 "track.c" + } +#line 228 "track.vala" + if (_tmp17_) { +#line 1422 "track.c" + ModelClip* _tmp21_; +#line 230 "track.vala" + _tmp16_ = model_clip_get_end (_tmp21_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i)) <= model_clip_get_end (c); +#line 1426 "track.c" + _g_object_unref0 (_tmp21_); + } else { +#line 228 "track.vala" + _tmp16_ = FALSE; +#line 1431 "track.c" + } +#line 228 "track.vala" + if (_tmp16_) { +#line 1435 "track.c" + ModelClip* _tmp22_; +#line 231 "track.vala" + model_track_delete_clip (self, _tmp22_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i)); +#line 1439 "track.c" + _g_object_unref0 (_tmp22_); + } else { +#line 234 "track.vala" + i++; +#line 1444 "track.c" + } + } + } +} + + +#line 239 "track.vala" +void model_track_move (ModelTrack* self, ModelClip* c, gint64 pos, gint64 original_time) { +#line 1453 "track.c" + ModelCommand* command; +#line 239 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 239 "track.vala" + g_return_if_fail (MODEL_IS_CLIP (c)); +#line 240 "track.vala" + command = MODEL_COMMAND (model_clip_add_command_new (self, c, original_time, pos)); +#line 241 "track.vala" + model_project_do_command (self->project, command); +#line 1463 "track.c" + _model_command_unref0 (command); +} + + +#line 244 "track.vala" +void _model_track_move (ModelTrack* self, ModelClip* c, gint64 pos) { +#line 244 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 244 "track.vala" + g_return_if_fail (MODEL_IS_CLIP (c)); +#line 245 "track.vala" + if (pos < 0) { +#line 246 "track.vala" + pos = (gint64) 0; +#line 1478 "track.c" + } +#line 248 "track.vala" + model_clip_set_start (c, pos); +#line 249 "track.vala" + model_track_do_clip_overwrite (self, c); +#line 251 "track.vala" + model_track_insert_clip_into_array (self, c, model_track_get_insert_index (self, model_clip_get_start (c))); +#line 252 "track.vala" + model_project_reseek (self->project); +#line 1488 "track.c" +} + + +#line 255 "track.vala" +void model_track_add (ModelTrack* self, ModelClip* c, gint64 pos, gboolean select) { +#line 255 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 255 "track.vala" + g_return_if_fail (MODEL_IS_CLIP (c)); +#line 256 "track.vala" + if (!model_track_check (self, c)) { +#line 257 "track.vala" + return; +#line 1502 "track.c" + } +#line 259 "track.vala" + _model_track_move (self, c, pos); +#line 260 "track.vala" + g_signal_emit_by_name (self, "clip-added", c, select); +#line 1508 "track.c" +} + + +#line 263 "track.vala" +static void model_track_real_on_clip_updated (ModelTrack* self, ModelClip* clip) { +#line 263 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 263 "track.vala" + g_return_if_fail (MODEL_IS_CLIP (clip)); +#line 264 "track.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_updated"); +#line 1520 "track.c" +} + + +#line 263 "track.vala" +void model_track_on_clip_updated (ModelTrack* self, ModelClip* clip) { +#line 263 "track.vala" + MODEL_TRACK_GET_CLASS (self)->on_clip_updated (self, clip); +#line 1528 "track.c" +} + + +#line 267 "track.vala" +void model_track_do_clip_paste (ModelTrack* self, ModelClip* clip, gint64 position) { +#line 267 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 267 "track.vala" + g_return_if_fail (MODEL_IS_CLIP (clip)); +#line 268 "track.vala" + model_track_append_at_time (self, clip, position, TRUE); +#line 1540 "track.c" +} + + +#line 271 "track.vala" +ModelClip* model_track_get_clip (ModelTrack* self, gint i) { +#line 1546 "track.c" + ModelClip* result = NULL; + gboolean _tmp0_ = FALSE; +#line 271 "track.vala" + g_return_val_if_fail (MODEL_IS_TRACK (self), NULL); +#line 272 "track.vala" + if (i < 0) { +#line 272 "track.vala" + _tmp0_ = TRUE; +#line 1555 "track.c" + } else { +#line 272 "track.vala" + _tmp0_ = i >= gee_collection_get_size (GEE_COLLECTION (self->clips)); +#line 1559 "track.c" + } +#line 272 "track.vala" + if (_tmp0_) { +#line 273 "track.vala" + g_error ("track.vala:273: get_clip: Invalid index! %d (%d)", i, gee_collection_get_size (GEE_COLLECTION (self->clips))); +#line 1565 "track.c" + } + result = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i); +#line 274 "track.vala" + return result; +#line 1570 "track.c" +} + + +#line 277 "track.vala" +gint model_track_get_clip_index (ModelTrack* self, ModelClip* c) { +#line 1576 "track.c" + gint result = 0; +#line 277 "track.vala" + g_return_val_if_fail (MODEL_IS_TRACK (self), 0); +#line 277 "track.vala" + g_return_val_if_fail (MODEL_IS_CLIP (c), 0); +#line 1582 "track.c" + { + gint i; +#line 278 "track.vala" + i = 0; +#line 1587 "track.c" + { + gboolean _tmp0_; +#line 278 "track.vala" + _tmp0_ = TRUE; +#line 278 "track.vala" + while (TRUE) { +#line 1594 "track.c" + ModelClip* _tmp1_; + gboolean _tmp2_; +#line 278 "track.vala" + if (!_tmp0_) { +#line 278 "track.vala" + i++; +#line 1601 "track.c" + } +#line 278 "track.vala" + _tmp0_ = FALSE; +#line 278 "track.vala" + if (!(i < gee_collection_get_size (GEE_COLLECTION (self->clips)))) { +#line 278 "track.vala" + break; +#line 1609 "track.c" + } +#line 279 "track.vala" + if ((_tmp2_ = (_tmp1_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i)) == c, _g_object_unref0 (_tmp1_), _tmp2_)) { +#line 1613 "track.c" + result = i; +#line 280 "track.vala" + return result; +#line 1617 "track.c" + } + } + } + } + result = -1; +#line 283 "track.vala" + return result; +#line 1625 "track.c" +} + + +#line 286 "track.vala" +ModelClip* model_track_get_clip_by_position (ModelTrack* self, gint64 pos) { +#line 1631 "track.c" + ModelClip* result = NULL; + gint length; +#line 286 "track.vala" + g_return_val_if_fail (MODEL_IS_TRACK (self), NULL); +#line 287 "track.vala" + length = gee_collection_get_size (GEE_COLLECTION (self->clips)); +#line 1638 "track.c" + { + gint i; +#line 289 "track.vala" + i = length - 1; +#line 1643 "track.c" + { + gboolean _tmp0_; +#line 289 "track.vala" + _tmp0_ = TRUE; +#line 289 "track.vala" + while (TRUE) { +#line 1650 "track.c" + ModelClip* _tmp1_; + gboolean _tmp2_; +#line 289 "track.vala" + if (!_tmp0_) { +#line 289 "track.vala" + i--; +#line 1657 "track.c" + } +#line 289 "track.vala" + _tmp0_ = FALSE; +#line 289 "track.vala" + if (!(i >= 0)) { +#line 289 "track.vala" + break; +#line 1665 "track.c" + } +#line 290 "track.vala" + if ((_tmp2_ = model_clip_get_start (_tmp1_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i)) < pos, _g_object_unref0 (_tmp1_), _tmp2_)) { +#line 1669 "track.c" + ModelClip* _tmp3_; + ModelClip* _tmp4_; + gboolean _tmp5_; + _tmp3_ = NULL; +#line 291 "track.vala" + if ((_tmp5_ = pos >= model_clip_get_end (_tmp4_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i)), _g_object_unref0 (_tmp4_), _tmp5_)) { +#line 1676 "track.c" + ModelClip* _tmp6_; +#line 291 "track.vala" + _tmp3_ = (_tmp6_ = NULL, _g_object_unref0 (_tmp3_), _tmp6_); +#line 1680 "track.c" + } else { + ModelClip* _tmp7_; + _tmp3_ = (_tmp7_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i), _g_object_unref0 (_tmp3_), _tmp7_); + } + result = _tmp3_; +#line 291 "track.vala" + return result; +#line 1688 "track.c" + } + } + } + } + result = NULL; +#line 292 "track.vala" + return result; +#line 1696 "track.c" +} + + +#line 295 "track.vala" +gint64 model_track_get_length (ModelTrack* self) { +#line 1702 "track.c" + gint64 result = 0LL; + gint64 _tmp0_ = 0LL; +#line 295 "track.vala" + g_return_val_if_fail (MODEL_IS_TRACK (self), 0LL); +#line 296 "track.vala" + if (gee_collection_get_size (GEE_COLLECTION (self->clips)) == 0) { +#line 296 "track.vala" + _tmp0_ = (gint64) 0; +#line 1711 "track.c" + } else { + ModelClip* _tmp2_; + ModelClip* _tmp1_; +#line 296 "track.vala" + _tmp0_ = model_clip_get_start (_tmp1_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), gee_collection_get_size (GEE_COLLECTION (self->clips)) - 1)) + model_clip_get_duration (_tmp2_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), gee_collection_get_size (GEE_COLLECTION (self->clips)) - 1)); +#line 1717 "track.c" + _g_object_unref0 (_tmp2_); + _g_object_unref0 (_tmp1_); + } + result = _tmp0_; +#line 296 "track.vala" + return result; +#line 1724 "track.c" +} + + +#line 299 "track.vala" +void _model_track_append_at_time (ModelTrack* self, ModelClip* c, gint64 time, gboolean select) { +#line 299 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 299 "track.vala" + g_return_if_fail (MODEL_IS_CLIP (c)); +#line 300 "track.vala" + model_track_add (self, c, time, select); +#line 1736 "track.c" +} + + +#line 303 "track.vala" +void model_track_append_at_time (ModelTrack* self, ModelClip* c, gint64 time, gboolean select) { +#line 1742 "track.c" + ModelCommand* command; +#line 303 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 303 "track.vala" + g_return_if_fail (MODEL_IS_CLIP (c)); +#line 304 "track.vala" + command = MODEL_COMMAND (model_clip_command_new (MODEL_CLIP_COMMAND_ACTION_APPEND, self, c, time, select)); +#line 305 "track.vala" + model_project_do_command (self->project, command); +#line 1752 "track.c" + _model_command_unref0 (command); +} + + +#line 308 "track.vala" +void model_track_delete_clip (ModelTrack* self, ModelClip* clip) { +#line 1759 "track.c" + ModelCommand* clip_command; +#line 308 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 308 "track.vala" + g_return_if_fail (MODEL_IS_CLIP (clip)); +#line 309 "track.vala" + clip_command = MODEL_COMMAND (model_clip_command_new (MODEL_CLIP_COMMAND_ACTION_DELETE, self, clip, model_clip_get_start (clip), FALSE)); +#line 311 "track.vala" + model_project_do_command (self->project, clip_command); +#line 1769 "track.c" + _model_command_unref0 (clip_command); +} + + +#line 314 "track.vala" +void _model_track_delete_clip (ModelTrack* self, ModelClip* clip) { +#line 1776 "track.c" + gint index; + ModelClip* _tmp0_; +#line 314 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 314 "track.vala" + g_return_if_fail (MODEL_IS_CLIP (clip)); +#line 315 "track.vala" + index = model_track_get_clip_index (self, clip); +#line 316 "track.vala" + g_assert (index != (-1)); +#line 317 "track.vala" + _tmp0_ = (ModelClip*) gee_abstract_list_remove_at (GEE_ABSTRACT_LIST (self->clips), index); +#line 1789 "track.c" + _g_object_unref0 (_tmp0_); +#line 319 "track.vala" + g_signal_emit_by_name (clip, "removed", clip); +#line 320 "track.vala" + g_signal_emit_by_name (self, "clip-removed", clip); +#line 1795 "track.c" +} + + +#line 323 "track.vala" +void model_track_delete_gap (ModelTrack* self, ModelGap* g) { +#line 323 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 323 "track.vala" + g_return_if_fail (MODEL_IS_GAP (g)); +#line 324 "track.vala" + model_project_reseek (self->project); +#line 1807 "track.c" +} + + +#line 327 "track.vala" +void model_track_remove_clip_from_array (ModelTrack* self, ModelClip* pos) { +#line 327 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 327 "track.vala" + g_return_if_fail (MODEL_IS_CLIP (pos)); +#line 328 "track.vala" + gee_abstract_collection_remove (GEE_ABSTRACT_COLLECTION (self->clips), pos); +#line 1819 "track.c" +} + + +#line 263 "track.vala" +static void _model_track_on_clip_updated_model_clip_updated (ModelClip* _sender, ModelClip* clip, gpointer self) { +#line 1825 "track.c" + model_track_on_clip_updated (self, clip); +} + + +#line 331 "track.vala" +static void model_track_insert_clip_into_array (ModelTrack* self, ModelClip* c, gint pos) { +#line 331 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 331 "track.vala" + g_return_if_fail (MODEL_IS_CLIP (c)); +#line 332 "track.vala" + g_signal_connect_object (c, "updated", (GCallback) _model_track_on_clip_updated_model_clip_updated, self, 0); +#line 333 "track.vala" + gee_abstract_list_insert (GEE_ABSTRACT_LIST (self->clips), pos, c); +#line 1840 "track.c" +} + + +#line 336 "track.vala" +void model_track_delete_all_clips (ModelTrack* self) { +#line 1846 "track.c" + guint size; +#line 336 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 337 "track.vala" + size = (guint) gee_collection_get_size (GEE_COLLECTION (self->clips)); +#line 1852 "track.c" + { + gint i; +#line 338 "track.vala" + i = 0; +#line 1857 "track.c" + { + gboolean _tmp0_; +#line 338 "track.vala" + _tmp0_ = TRUE; +#line 338 "track.vala" + while (TRUE) { +#line 1864 "track.c" + ModelClip* _tmp1_; +#line 338 "track.vala" + if (!_tmp0_) { +#line 338 "track.vala" + i++; +#line 1870 "track.c" + } +#line 338 "track.vala" + _tmp0_ = FALSE; +#line 338 "track.vala" + if (!(i < size)) { +#line 338 "track.vala" + break; +#line 1878 "track.c" + } +#line 339 "track.vala" + model_track_delete_clip (self, _tmp1_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), 0)); +#line 1882 "track.c" + _g_object_unref0 (_tmp1_); + } + } + } +#line 341 "track.vala" + view_media_engine_go (self->project->media_engine, (gint64) 0); +#line 1889 "track.c" +} + + +#line 344 "track.vala" +void model_track_revert_to_original (ModelTrack* self, ModelClip* clip) { +#line 1895 "track.c" + ModelCommand* command; +#line 344 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 344 "track.vala" + g_return_if_fail (MODEL_IS_CLIP (clip)); +#line 345 "track.vala" + command = MODEL_COMMAND (model_clip_revert_command_new (self, clip)); +#line 346 "track.vala" + model_project_do_command (self->project, command); +#line 1905 "track.c" + _model_command_unref0 (command); +} + + +#line 349 "track.vala" +void _model_track_revert_to_original (ModelTrack* self, ModelClip* c) { +#line 1912 "track.c" + gint index; +#line 349 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 349 "track.vala" + g_return_if_fail (MODEL_IS_CLIP (c)); +#line 350 "track.vala" + index = model_track_get_clip_index (self, c); +#line 351 "track.vala" + if (index == (-1)) { +#line 352 "track.vala" + g_error ("track.vala:352: revert_to_original: Clip not in track array!"); +#line 1924 "track.c" + } +#line 354 "track.vala" + model_clip_set_media_start_duration (c, (gint64) 0, model_clip_file_get_length (c->clipfile)); +#line 356 "track.vala" + view_media_engine_go (self->project->media_engine, model_clip_get_start (c)); +#line 1930 "track.c" +} + + +#line 359 "track.vala" +gboolean model_track_are_contiguous_clips (ModelTrack* self, gint64 position) { +#line 1936 "track.c" + gboolean result = FALSE; + ModelClip* right_clip; + ModelClip* left_clip; + gboolean _tmp0_ = FALSE; + gboolean _tmp1_ = FALSE; + gboolean _tmp2_ = FALSE; + gboolean _tmp3_ = FALSE; +#line 359 "track.vala" + g_return_val_if_fail (MODEL_IS_TRACK (self), FALSE); +#line 360 "track.vala" + right_clip = model_track_get_clip_by_position (self, position + 1); +#line 361 "track.vala" + left_clip = model_track_get_clip_by_position (self, position - 1); +#line 363 "track.vala" + if (left_clip != NULL) { +#line 363 "track.vala" + _tmp3_ = right_clip != NULL; +#line 1954 "track.c" + } else { +#line 363 "track.vala" + _tmp3_ = FALSE; +#line 1958 "track.c" + } +#line 363 "track.vala" + if (_tmp3_) { +#line 364 "track.vala" + _tmp2_ = left_clip != right_clip; +#line 1964 "track.c" + } else { +#line 363 "track.vala" + _tmp2_ = FALSE; +#line 1968 "track.c" + } +#line 363 "track.vala" + if (_tmp2_) { +#line 365 "track.vala" + _tmp1_ = left_clip->clipfile == right_clip->clipfile; +#line 1974 "track.c" + } else { +#line 363 "track.vala" + _tmp1_ = FALSE; +#line 1978 "track.c" + } +#line 363 "track.vala" + if (_tmp1_) { +#line 366 "track.vala" + _tmp0_ = model_clip_get_end (left_clip) == model_clip_get_start (right_clip); +#line 1984 "track.c" + } else { +#line 363 "track.vala" + _tmp0_ = FALSE; +#line 1988 "track.c" + } + result = _tmp0_; + _g_object_unref0 (right_clip); + _g_object_unref0 (left_clip); +#line 363 "track.vala" + return result; +#line 1995 "track.c" +} + + +#line 369 "track.vala" +void model_track_split_at (ModelTrack* self, gint64 position) { +#line 2001 "track.c" + ModelCommand* command; +#line 369 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 370 "track.vala" + command = MODEL_COMMAND (model_clip_split_command_new (MODEL_CLIP_SPLIT_COMMAND_ACTION_SPLIT, self, position)); +#line 371 "track.vala" + model_project_do_command (self->project, command); +#line 2009 "track.c" + _model_command_unref0 (command); +} + + +#line 374 "track.vala" +void _model_track_split_at (ModelTrack* self, gint64 position) { +#line 2016 "track.c" + ModelClip* c; + ModelClip* cn; +#line 374 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 375 "track.vala" + c = model_track_get_clip_by_position (self, position); +#line 376 "track.vala" + if (c == NULL) { +#line 2025 "track.c" + _g_object_unref0 (c); +#line 377 "track.vala" + return; +#line 2029 "track.c" + } +#line 379 "track.vala" + cn = model_clip_new (c->clipfile, c->type, c->name, position, (position - model_clip_get_start (c)) + model_clip_get_media_start (c), (model_clip_get_start (c) + model_clip_get_duration (c)) - position, FALSE); +#line 383 "track.vala" + model_clip_set_duration (c, position - model_clip_get_start (c)); +#line 385 "track.vala" + model_track_add (self, cn, position, FALSE); +#line 2037 "track.c" + _g_object_unref0 (c); + _g_object_unref0 (cn); +} + + +#line 388 "track.vala" +void model_track_join (ModelTrack* self, gint64 position) { +#line 2045 "track.c" + ModelCommand* command; +#line 388 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 389 "track.vala" + command = MODEL_COMMAND (model_clip_split_command_new (MODEL_CLIP_SPLIT_COMMAND_ACTION_JOIN, self, position)); +#line 390 "track.vala" + model_project_do_command (self->project, command); +#line 2053 "track.c" + _model_command_unref0 (command); +} + + +#line 393 "track.vala" +void _model_track_join (ModelTrack* self, gint64 position) { +#line 393 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 394 "track.vala" + g_assert (model_track_are_contiguous_clips (self, position)); +#line 395 "track.vala" + if (model_track_are_contiguous_clips (self, position)) { +#line 2066 "track.c" + ModelClip* right_clip; + gint right_clip_index; + gint left_clip_index; + ModelClip* left_clip; +#line 396 "track.vala" + right_clip = model_track_get_clip_by_position (self, position + 1); +#line 397 "track.vala" + g_assert (right_clip != NULL); +#line 399 "track.vala" + right_clip_index = model_track_get_clip_index (self, right_clip); +#line 400 "track.vala" + g_assert (right_clip_index > 0); +#line 402 "track.vala" + left_clip_index = right_clip_index - 1; +#line 403 "track.vala" + left_clip = model_track_get_clip (self, left_clip_index); +#line 404 "track.vala" + g_assert (left_clip != NULL); +#line 405 "track.vala" + model_clip_set_duration (left_clip, model_clip_get_end (right_clip) - model_clip_get_start (left_clip)); +#line 406 "track.vala" + _model_track_delete_clip (self, right_clip); +#line 2089 "track.c" + _g_object_unref0 (right_clip); + _g_object_unref0 (left_clip); + } +} + + +#line 410 "track.vala" +void model_track_trim (ModelTrack* self, ModelClip* clip, gint64 delta, GdkWindowEdge edge) { +#line 2098 "track.c" + ModelCommand* command; +#line 410 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 410 "track.vala" + g_return_if_fail (MODEL_IS_CLIP (clip)); +#line 411 "track.vala" + command = MODEL_COMMAND (model_clip_trim_command_new (self, clip, delta, edge)); +#line 412 "track.vala" + model_project_do_command (self->project, command); +#line 2108 "track.c" + _model_command_unref0 (command); +} + + +#line 415 "track.vala" +void _model_track_trim (ModelTrack* self, ModelClip* clip, gint64 delta, GdkWindowEdge edge) { +#line 415 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 415 "track.vala" + g_return_if_fail (MODEL_IS_CLIP (clip)); +#line 416 "track.vala" + model_clip_trim (clip, delta, edge); +#line 417 "track.vala" + model_track_do_clip_overwrite (self, clip); +#line 2123 "track.c" +} + + +#line 420 "track.vala" +gint64 model_track_previous_edit (ModelTrack* self, gint64 pos) { +#line 2129 "track.c" + gint64 result = 0LL; +#line 420 "track.vala" + g_return_val_if_fail (MODEL_IS_TRACK (self), 0LL); +#line 2133 "track.c" + { + gint i; +#line 421 "track.vala" + i = gee_collection_get_size (GEE_COLLECTION (self->clips)) - 1; +#line 2138 "track.c" + { + gboolean _tmp0_; +#line 421 "track.vala" + _tmp0_ = TRUE; +#line 421 "track.vala" + while (TRUE) { +#line 2145 "track.c" + ModelClip* c; +#line 421 "track.vala" + if (!_tmp0_) { +#line 421 "track.vala" + i = i - 1; +#line 2151 "track.c" + } +#line 421 "track.vala" + _tmp0_ = FALSE; +#line 421 "track.vala" + if (!(i >= 0)) { +#line 421 "track.vala" + break; +#line 2159 "track.c" + } + c = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i); +#line 423 "track.vala" + if (model_clip_get_end (c) < pos) { +#line 2164 "track.c" + result = model_clip_get_end (c); + _g_object_unref0 (c); +#line 424 "track.vala" + return result; +#line 2169 "track.c" + } +#line 425 "track.vala" + if (model_clip_get_start (c) < pos) { +#line 2173 "track.c" + result = model_clip_get_start (c); + _g_object_unref0 (c); +#line 426 "track.vala" + return result; +#line 2178 "track.c" + } + _g_object_unref0 (c); + } + } + } + result = (gint64) 0; +#line 428 "track.vala" + return result; +#line 2187 "track.c" +} + + +#line 431 "track.vala" +gint64 model_track_next_edit (ModelTrack* self, gint64 pos) { +#line 2193 "track.c" + gint64 result = 0LL; +#line 431 "track.vala" + g_return_val_if_fail (MODEL_IS_TRACK (self), 0LL); +#line 2197 "track.c" + { + GeeIterator* _c_it; + _c_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (self->clips)); +#line 432 "track.vala" + while (TRUE) { +#line 2203 "track.c" + ModelClip* c; +#line 432 "track.vala" + if (!gee_iterator_next (_c_it)) { +#line 432 "track.vala" + break; +#line 2209 "track.c" + } +#line 432 "track.vala" + c = (ModelClip*) gee_iterator_get (_c_it); +#line 433 "track.vala" + if (model_clip_get_start (c) > pos) { +#line 2215 "track.c" + result = model_clip_get_start (c); + _g_object_unref0 (c); + _g_object_unref0 (_c_it); +#line 434 "track.vala" + return result; +#line 2221 "track.c" + } else { +#line 435 "track.vala" + if (model_clip_get_end (c) > pos) { +#line 2225 "track.c" + result = model_clip_get_end (c); + _g_object_unref0 (c); + _g_object_unref0 (_c_it); +#line 436 "track.vala" + return result; +#line 2231 "track.c" + } + } + _g_object_unref0 (c); + } + _g_object_unref0 (_c_it); + } + result = model_track_get_length (self); +#line 437 "track.vala" + return result; +#line 2241 "track.c" +} + + +#line 440 "track.vala" +static void model_track_real_write_attributes (ModelTrack* self, FILE* f) { +#line 2247 "track.c" + char* _tmp1_; + char* _tmp0_; +#line 440 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 440 "track.vala" + g_return_if_fail (f != NULL); +#line 441 "track.vala" + fprintf (f, "type=\"%s\" name=\"%s\" ", _tmp0_ = model_track_name (self), _tmp1_ = model_track_get_display_name (self)); +#line 2256 "track.c" + _g_free0 (_tmp1_); + _g_free0 (_tmp0_); +} + + +#line 440 "track.vala" +void model_track_write_attributes (ModelTrack* self, FILE* f) { +#line 440 "track.vala" + MODEL_TRACK_GET_CLASS (self)->write_attributes (self, f); +#line 2266 "track.c" +} + + +#line 444 "track.vala" +void model_track_save (ModelTrack* self, FILE* f) { +#line 444 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 444 "track.vala" + g_return_if_fail (f != NULL); +#line 445 "track.vala" + fprintf (f, " \n"); +#line 2282 "track.c" + { + gint i; +#line 448 "track.vala" + i = 0; +#line 2287 "track.c" + { + gboolean _tmp0_; +#line 448 "track.vala" + _tmp0_ = TRUE; +#line 448 "track.vala" + while (TRUE) { +#line 2294 "track.c" + ModelClip* _tmp2_; + ModelClip* _tmp1_; +#line 448 "track.vala" + if (!_tmp0_) { +#line 448 "track.vala" + i++; +#line 2301 "track.c" + } +#line 448 "track.vala" + _tmp0_ = FALSE; +#line 448 "track.vala" + if (!(i < gee_collection_get_size (GEE_COLLECTION (self->clips)))) { +#line 448 "track.vala" + break; +#line 2309 "track.c" + } +#line 449 "track.vala" + model_clip_save (_tmp1_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i), f, model_project_get_clipfile_index (self->project, (_tmp2_ = (ModelClip*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->clips), i))->clipfile)); +#line 2313 "track.c" + _g_object_unref0 (_tmp2_); + _g_object_unref0 (_tmp1_); + } + } + } +#line 450 "track.vala" + fputs (" \n", f); +#line 2321 "track.c" +} + + +#line 453 "track.vala" +char* model_track_get_display_name (ModelTrack* self) { +#line 2327 "track.c" + char* result = NULL; +#line 453 "track.vala" + g_return_val_if_fail (MODEL_IS_TRACK (self), NULL); +#line 2331 "track.c" + result = g_strdup (self->display_name); +#line 454 "track.vala" + return result; +#line 2335 "track.c" +} + + +#line 457 "track.vala" +void model_track_set_display_name (ModelTrack* self, const char* new_display_name) { +#line 457 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 457 "track.vala" + g_return_if_fail (new_display_name != NULL); +#line 458 "track.vala" + if (_vala_strcmp0 (self->display_name, new_display_name) != 0) { +#line 2347 "track.c" + char* _tmp0_; +#line 459 "track.vala" + self->display_name = (_tmp0_ = g_strdup (new_display_name), _g_free0 (self->display_name), _tmp0_); +#line 460 "track.vala" + g_signal_emit_by_name (self, "track-renamed", self); +#line 2353 "track.c" + } +} + + +#line 464 "track.vala" +void model_track_set_selected (ModelTrack* self, gboolean is_selected) { +#line 464 "track.vala" + g_return_if_fail (MODEL_IS_TRACK (self)); +#line 465 "track.vala" + if (self->priv->is_selected != is_selected) { +#line 466 "track.vala" + self->priv->is_selected = is_selected; +#line 467 "track.vala" + g_signal_emit_by_name (self, "track-selection-changed", self); +#line 2368 "track.c" + } +} + + +#line 471 "track.vala" +gboolean model_track_get_is_selected (ModelTrack* self) { +#line 2375 "track.c" + gboolean result = FALSE; +#line 471 "track.vala" + g_return_val_if_fail (MODEL_IS_TRACK (self), FALSE); +#line 2379 "track.c" + result = self->priv->is_selected; +#line 472 "track.vala" + return result; +#line 2383 "track.c" +} + + +static void model_track_class_init (ModelTrackClass * klass) { + model_track_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ModelTrackPrivate)); + MODEL_TRACK_CLASS (klass)->name = model_track_real_name; + MODEL_TRACK_CLASS (klass)->media_type = model_track_real_media_type; + MODEL_TRACK_CLASS (klass)->check = model_track_real_check; + MODEL_TRACK_CLASS (klass)->on_clip_updated = model_track_real_on_clip_updated; + MODEL_TRACK_CLASS (klass)->write_attributes = model_track_real_write_attributes; + G_OBJECT_CLASS (klass)->finalize = model_track_finalize; + g_signal_new ("clip_added", MODEL_TYPE_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__OBJECT_BOOLEAN, G_TYPE_NONE, 2, MODEL_TYPE_CLIP, G_TYPE_BOOLEAN); + g_signal_new ("clip_removed", MODEL_TYPE_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_CLIP); + g_signal_new ("track_renamed", MODEL_TYPE_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_TRACK); + g_signal_new ("track_selection_changed", MODEL_TYPE_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_TRACK); + g_signal_new ("track_hidden", MODEL_TYPE_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_TRACK); + g_signal_new ("track_removed", MODEL_TYPE_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_TRACK); + g_signal_new ("error_occurred", MODEL_TYPE_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__STRING_STRING, G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRING); +} + + +static void model_track_instance_init (ModelTrack * self) { + self->priv = MODEL_TRACK_GET_PRIVATE (self); + self->clips = gee_array_list_new (MODEL_TYPE_CLIP, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL); +} + + +static void model_track_finalize (GObject* obj) { + ModelTrack * self; + self = MODEL_TRACK (obj); + _g_object_unref0 (self->clips); + _g_free0 (self->display_name); + G_OBJECT_CLASS (model_track_parent_class)->finalize (obj); +} + + +GType model_track_get_type (void) { + static volatile gsize model_track_type_id__volatile = 0; + if (g_once_init_enter (&model_track_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelTrackClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_track_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelTrack), 0, (GInstanceInitFunc) model_track_instance_init, NULL }; + GType model_track_type_id; + model_track_type_id = g_type_register_static (G_TYPE_OBJECT, "ModelTrack", &g_define_type_info, G_TYPE_FLAG_ABSTRACT); + g_once_init_leave (&model_track_type_id__volatile, model_track_type_id); + } + return model_track_type_id__volatile; +} + + +#line 487 "track.vala" +ModelAudioTrack* model_audio_track_construct (GType object_type, ModelProject* project, const char* display_name) { +#line 2435 "track.c" + ModelAudioTrack * self; +#line 487 "track.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (project), NULL); +#line 487 "track.vala" + g_return_val_if_fail (display_name != NULL, NULL); +#line 488 "track.vala" + self = (ModelAudioTrack*) model_track_construct (object_type, project, display_name); +#line 490 "track.vala" + model_audio_track_set_default_num_channels (self, MODEL_AUDIO_TRACK_INVALID_CHANNEL_COUNT); +#line 491 "track.vala" + _model_audio_track_set_pan (self, (double) 0); +#line 492 "track.vala" + _model_audio_track_set_volume (self, 1.0); +#line 2449 "track.c" + return self; +} + + +#line 487 "track.vala" +ModelAudioTrack* model_audio_track_new (ModelProject* project, const char* display_name) { +#line 487 "track.vala" + return model_audio_track_construct (MODEL_TYPE_AUDIO_TRACK, project, display_name); +#line 2458 "track.c" +} + + +#line 495 "track.vala" +static char* model_audio_track_real_name (ModelTrack* base) { +#line 2464 "track.c" + ModelAudioTrack * self; + char* result = NULL; + self = MODEL_AUDIO_TRACK (base); + result = g_strdup ("audio"); +#line 495 "track.vala" + return result; +#line 2471 "track.c" +} + + +#line 497 "track.vala" +static ModelMediaType model_audio_track_real_media_type (ModelTrack* base) { +#line 2477 "track.c" + ModelAudioTrack * self; + ModelMediaType result = 0; + self = MODEL_AUDIO_TRACK (base); + result = MODEL_MEDIA_TYPE_AUDIO; +#line 498 "track.vala" + return result; +#line 2484 "track.c" +} + + +#line 501 "track.vala" +static void model_audio_track_real_write_attributes (ModelTrack* base, FILE* f) { +#line 2490 "track.c" + ModelAudioTrack * self; + gint channels = 0; + gboolean _tmp0_ = FALSE; + self = MODEL_AUDIO_TRACK (base); +#line 501 "track.vala" + g_return_if_fail (f != NULL); +#line 502 "track.vala" + MODEL_TRACK_CLASS (model_audio_track_parent_class)->write_attributes (MODEL_TRACK (self), f); +#line 503 "track.vala" + fprintf (f, "volume=\"%f\" panorama=\"%f\" ", model_audio_track_get_volume (self), model_audio_track_get_pan (self)); +#line 506 "track.vala" + if (model_audio_track_get_num_channels (self, &channels)) { +#line 507 "track.vala" + _tmp0_ = channels != MODEL_AUDIO_TRACK_INVALID_CHANNEL_COUNT; +#line 2505 "track.c" + } else { +#line 506 "track.vala" + _tmp0_ = FALSE; +#line 2509 "track.c" + } +#line 506 "track.vala" + if (_tmp0_) { +#line 508 "track.vala" + fprintf (f, "channels=\"%d\" ", channels); +#line 2515 "track.c" + } +} + + +#line 511 "track.vala" +void model_audio_track_set_pan (ModelAudioTrack* self, double new_value) { +#line 2522 "track.c" + double old_value; +#line 511 "track.vala" + g_return_if_fail (MODEL_IS_AUDIO_TRACK (self)); +#line 512 "track.vala" + old_value = model_audio_track_get_pan (self); +#line 513 "track.vala" + if (!float_within (new_value - old_value, 0.05)) { +#line 2530 "track.c" + ModelParameterCommand* parameter_command; +#line 515 "track.vala" + parameter_command = model_parameter_command_new (self, MODEL_PARAMETER_PAN, new_value, old_value); +#line 516 "track.vala" + model_project_do_command (MODEL_TRACK (self)->project, MODEL_COMMAND (parameter_command)); +#line 2536 "track.c" + _model_command_unref0 (parameter_command); + } +} + + +#line 520 "track.vala" +void _model_audio_track_set_pan (ModelAudioTrack* self, double new_value) { +#line 2544 "track.c" + double old_value; +#line 520 "track.vala" + g_return_if_fail (MODEL_IS_AUDIO_TRACK (self)); +#line 521 "track.vala" + g_assert ((new_value <= 1.0) && (new_value >= (-1.0))); +#line 522 "track.vala" + old_value = model_audio_track_get_pan (self); +#line 523 "track.vala" + if (!float_within (old_value - new_value, 0.05)) { +#line 524 "track.vala" + self->priv->pan = new_value; +#line 525 "track.vala" + g_signal_emit_by_name (self, "parameter-changed", MODEL_PARAMETER_PAN, new_value); +#line 2558 "track.c" + } +} + + +#line 529 "track.vala" +double model_audio_track_get_pan (ModelAudioTrack* self) { +#line 2565 "track.c" + double result = 0.0; +#line 529 "track.vala" + g_return_val_if_fail (MODEL_IS_AUDIO_TRACK (self), 0.0); +#line 2569 "track.c" + result = self->priv->pan; +#line 530 "track.vala" + return result; +#line 2573 "track.c" +} + + +#line 533 "track.vala" +void model_audio_track_set_volume (ModelAudioTrack* self, double new_volume) { +#line 2579 "track.c" + double old_volume; +#line 533 "track.vala" + g_return_if_fail (MODEL_IS_AUDIO_TRACK (self)); +#line 534 "track.vala" + old_volume = model_audio_track_get_volume (self); +#line 535 "track.vala" + if (!float_within (old_volume - new_volume, 0.005)) { +#line 2587 "track.c" + ModelParameterCommand* parameter_command; +#line 537 "track.vala" + parameter_command = model_parameter_command_new (self, MODEL_PARAMETER_VOLUME, new_volume, old_volume); +#line 538 "track.vala" + model_project_do_command (MODEL_TRACK (self)->project, MODEL_COMMAND (parameter_command)); +#line 2593 "track.c" + _model_command_unref0 (parameter_command); + } +} + + +#line 542 "track.vala" +void _model_audio_track_set_volume (ModelAudioTrack* self, double new_volume) { +#line 2601 "track.c" + double old_volume; +#line 542 "track.vala" + g_return_if_fail (MODEL_IS_AUDIO_TRACK (self)); +#line 543 "track.vala" + g_assert ((new_volume >= 0.0) && (new_volume <= 10.0)); +#line 544 "track.vala" + old_volume = model_audio_track_get_volume (self); +#line 545 "track.vala" + if (!float_within (old_volume - new_volume, 0.005)) { +#line 546 "track.vala" + self->priv->volume = new_volume; +#line 547 "track.vala" + g_signal_emit_by_name (self, "parameter-changed", MODEL_PARAMETER_VOLUME, new_volume); +#line 2615 "track.c" + } +} + + +#line 551 "track.vala" +double model_audio_track_get_volume (ModelAudioTrack* self) { +#line 2622 "track.c" + double result = 0.0; +#line 551 "track.vala" + g_return_val_if_fail (MODEL_IS_AUDIO_TRACK (self), 0.0); +#line 2626 "track.c" + result = self->priv->volume; +#line 552 "track.vala" + return result; +#line 2630 "track.c" +} + + +#line 555 "track.vala" +void model_audio_track_set_default_num_channels (ModelAudioTrack* self, gint num) { +#line 555 "track.vala" + g_return_if_fail (MODEL_IS_AUDIO_TRACK (self)); +#line 556 "track.vala" + self->priv->default_num_channels = num; +#line 2640 "track.c" +} + + +#line 559 "track.vala" +gboolean model_audio_track_get_num_channels (ModelAudioTrack* self, gint* num) { +#line 2646 "track.c" + gboolean result = FALSE; +#line 559 "track.vala" + g_return_val_if_fail (MODEL_IS_AUDIO_TRACK (self), FALSE); +#line 560 "track.vala" + if (gee_collection_get_size (GEE_COLLECTION (MODEL_TRACK (self)->clips)) == 0) { +#line 2652 "track.c" + result = FALSE; +#line 561 "track.vala" + return result; +#line 2656 "track.c" + } + { + GeeIterator* _c_it; + _c_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (MODEL_TRACK (self)->clips)); +#line 563 "track.vala" + while (TRUE) { +#line 2663 "track.c" + ModelClip* c; +#line 563 "track.vala" + if (!gee_iterator_next (_c_it)) { +#line 563 "track.vala" + break; +#line 2669 "track.c" + } +#line 563 "track.vala" + c = (ModelClip*) gee_iterator_get (_c_it); +#line 564 "track.vala" + if (model_clip_file_is_online (c->clipfile)) { +#line 2675 "track.c" + gboolean can; +#line 565 "track.vala" + can = model_clip_file_get_num_channels (c->clipfile, num); +#line 566 "track.vala" + g_assert (can); +#line 2681 "track.c" + result = can; + _g_object_unref0 (c); + _g_object_unref0 (_c_it); +#line 568 "track.vala" + return result; +#line 2687 "track.c" + } + _g_object_unref0 (c); + } + _g_object_unref0 (_c_it); + } +#line 572 "track.vala" + if (self->priv->default_num_channels == MODEL_AUDIO_TRACK_INVALID_CHANNEL_COUNT) { +#line 2695 "track.c" + result = FALSE; +#line 573 "track.vala" + return result; +#line 2699 "track.c" + } +#line 575 "track.vala" + *num = self->priv->default_num_channels; +#line 2703 "track.c" + result = TRUE; +#line 576 "track.vala" + return result; +#line 2707 "track.c" +} + + +#line 579 "track.vala" +static gboolean model_audio_track_real_check (ModelTrack* base, ModelClip* clip) { +#line 2713 "track.c" + ModelAudioTrack * self; + gboolean result = FALSE; + gboolean good; + gint number_of_channels = 0; + self = MODEL_AUDIO_TRACK (base); +#line 579 "track.vala" + g_return_val_if_fail (MODEL_IS_CLIP (clip), FALSE); +#line 580 "track.vala" + if (!model_clip_file_is_online (clip->clipfile)) { +#line 2723 "track.c" + result = TRUE; +#line 581 "track.vala" + return result; +#line 2727 "track.c" + } +#line 584 "track.vala" + if (gee_collection_get_size (GEE_COLLECTION (MODEL_TRACK (self)->clips)) == 0) { +#line 2731 "track.c" + gint number_of_channels; +#line 585 "track.vala" + number_of_channels = 0; +#line 586 "track.vala" + if (model_clip_file_get_num_channels (clip->clipfile, &number_of_channels)) { +#line 587 "track.vala" + g_signal_emit_by_name (self, "channel-count-changed", number_of_channels); +#line 2739 "track.c" + } + result = TRUE; +#line 589 "track.vala" + return result; +#line 2744 "track.c" + } +#line 592 "track.vala" + good = FALSE; +#line 594 "track.vala" + if (model_clip_file_get_num_channels (clip->clipfile, &number_of_channels)) { +#line 2750 "track.c" + gint track_channel_count = 0; +#line 596 "track.vala" + if (model_audio_track_get_num_channels (self, &track_channel_count)) { +#line 597 "track.vala" + good = track_channel_count == number_of_channels; +#line 2756 "track.c" + } + } +#line 601 "track.vala" + if (!good) { +#line 2761 "track.c" + const char* _tmp0_; + char* sub_error; + _tmp0_ = NULL; +#line 602 "track.vala" + if (number_of_channels == 1) { +#line 603 "track.vala" + _tmp0_ = "Mono clips cannot go on stereo tracks."; +#line 2769 "track.c" + } else { +#line 604 "track.vala" + _tmp0_ = "Stereo clips cannot go on mono tracks."; +#line 2773 "track.c" + } +#line 602 "track.vala" + sub_error = g_strdup (_tmp0_); +#line 605 "track.vala" + g_signal_emit_by_name (MODEL_TRACK (self), "error-occurred", "Cannot add clip to track", sub_error); +#line 2779 "track.c" + _g_free0 (sub_error); + } + result = good; +#line 607 "track.vala" + return result; +#line 2785 "track.c" +} + + +#line 610 "track.vala" +void model_audio_track_on_level_changed (ModelAudioTrack* self, double level_left, double level_right) { +#line 610 "track.vala" + g_return_if_fail (MODEL_IS_AUDIO_TRACK (self)); +#line 611 "track.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_level_changed"); +#line 612 "track.vala" + g_signal_emit_by_name (self, "level-changed", level_left, level_right); +#line 2797 "track.c" +} + + +#line 615 "track.vala" +static void model_audio_track_real_on_clip_updated (ModelTrack* base, ModelClip* clip) { +#line 2803 "track.c" + ModelAudioTrack * self; + self = MODEL_AUDIO_TRACK (base); +#line 615 "track.vala" + g_return_if_fail (MODEL_IS_CLIP (clip)); +#line 616 "track.vala" + if (model_clip_file_is_online (clip->clipfile)) { +#line 2810 "track.c" + gint number_of_channels; +#line 617 "track.vala" + number_of_channels = 0; +#line 618 "track.vala" + if (model_audio_track_get_num_channels (self, &number_of_channels)) { +#line 619 "track.vala" + g_signal_emit_by_name (self, "channel-count-changed", number_of_channels); +#line 2818 "track.c" + } + } +} + + +static void model_audio_track_class_init (ModelAudioTrackClass * klass) { + model_audio_track_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ModelAudioTrackPrivate)); + MODEL_TRACK_CLASS (klass)->name = model_audio_track_real_name; + MODEL_TRACK_CLASS (klass)->media_type = model_audio_track_real_media_type; + MODEL_TRACK_CLASS (klass)->write_attributes = model_audio_track_real_write_attributes; + MODEL_TRACK_CLASS (klass)->check = model_audio_track_real_check; + MODEL_TRACK_CLASS (klass)->on_clip_updated = model_audio_track_real_on_clip_updated; + G_OBJECT_CLASS (klass)->finalize = model_audio_track_finalize; + g_signal_new ("parameter_changed", MODEL_TYPE_AUDIO_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__ENUM_DOUBLE, G_TYPE_NONE, 2, MODEL_TYPE_PARAMETER, G_TYPE_DOUBLE); + g_signal_new ("level_changed", MODEL_TYPE_AUDIO_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__DOUBLE_DOUBLE, G_TYPE_NONE, 2, G_TYPE_DOUBLE, G_TYPE_DOUBLE); + g_signal_new ("channel_count_changed", MODEL_TYPE_AUDIO_TRACK, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT); +} + + +static void model_audio_track_instance_init (ModelAudioTrack * self) { + self->priv = MODEL_AUDIO_TRACK_GET_PRIVATE (self); +} + + +static void model_audio_track_finalize (GObject* obj) { + ModelAudioTrack * self; + self = MODEL_AUDIO_TRACK (obj); + G_OBJECT_CLASS (model_audio_track_parent_class)->finalize (obj); +} + + +GType model_audio_track_get_type (void) { + static volatile gsize model_audio_track_type_id__volatile = 0; + if (g_once_init_enter (&model_audio_track_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelAudioTrackClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_audio_track_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelAudioTrack), 0, (GInstanceInitFunc) model_audio_track_instance_init, NULL }; + GType model_audio_track_type_id; + model_audio_track_type_id = g_type_register_static (MODEL_TYPE_TRACK, "ModelAudioTrack", &g_define_type_info, 0); + g_once_init_leave (&model_audio_track_type_id__volatile, model_audio_track_type_id); + } + return model_audio_track_type_id__volatile; +} + + +static int _vala_strcmp0 (const char * str1, const char * str2) { + if (str1 == NULL) { + return -(str1 != str2); + } + if (str2 == NULL) { + return str1 != str2; + } + return strcmp (str1, str2); +} + + + +static void g_cclosure_user_marshal_VOID__OBJECT_BOOLEAN (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) { + typedef void (*GMarshalFunc_VOID__OBJECT_BOOLEAN) (gpointer data1, gpointer arg_1, gboolean arg_2, gpointer data2); + register GMarshalFunc_VOID__OBJECT_BOOLEAN callback; + register GCClosure * cc; + register gpointer data1, data2; + cc = (GCClosure *) closure; + g_return_if_fail (n_param_values == 3); + if (G_CCLOSURE_SWAP_DATA (closure)) { + data1 = closure->data; + data2 = param_values->data[0].v_pointer; + } else { + data1 = param_values->data[0].v_pointer; + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__OBJECT_BOOLEAN) (marshal_data ? marshal_data : cc->callback); + callback (data1, g_value_get_object (param_values + 1), g_value_get_boolean (param_values + 2), data2); +} + + +static void g_cclosure_user_marshal_VOID__STRING_STRING (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) { + typedef void (*GMarshalFunc_VOID__STRING_STRING) (gpointer data1, const char* arg_1, const char* arg_2, gpointer data2); + register GMarshalFunc_VOID__STRING_STRING callback; + register GCClosure * cc; + register gpointer data1, data2; + cc = (GCClosure *) closure; + g_return_if_fail (n_param_values == 3); + if (G_CCLOSURE_SWAP_DATA (closure)) { + data1 = closure->data; + data2 = param_values->data[0].v_pointer; + } else { + data1 = param_values->data[0].v_pointer; + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__STRING_STRING) (marshal_data ? marshal_data : cc->callback); + callback (data1, g_value_get_string (param_values + 1), g_value_get_string (param_values + 2), data2); +} + + +static void g_cclosure_user_marshal_VOID__ENUM_DOUBLE (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) { + typedef void (*GMarshalFunc_VOID__ENUM_DOUBLE) (gpointer data1, gint arg_1, double arg_2, gpointer data2); + register GMarshalFunc_VOID__ENUM_DOUBLE callback; + register GCClosure * cc; + register gpointer data1, data2; + cc = (GCClosure *) closure; + g_return_if_fail (n_param_values == 3); + if (G_CCLOSURE_SWAP_DATA (closure)) { + data1 = closure->data; + data2 = param_values->data[0].v_pointer; + } else { + data1 = param_values->data[0].v_pointer; + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__ENUM_DOUBLE) (marshal_data ? marshal_data : cc->callback); + callback (data1, g_value_get_enum (param_values + 1), g_value_get_double (param_values + 2), data2); +} + + +static void g_cclosure_user_marshal_VOID__DOUBLE_DOUBLE (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) { + typedef void (*GMarshalFunc_VOID__DOUBLE_DOUBLE) (gpointer data1, double arg_1, double arg_2, gpointer data2); + register GMarshalFunc_VOID__DOUBLE_DOUBLE callback; + register GCClosure * cc; + register gpointer data1, data2; + cc = (GCClosure *) closure; + g_return_if_fail (n_param_values == 3); + if (G_CCLOSURE_SWAP_DATA (closure)) { + data1 = closure->data; + data2 = param_values->data[0].v_pointer; + } else { + data1 = param_values->data[0].v_pointer; + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__DOUBLE_DOUBLE) (marshal_data ? marshal_data : cc->callback); + callback (data1, g_value_get_double (param_values + 1), g_value_get_double (param_values + 2), data2); +} + + + diff --git a/src/marina/marina/track.o b/src/marina/marina/track.o new file mode 100644 index 0000000..b695006 Binary files /dev/null and b/src/marina/marina/track.o differ diff --git a/src/marina/marina/ui_clip.c b/src/marina/marina/ui_clip.c new file mode 100644 index 0000000..02ec30d --- /dev/null +++ b/src/marina/marina/ui_clip.c @@ -0,0 +1,1334 @@ +/* ui_clip.c generated by valac, the Vala compiler + * generated from ui_clip.vala, do not modify */ + +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#define TYPE_GAP_VIEW (gap_view_get_type ()) +#define GAP_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_GAP_VIEW, GapView)) +#define GAP_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_GAP_VIEW, GapViewClass)) +#define IS_GAP_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_GAP_VIEW)) +#define IS_GAP_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_GAP_VIEW)) +#define GAP_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_GAP_VIEW, GapViewClass)) + +typedef struct _GapView GapView; +typedef struct _GapViewClass GapViewClass; +typedef struct _GapViewPrivate GapViewPrivate; + +#define MODEL_TYPE_GAP (model_gap_get_type ()) +#define MODEL_GAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_GAP, ModelGap)) +#define MODEL_GAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_GAP, ModelGapClass)) +#define MODEL_IS_GAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_GAP)) +#define MODEL_IS_GAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_GAP)) +#define MODEL_GAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_GAP, ModelGapClass)) + +typedef struct _ModelGap ModelGap; +typedef struct _ModelGapClass ModelGapClass; +#define _model_gap_unref0(var) ((var == NULL) ? NULL : (var = (model_gap_unref (var), NULL))) + +#define TYPE_CLIP_VIEW (clip_view_get_type ()) +#define CLIP_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CLIP_VIEW, ClipView)) +#define CLIP_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CLIP_VIEW, ClipViewClass)) +#define IS_CLIP_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CLIP_VIEW)) +#define IS_CLIP_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CLIP_VIEW)) +#define CLIP_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CLIP_VIEW, ClipViewClass)) + +typedef struct _ClipView ClipView; +typedef struct _ClipViewClass ClipViewClass; +typedef struct _ClipViewPrivate ClipViewPrivate; + +#define MODEL_TYPE_CLIP (model_clip_get_type ()) +#define MODEL_CLIP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP, ModelClip)) +#define MODEL_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP, ModelClipClass)) +#define MODEL_IS_CLIP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP)) +#define MODEL_IS_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP)) +#define MODEL_CLIP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP, ModelClipClass)) + +typedef struct _ModelClip ModelClip; +typedef struct _ModelClipClass ModelClipClass; + +#define MODEL_TYPE_TIME_SYSTEM (model_time_system_get_type ()) +#define MODEL_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TIME_SYSTEM, ModelTimeSystem)) +#define MODEL_IS_TIME_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TIME_SYSTEM)) +#define MODEL_TIME_SYSTEM_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MODEL_TYPE_TIME_SYSTEM, ModelTimeSystemIface)) + +typedef struct _ModelTimeSystem ModelTimeSystem; +typedef struct _ModelTimeSystemIface ModelTimeSystemIface; + +#define TYPE_TRANSPORT_DELEGATE (transport_delegate_get_type ()) +#define TRANSPORT_DELEGATE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRANSPORT_DELEGATE, TransportDelegate)) +#define IS_TRANSPORT_DELEGATE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRANSPORT_DELEGATE)) +#define TRANSPORT_DELEGATE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_TRANSPORT_DELEGATE, TransportDelegateIface)) + +typedef struct _TransportDelegate TransportDelegate; +typedef struct _TransportDelegateIface TransportDelegateIface; + +#define CLIP_VIEW_TYPE_MOTION_MODE (clip_view_motion_mode_get_type ()) +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +typedef struct _ModelClipPrivate ModelClipPrivate; + +#define MODEL_TYPE_CLIP_FILE (model_clip_file_get_type ()) +#define MODEL_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFile)) +#define MODEL_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) +#define MODEL_IS_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE)) +#define MODEL_IS_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE)) +#define MODEL_CLIP_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) + +typedef struct _ModelClipFile ModelClipFile; +typedef struct _ModelClipFileClass ModelClipFileClass; + +#define MODEL_TYPE_MEDIA_TYPE (model_media_type_get_type ()) + +#define LOGGING_TYPE_FACILITY (logging_facility_get_type ()) + +#define LOGGING_TYPE_LEVEL (logging_level_get_type ()) +#define _g_free0(var) (var = (g_free (var), NULL)) + +struct _GapView { + GtkDrawingArea parent_instance; + GapViewPrivate * priv; + ModelGap* gap; +}; + +struct _GapViewClass { + GtkDrawingAreaClass parent_class; +}; + +struct _GapViewPrivate { + GdkColor fill_color; +}; + +struct _ClipView { + GtkDrawingArea parent_instance; + ClipViewPrivate * priv; + ModelClip* clip; + gint64 initial_time; + gboolean is_selected; + gint height; +}; + +struct _ClipViewClass { + GtkDrawingAreaClass parent_class; +}; + +struct _ModelTimeSystemIface { + GTypeInterface parent_iface; + void (*calculate_pixel_step) (ModelTimeSystem* self, float inc, float pixel_min, float pixel_div); + gint64 (*xpos_to_time) (ModelTimeSystem* self, gint x); + gint64 (*xsize_to_time) (ModelTimeSystem* self, gint x); + gint (*time_to_xpos) (ModelTimeSystem* self, gint64 time); + gint64 (*get_pixel_snap_time) (ModelTimeSystem* self); + gint (*time_to_xsize) (ModelTimeSystem* self, gint64 time); + float (*get_pixel_percentage) (ModelTimeSystem* self); + gint (*get_start_token) (ModelTimeSystem* self, gint xsize); + gint (*get_next_position) (ModelTimeSystem* self, gint token); + gint (*get_pixel_height) (ModelTimeSystem* self, gint token); + char* (*get_display_string) (ModelTimeSystem* self, gint token); + gint (*frame_to_xsize) (ModelTimeSystem* self, gint frame); + gint (*xsize_to_frame) (ModelTimeSystem* self, gint xsize); + char* (*get_time_string) (ModelTimeSystem* self, gint64 time); + char* (*get_time_duration) (ModelTimeSystem* self, gint64 time); +}; + +struct _TransportDelegateIface { + GTypeInterface parent_iface; + gboolean (*is_playing) (TransportDelegate* self); + gboolean (*is_recording) (TransportDelegate* self); + gboolean (*is_stopped) (TransportDelegate* self); +}; + +typedef enum { + CLIP_VIEW_MOTION_MODE_NONE, + CLIP_VIEW_MOTION_MODE_DRAGGING, + CLIP_VIEW_MOTION_MODE_LEFT_TRIM, + CLIP_VIEW_MOTION_MODE_RIGHT_TRIM +} ClipViewMotionMode; + +struct _ClipViewPrivate { + ModelTimeSystem* time_provider; + TransportDelegate* transport_delegate; + GdkColor color_black; + GdkColor color_normal; + GdkColor color_selected; + gint drag_point; + gint snap_amount; + gboolean snapped; + ClipViewMotionMode motion_mode; + gboolean button_down; + gboolean pending_selection; +}; + +typedef enum { + MODEL_MEDIA_TYPE_AUDIO, + MODEL_MEDIA_TYPE_VIDEO +} ModelMediaType; + +struct _ModelClip { + GObject parent_instance; + ModelClipPrivate * priv; + ModelClipFile* clipfile; + ModelMediaType type; + gboolean is_recording; + char* name; +}; + +struct _ModelClipClass { + GObjectClass parent_class; +}; + +typedef enum { + LOGGING_FACILITY_SIGNAL_HANDLERS, + LOGGING_FACILITY_DEVELOPER_WARNINGS, + LOGGING_FACILITY_GRAPH, + LOGGING_FACILITY_LOADING, + LOGGING_FACILITY_IMPORT, + LOGGING_FACILITY_SINGLEDECODEBIN +} LoggingFacility; + +typedef enum { + LOGGING_LEVEL_CRITICAL, + LOGGING_LEVEL_HIGH, + LOGGING_LEVEL_MEDIUM, + LOGGING_LEVEL_LOW, + LOGGING_LEVEL_INFO, + LOGGING_LEVEL_VERBOSE +} LoggingLevel; + + +static gpointer gap_view_parent_class = NULL; +extern GtkMenu* clip_view_context_menu; +GtkMenu* clip_view_context_menu = NULL; +static GdkCursor* clip_view_left_trim_cursor; +static GdkCursor* clip_view_left_trim_cursor = NULL; +static GdkCursor* clip_view_right_trim_cursor; +static GdkCursor* clip_view_right_trim_cursor = NULL; +static GdkCursor* clip_view_hand_cursor; +static GdkCursor* clip_view_hand_cursor = NULL; +static GdkCursor* clip_view_plus_cursor; +static GdkCursor* clip_view_plus_cursor = NULL; +static gpointer clip_view_parent_class = NULL; + +GType gap_view_get_type (void); +gpointer model_gap_ref (gpointer instance); +void model_gap_unref (gpointer instance); +GParamSpec* model_param_spec_gap (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_gap (GValue* value, gpointer v_object); +void model_value_take_gap (GValue* value, gpointer v_object); +gpointer model_value_get_gap (const GValue* value); +GType model_gap_get_type (void); +#define GAP_VIEW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_GAP_VIEW, GapViewPrivate)) +enum { + GAP_VIEW_DUMMY_PROPERTY +}; +ModelGap* model_gap_new (gint64 start, gint64 end); +ModelGap* model_gap_construct (GType object_type, gint64 start, gint64 end); +GapView* gap_view_new (gint64 start, gint64 length, gint width, gint height); +GapView* gap_view_construct (GType object_type, gint64 start, gint64 length, gint width, gint height); +void gap_view_remove (GapView* self); +void gap_view_unselect (GapView* self); +void draw_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height); +static gboolean gap_view_real_expose_event (GtkWidget* base, GdkEventExpose* e); +static void gap_view_finalize (GObject* obj); +GType clip_view_get_type (void); +GType model_clip_get_type (void); +GType model_time_system_get_type (void); +GType transport_delegate_get_type (void); +static GType clip_view_motion_mode_get_type (void) G_GNUC_UNUSED; +#define CLIP_VIEW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_CLIP_VIEW, ClipViewPrivate)) +enum { + CLIP_VIEW_DUMMY_PROPERTY +}; +#define CLIP_VIEW_MIN_DRAG 5 +#define CLIP_VIEW_TRIM_WIDTH 10 +#define CLIP_VIEW_SNAP_DELTA 10 +void clip_view_on_clip_moved (ClipView* self, ModelClip* clip); +static void _clip_view_on_clip_moved_model_clip_moved (ModelClip* _sender, ModelClip* clip, gpointer self); +static void clip_view_on_clip_updated (ClipView* self); +static void _clip_view_on_clip_updated_model_clip_updated (ModelClip* _sender, ModelClip* clip, gpointer self); +static void clip_view_get_clip_colors (ClipView* self); +void clip_view_adjust_size (ClipView* self, gint height); +ClipView* clip_view_new (TransportDelegate* transport_delegate, ModelClip* clip, ModelTimeSystem* time_provider, gint height); +ClipView* clip_view_construct (GType object_type, TransportDelegate* transport_delegate, ModelClip* clip, ModelTimeSystem* time_provider, gint height); +GType model_clip_file_get_type (void); +GType model_media_type_get_type (void); +gboolean model_clip_file_is_online (ModelClipFile* self); +GType logging_facility_get_type (void); +GType logging_level_get_type (void); +void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message); +gint model_time_system_time_to_xpos (ModelTimeSystem* self, gint64 time); +gint64 model_clip_get_start (ModelClip* self); +gint64 model_clip_get_duration (ModelClip* self); +void clip_view_delete_clip (ClipView* self); +gint64 model_clip_get_media_start (ModelClip* self); +gint64 model_clip_file_get_length (ModelClipFile* self); +void draw_left_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height); +void draw_right_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height); +void draw_square_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x, gint y, gint width, gint height); +void clip_view_draw (ClipView* self); +static gboolean clip_view_real_expose_event (GtkWidget* base, GdkEventExpose* event); +gboolean transport_delegate_is_stopped (TransportDelegate* self); +static gboolean clip_view_is_left_trim (ClipView* self, double x, double y); +static gboolean clip_view_is_right_trim (ClipView* self, double x, double y); +static gboolean clip_view_real_button_press_event (GtkWidget* base, GdkEventButton* event); +gint64 model_time_system_xsize_to_time (ModelTimeSystem* self, gint x); +static gboolean clip_view_real_button_release_event (GtkWidget* base, GdkEventButton* event); +void model_clip_trim (ModelClip* self, gint64 delta, GdkWindowEdge edge); +static gboolean clip_view_real_motion_notify_event (GtkWidget* base, GdkEventMotion* event); +static gboolean clip_view_is_trim_height (ClipView* self, double y); +void clip_view_select (ClipView* self); +gint model_time_system_time_to_xsize (ModelTimeSystem* self, gint64 time); +void clip_view_snap (ClipView* self, gint64 amount); +static void clip_view_finalize (GObject* obj); + + +static void g_cclosure_user_marshal_VOID__OBJECT_BOOLEAN (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data); +static void g_cclosure_user_marshal_VOID__OBJECT_INT64 (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data); +static void g_cclosure_user_marshal_VOID__OBJECT_ENUM (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data); + +#line 13 "ui_clip.vala" +GapView* gap_view_construct (GType object_type, gint64 start, gint64 length, gint width, gint height) { +#line 305 "ui_clip.c" + GapView * self; + ModelGap* _tmp0_; + self = g_object_newv (object_type, 0, NULL); +#line 15 "ui_clip.vala" + self->gap = (_tmp0_ = model_gap_new (start, start + length), _model_gap_unref0 (self->gap), _tmp0_); +#line 17 "ui_clip.vala" + gdk_color_parse ("#777", &self->priv->fill_color); +#line 19 "ui_clip.vala" + GTK_WIDGET_SET_FLAGS (GTK_WIDGET (self), GTK_NO_WINDOW); +#line 21 "ui_clip.vala" + gtk_widget_set_size_request (GTK_WIDGET (self), width, height); +#line 317 "ui_clip.c" + return self; +} + + +#line 13 "ui_clip.vala" +GapView* gap_view_new (gint64 start, gint64 length, gint width, gint height) { +#line 13 "ui_clip.vala" + return gap_view_construct (TYPE_GAP_VIEW, start, length, width, height); +#line 326 "ui_clip.c" +} + + +#line 27 "ui_clip.vala" +void gap_view_remove (GapView* self) { +#line 27 "ui_clip.vala" + g_return_if_fail (IS_GAP_VIEW (self)); +#line 28 "ui_clip.vala" + g_signal_emit_by_name (self, "removed", self); +#line 336 "ui_clip.c" +} + + +#line 31 "ui_clip.vala" +void gap_view_unselect (GapView* self) { +#line 31 "ui_clip.vala" + g_return_if_fail (IS_GAP_VIEW (self)); +#line 32 "ui_clip.vala" + g_signal_emit_by_name (self, "unselected", self); +#line 346 "ui_clip.c" +} + + +#line 35 "ui_clip.vala" +static gboolean gap_view_real_expose_event (GtkWidget* base, GdkEventExpose* e) { +#line 352 "ui_clip.c" + GapView * self; + gboolean result = FALSE; + self = GAP_VIEW (base); +#line 36 "ui_clip.vala" + draw_rounded_rectangle (GTK_WIDGET (self)->window, &self->priv->fill_color, TRUE, GTK_WIDGET (self)->allocation.x, GTK_WIDGET (self)->allocation.y, GTK_WIDGET (self)->allocation.width - 1, GTK_WIDGET (self)->allocation.height - 1); +#line 358 "ui_clip.c" + result = TRUE; +#line 38 "ui_clip.vala" + return result; +#line 362 "ui_clip.c" +} + + +static void gap_view_class_init (GapViewClass * klass) { + gap_view_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (GapViewPrivate)); + GTK_WIDGET_CLASS (klass)->expose_event = gap_view_real_expose_event; + G_OBJECT_CLASS (klass)->finalize = gap_view_finalize; + g_signal_new ("removed", TYPE_GAP_VIEW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, TYPE_GAP_VIEW); + g_signal_new ("unselected", TYPE_GAP_VIEW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, TYPE_GAP_VIEW); +} + + +static void gap_view_instance_init (GapView * self) { + self->priv = GAP_VIEW_GET_PRIVATE (self); +} + + +static void gap_view_finalize (GObject* obj) { + GapView * self; + self = GAP_VIEW (obj); + _model_gap_unref0 (self->gap); + G_OBJECT_CLASS (gap_view_parent_class)->finalize (obj); +} + + +GType gap_view_get_type (void) { + static volatile gsize gap_view_type_id__volatile = 0; + if (g_once_init_enter (&gap_view_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (GapViewClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gap_view_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GapView), 0, (GInstanceInitFunc) gap_view_instance_init, NULL }; + GType gap_view_type_id; + gap_view_type_id = g_type_register_static (GTK_TYPE_DRAWING_AREA, "GapView", &g_define_type_info, 0); + g_once_init_leave (&gap_view_type_id__volatile, gap_view_type_id); + } + return gap_view_type_id__volatile; +} + + +static GType clip_view_motion_mode_get_type (void) { + static volatile gsize clip_view_motion_mode_type_id__volatile = 0; + if (g_once_init_enter (&clip_view_motion_mode_type_id__volatile)) { + static const GEnumValue values[] = {{CLIP_VIEW_MOTION_MODE_NONE, "CLIP_VIEW_MOTION_MODE_NONE", "none"}, {CLIP_VIEW_MOTION_MODE_DRAGGING, "CLIP_VIEW_MOTION_MODE_DRAGGING", "dragging"}, {CLIP_VIEW_MOTION_MODE_LEFT_TRIM, "CLIP_VIEW_MOTION_MODE_LEFT_TRIM", "left-trim"}, {CLIP_VIEW_MOTION_MODE_RIGHT_TRIM, "CLIP_VIEW_MOTION_MODE_RIGHT_TRIM", "right-trim"}, {0, NULL, NULL}}; + GType clip_view_motion_mode_type_id; + clip_view_motion_mode_type_id = g_enum_register_static ("ClipViewMotionMode", values); + g_once_init_leave (&clip_view_motion_mode_type_id__volatile, clip_view_motion_mode_type_id); + } + return clip_view_motion_mode_type_id__volatile; +} + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 132 "ui_clip.vala" +static void _clip_view_on_clip_moved_model_clip_moved (ModelClip* _sender, ModelClip* clip, gpointer self) { +#line 420 "ui_clip.c" + clip_view_on_clip_moved (self, clip); +} + + +#line 117 "ui_clip.vala" +static void _clip_view_on_clip_updated_model_clip_updated (ModelClip* _sender, ModelClip* clip, gpointer self) { +#line 427 "ui_clip.c" + clip_view_on_clip_updated (self); +} + + +#line 86 "ui_clip.vala" +ClipView* clip_view_construct (GType object_type, TransportDelegate* transport_delegate, ModelClip* clip, ModelTimeSystem* time_provider, gint height) { +#line 434 "ui_clip.c" + ClipView * self; + TransportDelegate* _tmp0_; + ModelClip* _tmp1_; +#line 86 "ui_clip.vala" + g_return_val_if_fail (IS_TRANSPORT_DELEGATE (transport_delegate), NULL); +#line 86 "ui_clip.vala" + g_return_val_if_fail (MODEL_IS_CLIP (clip), NULL); +#line 86 "ui_clip.vala" + g_return_val_if_fail (MODEL_IS_TIME_SYSTEM (time_provider), NULL); +#line 444 "ui_clip.c" + self = g_object_newv (object_type, 0, NULL); +#line 88 "ui_clip.vala" + self->priv->transport_delegate = (_tmp0_ = _g_object_ref0 (transport_delegate), _g_object_unref0 (self->priv->transport_delegate), _tmp0_); +#line 89 "ui_clip.vala" + self->clip = (_tmp1_ = _g_object_ref0 (clip), _g_object_unref0 (self->clip), _tmp1_); +#line 90 "ui_clip.vala" + self->priv->time_provider = time_provider; +#line 91 "ui_clip.vala" + self->height = height; +#line 92 "ui_clip.vala" + self->is_selected = FALSE; +#line 94 "ui_clip.vala" + g_signal_connect_object (clip, "moved", (GCallback) _clip_view_on_clip_moved_model_clip_moved, self, 0); +#line 95 "ui_clip.vala" + g_signal_connect_object (clip, "updated", (GCallback) _clip_view_on_clip_updated_model_clip_updated, self, 0); +#line 97 "ui_clip.vala" + gdk_color_parse ("000", &self->priv->color_black); +#line 98 "ui_clip.vala" + clip_view_get_clip_colors (self); +#line 100 "ui_clip.vala" + GTK_WIDGET_SET_FLAGS (GTK_WIDGET (self), GTK_NO_WINDOW); +#line 102 "ui_clip.vala" + clip_view_adjust_size (self, height); +#line 468 "ui_clip.c" + return self; +} + + +#line 86 "ui_clip.vala" +ClipView* clip_view_new (TransportDelegate* transport_delegate, ModelClip* clip, ModelTimeSystem* time_provider, gint height) { +#line 86 "ui_clip.vala" + return clip_view_construct (TYPE_CLIP_VIEW, transport_delegate, clip, time_provider, height); +#line 477 "ui_clip.c" +} + + +#line 105 "ui_clip.vala" +static void clip_view_get_clip_colors (ClipView* self) { +#line 105 "ui_clip.vala" + g_return_if_fail (IS_CLIP_VIEW (self)); +#line 106 "ui_clip.vala" + if (model_clip_file_is_online (self->clip->clipfile)) { +#line 487 "ui_clip.c" + const char* _tmp0_; + const char* _tmp1_; + _tmp0_ = NULL; +#line 107 "ui_clip.vala" + if (self->clip->type == MODEL_MEDIA_TYPE_VIDEO) { +#line 107 "ui_clip.vala" + _tmp0_ = "#d82"; +#line 495 "ui_clip.c" + } else { +#line 107 "ui_clip.vala" + _tmp0_ = "#84a"; +#line 499 "ui_clip.c" + } +#line 107 "ui_clip.vala" + gdk_color_parse (_tmp0_, &self->priv->color_selected); +#line 503 "ui_clip.c" + _tmp1_ = NULL; +#line 109 "ui_clip.vala" + if (self->clip->type == MODEL_MEDIA_TYPE_VIDEO) { +#line 109 "ui_clip.vala" + _tmp1_ = "#da5"; +#line 509 "ui_clip.c" + } else { +#line 109 "ui_clip.vala" + _tmp1_ = "#b9d"; +#line 513 "ui_clip.c" + } +#line 109 "ui_clip.vala" + gdk_color_parse (_tmp1_, &self->priv->color_normal); +#line 517 "ui_clip.c" + } else { +#line 112 "ui_clip.vala" + gdk_color_parse ("red", &self->priv->color_selected); +#line 113 "ui_clip.vala" + gdk_color_parse ("#AA0000", &self->priv->color_normal); +#line 523 "ui_clip.c" + } +} + + +#line 117 "ui_clip.vala" +static void clip_view_on_clip_updated (ClipView* self) { +#line 117 "ui_clip.vala" + g_return_if_fail (IS_CLIP_VIEW (self)); +#line 118 "ui_clip.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_updated"); +#line 119 "ui_clip.vala" + clip_view_get_clip_colors (self); +#line 120 "ui_clip.vala" + gtk_widget_queue_draw (GTK_WIDGET (self)); +#line 538 "ui_clip.c" +} + + +#line 126 "ui_clip.vala" +void clip_view_adjust_size (ClipView* self, gint height) { +#line 544 "ui_clip.c" + gint width; +#line 126 "ui_clip.vala" + g_return_if_fail (IS_CLIP_VIEW (self)); +#line 127 "ui_clip.vala" + width = model_time_system_time_to_xpos (self->priv->time_provider, model_clip_get_start (self->clip) + model_clip_get_duration (self->clip)) - model_time_system_time_to_xpos (self->priv->time_provider, model_clip_get_start (self->clip)); +#line 129 "ui_clip.vala" + gtk_widget_set_size_request (GTK_WIDGET (self), width + 1, height); +#line 552 "ui_clip.c" +} + + +#line 132 "ui_clip.vala" +void clip_view_on_clip_moved (ClipView* self, ModelClip* clip) { +#line 132 "ui_clip.vala" + g_return_if_fail (IS_CLIP_VIEW (self)); +#line 132 "ui_clip.vala" + g_return_if_fail (MODEL_IS_CLIP (clip)); +#line 133 "ui_clip.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_clip_moved"); +#line 134 "ui_clip.vala" + clip_view_adjust_size (self, self->height); +#line 135 "ui_clip.vala" + g_signal_emit_by_name (self, "clip-moved", self); +#line 568 "ui_clip.c" +} + + +#line 138 "ui_clip.vala" +void clip_view_delete_clip (ClipView* self) { +#line 138 "ui_clip.vala" + g_return_if_fail (IS_CLIP_VIEW (self)); +#line 139 "ui_clip.vala" + g_signal_emit_by_name (self, "clip-deleted", self->clip); +#line 578 "ui_clip.c" +} + + +#line 142 "ui_clip.vala" +void clip_view_draw (ClipView* self) { +#line 584 "ui_clip.c" + GdkColor _tmp0_ = {0}; + GdkColor fill; + gboolean _tmp1_ = FALSE; + gboolean left_trimmed; + gboolean _tmp2_ = FALSE; + gboolean right_trimmed; + gboolean _tmp3_ = FALSE; + GdkGC* gc; + GdkRectangle _tmp6_ = {0}; + GdkRectangle r; + PangoLayout* layout; + gint width = 0; + gint height = 0; +#line 142 "ui_clip.vala" + g_return_if_fail (IS_CLIP_VIEW (self)); +#line 143 "ui_clip.vala" + if (self->is_selected) { +#line 143 "ui_clip.vala" + _tmp0_ = self->priv->color_selected; +#line 604 "ui_clip.c" + } else { +#line 143 "ui_clip.vala" + _tmp0_ = self->priv->color_normal; +#line 608 "ui_clip.c" + } +#line 143 "ui_clip.vala" + fill = _tmp0_; +#line 145 "ui_clip.vala" + if (model_clip_get_media_start (self->clip) != 0) { +#line 145 "ui_clip.vala" + _tmp1_ = !self->clip->is_recording; +#line 616 "ui_clip.c" + } else { +#line 145 "ui_clip.vala" + _tmp1_ = FALSE; +#line 620 "ui_clip.c" + } +#line 145 "ui_clip.vala" + left_trimmed = _tmp1_; +#line 147 "ui_clip.vala" + if (model_clip_file_is_online (self->clip->clipfile)) { +#line 148 "ui_clip.vala" + _tmp2_ = (model_clip_get_media_start (self->clip) + model_clip_get_duration (self->clip)) != model_clip_file_get_length (self->clip->clipfile); +#line 628 "ui_clip.c" + } else { +#line 148 "ui_clip.vala" + _tmp2_ = FALSE; +#line 632 "ui_clip.c" + } +#line 147 "ui_clip.vala" + right_trimmed = _tmp2_; +#line 150 "ui_clip.vala" + if (!left_trimmed) { +#line 150 "ui_clip.vala" + _tmp3_ = !right_trimmed; +#line 640 "ui_clip.c" + } else { +#line 150 "ui_clip.vala" + _tmp3_ = FALSE; +#line 644 "ui_clip.c" + } +#line 150 "ui_clip.vala" + if (_tmp3_) { +#line 151 "ui_clip.vala" + draw_rounded_rectangle (GTK_WIDGET (self)->window, &fill, TRUE, GTK_WIDGET (self)->allocation.x + 1, GTK_WIDGET (self)->allocation.y + 1, GTK_WIDGET (self)->allocation.width - 2, GTK_WIDGET (self)->allocation.height - 2); +#line 153 "ui_clip.vala" + draw_rounded_rectangle (GTK_WIDGET (self)->window, &self->priv->color_black, FALSE, GTK_WIDGET (self)->allocation.x, GTK_WIDGET (self)->allocation.y, GTK_WIDGET (self)->allocation.width - 1, GTK_WIDGET (self)->allocation.height - 1); +#line 652 "ui_clip.c" + } else { + gboolean _tmp4_ = FALSE; +#line 156 "ui_clip.vala" + if (!left_trimmed) { +#line 156 "ui_clip.vala" + _tmp4_ = right_trimmed; +#line 659 "ui_clip.c" + } else { +#line 156 "ui_clip.vala" + _tmp4_ = FALSE; +#line 663 "ui_clip.c" + } +#line 156 "ui_clip.vala" + if (_tmp4_) { +#line 157 "ui_clip.vala" + draw_left_rounded_rectangle (GTK_WIDGET (self)->window, &fill, TRUE, GTK_WIDGET (self)->allocation.x + 1, GTK_WIDGET (self)->allocation.y + 1, GTK_WIDGET (self)->allocation.width - 2, GTK_WIDGET (self)->allocation.height - 2); +#line 159 "ui_clip.vala" + draw_left_rounded_rectangle (GTK_WIDGET (self)->window, &self->priv->color_black, FALSE, GTK_WIDGET (self)->allocation.x, GTK_WIDGET (self)->allocation.y, GTK_WIDGET (self)->allocation.width - 1, GTK_WIDGET (self)->allocation.height - 1); +#line 671 "ui_clip.c" + } else { + gboolean _tmp5_ = FALSE; +#line 162 "ui_clip.vala" + if (left_trimmed) { +#line 162 "ui_clip.vala" + _tmp5_ = !right_trimmed; +#line 678 "ui_clip.c" + } else { +#line 162 "ui_clip.vala" + _tmp5_ = FALSE; +#line 682 "ui_clip.c" + } +#line 162 "ui_clip.vala" + if (_tmp5_) { +#line 163 "ui_clip.vala" + draw_right_rounded_rectangle (GTK_WIDGET (self)->window, &fill, TRUE, GTK_WIDGET (self)->allocation.x + 1, GTK_WIDGET (self)->allocation.y + 1, GTK_WIDGET (self)->allocation.width - 2, GTK_WIDGET (self)->allocation.height - 2); +#line 165 "ui_clip.vala" + draw_right_rounded_rectangle (GTK_WIDGET (self)->window, &self->priv->color_black, FALSE, GTK_WIDGET (self)->allocation.x, GTK_WIDGET (self)->allocation.y, GTK_WIDGET (self)->allocation.width - 1, GTK_WIDGET (self)->allocation.height - 1); +#line 690 "ui_clip.c" + } else { +#line 169 "ui_clip.vala" + draw_square_rectangle (GTK_WIDGET (self)->window, &fill, TRUE, GTK_WIDGET (self)->allocation.x + 1, GTK_WIDGET (self)->allocation.y + 1, GTK_WIDGET (self)->allocation.width - 2, GTK_WIDGET (self)->allocation.height - 2); +#line 171 "ui_clip.vala" + draw_square_rectangle (GTK_WIDGET (self)->window, &self->priv->color_black, FALSE, GTK_WIDGET (self)->allocation.x, GTK_WIDGET (self)->allocation.y, GTK_WIDGET (self)->allocation.width - 1, GTK_WIDGET (self)->allocation.height - 1); +#line 696 "ui_clip.c" + } + } + } +#line 175 "ui_clip.vala" + gc = gdk_gc_new (GDK_DRAWABLE (GTK_WIDGET (self)->window)); +#line 176 "ui_clip.vala" + r = (_tmp6_.x = 0, _tmp6_.y = 0, _tmp6_.width = 0, _tmp6_.height = 0, _tmp6_); +#line 179 "ui_clip.vala" + r.x = GTK_WIDGET (self)->allocation.x; +#line 180 "ui_clip.vala" + r.y = GTK_WIDGET (self)->allocation.y; +#line 181 "ui_clip.vala" + r.width = GTK_WIDGET (self)->allocation.width; +#line 182 "ui_clip.vala" + r.height = GTK_WIDGET (self)->allocation.height; +#line 184 "ui_clip.vala" + gdk_gc_set_clip_rectangle (gc, &r); +#line 714 "ui_clip.c" + layout = NULL; +#line 187 "ui_clip.vala" + if (self->clip->is_recording) { +#line 718 "ui_clip.c" + PangoLayout* _tmp7_; +#line 188 "ui_clip.vala" + layout = (_tmp7_ = gtk_widget_create_pango_layout (GTK_WIDGET (self), "Recording"), _g_object_unref0 (layout), _tmp7_); +#line 722 "ui_clip.c" + } else { +#line 189 "ui_clip.vala" + if (!model_clip_file_is_online (self->clip->clipfile)) { +#line 726 "ui_clip.c" + PangoLayout* _tmp9_; + char* _tmp8_; +#line 190 "ui_clip.vala" + layout = (_tmp9_ = gtk_widget_create_pango_layout (GTK_WIDGET (self), _tmp8_ = g_strdup_printf ("%s (Offline)", self->clip->name)), _g_object_unref0 (layout), _tmp9_); +#line 731 "ui_clip.c" + _g_free0 (_tmp8_); + } else { + PangoLayout* _tmp11_; + char* _tmp10_; +#line 193 "ui_clip.vala" + layout = (_tmp11_ = gtk_widget_create_pango_layout (GTK_WIDGET (self), _tmp10_ = g_strdup_printf ("%s", self->clip->name)), _g_object_unref0 (layout), _tmp11_); +#line 738 "ui_clip.c" + _g_free0 (_tmp10_); + } + } +#line 196 "ui_clip.vala" + pango_layout_get_pixel_size (layout, &width, &height); +#line 197 "ui_clip.vala" + gdk_draw_layout (GDK_DRAWABLE (GTK_WIDGET (self)->window), gc, GTK_WIDGET (self)->allocation.x + 10, GTK_WIDGET (self)->allocation.y + height, layout); +#line 746 "ui_clip.c" + _g_object_unref0 (gc); + _g_object_unref0 (layout); +} + + +#line 200 "ui_clip.vala" +static gboolean clip_view_real_expose_event (GtkWidget* base, GdkEventExpose* event) { +#line 754 "ui_clip.c" + ClipView * self; + gboolean result = FALSE; + self = CLIP_VIEW (base); +#line 201 "ui_clip.vala" + clip_view_draw (self); +#line 760 "ui_clip.c" + result = TRUE; +#line 202 "ui_clip.vala" + return result; +#line 764 "ui_clip.c" +} + + +#line 205 "ui_clip.vala" +static gboolean clip_view_real_button_press_event (GtkWidget* base, GdkEventButton* event) { +#line 770 "ui_clip.c" + ClipView * self; + gboolean result = FALSE; + gboolean primary_press; + gboolean extend_selection; + self = CLIP_VIEW (base); +#line 206 "ui_clip.vala" + if (!transport_delegate_is_stopped (self->priv->transport_delegate)) { +#line 778 "ui_clip.c" + result = TRUE; +#line 207 "ui_clip.vala" + return result; +#line 782 "ui_clip.c" + } +#line 210 "ui_clip.vala" + (*event).x = (*event).x - ((double) GTK_WIDGET (self)->allocation.x); +#line 211 "ui_clip.vala" + primary_press = (*event).button == 1; +#line 212 "ui_clip.vala" + if (primary_press) { +#line 213 "ui_clip.vala" + self->priv->button_down = TRUE; +#line 214 "ui_clip.vala" + self->priv->drag_point = (gint) (*event).x; +#line 215 "ui_clip.vala" + self->priv->snap_amount = 0; +#line 216 "ui_clip.vala" + self->priv->snapped = FALSE; +#line 798 "ui_clip.c" + } +#line 219 "ui_clip.vala" + extend_selection = ((*event).state & GDK_CONTROL_MASK) != 0; +#line 223 "ui_clip.vala" + if (clip_view_is_left_trim (self, (*event).x, (*event).y)) { +#line 224 "ui_clip.vala" + g_signal_emit_by_name (self, "selection-request", self, FALSE); +#line 225 "ui_clip.vala" + if (primary_press) { +#line 226 "ui_clip.vala" + g_signal_emit_by_name (self, "trim-begin", self, GDK_WINDOW_EDGE_WEST); +#line 227 "ui_clip.vala" + self->priv->motion_mode = CLIP_VIEW_MOTION_MODE_LEFT_TRIM; +#line 812 "ui_clip.c" + } + } else { +#line 229 "ui_clip.vala" + if (clip_view_is_right_trim (self, (*event).x, (*event).y)) { +#line 230 "ui_clip.vala" + g_signal_emit_by_name (self, "selection-request", self, FALSE); +#line 231 "ui_clip.vala" + if (primary_press) { +#line 232 "ui_clip.vala" + g_signal_emit_by_name (self, "trim-begin", self, GDK_WINDOW_EDGE_EAST); +#line 233 "ui_clip.vala" + self->priv->motion_mode = CLIP_VIEW_MOTION_MODE_RIGHT_TRIM; +#line 825 "ui_clip.c" + } + } else { +#line 236 "ui_clip.vala" + if (!self->is_selected) { +#line 237 "ui_clip.vala" + self->priv->pending_selection = FALSE; +#line 238 "ui_clip.vala" + g_signal_emit_by_name (self, "selection-request", self, extend_selection); +#line 834 "ui_clip.c" + } else { +#line 240 "ui_clip.vala" + self->priv->pending_selection = TRUE; +#line 838 "ui_clip.c" + } + } + } +#line 244 "ui_clip.vala" + if ((*event).button == 3) { +#line 245 "ui_clip.vala" + gtk_menu_shell_select_first (GTK_MENU_SHELL (clip_view_context_menu), TRUE); +#line 246 "ui_clip.vala" + gtk_menu_popup (clip_view_context_menu, NULL, NULL, NULL, NULL, (*event).button, (*event).time); +#line 848 "ui_clip.c" + } else { +#line 248 "ui_clip.vala" + gtk_menu_popdown (clip_view_context_menu); +#line 852 "ui_clip.c" + } + result = TRUE; +#line 251 "ui_clip.vala" + return result; +#line 857 "ui_clip.c" +} + + +#line 254 "ui_clip.vala" +static gboolean clip_view_real_button_release_event (GtkWidget* base, GdkEventButton* event) { +#line 863 "ui_clip.c" + ClipView * self; + gboolean result = FALSE; + self = CLIP_VIEW (base); +#line 255 "ui_clip.vala" + if (!transport_delegate_is_stopped (self->priv->transport_delegate)) { +#line 869 "ui_clip.c" + result = TRUE; +#line 256 "ui_clip.vala" + return result; +#line 873 "ui_clip.c" + } +#line 259 "ui_clip.vala" + (*event).x = (*event).x - ((double) GTK_WIDGET (self)->allocation.x); +#line 260 "ui_clip.vala" + self->priv->button_down = FALSE; +#line 261 "ui_clip.vala" + if ((*event).button == 1) { +#line 262 "ui_clip.vala" + switch (self->priv->motion_mode) { +#line 883 "ui_clip.c" + case CLIP_VIEW_MOTION_MODE_NONE: + { + { +#line 264 "ui_clip.vala" + if (self->priv->pending_selection) { +#line 265 "ui_clip.vala" + g_signal_emit_by_name (self, "selection-request", self, TRUE); +#line 891 "ui_clip.c" + } + } +#line 268 "ui_clip.vala" + break; +#line 896 "ui_clip.c" + } + case CLIP_VIEW_MOTION_MODE_DRAGGING: + { + { + gint64 delta; +#line 270 "ui_clip.vala" + delta = model_time_system_xsize_to_time (self->priv->time_provider, ((gint) (*event).x) - self->priv->drag_point); +#line 271 "ui_clip.vala" + if (self->priv->motion_mode == CLIP_VIEW_MOTION_MODE_DRAGGING) { +#line 272 "ui_clip.vala" + g_signal_emit_by_name (self, "move-commit", self, delta); +#line 908 "ui_clip.c" + } + } +#line 275 "ui_clip.vala" + break; +#line 913 "ui_clip.c" + } + case CLIP_VIEW_MOTION_MODE_LEFT_TRIM: + { +#line 277 "ui_clip.vala" + g_signal_emit_by_name (self, "trim-commit", self, GDK_WINDOW_EDGE_WEST); +#line 278 "ui_clip.vala" + break; +#line 921 "ui_clip.c" + } + case CLIP_VIEW_MOTION_MODE_RIGHT_TRIM: + { +#line 280 "ui_clip.vala" + g_signal_emit_by_name (self, "trim-commit", self, GDK_WINDOW_EDGE_EAST); +#line 281 "ui_clip.vala" + break; +#line 929 "ui_clip.c" + } + } + } +#line 284 "ui_clip.vala" + self->priv->motion_mode = CLIP_VIEW_MOTION_MODE_NONE; +#line 935 "ui_clip.c" + result = TRUE; +#line 285 "ui_clip.vala" + return result; +#line 939 "ui_clip.c" +} + + +#line 288 "ui_clip.vala" +static gboolean clip_view_real_motion_notify_event (GtkWidget* base, GdkEventMotion* event) { +#line 945 "ui_clip.c" + ClipView * self; + gboolean result = FALSE; + gint delta_pixels; + gint64 delta_time; + self = CLIP_VIEW (base); +#line 289 "ui_clip.vala" + if (!transport_delegate_is_stopped (self->priv->transport_delegate)) { +#line 953 "ui_clip.c" + result = TRUE; +#line 290 "ui_clip.vala" + return result; +#line 957 "ui_clip.c" + } +#line 293 "ui_clip.vala" + (*event).x = (*event).x - ((double) GTK_WIDGET (self)->allocation.x); +#line 294 "ui_clip.vala" + delta_pixels = ((gint) ((*event).x - self->priv->drag_point)) - self->priv->snap_amount; +#line 295 "ui_clip.vala" + if (self->priv->snapped) { +#line 296 "ui_clip.vala" + self->priv->snap_amount = self->priv->snap_amount + delta_pixels; +#line 297 "ui_clip.vala" + if (abs (self->priv->snap_amount) < CLIP_VIEW_SNAP_DELTA) { +#line 969 "ui_clip.c" + result = TRUE; +#line 298 "ui_clip.vala" + return result; +#line 973 "ui_clip.c" + } +#line 300 "ui_clip.vala" + delta_pixels = delta_pixels + self->priv->snap_amount; +#line 301 "ui_clip.vala" + self->priv->snap_amount = 0; +#line 302 "ui_clip.vala" + self->priv->snapped = FALSE; +#line 981 "ui_clip.c" + } +#line 305 "ui_clip.vala" + delta_time = model_time_system_xsize_to_time (self->priv->time_provider, delta_pixels); +#line 307 "ui_clip.vala" + switch (self->priv->motion_mode) { +#line 987 "ui_clip.c" + case CLIP_VIEW_MOTION_MODE_NONE: + { + gboolean _tmp0_ = FALSE; +#line 309 "ui_clip.vala" + if (!self->priv->button_down) { +#line 309 "ui_clip.vala" + _tmp0_ = clip_view_is_left_trim (self, (*event).x, (*event).y); +#line 995 "ui_clip.c" + } else { +#line 309 "ui_clip.vala" + _tmp0_ = FALSE; +#line 999 "ui_clip.c" + } +#line 309 "ui_clip.vala" + if (_tmp0_) { +#line 310 "ui_clip.vala" + gdk_window_set_cursor (GTK_WIDGET (self)->window, clip_view_left_trim_cursor); +#line 1005 "ui_clip.c" + } else { + gboolean _tmp1_ = FALSE; +#line 311 "ui_clip.vala" + if (!self->priv->button_down) { +#line 311 "ui_clip.vala" + _tmp1_ = clip_view_is_right_trim (self, (*event).x, (*event).y); +#line 1012 "ui_clip.c" + } else { +#line 311 "ui_clip.vala" + _tmp1_ = FALSE; +#line 1016 "ui_clip.c" + } +#line 311 "ui_clip.vala" + if (_tmp1_) { +#line 312 "ui_clip.vala" + gdk_window_set_cursor (GTK_WIDGET (self)->window, clip_view_right_trim_cursor); +#line 1022 "ui_clip.c" + } else { + gboolean _tmp2_ = FALSE; +#line 313 "ui_clip.vala" + if (self->is_selected) { +#line 313 "ui_clip.vala" + _tmp2_ = self->priv->button_down; +#line 1029 "ui_clip.c" + } else { +#line 313 "ui_clip.vala" + _tmp2_ = FALSE; +#line 1033 "ui_clip.c" + } +#line 313 "ui_clip.vala" + if (_tmp2_) { +#line 314 "ui_clip.vala" + if (abs (delta_pixels) > CLIP_VIEW_MIN_DRAG) { +#line 1039 "ui_clip.c" + gboolean do_copy; +#line 315 "ui_clip.vala" + do_copy = ((*event).state & GDK_CONTROL_MASK) != 0; +#line 316 "ui_clip.vala" + if (do_copy) { +#line 317 "ui_clip.vala" + gdk_window_set_cursor (GTK_WIDGET (self)->window, clip_view_plus_cursor); +#line 1047 "ui_clip.c" + } else { +#line 319 "ui_clip.vala" + gdk_window_set_cursor (GTK_WIDGET (self)->window, clip_view_hand_cursor); +#line 1051 "ui_clip.c" + } +#line 321 "ui_clip.vala" + self->priv->motion_mode = CLIP_VIEW_MOTION_MODE_DRAGGING; +#line 322 "ui_clip.vala" + g_signal_emit_by_name (self, "move-begin", self, do_copy); +#line 1057 "ui_clip.c" + } + } else { +#line 325 "ui_clip.vala" + gdk_window_set_cursor (GTK_WIDGET (self)->window, NULL); +#line 1062 "ui_clip.c" + } + } + } +#line 327 "ui_clip.vala" + break; +#line 1068 "ui_clip.c" + } + case CLIP_VIEW_MOTION_MODE_RIGHT_TRIM: + case CLIP_VIEW_MOTION_MODE_LEFT_TRIM: + { +#line 330 "ui_clip.vala" + if (self->priv->button_down) { +#line 331 "ui_clip.vala" + if (self->priv->motion_mode == CLIP_VIEW_MOTION_MODE_LEFT_TRIM) { +#line 332 "ui_clip.vala" + model_clip_trim (self->clip, delta_time, GDK_WINDOW_EDGE_WEST); +#line 1079 "ui_clip.c" + } else { + gint64 duration; +#line 334 "ui_clip.vala" + duration = model_clip_get_duration (self->clip); +#line 335 "ui_clip.vala" + model_clip_trim (self->clip, delta_time, GDK_WINDOW_EDGE_EAST); +#line 336 "ui_clip.vala" + if (duration != model_clip_get_duration (self->clip)) { +#line 337 "ui_clip.vala" + self->priv->drag_point = self->priv->drag_point + ((gint) delta_pixels); +#line 1090 "ui_clip.c" + } + } + } + result = TRUE; +#line 341 "ui_clip.vala" + return result; +#line 1097 "ui_clip.c" + } + case CLIP_VIEW_MOTION_MODE_DRAGGING: + { +#line 343 "ui_clip.vala" + g_signal_emit_by_name (self, "move-request", self, delta_time); +#line 1103 "ui_clip.c" + result = TRUE; +#line 344 "ui_clip.vala" + return result; +#line 1107 "ui_clip.c" + } + } + result = FALSE; +#line 346 "ui_clip.vala" + return result; +#line 1113 "ui_clip.c" +} + + +#line 349 "ui_clip.vala" +static gboolean clip_view_is_trim_height (ClipView* self, double y) { +#line 1119 "ui_clip.c" + gboolean result = FALSE; +#line 349 "ui_clip.vala" + g_return_val_if_fail (IS_CLIP_VIEW (self), FALSE); +#line 1123 "ui_clip.c" + result = (y - GTK_WIDGET (self)->allocation.y) > (GTK_WIDGET (self)->allocation.height / 2); +#line 350 "ui_clip.vala" + return result; +#line 1127 "ui_clip.c" +} + + +#line 353 "ui_clip.vala" +static gboolean clip_view_is_left_trim (ClipView* self, double x, double y) { +#line 1133 "ui_clip.c" + gboolean result = FALSE; + gboolean _tmp0_ = FALSE; + gboolean _tmp1_ = FALSE; +#line 353 "ui_clip.vala" + g_return_val_if_fail (IS_CLIP_VIEW (self), FALSE); +#line 354 "ui_clip.vala" + if (clip_view_is_trim_height (self, y)) { +#line 354 "ui_clip.vala" + _tmp1_ = x > 0; +#line 1143 "ui_clip.c" + } else { +#line 354 "ui_clip.vala" + _tmp1_ = FALSE; +#line 1147 "ui_clip.c" + } +#line 354 "ui_clip.vala" + if (_tmp1_) { +#line 354 "ui_clip.vala" + _tmp0_ = x < CLIP_VIEW_TRIM_WIDTH; +#line 1153 "ui_clip.c" + } else { +#line 354 "ui_clip.vala" + _tmp0_ = FALSE; +#line 1157 "ui_clip.c" + } + result = _tmp0_; +#line 354 "ui_clip.vala" + return result; +#line 1162 "ui_clip.c" +} + + +#line 357 "ui_clip.vala" +static gboolean clip_view_is_right_trim (ClipView* self, double x, double y) { +#line 1168 "ui_clip.c" + gboolean result = FALSE; + gboolean _tmp0_ = FALSE; + gboolean _tmp1_ = FALSE; +#line 357 "ui_clip.vala" + g_return_val_if_fail (IS_CLIP_VIEW (self), FALSE); +#line 358 "ui_clip.vala" + if (clip_view_is_trim_height (self, y)) { +#line 358 "ui_clip.vala" + _tmp1_ = x > (GTK_WIDGET (self)->allocation.width - CLIP_VIEW_TRIM_WIDTH); +#line 1178 "ui_clip.c" + } else { +#line 358 "ui_clip.vala" + _tmp1_ = FALSE; +#line 1182 "ui_clip.c" + } +#line 358 "ui_clip.vala" + if (_tmp1_) { +#line 359 "ui_clip.vala" + _tmp0_ = x < GTK_WIDGET (self)->allocation.width; +#line 1188 "ui_clip.c" + } else { +#line 358 "ui_clip.vala" + _tmp0_ = FALSE; +#line 1192 "ui_clip.c" + } + result = _tmp0_; +#line 358 "ui_clip.vala" + return result; +#line 1197 "ui_clip.c" +} + + +#line 362 "ui_clip.vala" +void clip_view_select (ClipView* self) { +#line 362 "ui_clip.vala" + g_return_if_fail (IS_CLIP_VIEW (self)); +#line 363 "ui_clip.vala" + if (!self->is_selected) { +#line 364 "ui_clip.vala" + g_signal_emit_by_name (self, "selection-request", self, TRUE); +#line 1209 "ui_clip.c" + } +} + + +#line 368 "ui_clip.vala" +void clip_view_snap (ClipView* self, gint64 amount) { +#line 368 "ui_clip.vala" + g_return_if_fail (IS_CLIP_VIEW (self)); +#line 369 "ui_clip.vala" + self->priv->snap_amount = model_time_system_time_to_xsize (self->priv->time_provider, amount); +#line 370 "ui_clip.vala" + self->priv->snapped = TRUE; +#line 1222 "ui_clip.c" +} + + +static void clip_view_class_init (ClipViewClass * klass) { + clip_view_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ClipViewPrivate)); + GTK_WIDGET_CLASS (klass)->expose_event = clip_view_real_expose_event; + GTK_WIDGET_CLASS (klass)->button_press_event = clip_view_real_button_press_event; + GTK_WIDGET_CLASS (klass)->button_release_event = clip_view_real_button_release_event; + GTK_WIDGET_CLASS (klass)->motion_notify_event = clip_view_real_motion_notify_event; + G_OBJECT_CLASS (klass)->finalize = clip_view_finalize; + g_signal_new ("clip_deleted", TYPE_CLIP_VIEW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, MODEL_TYPE_CLIP); + g_signal_new ("clip_moved", TYPE_CLIP_VIEW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, TYPE_CLIP_VIEW); + g_signal_new ("selection_request", TYPE_CLIP_VIEW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__OBJECT_BOOLEAN, G_TYPE_NONE, 2, TYPE_CLIP_VIEW, G_TYPE_BOOLEAN); + g_signal_new ("move_request", TYPE_CLIP_VIEW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__OBJECT_INT64, G_TYPE_NONE, 2, TYPE_CLIP_VIEW, G_TYPE_INT64); + g_signal_new ("move_commit", TYPE_CLIP_VIEW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__OBJECT_INT64, G_TYPE_NONE, 2, TYPE_CLIP_VIEW, G_TYPE_INT64); + g_signal_new ("move_begin", TYPE_CLIP_VIEW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__OBJECT_BOOLEAN, G_TYPE_NONE, 2, TYPE_CLIP_VIEW, G_TYPE_BOOLEAN); + g_signal_new ("trim_begin", TYPE_CLIP_VIEW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__OBJECT_ENUM, G_TYPE_NONE, 2, TYPE_CLIP_VIEW, GDK_TYPE_WINDOW_EDGE); + g_signal_new ("trim_commit", TYPE_CLIP_VIEW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__OBJECT_ENUM, G_TYPE_NONE, 2, TYPE_CLIP_VIEW, GDK_TYPE_WINDOW_EDGE); + clip_view_left_trim_cursor = gdk_cursor_new (GDK_LEFT_SIDE); + clip_view_right_trim_cursor = gdk_cursor_new (GDK_RIGHT_SIDE); + clip_view_hand_cursor = gdk_cursor_new_from_name (gdk_display_get_default (), "dnd-none"); + clip_view_plus_cursor = gdk_cursor_new_from_name (gdk_display_get_default (), "dnd-copy"); +} + + +static void clip_view_instance_init (ClipView * self) { + self->priv = CLIP_VIEW_GET_PRIVATE (self); + self->priv->motion_mode = CLIP_VIEW_MOTION_MODE_NONE; + self->priv->button_down = FALSE; +} + + +static void clip_view_finalize (GObject* obj) { + ClipView * self; + self = CLIP_VIEW (obj); + _g_object_unref0 (self->clip); + _g_object_unref0 (self->priv->transport_delegate); + G_OBJECT_CLASS (clip_view_parent_class)->finalize (obj); +} + + +GType clip_view_get_type (void) { + static volatile gsize clip_view_type_id__volatile = 0; + if (g_once_init_enter (&clip_view_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ClipViewClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) clip_view_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ClipView), 0, (GInstanceInitFunc) clip_view_instance_init, NULL }; + GType clip_view_type_id; + clip_view_type_id = g_type_register_static (GTK_TYPE_DRAWING_AREA, "ClipView", &g_define_type_info, 0); + g_once_init_leave (&clip_view_type_id__volatile, clip_view_type_id); + } + return clip_view_type_id__volatile; +} + + + +static void g_cclosure_user_marshal_VOID__OBJECT_BOOLEAN (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) { + typedef void (*GMarshalFunc_VOID__OBJECT_BOOLEAN) (gpointer data1, gpointer arg_1, gboolean arg_2, gpointer data2); + register GMarshalFunc_VOID__OBJECT_BOOLEAN callback; + register GCClosure * cc; + register gpointer data1, data2; + cc = (GCClosure *) closure; + g_return_if_fail (n_param_values == 3); + if (G_CCLOSURE_SWAP_DATA (closure)) { + data1 = closure->data; + data2 = param_values->data[0].v_pointer; + } else { + data1 = param_values->data[0].v_pointer; + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__OBJECT_BOOLEAN) (marshal_data ? marshal_data : cc->callback); + callback (data1, g_value_get_object (param_values + 1), g_value_get_boolean (param_values + 2), data2); +} + + +static void g_cclosure_user_marshal_VOID__OBJECT_INT64 (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) { + typedef void (*GMarshalFunc_VOID__OBJECT_INT64) (gpointer data1, gpointer arg_1, gint64 arg_2, gpointer data2); + register GMarshalFunc_VOID__OBJECT_INT64 callback; + register GCClosure * cc; + register gpointer data1, data2; + cc = (GCClosure *) closure; + g_return_if_fail (n_param_values == 3); + if (G_CCLOSURE_SWAP_DATA (closure)) { + data1 = closure->data; + data2 = param_values->data[0].v_pointer; + } else { + data1 = param_values->data[0].v_pointer; + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__OBJECT_INT64) (marshal_data ? marshal_data : cc->callback); + callback (data1, g_value_get_object (param_values + 1), g_value_get_int64 (param_values + 2), data2); +} + + +static void g_cclosure_user_marshal_VOID__OBJECT_ENUM (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) { + typedef void (*GMarshalFunc_VOID__OBJECT_ENUM) (gpointer data1, gpointer arg_1, gint arg_2, gpointer data2); + register GMarshalFunc_VOID__OBJECT_ENUM callback; + register GCClosure * cc; + register gpointer data1, data2; + cc = (GCClosure *) closure; + g_return_if_fail (n_param_values == 3); + if (G_CCLOSURE_SWAP_DATA (closure)) { + data1 = closure->data; + data2 = param_values->data[0].v_pointer; + } else { + data1 = param_values->data[0].v_pointer; + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__OBJECT_ENUM) (marshal_data ? marshal_data : cc->callback); + callback (data1, g_value_get_object (param_values + 1), g_value_get_enum (param_values + 2), data2); +} + + + diff --git a/src/marina/marina/ui_clip.o b/src/marina/marina/ui_clip.o new file mode 100644 index 0000000..ff9d8e7 Binary files /dev/null and b/src/marina/marina/ui_clip.o differ diff --git a/src/marina/marina/util.c b/src/marina/marina/util.c new file mode 100644 index 0000000..9a506ac --- /dev/null +++ b/src/marina/marina/util.c @@ -0,0 +1,1673 @@ +/* util.c generated by valac, the Vala compiler + * generated from util.vala, do not modify */ + +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define _g_free0(var) (var = (g_free (var), NULL)) + +#define TYPE_FRACTION (fraction_get_type ()) +typedef struct _Fraction Fraction; + +#define TYPE_TIME_CODE (time_code_get_type ()) +typedef struct _TimeCode TimeCode; +#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL))) +#define _g_checksum_free0(var) ((var == NULL) ? NULL : (var = (g_checksum_free (var), NULL))) +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +#define _cairo_destroy0(var) ((var == NULL) ? NULL : (var = (cairo_destroy (var), NULL))) +#define _gst_object_unref0(var) ((var == NULL) ? NULL : (var = (gst_object_unref (var), NULL))) + +typedef enum { + MEDIA_ERROR_MISSING_PLUGIN +} MediaError; +#define MEDIA_ERROR media_error_quark () +struct _Fraction { + gint numerator; + gint denominator; +}; + +struct _TimeCode { + gint hour; + gint minute; + gint second; + gint frame; + gboolean drop_code; +}; + +typedef enum { + GDK_Control_L, + GDK_Control_R, + GDK_Down, + GDK_equal, + GDK_Escape, + GDK_KP_Add, + GDK_KP_Enter, + GDK_KP_Subtract, + GDK_Left, + GDK_minus, + GDK_plus, + GDK_Return, + GDK_Right, + GDK_Shift_L, + GDK_Shift_R, + GDK_underscore, + GDK_Up +} KeySyms; + + +extern gboolean debug_enabled; +gboolean debug_enabled = FALSE; +extern GdkModifierType GDK_SHIFT_ALT_CONTROL_MASK; +GdkModifierType GDK_SHIFT_ALT_CONTROL_MASK = (GDK_SHIFT_MASK | GDK_MOD1_MASK) | GDK_CONTROL_MASK; + +GQuark media_error_quark (void); +float float_abs (float f); +gboolean float_within (double f, double epsilon); +gint sign (gint x); +gint stricmp (const char* str1, const char* str2); +char** copy_array (char** source, int source_length1, int* result_length1); +void print_debug (const char* text); +GType fraction_get_type (void); +Fraction* fraction_dup (const Fraction* self); +void fraction_free (Fraction* self); +void fraction_init (Fraction *self, gint numerator, gint denominator); +void fraction_init_from_string (Fraction *self, const char* s); +gboolean fraction_equal (Fraction *self, Fraction* f); +gint fraction_nearest_int (Fraction *self); +char* fraction_to_string (Fraction *self); +GType time_code_get_type (void); +TimeCode* time_code_dup (const TimeCode* self); +void time_code_free (TimeCode* self); +void time_code_get_from_length (TimeCode *self, gint64 length); +char* time_code_to_string (TimeCode *self); +gboolean time_in_range (gint64 time, gint64 center, gint64 delta); +char* isolate_filename (const char* path); +char* get_file_extension (const char* path); +char* append_extension (const char* path, const char* extension); +gboolean version_at_least (const char* v, const char* w); +gboolean get_file_md5_checksum (const char* filename, char** checksum); +void save_file_md5_checksum (const char* filename, const char* checksum); +gboolean md5_checksum_on_file (const char* filename, char** checksum); +void parse_color (const char* color, GdkColor* result); +GtkWidget* get_widget (GtkUIManager* manager, const char* name); +#define LINE_WIDTH 1.0 +#define RADIUS 15.0 +#define ANTIALIAS CAIRO_ANTIALIAS_DEFAULT +void draw_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height); +void draw_right_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height); +void draw_left_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height); +void draw_square_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x, gint y, gint width, gint height); +gboolean is_drop_frame_rate (Fraction* r); +gint64 frame_to_time_with_rate (gint frame, Fraction* rate); +gint time_to_frame_with_rate (gint64 time, Fraction* rate); +void frame_to_time (gint frame, Fraction* rate, TimeCode* result); +char* frame_to_string (gint frame, Fraction* rate); +void breakup_time (gint64 time, gint* hours, gint* minutes, double* seconds); +char* time_to_HHMMSS (gint64 time); +char* time_to_string (gint64 time); +GstElement* make_element_with_name (const char* element_name, const char* display_name, GError** error); +GstElement* make_element (const char* name, GError** error); +static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func); +static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func); +static gint _vala_array_length (gpointer array); +static int _vala_strcmp0 (const char * str1, const char * str2); + +const GtkTargetEntry drag_target_entries[1] = {{"text/uri-list", (guint) 0, (guint) 0}}; + + +GQuark media_error_quark (void) { + return g_quark_from_static_string ("media_error-quark"); +} + + +#line 12 "util.vala" +float float_abs (float f) { +#line 141 "util.c" + float result = 0.0F; +#line 13 "util.vala" + if (f < 0.0f) { +#line 145 "util.c" + result = -f; +#line 14 "util.vala" + return result; +#line 149 "util.c" + } + result = f; +#line 15 "util.vala" + return result; +#line 154 "util.c" +} + + +#line 18 "util.vala" +gboolean float_within (double f, double epsilon) { +#line 160 "util.c" + gboolean result = FALSE; + result = float_abs ((float) f) < epsilon; +#line 19 "util.vala" + return result; +#line 165 "util.c" +} + + +#line 22 "util.vala" +gint sign (gint x) { +#line 171 "util.c" + gint result = 0; + gint _tmp0_ = 0; +#line 23 "util.vala" + if (x == 0) { +#line 176 "util.c" + result = 0; +#line 24 "util.vala" + return result; +#line 180 "util.c" + } +#line 25 "util.vala" + if (x < 0) { +#line 25 "util.vala" + _tmp0_ = -1; +#line 186 "util.c" + } else { +#line 25 "util.vala" + _tmp0_ = 1; +#line 190 "util.c" + } + result = _tmp0_; +#line 25 "util.vala" + return result; +#line 195 "util.c" +} + + +#line 28 "util.vala" +gint stricmp (const char* str1, const char* str2) { +#line 201 "util.c" + gint result = 0; + char* temp_str1; + char* temp_str2; +#line 28 "util.vala" + g_return_val_if_fail (str1 != NULL, 0); +#line 28 "util.vala" + g_return_val_if_fail (str2 != NULL, 0); +#line 29 "util.vala" + temp_str1 = g_utf8_casefold (str1, (gssize) (-1)); +#line 30 "util.vala" + temp_str2 = g_utf8_casefold (str2, (gssize) (-1)); +#line 213 "util.c" + result = g_utf8_collate (temp_str1, temp_str2); + _g_free0 (temp_str1); + _g_free0 (temp_str2); +#line 32 "util.vala" + return result; +#line 219 "util.c" +} + + +#line 36 "util.vala" +char** copy_array (char** source, int source_length1, int* result_length1) { +#line 225 "util.c" + char** result = NULL; + char** _tmp0_; + gint _destination_size_; + gint destination_length1; + char** destination; + gint i; + char** _tmp2_; + destination = (_tmp0_ = g_new0 (char*, source_length1 + 1), destination_length1 = source_length1, _destination_size_ = destination_length1, _tmp0_); +#line 38 "util.vala" + i = 0; +#line 236 "util.c" + { + char** item_collection; + int item_collection_length1; + int item_it; +#line 39 "util.vala" + item_collection = source; +#line 243 "util.c" + item_collection_length1 = source_length1; + for (item_it = 0; item_it < source_length1; item_it = item_it + 1) { + char* item; + item = g_strdup (item_collection[item_it]); + { + char* _tmp1_; +#line 40 "util.vala" + destination[i] = (_tmp1_ = g_strdup (item), _g_free0 (destination[i]), _tmp1_); +#line 41 "util.vala" + i = i + 1; +#line 254 "util.c" + _g_free0 (item); + } + } + } + result = (_tmp2_ = destination, *result_length1 = destination_length1, _tmp2_); +#line 43 "util.vala" + return result; +#line 262 "util.c" + destination = (_vala_array_free (destination, destination_length1, (GDestroyNotify) g_free), NULL); +} + + +#line 50 "util.vala" +void print_debug (const char* text) { +#line 50 "util.vala" + g_return_if_fail (text != NULL); +#line 51 "util.vala" + if (!debug_enabled) { +#line 52 "util.vala" + return; +#line 275 "util.c" + } +#line 54 "util.vala" + g_debug ("util.vala:54: %s", text); +#line 279 "util.c" +} + + +#line 61 "util.vala" +void fraction_init (Fraction *self, gint numerator, gint denominator) { +#line 285 "util.c" + memset (self, 0, sizeof (Fraction)); +#line 62 "util.vala" + (*self).numerator = numerator; +#line 63 "util.vala" + (*self).denominator = denominator; +#line 291 "util.c" +} + + +#line 66 "util.vala" +void fraction_init_from_string (Fraction *self, const char* s) { +#line 297 "util.c" + char** _tmp1_; + gint _elements_size_; + gint elements_length1; + char** _tmp0_; + char** elements; +#line 66 "util.vala" + g_return_if_fail (s != NULL); +#line 305 "util.c" + memset (self, 0, sizeof (Fraction)); + elements = (_tmp1_ = _tmp0_ = g_strsplit (s, "/", 0), elements_length1 = _vala_array_length (_tmp0_), _elements_size_ = elements_length1, _tmp1_); +#line 68 "util.vala" + if (elements_length1 != 2) { +#line 69 "util.vala" + (*self).numerator = 0; +#line 70 "util.vala" + (*self).denominator = 0; +#line 314 "util.c" + } else { +#line 72 "util.vala" + (*self).numerator = atoi (elements[0]); +#line 73 "util.vala" + (*self).denominator = atoi (elements[1]); +#line 320 "util.c" + } + elements = (_vala_array_free (elements, elements_length1, (GDestroyNotify) g_free), NULL); +} + + +#line 77 "util.vala" +gboolean fraction_equal (Fraction *self, Fraction* f) { +#line 328 "util.c" + gboolean result = FALSE; +#line 78 "util.vala" + if (float_abs (((*self).numerator / ((float) (*self).denominator)) - ((*f).numerator / ((float) (*f).denominator))) <= (1000.0f / 1001.0f)) { +#line 332 "util.c" + result = TRUE; +#line 80 "util.vala" + return result; +#line 336 "util.c" + } + result = FALSE; +#line 81 "util.vala" + return result; +#line 341 "util.c" +} + + +#line 84 "util.vala" +gint fraction_nearest_int (Fraction *self) { +#line 347 "util.c" + gint result = 0; + result = (gint) ((((double) (*self).numerator) / (*self).denominator) + 0.5); +#line 85 "util.vala" + return result; +#line 352 "util.c" +} + + +#line 88 "util.vala" +char* fraction_to_string (Fraction *self) { +#line 358 "util.c" + char* result = NULL; + result = g_strdup_printf ("%d/%d", (*self).numerator, (*self).denominator); +#line 89 "util.vala" + return result; +#line 363 "util.c" +} + + +Fraction* fraction_dup (const Fraction* self) { + Fraction* dup; + dup = g_new0 (Fraction, 1); + memcpy (dup, self, sizeof (Fraction)); + return dup; +} + + +void fraction_free (Fraction* self) { + g_free (self); +} + + +GType fraction_get_type (void) { + static volatile gsize fraction_type_id__volatile = 0; + if (g_once_init_enter (&fraction_type_id__volatile)) { + GType fraction_type_id; + fraction_type_id = g_boxed_type_register_static ("Fraction", (GBoxedCopyFunc) fraction_dup, (GBoxedFreeFunc) fraction_free); + g_once_init_leave (&fraction_type_id__volatile, fraction_type_id); + } + return fraction_type_id__volatile; +} + + +#line 101 "util.vala" +void time_code_get_from_length (TimeCode *self, gint64 length) { +#line 102 "util.vala" + length = length / ((gint64) GST_SECOND); +#line 104 "util.vala" + (*self).hour = (gint) (length / 3600); +#line 105 "util.vala" + (*self).minute = (gint) ((length % 3600) / 60); +#line 106 "util.vala" + (*self).second = (gint) ((length % 3600) % 60); +#line 107 "util.vala" + (*self).frame = 0; +#line 403 "util.c" +} + + +#line 110 "util.vala" +char* time_code_to_string (TimeCode *self) { +#line 409 "util.c" + char* result = NULL; + char* ret; + char* _tmp3_; + char* _tmp2_; + char* _tmp5_; + char* _tmp4_; + char* _tmp9_; + char* _tmp8_; +#line 111 "util.vala" + ret = g_strdup (""); +#line 112 "util.vala" + if ((*self).hour != 0) { +#line 422 "util.c" + char* _tmp1_; + char* _tmp0_; +#line 113 "util.vala" + ret = (_tmp1_ = g_strconcat (ret, _tmp0_ = g_strdup_printf ("%.2d:", (*self).hour), NULL), _g_free0 (ret), _tmp1_); +#line 427 "util.c" + _g_free0 (_tmp0_); + } +#line 115 "util.vala" + ret = (_tmp3_ = g_strconcat (ret, _tmp2_ = g_strdup_printf ("%.2d:", (*self).minute), NULL), _g_free0 (ret), _tmp3_); +#line 432 "util.c" + _g_free0 (_tmp2_); +#line 116 "util.vala" + ret = (_tmp5_ = g_strconcat (ret, _tmp4_ = g_strdup_printf ("%.2d", (*self).second), NULL), _g_free0 (ret), _tmp5_); +#line 436 "util.c" + _g_free0 (_tmp4_); +#line 118 "util.vala" + if ((*self).drop_code) { +#line 440 "util.c" + char* _tmp6_; +#line 119 "util.vala" + ret = (_tmp6_ = g_strconcat (ret, ";", NULL), _g_free0 (ret), _tmp6_); +#line 444 "util.c" + } else { + char* _tmp7_; +#line 121 "util.vala" + ret = (_tmp7_ = g_strconcat (ret, ":", NULL), _g_free0 (ret), _tmp7_); +#line 449 "util.c" + } +#line 122 "util.vala" + ret = (_tmp9_ = g_strconcat (ret, _tmp8_ = g_strdup_printf ("%.2d", (*self).frame), NULL), _g_free0 (ret), _tmp9_); +#line 453 "util.c" + _g_free0 (_tmp8_); + result = ret; +#line 124 "util.vala" + return result; +#line 458 "util.c" +} + + +TimeCode* time_code_dup (const TimeCode* self) { + TimeCode* dup; + dup = g_new0 (TimeCode, 1); + memcpy (dup, self, sizeof (TimeCode)); + return dup; +} + + +void time_code_free (TimeCode* self) { + g_free (self); +} + + +GType time_code_get_type (void) { + static volatile gsize time_code_type_id__volatile = 0; + if (g_once_init_enter (&time_code_type_id__volatile)) { + GType time_code_type_id; + time_code_type_id = g_boxed_type_register_static ("TimeCode", (GBoxedCopyFunc) time_code_dup, (GBoxedFreeFunc) time_code_free); + g_once_init_leave (&time_code_type_id__volatile, time_code_type_id); + } + return time_code_type_id__volatile; +} + + +#line 128 "util.vala" +gboolean time_in_range (gint64 time, gint64 center, gint64 delta) { +#line 488 "util.c" + gboolean result = FALSE; + gint64 diff; +#line 129 "util.vala" + diff = time - center; +#line 493 "util.c" + result = llabs (diff) <= delta; +#line 130 "util.vala" + return result; +#line 497 "util.c" +} + + +#line 133 "util.vala" +char* isolate_filename (const char* path) { +#line 503 "util.c" + char* result = NULL; + char* str; + gint _tmp1__length1; + char** _tmp1_; + char** _tmp0_; + char* _tmp2_; +#line 133 "util.vala" + g_return_val_if_fail (path != NULL, NULL); +#line 134 "util.vala" + str = g_path_get_basename (path); +#line 514 "util.c" + result = (_tmp2_ = g_strdup ((_tmp1_ = _tmp0_ = g_strsplit (str, ".", 0), _tmp1__length1 = _vala_array_length (_tmp0_), _tmp1_)[0]), _tmp1_ = (_vala_array_free (_tmp1_, _tmp1__length1, (GDestroyNotify) g_free), NULL), _tmp2_); + _g_free0 (str); +#line 135 "util.vala" + return result; +#line 519 "util.c" + _g_free0 (str); +} + + +#line 138 "util.vala" +char* get_file_extension (const char* path) { +#line 526 "util.c" + char* result = NULL; + const char* dot; + const char* _tmp0_; +#line 138 "util.vala" + g_return_val_if_fail (path != NULL, NULL); +#line 139 "util.vala" + dot = g_utf8_strrchr (path, (gssize) (-1), (gunichar) '.'); +#line 534 "util.c" + _tmp0_ = NULL; +#line 140 "util.vala" + if (dot == NULL) { +#line 140 "util.vala" + _tmp0_ = ""; +#line 540 "util.c" + } else { +#line 140 "util.vala" + _tmp0_ = g_utf8_next_char (dot); +#line 544 "util.c" + } + result = g_strdup (_tmp0_); +#line 140 "util.vala" + return result; +#line 549 "util.c" +} + + +#line 143 "util.vala" +char* append_extension (const char* path, const char* extension) { +#line 555 "util.c" + char* result = NULL; + char* _tmp0_; + gboolean _tmp1_; + char* _tmp2_; + char* _tmp3_; +#line 143 "util.vala" + g_return_val_if_fail (path != NULL, NULL); +#line 143 "util.vala" + g_return_val_if_fail (extension != NULL, NULL); +#line 144 "util.vala" + if ((_tmp1_ = _vala_strcmp0 (_tmp0_ = get_file_extension (path), extension) == 0, _g_free0 (_tmp0_), _tmp1_)) { +#line 567 "util.c" + result = g_strdup (path); +#line 145 "util.vala" + return result; +#line 571 "util.c" + } + result = (_tmp3_ = g_strconcat (_tmp2_ = g_strconcat (path, ".", NULL), extension, NULL), _g_free0 (_tmp2_), _tmp3_); +#line 147 "util.vala" + return result; +#line 576 "util.c" +} + + +#line 152 "util.vala" +gboolean version_at_least (const char* v, const char* w) { +#line 582 "util.c" + gboolean result = FALSE; + char** _tmp1_; + gint _va_size_; + gint va_length1; + char** _tmp0_; + char** va; + char** _tmp3_; + gint _wa_size_; + gint wa_length1; + char** _tmp2_; + char** wa; +#line 152 "util.vala" + g_return_val_if_fail (v != NULL, FALSE); +#line 152 "util.vala" + g_return_val_if_fail (w != NULL, FALSE); +#line 598 "util.c" + va = (_tmp1_ = _tmp0_ = g_strsplit (v, ".", 0), va_length1 = _vala_array_length (_tmp0_), _va_size_ = va_length1, _tmp1_); + wa = (_tmp3_ = _tmp2_ = g_strsplit (w, ".", 0), wa_length1 = _vala_array_length (_tmp2_), _wa_size_ = wa_length1, _tmp3_); + { + gint i; +#line 155 "util.vala" + i = 0; +#line 605 "util.c" + { + gboolean _tmp4_; +#line 155 "util.vala" + _tmp4_ = TRUE; +#line 155 "util.vala" + while (TRUE) { +#line 612 "util.c" + gint vi; + gint wi; +#line 155 "util.vala" + if (!_tmp4_) { +#line 155 "util.vala" + i = i + 1; +#line 619 "util.c" + } +#line 155 "util.vala" + _tmp4_ = FALSE; +#line 155 "util.vala" + if (!(i < wa_length1)) { +#line 155 "util.vala" + break; +#line 627 "util.c" + } +#line 156 "util.vala" + if (i >= va_length1) { +#line 631 "util.c" + result = FALSE; + va = (_vala_array_free (va, va_length1, (GDestroyNotify) g_free), NULL); + wa = (_vala_array_free (wa, wa_length1, (GDestroyNotify) g_free), NULL); +#line 157 "util.vala" + return result; +#line 637 "util.c" + } +#line 158 "util.vala" + vi = atoi (va[i]); +#line 159 "util.vala" + wi = atoi (wa[i]); +#line 160 "util.vala" + if (vi > wi) { +#line 645 "util.c" + result = TRUE; + va = (_vala_array_free (va, va_length1, (GDestroyNotify) g_free), NULL); + wa = (_vala_array_free (wa, wa_length1, (GDestroyNotify) g_free), NULL); +#line 161 "util.vala" + return result; +#line 651 "util.c" + } +#line 162 "util.vala" + if (wi > vi) { +#line 655 "util.c" + result = FALSE; + va = (_vala_array_free (va, va_length1, (GDestroyNotify) g_free), NULL); + wa = (_vala_array_free (wa, wa_length1, (GDestroyNotify) g_free), NULL); +#line 163 "util.vala" + return result; +#line 661 "util.c" + } + } + } + } + result = TRUE; + va = (_vala_array_free (va, va_length1, (GDestroyNotify) g_free), NULL); + wa = (_vala_array_free (wa, wa_length1, (GDestroyNotify) g_free), NULL); +#line 165 "util.vala" + return result; +#line 671 "util.c" +} + + +#line 168 "util.vala" +gboolean get_file_md5_checksum (const char* filename, char** checksum) { +#line 677 "util.c" + gboolean result = FALSE; + GError * _inner_error_; + char* new_filename; + gsize buffer_length = 0UL; +#line 168 "util.vala" + g_return_val_if_fail (filename != NULL, FALSE); +#line 684 "util.c" + if (checksum != NULL) { + *checksum = NULL; + } + _inner_error_ = NULL; +#line 169 "util.vala" + new_filename = append_extension (filename, "md5"); +#line 691 "util.c" + { + char* _tmp1_; + char* _tmp0_ = NULL; +#line 173 "util.vala" + g_file_get_contents (new_filename, &_tmp0_, &buffer_length, &_inner_error_); +#line 173 "util.vala" + *checksum = (_tmp1_ = _tmp0_, _g_free0 (*checksum), _tmp1_); +#line 699 "util.c" + if (_inner_error_ != NULL) { + if (_inner_error_->domain == G_FILE_ERROR) { + goto __catch17_g_file_error; + } + _g_free0 (new_filename); + g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return FALSE; + } + } + goto __finally17; + __catch17_g_file_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { + result = FALSE; + _g_error_free0 (e); + _g_free0 (new_filename); +#line 175 "util.vala" + return result; +#line 722 "util.c" + } + } + __finally17: + if (_inner_error_ != NULL) { + _g_free0 (new_filename); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return FALSE; + } + result = buffer_length == 32; + _g_free0 (new_filename); +#line 178 "util.vala" + return result; +#line 736 "util.c" +} + + +#line 181 "util.vala" +void save_file_md5_checksum (const char* filename, const char* checksum) { +#line 742 "util.c" + GError * _inner_error_; + char* new_filename; +#line 181 "util.vala" + g_return_if_fail (filename != NULL); +#line 181 "util.vala" + g_return_if_fail (checksum != NULL); +#line 749 "util.c" + _inner_error_ = NULL; +#line 182 "util.vala" + new_filename = append_extension (filename, "md5"); +#line 753 "util.c" + { +#line 185 "util.vala" + g_file_set_contents (new_filename, checksum, -1, &_inner_error_); +#line 757 "util.c" + if (_inner_error_ != NULL) { + if (_inner_error_->domain == G_FILE_ERROR) { + goto __catch18_g_file_error; + } + _g_free0 (new_filename); + g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } + } + goto __finally18; + __catch18_g_file_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { +#line 187 "util.vala" + g_error ("util.vala:187: Cannot save md5 file %s!\n", new_filename); +#line 777 "util.c" + _g_error_free0 (e); + } + } + __finally18: + if (_inner_error_ != NULL) { + _g_free0 (new_filename); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } + _g_free0 (new_filename); +} + + +#line 191 "util.vala" +gboolean md5_checksum_on_file (const char* filename, char** checksum) { +#line 794 "util.c" + gboolean result = FALSE; + GError * _inner_error_; + char* file_buffer; + gsize len = 0UL; + GChecksum* c; + char* _tmp2_; +#line 191 "util.vala" + g_return_val_if_fail (filename != NULL, FALSE); +#line 803 "util.c" + if (checksum != NULL) { + *checksum = NULL; + } + _inner_error_ = NULL; + file_buffer = NULL; + { + char* _tmp1_; + char* _tmp0_ = NULL; +#line 196 "util.vala" + g_file_get_contents (filename, &_tmp0_, &len, &_inner_error_); +#line 196 "util.vala" + file_buffer = (_tmp1_ = _tmp0_, _g_free0 (file_buffer), _tmp1_); +#line 816 "util.c" + if (_inner_error_ != NULL) { + if (_inner_error_->domain == G_FILE_ERROR) { + goto __catch19_g_file_error; + } + _g_free0 (file_buffer); + g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return FALSE; + } + } + goto __finally19; + __catch19_g_file_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { + result = FALSE; + _g_error_free0 (e); + _g_free0 (file_buffer); +#line 198 "util.vala" + return result; +#line 839 "util.c" + } + } + __finally19: + if (_inner_error_ != NULL) { + _g_free0 (file_buffer); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return FALSE; + } +#line 201 "util.vala" + c = g_checksum_new (G_CHECKSUM_MD5); +#line 202 "util.vala" + g_checksum_update (c, (guchar*) file_buffer, len); +#line 203 "util.vala" + *checksum = (_tmp2_ = g_strdup (g_checksum_get_string (c)), _g_free0 (*checksum), _tmp2_); +#line 855 "util.c" + result = TRUE; + _g_free0 (file_buffer); + _g_checksum_free0 (c); +#line 204 "util.vala" + return result; +#line 861 "util.c" +} + + +#line 239 "util.vala" +void parse_color (const char* color, GdkColor* result) { +#line 867 "util.c" + GdkColor c = {0}; +#line 239 "util.vala" + g_return_if_fail (color != NULL); +#line 241 "util.vala" + if (!gdk_color_parse (color, &c)) { +#line 242 "util.vala" + g_error ("util.vala:242: can't parse color"); +#line 875 "util.c" + } + *result = c; +#line 243 "util.vala" + return; +#line 880 "util.c" +} + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 246 "util.vala" +GtkWidget* get_widget (GtkUIManager* manager, const char* name) { +#line 891 "util.c" + GtkWidget* result = NULL; + GtkWidget* widget; +#line 246 "util.vala" + g_return_val_if_fail (GTK_IS_UI_MANAGER (manager), NULL); +#line 246 "util.vala" + g_return_val_if_fail (name != NULL, NULL); +#line 247 "util.vala" + widget = _g_object_ref0 (gtk_ui_manager_get_widget (manager, name)); +#line 248 "util.vala" + if (widget == NULL) { +#line 249 "util.vala" + g_error ("util.vala:249: can't find widget"); +#line 904 "util.c" + } + result = widget; +#line 250 "util.vala" + return result; +#line 909 "util.c" +} + + +#line 262 "util.vala" +void draw_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height) { +#line 915 "util.c" + gboolean _tmp0_ = FALSE; + double x1; + double y1; + cairo_t* cairo_window; +#line 262 "util.vala" + g_return_if_fail (GDK_IS_WINDOW (window)); +#line 264 "util.vala" + if (width == 0) { +#line 264 "util.vala" + _tmp0_ = TRUE; +#line 926 "util.c" + } else { +#line 264 "util.vala" + _tmp0_ = height == 0; +#line 930 "util.c" + } +#line 264 "util.vala" + if (_tmp0_) { +#line 265 "util.vala" + return; +#line 936 "util.c" + } +#line 267 "util.vala" + x1 = (double) (x0 + width); +#line 268 "util.vala" + y1 = (double) (y0 + height); +#line 270 "util.vala" + cairo_window = gdk_cairo_create (GDK_DRAWABLE (window)); +#line 271 "util.vala" + gdk_cairo_set_source_color (cairo_window, color); +#line 272 "util.vala" + cairo_set_antialias (cairo_window, ANTIALIAS); +#line 274 "util.vala" + if ((width / 2) < RADIUS) { +#line 275 "util.vala" + if ((height / 2) < RADIUS) { +#line 276 "util.vala" + cairo_move_to (cairo_window, (double) x0, (y0 + y1) / 2); +#line 277 "util.vala" + cairo_curve_to (cairo_window, (double) x0, (double) y0, (double) x0, (double) y0, (x0 + x1) / 2, (double) y0); +#line 278 "util.vala" + cairo_curve_to (cairo_window, x1, (double) y0, x1, (double) y0, x1, (y0 + y1) / 2); +#line 279 "util.vala" + cairo_curve_to (cairo_window, x1, y1, x1, y1, (x1 + x0) / 2, y1); +#line 280 "util.vala" + cairo_curve_to (cairo_window, (double) x0, y1, (double) x0, y1, (double) x0, (y0 + y1) / 2); +#line 962 "util.c" + } else { +#line 282 "util.vala" + cairo_move_to (cairo_window, (double) x0, y0 + RADIUS); +#line 283 "util.vala" + cairo_curve_to (cairo_window, (double) x0, (double) y0, (double) x0, (double) y0, (x0 + x1) / 2, (double) y0); +#line 284 "util.vala" + cairo_curve_to (cairo_window, x1, (double) y0, x1, (double) y0, x1, y0 + RADIUS); +#line 285 "util.vala" + cairo_line_to (cairo_window, x1, y1 - RADIUS); +#line 286 "util.vala" + cairo_curve_to (cairo_window, x1, y1, x1, y1, (x1 + x0) / 2, y1); +#line 287 "util.vala" + cairo_curve_to (cairo_window, (double) x0, y1, (double) x0, y1, (double) x0, y1 - RADIUS); +#line 976 "util.c" + } + } else { +#line 290 "util.vala" + if ((height / 2) < RADIUS) { +#line 291 "util.vala" + cairo_move_to (cairo_window, (double) x0, (y0 + y1) / 2); +#line 292 "util.vala" + cairo_curve_to (cairo_window, (double) x0, (double) y0, (double) x0, (double) y0, x0 + RADIUS, (double) y0); +#line 293 "util.vala" + cairo_line_to (cairo_window, x1 - RADIUS, (double) y0); +#line 294 "util.vala" + cairo_curve_to (cairo_window, x1, (double) y0, x1, (double) y0, x1, (y0 + y1) / 2); +#line 295 "util.vala" + cairo_curve_to (cairo_window, x1, y1, x1, y1, x1 - RADIUS, y1); +#line 296 "util.vala" + cairo_line_to (cairo_window, x0 + RADIUS, y1); +#line 297 "util.vala" + cairo_curve_to (cairo_window, (double) x0, y1, (double) x0, y1, (double) x0, (y0 + y1) / 2); +#line 995 "util.c" + } else { +#line 299 "util.vala" + cairo_move_to (cairo_window, (double) x0, y0 + RADIUS); +#line 300 "util.vala" + cairo_curve_to (cairo_window, (double) x0, (double) y0, (double) x0, (double) y0, x0 + RADIUS, (double) y0); +#line 301 "util.vala" + cairo_line_to (cairo_window, x1 - RADIUS, (double) y0); +#line 302 "util.vala" + cairo_curve_to (cairo_window, x1, (double) y0, x1, (double) y0, x1, y0 + RADIUS); +#line 303 "util.vala" + cairo_line_to (cairo_window, x1, y1 - RADIUS); +#line 304 "util.vala" + cairo_curve_to (cairo_window, x1, y1, x1, y1, x1 - RADIUS, y1); +#line 305 "util.vala" + cairo_line_to (cairo_window, x0 + RADIUS, y1); +#line 306 "util.vala" + cairo_curve_to (cairo_window, (double) x0, y1, (double) x0, y1, (double) x0, y1 - RADIUS); +#line 1013 "util.c" + } + } +#line 309 "util.vala" + cairo_close_path (cairo_window); +#line 311 "util.vala" + if (filled) { +#line 312 "util.vala" + cairo_fill (cairo_window); +#line 1022 "util.c" + } else { +#line 314 "util.vala" + cairo_set_line_width (cairo_window, LINE_WIDTH); +#line 315 "util.vala" + cairo_stroke (cairo_window); +#line 1028 "util.c" + } + _cairo_destroy0 (cairo_window); +} + + +#line 319 "util.vala" +void draw_right_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height) { +#line 1036 "util.c" + gboolean _tmp0_ = FALSE; + double x1; + double y1; + cairo_t* cairo_window; +#line 319 "util.vala" + g_return_if_fail (GDK_IS_WINDOW (window)); +#line 321 "util.vala" + if (width == 0) { +#line 321 "util.vala" + _tmp0_ = TRUE; +#line 1047 "util.c" + } else { +#line 321 "util.vala" + _tmp0_ = height == 0; +#line 1051 "util.c" + } +#line 321 "util.vala" + if (_tmp0_) { +#line 322 "util.vala" + return; +#line 1057 "util.c" + } +#line 324 "util.vala" + x1 = (double) (x0 + width); +#line 325 "util.vala" + y1 = (double) (y0 + height); +#line 327 "util.vala" + cairo_window = gdk_cairo_create (GDK_DRAWABLE (window)); +#line 328 "util.vala" + gdk_cairo_set_source_color (cairo_window, color); +#line 329 "util.vala" + cairo_set_antialias (cairo_window, ANTIALIAS); +#line 331 "util.vala" + if ((width / 2) < RADIUS) { +#line 332 "util.vala" + if ((height / 2) < RADIUS) { +#line 333 "util.vala" + cairo_move_to (cairo_window, (double) x0, (double) y0); +#line 334 "util.vala" + cairo_line_to (cairo_window, (x0 + x1) / 2, (double) y0); +#line 335 "util.vala" + cairo_curve_to (cairo_window, x1, (double) y0, x1, (double) y0, x1, (y0 + y1) / 2); +#line 336 "util.vala" + cairo_curve_to (cairo_window, x1, y1, x1, y1, (x1 + x0) / 2, y1); +#line 337 "util.vala" + cairo_line_to (cairo_window, (double) x0, y1); +#line 338 "util.vala" + cairo_line_to (cairo_window, (double) x0, (double) y0); +#line 1085 "util.c" + } else { +#line 340 "util.vala" + cairo_move_to (cairo_window, (double) x0, (double) y0); +#line 341 "util.vala" + cairo_line_to (cairo_window, (x0 + x1) / 2, (double) y0); +#line 342 "util.vala" + cairo_curve_to (cairo_window, x1, (double) y0, x1, (double) y0, x1, y0 + RADIUS); +#line 343 "util.vala" + cairo_line_to (cairo_window, x1, y1 - RADIUS); +#line 344 "util.vala" + cairo_curve_to (cairo_window, x1, y1, x1, y1, (x1 + x0) / 2, y1); +#line 345 "util.vala" + cairo_line_to (cairo_window, (double) x0, y1); +#line 346 "util.vala" + cairo_line_to (cairo_window, (double) x0, (double) y0); +#line 1101 "util.c" + } + } else { +#line 349 "util.vala" + if ((height / 2) < RADIUS) { +#line 350 "util.vala" + cairo_move_to (cairo_window, (double) x0, (double) y0); +#line 351 "util.vala" + cairo_line_to (cairo_window, x1 - RADIUS, (double) y0); +#line 352 "util.vala" + cairo_curve_to (cairo_window, x1, (double) y0, x1, (double) y0, x1, (y0 + y1) / 2); +#line 353 "util.vala" + cairo_curve_to (cairo_window, x1, y1, x1, y1, x1 - RADIUS, y1); +#line 354 "util.vala" + cairo_line_to (cairo_window, (double) x0, y1); +#line 355 "util.vala" + cairo_line_to (cairo_window, (double) x0, (double) y0); +#line 1118 "util.c" + } else { +#line 357 "util.vala" + cairo_move_to (cairo_window, (double) x0, (double) y0); +#line 358 "util.vala" + cairo_line_to (cairo_window, x1 - RADIUS, (double) y0); +#line 359 "util.vala" + cairo_curve_to (cairo_window, x1, (double) y0, x1, (double) y0, x1, y0 + RADIUS); +#line 360 "util.vala" + cairo_line_to (cairo_window, x1, y1 - RADIUS); +#line 361 "util.vala" + cairo_curve_to (cairo_window, x1, y1, x1, y1, x1 - RADIUS, y1); +#line 362 "util.vala" + cairo_line_to (cairo_window, (double) x0, y1); +#line 363 "util.vala" + cairo_line_to (cairo_window, (double) x0, (double) y0); +#line 1134 "util.c" + } + } +#line 366 "util.vala" + cairo_close_path (cairo_window); +#line 368 "util.vala" + if (filled) { +#line 369 "util.vala" + cairo_fill (cairo_window); +#line 1143 "util.c" + } else { +#line 371 "util.vala" + cairo_set_line_width (cairo_window, LINE_WIDTH); +#line 372 "util.vala" + cairo_stroke (cairo_window); +#line 1149 "util.c" + } + _cairo_destroy0 (cairo_window); +} + + +#line 376 "util.vala" +void draw_left_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height) { +#line 1157 "util.c" + gboolean _tmp0_ = FALSE; + double x1; + double y1; + cairo_t* cairo_window; +#line 376 "util.vala" + g_return_if_fail (GDK_IS_WINDOW (window)); +#line 378 "util.vala" + if (width == 0) { +#line 378 "util.vala" + _tmp0_ = TRUE; +#line 1168 "util.c" + } else { +#line 378 "util.vala" + _tmp0_ = height == 0; +#line 1172 "util.c" + } +#line 378 "util.vala" + if (_tmp0_) { +#line 379 "util.vala" + return; +#line 1178 "util.c" + } +#line 381 "util.vala" + x1 = (double) (x0 + width); +#line 382 "util.vala" + y1 = (double) (y0 + height); +#line 384 "util.vala" + cairo_window = gdk_cairo_create (GDK_DRAWABLE (window)); +#line 385 "util.vala" + gdk_cairo_set_source_color (cairo_window, color); +#line 386 "util.vala" + cairo_set_antialias (cairo_window, ANTIALIAS); +#line 388 "util.vala" + if ((width / 2) < RADIUS) { +#line 389 "util.vala" + if ((height / 2) < RADIUS) { +#line 390 "util.vala" + cairo_move_to (cairo_window, (double) x0, (y0 + y1) / 2); +#line 391 "util.vala" + cairo_curve_to (cairo_window, (double) x0, (double) y0, (double) x0, (double) y0, (x0 + x1) / 2, (double) y0); +#line 392 "util.vala" + cairo_line_to (cairo_window, x1, (double) y0); +#line 393 "util.vala" + cairo_line_to (cairo_window, x1, y1); +#line 394 "util.vala" + cairo_line_to (cairo_window, (x1 + x0) / 2, y1); +#line 395 "util.vala" + cairo_curve_to (cairo_window, (double) x0, y1, (double) x0, y1, (double) x0, (y0 + y1) / 2); +#line 1206 "util.c" + } else { +#line 397 "util.vala" + cairo_move_to (cairo_window, (double) x0, y0 + RADIUS); +#line 398 "util.vala" + cairo_curve_to (cairo_window, (double) x0, (double) y0, (double) x0, (double) y0, (x0 + x1) / 2, (double) y0); +#line 399 "util.vala" + cairo_line_to (cairo_window, x1, (double) y0); +#line 400 "util.vala" + cairo_line_to (cairo_window, x1, y1); +#line 401 "util.vala" + cairo_line_to (cairo_window, (x1 + x0) / 2, y1); +#line 402 "util.vala" + cairo_curve_to (cairo_window, (double) x0, y1, (double) x0, y1, (double) x0, y1 - RADIUS); +#line 1220 "util.c" + } + } else { +#line 405 "util.vala" + if ((height / 2) < RADIUS) { +#line 406 "util.vala" + cairo_move_to (cairo_window, (double) x0, (y0 + y1) / 2); +#line 407 "util.vala" + cairo_curve_to (cairo_window, (double) x0, (double) y0, (double) x0, (double) y0, x0 + RADIUS, (double) y0); +#line 408 "util.vala" + cairo_line_to (cairo_window, x1, (double) y0); +#line 409 "util.vala" + cairo_line_to (cairo_window, x1, y1); +#line 410 "util.vala" + cairo_line_to (cairo_window, x0 + RADIUS, y1); +#line 411 "util.vala" + cairo_curve_to (cairo_window, (double) x0, y1, (double) x0, y1, (double) x0, (y0 + y1) / 2); +#line 1237 "util.c" + } else { +#line 413 "util.vala" + cairo_move_to (cairo_window, (double) x0, y0 + RADIUS); +#line 414 "util.vala" + cairo_curve_to (cairo_window, (double) x0, (double) y0, (double) x0, (double) y0, x0 + RADIUS, (double) y0); +#line 415 "util.vala" + cairo_line_to (cairo_window, x1, (double) y0); +#line 416 "util.vala" + cairo_line_to (cairo_window, x1, y1); +#line 417 "util.vala" + cairo_line_to (cairo_window, x0 + RADIUS, y1); +#line 418 "util.vala" + cairo_curve_to (cairo_window, (double) x0, y1, (double) x0, y1, (double) x0, y1 - RADIUS); +#line 1251 "util.c" + } + } +#line 421 "util.vala" + cairo_close_path (cairo_window); +#line 423 "util.vala" + if (filled) { +#line 424 "util.vala" + cairo_fill (cairo_window); +#line 1260 "util.c" + } else { +#line 426 "util.vala" + cairo_set_line_width (cairo_window, LINE_WIDTH); +#line 427 "util.vala" + cairo_stroke (cairo_window); +#line 1266 "util.c" + } + _cairo_destroy0 (cairo_window); +} + + +#line 431 "util.vala" +void draw_square_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x, gint y, gint width, gint height) { +#line 1274 "util.c" + gboolean _tmp0_ = FALSE; + cairo_t* cairo_window; +#line 431 "util.vala" + g_return_if_fail (GDK_IS_WINDOW (window)); +#line 433 "util.vala" + if (width == 0) { +#line 433 "util.vala" + _tmp0_ = TRUE; +#line 1283 "util.c" + } else { +#line 433 "util.vala" + _tmp0_ = height == 0; +#line 1287 "util.c" + } +#line 433 "util.vala" + if (_tmp0_) { +#line 434 "util.vala" + return; +#line 1293 "util.c" + } +#line 436 "util.vala" + cairo_window = gdk_cairo_create (GDK_DRAWABLE (window)); +#line 437 "util.vala" + gdk_cairo_set_source_color (cairo_window, color); +#line 438 "util.vala" + cairo_set_antialias (cairo_window, ANTIALIAS); +#line 440 "util.vala" + cairo_rectangle (cairo_window, (double) x, (double) y, (double) width, (double) height); +#line 442 "util.vala" + if (filled) { +#line 443 "util.vala" + cairo_fill (cairo_window); +#line 1307 "util.c" + } else { +#line 445 "util.vala" + cairo_set_line_width (cairo_window, LINE_WIDTH); +#line 446 "util.vala" + cairo_stroke (cairo_window); +#line 1313 "util.c" + } + _cairo_destroy0 (cairo_window); +} + + +#line 452 "util.vala" +gboolean is_drop_frame_rate (Fraction* r) { +#line 1321 "util.c" + gboolean result = FALSE; + gboolean _tmp0_ = FALSE; + gboolean _tmp1_ = FALSE; +#line 453 "util.vala" + if ((*r).numerator == 2997) { +#line 453 "util.vala" + _tmp1_ = (*r).denominator == 100; +#line 1329 "util.c" + } else { +#line 453 "util.vala" + _tmp1_ = FALSE; +#line 1333 "util.c" + } +#line 453 "util.vala" + if (_tmp1_) { +#line 453 "util.vala" + _tmp0_ = TRUE; +#line 1339 "util.c" + } else { + gboolean _tmp2_ = FALSE; +#line 454 "util.vala" + if ((*r).numerator == 30000) { +#line 454 "util.vala" + _tmp2_ = (*r).denominator == 1001; +#line 1346 "util.c" + } else { +#line 454 "util.vala" + _tmp2_ = FALSE; +#line 1350 "util.c" + } +#line 454 "util.vala" + _tmp0_ = _tmp2_; +#line 1354 "util.c" + } + result = _tmp0_; +#line 453 "util.vala" + return result; +#line 1359 "util.c" +} + + +#line 457 "util.vala" +gint64 frame_to_time_with_rate (gint frame, Fraction* rate) { +#line 1365 "util.c" + gint64 result = 0LL; + gint64 time; +#line 458 "util.vala" + time = (gint64) gst_util_uint64_scale ((guint64) frame, (guint64) (GST_SECOND * (*rate).denominator), (guint64) (*rate).numerator); +#line 1370 "util.c" + result = time; +#line 459 "util.vala" + return result; +#line 1374 "util.c" +} + + +#line 462 "util.vala" +gint time_to_frame_with_rate (gint64 time, Fraction* rate) { +#line 1380 "util.c" + gint result = 0; + gint frame; + gint _tmp0_ = 0; +#line 463 "util.vala" + frame = (gint) gst_util_uint64_scale ((guint64) time, (guint64) (*rate).numerator, (guint64) (GST_SECOND * (*rate).denominator)); +#line 469 "util.vala" + if (time >= frame_to_time_with_rate (frame + 1, rate)) { +#line 469 "util.vala" + _tmp0_ = frame + 1; +#line 1390 "util.c" + } else { +#line 469 "util.vala" + _tmp0_ = frame; +#line 1394 "util.c" + } + result = _tmp0_; +#line 469 "util.vala" + return result; +#line 1399 "util.c" +} + + +#line 472 "util.vala" +void frame_to_time (gint frame, Fraction* rate, TimeCode* result) { +#line 1405 "util.c" + gint frame_rate; + TimeCode _tmp0_ = {0}; + TimeCode t; + gint64 secs; +#line 473 "util.vala" + frame_rate = 0; +#line 475 "util.vala" + t = (_tmp0_); +#line 477 "util.vala" + t.drop_code = FALSE; +#line 478 "util.vala" + if ((*rate).denominator == 1) { +#line 479 "util.vala" + frame_rate = (*rate).numerator; +#line 1420 "util.c" + } else { +#line 480 "util.vala" + if (is_drop_frame_rate (rate)) { +#line 1424 "util.c" + gint FRAMES_PER_MINUTE; + gint FRAMES_PER_10_MINUTES; + gint block; + gint minute_in_block; + gint minutes; +#line 481 "util.vala" + t.drop_code = TRUE; +#line 482 "util.vala" + frame_rate = 30; +#line 485 "util.vala" + FRAMES_PER_MINUTE = (30 * 60) - 2; +#line 486 "util.vala" + FRAMES_PER_10_MINUTES = (10 * FRAMES_PER_MINUTE) + 2; +#line 488 "util.vala" + block = frame / FRAMES_PER_10_MINUTES; +#line 489 "util.vala" + minute_in_block = ((frame % FRAMES_PER_10_MINUTES) - 2) / FRAMES_PER_MINUTE; +#line 490 "util.vala" + minutes = (10 * block) + minute_in_block; +#line 491 "util.vala" + frame = frame + ((2 * minutes) - (2 * block)); +#line 1446 "util.c" + } else { +#line 495 "util.vala" + frame_rate = (*rate).numerator / (*rate).denominator; +#line 1450 "util.c" + } + } +#line 498 "util.vala" + t.frame = frame % frame_rate; +#line 500 "util.vala" + secs = (gint64) (frame / frame_rate); +#line 501 "util.vala" + t.hour = ((gint) secs) / 3600; +#line 502 "util.vala" + t.minute = (((gint) secs) % 3600) / 60; +#line 503 "util.vala" + t.second = (((gint) secs) % 3600) % 60; +#line 1463 "util.c" + *result = t; +#line 505 "util.vala" + return; +#line 1467 "util.c" +} + + +#line 508 "util.vala" +char* frame_to_string (gint frame, Fraction* rate) { +#line 1473 "util.c" + char* result = NULL; + TimeCode _tmp1_; + TimeCode _tmp0_ = {0}; + result = time_code_to_string ((_tmp1_ = (frame_to_time (frame, rate, &_tmp0_), _tmp0_), &_tmp1_)); +#line 509 "util.vala" + return result; +#line 1480 "util.c" +} + + +#line 512 "util.vala" +void breakup_time (gint64 time, gint* hours, gint* minutes, double* seconds) { +#line 1486 "util.c" + gint64 the_time; + gint64 minute; + gint64 hour; +#line 513 "util.vala" + the_time = time; +#line 514 "util.vala" + minute = (gint64) (GST_SECOND * 60); +#line 515 "util.vala" + hour = minute * 60; +#line 516 "util.vala" + *hours = (gint) (the_time / hour); +#line 517 "util.vala" + the_time = the_time % hour; +#line 518 "util.vala" + *minutes = (gint) (the_time / minute); +#line 519 "util.vala" + the_time = the_time % minute; +#line 520 "util.vala" + *seconds = ((double) the_time) / GST_SECOND; +#line 1506 "util.c" +} + + +#line 523 "util.vala" +char* time_to_HHMMSS (gint64 time) { +#line 1512 "util.c" + char* result = NULL; + gint hours = 0; + gint minutes = 0; + double seconds = 0.0; +#line 528 "util.vala" + breakup_time (time, &hours, &minutes, &seconds); +#line 1519 "util.c" + result = g_strdup_printf ("%02d:%02d:%05.2lf", hours, minutes, seconds); +#line 529 "util.vala" + return result; +#line 1523 "util.c" +} + + +#line 532 "util.vala" +char* time_to_string (gint64 time) { +#line 1529 "util.c" + char* result = NULL; + gint hours = 0; + gint minutes = 0; + double seconds = 0.0; + char* return_value; + gboolean _tmp0_ = FALSE; +#line 537 "util.vala" + breakup_time (time, &hours, &minutes, &seconds); +#line 538 "util.vala" + return_value = g_strdup_printf ("%1.2lfs", seconds); +#line 539 "util.vala" + if (hours > 0) { +#line 539 "util.vala" + _tmp0_ = TRUE; +#line 1544 "util.c" + } else { +#line 539 "util.vala" + _tmp0_ = minutes > 0; +#line 1548 "util.c" + } +#line 539 "util.vala" + if (_tmp0_) { +#line 1552 "util.c" + char* _tmp2_; + char* _tmp1_; +#line 540 "util.vala" + return_value = (_tmp2_ = g_strconcat (_tmp1_ = g_strdup_printf ("%dm ", minutes), return_value, NULL), _g_free0 (return_value), _tmp2_); +#line 1557 "util.c" + _g_free0 (_tmp1_); + } +#line 543 "util.vala" + if (hours > 0) { +#line 1562 "util.c" + char* _tmp4_; + char* _tmp3_; +#line 544 "util.vala" + return_value = (_tmp4_ = g_strconcat (_tmp3_ = g_strdup_printf ("%dh ", hours), return_value, NULL), _g_free0 (return_value), _tmp4_); +#line 1567 "util.c" + _g_free0 (_tmp3_); + } + result = return_value; +#line 547 "util.vala" + return result; +#line 1573 "util.c" +} + + +#line 550 "util.vala" +GstElement* make_element_with_name (const char* element_name, const char* display_name, GError** error) { +#line 1579 "util.c" + GstElement* result = NULL; + GError * _inner_error_; + GstElement* e; +#line 550 "util.vala" + g_return_val_if_fail (element_name != NULL, NULL); +#line 1585 "util.c" + _inner_error_ = NULL; +#line 552 "util.vala" + e = gst_element_factory_make (element_name, display_name); +#line 553 "util.vala" + if (e == NULL) { +#line 1591 "util.c" + char* _tmp0_; + GError* _tmp1_; + _inner_error_ = (_tmp1_ = g_error_new_literal (MEDIA_ERROR, MEDIA_ERROR_MISSING_PLUGIN, _tmp0_ = g_strdup_printf ("Could not create element %s(%s)", element_name, display_name)), _g_free0 (_tmp0_), _tmp1_); + { + g_propagate_error (error, _inner_error_); + _gst_object_unref0 (e); + return NULL; + } + } + result = e; +#line 557 "util.vala" + return result; +#line 1604 "util.c" +} + + +#line 560 "util.vala" +GstElement* make_element (const char* name, GError** error) { +#line 1610 "util.c" + GstElement* result = NULL; + GError * _inner_error_; + GstElement* _tmp0_; +#line 560 "util.vala" + g_return_val_if_fail (name != NULL, NULL); +#line 1616 "util.c" + _inner_error_ = NULL; +#line 561 "util.vala" + _tmp0_ = make_element_with_name (name, NULL, &_inner_error_); +#line 1620 "util.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + return NULL; + } + result = _tmp0_; +#line 561 "util.vala" + return result; +#line 1628 "util.c" +} + + +static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) { + if ((array != NULL) && (destroy_func != NULL)) { + int i; + for (i = 0; i < array_length; i = i + 1) { + if (((gpointer*) array)[i] != NULL) { + destroy_func (((gpointer*) array)[i]); + } + } + } +} + + +static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) { + _vala_array_destroy (array, array_length, destroy_func); + g_free (array); +} + + +static gint _vala_array_length (gpointer array) { + int length; + length = 0; + if (array) { + while (((gpointer*) array)[length]) { + length++; + } + } + return length; +} + + +static int _vala_strcmp0 (const char * str1, const char * str2) { + if (str1 == NULL) { + return -(str1 != str2); + } + if (str2 == NULL) { + return str1 != str2; + } + return strcmp (str1, str2); +} + + + + diff --git a/src/marina/marina/util.o b/src/marina/marina/util.o new file mode 100644 index 0000000..102f61f Binary files /dev/null and b/src/marina/marina/util.o differ diff --git a/src/marina/marina/video_track.c b/src/marina/marina/video_track.c new file mode 100644 index 0000000..ea18f10 --- /dev/null +++ b/src/marina/marina/video_track.c @@ -0,0 +1,571 @@ +/* video_track.c generated by valac, the Vala compiler + * generated from video_track.vala, do not modify */ + +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#define MODEL_TYPE_TRACK (model_track_get_type ()) +#define MODEL_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TRACK, ModelTrack)) +#define MODEL_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TRACK, ModelTrackClass)) +#define MODEL_IS_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TRACK)) +#define MODEL_IS_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TRACK)) +#define MODEL_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TRACK, ModelTrackClass)) + +typedef struct _ModelTrack ModelTrack; +typedef struct _ModelTrackClass ModelTrackClass; +typedef struct _ModelTrackPrivate ModelTrackPrivate; + +#define MODEL_TYPE_MEDIA_TYPE (model_media_type_get_type ()) + +#define MODEL_TYPE_CLIP (model_clip_get_type ()) +#define MODEL_CLIP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP, ModelClip)) +#define MODEL_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP, ModelClipClass)) +#define MODEL_IS_CLIP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP)) +#define MODEL_IS_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP)) +#define MODEL_CLIP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP, ModelClipClass)) + +typedef struct _ModelClip ModelClip; +typedef struct _ModelClipClass ModelClipClass; + +#define MODEL_TYPE_PROJECT (model_project_get_type ()) +#define MODEL_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT, ModelProject)) +#define MODEL_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT, ModelProjectClass)) +#define MODEL_IS_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT)) +#define MODEL_IS_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT)) +#define MODEL_PROJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT, ModelProjectClass)) + +typedef struct _ModelProject ModelProject; +typedef struct _ModelProjectClass ModelProjectClass; + +#define MODEL_TYPE_VIDEO_TRACK (model_video_track_get_type ()) +#define MODEL_VIDEO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_VIDEO_TRACK, ModelVideoTrack)) +#define MODEL_VIDEO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_VIDEO_TRACK, ModelVideoTrackClass)) +#define MODEL_IS_VIDEO_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_VIDEO_TRACK)) +#define MODEL_IS_VIDEO_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_VIDEO_TRACK)) +#define MODEL_VIDEO_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_VIDEO_TRACK, ModelVideoTrackClass)) + +typedef struct _ModelVideoTrack ModelVideoTrack; +typedef struct _ModelVideoTrackClass ModelVideoTrackClass; +typedef struct _ModelVideoTrackPrivate ModelVideoTrackPrivate; + +#define TYPE_FRACTION (fraction_get_type ()) +typedef struct _Fraction Fraction; +typedef struct _ModelClipPrivate ModelClipPrivate; + +#define MODEL_TYPE_CLIP_FILE (model_clip_file_get_type ()) +#define MODEL_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFile)) +#define MODEL_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) +#define MODEL_IS_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE)) +#define MODEL_IS_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE)) +#define MODEL_CLIP_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) + +typedef struct _ModelClipFile ModelClipFile; +typedef struct _ModelClipFileClass ModelClipFileClass; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) + +#define MODEL_TYPE_TEMPO_INFORMATION (model_tempo_information_get_type ()) +#define MODEL_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformation)) +#define MODEL_IS_TEMPO_INFORMATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TEMPO_INFORMATION)) +#define MODEL_TEMPO_INFORMATION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MODEL_TYPE_TEMPO_INFORMATION, ModelTempoInformationIface)) + +typedef struct _ModelTempoInformation ModelTempoInformation; +typedef struct _ModelTempoInformationIface ModelTempoInformationIface; +typedef struct _ModelProjectPrivate ModelProjectPrivate; + +#define TYPE_TIME_CODE (time_code_get_type ()) +typedef struct _TimeCode TimeCode; + +#define VIEW_TYPE_MEDIA_ENGINE (view_media_engine_get_type ()) +#define VIEW_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngine)) +#define VIEW_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass)) +#define VIEW_IS_MEDIA_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VIEW_TYPE_MEDIA_ENGINE)) +#define VIEW_IS_MEDIA_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VIEW_TYPE_MEDIA_ENGINE)) +#define VIEW_MEDIA_ENGINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VIEW_TYPE_MEDIA_ENGINE, ViewMediaEngineClass)) + +typedef struct _ViewMediaEngine ViewMediaEngine; +typedef struct _ViewMediaEngineClass ViewMediaEngineClass; + +#define MODEL_TYPE_PROJECT_LOADER (model_project_loader_get_type ()) +#define MODEL_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoader)) +#define MODEL_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass)) +#define MODEL_IS_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT_LOADER)) +#define MODEL_IS_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT_LOADER)) +#define MODEL_PROJECT_LOADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass)) + +typedef struct _ModelProjectLoader ModelProjectLoader; +typedef struct _ModelProjectLoaderClass ModelProjectLoaderClass; + +#define MODEL_TYPE_UNDO_MANAGER (model_undo_manager_get_type ()) +#define MODEL_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManager)) +#define MODEL_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass)) +#define MODEL_IS_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_UNDO_MANAGER)) +#define MODEL_IS_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_UNDO_MANAGER)) +#define MODEL_UNDO_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass)) + +typedef struct _ModelUndoManager ModelUndoManager; +typedef struct _ModelUndoManagerClass ModelUndoManagerClass; + +#define MODEL_TYPE_LIBRARY_IMPORTER (model_library_importer_get_type ()) +#define MODEL_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporter)) +#define MODEL_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass)) +#define MODEL_IS_LIBRARY_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_LIBRARY_IMPORTER)) +#define MODEL_IS_LIBRARY_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_LIBRARY_IMPORTER)) +#define MODEL_LIBRARY_IMPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_LIBRARY_IMPORTER, ModelLibraryImporterClass)) + +typedef struct _ModelLibraryImporter ModelLibraryImporter; +typedef struct _ModelLibraryImporterClass ModelLibraryImporterClass; + +typedef enum { + MODEL_MEDIA_TYPE_AUDIO, + MODEL_MEDIA_TYPE_VIDEO +} ModelMediaType; + +struct _ModelTrack { + GObject parent_instance; + ModelTrackPrivate * priv; + ModelProject* project; + GeeArrayList* clips; + char* display_name; +}; + +struct _ModelTrackClass { + GObjectClass parent_class; + char* (*name) (ModelTrack* self); + ModelMediaType (*media_type) (ModelTrack* self); + gboolean (*check) (ModelTrack* self, ModelClip* clip); + void (*on_clip_updated) (ModelTrack* self, ModelClip* clip); + void (*write_attributes) (ModelTrack* self, FILE* f); +}; + +struct _ModelVideoTrack { + ModelTrack parent_instance; + ModelVideoTrackPrivate * priv; +}; + +struct _ModelVideoTrackClass { + ModelTrackClass parent_class; +}; + +struct _Fraction { + gint numerator; + gint denominator; +}; + +struct _ModelClip { + GObject parent_instance; + ModelClipPrivate * priv; + ModelClipFile* clipfile; + ModelMediaType type; + gboolean is_recording; + char* name; +}; + +struct _ModelClipClass { + GObjectClass parent_class; +}; + +struct _ModelTempoInformationIface { + GTypeInterface parent_iface; + void (*get_time_signature) (ModelTempoInformation* self, Fraction* result); + gint (*get_bpm) (ModelTempoInformation* self); +}; + +struct _TimeCode { + gint hour; + gint minute; + gint second; + gint frame; + gboolean drop_code; +}; + +struct _ModelProject { + GObject parent_instance; + ModelProjectPrivate * priv; + GeeArrayList* tracks; + GeeArrayList* inactive_tracks; + GeeArrayList* clipfiles; + ViewMediaEngine* media_engine; + char* project_file; + ModelProjectLoader* loader; + ModelUndoManager* undo_manager; + ModelLibraryImporter* importer; + Fraction default_framerate; + gboolean click_during_play; + gboolean click_during_record; + double click_volume; + gboolean library_visible; + gint library_width; + gboolean snap_to_clip; +}; + +struct _ModelProjectClass { + GObjectClass parent_class; + void (*get_clip_time) (ModelProject* self, ModelClipFile* f, TimeCode* result); + char* (*get_project_file) (ModelProject* self); + void (*do_append) (ModelProject* self, ModelTrack* track, ModelClipFile* clipfile, const char* name, gint64 insert_time); + void (*add_track) (ModelProject* self, ModelTrack* track); + void (*insert_track) (ModelProject* self, gint index, ModelTrack* track); + void (*load) (ModelProject* self, const char* fname); + void (*save) (ModelProject* self, const char* filename); + char* (*get_app_name) (ModelProject* self); + void (*load_complete) (ModelProject* self); +}; + + +extern Fraction model_project_INVALID_FRAME_RATE; +static gpointer model_video_track_parent_class = NULL; + +GType model_track_get_type (void); +GType model_media_type_get_type (void); +GType model_clip_get_type (void); +GType model_project_get_type (void); +GType model_video_track_get_type (void); +enum { + MODEL_VIDEO_TRACK_DUMMY_PROPERTY +}; +ModelTrack* model_track_construct (GType object_type, ModelProject* project, const char* display_name); +ModelVideoTrack* model_video_track_new (ModelProject* project); +ModelVideoTrack* model_video_track_construct (GType object_type, ModelProject* project); +static char* model_video_track_real_name (ModelTrack* base); +static ModelMediaType model_video_track_real_media_type (ModelTrack* base); +GType fraction_get_type (void); +Fraction* fraction_dup (const Fraction* self); +void fraction_free (Fraction* self); +GType model_clip_file_get_type (void); +gboolean model_clip_file_is_online (ModelClipFile* self); +gboolean model_video_track_get_framerate (ModelVideoTrack* self, Fraction* rate); +gboolean model_clip_file_get_frame_rate (ModelClipFile* self, Fraction* rate); +gboolean fraction_equal (Fraction *self, Fraction* f); +static gboolean model_video_track_real_check (ModelTrack* base, ModelClip* clip); +static gint64 model_video_track_frame_to_time (ModelVideoTrack* self, gint frame); +gint time_to_frame_with_rate (gint64 time, Fraction* rate); +static gint model_video_track_time_to_frame (ModelVideoTrack* self, gint64 time); +gint model_video_track_get_current_frame (ModelVideoTrack* self, gint64 time); +gint64 model_video_track_previous_frame (ModelVideoTrack* self, gint64 position); +gint64 model_video_track_next_frame (ModelVideoTrack* self, gint64 position); +GType model_tempo_information_get_type (void); +GType time_code_get_type (void); +TimeCode* time_code_dup (const TimeCode* self); +void time_code_free (TimeCode* self); +GType view_media_engine_get_type (void); +GType model_project_loader_get_type (void); +gpointer model_undo_manager_ref (gpointer instance); +void model_undo_manager_unref (gpointer instance); +GParamSpec* model_param_spec_undo_manager (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_undo_manager (GValue* value, gpointer v_object); +void model_value_take_undo_manager (GValue* value, gpointer v_object); +gpointer model_value_get_undo_manager (const GValue* value); +GType model_undo_manager_get_type (void); +GType model_library_importer_get_type (void); + + + +#line 11 "video_track.vala" +ModelVideoTrack* model_video_track_construct (GType object_type, ModelProject* project) { +#line 280 "video_track.c" + ModelVideoTrack * self; +#line 11 "video_track.vala" + g_return_val_if_fail (MODEL_IS_PROJECT (project), NULL); +#line 12 "video_track.vala" + self = (ModelVideoTrack*) model_track_construct (object_type, project, "Video Track"); +#line 286 "video_track.c" + return self; +} + + +#line 11 "video_track.vala" +ModelVideoTrack* model_video_track_new (ModelProject* project) { +#line 11 "video_track.vala" + return model_video_track_construct (MODEL_TYPE_VIDEO_TRACK, project); +#line 295 "video_track.c" +} + + +#line 15 "video_track.vala" +static char* model_video_track_real_name (ModelTrack* base) { +#line 301 "video_track.c" + ModelVideoTrack * self; + char* result = NULL; + self = MODEL_VIDEO_TRACK (base); + result = g_strdup ("video"); +#line 15 "video_track.vala" + return result; +#line 308 "video_track.c" +} + + +#line 17 "video_track.vala" +static ModelMediaType model_video_track_real_media_type (ModelTrack* base) { +#line 314 "video_track.c" + ModelVideoTrack * self; + ModelMediaType result = 0; + self = MODEL_VIDEO_TRACK (base); + result = MODEL_MEDIA_TYPE_VIDEO; +#line 18 "video_track.vala" + return result; +#line 321 "video_track.c" +} + + +#line 21 "video_track.vala" +static gboolean model_video_track_real_check (ModelTrack* base, ModelClip* clip) { +#line 327 "video_track.c" + ModelVideoTrack * self; + gboolean result = FALSE; + Fraction rate1 = {0}; + Fraction rate2 = {0}; + self = MODEL_VIDEO_TRACK (base); +#line 21 "video_track.vala" + g_return_val_if_fail (MODEL_IS_CLIP (clip), FALSE); +#line 25 "video_track.vala" + if (!model_clip_file_is_online (clip->clipfile)) { +#line 337 "video_track.c" + result = TRUE; +#line 26 "video_track.vala" + return result; +#line 341 "video_track.c" + } +#line 28 "video_track.vala" + if (gee_collection_get_size (GEE_COLLECTION (MODEL_TRACK (self)->clips)) == 0) { +#line 345 "video_track.c" + result = TRUE; +#line 29 "video_track.vala" + return result; +#line 349 "video_track.c" + } +#line 31 "video_track.vala" + if (!model_video_track_get_framerate (self, &rate2)) { +#line 32 "video_track.vala" + g_signal_emit_by_name (MODEL_TRACK (self), "error-occurred", "Cannot get initial frame rate!", NULL); +#line 355 "video_track.c" + result = FALSE; +#line 33 "video_track.vala" + return result; +#line 359 "video_track.c" + } +#line 36 "video_track.vala" + if (!model_clip_file_get_frame_rate (clip->clipfile, &rate1)) { +#line 37 "video_track.vala" + g_signal_emit_by_name (MODEL_TRACK (self), "error-occurred", "can't get frame rate", NULL); +#line 365 "video_track.c" + result = FALSE; +#line 38 "video_track.vala" + return result; +#line 369 "video_track.c" + } +#line 41 "video_track.vala" + if (!fraction_equal (&rate1, &rate2)) { +#line 42 "video_track.vala" + g_signal_emit_by_name (MODEL_TRACK (self), "error-occurred", "can't insert clip with different frame rate", NULL); +#line 375 "video_track.c" + result = FALSE; +#line 43 "video_track.vala" + return result; +#line 379 "video_track.c" + } + result = TRUE; +#line 45 "video_track.vala" + return result; +#line 384 "video_track.c" +} + + +#line 63 "video_track.vala" +static gint64 model_video_track_frame_to_time (ModelVideoTrack* self, gint frame) { +#line 390 "video_track.c" + gint64 result = 0LL; + Fraction rate = {0}; +#line 63 "video_track.vala" + g_return_val_if_fail (MODEL_IS_VIDEO_TRACK (self), 0LL); +#line 65 "video_track.vala" + if (!model_video_track_get_framerate (self, &rate)) { +#line 397 "video_track.c" + result = (gint64) 0; +#line 66 "video_track.vala" + return result; +#line 401 "video_track.c" + } + result = (gint64) gst_util_uint64_scale ((guint64) frame, (guint64) (GST_SECOND * rate.denominator), (guint64) rate.numerator); +#line 68 "video_track.vala" + return result; +#line 406 "video_track.c" +} + + +#line 71 "video_track.vala" +static gint model_video_track_time_to_frame (ModelVideoTrack* self, gint64 time) { +#line 412 "video_track.c" + gint result = 0; + Fraction rate = {0}; +#line 71 "video_track.vala" + g_return_val_if_fail (MODEL_IS_VIDEO_TRACK (self), 0); +#line 73 "video_track.vala" + if (!model_video_track_get_framerate (self, &rate)) { +#line 419 "video_track.c" + result = 0; +#line 74 "video_track.vala" + return result; +#line 423 "video_track.c" + } + result = time_to_frame_with_rate (time, &rate); +#line 75 "video_track.vala" + return result; +#line 428 "video_track.c" +} + + +#line 78 "video_track.vala" +gint model_video_track_get_current_frame (ModelVideoTrack* self, gint64 time) { +#line 434 "video_track.c" + gint result = 0; +#line 78 "video_track.vala" + g_return_val_if_fail (MODEL_IS_VIDEO_TRACK (self), 0); +#line 438 "video_track.c" + result = model_video_track_time_to_frame (self, time); +#line 79 "video_track.vala" + return result; +#line 442 "video_track.c" +} + + +#line 82 "video_track.vala" +gint64 model_video_track_previous_frame (ModelVideoTrack* self, gint64 position) { +#line 448 "video_track.c" + gint64 result = 0LL; + gint frame; +#line 82 "video_track.vala" + g_return_val_if_fail (MODEL_IS_VIDEO_TRACK (self), 0LL); +#line 83 "video_track.vala" + frame = model_video_track_time_to_frame (self, position); +#line 455 "video_track.c" + result = model_video_track_frame_to_time (self, frame - 1); +#line 84 "video_track.vala" + return result; +#line 459 "video_track.c" +} + + +#line 87 "video_track.vala" +gint64 model_video_track_next_frame (ModelVideoTrack* self, gint64 position) { +#line 465 "video_track.c" + gint64 result = 0LL; + gint frame; +#line 87 "video_track.vala" + g_return_val_if_fail (MODEL_IS_VIDEO_TRACK (self), 0LL); +#line 88 "video_track.vala" + frame = model_video_track_time_to_frame (self, position); +#line 472 "video_track.c" + result = model_video_track_frame_to_time (self, frame + 1); +#line 89 "video_track.vala" + return result; +#line 476 "video_track.c" +} + + +#line 92 "video_track.vala" +gboolean model_video_track_get_framerate (ModelVideoTrack* self, Fraction* rate) { +#line 482 "video_track.c" + gboolean result = FALSE; +#line 92 "video_track.vala" + g_return_val_if_fail (MODEL_IS_VIDEO_TRACK (self), FALSE); +#line 93 "video_track.vala" + if (gee_collection_get_size (GEE_COLLECTION (MODEL_TRACK (self)->clips)) == 0) { +#line 488 "video_track.c" + result = FALSE; +#line 94 "video_track.vala" + return result; +#line 492 "video_track.c" + } + { + GeeIterator* _c_it; + _c_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (MODEL_TRACK (self)->clips)); +#line 96 "video_track.vala" + while (TRUE) { +#line 499 "video_track.c" + ModelClip* c; +#line 96 "video_track.vala" + if (!gee_iterator_next (_c_it)) { +#line 96 "video_track.vala" + break; +#line 505 "video_track.c" + } +#line 96 "video_track.vala" + c = (ModelClip*) gee_iterator_get (_c_it); +#line 97 "video_track.vala" + if (model_clip_file_is_online (c->clipfile)) { +#line 511 "video_track.c" + gboolean can; +#line 98 "video_track.vala" + can = model_clip_file_get_frame_rate (c->clipfile, rate); +#line 99 "video_track.vala" + g_assert (can); +#line 517 "video_track.c" + result = can; + _g_object_unref0 (c); + _g_object_unref0 (_c_it); +#line 101 "video_track.vala" + return result; +#line 523 "video_track.c" + } + _g_object_unref0 (c); + } + _g_object_unref0 (_c_it); + } +#line 105 "video_track.vala" + if (fraction_equal (&MODEL_TRACK (self)->project->default_framerate, &model_project_INVALID_FRAME_RATE)) { +#line 531 "video_track.c" + result = FALSE; +#line 106 "video_track.vala" + return result; +#line 535 "video_track.c" + } +#line 108 "video_track.vala" + *rate = MODEL_TRACK (self)->project->default_framerate; +#line 539 "video_track.c" + result = TRUE; +#line 109 "video_track.vala" + return result; +#line 543 "video_track.c" +} + + +static void model_video_track_class_init (ModelVideoTrackClass * klass) { + model_video_track_parent_class = g_type_class_peek_parent (klass); + MODEL_TRACK_CLASS (klass)->name = model_video_track_real_name; + MODEL_TRACK_CLASS (klass)->media_type = model_video_track_real_media_type; + MODEL_TRACK_CLASS (klass)->check = model_video_track_real_check; +} + + +static void model_video_track_instance_init (ModelVideoTrack * self) { +} + + +GType model_video_track_get_type (void) { + static volatile gsize model_video_track_type_id__volatile = 0; + if (g_once_init_enter (&model_video_track_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelVideoTrackClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_video_track_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelVideoTrack), 0, (GInstanceInitFunc) model_video_track_instance_init, NULL }; + GType model_video_track_type_id; + model_video_track_type_id = g_type_register_static (MODEL_TYPE_TRACK, "ModelVideoTrack", &g_define_type_info, 0); + g_once_init_leave (&model_video_track_type_id__volatile, model_video_track_type_id); + } + return model_video_track_type_id__volatile; +} + + + + diff --git a/src/marina/marina/video_track.o b/src/marina/marina/video_track.o new file mode 100644 index 0000000..42fcd47 Binary files /dev/null and b/src/marina/marina/video_track.o differ diff --git a/src/marina/project.vala b/src/marina/project.vala new file mode 100644 index 0000000..22b1d93 --- /dev/null +++ b/src/marina/project.vala @@ -0,0 +1,1143 @@ +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +using Logging; + +extern const string _VERSION; + +namespace Model { +public class MediaLoaderHandler : LoaderHandler { + protected weak Project the_project; + protected Track current_track; + + Gee.ArrayList clipfetchers = new Gee.ArrayList(); + int num_clipfiles_complete; + + public MediaLoaderHandler(Project the_project) { + this.the_project = the_project; + current_track = null; + } + + public override bool commit_marina(string[] attr_names, string[] attr_values) { + int number_of_attributes = attr_names.length; + if (number_of_attributes != 1 || + attr_names[0] != "version") { + load_error("Missing version information"); + return false; + } + + if (the_project.get_file_version() < attr_values[0].to_int()) { + load_error("Version mismatch! (File Version: %d, App Version: %d)".printf( + the_project.get_file_version(), attr_values[0].to_int())); + return false; + } + + num_clipfiles_complete = 0; + return true; + } + + public override bool commit_library(string[] attr_names, string[] attr_values) { + // We return true since framerate is an optional parameter + if (attr_names.length != 1) + return true; + + if (attr_names[0] != "framerate") { + load_error("Missing framerate tag"); + return false; + } + + string[] arr = attr_values[0].split("/"); + if (arr.length != 2) { + load_error("Invalid framerate attribute"); + return false; + } + + the_project.set_default_framerate(Fraction(arr[0].to_int(), arr[1].to_int())); + return true; + } + + public override bool commit_track(string[] attr_names, string[] attr_values) { + assert(current_track == null); + + int number_of_attributes = attr_names.length; + string? name = null; + string? type = null; + for (int i = 0; i < number_of_attributes; ++i) { + switch(attr_names[i]) { + case "type": + type = attr_values[i]; + break; + case "name": + name = attr_values[i]; + break; + default: + break; + } + } + + if (name == null) { + load_error("Missing track name"); + return false; + } + + if (type == null) { + load_error("Missing track type"); + return false; + } + + if (type == "audio") { + AudioTrack audio_track = new AudioTrack(the_project, name); + current_track = audio_track; + the_project.add_track(current_track); + + for (int i = 0; i < number_of_attributes; ++i) { + switch(attr_names[i]) { + case "panorama": + audio_track._set_pan(attr_values[i].to_double()); + break; + case "volume": + audio_track._set_volume(attr_values[i].to_double()); + break; + case "channels": + audio_track.set_default_num_channels(attr_values[i].to_int()); + break; + default: + break; + } + } + return true; + } else if (type == "video") { + current_track = new VideoTrack(the_project); + the_project.add_track(current_track); + } + + return base.commit_track(attr_names, attr_values); + } + + public override void leave_track() { + assert(current_track != null); + current_track = null; + } + + public override bool commit_clip(string[] attr_names, string[] attr_values) { + assert(current_track != null); + + int number_of_attributes = attr_names.length; + int id = -1; + string? clip_name = null; + int64 start = -1; + int64 media_start = -1; + int64 duration = -1; + for (int i = 0; i < number_of_attributes; i++) { + switch (attr_names[i]) { + case "id": + id = attr_values[i].to_int(); + break; + case "name": + clip_name = attr_values[i]; + break; + case "start": + start = attr_values[i].to_int64(); + break; + case "media-start": + media_start = attr_values[i].to_int64(); + break; + case "duration": + duration = attr_values[i].to_int64(); + break; + default: + // TODO: we need a way to deal with orphaned attributes, for now, reject the file + load_error("Unknown attribute %s".printf(attr_names[i])); + return false; + } + } + + if (id == -1) { + load_error("missing clip id"); + return false; + } + + if (clip_name == null) { + load_error("missing clip_name"); + return false; + } + + if (start == -1) { + load_error("missing start time"); + return false; + } + + if (media_start == -1) { + load_error("missing media_start"); + return false; + } + + if (duration == -1) { + load_error("missing duration"); + return false; + } + + if (id >= clipfetchers.size) { + load_error("clip file id %s was not loaded".printf(clip_name)); + return false; + } + + Clip clip = new Clip(clipfetchers[id].clipfile, current_track.media_type(), clip_name, + start, media_start, duration, false); + current_track.add(clip, start, false); + return true; + } + + void fetcher_ready(Fetcher f) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "fetcher_ready"); + if (f.error_string != null) { + load_error("Could not load %s.".printf(f.clipfile.filename)); + warning("Could not load %s: %s", f.clipfile.filename, f.error_string); + } + the_project.add_clipfile(f.clipfile); + num_clipfiles_complete++; + if (num_clipfiles_complete == clipfetchers.size) { + complete(); + } + } + + public override bool commit_clipfile(string[] attr_names, string[] attr_values) { + string filename = null; + int id = -1; + + for (int i = 0; i < attr_names.length; i++) { + if (attr_names[i] == "filename") { + filename = attr_values[i]; + } else if (attr_names[i] == "id") { + id = attr_values[i].to_int(); + } + } + + if (filename == null) { + load_error("Invalid clipfile filename"); + return false; + } + + if (id < 0) { + load_error("Invalid clipfile id"); + return false; + } + + try { + ClipFetcher fetcher = new ClipFetcher(filename); + fetcher.ready.connect(fetcher_ready); + clipfetchers.insert(id, fetcher); + } catch (Error e) { + load_error(e.message); + return false; + } + return true; + } + + public override bool commit_tempo_entry(string[] attr_names, string[] attr_values) { + if (attr_names[0] != "tempo") { + load_error("Invalid attribute on tempo entry"); + return false; + } + + the_project._set_bpm(attr_values[0].to_int()); + return true; + } + + public override bool commit_time_signature_entry(string[] attr_names, string[] attr_values) { + if (attr_names[0] != "signature") { + load_error("Invalid attribute on time signature"); + return false; + } + + the_project._set_time_signature(Fraction.from_string(attr_values[0])); + return true; + } + + public override bool commit_click(string[] attr_names, string[] attr_values) { + for (int i = 0; i < attr_names.length; ++i) { + switch (attr_names[i]) { + case "on_play": + the_project.click_during_play = attr_values[i] == "true"; + break; + case "on_record": + the_project.click_during_record = attr_values[i] == "true"; + break; + case "volume": + the_project.click_volume = attr_values[i].to_double(); + break; + default: + load_error("unknown attribute for click '%s'".printf(attr_names[i])); + return false; + } + } + return true; + } + + public override bool commit_library_preference(string[] attr_names, string[] attr_values) { + for (int i = 0; i < attr_names.length; ++i) { + switch (attr_names[i]) { + case "width": + the_project.library_width = attr_values[i].to_int(); + break; + case "visible": + the_project.library_visible = attr_values[i] == "true"; + break; + default: + load_error("unknown attribute for library '%s'".printf(attr_names[i])); + return false; + } + } + return true; + } + + public override void leave_library() { + if (clipfetchers.size == 0) + complete(); + } +} + +public abstract class Project : TempoInformation, Object { + public const string FILLMORE_FILE_EXTENSION = "fill"; + public const string FILLMORE_FILE_FILTER = "*." + FILLMORE_FILE_EXTENSION; + public const string LOMBARD_FILE_EXTENSION = "lom"; + public const string LOMBARD_FILE_FILTER = "*." + LOMBARD_FILE_EXTENSION; + + const string license = """ +%s 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. + +%s 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 %s; if not, write to the Free Software Foundation, Inc., +51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +"""; + + public const string[] authors = { + "Robert Powell ", + "Adam Dingle ", + "Andrew O'Mahony ", + "Dru Moore ", + null + }; + + public Gee.ArrayList tracks = new Gee.ArrayList(); + public Gee.ArrayList inactive_tracks = new Gee.ArrayList(); + Gee.HashSet pending = new Gee.HashSet(); + Gee.ArrayList pending_thumbs = new Gee.ArrayList(); + protected Gee.ArrayList clipfiles = new Gee.ArrayList(); + // TODO: media_engine is a member of project only temporarily. It will be + // less work to move it to fillmore/lombard once we have a transport class. + public View.MediaEngine media_engine; + + protected string project_file; // may be null if project has not yet been saved + public ProjectLoader loader; + + FetcherCompletion fetcher_completion; + public UndoManager undo_manager; + public LibraryImporter importer; + + public Fraction default_framerate; + int tempo = 120; + Fraction time_signature = Fraction(4, 4); + public bool click_during_play = false; + public bool click_during_record = true; + public double click_volume = 0.8; + public bool library_visible = true; + public int library_width = 600; + public bool snap_to_clip; + + /* TODO: + * This can't be const since the Vala compiler (0.7.7) crashes if we try to make it a const. + * I've filed a bug with the Vala bugzilla for this: + * https://bugzilla.gnome.org/show_bug.cgi?id=598204 + */ + public static Fraction INVALID_FRAME_RATE = Fraction(-1, 1); + + public signal void playstate_changed(PlayState playstate); + + public signal void name_changed(string? project_file); + public signal void load_error(string error); + public virtual signal void load_complete() { + } + + public signal void closed(); + + public signal void track_added(Track track); + public signal void track_removed(Track track); + public signal void error_occurred(string major_message, string? minor_message); + + public signal void clipfile_added(ClipFile c); + public signal void clipfile_removed(ClipFile clip_file); + public signal void cleared(); + + public abstract TimeCode get_clip_time(ClipFile f); + + public Project(string? filename, bool include_video) throws Error { + undo_manager = new UndoManager(); + project_file = filename; + + media_engine = new View.MediaEngine(this, include_video); + track_added.connect(media_engine.on_track_added); + media_engine.playstate_changed.connect(on_playstate_changed); + media_engine.error_occurred.connect(on_error_occurred); + + set_default_framerate(INVALID_FRAME_RATE); + } + + public void on_playstate_changed() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_playstate_changed"); + switch (media_engine.get_play_state()) { + case PlayState.STOPPED: + ClearTrackMeters(); + break; + case PlayState.CLOSED: + closed(); + break; + } + playstate_changed(media_engine.get_play_state()); + } + + public virtual string? get_project_file() { + return project_file; + } + + public ClipFile? get_clipfile(int index) { + if (index < 0 || + index >= clipfiles.size) + return null; + return clipfiles[index]; + } + + public int get_clipfile_index(ClipFile find) { + int i = 0; + foreach (ClipFile f in clipfiles) { + if (f == find) + return i; + i++; + } + return -1; + } + + public Track? track_from_clip(Clip clip) { + foreach (Track track in tracks) { + foreach (Clip match in track.clips) { + if (match == clip) { + return track; + } + } + } + return null; + } + + public void print_graph(Gst.Bin bin, string file_name) { + Gst.debug_bin_to_dot_file_with_ts(bin, Gst.DebugGraphDetails.ALL, file_name); + } + + public int64 get_length() { + int64 max = 0; + foreach (Track track in tracks) { + max = int64.max(max, track.get_length()); + } + return max; + } + + public int64 snap_clip(Clip c, int64 span) { + foreach (Track track in tracks) { + int64 new_start = track.snap_clip(c, span); + if (new_start != c.start) { + return new_start; + } + } + return c.start; + } + + public void snap_coord(out int64 coord, int64 span) { + foreach (Track track in tracks) { + if (track.snap_coord(out coord, span)) { + break; + } + } + } + + Gap get_gap_intersection(Gap gap) { + Gap intersection = gap; + + foreach (Track track in tracks) { + intersection = intersection.intersect(track.find_first_gap(intersection.start)); + } + + return intersection; + } + + public bool can_delete_gap(Gap gap) { + Gap intersection = get_gap_intersection(gap); + return !intersection.is_empty(); + } + + public void delete_gap(Gap gap) { + Gap intersection = get_gap_intersection(gap); + assert(!intersection.is_empty()); + + foreach (Track track in tracks) { + track.delete_gap(intersection); + } + } + + protected virtual void do_append(Track track, ClipFile clipfile, string name, + int64 insert_time) { + switch(track.media_type()) { + case MediaType.AUDIO: + if (clipfile.audio_caps == null) { + return; + } + break; + case MediaType.VIDEO: + if (clipfile.video_caps == null) { + return; + } + break; + } + + Clip clip = new Clip(clipfile, track.media_type(), name, 0, 0, clipfile.length, false); + track.append_at_time(clip, insert_time, true); + } + + public void append(Track track, ClipFile clipfile) { + string name = isolate_filename(clipfile.filename); + int64 insert_time = 0; + + foreach (Track temp_track in tracks) { + insert_time = int64.max(insert_time, temp_track.get_length()); + } + do_append(track, clipfile, name, insert_time); + } + + public void add(Track track, ClipFile clipfile, int64 time) { + string name = isolate_filename(clipfile.filename); + do_append(track, clipfile, name, time); + } + + public void on_clip_removed(Track t, Clip clip) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_removed"); + reseek(); + } + + public void split_at_playhead() { + string description = "Split At Playhead"; + undo_manager.start_transaction(description); + foreach (Track track in tracks) { + if (track.get_clip_by_position(transport_get_position()) != null) { + track.split_at(transport_get_position()); + } + } + undo_manager.end_transaction(description); + } + + public bool can_trim(out bool left) { + Clip first_clip = null; + + // When trimming multiple clips, we allow trimming left only if both clips already start + // at the same position, and trimming right only if both clips already end at the same + // position. + + int64 start = 0; + int64 end = 0; + bool start_same = true; + bool end_same = true; + foreach (Track track in tracks) { + Clip clip = track.get_clip_by_position(transport_get_position()); + if (first_clip != null && clip != null) { + start_same = start_same && start == clip.start; + end_same = end_same && end == clip.end; + } else if (clip != null) { + first_clip = clip; + start = first_clip.start; + end = first_clip.end; + } + } + + if (first_clip == null) { + return false; + } + + if (start_same && !end_same) { + left = true; + return true; + } + + if (!start_same && end_same) { + left = false; + return true; + } + + // which half of the clip are we closer to? + left = (transport_get_position() - first_clip.start < first_clip.duration / 2); + return true; + } + + public void trim_to_playhead() { + bool left; + if (!can_trim(out left)) { + return; + } + string description = "Trim To Playhead"; + Clip first_clip = null; + undo_manager.start_transaction(description); + foreach (Track track in tracks) { + Clip clip = track.get_clip_by_position(transport_get_position()); + if (clip != null) { + int64 delta; + if (left) { + delta = transport_get_position() - clip.start; + } else { + delta = transport_get_position() - clip.end; + } + track.trim(clip, delta, left ? Gdk.WindowEdge.WEST : Gdk.WindowEdge.EAST); + } + } + undo_manager.end_transaction(description); + + if (left && first_clip != null) { + transport_go(first_clip.start); + } + } + + public void transport_go(int64 position) { + media_engine.go(position); + } + + public bool transport_is_playing() { + return media_engine.playing; + } + + public bool transport_is_recording() { + return media_engine.get_play_state() == PlayState.PRE_RECORD || + media_engine.get_play_state() == PlayState.RECORDING; + } + + public bool playhead_on_clip() { + foreach (Track track in tracks) { + if (track.get_clip_by_position(transport_get_position()) != null) { + return true; + } + } + return false; + } + + public bool playhead_on_contiguous_clip() { + foreach (Track track in tracks) { + if (track.are_contiguous_clips(transport_get_position())) { + return true; + } + } + return false; + } + + public bool is_duplicate_track_name(Track? track, string new_name) { + assert(new_name != ""); + foreach (Track this_track in tracks) { + if (track != this_track) { + if (this_track.get_display_name() == new_name) { + return true; + } + } + } + + foreach (Track this_track in inactive_tracks) { + if (track != this_track) { + if (this_track.get_display_name() == new_name) { + return true; + } + } + } + return false; + } + + public virtual void add_track(Track track) { + track.clip_removed.connect(on_clip_removed); + track.error_occurred.connect(on_error_occurred); + tracks.add(track); + track_added(track); + } + public virtual void insert_track(int index, Track track) { + if (0 > index) index = 0; + if (tracks.size <= index) { + add_track(track); + } + else { + track.clip_removed.connect(on_clip_removed); + track.error_occurred.connect(on_error_occurred); + tracks.insert(index, track); + track_added(track); + } + } + + public void add_inactive_track(Track track) { + track.hide(); + inactive_tracks.add(track); + } + + public void remove_track(Track track) { + media_engine.pipeline.set_state(Gst.State.NULL); + track.track_removed(track); + tracks.remove(track); + track_removed(track); + } + + public void remove_track_at(int index) { + remove_track(tracks.get(index)); + } + + public void add_clipfile(ClipFile clipfile) { + Model.Command command = new Model.AddClipCommand(this, clipfile); + do_command(command); + } + + public void _add_clipfile(ClipFile clipfile) throws Error { + clipfiles.add(clipfile); + if (clipfile.is_online() && clipfile.is_of_type(MediaType.VIDEO)) { + ThumbnailFetcher fetcher = new ThumbnailFetcher(clipfile, 0); + fetcher.ready.connect(on_thumbnail_ready); + pending_thumbs.add(fetcher); + } else { + clipfile_added(clipfile); + } + } + + void on_thumbnail_ready(Fetcher f) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_thumbnail_ready"); + clipfile_added(f.clipfile); + pending_thumbs.remove(f as ThumbnailFetcher); + } + + public bool clipfile_on_track(string filename) { + ClipFile cf = find_clipfile(filename); + + foreach (Track t in tracks) { + foreach (Clip c in t.clips) { + if (c.clipfile == cf) + return true; + } + } + + foreach (Track t in inactive_tracks) { + foreach (Clip c in t.clips) { + if (c.clipfile == cf) + return true; + } + } + + return false; + } + + void delete_clipfile_from_tracks(ClipFile cf) { + foreach (Track t in tracks) { + for (int i = 0; i < t.clips.size; i++) { + if (t.clips[i].clipfile == cf) { + t.delete_clip(t.clips[i]); + i --; + } + } + } + + foreach (Track t in inactive_tracks) { + for (int i = 0; i < t.clips.size; i++) { + if (t.clips[i].clipfile == cf) { + t.delete_clip(t.clips[i]); + i --; + } + } + } + } + + public void _remove_clipfile(ClipFile cf) { + clipfiles.remove(cf); + clipfile_removed(cf); + } + + public void remove_clipfile(string filename) { + ClipFile cf = find_clipfile(filename); + if (cf != null) { + string description = "Delete From Library"; + undo_manager.start_transaction(description); + + delete_clipfile_from_tracks(cf); + + Command clipfile_delete = new ClipFileDeleteCommand(this, cf); + do_command(clipfile_delete); + + undo_manager.end_transaction(description); + } + } + + public ClipFile? find_clipfile(string filename) { + foreach (ClipFile cf in clipfiles) + if (cf.filename == filename) + return cf; + return null; + } + + public void reseek() { transport_go(transport_get_position()); } + + public void go_start() { transport_go(0); } + + public void go_end() { transport_go(get_length()); } + + public void go_previous() { + int64 start_pos = transport_get_position(); + + // If we're currently playing, we jump to the previous clip if we're within the first + // second of the current clip. + if (transport_is_playing()) + start_pos -= 1 * Gst.SECOND; + + int64 new_position = 0; + foreach (Track track in tracks) { + new_position = int64.max(new_position, track.previous_edit(start_pos)); + } + transport_go(new_position); + } + + // Move to the next clip boundary after the current transport position. + public void go_next() { + int64 start_pos = transport_get_position(); + int64 new_position = get_length(); + foreach (Track track in tracks) { + if (track.get_length() > start_pos) { + new_position = int64.min(new_position, track.next_edit(start_pos)); + } + } + transport_go(new_position); + } + + public int64 transport_get_position() { + return media_engine.position; + } + + public void set_name(string? filename) { + if (filename != null) { + this.project_file = filename; + } + name_changed(filename); + } + + public void set_default_framerate(Fraction rate) { + default_framerate = rate; + } + + public string get_file_display_name() { + string filename = get_project_file(); + if (filename == null) { + return "Unsaved Project - %s".printf(get_app_name()); + } + else { + string dir = Path.get_dirname(filename); + string name = Path.get_basename(filename); + string home_path = GLib.Environment.get_home_dir(); + + if (dir == ".") + dir = GLib.Environment.get_current_dir(); + + if (dir.has_prefix(home_path)) + dir = "~" + dir.substring(home_path.length); + return "%s (%s) - %s".printf(name, dir, get_app_name()); + } + } + + public void clear() { + media_engine.set_gst_state(Gst.State.NULL); + + foreach (Track track in tracks) { + track.delete_all_clips(); + track.track_removed(track); + track_removed(track); + } + + tracks.clear(); + + clipfiles.clear(); + set_name(null); + cleared(); + } + + public bool can_export() { + if (media_engine.get_play_state() != PlayState.STOPPED) { + return false; + } + foreach (Track track in tracks) { + if (track.get_length() > 0) { + return true; + } + } + return false; + } + + public void on_load_started(string filename) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_load_started"); + project_file = filename; + } + + void on_load_error(string error) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_load_error"); + load_error(error); + } + + void on_load_complete() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_load_complete"); + undo_manager.reset(); + set_name(project_file); + load_complete(); + } + + // Load a project file. The load is asynchronous: it may continue after this method returns. + // Any load error will be reported via the load_error signal, which may run either while this + // method executes or afterward. + public virtual void load(string? fname) { + emit(this, Facility.LOADING, Level.INFO, "loading project"); + clear(); + set_name(null); + if (fname == null) { + return; + } + + loader = new ProjectLoader(new MediaLoaderHandler(this), fname); + + loader.load_started.connect(on_load_started); + loader.load_error.connect(on_load_error); + loader.load_complete.connect(on_load_complete); + loader.load_complete.connect(media_engine.on_load_complete); + media_engine.set_play_state(PlayState.LOADING); + media_engine.pipeline.set_state(Gst.State.NULL); + loader.load(); + } + + public void on_error_occurred(string major_error, string? minor_error) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_error_occurred"); + error_occurred(major_error, minor_error); + } + + public int get_file_version() { + return 4; + } + + public void save_library(FileStream f) { + f.printf(" \n"); + + for (int i = 0; i < clipfiles.size; i++) { + f.printf(" \n", clipfiles[i].filename, i); + } + + f.printf(" \n"); + } + + public virtual void save(string? filename) { + if (filename != null) { + set_name(filename); + } + + FileStream f = FileStream.open(project_file, "w"); + if (f == null) { + error_occurred("Could not save project", + "%s: %s".printf(project_file, GLib.strerror(GLib.errno))); + return; + } + f.printf("\n", get_file_version()); + + save_library(f); + + f.printf(" \n"); + foreach (Track track in tracks) { + track.save(f); + } + + foreach (Track track in inactive_tracks) { + track.save(f); + } + f.printf(" \n"); + f.printf(" \n"); + f.printf(" \n", + click_during_play ? "true" : "false", + click_during_record ? "true" : "false", + click_volume); + f.printf(" \n", + library_width, library_visible ? "true" : "false"); + f.printf(" \n"); + f.printf(" \n"); + f.printf(" \n"); + f.printf(" \n", tempo); + f.printf(" \n"); + f.printf(" \n"); + f.printf(" \n", time_signature.to_string()); + f.printf(" \n"); + f.printf(" \n"); + + f.printf("\n"); + f.flush(); + + // TODO: clean up responsibility between dirty and undo + undo_manager.mark_clean(); + } + + public void close() { + media_engine.close(); + } + + public void on_importer_clip_complete(ClipFetcher fetcher) { + if (fetcher.error_string != null) { + error_occurred("Error importing clip", fetcher.error_string); + } else { + fetcher_completion.complete(fetcher); + } + } + + public void create_clip_fetcher(FetcherCompletion fetcher_completion, string filename) + throws Error { + ClipFetcher fetcher = new ClipFetcher(filename); + this.fetcher_completion = fetcher_completion; + fetcher.ready.connect(on_fetcher_ready); + pending.add(fetcher); + } + + // TODO: We should be using Library importer rather than this mechanism for fillmore + void on_fetcher_ready(Fetcher fetcher) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_fetcher_ready"); + pending.remove(fetcher as ClipFetcher); + if (fetcher.error_string != null) { + emit(this, Facility.DEVELOPER_WARNINGS, Level.INFO, fetcher.error_string); + error_occurred("Error retrieving clip", fetcher.error_string); + } else { + if (get_clipfile_index(fetcher.clipfile) == -1) { + add_clipfile(fetcher.clipfile); + } + fetcher_completion.complete(fetcher); + } + } + + public bool is_project_extension(string filename) { + string extension = get_file_extension(filename); + return extension == LOMBARD_FILE_EXTENSION || extension == FILLMORE_FILE_EXTENSION; + } + + public void do_command(Command the_command) { + undo_manager.do_command(the_command); + } + + public void undo() { + undo_manager.undo(); + } + + void ClearTrackMeters() { + foreach (Track track in tracks) { + AudioTrack audio_track = track as AudioTrack; + if (audio_track != null) { + audio_track.level_changed(-100, -100); + } + } + } + + public void create_clip_importer(Model.Track? track, bool timeline_add, + int64 time_to_add, bool both_tracks, Gtk.Window? progress_window_parent, int number) { + if (timeline_add) { + assert(track != null); + importer = new Model.TimelineImporter(track, this, time_to_add, both_tracks); + } else { + importer = new Model.LibraryImporter(this); + } + if (progress_window_parent != null) { + new MultiFileProgress(progress_window_parent, number, "Import", + importer.importer); + } + + } + + public string get_version() { + return _VERSION; + } + + public abstract string get_app_name(); + + public string get_license() { + return license.printf(get_app_name(), get_app_name(), get_app_name()); + } + + public void set_time_signature(Fraction time_signature) { + TimeSignatureCommand command = new TimeSignatureCommand(this, time_signature); + undo_manager.do_command(command); + } + + public void _set_time_signature(Fraction time_signature) { + this.time_signature = time_signature; + time_signature_changed(time_signature); + } + + public Fraction get_time_signature() { + return time_signature; + } + + public void set_bpm(int bpm) { + BpmCommand command = new BpmCommand(this, bpm); + undo_manager.do_command(command); + } + + public void _set_bpm(int bpm) { + this.tempo = bpm; + bpm_changed(bpm); + } + + public int get_bpm() { + return tempo; + } + + public string get_audio_path() { + string path = get_path(); + return path == null ? null : Path.build_filename(path, "audio files"); + } + + string get_path() { + return project_file == null ? null : Path.get_dirname(project_file); + } + + public VideoTrack? find_video_track() { + foreach (Track track in tracks) { + if (track is VideoTrack) { + return track as VideoTrack; + } + } + return null; + } + + public AudioTrack? find_audio_track() { + foreach (Track track in tracks) { + if (track is AudioTrack) { + return track as AudioTrack; + } + } + return null; + } +} +} + diff --git a/src/marina/singledecodebin.vala b/src/marina/singledecodebin.vala new file mode 100644 index 0000000..adf9153 --- /dev/null +++ b/src/marina/singledecodebin.vala @@ -0,0 +1,370 @@ +/* Ported to Vala from singledecodebin.py in Pitivi: + * + * Copyright (c) 2005, Edward Hervey + * + * This program 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 program 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 program; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +using Gee; +using Logging; + +extern void qsort(void *p, size_t num, size_t size, GLib.CompareFunc func); + +// Single-stream queue-less decodebin + +// returns true if the caps are RAW +bool is_raw(Gst.Caps caps) { + string rep = caps.to_string(); + string[] valid = { "video/x-raw", "audio/x-raw", "text/plain", "text/x-pango-markup" }; + foreach (string val in valid) + if (rep.has_prefix(val)) + return true; + return false; +} + +// A variant of decodebin. +// Only outputs one stream; doesn't contain any internal queue. +class SingleDecodeBin : Gst.Bin { + Gst.Caps caps; + Gst.Element typefind; + Gst.GhostPad srcpad; + + ArrayList dynamics = new ArrayList(); + ArrayList validelements = new ArrayList(); // added elements + Gst.ElementFactory[] factories; + + const int64 QUEUE_SIZE = 1 * Gst.SECOND; + + class construct { + Gst.PadTemplate sink_pad = new Gst.PadTemplate("sinkpadtemplate", Gst.PadDirection.SINK, + Gst.PadPresence.ALWAYS, new Gst.Caps.any()); + Gst.PadTemplate src_pad = new Gst.PadTemplate("srcpadtemplate", Gst.PadDirection.SINK, + Gst.PadPresence.ALWAYS, new Gst.Caps.any()); + + add_pad_template (src_pad); + add_pad_template (sink_pad); + } + + public SingleDecodeBin(Gst.Caps? caps, string name, string? uri) throws Error { + this.caps = caps == null ? new Gst.Caps.any() : caps; + + typefind = Gst.ElementFactory.make("typefind", "internal-typefind"); + add(typefind); + + if (uri != null) { + Gst.Element file_src = make_element("filesrc"); + + file_src.set("location", uri); + add(file_src); + + file_src.link(typefind); + } else { + Gst.GhostPad sinkpad = new Gst.GhostPad("sink", typefind.get_pad("sink")); + sinkpad.set_active(true); + add_pad(sinkpad); + } + Signal.connect(typefind, "have-type", (Callback) typefindHaveTypeCb, this); + + factories = getSortedFactoryList(); + } + + // internal methods + + void controlDynamicElement(Gst.Element element) { + dynamics.add(element); + element.pad_added.connect(dynamicPadAddedCb); + element.no_more_pads.connect(dynamicNoMorePadsCb); + } + + static int factory_compare(Gst.ElementFactory** a, Gst.ElementFactory** b) { + Gst.PluginFeature* p1 = *(Gst.PluginFeature**)a; + Gst.PluginFeature* p2 = *(Gst.PluginFeature**)b; + return (int) (((Gst.PluginFeature) p2).get_rank() - ((Gst.PluginFeature) p1).get_rank()); + } + + // Returns the list of demuxers, decoders and parsers available, sorted by rank + Gst.ElementFactory[] getSortedFactoryList() { + Gst.Registry registry = Gst.Registry.get_default(); + Gst.ElementFactory[] factories = new Gst.ElementFactory[0]; + + foreach (Gst.PluginFeature plugin_feature in + registry.get_feature_list(typeof(Gst.ElementFactory)) ) { + + Gst.ElementFactory factory = plugin_feature as Gst.ElementFactory; + if (factory == null || factory.get_rank() < 64) + continue; + string klass = factory.get_klass(); + if (klass.contains("Demuxer") || klass.contains("Decoder") || klass.contains("Parse")) + factories += factory; + } + + qsort(factories, factories.length, sizeof(Gst.ElementFactory *), + (GLib.CompareFunc) factory_compare); + return factories; + } + + /* Returns a list of factories (sorted by rank) which can take caps as + * input. Returns empty list if none are compatible. */ + Gee.ArrayList findCompatibleFactory(Gst.Caps caps) { + Gee.ArrayList res = new Gee.ArrayList(); + + foreach (Gst.ElementFactory factory in factories) { + weak GLib.List templates = factory.get_static_pad_templates(); + foreach (Gst.StaticPadTemplate template in templates) + if (template.direction == Gst.PadDirection.SINK) { + Gst.Caps intersect = caps.intersect(template.static_caps.get()); + if (!intersect.is_empty()) { + res.add(factory); + break; + } + } + } + + return res; + } + + // Inspect element and try to connect something on the srcpads. + // If there are dynamic pads, set up a signal handler to + // continue autoplugging when they become available. + void closeLink(Gst.Element element) { + Gst.Pad[] to_connect = new Gst.Pad[0]; + bool is_dynamic = false; + + foreach (Gst.PadTemplate template in element.get_pad_template_list ()) { + if (template.direction != Gst.PadDirection.SRC) + continue; + if (template.presence == Gst.PadPresence.ALWAYS) { + Gst.Pad pad = element.get_pad(template.name_template); + to_connect += pad; + } else if (template.presence == Gst.PadPresence.SOMETIMES) { + Gst.Pad pad = element.get_pad(template.name_template); + if (pad != null) + to_connect += pad; + else is_dynamic = true; + } + } + + if (is_dynamic) { + emit(this, Facility.SINGLEDECODEBIN, Level.VERBOSE, + "%s is a dynamic element".printf(element.get_name())); + controlDynamicElement(element); + } + + foreach (Gst.Pad pad in to_connect) + closePadLink(element, pad, pad.get_caps()); + } + + bool isDemuxer(Gst.Element element) { + if (!element.get_factory().get_klass().contains("Demux")) + return false; + + int potential_src_pads = 0; + foreach (Gst.PadTemplate template in element.get_pad_template_list()) { + if (template.direction != Gst.PadDirection.SRC) + continue; + + if (template.presence == Gst.PadPresence.REQUEST || + template.name_template.contains("%")) { + potential_src_pads += 2; + break; + } else potential_src_pads += 1; + } + + return potential_src_pads > 1; + } + + Gst.Pad plugDecodingQueue(Gst.Pad pad) { + Gst.Element queue = Gst.ElementFactory.make("queue", null); + queue.set_property("max_size_time", QUEUE_SIZE); + add(queue); + queue.sync_state_with_parent(); + pad.link(queue.get_pad("sink")); + return queue.get_pad("src"); + } + + // Tries to link one of the factories' element to the given pad. + // Returns the element that was successfully linked to the pad. + Gst.Element tryToLink1(Gst.Element source, Gst.Pad in_pad, + Gee.ArrayList factories) { + Gst.Pad? pad = in_pad; + if (isDemuxer(source)) + pad = plugDecodingQueue(in_pad); + + Gst.Element result = null; + foreach (Gst.ElementFactory factory in factories) { + Gst.Element element = factory.create(null); + if (element == null) { + warning("couldn't create element from factory"); + continue; + } + + Gst.Pad sinkpad = element.get_pad("sink"); + if (sinkpad == null) + continue; + + add(element); + element.set_state(Gst.State.READY); + if (pad.link(sinkpad) != Gst.PadLinkReturn.OK) { + element.set_state(Gst.State.NULL); + remove(element); + continue; + } + + closeLink(element); + element.set_state(Gst.State.PAUSED); + + result = element; + break; + } + + return result; + } + + // Finds the list of elements that could connect to the pad. + // If the pad has the desired caps, it will create a ghostpad. + // If no compatible elements could be found, the search will stop. + void closePadLink(Gst.Element element, Gst.Pad pad, Gst.Caps caps) { + emit(this, Facility.SINGLEDECODEBIN, Level.VERBOSE, + "element:%s, pad:%s, caps:%s".printf(element.get_name(), + pad.get_name(), + caps.to_string())); + if (caps.is_empty()) { + emit(this, Facility.SINGLEDECODEBIN, Level.INFO, "unknown type"); + return; + } + if (caps.is_any()) { + emit(this, Facility.SINGLEDECODEBIN, Level.VERBOSE, "type is not known yet, waiting"); + return; + } + + pad.get_direction (); + + if (!caps.intersect(this.caps).is_empty()) { + // This is the desired caps + if (srcpad == null) + wrapUp(element, pad); + } else if (is_raw(caps)) { + emit(this, Facility.SINGLEDECODEBIN, Level.VERBOSE, + "We hit a raw caps which isn't the wanted one"); + // TODO : recursively remove everything until demux/typefind + } else { + // Find something + if (caps.get_size() > 1) { + emit(this, Facility.SINGLEDECODEBIN, Level.VERBOSE, + "many possible types, delaying"); + return; + } + Gee.ArrayList facts = findCompatibleFactory(caps); + if (facts.size == 0) { + emit(this, Facility.SINGLEDECODEBIN, Level.VERBOSE, + "unknown type"); + return; + } + tryToLink1(element, pad, facts); + } + } + + // Ghost the given pad of element. + // Remove non-used elements. + void wrapUp(Gst.Element element, Gst.Pad pad) { + if (srcpad != null) + return; + markValidElements(element); + removeUnusedElements(typefind); + emit(this, Facility.SINGLEDECODEBIN, Level.VERBOSE, + "ghosting pad %s".printf(pad.get_name())); + srcpad = new Gst.GhostPad("src", pad); + if (caps.is_fixed()) { + srcpad.set_caps(caps); + } + srcpad.set_active(true); + + add_pad(srcpad); + post_message(new Gst.Message.state_dirty(this)); + } + + // Mark this element and upstreams as valid + void markValidElements(Gst.Element element) { + emit(this, Facility.SINGLEDECODEBIN, Level.VERBOSE, + "element:%s".printf(element.get_name())); + if (element == typefind) + return; + validelements.add(element); + + // find upstream element + Gst.Pad pad = (Gst.Pad) element.sinkpads.first().data; + Gst.Element parent = pad.get_peer().get_parent_element(); + markValidElements(parent); + } + + // Remove unused elements connected to srcpad(s) of element + void removeUnusedElements(Gst.Element element) { + foreach (Gst.Pad pad in element.srcpads) + if (pad.is_linked()) { + Gst.Element peer = pad.get_peer().get_parent_element(); + removeUnusedElements(peer); + if (!(peer in validelements)) { + emit(this, Facility.SINGLEDECODEBIN, Level.VERBOSE, + "removing %s".printf(peer.get_name())); + pad.unlink(pad.get_peer()); + peer.set_state(Gst.State.NULL); + remove(peer); + } + } + } + + void cleanUp() { + if (srcpad != null) + remove_pad(srcpad); + srcpad = null; + foreach (Gst.Element element in validelements) { + element.set_state(Gst.State.NULL); + remove(element); + } + validelements = new Gee.ArrayList(); + } + + // Overrides + + public override Gst.StateChangeReturn change_state(Gst.StateChange transition) { + Gst.StateChangeReturn res = base.change_state(transition); + if (transition == Gst.StateChange.PAUSED_TO_READY) + cleanUp(); + return res; + } + + // Signal callbacks + + static void typefindHaveTypeCb(Gst.Element t, int probability, Gst.Caps caps, + SingleDecodeBin data) { + emit(data, Facility.SINGLEDECODEBIN, Level.VERBOSE, + "probability:%d, caps:%s".printf(probability, caps.to_string())); + data.closePadLink(t, t.get_pad("src"), caps); + } + + // Dynamic element Callbacks + + void dynamicPadAddedCb(Gst.Element element, Gst.Pad pad) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "dynamicPadAddedCb"); + if (srcpad == null) + closePadLink(element, pad, pad.get_caps()); + } + + void dynamicNoMorePadsCb(Gst.Element element) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "dynamicNoMorePadsCb"); + } +} + diff --git a/src/marina/sources.mk b/src/marina/sources.mk new file mode 100644 index 0000000..7486e0f --- /dev/null +++ b/src/marina/sources.mk @@ -0,0 +1,28 @@ +$(SRC_PREFIX)SRC_FILES = \ + AppDirs.vala \ + AudioMeter.vala \ + ClassFactory.vala \ + ClipLibraryView.vala \ + clip.vala \ + command.vala \ + DialogUtils.vala \ + import.vala \ + Logging.vala \ + MediaEngine.vala \ + MultiFileProgress.vala \ + ProjectLoader.vala \ + project.vala \ + Ruler.vala \ + singledecodebin.vala \ + StatusBar.vala \ + thumbnailsink.vala \ + timeline.vala \ + TimeSystem.vala \ + track.vala \ + TrackView.vala \ + TransportDelegate.vala \ + ui_clip.vala \ + UndoManager.vala \ + util.vala \ + video_track.vala + diff --git a/src/marina/thumbnailsink.vala b/src/marina/thumbnailsink.vala new file mode 100644 index 0000000..fe4f358 --- /dev/null +++ b/src/marina/thumbnailsink.vala @@ -0,0 +1,68 @@ +class ThumbnailSink : Gst.BaseSink { + int width; + int height; + + const string caps_string = """video/x-raw-rgb,bpp = (int) 32, depth = (int) 32, + endianness = (int) BIG_ENDIAN, + blue_mask = (int) 0xFF000000, + green_mask = (int) 0x00FF0000, + red_mask = (int) 0x0000FF00, + width = (int) [ 1, max ], + height = (int) [ 1, max ], + framerate = (fraction) [ 0, max ]"""; + + public signal void have_thumbnail(Gdk.Pixbuf b); + + class construct { + Gst.StaticPadTemplate pad; + pad.name_template = "sink"; + pad.direction = Gst.PadDirection.SINK; + pad.presence = Gst.PadPresence.ALWAYS; + pad.static_caps.str = caps_string; + + add_pad_template(pad.get()); + } + + // This empty construct block eliminates a build warning about chaining up to a private + // constructor. + construct { + } + + public ThumbnailSink() { + set_sync(false); + } + + public override bool set_caps(Gst.Caps c) { + if (c.get_size() < 1) + return false; + + Gst.Structure s = c.get_structure(0); + + if (!s.get_int("width", out width) || + !s.get_int("height", out height)) + return false; + return true; + } + + void convert_pixbuf_to_rgb(Gdk.Pixbuf buf) { + uchar* data = buf.get_pixels(); + int limit = buf.get_width() * buf.get_height(); + + while (limit-- != 0) { + uchar temp = data[0]; + data[0] = data[2]; + data[2] = temp; + + data += 4; + } + } + + public override Gst.FlowReturn preroll(Gst.Buffer b) { + Gdk.Pixbuf buf = new Gdk.Pixbuf.from_data(b.data, Gdk.Colorspace.RGB, + true, 8, width, height, width * 4, null); + convert_pixbuf_to_rgb(buf); + + have_thumbnail(buf); + return Gst.FlowReturn.OK; + } +} diff --git a/src/marina/timeline.vala b/src/marina/timeline.vala new file mode 100644 index 0000000..cf8bdd5 --- /dev/null +++ b/src/marina/timeline.vala @@ -0,0 +1,617 @@ +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +using Logging; + +public class TrackClipPair { + public TrackClipPair(Model.Track track, Model.Clip clip) { + this.track = track; + this.clip = clip; + } + public Model.Track track; + public Model.Clip clip; +} + +public class Clipboard { + public Gee.ArrayList clips = new Gee.ArrayList(); + int64 minimum_time = -1; + + public void select(Gee.ArrayList selected_clips) { + clips.clear(); + minimum_time = -1; + foreach(ClipView clip_view in selected_clips) { + TrackView track_view = clip_view.parent as TrackView; + if (minimum_time < 0 || clip_view.clip.start < minimum_time) { + minimum_time = clip_view.clip.start; + } + TrackClipPair track_clip_pair = new TrackClipPair(track_view.get_track(), clip_view.clip); + clips.add(track_clip_pair); + } + } + + public void paste(Model.Track selected_track, int64 time) { + if (clips.size != 1) { + foreach (TrackClipPair pair in clips) { + pair.track.do_clip_paste(pair.clip.copy(), time + pair.clip.start - minimum_time); + } + } else { + selected_track.do_clip_paste(clips[0].clip.copy(), time); + } + } +} + +public class TimeLine : Gtk.EventBox { + public Model.Project project; + public weak Model.TimeSystem provider; + public View.Ruler ruler; + Gtk.Widget drag_widget = null; + bool copying; + public Gee.ArrayList tracks = new Gee.ArrayList(); + Gtk.VBox vbox; + + public Gee.ArrayList selected_clips = new Gee.ArrayList(); + public Clipboard clipboard = new Clipboard(); + + public const int BAR_HEIGHT = 32; + public const int BORDER = 4; + + public signal void selection_changed(bool selected); + public signal void track_changed(); + public signal void trackview_added(TrackView trackview); + public signal void trackview_removed(TrackView trackview); + + float pixel_div; + float pixel_min = 0.1f; + float pixel_max = 4505.0f; + Gtk.Label high_water; + + public const int RULER_HEIGHT = 32; + // GapView will re-emerge after 0.1 release + // public GapView gap_view; + + public TimeLine(Model.Project p, Model.TimeSystem provider, Gdk.DragAction actions) { + add_events(Gdk.EventMask.POINTER_MOTION_MASK); + drag_widget = null; + can_focus = true; + project = p; + this.provider = provider; + provider.geometry_changed.connect(on_geometry_changed); + + vbox = new Gtk.VBox(false, 0); + ruler = new View.Ruler(provider, RULER_HEIGHT); + ruler.position_changed.connect(on_ruler_position_changed); + vbox.pack_start(ruler, false, false, 0); + + project.track_added.connect(on_track_added); + project.track_removed.connect(on_track_removed); + project.media_engine.position_changed.connect(on_position_changed); + add(vbox); + + modify_bg(Gtk.StateType.NORMAL, parse_color("#444")); + modify_fg(Gtk.StateType.NORMAL, parse_color("#f00")); + + pixel_div = pixel_max / pixel_min; + provider.calculate_pixel_step (0.5f, pixel_min, pixel_div); + Gtk.drag_dest_set(this, Gtk.DestDefaults.ALL, drag_target_entries, actions); + } + + public void zoom_to_project(double width) { + if (project.get_length() == 0) + return; + + // The 12.0 is just a magic number to completely get rid of the scrollbar on this operation + width -= 12.0; + + double numerator = GLib.Math.log( + (width * Gst.SECOND) / ((double) project.get_length() * (double) pixel_min)); + double denominator = GLib.Math.log((double) pixel_div); + + zoom((float) (numerator / denominator) - provider.get_pixel_percentage()); + } + + public void zoom(float inc) { + provider.calculate_pixel_step(inc, pixel_min, pixel_div); + foreach (TrackView track in tracks) { + track.resize(); + } + project.media_engine.position_changed(project.transport_get_position()); + queue_draw(); + } + + void on_geometry_changed() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_geometry_changed"); + provider.calculate_pixel_step(0, pixel_min, pixel_div); + ruler.queue_draw(); + } + + void on_position_changed() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_position_changed"); + queue_draw(); + } + + void on_track_added(Model.Track track) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_track_added"); + TrackView track_view = ClassFactory.get_class_factory().get_track_view(track, this); + track_view.clip_view_added.connect(on_clip_view_added); + tracks.add(track_view); + vbox.pack_start(track_view, false, false, 0); + trackview_added(track_view); + if (track.media_type() == Model.MediaType.VIDEO) { + vbox.reorder_child(track_view, 1); + } + vbox.show_all(); + } + + void on_track_removed(Model.Track track) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_track_removed"); + foreach (TrackView track_view in tracks) { + if (track_view.get_track() == track) { + trackview_removed(track_view); + vbox.remove(track_view); + tracks.remove(track_view); + break; + } + } + } + + public void on_clip_view_added(ClipView clip_view) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_clip_view_added"); + clip_view.selection_request.connect(on_clip_view_selection_request); + clip_view.move_request.connect(on_clip_view_move_request); + clip_view.move_commit.connect(on_clip_view_move_commit); + clip_view.move_begin.connect(on_clip_view_move_begin); + clip_view.trim_begin.connect(on_clip_view_trim_begin); + clip_view.trim_commit.connect(on_clip_view_trim_commit); + } + + public void deselect_all_clips() { + foreach(ClipView selected_clip_view in selected_clips) { + selected_clip_view.is_selected = false; + } + selected_clips.clear(); + } + + void on_clip_view_move_begin(ClipView clip_view, bool copy) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_view_move_begin"); + copying = copy; + if (copy) { + project.undo_manager.start_transaction("Copy Clip"); + } + ClipView max_clip = null; + //The first pass removes the clips from the track model and makes any copies + foreach (ClipView selected_clip in selected_clips) { + if (max_clip == null) { + max_clip = selected_clip; + } else if (max_clip.clip.end < selected_clip.clip.end) { + max_clip = selected_clip; + } + selected_clip.initial_time = selected_clip.clip.start; + selected_clip.clip.gnonlin_disconnect(); + TrackView track_view = selected_clip.get_parent() as TrackView; + if (track_view != null) { + track_view.get_track().remove_clip_from_array(selected_clip.clip); + } + if (copy) { + // TODO: When adding in linking/groups, this should be moved into track_view + // We'll want to call move_begin for each clip that is linked, or in a group + // or selected and not iterate over them in this fashion in the timeline. + Model.Clip clip = selected_clip.clip.copy(); + track_view.get_track().append_at_time(clip, selected_clip.clip.start, false); + } + } + + high_water = new Gtk.Label(null); + Gtk.Fixed the_parent = clip_view.get_parent() as Gtk.Fixed; + the_parent.put(high_water, + max_clip.allocation.x + max_clip.allocation.width, max_clip.allocation.y); + + //The second pass moves the selected clips to the top. We can't do this in one pass + //because creating a copy inserts the new copy in the z-order at the top. + foreach (ClipView selected_clip in selected_clips) { + TrackView track_view = selected_clip.get_parent() as TrackView; + track_view.move_to_top(selected_clip); + } + } + + void on_clip_view_trim_begin(ClipView clip, Gdk.WindowEdge edge) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_view_trim_begin"); + switch (edge) { + case Gdk.WindowEdge.WEST: + clip.initial_time = clip.clip.start; + break; + case Gdk.WindowEdge.EAST: + clip.initial_time = clip.clip.duration; + break; + default: + assert(false); // We only support trimming east and west; + break; + } + } + + void on_clip_view_selection_request(ClipView clip_view, bool extend) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_view_selection_request"); +/* + if (gap_view != null) { + gap_view.unselect(); + } +*/ + bool in_selected_clips = selected_clips.contains(clip_view); + if (!extend) { + if (!in_selected_clips) { + deselect_all_clips(); + clip_view.is_selected = true; + selected_clips.add(clip_view); + } + } else { + if (selected_clips.size > 1) { + if (in_selected_clips && clip_view.is_selected) { + clip_view.is_selected = false; + // just deselected with multiple clips, so moving is not allowed + drag_widget = null; + selected_clips.remove(clip_view); + } + } + if (!in_selected_clips) { + clip_view.is_selected = true; + selected_clips.add(clip_view); + } + } + track_changed(); + selection_changed(is_clip_selected()); + queue_draw(); + } + + void on_clip_view_move_commit(ClipView clip_view, int64 delta) { + window.set_cursor(null); + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_view_move_request"); + Gtk.Fixed fixed = high_water.get_parent() as Gtk.Fixed; + fixed.remove(high_water); + high_water = null; + + project.undo_manager.start_transaction("Move Clip"); + foreach (ClipView selected_clip_view in selected_clips) { + TrackView track_view = selected_clip_view.get_parent() as TrackView; + selected_clip_view.clip.gnonlin_connect(); + track_view.get_track().move(selected_clip_view.clip, + selected_clip_view.clip.start, selected_clip_view.initial_time); + } + project.undo_manager.end_transaction("Move Clip"); + if (copying) { + copying = false; + project.undo_manager.end_transaction("Copy Clip"); + } + } + + void on_clip_view_trim_commit(ClipView clip_view, Gdk.WindowEdge edge) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_view_move_commit"); + window.set_cursor(null); + TrackView track_view = clip_view.get_parent() as TrackView; + int64 delta = 0; + switch (edge) { + case Gdk.WindowEdge.WEST: + delta = clip_view.clip.start - clip_view.initial_time; + break; + case Gdk.WindowEdge.EAST: + delta = clip_view.clip.duration - clip_view.initial_time; + break; + default: + assert(false); // We only handle WEST and EAST + break; + } + //restore back to pre-trim state + project.undo_manager.start_transaction("Trim Clip"); + clip_view.clip.trim(-delta, edge); + clip_view.clip.gnonlin_connect(); + track_view.get_track().trim(clip_view.clip, delta, edge); + project.undo_manager.end_transaction("Trim Clip"); + } + + void constrain_move(ClipView clip_view, ref int64 delta) { + int min_delta = clip_view.SNAP_DELTA; + int delta_xsize = provider.time_to_xsize(delta); + TrackView track_view = (TrackView) clip_view.parent as TrackView; + Model.Track track = track_view.get_track(); + if (delta_xsize.abs() < min_delta) { + int64 range = provider.xsize_to_time(min_delta); + int64 adjustment; + if (track.clip_is_near(clip_view.clip, range, out adjustment)) { + delta = adjustment; + clip_view.snap(provider.time_to_xsize(adjustment)); + } + } + } + + void on_clip_view_move_request(ClipView clip_view, int64 delta) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_view_move_request"); + if (project.snap_to_clip) { + constrain_move(clip_view, ref delta); + } + if (move_allowed(ref delta)) { + move_the_clips(delta); + } + } + + bool move_allowed(ref int64 move_distance) { + if (drag_widget == null) { + return false; + } + + ClipView max_clip = null; + + foreach(ClipView clip_view in selected_clips) { + if (max_clip == null) { + max_clip = clip_view; + } else if (clip_view.clip.end > max_clip.clip.end){ + max_clip = clip_view; + } + int position = provider.time_to_xpos(clip_view.clip.start + move_distance); + if (position < BORDER) { + return false; + } + } + return true; + } + + void move_the_clips(int64 move_distance) { + foreach (ClipView clip_view in selected_clips) { + do_clip_move(clip_view, move_distance); + } + } + + public void do_clip_move(ClipView clip_view, int64 delta) { + clip_view.clip.start += delta; + } + + public void on_ruler_position_changed(int x) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_ruler_position_changed"); + if (!project.transport_is_recording()) { + update_pos(x); + } + } + + public bool is_clip_selected() { + return selected_clips.size > 0; + } + + public bool gap_selected() { + return false; +// return gap_view != null; + } + + public void delete_selection() { + project.undo_manager.start_transaction("Delete Clips From Timeline"); + drag_widget = null; + if (is_clip_selected()) { + while (selected_clips.size > 0) { + selected_clips[0].delete_clip(); + selected_clips.remove_at(0); + } + track_changed(); + } else { +/* + if (gap_view != null) { + if (!project.can_delete_gap(gap_view.gap)) { + if (DialogUtils.delete_cancel("Really delete single-track gap?") == + Gtk.ResponseType.YES) { + gap_view.remove(); + } + } else { + project.delete_gap(gap_view.gap); + } + + gap_view.unselect(); + } +*/ + } + project.undo_manager.end_transaction("Delete Clips From Timeline"); + } + + public void do_cut() { + clipboard.select(selected_clips); + delete_selection(); + } + + public void do_copy() { + clipboard.select(selected_clips); + selection_changed(true); + } + + public void paste() { + do_paste(project.transport_get_position()); + } + + public void do_paste(int64 pos) { + TrackView? view = null; + foreach (TrackView track_view in tracks) { + if (track_view.get_track().get_is_selected()) { + view = track_view; + } + } + // TODO: Lombard doesn't use selected state. The following check should be removed + // when it does + if (view == null) { + view = clipboard.clips[0].clip.type == Model.MediaType.VIDEO ? + find_video_track_view() : find_audio_track_view(); + } + project.undo_manager.start_transaction("Paste"); + clipboard.paste(view.get_track(), pos); + project.undo_manager.end_transaction("Paste"); + queue_draw(); + } + + public void select_all() { + foreach (TrackView track in tracks) { + track.select_all(); + } + } + + public override bool expose_event(Gdk.EventExpose event) { + base.expose_event(event); + + int xpos = provider.time_to_xpos(project.transport_get_position()); + Gdk.draw_line(window, style.fg_gc[(int) Gtk.StateType.NORMAL], + xpos, 0, + xpos, allocation.height); + + return true; + } + + public override void drag_data_received(Gdk.DragContext context, int x, int y, + Gtk.SelectionData selection_data, uint drag_info, + uint time) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_drag_data_received"); + string[] a = selection_data.get_uris(); + Gtk.drag_finish(context, true, false, time); + + Model.Track? track = null; + TrackView? track_view = find_child(x, y) as TrackView; + + if (track_view == null) { + return; + } + + bool timeline_add = true; + + if (a.length > 1) { + if (Gtk.drag_get_source_widget(context) != null) { + DialogUtils.warning("Cannot add files", + "Files must be dropped onto the timeline individually."); + return; + } + + if (DialogUtils.add_cancel( + "Files must be dropped onto the timeline individually.\n" + + "Do you wish to add these files to the library?") != Gtk.ResponseType.YES) { + return; + } + timeline_add = false; + } else { + track = track_view.get_track(); + } + + project.create_clip_importer(track, timeline_add, provider.xpos_to_time(x), + context.action == Gdk.DragAction.COPY, (Gtk.Window) get_toplevel(), a.length); + try { + foreach (string s in a) { + string filename; + try { + filename = GLib.Filename.from_uri(s); + } catch (GLib.ConvertError e) { continue; } + project.importer.add_file(filename); + } + project.importer.start(); + } catch (Error e) { + project.error_occurred("Error importing", e.message); + } + } + + public void update_pos(int event_x) { + int64 time = provider.xpos_to_time(event_x); + if (project.snap_to_clip) { + project.snap_coord(out time, provider.get_pixel_snap_time()); + } + project.media_engine.go(time); + } + + public Gtk.Widget? find_child(double x, double y) { + foreach (Gtk.Widget w in vbox.get_children()) { + if (w.allocation.y <= y && y < w.allocation.y + w.allocation.height) + return w; + } + return null; + } + + void deselect_all() { + foreach (ClipView clip_view in selected_clips) { + clip_view.is_selected = false; + } + selected_clips.clear(); + selection_changed(false); + } + + public override bool button_press_event(Gdk.EventButton event) { +/* + if (gap_view != null) + gap_view.unselect(); +*/ + drag_widget = null; + Gtk.Widget? child = find_child(event.x, event.y); + + if (child is View.Ruler) { + View.Ruler ruler = child as View.Ruler; + ruler.button_press_event(event); + drag_widget = child; + } else if (child is TrackView) { + TrackView track_view = child as TrackView; + + drag_widget = track_view.find_child(event.x, event.y); + if (drag_widget != null) { + drag_widget.button_press_event(event); + } else { + deselect_all(); + // want to select the track_views track as selected + track_view.get_track().set_selected(true); + } + } else { + deselect_all(); + } + queue_draw(); + + return true; + } + + public override bool button_release_event(Gdk.EventButton event) { + if (drag_widget != null) { + drag_widget.button_release_event(event); + drag_widget = null; + } + return true; + } + + public override bool motion_notify_event(Gdk.EventMotion event) { + if (drag_widget != null) { + drag_widget.motion_notify_event(event); + } else { + Gtk.Widget widget = find_child(event.x, event.y); + if (widget is TrackView) { + TrackView? track_view = widget as TrackView; + if (track_view != null) { + ClipView? clip_view = track_view.find_child(event.x, event.y) as ClipView; + if (clip_view != null) { + clip_view.motion_notify_event(event); + } else { + window.set_cursor(null); + } + } + } else if (widget is View.Ruler) { + widget.motion_notify_event(event); + } else { + window.set_cursor(null); + } + } + return true; + } + + TrackView? find_video_track_view() { + foreach (TrackView track in tracks) { + if (track.get_track().media_type() == Model.MediaType.VIDEO) { + return track; + } + } + + return null; + } + + TrackView? find_audio_track_view() { + foreach (TrackView track in tracks) { + if (track.get_track().media_type() == Model.MediaType.AUDIO) { + return track; + } + } + + return null; + } +} diff --git a/src/marina/track.vala b/src/marina/track.vala new file mode 100644 index 0000000..172fff6 --- /dev/null +++ b/src/marina/track.vala @@ -0,0 +1,624 @@ +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +using Logging; + +namespace Model { + +public abstract class Track : Object { + protected weak Project project; + public Gee.ArrayList clips = new Gee.ArrayList(); // all clips, sorted by time + public string display_name; + bool is_selected; + + public signal void clip_added(Clip clip, bool select); + public signal void clip_removed(Clip clip); + + public signal void track_renamed(Track track); + public signal void track_selection_changed(Track track); + public signal void track_hidden(Track track); + public signal void track_removed(Track track); + public signal void error_occurred(string major_error, string? minor_error); + + public Track(Project project, string display_name) { + this.project = project; + this.display_name = display_name; + } + + protected abstract string name(); + public abstract MediaType media_type(); + + public void hide() { + track_hidden(this); + } + + public bool contains_clipfile(ClipFile f) { + foreach (Clip c in clips) { + if (c.clipfile == f) + return true; + } + return false; + } + + protected abstract bool check(Clip clip); + + public int64 get_time_from_pos(Clip clip, bool after) { + if (after) + return clip.start + clip.duration; + else + return clip.start; + } + + int get_clip_from_time(int64 time) { + for (int i = 0; i < clips.size; i++) { + if (time >= clips[i].start && + time < clips[i].end) + return i; + } + return -1; + } + + public int64 snap_clip(Clip c, int64 span) { + foreach (Clip cl in clips) { + int64 new_start = c.snap(cl, span); + if (new_start != c.start) { + return new_start; + } + } + return c.start; + } + + public bool snap_coord(out int64 coord, int64 span) { + foreach (Clip c in clips) { + if (c.snap_coord(out coord, span)) + return true; + } + return false; + } + + public bool clip_is_near(Model.Clip clip, int64 range, out int64 adjustment) { + foreach (Clip potential_clip in clips) { + if (potential_clip != clip) { + int64 difference = clip.start - potential_clip.end; + if (difference.abs() < range) { + adjustment = -difference; + return true; + } + + difference = potential_clip.start - clip.end; + if (difference.abs() < range) { + adjustment = difference; + return true; + } + } + } + return false; + } + + int get_insert_index(int64 time) { + int end_ret = 0; + for (int i = 0; i < clips.size; i++) { + Clip c = clips[i]; + + if (time >= c.start) { + if (time < c.start + c.duration/2) + return i; + else if (time < c.start + c.duration) + return i + 1; + else + end_ret ++; + } + } + return end_ret; + } + + // This is called to find the first gap after a start time + public Gap find_first_gap(int64 start) { + int64 new_start = 0; + int64 new_end = int64.MAX; + + foreach (Clip c in clips) { + if (c.start > new_start && + c.start > start) { + new_end = c.start; + break; + } + new_start = c.end; + } + return new Gap(new_start, new_end); + } + + // This is always called with the assumption that we are not on a clip + int get_gap_index(int64 time) { + int i = 0; + while (i < clips.size) { + if (time <= clips[i].start) + break; + i++; + } + return i; + } + + // If we are not on a valid gap (as in, a space between two clips or between the start + // and the first clip), we return an empty (and invalid) gap + public void find_containing_gap(int64 time, out Gap g) { + g = new Gap(0, 0); + + int index = get_gap_index(time); + if (index < clips.size) { + g.start = index > 0 ? clips[index - 1].end : 0; + g.end = clips[index].start; + } + } + + public Clip? find_overlapping_clip(int64 start, int64 length) { + for (int i = 0; i < clips.size; i++) { + Clip c = clips[i]; + if (c.overlap_pos(start, length)) + return c; + } + return null; + } + + public Clip? find_nearest_clip_edge(int64 time, out bool after) { + int limit = clips.size * 2; + int64 prev_time = clips[0].start; + + for (int i = 1; i < limit; i++) { + Clip c = clips[i / 2]; + int64 t; + + if (i % 2 == 0) + t = c.start; + else + t = c.end; + + if (t > time) { + if (t - time < time - prev_time) { + after = ((i % 2) != 0); + return clips[i / 2]; + } else { + after = ((i % 2) == 0); + return clips[(i - 1) / 2]; + } + } + prev_time = t; + } + + after = true; + return clips[clips.size - 1]; + } + + void do_clip_overwrite(Clip c) { + int start_index = get_clip_from_time(c.start); + int end_index = get_clip_from_time(c.end); + + if (end_index >= 0) { + int64 diff = c.end - clips[end_index].start; + if (end_index == start_index) { + if (c == clips[end_index]) { + return; + } + + if (diff > 0) { + Clip cl = new Clip(clips[end_index].clipfile, clips[end_index].type, + clips[end_index].name, c.end, + clips[end_index].media_start + diff, + clips[end_index].duration - diff, false); + append_at_time(cl, cl.start, false); + } + } else { + trim(clips[end_index], diff, Gdk.WindowEdge.WEST); + } + } + if (start_index >= 0 && clips[start_index] != c) { + int64 delta = clips[start_index].end - c.start; + trim(clips[start_index], -delta, Gdk.WindowEdge.EAST); + } + + int i = 0; + // TODO: This code assumes that when a delete happens, it is reflected immediately. + // When we are in an undo (or redo) deleting will happen later. It would be better + // for callers not to have to deal with this problem. Too large of a change for now. + if (!project.undo_manager.in_undo) { + while (i < clips.size) { + if (clips[i] != c && + clips[i].start >= c.start && + clips[i].end <= c.end) { + delete_clip(clips[i]); + } + else + i++; + } + } + } + + public void move(Clip c, int64 pos, int64 original_time) { + Command command = new ClipAddCommand(this, c, original_time, pos); + project.do_command(command); + } + + public void _move(Clip c, int64 pos) { + if (pos < 0) { + pos = 0; + } + c.start = pos; + do_clip_overwrite(c); + + insert_clip_into_array(c, get_insert_index(c.start)); + project.reseek(); + } + + public void add(Clip c, int64 pos, bool select) { + if (!check(c)) + return; + + _move(c, pos); + clip_added(c, select); + } + + public virtual void on_clip_updated(Clip clip) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_updated"); + } + + public void do_clip_paste(Clip clip, int64 position) { + append_at_time(clip, position, true); + } + + public Clip? get_clip(int i) { + if (i < 0 || i >= clips.size) + error("get_clip: Invalid index! %d (%d)", i, clips.size); + return clips[i]; + } + + public int get_clip_index(Clip c) { + for (int i = 0; i < clips.size; i++) { + if (clips[i] == c) { + return i; + } + } + return -1; + } + + public Clip? get_clip_by_position(int64 pos) { + int length = clips.size; + + for (int i = length - 1; i >= 0; i--) + if (clips[i].start < pos) + return pos >= clips[i].end ? null : clips[i]; + return null; + } + + public int64 get_length() { + return clips.size == 0 ? 0 : clips[clips.size - 1].start + clips[clips.size - 1].duration; + } + + public void _append_at_time(Clip c, int64 time, bool select) { + add(c, time, select); + } + + public void append_at_time(Clip c, int64 time, bool select) { + Command command = new ClipCommand(ClipCommand.Action.APPEND, this, c, time, select); + project.do_command(command); + } + + public void delete_clip(Clip clip) { + Command clip_command = new ClipCommand(ClipCommand.Action.DELETE, + this, clip, clip.start, false); + project.do_command(clip_command); + } + + public void _delete_clip(Clip clip) { + int index = get_clip_index(clip); + assert(index != -1); + clips.remove_at(index); + + clip.removed(clip); + clip_removed(clip); + } + + public void delete_gap(Gap g) { + project.reseek(); + } + + public void remove_clip_from_array(Clip pos) { + clips.remove(pos); + } + + void insert_clip_into_array(Clip c, int pos) { + c.updated.connect(on_clip_updated); + clips.insert(pos, c); + } + + public void delete_all_clips() { + uint size = clips.size; + for (int i = 0; i < size; i++) { + delete_clip(clips[0]); + } + project.media_engine.go(0); + } + + public void revert_to_original(Clip clip) { + Command command = new ClipRevertCommand(this, clip); + project.do_command(command); + } + + public void _revert_to_original(Clip c) { + int index = get_clip_index(c); + if (index == -1) + error("revert_to_original: Clip not in track array!"); + + c.set_media_start_duration(0, c.clipfile.length); + + project.media_engine.go(c.start); + } + + public bool are_contiguous_clips(int64 position) { + Clip right_clip = get_clip_by_position(position + 1); + Clip left_clip = get_clip_by_position(position - 1); + + return left_clip != null && right_clip != null && + left_clip != right_clip && + left_clip.clipfile == right_clip.clipfile && + left_clip.end == right_clip.start; + } + + public void split_at(int64 position) { + Command command = new ClipSplitCommand(ClipSplitCommand.Action.SPLIT, this, position); + project.do_command(command); + } + + public void _split_at(int64 position) { + Clip c = get_clip_by_position(position); + if (c == null) + return; + + Clip cn = new Clip(c.clipfile, c.type, c.name, position, + (position - c.start) + c.media_start, + c.start + c.duration - position, false); + + c.duration = position - c.start; + + add(cn, position, false); + } + + public void join(int64 position) { + Command command = new ClipSplitCommand(ClipSplitCommand.Action.JOIN, this, position); + project.do_command(command); + } + + public void _join(int64 position) { + assert(are_contiguous_clips(position)); + if (are_contiguous_clips(position)) { + Clip right_clip = get_clip_by_position(position + 1); + assert(right_clip != null); + + int right_clip_index = get_clip_index(right_clip); + assert(right_clip_index > 0); + + int left_clip_index = right_clip_index - 1; + Clip left_clip = get_clip(left_clip_index); + assert(left_clip != null); + left_clip.duration = right_clip.end - left_clip.start; + _delete_clip(right_clip); + } + } + + public void trim(Clip clip, int64 delta, Gdk.WindowEdge edge) { + Command command = new ClipTrimCommand(this, clip, delta, edge); + project.do_command(command); + } + + public void _trim(Clip clip, int64 delta, Gdk.WindowEdge edge) { + clip.trim(delta, edge); + do_clip_overwrite(clip); + } + + public int64 previous_edit(int64 pos) { + for (int i = clips.size - 1; i >= 0 ; --i) { + Clip c = clips[i]; + if (c.end < pos) + return c.end; + if (c.start < pos) + return c.start; + } + return 0; + } + + public int64 next_edit(int64 pos) { + foreach (Clip c in clips) + if (c.start > pos) + return c.start; + else if (c.end > pos) + return c.end; + return get_length(); + } + + public virtual void write_attributes(FileStream f) { + f.printf("type=\"%s\" name=\"%s\" ", name(), get_display_name()); + } + + public void save(FileStream f) { + f.printf(" \n"); + for (int i = 0; i < clips.size; i++) + clips[i].save(f, project.get_clipfile_index(clips[i].clipfile)); + f.puts(" \n"); + } + + public string get_display_name() { + return display_name; + } + + public void set_display_name(string new_display_name) { + if (display_name != new_display_name) { + display_name = new_display_name; + track_renamed(this); + } + } + + public void set_selected(bool is_selected) { + if (this.is_selected != is_selected) { + this.is_selected = is_selected; + track_selection_changed(this); + } + } + + public bool get_is_selected() { + return is_selected; + } +} + +public class AudioTrack : Track { + double pan; + double volume; + + int default_num_channels; + public static const int INVALID_CHANNEL_COUNT = -1; + + public signal void parameter_changed(Parameter parameter, double new_value); + public signal void level_changed(double level_left, double level_right); + public signal void channel_count_changed(int channel_count); + + public AudioTrack(Project project, string display_name) { + base(project, display_name); + + set_default_num_channels(INVALID_CHANNEL_COUNT); + _set_pan(0); + _set_volume(1.0); + } + + protected override string name() { return "audio"; } + + public override MediaType media_type() { + return MediaType.AUDIO; + } + + public override void write_attributes(FileStream f) { + base.write_attributes(f); + f.printf("volume=\"%f\" panorama=\"%f\" ", get_volume(), get_pan()); + + int channels; + if (get_num_channels(out channels) && + channels != INVALID_CHANNEL_COUNT) + f.printf("channels=\"%d\" ", channels); + } + + public void set_pan(double new_value) { + double old_value = get_pan(); + if (!float_within(new_value - old_value, 0.05)) { + ParameterCommand parameter_command = + new ParameterCommand(this, Parameter.PAN, new_value, old_value); + project.do_command(parameter_command); + } + } + + public void _set_pan(double new_value) { + assert(new_value <= 1.0 && new_value >= -1.0); + double old_value = get_pan(); + if (!float_within(old_value - new_value, 0.05)) { + pan = new_value; + parameter_changed(Parameter.PAN, new_value); + } + } + + public double get_pan() { + return pan; + } + + public void set_volume(double new_volume) { + double old_volume = get_volume(); + if (!float_within(old_volume - new_volume, 0.005)) { + ParameterCommand parameter_command = + new ParameterCommand(this, Parameter.VOLUME, new_volume, old_volume); + project.do_command(parameter_command); + } + } + + public void _set_volume(double new_volume) { + assert(new_volume >= 0.0 && new_volume <= 10.0); + double old_volume = get_volume(); + if (!float_within(old_volume - new_volume, 0.005)) { + volume = new_volume; + parameter_changed(Parameter.VOLUME, new_volume); + } + } + + public double get_volume() { + return volume; + } + + public void set_default_num_channels(int num) { + default_num_channels = num; + } + + public bool get_num_channels(out int num) { + if (clips.size == 0) + return false; + + foreach (Clip c in clips) { + if (c.clipfile.is_online()) { + bool can = c.clipfile.get_num_channels(out num); + assert(can); + + return can; + } + } + + if (default_num_channels == INVALID_CHANNEL_COUNT) + return false; + + num = default_num_channels; + return true; + } + + public override bool check(Clip clip) { + if (!clip.clipfile.is_online()) { + return true; + } + + if (clips.size == 0) { + int number_of_channels = 0; + if (clip.clipfile.get_num_channels(out number_of_channels)) { + channel_count_changed(number_of_channels); + } + return true; + } + + bool good = false; + int number_of_channels; + if (clip.clipfile.get_num_channels(out number_of_channels)) { + int track_channel_count; + if (get_num_channels(out track_channel_count)) { + good = track_channel_count == number_of_channels; + } + } + + if (!good) { + string sub_error = number_of_channels == 1 ? + "Mono clips cannot go on stereo tracks." : + "Stereo clips cannot go on mono tracks."; + error_occurred("Cannot add clip to track", sub_error); + } + return good; + } + + public void on_level_changed(double level_left, double level_right) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_level_changed"); + level_changed(level_left, level_right); + } + + public override void on_clip_updated(Clip clip) { + if (clip.clipfile.is_online()) { + int number_of_channels = 0; + if (get_num_channels(out number_of_channels)) { + channel_count_changed(number_of_channels); + } + } + } +} +} diff --git a/src/marina/ui_clip.vala b/src/marina/ui_clip.vala new file mode 100644 index 0000000..9a17244 --- /dev/null +++ b/src/marina/ui_clip.vala @@ -0,0 +1,372 @@ +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +using Logging; + +public class GapView : Gtk.DrawingArea { + public Model.Gap gap; + Gdk.Color fill_color; + + public GapView(int64 start, int64 length, int width, int height) { + + gap = new Model.Gap(start, start + length); + + Gdk.Color.parse("#777", out fill_color); + + set_flags(Gtk.WidgetFlags.NO_WINDOW); + + set_size_request(width, height); + } + + public signal void removed(GapView gap_view); + public signal void unselected(GapView gap_view); + + public void remove() { + removed(this); + } + + public void unselect() { + unselected(this); + } + + public override bool expose_event(Gdk.EventExpose e) { + draw_rounded_rectangle(window, fill_color, true, allocation.x, allocation.y, + allocation.width - 1, allocation.height - 1); + return true; + } +} + +public class ClipView : Gtk.DrawingArea { + enum MotionMode { + NONE, + DRAGGING, + LEFT_TRIM, + RIGHT_TRIM + } + + public Model.Clip clip; + public int64 initial_time; + weak Model.TimeSystem time_provider; + public bool is_selected; + public int height; // TODO: We request size of height, but we aren't allocated this height. + // We should be using the allocated height, not the requested height. + public static Gtk.Menu context_menu; + TransportDelegate transport_delegate; + Gdk.Color color_black; + Gdk.Color color_normal; + Gdk.Color color_selected; + int drag_point; + int snap_amount; + bool snapped; + MotionMode motion_mode = MotionMode.NONE; + bool button_down = false; + bool pending_selection; + const int MIN_DRAG = 5; + const int TRIM_WIDTH = 10; + public const int SNAP_DELTA = 10; + + static Gdk.Cursor left_trim_cursor = new Gdk.Cursor(Gdk.CursorType.LEFT_SIDE); + static Gdk.Cursor right_trim_cursor = new Gdk.Cursor(Gdk.CursorType.RIGHT_SIDE); + static Gdk.Cursor hand_cursor = new Gdk.Cursor.from_name(Gdk.Display.get_default(), "dnd-none"); + // will be used for drag + static Gdk.Cursor plus_cursor = new Gdk.Cursor.from_name(Gdk.Display.get_default(), "dnd-copy"); + + public signal void clip_deleted(Model.Clip clip); + public signal void clip_moved(ClipView clip); + public signal void selection_request(ClipView clip_view, bool extend_selection); + public signal void move_request(ClipView clip_view, int64 delta); + public signal void move_commit(ClipView clip_view, int64 delta); + public signal void move_begin(ClipView clip_view, bool copy); + public signal void trim_begin(ClipView clip_view, Gdk.WindowEdge edge); + public signal void trim_commit(ClipView clip_view, Gdk.WindowEdge edge); + + public ClipView(TransportDelegate transport_delegate, Model.Clip clip, + Model.TimeSystem time_provider, int height) { + this.transport_delegate = transport_delegate; + this.clip = clip; + this.time_provider = time_provider; + this.height = height; + is_selected = false; + + clip.moved.connect(on_clip_moved); + clip.updated.connect(on_clip_updated); + + Gdk.Color.parse("000", out color_black); + get_clip_colors(); + + set_flags(Gtk.WidgetFlags.NO_WINDOW); + + adjust_size(height); + } + + void get_clip_colors() { + if (clip.clipfile.is_online()) { + Gdk.Color.parse(clip.type == Model.MediaType.VIDEO ? "#d82" : "#84a", + out color_selected); + Gdk.Color.parse(clip.type == Model.MediaType.VIDEO ? "#da5" : "#b9d", + out color_normal); + } else { + Gdk.Color.parse("red", out color_selected); + Gdk.Color.parse("#AA0000", out color_normal); + } + } + + void on_clip_updated() { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_updated"); + get_clip_colors(); + queue_draw(); + } + + // Note that a view's size may vary slightly (by a single pixel) depending on its + // starting position. This is because the clip's length may not be an integer number of + // pixels, and may get rounded either up or down depending on the clip position. + public void adjust_size(int height) { + int width = time_provider.time_to_xpos(clip.start + clip.duration) - + time_provider.time_to_xpos(clip.start); + set_size_request(width + 1, height); + } + + public void on_clip_moved(Model.Clip clip) { + emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_moved"); + adjust_size(height); + clip_moved(this); + } + + public void delete_clip() { + clip_deleted(clip); + } + + public void draw() { + weak Gdk.Color fill = is_selected ? color_selected : color_normal; + + bool left_trimmed = clip.media_start != 0 && !clip.is_recording; + + bool right_trimmed = clip.clipfile.is_online() ? + (clip.media_start + clip.duration != clip.clipfile.length) : false; + + if (!left_trimmed && !right_trimmed) { + draw_rounded_rectangle(window, fill, true, allocation.x + 1, allocation.y + 1, + allocation.width - 2, allocation.height - 2); + draw_rounded_rectangle(window, color_black, false, allocation.x, allocation.y, + allocation.width - 1, allocation.height - 1); + + } else if (!left_trimmed && right_trimmed) { + draw_left_rounded_rectangle(window, fill, true, allocation.x + 1, allocation.y + 1, + allocation.width - 2, allocation.height - 2); + draw_left_rounded_rectangle(window, color_black, false, allocation.x, allocation.y, + allocation.width - 1, allocation.height - 1); + + } else if (left_trimmed && !right_trimmed) { + draw_right_rounded_rectangle(window, fill, true, allocation.x + 1, allocation.y + 1, + allocation.width - 2, allocation.height - 2); + draw_right_rounded_rectangle(window, color_black, false, allocation.x, allocation.y, + allocation.width - 1, allocation.height - 1); + + } else { + draw_square_rectangle(window, fill, true, allocation.x + 1, allocation.y + 1, + allocation.width - 2, allocation.height - 2); + draw_square_rectangle(window, color_black, false, allocation.x, allocation.y, + allocation.width - 1, allocation.height - 1); + } + + Gdk.GC gc = new Gdk.GC(window); + Gdk.Rectangle r = { 0, 0, 0, 0 }; + + // Due to a Vala compiler bug, we have to do this initialization here... + r.x = allocation.x; + r.y = allocation.y; + r.width = allocation.width; + r.height = allocation.height; + + gc.set_clip_rectangle(r); + + Pango.Layout layout; + if (clip.is_recording) { + layout = create_pango_layout("Recording"); + } else if (!clip.clipfile.is_online()) { + layout = create_pango_layout("%s (Offline)".printf(clip.name)); + } + else { + layout = create_pango_layout("%s".printf(clip.name)); + } + int width, height; + layout.get_pixel_size(out width, out height); + Gdk.draw_layout(window, gc, allocation.x + 10, allocation.y + height, layout); + } + + public override bool expose_event(Gdk.EventExpose event) { + draw(); + return true; + } + + public override bool button_press_event(Gdk.EventButton event) { + if (!transport_delegate.is_stopped()) { + return true; + } + + event.x -= allocation.x; + bool primary_press = event.button == 1; + if (primary_press) { + button_down = true; + drag_point = (int)event.x; + snap_amount = 0; + snapped = false; + } + + bool extend_selection = (event.state & Gdk.ModifierType.CONTROL_MASK) != 0; + // The clip is not responsible for changing the selection state. + // It may depend upon knowledge of multiple clips. Let anyone who is interested + // update our state. + if (is_left_trim(event.x, event.y)) { + selection_request(this, false); + if (primary_press) { + trim_begin(this, Gdk.WindowEdge.WEST); + motion_mode = MotionMode.LEFT_TRIM; + } + } else if (is_right_trim(event.x, event.y)){ + selection_request(this, false); + if (primary_press) { + trim_begin(this, Gdk.WindowEdge.EAST); + motion_mode = MotionMode.RIGHT_TRIM; + } + } else { + if (!is_selected) { + pending_selection = false; + selection_request(this, extend_selection); + } else { + pending_selection = true; + } + } + + if (event.button == 3) { + context_menu.select_first(true); + context_menu.popup(null, null, null, event.button, event.time); + } else { + context_menu.popdown(); + } + + return true; + } + + public override bool button_release_event(Gdk.EventButton event) { + if (!transport_delegate.is_stopped()) { + return true; + } + + event.x -= allocation.x; + button_down = false; + if (event.button == 1) { + switch (motion_mode) { + case MotionMode.NONE: { + if (pending_selection) { + selection_request(this, true); + } + } + break; + case MotionMode.DRAGGING: { + int64 delta = time_provider.xsize_to_time((int) event.x - drag_point); + if (motion_mode == MotionMode.DRAGGING) { + move_commit(this, delta); + } + } + break; + case MotionMode.LEFT_TRIM: + trim_commit(this, Gdk.WindowEdge.WEST); + break; + case MotionMode.RIGHT_TRIM: + trim_commit(this, Gdk.WindowEdge.EAST); + break; + } + } + motion_mode = MotionMode.NONE; + return true; + } + + public override bool motion_notify_event(Gdk.EventMotion event) { + if (!transport_delegate.is_stopped()) { + return true; + } + + event.x -= allocation.x; + int delta_pixels = (int)(event.x - drag_point) - snap_amount; + if (snapped) { + snap_amount += delta_pixels; + if (snap_amount.abs() < SNAP_DELTA) { + return true; + } + delta_pixels += snap_amount; + snap_amount = 0; + snapped = false; + } + + int64 delta_time = time_provider.xsize_to_time(delta_pixels); + + switch (motion_mode) { + case MotionMode.NONE: + if (!button_down && is_left_trim(event.x, event.y)) { + window.set_cursor(left_trim_cursor); + } else if (!button_down && is_right_trim(event.x, event.y)) { + window.set_cursor(right_trim_cursor); + } else if (is_selected && button_down) { + if (delta_pixels.abs() > MIN_DRAG) { + bool do_copy = (event.state & Gdk.ModifierType.CONTROL_MASK) != 0; + if (do_copy) { + window.set_cursor(plus_cursor); + } else { + window.set_cursor(hand_cursor); + } + motion_mode = MotionMode.DRAGGING; + move_begin(this, do_copy); + } + } else { + window.set_cursor(null); + } + break; + case MotionMode.RIGHT_TRIM: + case MotionMode.LEFT_TRIM: + if (button_down) { + if (motion_mode == MotionMode.LEFT_TRIM) { + clip.trim(delta_time, Gdk.WindowEdge.WEST); + } else { + int64 duration = clip.duration; + clip.trim(delta_time, Gdk.WindowEdge.EAST); + if (duration != clip.duration) { + drag_point += (int)delta_pixels; + } + } + } + return true; + case MotionMode.DRAGGING: + move_request(this, delta_time); + return true; + } + return false; + } + + bool is_trim_height(double y) { + return y - allocation.y > allocation.height / 2; + } + + bool is_left_trim(double x, double y) { + return is_trim_height(y) && x > 0 && x < TRIM_WIDTH; + } + + bool is_right_trim(double x, double y) { + return is_trim_height(y) && x > allocation.width - TRIM_WIDTH && + x < allocation.width; + } + + public void select() { + if (!is_selected) { + selection_request(this, true); + } + } + + public void snap(int64 amount) { + snap_amount = time_provider.time_to_xsize(amount); + snapped = true; + } +} diff --git a/src/marina/util.vala b/src/marina/util.vala new file mode 100644 index 0000000..576324a --- /dev/null +++ b/src/marina/util.vala @@ -0,0 +1,563 @@ +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +public errordomain MediaError { + MISSING_PLUGIN +} + +// I can't find a floating point absolute value function in Vala... +public float float_abs(float f) { + if (f < 0.0f) + return -f; + return f; +} + +public bool float_within(double f, double epsilon) { + return float_abs((float) f) < epsilon; +} + +public int sign(int x) { + if (x == 0) + return 0; + return x < 0 ? -1 : 1; +} + +int stricmp(string str1, string str2) { + string temp_str1 = str1.casefold(-1); + string temp_str2 = str2.casefold(-1); + + return temp_str1.collate(temp_str2); +} + +// TODO: write this using generics. +public string[] copy_array(string[] source) { + string[] destination = new string[source.length]; + int i = 0; + foreach (string item in source) { + destination[i] = item; + ++i; + } + return destination; +} + +// Debug utilities + +public bool debug_enabled; + +public void print_debug(string text) { + if (!debug_enabled) + return; + + debug("%s", text); +} + +public struct Fraction { + public int numerator; + public int denominator; + + public Fraction(int numerator, int denominator) { + this.numerator = numerator; + this.denominator = denominator; + } + + public Fraction.from_string(string s) { + string[] elements = s.split("/"); + if (elements.length != 2) { + numerator = 0; + denominator = 0; + } else { + numerator = elements[0].to_int(); + denominator = elements[1].to_int(); + } + } + + public bool equal(Fraction f) { + if (float_abs(((numerator / (float)denominator) - (f.numerator / (float)f.denominator))) <= + (1000.0f / 1001.0f)) + return true; + return false; + } + + public int nearest_int() { + return (int) (((double) numerator / denominator) + 0.5); + } + + public string to_string() { + return "%d/%d".printf(numerator, denominator); + } + +} + +public struct TimeCode { + public int hour; + public int minute; + public int second; + public int frame; + public bool drop_code; + + public void get_from_length(int64 length) { + length /= Gst.SECOND; + + hour = (int) (length / 3600); + minute = (int) ((length % 3600) / 60); + second = (int) ((length % 3600) % 60); + frame = 0; + } + + public string to_string() { + string ret = ""; + if (hour != 0) + ret += "%.2d:".printf(hour); + + ret += "%.2d:".printf(minute); + ret += "%.2d".printf(second); + + if (drop_code) + ret += ";"; + else + ret += ":"; + ret += "%.2d".printf(frame); + + return ret; + } +} + +public bool time_in_range(int64 time, int64 center, int64 delta) { + int64 diff = time - center; + return diff.abs() <= delta; +} + +public string isolate_filename(string path) { + string str = Path.get_basename(path); + return str.split(".")[0]; +} + +public string get_file_extension(string path) { + unowned string dot = path.rchr(-1, '.'); + return dot == null ? "" : dot.next_char(); +} + +public string append_extension(string path, string extension) { + if (get_file_extension(path) == extension) + return path; + + return path + "." + extension; +} + +// Given two version number strings such as "0.10.2.4", return true if the first is +// greater than or equal to the second. +public bool version_at_least(string v, string w) { + string[] va = v.split("."); + string[] wa = w.split("."); + for (int i = 0 ; i < wa.length ; ++i) { + if (i >= va.length) + return false; + int vi = va[i].to_int(); + int wi = wa[i].to_int(); + if (vi > wi) + return true; + if (wi > vi) + return false; + } + return true; +} + +public bool get_file_md5_checksum(string filename, out string checksum) { + string new_filename = append_extension(filename, "md5"); + + size_t buffer_length; + try { + GLib.FileUtils.get_contents(new_filename, out checksum, out buffer_length); + } catch (GLib.FileError e) { + return false; + } + + return buffer_length == 32; +} + +public void save_file_md5_checksum(string filename, string checksum) { + string new_filename = append_extension(filename, "md5"); + + try { + GLib.FileUtils.set_contents(new_filename, checksum); + } catch (GLib.FileError e) { + error("Cannot save md5 file %s!\n", new_filename); + } +} + +public bool md5_checksum_on_file(string filename, out string checksum) { + string file_buffer; + size_t len; + + try { + GLib.FileUtils.get_contents(filename, out file_buffer, out len); + } catch (GLib.FileError e) { + return false; + } + + GLib.Checksum c = new GLib.Checksum(GLib.ChecksumType.MD5); + c.update((uchar[]) file_buffer, len); + checksum = c.get_string(); + return true; +} + +// GDK/GTK utility functions + +// constants from gdkkeysyms.h https://bugzilla.gnome.org/show_bug.cgi?id=551184 +[CCode (cprefix = "GDK_", has_type_id = "0", cheader_filename = "gdk/gdkkeysyms.h")] +public enum KeySyms { + Control_L, + Control_R, + Down, + equal, + Escape, + KP_Add, + KP_Enter, + KP_Subtract, + Left, + minus, + plus, + Return, + Right, + Shift_L, + Shift_R, + underscore, + Up +} + +public Gdk.ModifierType GDK_SHIFT_ALT_CONTROL_MASK = Gdk.ModifierType.SHIFT_MASK | + Gdk.ModifierType.MOD1_MASK | + Gdk.ModifierType.CONTROL_MASK; + +public const Gtk.TargetEntry[] drag_target_entries = { + { "text/uri-list", 0, 0 } +}; + +public Gdk.Color parse_color(string color) { + Gdk.Color c; + if (!Gdk.Color.parse(color, out c)) + error("can't parse color"); + return c; +} + +public Gtk.Widget get_widget(Gtk.UIManager manager, string name) { + Gtk.Widget widget = manager.get_widget(name); + if (widget == null) + error("can't find widget"); + return widget; +} + +///////////////////////////////////////////////////////////////////////////// +// Rectangle drawing stuff // +// Original rounded rectangle code from: http://cairographics.org/samples/ // +///////////////////////////////////////////////////////////////////////////// + +const double LINE_WIDTH = 1.0; +const double RADIUS = 15.0; +const Cairo.Antialias ANTIALIAS = Cairo.Antialias.DEFAULT; // NONE/DEFAULT + +public void draw_rounded_rectangle(Gdk.Window window, Gdk.Color color, bool filled, + int x0, int y0, int width, int height) { + if (width == 0 || height == 0) + return; + + double x1 = x0 + width; + double y1 = y0 + height; + + Cairo.Context cairo_window = Gdk.cairo_create(window); + Gdk.cairo_set_source_color(cairo_window, color); + cairo_window.set_antialias(ANTIALIAS); + + if ((width / 2) < RADIUS) { + if ((height / 2) < RADIUS) { + cairo_window.move_to(x0, ((y0 + y1) / 2)); + cairo_window.curve_to(x0, y0, x0, y0, (x0 + x1) / 2, y0); + cairo_window.curve_to(x1, y0, x1, y0, x1, (y0 + y1) / 2); + cairo_window.curve_to(x1, y1, x1, y1, (x1 + x0) / 2, y1); + cairo_window.curve_to(x0, y1, x0, y1, x0, (y0 + y1) / 2); + } else { + cairo_window.move_to(x0, y0 + RADIUS); + cairo_window.curve_to(x0,y0, x0, y0, (x0 + x1) / 2, y0); + cairo_window.curve_to(x1, y0, x1, y0, x1, y0 + RADIUS); + cairo_window.line_to(x1, y1 - RADIUS); + cairo_window.curve_to(x1, y1, x1, y1, (x1 + x0) / 2, y1); + cairo_window.curve_to(x0, y1, x0, y1, x0, y1 - RADIUS); + } + } else { + if ((height / 2) < RADIUS) { + cairo_window.move_to(x0, (y0 + y1) / 2); + cairo_window.curve_to(x0, y0, x0, y0, x0 + RADIUS, y0); + cairo_window.line_to(x1 - RADIUS, y0); + cairo_window.curve_to(x1, y0, x1, y0, x1, (y0 + y1) / 2); + cairo_window.curve_to(x1, y1, x1, y1, x1 - RADIUS, y1); + cairo_window.line_to(x0 + RADIUS, y1); + cairo_window.curve_to(x0, y1, x0, y1, x0, (y0 + y1) / 2); + } else { + cairo_window.move_to(x0, y0 + RADIUS); + cairo_window.curve_to(x0, y0, x0, y0, x0 + RADIUS, y0); + cairo_window.line_to(x1 - RADIUS, y0); + cairo_window.curve_to(x1, y0, x1, y0, x1, y0 + RADIUS); + cairo_window.line_to(x1, y1 - RADIUS); + cairo_window.curve_to(x1, y1, x1, y1, x1 - RADIUS, y1); + cairo_window.line_to(x0 + RADIUS, y1); + cairo_window.curve_to(x0, y1, x0, y1, x0, y1 - RADIUS); + } + } + cairo_window.close_path(); + + if (filled) { + cairo_window.fill(); + } else { + cairo_window.set_line_width(LINE_WIDTH); + cairo_window.stroke(); + } +} + +public void draw_right_rounded_rectangle(Gdk.Window window, Gdk.Color color, bool filled, + int x0, int y0, int width, int height) { + if (width == 0 || height == 0) + return; + + double x1 = x0 + width; + double y1 = y0 + height; + + Cairo.Context cairo_window = Gdk.cairo_create(window); + Gdk.cairo_set_source_color(cairo_window, color); + cairo_window.set_antialias(ANTIALIAS); + + if ((width / 2) < RADIUS) { + if ((height / 2) < RADIUS) { + cairo_window.move_to(x0, y0); + cairo_window.line_to((x0 + x1) / 2, y0); + cairo_window.curve_to(x1, y0, x1, y0, x1, (y0 + y1) / 2); + cairo_window.curve_to(x1, y1, x1, y1, (x1 + x0) / 2, y1); + cairo_window.line_to(x0, y1); + cairo_window.line_to(x0, y0); + } else { + cairo_window.move_to(x0, y0); + cairo_window.line_to((x0 + x1) / 2, y0); + cairo_window.curve_to(x1, y0, x1, y0, x1, y0 + RADIUS); + cairo_window.line_to(x1, y1 - RADIUS); + cairo_window.curve_to(x1, y1, x1, y1, (x1 + x0) / 2, y1); + cairo_window.line_to(x0, y1); + cairo_window.line_to(x0, y0); + } + } else { + if ((height / 2) < RADIUS) { + cairo_window.move_to(x0, y0); + cairo_window.line_to(x1 - RADIUS, y0); + cairo_window.curve_to(x1, y0, x1, y0, x1, (y0 + y1) / 2); + cairo_window.curve_to(x1, y1, x1, y1, x1 - RADIUS, y1); + cairo_window.line_to(x0, y1); + cairo_window.line_to(x0, y0); + } else { + cairo_window.move_to(x0, y0); + cairo_window.line_to(x1 - RADIUS, y0); + cairo_window.curve_to(x1, y0, x1, y0, x1, y0 + RADIUS); + cairo_window.line_to(x1, y1 - RADIUS); + cairo_window.curve_to(x1, y1, x1, y1, x1 - RADIUS, y1); + cairo_window.line_to(x0, y1); + cairo_window.line_to(x0, y0); + } + } + cairo_window.close_path(); + + if (filled) { + cairo_window.fill(); + } else { + cairo_window.set_line_width(LINE_WIDTH); + cairo_window.stroke(); + } +} + +public void draw_left_rounded_rectangle(Gdk.Window window, Gdk.Color color, bool filled, + int x0, int y0, int width, int height) { + if (width == 0 || height == 0) + return; + + double x1 = x0 + width; + double y1 = y0 + height; + + Cairo.Context cairo_window = Gdk.cairo_create(window); + Gdk.cairo_set_source_color(cairo_window, color); + cairo_window.set_antialias(ANTIALIAS); + + if ((width / 2) < RADIUS) { + if ((height / 2) < RADIUS) { + cairo_window.move_to(x0, ((y0 + y1) / 2)); + cairo_window.curve_to(x0, y0, x0, y0, (x0 + x1) / 2, y0); + cairo_window.line_to(x1, y0); + cairo_window.line_to(x1, y1); + cairo_window.line_to((x1 + x0) / 2, y1); + cairo_window.curve_to(x0, y1, x0, y1, x0, (y0 + y1) / 2); + } else { + cairo_window.move_to(x0, y0 + RADIUS); + cairo_window.curve_to(x0,y0, x0, y0, (x0 + x1) / 2, y0); + cairo_window.line_to(x1, y0); + cairo_window.line_to(x1, y1); + cairo_window.line_to((x1 + x0) / 2, y1); + cairo_window.curve_to(x0, y1, x0, y1, x0, y1 - RADIUS); + } + } else { + if ((height / 2) < RADIUS) { + cairo_window.move_to(x0, (y0 + y1) / 2); + cairo_window.curve_to(x0, y0, x0, y0, x0 + RADIUS, y0); + cairo_window.line_to(x1, y0); + cairo_window.line_to(x1, y1); + cairo_window.line_to(x0 + RADIUS, y1); + cairo_window.curve_to(x0, y1, x0, y1, x0, (y0 + y1) / 2); + } else { + cairo_window.move_to(x0, y0 + RADIUS); + cairo_window.curve_to(x0, y0, x0, y0, x0 + RADIUS, y0); + cairo_window.line_to(x1, y0); + cairo_window.line_to(x1, y1); + cairo_window.line_to(x0 + RADIUS, y1); + cairo_window.curve_to(x0, y1, x0, y1, x0, y1 - RADIUS); + } + } + cairo_window.close_path(); + + if (filled) { + cairo_window.fill(); + } else { + cairo_window.set_line_width(LINE_WIDTH); + cairo_window.stroke(); + } +} + +public void draw_square_rectangle(Gdk.Window window, Gdk.Color color, bool filled, + int x, int y, int width, int height) { + if (width == 0 || height == 0) + return; + + Cairo.Context cairo_window = Gdk.cairo_create(window); + Gdk.cairo_set_source_color(cairo_window, color); + cairo_window.set_antialias(ANTIALIAS); + + cairo_window.rectangle(x, y, width, height); + + if (filled) { + cairo_window.fill(); + } else { + cairo_window.set_line_width(LINE_WIDTH); + cairo_window.stroke(); + } +} + +// GStreamer utility functions + +public bool is_drop_frame_rate(Fraction r) { + return r.numerator == 2997 && r.denominator == 100 || + r.numerator == 30000 && r.denominator == 1001; +} + +public int64 frame_to_time_with_rate(int frame, Fraction rate) { + int64 time = (int64) Gst.util_uint64_scale(frame, Gst.SECOND * rate.denominator, rate.numerator); + return time; +} + +public int time_to_frame_with_rate(int64 time, Fraction rate) { + int frame = (int) Gst.util_uint64_scale(time, rate.numerator, Gst.SECOND * rate.denominator); + + /* We need frame_to_time_with_rate and time_to_frame_with_rate to be inverse functions, so that + * time_to_frame(frame_to_time_with_rate(f)) = f for all f. With the simple calculation + * above the functions might not be inverses due to rounding error, so we + * need the following check. */ + return time >= frame_to_time_with_rate(frame + 1, rate) ? frame + 1 : frame; +} + +public TimeCode frame_to_time(int frame, Fraction rate) { + int frame_rate = 0; + + TimeCode t = {}; + + t.drop_code = false; + if (rate.denominator == 1) + frame_rate = rate.numerator; + else if (is_drop_frame_rate(rate)) { + t.drop_code = true; + frame_rate = 30; + + // We can't declare these as const int due to a Vala compiler bug. + int FRAMES_PER_MINUTE = 30 * 60 - 2; + int FRAMES_PER_10_MINUTES = 10 * FRAMES_PER_MINUTE + 2; + + int block = frame / FRAMES_PER_10_MINUTES; // number of 10-minute blocks elapsed + int minute_in_block = (frame % FRAMES_PER_10_MINUTES - 2) / FRAMES_PER_MINUTE; + int minutes = 10 * block + minute_in_block; + frame += 2 * minutes - 2 * block; // skip 2 frames per minute, except every 10 minutes + } else { + // TODO: We're getting odd framerate fractions from imported videos, so + // I've removed the error call until we decide what to do + frame_rate = rate.numerator / rate.denominator; + } + + t.frame = frame % frame_rate; + + int64 secs = frame / frame_rate; + t.hour = (int) secs / 3600; + t.minute = ((int) secs % 3600) / 60; + t.second = ((int) secs % 3600) % 60; + + return t; +} + +public string frame_to_string(int frame, Fraction rate) { + return frame_to_time(frame, rate).to_string(); +} + +void breakup_time(int64 time, out int hours, out int minutes, out double seconds) { + int64 the_time = time; + int64 minute = Gst.SECOND * 60; + int64 hour = minute * 60; + hours = (int) (the_time / hour); + the_time = the_time % hour; + minutes = (int) (the_time / minute); + the_time = the_time % minute; + seconds = (double) the_time / Gst.SECOND; +} + +public string time_to_HHMMSS(int64 time) { + int hours; + int minutes; + double seconds; + + breakup_time(time, out hours, out minutes, out seconds); + return "%02d:%02d:%05.2lf".printf(hours, minutes, seconds); +} + +public string time_to_string(int64 time) { + int hours; + int minutes; + double seconds; + + breakup_time(time, out hours, out minutes, out seconds); + string return_value = "%1.2lfs".printf(seconds); + if (hours > 0 || minutes > 0) { + return_value = "%dm ".printf(minutes) + return_value; + } + + if (hours > 0) { + return_value = "%dh ".printf(hours) + return_value; + } + + return return_value; +} + +public static Gst.Element make_element_with_name(string element_name, string? display_name) + throws GLib.Error { + Gst.Element e = Gst.ElementFactory.make(element_name, display_name); + if (e == null) { + throw new + MediaError.MISSING_PLUGIN("Could not create element %s(%s)".printf(element_name, display_name)); + } + return e; +} + +public static Gst.Element make_element(string name) throws Error { + return make_element_with_name(name, null); +} + diff --git a/src/marina/video_track.vala b/src/marina/video_track.vala new file mode 100644 index 0000000..bc858b2 --- /dev/null +++ b/src/marina/video_track.vala @@ -0,0 +1,114 @@ +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + + +namespace Model { +public class VideoTrack : Track { + + public VideoTrack(Model.Project project) { + base(project, "Video Track"); + } + + protected override string name() { return "video"; } + + public override MediaType media_type() { + return MediaType.VIDEO; + } + + protected override bool check(Clip clip) { + Fraction rate1; + Fraction rate2; + + if (!clip.clipfile.is_online()) + return true; + + if (clips.size == 0) + return true; + + if (!get_framerate(out rate2)) { + error_occurred("Cannot get initial frame rate!", null); + return false; + } + + if (!clip.clipfile.get_frame_rate(out rate1)) { + error_occurred("can't get frame rate", null); + return false; + } + + if (!rate1.equal(rate2)) { + error_occurred("can't insert clip with different frame rate", null); + return false; + } + return true; + } + + /* It would be nice if we could query or seek in frames using GST_FORMAT_DEFAULT, or ask + * GStreamer to convert frame->time and time->frame for us using gst_element_query_convert(). + * Unfortunately there are several reasons we can't. + * 1) It appears that position queries using GST_FORMAT_DEFAULT are broken since GstBaseSink + * won't pass them upstream. + * 2) Some codecs (e.g. theoradec) will convert between time and frames, but + * others (e.g. ffmpegdec, dvdec) haven't implemented this conversion. + * 3) Even when a codec will perform conversions, its frame->time and time->frame functions may + * not be perfect inverses; see the comments in time_to_frame(), below. + * + * So instead we must convert manually using the frame rate. + * + * TODO: We should file GStreamer bugs for all of these. + */ + + int64 frame_to_time(int frame) { + Fraction rate; + if (!get_framerate(out rate)) + return 0; + + return (int64) Gst.util_uint64_scale(frame, Gst.SECOND * rate.denominator, rate.numerator); + } + + int time_to_frame(int64 time) { + Fraction rate; + if (!get_framerate(out rate)) + return 0; + return time_to_frame_with_rate(time, rate); + } + + public int get_current_frame(int64 time) { + return time_to_frame(time); + } + + public int64 previous_frame(int64 position) { + int frame = time_to_frame(position); + return frame_to_time(frame - 1); + } + + public int64 next_frame(int64 position) { + int frame = time_to_frame(position); + return frame_to_time(frame + 1); + } + + public bool get_framerate(out Fraction rate) { + if (clips.size == 0) + return false; + + foreach (Clip c in clips) { + if (c.clipfile.is_online()) { + bool can = c.clipfile.get_frame_rate(out rate); + assert(can); + + return can; + } + } + + if (project.default_framerate.equal(Project.INVALID_FRAME_RATE)) + return false; + + rate = project.default_framerate; + return true; + } +} + +} + diff --git a/src/test/Makefile b/src/test/Makefile new file mode 100644 index 0000000..41b0361 --- /dev/null +++ b/src/test/Makefile @@ -0,0 +1,19 @@ +PROGRAM = ../../$(PROGRAM_NAME) +all: $(PROGRAM) + +-include ../../configure.mk + +VALA_LDFLAGS = `pkg-config --libs $(EXT_PKGS)` +-include sources.mk +SRC_FILES += \ + ../marina/ProjectLoader.vala \ + ../marina/Logging.vala \ + ../marina/util.vala + +ifndef BUILD_DIR +BUILD_DIR=debug +endif + +-include ../../marina.mk +HEADER_DIRS += ../marina + diff --git a/src/test/debug/.stamp b/src/test/debug/.stamp new file mode 100644 index 0000000..e69de29 diff --git a/src/test/debug/Logging.c b/src/test/debug/Logging.c new file mode 100644 index 0000000..59595c4 --- /dev/null +++ b/src/test/debug/Logging.c @@ -0,0 +1,127 @@ +/* Logging.c generated by valac, the Vala compiler + * generated from Logging.vala, do not modify */ + +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include + + +#define LOGGING_TYPE_FACILITY (logging_facility_get_type ()) + +#define LOGGING_TYPE_LEVEL (logging_level_get_type ()) + +typedef enum { + LOGGING_FACILITY_SIGNAL_HANDLERS, + LOGGING_FACILITY_DEVELOPER_WARNINGS, + LOGGING_FACILITY_GRAPH, + LOGGING_FACILITY_LOADING, + LOGGING_FACILITY_IMPORT, + LOGGING_FACILITY_SINGLEDECODEBIN +} LoggingFacility; + +typedef enum { + LOGGING_LEVEL_CRITICAL, + LOGGING_LEVEL_HIGH, + LOGGING_LEVEL_MEDIUM, + LOGGING_LEVEL_LOW, + LOGGING_LEVEL_INFO, + LOGGING_LEVEL_VERBOSE +} LoggingLevel; + + +extern LoggingLevel logging_current_level; +LoggingLevel logging_current_level = LOGGING_LEVEL_HIGH; + +GType logging_facility_get_type (void); +GType logging_level_get_type (void); +void logging_set_logging_level (LoggingLevel new_level); +void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message); + +const LoggingLevel LOGGING_active_facility[6] = {LOGGING_LEVEL_CRITICAL, LOGGING_LEVEL_CRITICAL, LOGGING_LEVEL_CRITICAL, LOGGING_LEVEL_CRITICAL, LOGGING_LEVEL_CRITICAL, LOGGING_LEVEL_CRITICAL}; +const char* LOGGING_facility_names[6] = {"SIGNAL_HANDLERS", "DEVELOPER_WARNINGS", "GRAPH", "LOADING", "IMPORT", "SINGLEDECODEBIN"}; + + +GType logging_facility_get_type (void) { + static volatile gsize logging_facility_type_id__volatile = 0; + if (g_once_init_enter (&logging_facility_type_id__volatile)) { + static const GEnumValue values[] = {{LOGGING_FACILITY_SIGNAL_HANDLERS, "LOGGING_FACILITY_SIGNAL_HANDLERS", "signal-handlers"}, {LOGGING_FACILITY_DEVELOPER_WARNINGS, "LOGGING_FACILITY_DEVELOPER_WARNINGS", "developer-warnings"}, {LOGGING_FACILITY_GRAPH, "LOGGING_FACILITY_GRAPH", "graph"}, {LOGGING_FACILITY_LOADING, "LOGGING_FACILITY_LOADING", "loading"}, {LOGGING_FACILITY_IMPORT, "LOGGING_FACILITY_IMPORT", "import"}, {LOGGING_FACILITY_SINGLEDECODEBIN, "LOGGING_FACILITY_SINGLEDECODEBIN", "singledecodebin"}, {0, NULL, NULL}}; + GType logging_facility_type_id; + logging_facility_type_id = g_enum_register_static ("LoggingFacility", values); + g_once_init_leave (&logging_facility_type_id__volatile, logging_facility_type_id); + } + return logging_facility_type_id__volatile; +} + + +GType logging_level_get_type (void) { + static volatile gsize logging_level_type_id__volatile = 0; + if (g_once_init_enter (&logging_level_type_id__volatile)) { + static const GEnumValue values[] = {{LOGGING_LEVEL_CRITICAL, "LOGGING_LEVEL_CRITICAL", "critical"}, {LOGGING_LEVEL_HIGH, "LOGGING_LEVEL_HIGH", "high"}, {LOGGING_LEVEL_MEDIUM, "LOGGING_LEVEL_MEDIUM", "medium"}, {LOGGING_LEVEL_LOW, "LOGGING_LEVEL_LOW", "low"}, {LOGGING_LEVEL_INFO, "LOGGING_LEVEL_INFO", "info"}, {LOGGING_LEVEL_VERBOSE, "LOGGING_LEVEL_VERBOSE", "verbose"}, {0, NULL, NULL}}; + GType logging_level_type_id; + logging_level_type_id = g_enum_register_static ("LoggingLevel", values); + g_once_init_leave (&logging_level_type_id__volatile, logging_level_type_id); + } + return logging_level_type_id__volatile; +} + + +#line 46 "Logging.vala" +void logging_set_logging_level (LoggingLevel new_level) { +#line 79 "Logging.c" + gboolean _tmp0_ = FALSE; +#line 47 "Logging.vala" + if (new_level <= LOGGING_LEVEL_VERBOSE) { +#line 47 "Logging.vala" + _tmp0_ = new_level >= LOGGING_LEVEL_CRITICAL; +#line 85 "Logging.c" + } else { +#line 47 "Logging.vala" + _tmp0_ = FALSE; +#line 89 "Logging.c" + } +#line 47 "Logging.vala" + if (_tmp0_) { +#line 48 "Logging.vala" + logging_current_level = new_level; +#line 95 "Logging.c" + } +} + + +#line 52 "Logging.vala" +void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message) { +#line 102 "Logging.c" + gboolean _tmp0_ = FALSE; +#line 52 "Logging.vala" + g_return_if_fail (G_IS_OBJECT (object)); +#line 52 "Logging.vala" + g_return_if_fail (message != NULL); +#line 53 "Logging.vala" + if (level <= logging_current_level) { +#line 53 "Logging.vala" + _tmp0_ = TRUE; +#line 112 "Logging.c" + } else { +#line 53 "Logging.vala" + _tmp0_ = level <= LOGGING_active_facility[facility]; +#line 116 "Logging.c" + } +#line 53 "Logging.vala" + if (_tmp0_) { +#line 54 "Logging.vala" + fprintf (stderr, "%s(%s): %s\n", g_type_name (G_TYPE_FROM_INSTANCE (object)), LOGGING_facility_names[facility], message); +#line 122 "Logging.c" + } +} + + + + diff --git a/src/test/debug/Logging.o b/src/test/debug/Logging.o new file mode 100644 index 0000000..24bc0f4 Binary files /dev/null and b/src/test/debug/Logging.o differ diff --git a/src/test/debug/ProjectLoader.c b/src/test/debug/ProjectLoader.c new file mode 100644 index 0000000..2540eb1 --- /dev/null +++ b/src/test/debug/ProjectLoader.c @@ -0,0 +1,2126 @@ +/* ProjectLoader.c generated by valac, the Vala compiler + * generated from ProjectLoader.vala, do not modify */ + +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include + + +#define MODEL_TYPE_LOADER_HANDLER (model_loader_handler_get_type ()) +#define MODEL_LOADER_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_LOADER_HANDLER, ModelLoaderHandler)) +#define MODEL_LOADER_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_LOADER_HANDLER, ModelLoaderHandlerClass)) +#define MODEL_IS_LOADER_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_LOADER_HANDLER)) +#define MODEL_IS_LOADER_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_LOADER_HANDLER)) +#define MODEL_LOADER_HANDLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_LOADER_HANDLER, ModelLoaderHandlerClass)) + +typedef struct _ModelLoaderHandler ModelLoaderHandler; +typedef struct _ModelLoaderHandlerClass ModelLoaderHandlerClass; +typedef struct _ModelLoaderHandlerPrivate ModelLoaderHandlerPrivate; + +#define MODEL_TYPE_XML_TREE_LOADER (model_xml_tree_loader_get_type ()) +#define MODEL_XML_TREE_LOADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_XML_TREE_LOADER, ModelXmlTreeLoader)) +#define MODEL_XML_TREE_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_XML_TREE_LOADER, ModelXmlTreeLoaderClass)) +#define MODEL_IS_XML_TREE_LOADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_XML_TREE_LOADER)) +#define MODEL_IS_XML_TREE_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_XML_TREE_LOADER)) +#define MODEL_XML_TREE_LOADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_XML_TREE_LOADER, ModelXmlTreeLoaderClass)) + +typedef struct _ModelXmlTreeLoader ModelXmlTreeLoader; +typedef struct _ModelXmlTreeLoaderClass ModelXmlTreeLoaderClass; +typedef struct _ModelXmlTreeLoaderPrivate ModelXmlTreeLoaderPrivate; + +#define MODEL_TYPE_XML_ELEMENT (model_xml_element_get_type ()) +#define MODEL_XML_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_XML_ELEMENT, ModelXmlElement)) +#define MODEL_XML_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_XML_ELEMENT, ModelXmlElementClass)) +#define MODEL_IS_XML_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_XML_ELEMENT)) +#define MODEL_IS_XML_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_XML_ELEMENT)) +#define MODEL_XML_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_XML_ELEMENT, ModelXmlElementClass)) + +typedef struct _ModelXmlElement ModelXmlElement; +typedef struct _ModelXmlElementClass ModelXmlElementClass; +#define _model_xml_element_unref0(var) ((var == NULL) ? NULL : (var = (model_xml_element_unref (var), NULL))) +#define _g_markup_parse_context_free0(var) ((var == NULL) ? NULL : (var = (g_markup_parse_context_free (var), NULL))) +#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL))) +typedef struct _ModelParamSpecXmlTreeLoader ModelParamSpecXmlTreeLoader; + +#define MODEL_TYPE_PROJECT_BUILDER (model_project_builder_get_type ()) +#define MODEL_PROJECT_BUILDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT_BUILDER, ModelProjectBuilder)) +#define MODEL_PROJECT_BUILDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT_BUILDER, ModelProjectBuilderClass)) +#define MODEL_IS_PROJECT_BUILDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT_BUILDER)) +#define MODEL_IS_PROJECT_BUILDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT_BUILDER)) +#define MODEL_PROJECT_BUILDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT_BUILDER, ModelProjectBuilderClass)) + +typedef struct _ModelProjectBuilder ModelProjectBuilder; +typedef struct _ModelProjectBuilderClass ModelProjectBuilderClass; +typedef struct _ModelProjectBuilderPrivate ModelProjectBuilderPrivate; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +#define _g_free0(var) (var = (g_free (var), NULL)) +typedef struct _ModelXmlElementPrivate ModelXmlElementPrivate; + +#define LOGGING_TYPE_FACILITY (logging_facility_get_type ()) + +#define LOGGING_TYPE_LEVEL (logging_level_get_type ()) +typedef struct _ModelParamSpecXmlElement ModelParamSpecXmlElement; + +#define MODEL_TYPE_PROJECT_LOADER (model_project_loader_get_type ()) +#define MODEL_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoader)) +#define MODEL_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass)) +#define MODEL_IS_PROJECT_LOADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT_LOADER)) +#define MODEL_IS_PROJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT_LOADER)) +#define MODEL_PROJECT_LOADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderClass)) + +typedef struct _ModelProjectLoader ModelProjectLoader; +typedef struct _ModelProjectLoaderClass ModelProjectLoaderClass; +typedef struct _ModelProjectLoaderPrivate ModelProjectLoaderPrivate; +#define _model_xml_tree_loader_unref0(var) ((var == NULL) ? NULL : (var = (model_xml_tree_loader_unref (var), NULL))) + +struct _ModelLoaderHandler { + GObject parent_instance; + ModelLoaderHandlerPrivate * priv; +}; + +struct _ModelLoaderHandlerClass { + GObjectClass parent_class; + gboolean (*commit_library) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_marina) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_track) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_clip) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_clipfile) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_time_signature_entry) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_tempo_entry) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_click) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + gboolean (*commit_library_preference) (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); + void (*leave_library) (ModelLoaderHandler* self); + void (*leave_marina) (ModelLoaderHandler* self); + void (*leave_track) (ModelLoaderHandler* self); + void (*leave_clip) (ModelLoaderHandler* self); + void (*leave_clipfile) (ModelLoaderHandler* self); +}; + +struct _ModelXmlTreeLoader { + GTypeInstance parent_instance; + volatile int ref_count; + ModelXmlTreeLoaderPrivate * priv; + ModelXmlElement* root; +}; + +struct _ModelXmlTreeLoaderClass { + GTypeClass parent_class; + void (*finalize) (ModelXmlTreeLoader *self); +}; + +struct _ModelXmlTreeLoaderPrivate { + ModelXmlElement* current_element; +}; + +struct _ModelParamSpecXmlTreeLoader { + GParamSpec parent_instance; +}; + +struct _ModelProjectBuilder { + GObject parent_instance; + ModelProjectBuilderPrivate * priv; +}; + +struct _ModelProjectBuilderClass { + GObjectClass parent_class; +}; + +struct _ModelProjectBuilderPrivate { + ModelLoaderHandler* handler; +}; + +struct _ModelXmlElement { + GTypeInstance parent_instance; + volatile int ref_count; + ModelXmlElementPrivate * priv; + char** attribute_names; + gint attribute_names_length1; + char** attribute_values; + gint attribute_values_length1; +}; + +struct _ModelXmlElementClass { + GTypeClass parent_class; + void (*finalize) (ModelXmlElement *self); +}; + +typedef enum { + LOGGING_FACILITY_SIGNAL_HANDLERS, + LOGGING_FACILITY_DEVELOPER_WARNINGS, + LOGGING_FACILITY_GRAPH, + LOGGING_FACILITY_LOADING, + LOGGING_FACILITY_IMPORT, + LOGGING_FACILITY_SINGLEDECODEBIN +} LoggingFacility; + +typedef enum { + LOGGING_LEVEL_CRITICAL, + LOGGING_LEVEL_HIGH, + LOGGING_LEVEL_MEDIUM, + LOGGING_LEVEL_LOW, + LOGGING_LEVEL_INFO, + LOGGING_LEVEL_VERBOSE +} LoggingLevel; + +struct _ModelXmlElementPrivate { + char* _name; + ModelXmlElement* _parent; + GeeArrayList* _children; +}; + +struct _ModelParamSpecXmlElement { + GParamSpec parent_instance; +}; + +struct _ModelProjectLoader { + GObject parent_instance; + ModelProjectLoaderPrivate * priv; +}; + +struct _ModelProjectLoaderClass { + GObjectClass parent_class; +}; + +struct _ModelProjectLoaderPrivate { + char* file_name; + ModelLoaderHandler* loader_handler; + char* text; + gsize text_len; + gboolean project_load_completed; + gboolean load_completed_fired; + gboolean handler_completed; +}; + + +static gpointer model_loader_handler_parent_class = NULL; +static gpointer model_xml_tree_loader_parent_class = NULL; +static gpointer model_project_builder_parent_class = NULL; +static gpointer model_xml_element_parent_class = NULL; +static gpointer model_project_loader_parent_class = NULL; + +GType model_loader_handler_get_type (void); +enum { + MODEL_LOADER_HANDLER_DUMMY_PROPERTY +}; +ModelLoaderHandler* model_loader_handler_new (void); +ModelLoaderHandler* model_loader_handler_construct (GType object_type); +gboolean model_loader_handler_commit_library (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +static gboolean model_loader_handler_real_commit_library (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +gboolean model_loader_handler_commit_marina (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +static gboolean model_loader_handler_real_commit_marina (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +gboolean model_loader_handler_commit_track (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +static gboolean model_loader_handler_real_commit_track (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +gboolean model_loader_handler_commit_clip (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +static gboolean model_loader_handler_real_commit_clip (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +gboolean model_loader_handler_commit_clipfile (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +static gboolean model_loader_handler_real_commit_clipfile (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +gboolean model_loader_handler_commit_time_signature_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +static gboolean model_loader_handler_real_commit_time_signature_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +gboolean model_loader_handler_commit_tempo_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +static gboolean model_loader_handler_real_commit_tempo_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +gboolean model_loader_handler_commit_click (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +static gboolean model_loader_handler_real_commit_click (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +gboolean model_loader_handler_commit_library_preference (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +static gboolean model_loader_handler_real_commit_library_preference (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +void model_loader_handler_leave_library (ModelLoaderHandler* self); +static void model_loader_handler_real_leave_library (ModelLoaderHandler* self); +void model_loader_handler_leave_marina (ModelLoaderHandler* self); +static void model_loader_handler_real_leave_marina (ModelLoaderHandler* self); +void model_loader_handler_leave_track (ModelLoaderHandler* self); +static void model_loader_handler_real_leave_track (ModelLoaderHandler* self); +void model_loader_handler_leave_clip (ModelLoaderHandler* self); +static void model_loader_handler_real_leave_clip (ModelLoaderHandler* self); +void model_loader_handler_leave_clipfile (ModelLoaderHandler* self); +static void model_loader_handler_real_leave_clipfile (ModelLoaderHandler* self); +gpointer model_xml_tree_loader_ref (gpointer instance); +void model_xml_tree_loader_unref (gpointer instance); +GParamSpec* model_param_spec_xml_tree_loader (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_xml_tree_loader (GValue* value, gpointer v_object); +void model_value_take_xml_tree_loader (GValue* value, gpointer v_object); +gpointer model_value_get_xml_tree_loader (const GValue* value); +GType model_xml_tree_loader_get_type (void); +gpointer model_xml_element_ref (gpointer instance); +void model_xml_element_unref (gpointer instance); +GParamSpec* model_param_spec_xml_element (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_xml_element (GValue* value, gpointer v_object); +void model_value_take_xml_element (GValue* value, gpointer v_object); +gpointer model_value_get_xml_element (const GValue* value); +GType model_xml_element_get_type (void); +#define MODEL_XML_TREE_LOADER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_XML_TREE_LOADER, ModelXmlTreeLoaderPrivate)) +enum { + MODEL_XML_TREE_LOADER_DUMMY_PROPERTY +}; +static void model_xml_tree_loader_xml_start_element (ModelXmlTreeLoader* self, GMarkupParseContext* c, const char* name, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1); +static void _model_xml_tree_loader_xml_start_element_gmarkup_parser_start_element_func (GMarkupParseContext* context, const char* element_name, char** attribute_names, char** attribute_values, gpointer self); +static void model_xml_tree_loader_xml_end_element (ModelXmlTreeLoader* self, GMarkupParseContext* c, const char* name); +static void _model_xml_tree_loader_xml_end_element_gmarkup_parser_end_element_func (GMarkupParseContext* context, const char* element_name, gpointer self); +ModelXmlTreeLoader* model_xml_tree_loader_new (const char* document); +ModelXmlTreeLoader* model_xml_tree_loader_construct (GType object_type, const char* document); +ModelXmlElement* model_xml_element_new (const char* name, char** attribute_names, int attribute_names_length1, char** attribute_values, int attribute_values_length1, ModelXmlElement* parent); +ModelXmlElement* model_xml_element_construct (GType object_type, const char* name, char** attribute_names, int attribute_names_length1, char** attribute_values, int attribute_values_length1, ModelXmlElement* parent); +void model_xml_element_add_child (ModelXmlElement* self, ModelXmlElement* child_element); +ModelXmlElement* model_xml_element_get_parent (ModelXmlElement* self); +static void model_xml_tree_loader_finalize (ModelXmlTreeLoader* obj); +GType model_project_builder_get_type (void); +#define MODEL_PROJECT_BUILDER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_PROJECT_BUILDER, ModelProjectBuilderPrivate)) +enum { + MODEL_PROJECT_BUILDER_DUMMY_PROPERTY +}; +ModelProjectBuilder* model_project_builder_new (ModelLoaderHandler* handler); +ModelProjectBuilder* model_project_builder_construct (GType object_type, ModelLoaderHandler* handler); +const char* model_xml_element_get_name (ModelXmlElement* self); +static gboolean model_project_builder_check_name (ModelProjectBuilder* self, const char* expected_name, ModelXmlElement* node); +GeeArrayList* model_xml_element_get_children (ModelXmlElement* self); +static void model_project_builder_handle_clip (ModelProjectBuilder* self, ModelXmlElement* clip); +GType logging_facility_get_type (void); +GType logging_level_get_type (void); +void logging_emit (GObject* object, LoggingFacility facility, LoggingLevel level, const char* message); +static void model_project_builder_handle_track (ModelProjectBuilder* self, ModelXmlElement* track); +static void model_project_builder_handle_preference (ModelProjectBuilder* self, ModelXmlElement* preference); +static void model_project_builder_handle_time_signature (ModelProjectBuilder* self, ModelXmlElement* time_signature); +static void model_project_builder_handle_tempo (ModelProjectBuilder* self, ModelXmlElement* tempo); +static void model_project_builder_handle_map (ModelProjectBuilder* self, ModelXmlElement* map); +static void model_project_builder_handle_library (ModelProjectBuilder* self, ModelXmlElement* library); +static void model_project_builder_handle_tracks (ModelProjectBuilder* self, ModelXmlElement* tracks); +static void model_project_builder_handle_preferences (ModelProjectBuilder* self, ModelXmlElement* preferences); +static void model_project_builder_handle_maps (ModelProjectBuilder* self, ModelXmlElement* maps); +gboolean model_project_builder_check_project (ModelProjectBuilder* self, ModelXmlElement* root); +void model_project_builder_build_project (ModelProjectBuilder* self, ModelXmlElement* root); +static void model_project_builder_finalize (GObject* obj); +#define MODEL_XML_ELEMENT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_XML_ELEMENT, ModelXmlElementPrivate)) +enum { + MODEL_XML_ELEMENT_DUMMY_PROPERTY +}; +static void model_xml_element_set_name (ModelXmlElement* self, const char* value); +char** copy_array (char** source, int source_length1, int* result_length1); +static void model_xml_element_set_parent (ModelXmlElement* self, ModelXmlElement* value); +static void model_xml_element_finalize (ModelXmlElement* obj); +GType model_project_loader_get_type (void); +#define MODEL_PROJECT_LOADER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_PROJECT_LOADER, ModelProjectLoaderPrivate)) +enum { + MODEL_PROJECT_LOADER_DUMMY_PROPERTY +}; +static void model_project_loader_on_load_error (ModelProjectLoader* self, const char* _error_); +static void _model_project_loader_on_load_error_model_loader_handler_load_error (ModelLoaderHandler* _sender, const char* error_message, gpointer self); +static void model_project_loader_on_handler_complete (ModelProjectLoader* self); +static void _model_project_loader_on_handler_complete_model_loader_handler_complete (ModelLoaderHandler* _sender, gpointer self); +ModelProjectLoader* model_project_loader_new (ModelLoaderHandler* loader_handler, const char* file_name); +ModelProjectLoader* model_project_loader_construct (GType object_type, ModelLoaderHandler* loader_handler, const char* file_name); +static void _model_project_loader_on_load_error_model_project_builder_error_occurred (ModelProjectBuilder* _sender, const char* _error_, gpointer self); +void model_project_loader_load (ModelProjectLoader* self); +static void model_project_loader_finalize (GObject* obj); +static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func); +static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func); +static gint _vala_array_length (gpointer array); +static int _vala_strcmp0 (const char * str1, const char * str2); + + + +#line 15 "ProjectLoader.vala" +ModelLoaderHandler* model_loader_handler_construct (GType object_type) { +#line 332 "ProjectLoader.c" + ModelLoaderHandler * self; +#line 15 "ProjectLoader.vala" + self = (ModelLoaderHandler*) g_object_new (object_type, NULL); +#line 336 "ProjectLoader.c" + return self; +} + + +#line 15 "ProjectLoader.vala" +ModelLoaderHandler* model_loader_handler_new (void) { +#line 15 "ProjectLoader.vala" + return model_loader_handler_construct (MODEL_TYPE_LOADER_HANDLER); +#line 345 "ProjectLoader.c" +} + + +#line 18 "ProjectLoader.vala" +static gboolean model_loader_handler_real_commit_library (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 351 "ProjectLoader.c" + gboolean result = FALSE; +#line 18 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE); +#line 355 "ProjectLoader.c" + result = TRUE; +#line 19 "ProjectLoader.vala" + return result; +#line 359 "ProjectLoader.c" +} + + +#line 18 "ProjectLoader.vala" +gboolean model_loader_handler_commit_library (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 18 "ProjectLoader.vala" + return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_library (self, attr_names, attr_names_length1, attr_values, attr_values_length1); +#line 367 "ProjectLoader.c" +} + + +#line 22 "ProjectLoader.vala" +static gboolean model_loader_handler_real_commit_marina (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 373 "ProjectLoader.c" + gboolean result = FALSE; +#line 22 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE); +#line 377 "ProjectLoader.c" + result = TRUE; +#line 23 "ProjectLoader.vala" + return result; +#line 381 "ProjectLoader.c" +} + + +#line 22 "ProjectLoader.vala" +gboolean model_loader_handler_commit_marina (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 22 "ProjectLoader.vala" + return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_marina (self, attr_names, attr_names_length1, attr_values, attr_values_length1); +#line 389 "ProjectLoader.c" +} + + +#line 26 "ProjectLoader.vala" +static gboolean model_loader_handler_real_commit_track (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 395 "ProjectLoader.c" + gboolean result = FALSE; +#line 26 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE); +#line 399 "ProjectLoader.c" + result = TRUE; +#line 27 "ProjectLoader.vala" + return result; +#line 403 "ProjectLoader.c" +} + + +#line 26 "ProjectLoader.vala" +gboolean model_loader_handler_commit_track (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 26 "ProjectLoader.vala" + return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_track (self, attr_names, attr_names_length1, attr_values, attr_values_length1); +#line 411 "ProjectLoader.c" +} + + +#line 30 "ProjectLoader.vala" +static gboolean model_loader_handler_real_commit_clip (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 417 "ProjectLoader.c" + gboolean result = FALSE; +#line 30 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE); +#line 421 "ProjectLoader.c" + result = TRUE; +#line 31 "ProjectLoader.vala" + return result; +#line 425 "ProjectLoader.c" +} + + +#line 30 "ProjectLoader.vala" +gboolean model_loader_handler_commit_clip (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 30 "ProjectLoader.vala" + return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_clip (self, attr_names, attr_names_length1, attr_values, attr_values_length1); +#line 433 "ProjectLoader.c" +} + + +#line 34 "ProjectLoader.vala" +static gboolean model_loader_handler_real_commit_clipfile (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 439 "ProjectLoader.c" + gboolean result = FALSE; +#line 34 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE); +#line 443 "ProjectLoader.c" + result = TRUE; +#line 35 "ProjectLoader.vala" + return result; +#line 447 "ProjectLoader.c" +} + + +#line 34 "ProjectLoader.vala" +gboolean model_loader_handler_commit_clipfile (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 34 "ProjectLoader.vala" + return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_clipfile (self, attr_names, attr_names_length1, attr_values, attr_values_length1); +#line 455 "ProjectLoader.c" +} + + +#line 38 "ProjectLoader.vala" +static gboolean model_loader_handler_real_commit_time_signature_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 461 "ProjectLoader.c" + gboolean result = FALSE; +#line 38 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE); +#line 465 "ProjectLoader.c" + result = TRUE; +#line 39 "ProjectLoader.vala" + return result; +#line 469 "ProjectLoader.c" +} + + +#line 38 "ProjectLoader.vala" +gboolean model_loader_handler_commit_time_signature_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 38 "ProjectLoader.vala" + return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_time_signature_entry (self, attr_names, attr_names_length1, attr_values, attr_values_length1); +#line 477 "ProjectLoader.c" +} + + +#line 42 "ProjectLoader.vala" +static gboolean model_loader_handler_real_commit_tempo_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 483 "ProjectLoader.c" + gboolean result = FALSE; +#line 42 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE); +#line 487 "ProjectLoader.c" + result = TRUE; +#line 43 "ProjectLoader.vala" + return result; +#line 491 "ProjectLoader.c" +} + + +#line 42 "ProjectLoader.vala" +gboolean model_loader_handler_commit_tempo_entry (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 42 "ProjectLoader.vala" + return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_tempo_entry (self, attr_names, attr_names_length1, attr_values, attr_values_length1); +#line 499 "ProjectLoader.c" +} + + +#line 46 "ProjectLoader.vala" +static gboolean model_loader_handler_real_commit_click (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 505 "ProjectLoader.c" + gboolean result = FALSE; +#line 46 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE); +#line 509 "ProjectLoader.c" + result = TRUE; +#line 47 "ProjectLoader.vala" + return result; +#line 513 "ProjectLoader.c" +} + + +#line 46 "ProjectLoader.vala" +gboolean model_loader_handler_commit_click (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 46 "ProjectLoader.vala" + return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_click (self, attr_names, attr_names_length1, attr_values, attr_values_length1); +#line 521 "ProjectLoader.c" +} + + +#line 50 "ProjectLoader.vala" +static gboolean model_loader_handler_real_commit_library_preference (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 527 "ProjectLoader.c" + gboolean result = FALSE; +#line 50 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (self), FALSE); +#line 531 "ProjectLoader.c" + result = TRUE; +#line 51 "ProjectLoader.vala" + return result; +#line 535 "ProjectLoader.c" +} + + +#line 50 "ProjectLoader.vala" +gboolean model_loader_handler_commit_library_preference (ModelLoaderHandler* self, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 50 "ProjectLoader.vala" + return MODEL_LOADER_HANDLER_GET_CLASS (self)->commit_library_preference (self, attr_names, attr_names_length1, attr_values, attr_values_length1); +#line 543 "ProjectLoader.c" +} + + +#line 54 "ProjectLoader.vala" +static void model_loader_handler_real_leave_library (ModelLoaderHandler* self) { +#line 54 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_LOADER_HANDLER (self)); +#line 551 "ProjectLoader.c" +} + + +#line 54 "ProjectLoader.vala" +void model_loader_handler_leave_library (ModelLoaderHandler* self) { +#line 54 "ProjectLoader.vala" + MODEL_LOADER_HANDLER_GET_CLASS (self)->leave_library (self); +#line 559 "ProjectLoader.c" +} + + +#line 57 "ProjectLoader.vala" +static void model_loader_handler_real_leave_marina (ModelLoaderHandler* self) { +#line 57 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_LOADER_HANDLER (self)); +#line 567 "ProjectLoader.c" +} + + +#line 57 "ProjectLoader.vala" +void model_loader_handler_leave_marina (ModelLoaderHandler* self) { +#line 57 "ProjectLoader.vala" + MODEL_LOADER_HANDLER_GET_CLASS (self)->leave_marina (self); +#line 575 "ProjectLoader.c" +} + + +#line 60 "ProjectLoader.vala" +static void model_loader_handler_real_leave_track (ModelLoaderHandler* self) { +#line 60 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_LOADER_HANDLER (self)); +#line 583 "ProjectLoader.c" +} + + +#line 60 "ProjectLoader.vala" +void model_loader_handler_leave_track (ModelLoaderHandler* self) { +#line 60 "ProjectLoader.vala" + MODEL_LOADER_HANDLER_GET_CLASS (self)->leave_track (self); +#line 591 "ProjectLoader.c" +} + + +#line 63 "ProjectLoader.vala" +static void model_loader_handler_real_leave_clip (ModelLoaderHandler* self) { +#line 63 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_LOADER_HANDLER (self)); +#line 599 "ProjectLoader.c" +} + + +#line 63 "ProjectLoader.vala" +void model_loader_handler_leave_clip (ModelLoaderHandler* self) { +#line 63 "ProjectLoader.vala" + MODEL_LOADER_HANDLER_GET_CLASS (self)->leave_clip (self); +#line 607 "ProjectLoader.c" +} + + +#line 66 "ProjectLoader.vala" +static void model_loader_handler_real_leave_clipfile (ModelLoaderHandler* self) { +#line 66 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_LOADER_HANDLER (self)); +#line 615 "ProjectLoader.c" +} + + +#line 66 "ProjectLoader.vala" +void model_loader_handler_leave_clipfile (ModelLoaderHandler* self) { +#line 66 "ProjectLoader.vala" + MODEL_LOADER_HANDLER_GET_CLASS (self)->leave_clipfile (self); +#line 623 "ProjectLoader.c" +} + + +static void model_loader_handler_class_init (ModelLoaderHandlerClass * klass) { + model_loader_handler_parent_class = g_type_class_peek_parent (klass); + MODEL_LOADER_HANDLER_CLASS (klass)->commit_library = model_loader_handler_real_commit_library; + MODEL_LOADER_HANDLER_CLASS (klass)->commit_marina = model_loader_handler_real_commit_marina; + MODEL_LOADER_HANDLER_CLASS (klass)->commit_track = model_loader_handler_real_commit_track; + MODEL_LOADER_HANDLER_CLASS (klass)->commit_clip = model_loader_handler_real_commit_clip; + MODEL_LOADER_HANDLER_CLASS (klass)->commit_clipfile = model_loader_handler_real_commit_clipfile; + MODEL_LOADER_HANDLER_CLASS (klass)->commit_time_signature_entry = model_loader_handler_real_commit_time_signature_entry; + MODEL_LOADER_HANDLER_CLASS (klass)->commit_tempo_entry = model_loader_handler_real_commit_tempo_entry; + MODEL_LOADER_HANDLER_CLASS (klass)->commit_click = model_loader_handler_real_commit_click; + MODEL_LOADER_HANDLER_CLASS (klass)->commit_library_preference = model_loader_handler_real_commit_library_preference; + MODEL_LOADER_HANDLER_CLASS (klass)->leave_library = model_loader_handler_real_leave_library; + MODEL_LOADER_HANDLER_CLASS (klass)->leave_marina = model_loader_handler_real_leave_marina; + MODEL_LOADER_HANDLER_CLASS (klass)->leave_track = model_loader_handler_real_leave_track; + MODEL_LOADER_HANDLER_CLASS (klass)->leave_clip = model_loader_handler_real_leave_clip; + MODEL_LOADER_HANDLER_CLASS (klass)->leave_clipfile = model_loader_handler_real_leave_clipfile; + g_signal_new ("load_error", MODEL_TYPE_LOADER_HANDLER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING); + g_signal_new ("complete", MODEL_TYPE_LOADER_HANDLER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); +} + + +static void model_loader_handler_instance_init (ModelLoaderHandler * self) { +} + + +GType model_loader_handler_get_type (void) { + static volatile gsize model_loader_handler_type_id__volatile = 0; + if (g_once_init_enter (&model_loader_handler_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelLoaderHandlerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_loader_handler_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelLoaderHandler), 0, (GInstanceInitFunc) model_loader_handler_instance_init, NULL }; + GType model_loader_handler_type_id; + model_loader_handler_type_id = g_type_register_static (G_TYPE_OBJECT, "ModelLoaderHandler", &g_define_type_info, 0); + g_once_init_leave (&model_loader_handler_type_id__volatile, model_loader_handler_type_id); + } + return model_loader_handler_type_id__volatile; +} + + +#line 87 "ProjectLoader.vala" +static void _model_xml_tree_loader_xml_start_element_gmarkup_parser_start_element_func (GMarkupParseContext* context, const char* element_name, char** attribute_names, char** attribute_values, gpointer self) { +#line 666 "ProjectLoader.c" + model_xml_tree_loader_xml_start_element (self, context, element_name, attribute_names, _vala_array_length (attribute_names), attribute_values, _vala_array_length (attribute_values)); +} + + +#line 100 "ProjectLoader.vala" +static void _model_xml_tree_loader_xml_end_element_gmarkup_parser_end_element_func (GMarkupParseContext* context, const char* element_name, gpointer self) { +#line 673 "ProjectLoader.c" + model_xml_tree_loader_xml_end_element (self, context, element_name); +} + + +static glong string_get_length (const char* self) { + glong result; + g_return_val_if_fail (self != NULL, 0L); + result = g_utf8_strlen (self, -1); +#line 1158 "glib-2.0.vapi" + return result; +#line 684 "ProjectLoader.c" +} + + +#line 76 "ProjectLoader.vala" +ModelXmlTreeLoader* model_xml_tree_loader_construct (GType object_type, const char* document) { +#line 690 "ProjectLoader.c" + GError * _inner_error_; + ModelXmlTreeLoader* self; + GMarkupParser _tmp0_ = {0}; + GMarkupParser parser; + GMarkupParseContext* context; +#line 76 "ProjectLoader.vala" + g_return_val_if_fail (document != NULL, NULL); +#line 698 "ProjectLoader.c" + _inner_error_ = NULL; + self = (ModelXmlTreeLoader*) g_type_create_instance (object_type); +#line 77 "ProjectLoader.vala" + parser = (_tmp0_.start_element = _model_xml_tree_loader_xml_start_element_gmarkup_parser_start_element_func, _tmp0_.end_element = _model_xml_tree_loader_xml_end_element_gmarkup_parser_end_element_func, _tmp0_.text = NULL, _tmp0_.passthrough = NULL, _tmp0_); +#line 79 "ProjectLoader.vala" + context = g_markup_parse_context_new (&parser, (GMarkupParseFlags) 0, self, NULL); +#line 705 "ProjectLoader.c" + { +#line 81 "ProjectLoader.vala" + g_markup_parse_context_parse (context, document, (gssize) string_get_length (document), &_inner_error_); +#line 709 "ProjectLoader.c" + if (_inner_error_ != NULL) { + if (_inner_error_->domain == G_MARKUP_ERROR) { + goto __catch0_g_markup_error; + } + _g_markup_parse_context_free0 (context); + g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return NULL; + } + } + goto __finally0; + __catch0_g_markup_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { + _g_error_free0 (e); + } + } + __finally0: + if (_inner_error_ != NULL) { + _g_markup_parse_context_free0 (context); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return NULL; + } + _g_markup_parse_context_free0 (context); + return self; +} + + +#line 76 "ProjectLoader.vala" +ModelXmlTreeLoader* model_xml_tree_loader_new (const char* document) { +#line 76 "ProjectLoader.vala" + return model_xml_tree_loader_construct (MODEL_TYPE_XML_TREE_LOADER, document); +#line 746 "ProjectLoader.c" +} + + +static gpointer _model_xml_element_ref0 (gpointer self) { + return self ? model_xml_element_ref (self) : NULL; +} + + +#line 87 "ProjectLoader.vala" +static void model_xml_tree_loader_xml_start_element (ModelXmlTreeLoader* self, GMarkupParseContext* c, const char* name, char** attr_names, int attr_names_length1, char** attr_values, int attr_values_length1) { +#line 757 "ProjectLoader.c" + ModelXmlElement* new_element; + ModelXmlElement* _tmp1_; +#line 87 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_TREE_LOADER (self)); +#line 87 "ProjectLoader.vala" + g_return_if_fail (c != NULL); +#line 87 "ProjectLoader.vala" + g_return_if_fail (name != NULL); +#line 89 "ProjectLoader.vala" + new_element = model_xml_element_new (name, attr_names, attr_names_length1, attr_values, attr_values_length1, self->priv->current_element); +#line 90 "ProjectLoader.vala" + if (self->root == NULL) { +#line 770 "ProjectLoader.c" + ModelXmlElement* _tmp0_; +#line 91 "ProjectLoader.vala" + self->root = (_tmp0_ = _model_xml_element_ref0 (new_element), _model_xml_element_unref0 (self->root), _tmp0_); +#line 774 "ProjectLoader.c" + } else { +#line 93 "ProjectLoader.vala" + g_assert (self->priv->current_element != NULL); +#line 94 "ProjectLoader.vala" + model_xml_element_add_child (self->priv->current_element, new_element); +#line 780 "ProjectLoader.c" + } +#line 97 "ProjectLoader.vala" + self->priv->current_element = (_tmp1_ = _model_xml_element_ref0 (new_element), _model_xml_element_unref0 (self->priv->current_element), _tmp1_); +#line 784 "ProjectLoader.c" + _model_xml_element_unref0 (new_element); +} + + +#line 100 "ProjectLoader.vala" +static void model_xml_tree_loader_xml_end_element (ModelXmlTreeLoader* self, GMarkupParseContext* c, const char* name) { +#line 791 "ProjectLoader.c" + ModelXmlElement* _tmp0_; +#line 100 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_TREE_LOADER (self)); +#line 100 "ProjectLoader.vala" + g_return_if_fail (c != NULL); +#line 100 "ProjectLoader.vala" + g_return_if_fail (name != NULL); +#line 101 "ProjectLoader.vala" + g_assert (self->priv->current_element != NULL); +#line 102 "ProjectLoader.vala" + self->priv->current_element = (_tmp0_ = _model_xml_element_ref0 (model_xml_element_get_parent (self->priv->current_element)), _model_xml_element_unref0 (self->priv->current_element), _tmp0_); +#line 803 "ProjectLoader.c" +} + + +static void model_value_xml_tree_loader_init (GValue* value) { + value->data[0].v_pointer = NULL; +} + + +static void model_value_xml_tree_loader_free_value (GValue* value) { + if (value->data[0].v_pointer) { + model_xml_tree_loader_unref (value->data[0].v_pointer); + } +} + + +static void model_value_xml_tree_loader_copy_value (const GValue* src_value, GValue* dest_value) { + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = model_xml_tree_loader_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + + +static gpointer model_value_xml_tree_loader_peek_pointer (const GValue* value) { + return value->data[0].v_pointer; +} + + +static gchar* model_value_xml_tree_loader_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + if (collect_values[0].v_pointer) { + ModelXmlTreeLoader* object; + object = collect_values[0].v_pointer; + if (object->parent_instance.g_class == NULL) { + return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) { + return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } + value->data[0].v_pointer = model_xml_tree_loader_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + + +static gchar* model_value_xml_tree_loader_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + ModelXmlTreeLoader** object_p; + object_p = collect_values[0].v_pointer; + if (!object_p) { + return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); + } + if (!value->data[0].v_pointer) { + *object_p = NULL; + } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) { + *object_p = value->data[0].v_pointer; + } else { + *object_p = model_xml_tree_loader_ref (value->data[0].v_pointer); + } + return NULL; +} + + +GParamSpec* model_param_spec_xml_tree_loader (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) { + ModelParamSpecXmlTreeLoader* spec; + g_return_val_if_fail (g_type_is_a (object_type, MODEL_TYPE_XML_TREE_LOADER), NULL); + spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags); + G_PARAM_SPEC (spec)->value_type = object_type; + return G_PARAM_SPEC (spec); +} + + +gpointer model_value_get_xml_tree_loader (const GValue* value) { + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_XML_TREE_LOADER), NULL); + return value->data[0].v_pointer; +} + + +void model_value_set_xml_tree_loader (GValue* value, gpointer v_object) { + ModelXmlTreeLoader* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_XML_TREE_LOADER)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_XML_TREE_LOADER)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + model_xml_tree_loader_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + model_xml_tree_loader_unref (old); + } +} + + +void model_value_take_xml_tree_loader (GValue* value, gpointer v_object) { + ModelXmlTreeLoader* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_XML_TREE_LOADER)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_XML_TREE_LOADER)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + model_xml_tree_loader_unref (old); + } +} + + +static void model_xml_tree_loader_class_init (ModelXmlTreeLoaderClass * klass) { + model_xml_tree_loader_parent_class = g_type_class_peek_parent (klass); + MODEL_XML_TREE_LOADER_CLASS (klass)->finalize = model_xml_tree_loader_finalize; + g_type_class_add_private (klass, sizeof (ModelXmlTreeLoaderPrivate)); +} + + +static void model_xml_tree_loader_instance_init (ModelXmlTreeLoader * self) { + self->priv = MODEL_XML_TREE_LOADER_GET_PRIVATE (self); + self->priv->current_element = NULL; + self->root = NULL; + self->ref_count = 1; +} + + +static void model_xml_tree_loader_finalize (ModelXmlTreeLoader* obj) { + ModelXmlTreeLoader * self; + self = MODEL_XML_TREE_LOADER (obj); + _model_xml_element_unref0 (self->priv->current_element); + _model_xml_element_unref0 (self->root); +} + + +GType model_xml_tree_loader_get_type (void) { + static volatile gsize model_xml_tree_loader_type_id__volatile = 0; + if (g_once_init_enter (&model_xml_tree_loader_type_id__volatile)) { + static const GTypeValueTable g_define_type_value_table = { model_value_xml_tree_loader_init, model_value_xml_tree_loader_free_value, model_value_xml_tree_loader_copy_value, model_value_xml_tree_loader_peek_pointer, "p", model_value_xml_tree_loader_collect_value, "p", model_value_xml_tree_loader_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (ModelXmlTreeLoaderClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_xml_tree_loader_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelXmlTreeLoader), 0, (GInstanceInitFunc) model_xml_tree_loader_instance_init, &g_define_type_value_table }; + static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) }; + GType model_xml_tree_loader_type_id; + model_xml_tree_loader_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ModelXmlTreeLoader", &g_define_type_info, &g_define_type_fundamental_info, 0); + g_once_init_leave (&model_xml_tree_loader_type_id__volatile, model_xml_tree_loader_type_id); + } + return model_xml_tree_loader_type_id__volatile; +} + + +gpointer model_xml_tree_loader_ref (gpointer instance) { + ModelXmlTreeLoader* self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + + +void model_xml_tree_loader_unref (gpointer instance) { + ModelXmlTreeLoader* self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + MODEL_XML_TREE_LOADER_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 114 "ProjectLoader.vala" +ModelProjectBuilder* model_project_builder_construct (GType object_type, ModelLoaderHandler* handler) { +#line 979 "ProjectLoader.c" + ModelProjectBuilder * self; + ModelLoaderHandler* _tmp0_; +#line 114 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (handler), NULL); +#line 114 "ProjectLoader.vala" + self = (ModelProjectBuilder*) g_object_new (object_type, NULL); +#line 115 "ProjectLoader.vala" + self->priv->handler = (_tmp0_ = _g_object_ref0 (handler), _g_object_unref0 (self->priv->handler), _tmp0_); +#line 988 "ProjectLoader.c" + return self; +} + + +#line 114 "ProjectLoader.vala" +ModelProjectBuilder* model_project_builder_new (ModelLoaderHandler* handler) { +#line 114 "ProjectLoader.vala" + return model_project_builder_construct (MODEL_TYPE_PROJECT_BUILDER, handler); +#line 997 "ProjectLoader.c" +} + + +#line 118 "ProjectLoader.vala" +static gboolean model_project_builder_check_name (ModelProjectBuilder* self, const char* expected_name, ModelXmlElement* node) { +#line 1003 "ProjectLoader.c" + gboolean result = FALSE; + char* _tmp0_; +#line 118 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_PROJECT_BUILDER (self), FALSE); +#line 118 "ProjectLoader.vala" + g_return_val_if_fail (expected_name != NULL, FALSE); +#line 118 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_XML_ELEMENT (node), FALSE); +#line 119 "ProjectLoader.vala" + if (_vala_strcmp0 (model_xml_element_get_name (node), expected_name) == 0) { +#line 1014 "ProjectLoader.c" + result = TRUE; +#line 120 "ProjectLoader.vala" + return result; +#line 1018 "ProjectLoader.c" + } +#line 123 "ProjectLoader.vala" + g_signal_emit_by_name (self, "error-occurred", _tmp0_ = g_strdup_printf ("expected %s, got %s", expected_name, model_xml_element_get_name (node))); +#line 1022 "ProjectLoader.c" + _g_free0 (_tmp0_); + result = FALSE; +#line 124 "ProjectLoader.vala" + return result; +#line 1027 "ProjectLoader.c" +} + + +#line 127 "ProjectLoader.vala" +static void model_project_builder_handle_clip (ModelProjectBuilder* self, ModelXmlElement* clip) { +#line 127 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self)); +#line 127 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_ELEMENT (clip)); +#line 128 "ProjectLoader.vala" + if (model_project_builder_check_name (self, "clip", clip)) { +#line 129 "ProjectLoader.vala" + if (model_loader_handler_commit_clip (self->priv->handler, clip->attribute_names, clip->attribute_names_length1, clip->attribute_values, clip->attribute_values_length1)) { +#line 130 "ProjectLoader.vala" + if (gee_collection_get_size (GEE_COLLECTION (model_xml_element_get_children (clip))) != 0) { +#line 131 "ProjectLoader.vala" + g_signal_emit_by_name (self, "error-occurred", "clip cannot have children"); +#line 1045 "ProjectLoader.c" + } +#line 133 "ProjectLoader.vala" + model_loader_handler_leave_clip (self->priv->handler); +#line 1049 "ProjectLoader.c" + } + } +} + + +#line 138 "ProjectLoader.vala" +static void model_project_builder_handle_track (ModelProjectBuilder* self, ModelXmlElement* track) { +#line 138 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self)); +#line 138 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_ELEMENT (track)); +#line 139 "ProjectLoader.vala" + if (model_project_builder_check_name (self, "track", track)) { +#line 140 "ProjectLoader.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_LOADING, LOGGING_LEVEL_VERBOSE, "loading track"); +#line 141 "ProjectLoader.vala" + if (model_loader_handler_commit_track (self->priv->handler, track->attribute_names, track->attribute_names_length1, track->attribute_values, track->attribute_values_length1)) { +#line 1067 "ProjectLoader.c" + { + GeeIterator* _child_it; + _child_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (model_xml_element_get_children (track))); +#line 142 "ProjectLoader.vala" + while (TRUE) { +#line 1073 "ProjectLoader.c" + ModelXmlElement* child; +#line 142 "ProjectLoader.vala" + if (!gee_iterator_next (_child_it)) { +#line 142 "ProjectLoader.vala" + break; +#line 1079 "ProjectLoader.c" + } +#line 142 "ProjectLoader.vala" + child = (ModelXmlElement*) gee_iterator_get (_child_it); +#line 143 "ProjectLoader.vala" + model_project_builder_handle_clip (self, child); +#line 1085 "ProjectLoader.c" + _model_xml_element_unref0 (child); + } + _g_object_unref0 (_child_it); + } +#line 145 "ProjectLoader.vala" + model_loader_handler_leave_track (self->priv->handler); +#line 1092 "ProjectLoader.c" + } + } +} + + +#line 150 "ProjectLoader.vala" +static void model_project_builder_handle_preference (ModelProjectBuilder* self, ModelXmlElement* preference) { +#line 150 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self)); +#line 150 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_ELEMENT (preference)); +#line 151 "ProjectLoader.vala" + if (_vala_strcmp0 ("click", model_xml_element_get_name (preference)) == 0) { +#line 152 "ProjectLoader.vala" + model_loader_handler_commit_click (self->priv->handler, preference->attribute_names, preference->attribute_names_length1, preference->attribute_values, preference->attribute_values_length1); +#line 1108 "ProjectLoader.c" + } else { +#line 153 "ProjectLoader.vala" + if (_vala_strcmp0 ("library", model_xml_element_get_name (preference)) == 0) { +#line 154 "ProjectLoader.vala" + model_loader_handler_commit_library_preference (self->priv->handler, preference->attribute_names, preference->attribute_names_length1, preference->attribute_values, preference->attribute_values_length1); +#line 1114 "ProjectLoader.c" + } else { + char* _tmp0_; +#line 157 "ProjectLoader.vala" + g_signal_emit_by_name (self, "error-occurred", _tmp0_ = g_strdup_printf ("Unknown preference: %s", model_xml_element_get_name (preference))); +#line 1119 "ProjectLoader.c" + _g_free0 (_tmp0_); + } + } +} + + +#line 161 "ProjectLoader.vala" +static void model_project_builder_handle_time_signature (ModelProjectBuilder* self, ModelXmlElement* time_signature) { +#line 161 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self)); +#line 161 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_ELEMENT (time_signature)); +#line 1132 "ProjectLoader.c" + { + GeeIterator* _child_it; + _child_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (model_xml_element_get_children (time_signature))); +#line 162 "ProjectLoader.vala" + while (TRUE) { +#line 1138 "ProjectLoader.c" + ModelXmlElement* child; +#line 162 "ProjectLoader.vala" + if (!gee_iterator_next (_child_it)) { +#line 162 "ProjectLoader.vala" + break; +#line 1144 "ProjectLoader.c" + } +#line 162 "ProjectLoader.vala" + child = (ModelXmlElement*) gee_iterator_get (_child_it); +#line 163 "ProjectLoader.vala" + if (model_project_builder_check_name (self, "entry", child)) { +#line 164 "ProjectLoader.vala" + if (!model_loader_handler_commit_time_signature_entry (self->priv->handler, child->attribute_names, child->attribute_names_length1, child->attribute_values, child->attribute_values_length1)) { +#line 166 "ProjectLoader.vala" + g_signal_emit_by_name (self, "error-occurred", "Improper time signature node"); +#line 1154 "ProjectLoader.c" + } + } + _model_xml_element_unref0 (child); + } + _g_object_unref0 (_child_it); + } +} + + +#line 172 "ProjectLoader.vala" +static void model_project_builder_handle_tempo (ModelProjectBuilder* self, ModelXmlElement* tempo) { +#line 172 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self)); +#line 172 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_ELEMENT (tempo)); +#line 1170 "ProjectLoader.c" + { + GeeIterator* _child_it; + _child_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (model_xml_element_get_children (tempo))); +#line 173 "ProjectLoader.vala" + while (TRUE) { +#line 1176 "ProjectLoader.c" + ModelXmlElement* child; +#line 173 "ProjectLoader.vala" + if (!gee_iterator_next (_child_it)) { +#line 173 "ProjectLoader.vala" + break; +#line 1182 "ProjectLoader.c" + } +#line 173 "ProjectLoader.vala" + child = (ModelXmlElement*) gee_iterator_get (_child_it); +#line 174 "ProjectLoader.vala" + if (model_project_builder_check_name (self, "entry", child)) { +#line 175 "ProjectLoader.vala" + if (!model_loader_handler_commit_tempo_entry (self->priv->handler, child->attribute_names, child->attribute_names_length1, child->attribute_values, child->attribute_values_length1)) { +#line 176 "ProjectLoader.vala" + g_signal_emit_by_name (self, "error-occurred", "Improper tempo node"); +#line 1192 "ProjectLoader.c" + } + } + _model_xml_element_unref0 (child); + } + _g_object_unref0 (_child_it); + } +} + + +#line 182 "ProjectLoader.vala" +static void model_project_builder_handle_map (ModelProjectBuilder* self, ModelXmlElement* map) { +#line 1204 "ProjectLoader.c" + GQuark _tmp1_; + const char* _tmp0_; + static GQuark _tmp1__label0 = 0; + static GQuark _tmp1__label1 = 0; +#line 182 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self)); +#line 182 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_ELEMENT (map)); +#line 1213 "ProjectLoader.c" + _tmp0_ = model_xml_element_get_name (map); + _tmp1_ = (NULL == _tmp0_) ? 0 : g_quark_from_string (_tmp0_); + if (_tmp1_ == ((0 != _tmp1__label0) ? _tmp1__label0 : (_tmp1__label0 = g_quark_from_static_string ("tempo")))) + switch (0) { + default: + { +#line 185 "ProjectLoader.vala" + model_project_builder_handle_tempo (self, map); +#line 186 "ProjectLoader.vala" + break; +#line 1224 "ProjectLoader.c" + } + } else if (_tmp1_ == ((0 != _tmp1__label1) ? _tmp1__label1 : (_tmp1__label1 = g_quark_from_static_string ("time_signature")))) + switch (0) { + default: + { +#line 188 "ProjectLoader.vala" + model_project_builder_handle_time_signature (self, map); +#line 189 "ProjectLoader.vala" + break; +#line 1234 "ProjectLoader.c" + } + } else + switch (0) { + default: + { +#line 191 "ProjectLoader.vala" + g_signal_emit_by_name (self, "error-occurred", "improper map node"); +#line 192 "ProjectLoader.vala" + break; +#line 1244 "ProjectLoader.c" + } + } +} + + +#line 196 "ProjectLoader.vala" +static void model_project_builder_handle_library (ModelProjectBuilder* self, ModelXmlElement* library) { +#line 196 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self)); +#line 196 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_ELEMENT (library)); +#line 197 "ProjectLoader.vala" + if (model_loader_handler_commit_library (self->priv->handler, library->attribute_names, library->attribute_names_length1, library->attribute_values, library->attribute_values_length1)) { +#line 1258 "ProjectLoader.c" + { + GeeIterator* _child_it; + _child_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (model_xml_element_get_children (library))); +#line 198 "ProjectLoader.vala" + while (TRUE) { +#line 1264 "ProjectLoader.c" + ModelXmlElement* child; +#line 198 "ProjectLoader.vala" + if (!gee_iterator_next (_child_it)) { +#line 198 "ProjectLoader.vala" + break; +#line 1270 "ProjectLoader.c" + } +#line 198 "ProjectLoader.vala" + child = (ModelXmlElement*) gee_iterator_get (_child_it); +#line 199 "ProjectLoader.vala" + if (!model_loader_handler_commit_clipfile (self->priv->handler, child->attribute_names, child->attribute_names_length1, child->attribute_values, child->attribute_values_length1)) { +#line 200 "ProjectLoader.vala" + g_signal_emit_by_name (self, "error-occurred", "Improper library node"); +#line 1278 "ProjectLoader.c" + } + _model_xml_element_unref0 (child); + } + _g_object_unref0 (_child_it); + } +#line 202 "ProjectLoader.vala" + model_loader_handler_leave_library (self->priv->handler); +#line 1286 "ProjectLoader.c" + } +} + + +#line 206 "ProjectLoader.vala" +static void model_project_builder_handle_tracks (ModelProjectBuilder* self, ModelXmlElement* tracks) { +#line 206 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self)); +#line 206 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_ELEMENT (tracks)); +#line 1297 "ProjectLoader.c" + { + GeeIterator* _child_it; + _child_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (model_xml_element_get_children (tracks))); +#line 207 "ProjectLoader.vala" + while (TRUE) { +#line 1303 "ProjectLoader.c" + ModelXmlElement* child; +#line 207 "ProjectLoader.vala" + if (!gee_iterator_next (_child_it)) { +#line 207 "ProjectLoader.vala" + break; +#line 1309 "ProjectLoader.c" + } +#line 207 "ProjectLoader.vala" + child = (ModelXmlElement*) gee_iterator_get (_child_it); +#line 208 "ProjectLoader.vala" + model_project_builder_handle_track (self, child); +#line 1315 "ProjectLoader.c" + _model_xml_element_unref0 (child); + } + _g_object_unref0 (_child_it); + } +} + + +#line 212 "ProjectLoader.vala" +static void model_project_builder_handle_preferences (ModelProjectBuilder* self, ModelXmlElement* preferences) { +#line 212 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self)); +#line 212 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_ELEMENT (preferences)); +#line 1329 "ProjectLoader.c" + { + GeeIterator* _child_it; + _child_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (model_xml_element_get_children (preferences))); +#line 213 "ProjectLoader.vala" + while (TRUE) { +#line 1335 "ProjectLoader.c" + ModelXmlElement* child; +#line 213 "ProjectLoader.vala" + if (!gee_iterator_next (_child_it)) { +#line 213 "ProjectLoader.vala" + break; +#line 1341 "ProjectLoader.c" + } +#line 213 "ProjectLoader.vala" + child = (ModelXmlElement*) gee_iterator_get (_child_it); +#line 214 "ProjectLoader.vala" + model_project_builder_handle_preference (self, child); +#line 1347 "ProjectLoader.c" + _model_xml_element_unref0 (child); + } + _g_object_unref0 (_child_it); + } +} + + +#line 217 "ProjectLoader.vala" +static void model_project_builder_handle_maps (ModelProjectBuilder* self, ModelXmlElement* maps) { +#line 217 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self)); +#line 217 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_ELEMENT (maps)); +#line 1361 "ProjectLoader.c" + { + GeeIterator* _child_it; + _child_it = gee_abstract_collection_iterator (GEE_ABSTRACT_COLLECTION (model_xml_element_get_children (maps))); +#line 218 "ProjectLoader.vala" + while (TRUE) { +#line 1367 "ProjectLoader.c" + ModelXmlElement* child; +#line 218 "ProjectLoader.vala" + if (!gee_iterator_next (_child_it)) { +#line 218 "ProjectLoader.vala" + break; +#line 1373 "ProjectLoader.c" + } +#line 218 "ProjectLoader.vala" + child = (ModelXmlElement*) gee_iterator_get (_child_it); +#line 219 "ProjectLoader.vala" + model_project_builder_handle_map (self, child); +#line 1379 "ProjectLoader.c" + _model_xml_element_unref0 (child); + } + _g_object_unref0 (_child_it); + } +} + + +#line 222 "ProjectLoader.vala" +gboolean model_project_builder_check_project (ModelProjectBuilder* self, ModelXmlElement* root) { +#line 1389 "ProjectLoader.c" + gboolean result = FALSE; + gboolean _tmp0_ = FALSE; +#line 222 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_PROJECT_BUILDER (self), FALSE); +#line 222 "ProjectLoader.vala" + g_return_val_if_fail ((root == NULL) || MODEL_IS_XML_ELEMENT (root), FALSE); +#line 223 "ProjectLoader.vala" + if (root == NULL) { +#line 224 "ProjectLoader.vala" + g_signal_emit_by_name (self, "error-occurred", "Invalid XML file!"); +#line 1400 "ProjectLoader.c" + result = FALSE; +#line 225 "ProjectLoader.vala" + return result; +#line 1404 "ProjectLoader.c" + } +#line 228 "ProjectLoader.vala" + if (model_project_builder_check_name (self, "marina", root)) { +#line 229 "ProjectLoader.vala" + _tmp0_ = model_loader_handler_commit_marina (self->priv->handler, root->attribute_names, root->attribute_names_length1, root->attribute_values, root->attribute_values_length1); +#line 1410 "ProjectLoader.c" + } else { +#line 228 "ProjectLoader.vala" + _tmp0_ = FALSE; +#line 1414 "ProjectLoader.c" + } +#line 228 "ProjectLoader.vala" + if (_tmp0_) { +#line 1418 "ProjectLoader.c" + gboolean _tmp1_ = FALSE; + gboolean _tmp2_ = FALSE; + gboolean _tmp3_ = FALSE; + ModelXmlElement* _tmp4_; + gboolean _tmp5_; + gboolean _tmp8_ = FALSE; +#line 230 "ProjectLoader.vala" + if (gee_collection_get_size (GEE_COLLECTION (model_xml_element_get_children (root))) != 3) { +#line 230 "ProjectLoader.vala" + _tmp1_ = gee_collection_get_size (GEE_COLLECTION (model_xml_element_get_children (root))) != 4; +#line 1429 "ProjectLoader.c" + } else { +#line 230 "ProjectLoader.vala" + _tmp1_ = FALSE; +#line 1433 "ProjectLoader.c" + } +#line 230 "ProjectLoader.vala" + if (_tmp1_) { +#line 231 "ProjectLoader.vala" + g_signal_emit_by_name (self, "error-occurred", "Improper number of children!"); +#line 1439 "ProjectLoader.c" + result = FALSE; +#line 232 "ProjectLoader.vala" + return result; +#line 1443 "ProjectLoader.c" + } +#line 235 "ProjectLoader.vala" + if ((_tmp5_ = !model_project_builder_check_name (self, "library", _tmp4_ = (ModelXmlElement*) gee_abstract_list_get (GEE_ABSTRACT_LIST (model_xml_element_get_children (root)), 0)), _model_xml_element_unref0 (_tmp4_), _tmp5_)) { +#line 235 "ProjectLoader.vala" + _tmp3_ = TRUE; +#line 1449 "ProjectLoader.c" + } else { + ModelXmlElement* _tmp6_; +#line 236 "ProjectLoader.vala" + _tmp3_ = !model_project_builder_check_name (self, "tracks", _tmp6_ = (ModelXmlElement*) gee_abstract_list_get (GEE_ABSTRACT_LIST (model_xml_element_get_children (root)), 1)); +#line 1454 "ProjectLoader.c" + _model_xml_element_unref0 (_tmp6_); + } +#line 235 "ProjectLoader.vala" + if (_tmp3_) { +#line 235 "ProjectLoader.vala" + _tmp2_ = TRUE; +#line 1461 "ProjectLoader.c" + } else { + ModelXmlElement* _tmp7_; +#line 237 "ProjectLoader.vala" + _tmp2_ = !model_project_builder_check_name (self, "preferences", _tmp7_ = (ModelXmlElement*) gee_abstract_list_get (GEE_ABSTRACT_LIST (model_xml_element_get_children (root)), 2)); +#line 1466 "ProjectLoader.c" + _model_xml_element_unref0 (_tmp7_); + } +#line 235 "ProjectLoader.vala" + if (_tmp2_) { +#line 1471 "ProjectLoader.c" + result = FALSE; +#line 238 "ProjectLoader.vala" + return result; +#line 1475 "ProjectLoader.c" + } +#line 240 "ProjectLoader.vala" + if (gee_collection_get_size (GEE_COLLECTION (model_xml_element_get_children (root))) == 4) { +#line 1479 "ProjectLoader.c" + ModelXmlElement* _tmp9_; +#line 240 "ProjectLoader.vala" + _tmp8_ = !model_project_builder_check_name (self, "maps", _tmp9_ = (ModelXmlElement*) gee_abstract_list_get (GEE_ABSTRACT_LIST (model_xml_element_get_children (root)), 3)); +#line 1483 "ProjectLoader.c" + _model_xml_element_unref0 (_tmp9_); + } else { +#line 240 "ProjectLoader.vala" + _tmp8_ = FALSE; +#line 1488 "ProjectLoader.c" + } +#line 240 "ProjectLoader.vala" + if (_tmp8_) { +#line 1492 "ProjectLoader.c" + result = FALSE; +#line 241 "ProjectLoader.vala" + return result; +#line 1496 "ProjectLoader.c" + } + } else { + result = FALSE; +#line 244 "ProjectLoader.vala" + return result; +#line 1502 "ProjectLoader.c" + } + result = TRUE; +#line 245 "ProjectLoader.vala" + return result; +#line 1507 "ProjectLoader.c" +} + + +#line 248 "ProjectLoader.vala" +void model_project_builder_build_project (ModelProjectBuilder* self, ModelXmlElement* root) { +#line 1513 "ProjectLoader.c" + ModelXmlElement* _tmp0_; + ModelXmlElement* _tmp1_; + ModelXmlElement* _tmp2_; +#line 248 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_BUILDER (self)); +#line 248 "ProjectLoader.vala" + g_return_if_fail ((root == NULL) || MODEL_IS_XML_ELEMENT (root)); +#line 249 "ProjectLoader.vala" + model_project_builder_handle_library (self, _tmp0_ = (ModelXmlElement*) gee_abstract_list_get (GEE_ABSTRACT_LIST (model_xml_element_get_children (root)), 0)); +#line 1523 "ProjectLoader.c" + _model_xml_element_unref0 (_tmp0_); +#line 250 "ProjectLoader.vala" + model_project_builder_handle_tracks (self, _tmp1_ = (ModelXmlElement*) gee_abstract_list_get (GEE_ABSTRACT_LIST (model_xml_element_get_children (root)), 1)); +#line 1527 "ProjectLoader.c" + _model_xml_element_unref0 (_tmp1_); +#line 251 "ProjectLoader.vala" + model_project_builder_handle_preferences (self, _tmp2_ = (ModelXmlElement*) gee_abstract_list_get (GEE_ABSTRACT_LIST (model_xml_element_get_children (root)), 2)); +#line 1531 "ProjectLoader.c" + _model_xml_element_unref0 (_tmp2_); +#line 252 "ProjectLoader.vala" + if (gee_collection_get_size (GEE_COLLECTION (model_xml_element_get_children (root))) == 4) { +#line 1535 "ProjectLoader.c" + ModelXmlElement* _tmp3_; +#line 253 "ProjectLoader.vala" + model_project_builder_handle_maps (self, _tmp3_ = (ModelXmlElement*) gee_abstract_list_get (GEE_ABSTRACT_LIST (model_xml_element_get_children (root)), 3)); +#line 1539 "ProjectLoader.c" + _model_xml_element_unref0 (_tmp3_); + } +#line 256 "ProjectLoader.vala" + model_loader_handler_leave_marina (self->priv->handler); +#line 1544 "ProjectLoader.c" +} + + +static void model_project_builder_class_init (ModelProjectBuilderClass * klass) { + model_project_builder_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ModelProjectBuilderPrivate)); + G_OBJECT_CLASS (klass)->finalize = model_project_builder_finalize; + g_signal_new ("error_occurred", MODEL_TYPE_PROJECT_BUILDER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING); +} + + +static void model_project_builder_instance_init (ModelProjectBuilder * self) { + self->priv = MODEL_PROJECT_BUILDER_GET_PRIVATE (self); +} + + +static void model_project_builder_finalize (GObject* obj) { + ModelProjectBuilder * self; + self = MODEL_PROJECT_BUILDER (obj); + _g_object_unref0 (self->priv->handler); + G_OBJECT_CLASS (model_project_builder_parent_class)->finalize (obj); +} + + +GType model_project_builder_get_type (void) { + static volatile gsize model_project_builder_type_id__volatile = 0; + if (g_once_init_enter (&model_project_builder_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelProjectBuilderClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_project_builder_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelProjectBuilder), 0, (GInstanceInitFunc) model_project_builder_instance_init, NULL }; + GType model_project_builder_type_id; + model_project_builder_type_id = g_type_register_static (G_TYPE_OBJECT, "ModelProjectBuilder", &g_define_type_info, 0); + g_once_init_leave (&model_project_builder_type_id__volatile, model_project_builder_type_id); + } + return model_project_builder_type_id__volatile; +} + + +#line 272 "ProjectLoader.vala" +ModelXmlElement* model_xml_element_construct (GType object_type, const char* name, char** attribute_names, int attribute_names_length1, char** attribute_values, int attribute_values_length1, ModelXmlElement* parent) { +#line 1583 "ProjectLoader.c" + ModelXmlElement* self; + char** _tmp1_; + gint _tmp0_; + char** _tmp3_; + gint _tmp2_; + GeeArrayList* _tmp4_; +#line 272 "ProjectLoader.vala" + g_return_val_if_fail (name != NULL, NULL); +#line 272 "ProjectLoader.vala" + g_return_val_if_fail ((parent == NULL) || MODEL_IS_XML_ELEMENT (parent), NULL); +#line 1594 "ProjectLoader.c" + self = (ModelXmlElement*) g_type_create_instance (object_type); +#line 274 "ProjectLoader.vala" + model_xml_element_set_name (self, name); +#line 276 "ProjectLoader.vala" + self->attribute_names = (_tmp1_ = copy_array (attribute_names, attribute_names_length1, &_tmp0_), self->attribute_names = (_vala_array_free (self->attribute_names, self->attribute_names_length1, (GDestroyNotify) g_free), NULL), self->attribute_names_length1 = _tmp0_, _tmp1_); +#line 277 "ProjectLoader.vala" + self->attribute_values = (_tmp3_ = copy_array (attribute_values, attribute_values_length1, &_tmp2_), self->attribute_values = (_vala_array_free (self->attribute_values, self->attribute_values_length1, (GDestroyNotify) g_free), NULL), self->attribute_values_length1 = _tmp2_, _tmp3_); +#line 278 "ProjectLoader.vala" + model_xml_element_set_parent (self, parent); +#line 279 "ProjectLoader.vala" + self->priv->_children = (_tmp4_ = gee_array_list_new (MODEL_TYPE_XML_ELEMENT, (GBoxedCopyFunc) model_xml_element_ref, model_xml_element_unref, NULL), _g_object_unref0 (self->priv->_children), _tmp4_); +#line 1606 "ProjectLoader.c" + return self; +} + + +#line 272 "ProjectLoader.vala" +ModelXmlElement* model_xml_element_new (const char* name, char** attribute_names, int attribute_names_length1, char** attribute_values, int attribute_values_length1, ModelXmlElement* parent) { +#line 272 "ProjectLoader.vala" + return model_xml_element_construct (MODEL_TYPE_XML_ELEMENT, name, attribute_names, attribute_names_length1, attribute_values, attribute_values_length1, parent); +#line 1615 "ProjectLoader.c" +} + + +#line 282 "ProjectLoader.vala" +void model_xml_element_add_child (ModelXmlElement* self, ModelXmlElement* child_element) { +#line 282 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_ELEMENT (self)); +#line 282 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_XML_ELEMENT (child_element)); +#line 283 "ProjectLoader.vala" + gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->_children), child_element); +#line 1627 "ProjectLoader.c" +} + + +const char* model_xml_element_get_name (ModelXmlElement* self) { + const char* result; + g_return_val_if_fail (MODEL_IS_XML_ELEMENT (self), NULL); + result = self->priv->_name; +#line 261 "ProjectLoader.vala" + return result; +#line 1637 "ProjectLoader.c" +} + + +static void model_xml_element_set_name (ModelXmlElement* self, const char* value) { + char* _tmp0_; + g_return_if_fail (MODEL_IS_XML_ELEMENT (self)); + self->priv->_name = (_tmp0_ = g_strdup (value), _g_free0 (self->priv->_name), _tmp0_); +} + + +GeeArrayList* model_xml_element_get_children (ModelXmlElement* self) { + GeeArrayList* result; + g_return_val_if_fail (MODEL_IS_XML_ELEMENT (self), NULL); + result = self->priv->_children; +#line 267 "ProjectLoader.vala" + return result; +#line 1654 "ProjectLoader.c" +} + + +ModelXmlElement* model_xml_element_get_parent (ModelXmlElement* self) { + ModelXmlElement* result; + g_return_val_if_fail (MODEL_IS_XML_ELEMENT (self), NULL); + result = self->priv->_parent; +#line 269 "ProjectLoader.vala" + return result; +#line 1664 "ProjectLoader.c" +} + + +static void model_xml_element_set_parent (ModelXmlElement* self, ModelXmlElement* value) { + g_return_if_fail (MODEL_IS_XML_ELEMENT (self)); + self->priv->_parent = value; +} + + +static void model_value_xml_element_init (GValue* value) { + value->data[0].v_pointer = NULL; +} + + +static void model_value_xml_element_free_value (GValue* value) { + if (value->data[0].v_pointer) { + model_xml_element_unref (value->data[0].v_pointer); + } +} + + +static void model_value_xml_element_copy_value (const GValue* src_value, GValue* dest_value) { + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = model_xml_element_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + + +static gpointer model_value_xml_element_peek_pointer (const GValue* value) { + return value->data[0].v_pointer; +} + + +static gchar* model_value_xml_element_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + if (collect_values[0].v_pointer) { + ModelXmlElement* object; + object = collect_values[0].v_pointer; + if (object->parent_instance.g_class == NULL) { + return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) { + return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } + value->data[0].v_pointer = model_xml_element_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + + +static gchar* model_value_xml_element_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + ModelXmlElement** object_p; + object_p = collect_values[0].v_pointer; + if (!object_p) { + return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); + } + if (!value->data[0].v_pointer) { + *object_p = NULL; + } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) { + *object_p = value->data[0].v_pointer; + } else { + *object_p = model_xml_element_ref (value->data[0].v_pointer); + } + return NULL; +} + + +GParamSpec* model_param_spec_xml_element (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) { + ModelParamSpecXmlElement* spec; + g_return_val_if_fail (g_type_is_a (object_type, MODEL_TYPE_XML_ELEMENT), NULL); + spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags); + G_PARAM_SPEC (spec)->value_type = object_type; + return G_PARAM_SPEC (spec); +} + + +gpointer model_value_get_xml_element (const GValue* value) { + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_XML_ELEMENT), NULL); + return value->data[0].v_pointer; +} + + +void model_value_set_xml_element (GValue* value, gpointer v_object) { + ModelXmlElement* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_XML_ELEMENT)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_XML_ELEMENT)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + model_xml_element_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + model_xml_element_unref (old); + } +} + + +void model_value_take_xml_element (GValue* value, gpointer v_object) { + ModelXmlElement* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_XML_ELEMENT)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_XML_ELEMENT)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + model_xml_element_unref (old); + } +} + + +static void model_xml_element_class_init (ModelXmlElementClass * klass) { + model_xml_element_parent_class = g_type_class_peek_parent (klass); + MODEL_XML_ELEMENT_CLASS (klass)->finalize = model_xml_element_finalize; + g_type_class_add_private (klass, sizeof (ModelXmlElementPrivate)); +} + + +static void model_xml_element_instance_init (ModelXmlElement * self) { + self->priv = MODEL_XML_ELEMENT_GET_PRIVATE (self); + self->ref_count = 1; +} + + +static void model_xml_element_finalize (ModelXmlElement* obj) { + ModelXmlElement * self; + self = MODEL_XML_ELEMENT (obj); + _g_free0 (self->priv->_name); + self->attribute_names = (_vala_array_free (self->attribute_names, self->attribute_names_length1, (GDestroyNotify) g_free), NULL); + self->attribute_values = (_vala_array_free (self->attribute_values, self->attribute_values_length1, (GDestroyNotify) g_free), NULL); + _g_object_unref0 (self->priv->_children); +} + + +GType model_xml_element_get_type (void) { + static volatile gsize model_xml_element_type_id__volatile = 0; + if (g_once_init_enter (&model_xml_element_type_id__volatile)) { + static const GTypeValueTable g_define_type_value_table = { model_value_xml_element_init, model_value_xml_element_free_value, model_value_xml_element_copy_value, model_value_xml_element_peek_pointer, "p", model_value_xml_element_collect_value, "p", model_value_xml_element_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (ModelXmlElementClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_xml_element_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelXmlElement), 0, (GInstanceInitFunc) model_xml_element_instance_init, &g_define_type_value_table }; + static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) }; + GType model_xml_element_type_id; + model_xml_element_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ModelXmlElement", &g_define_type_info, &g_define_type_fundamental_info, 0); + g_once_init_leave (&model_xml_element_type_id__volatile, model_xml_element_type_id); + } + return model_xml_element_type_id__volatile; +} + + +gpointer model_xml_element_ref (gpointer instance) { + ModelXmlElement* self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + + +void model_xml_element_unref (gpointer instance) { + ModelXmlElement* self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + MODEL_XML_ELEMENT_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + + +#line 307 "ProjectLoader.vala" +static void _model_project_loader_on_load_error_model_loader_handler_load_error (ModelLoaderHandler* _sender, const char* error_message, gpointer self) { +#line 1841 "ProjectLoader.c" + model_project_loader_on_load_error (self, error_message); +} + + +#line 312 "ProjectLoader.vala" +static void _model_project_loader_on_handler_complete_model_loader_handler_complete (ModelLoaderHandler* _sender, gpointer self) { +#line 1848 "ProjectLoader.c" + model_project_loader_on_handler_complete (self); +} + + +#line 300 "ProjectLoader.vala" +ModelProjectLoader* model_project_loader_construct (GType object_type, ModelLoaderHandler* loader_handler, const char* file_name) { +#line 1855 "ProjectLoader.c" + ModelProjectLoader * self; + char* _tmp0_; + ModelLoaderHandler* _tmp1_; +#line 300 "ProjectLoader.vala" + g_return_val_if_fail (MODEL_IS_LOADER_HANDLER (loader_handler), NULL); +#line 300 "ProjectLoader.vala" + self = (ModelProjectLoader*) g_object_new (object_type, NULL); +#line 301 "ProjectLoader.vala" + self->priv->file_name = (_tmp0_ = g_strdup (file_name), _g_free0 (self->priv->file_name), _tmp0_); +#line 302 "ProjectLoader.vala" + self->priv->loader_handler = (_tmp1_ = _g_object_ref0 (loader_handler), _g_object_unref0 (self->priv->loader_handler), _tmp1_); +#line 303 "ProjectLoader.vala" + g_signal_connect_object (loader_handler, "load-error", (GCallback) _model_project_loader_on_load_error_model_loader_handler_load_error, self, 0); +#line 304 "ProjectLoader.vala" + g_signal_connect_object (loader_handler, "complete", (GCallback) _model_project_loader_on_handler_complete_model_loader_handler_complete, self, 0); +#line 1871 "ProjectLoader.c" + return self; +} + + +#line 300 "ProjectLoader.vala" +ModelProjectLoader* model_project_loader_new (ModelLoaderHandler* loader_handler, const char* file_name) { +#line 300 "ProjectLoader.vala" + return model_project_loader_construct (MODEL_TYPE_PROJECT_LOADER, loader_handler, file_name); +#line 1880 "ProjectLoader.c" +} + + +#line 307 "ProjectLoader.vala" +static void model_project_loader_on_load_error (ModelProjectLoader* self, const char* _error_) { +#line 307 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_LOADER (self)); +#line 307 "ProjectLoader.vala" + g_return_if_fail (_error_ != NULL); +#line 308 "ProjectLoader.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_load_error"); +#line 309 "ProjectLoader.vala" + g_signal_emit_by_name (self, "load-error", _error_); +#line 1894 "ProjectLoader.c" +} + + +#line 312 "ProjectLoader.vala" +static void model_project_loader_on_handler_complete (ModelProjectLoader* self) { +#line 1900 "ProjectLoader.c" + gboolean _tmp0_ = FALSE; +#line 312 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_LOADER (self)); +#line 313 "ProjectLoader.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_SIGNAL_HANDLERS, LOGGING_LEVEL_INFO, "on_handler_complete"); +#line 314 "ProjectLoader.vala" + self->priv->handler_completed = TRUE; +#line 315 "ProjectLoader.vala" + if (self->priv->project_load_completed) { +#line 315 "ProjectLoader.vala" + _tmp0_ = !self->priv->load_completed_fired; +#line 1912 "ProjectLoader.c" + } else { +#line 315 "ProjectLoader.vala" + _tmp0_ = FALSE; +#line 1916 "ProjectLoader.c" + } +#line 315 "ProjectLoader.vala" + if (_tmp0_) { +#line 316 "ProjectLoader.vala" + self->priv->load_completed_fired = TRUE; +#line 317 "ProjectLoader.vala" + g_signal_emit_by_name (self, "load-complete"); +#line 1924 "ProjectLoader.c" + } +} + + +#line 307 "ProjectLoader.vala" +static void _model_project_loader_on_load_error_model_project_builder_error_occurred (ModelProjectBuilder* _sender, const char* _error_, gpointer self) { +#line 1931 "ProjectLoader.c" + model_project_loader_on_load_error (self, _error_); +} + + +#line 321 "ProjectLoader.vala" +void model_project_loader_load (ModelProjectLoader* self) { +#line 1938 "ProjectLoader.c" + GError * _inner_error_; + char* _tmp3_; + ModelXmlTreeLoader* tree_loader; + ModelProjectBuilder* builder; +#line 321 "ProjectLoader.vala" + g_return_if_fail (MODEL_IS_PROJECT_LOADER (self)); +#line 1945 "ProjectLoader.c" + _inner_error_ = NULL; + { + char* _tmp1_; + char* _tmp0_ = NULL; +#line 323 "ProjectLoader.vala" + g_file_get_contents (self->priv->file_name, &_tmp0_, &self->priv->text_len, &_inner_error_); +#line 323 "ProjectLoader.vala" + self->priv->text = (_tmp1_ = _tmp0_, _g_free0 (self->priv->text), _tmp1_); +#line 1954 "ProjectLoader.c" + if (_inner_error_ != NULL) { + if (_inner_error_->domain == G_FILE_ERROR) { + goto __catch1_g_file_error; + } + g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } + } + goto __finally1; + __catch1_g_file_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { + char* _tmp2_; +#line 325 "ProjectLoader.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_LOADING, LOGGING_LEVEL_MEDIUM, _tmp2_ = g_strdup_printf ("error loading %s: %s", self->priv->file_name, e->message)); +#line 1974 "ProjectLoader.c" + _g_free0 (_tmp2_); +#line 327 "ProjectLoader.vala" + g_signal_emit_by_name (self, "load-error", e->message); +#line 328 "ProjectLoader.vala" + g_signal_emit_by_name (self, "load-complete"); +#line 1980 "ProjectLoader.c" + _g_error_free0 (e); +#line 329 "ProjectLoader.vala" + return; +#line 1984 "ProjectLoader.c" + } + } + __finally1: + if (_inner_error_ != NULL) { + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } +#line 331 "ProjectLoader.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_LOADING, LOGGING_LEVEL_VERBOSE, _tmp3_ = g_strdup_printf ("Building tree for %s", self->priv->file_name)); +#line 1995 "ProjectLoader.c" + _g_free0 (_tmp3_); +#line 332 "ProjectLoader.vala" + tree_loader = model_xml_tree_loader_new (self->priv->text); +#line 334 "ProjectLoader.vala" + builder = model_project_builder_new (self->priv->loader_handler); +#line 335 "ProjectLoader.vala" + g_signal_connect_object (builder, "error-occurred", (GCallback) _model_project_loader_on_load_error_model_project_builder_error_occurred, self, 0); +#line 337 "ProjectLoader.vala" + if (model_project_builder_check_project (builder, tree_loader->root)) { +#line 2005 "ProjectLoader.c" + gboolean _tmp4_ = FALSE; +#line 338 "ProjectLoader.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_LOADING, LOGGING_LEVEL_VERBOSE, "project checked out. starting load"); +#line 339 "ProjectLoader.vala" + g_signal_emit_by_name (self, "load-started", self->priv->file_name); +#line 340 "ProjectLoader.vala" + model_project_builder_build_project (builder, tree_loader->root); +#line 341 "ProjectLoader.vala" + self->priv->project_load_completed = TRUE; +#line 342 "ProjectLoader.vala" + if (self->priv->handler_completed) { +#line 342 "ProjectLoader.vala" + _tmp4_ = !self->priv->load_completed_fired; +#line 2019 "ProjectLoader.c" + } else { +#line 342 "ProjectLoader.vala" + _tmp4_ = FALSE; +#line 2023 "ProjectLoader.c" + } +#line 342 "ProjectLoader.vala" + if (_tmp4_) { +#line 343 "ProjectLoader.vala" + self->priv->load_completed_fired = TRUE; +#line 344 "ProjectLoader.vala" + g_signal_emit_by_name (self, "load-complete"); +#line 2031 "ProjectLoader.c" + } + } else { +#line 348 "ProjectLoader.vala" + logging_emit (G_OBJECT (self), LOGGING_FACILITY_LOADING, LOGGING_LEVEL_INFO, "project did not check out. stopping."); +#line 349 "ProjectLoader.vala" + g_signal_emit_by_name (self, "load-complete"); +#line 2038 "ProjectLoader.c" + } + _model_xml_tree_loader_unref0 (tree_loader); + _g_object_unref0 (builder); +} + + +static void model_project_loader_class_init (ModelProjectLoaderClass * klass) { + model_project_loader_parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (ModelProjectLoaderPrivate)); + G_OBJECT_CLASS (klass)->finalize = model_project_loader_finalize; + g_signal_new ("load_started", MODEL_TYPE_PROJECT_LOADER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING); + g_signal_new ("load_complete", MODEL_TYPE_PROJECT_LOADER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); + g_signal_new ("load_error", MODEL_TYPE_PROJECT_LOADER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING); +} + + +static void model_project_loader_instance_init (ModelProjectLoader * self) { + self->priv = MODEL_PROJECT_LOADER_GET_PRIVATE (self); + self->priv->project_load_completed = FALSE; + self->priv->load_completed_fired = FALSE; + self->priv->handler_completed = FALSE; +} + + +static void model_project_loader_finalize (GObject* obj) { + ModelProjectLoader * self; + self = MODEL_PROJECT_LOADER (obj); + _g_free0 (self->priv->file_name); + _g_object_unref0 (self->priv->loader_handler); + _g_free0 (self->priv->text); + G_OBJECT_CLASS (model_project_loader_parent_class)->finalize (obj); +} + + +GType model_project_loader_get_type (void) { + static volatile gsize model_project_loader_type_id__volatile = 0; + if (g_once_init_enter (&model_project_loader_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (ModelProjectLoaderClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_project_loader_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelProjectLoader), 0, (GInstanceInitFunc) model_project_loader_instance_init, NULL }; + GType model_project_loader_type_id; + model_project_loader_type_id = g_type_register_static (G_TYPE_OBJECT, "ModelProjectLoader", &g_define_type_info, 0); + g_once_init_leave (&model_project_loader_type_id__volatile, model_project_loader_type_id); + } + return model_project_loader_type_id__volatile; +} + + +static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) { + if ((array != NULL) && (destroy_func != NULL)) { + int i; + for (i = 0; i < array_length; i = i + 1) { + if (((gpointer*) array)[i] != NULL) { + destroy_func (((gpointer*) array)[i]); + } + } + } +} + + +static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) { + _vala_array_destroy (array, array_length, destroy_func); + g_free (array); +} + + +static gint _vala_array_length (gpointer array) { + int length; + length = 0; + if (array) { + while (((gpointer*) array)[length]) { + length++; + } + } + return length; +} + + +static int _vala_strcmp0 (const char * str1, const char * str2) { + if (str1 == NULL) { + return -(str1 != str2); + } + if (str2 == NULL) { + return str1 != str2; + } + return strcmp (str1, str2); +} + + + + diff --git a/src/test/debug/ProjectLoader.o b/src/test/debug/ProjectLoader.o new file mode 100644 index 0000000..bab2c37 Binary files /dev/null and b/src/test/debug/ProjectLoader.o differ diff --git a/src/test/debug/ProjectLoading.c b/src/test/debug/ProjectLoading.c new file mode 100644 index 0000000..b2c1845 --- /dev/null +++ b/src/test/debug/ProjectLoading.c @@ -0,0 +1,989 @@ +/* ProjectLoading.c generated by valac, the Vala compiler + * generated from ProjectLoading.vala, do not modify */ + +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include + + +#define MODEL_TYPE_CLIP_FETCHER (model_clip_fetcher_get_type ()) +#define MODEL_CLIP_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcher)) +#define MODEL_CLIP_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcherClass)) +#define MODEL_IS_CLIP_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FETCHER)) +#define MODEL_IS_CLIP_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FETCHER)) +#define MODEL_CLIP_FETCHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcherClass)) + +typedef struct _ModelClipFetcher ModelClipFetcher; +typedef struct _ModelClipFetcherClass ModelClipFetcherClass; +typedef struct _ModelClipFetcherPrivate ModelClipFetcherPrivate; + +#define MODEL_TYPE_CLIP_FILE (model_clip_file_get_type ()) +#define MODEL_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFile)) +#define MODEL_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) +#define MODEL_IS_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE)) +#define MODEL_IS_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE)) +#define MODEL_CLIP_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFileClass)) + +typedef struct _ModelClipFile ModelClipFile; +typedef struct _ModelClipFileClass ModelClipFileClass; +#define _g_free0(var) (var = (g_free (var), NULL)) +#define _model_clip_file_unref0(var) ((var == NULL) ? NULL : (var = (model_clip_file_unref (var), NULL))) +typedef struct _ModelParamSpecClipFetcher ModelParamSpecClipFetcher; +typedef struct _ModelClipFilePrivate ModelClipFilePrivate; +typedef struct _ModelParamSpecClipFile ModelParamSpecClipFile; + +#define TYPE_VALID_DOCUMENT (valid_document_get_type ()) +typedef struct _ValidDocument ValidDocument; + +#define TYPE_STATE_CHANGE_FIXTURE (state_change_fixture_get_type ()) + +#define MODEL_TYPE_XML_ELEMENT (model_xml_element_get_type ()) +#define MODEL_XML_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_XML_ELEMENT, ModelXmlElement)) +#define MODEL_XML_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_XML_ELEMENT, ModelXmlElementClass)) +#define MODEL_IS_XML_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_XML_ELEMENT)) +#define MODEL_IS_XML_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_XML_ELEMENT)) +#define MODEL_XML_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_XML_ELEMENT, ModelXmlElementClass)) + +typedef struct _ModelXmlElement ModelXmlElement; +typedef struct _ModelXmlElementClass ModelXmlElementClass; + +#define MODEL_TYPE_PROJECT_BUILDER (model_project_builder_get_type ()) +#define MODEL_PROJECT_BUILDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT_BUILDER, ModelProjectBuilder)) +#define MODEL_PROJECT_BUILDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT_BUILDER, ModelProjectBuilderClass)) +#define MODEL_IS_PROJECT_BUILDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT_BUILDER)) +#define MODEL_IS_PROJECT_BUILDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT_BUILDER)) +#define MODEL_PROJECT_BUILDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT_BUILDER, ModelProjectBuilderClass)) + +typedef struct _ModelProjectBuilder ModelProjectBuilder; +typedef struct _ModelProjectBuilderClass ModelProjectBuilderClass; +typedef struct _StateChangeFixture StateChangeFixture; +#define _model_xml_element_unref0(var) ((var == NULL) ? NULL : (var = (model_xml_element_unref (var), NULL))) +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) + +#define MODEL_TYPE_XML_TREE_LOADER (model_xml_tree_loader_get_type ()) +#define MODEL_XML_TREE_LOADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_XML_TREE_LOADER, ModelXmlTreeLoader)) +#define MODEL_XML_TREE_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_XML_TREE_LOADER, ModelXmlTreeLoaderClass)) +#define MODEL_IS_XML_TREE_LOADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_XML_TREE_LOADER)) +#define MODEL_IS_XML_TREE_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_XML_TREE_LOADER)) +#define MODEL_XML_TREE_LOADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_XML_TREE_LOADER, ModelXmlTreeLoaderClass)) + +typedef struct _ModelXmlTreeLoader ModelXmlTreeLoader; +typedef struct _ModelXmlTreeLoaderClass ModelXmlTreeLoaderClass; +typedef struct _ModelXmlTreeLoaderPrivate ModelXmlTreeLoaderPrivate; + +#define MODEL_TYPE_LOADER_HANDLER (model_loader_handler_get_type ()) +#define MODEL_LOADER_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_LOADER_HANDLER, ModelLoaderHandler)) +#define MODEL_LOADER_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_LOADER_HANDLER, ModelLoaderHandlerClass)) +#define MODEL_IS_LOADER_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_LOADER_HANDLER)) +#define MODEL_IS_LOADER_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_LOADER_HANDLER)) +#define MODEL_LOADER_HANDLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_LOADER_HANDLER, ModelLoaderHandlerClass)) + +typedef struct _ModelLoaderHandler ModelLoaderHandler; +typedef struct _ModelLoaderHandlerClass ModelLoaderHandlerClass; +#define _model_xml_tree_loader_unref0(var) ((var == NULL) ? NULL : (var = (model_xml_tree_loader_unref (var), NULL))) +typedef GTestSuite ProjectLoaderSuite; + +struct _ModelClipFetcher { + GTypeInstance parent_instance; + volatile int ref_count; + ModelClipFetcherPrivate * priv; + char* error_string; + ModelClipFile* clipfile; +}; + +struct _ModelClipFetcherClass { + GTypeClass parent_class; + void (*finalize) (ModelClipFetcher *self); +}; + +struct _ModelClipFetcherPrivate { + char* filename; +}; + +struct _ModelParamSpecClipFetcher { + GParamSpec parent_instance; +}; + +struct _ModelClipFile { + GTypeInstance parent_instance; + volatile int ref_count; + ModelClipFilePrivate * priv; + char* filename; +}; + +struct _ModelClipFileClass { + GTypeClass parent_class; + void (*finalize) (ModelClipFile *self); +}; + +struct _ModelParamSpecClipFile { + GParamSpec parent_instance; +}; + +struct _ValidDocument { + gboolean valid; + char* document; +}; + +struct _StateChangeFixture { + ModelXmlElement* root; + ModelProjectBuilder* project_builder; + gboolean valid; +}; + +struct _ModelXmlTreeLoader { + GTypeInstance parent_instance; + volatile int ref_count; + ModelXmlTreeLoaderPrivate * priv; + ModelXmlElement* root; +}; + +struct _ModelXmlTreeLoaderClass { + GTypeClass parent_class; + void (*finalize) (ModelXmlTreeLoader *self); +}; + + +static gpointer model_clip_fetcher_parent_class = NULL; +static gpointer model_clip_file_parent_class = NULL; +extern ValidDocument* project_documents; +extern gint project_documents_length1; +ValidDocument* project_documents = NULL; +gint project_documents_length1 = 0; +static gint _project_documents_size_ = 0; +extern gint current_document; +gint current_document = 0; +extern gboolean document_valid; +gboolean document_valid = FALSE; + +gpointer model_clip_fetcher_ref (gpointer instance); +void model_clip_fetcher_unref (gpointer instance); +GParamSpec* model_param_spec_clip_fetcher (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_clip_fetcher (GValue* value, gpointer v_object); +void model_value_take_clip_fetcher (GValue* value, gpointer v_object); +gpointer model_value_get_clip_fetcher (const GValue* value); +GType model_clip_fetcher_get_type (void); +gpointer model_clip_file_ref (gpointer instance); +void model_clip_file_unref (gpointer instance); +GParamSpec* model_param_spec_clip_file (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_clip_file (GValue* value, gpointer v_object); +void model_value_take_clip_file (GValue* value, gpointer v_object); +gpointer model_value_get_clip_file (const GValue* value); +GType model_clip_file_get_type (void); +#define MODEL_CLIP_FETCHER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcherPrivate)) +enum { + MODEL_CLIP_FETCHER_DUMMY_PROPERTY +}; +ModelClipFetcher* model_clip_fetcher_new (const char* filename); +ModelClipFetcher* model_clip_fetcher_construct (GType object_type, const char* filename); +char* model_clip_fetcher_get_filename (ModelClipFetcher* self); +static void model_clip_fetcher_finalize (ModelClipFetcher* obj); +enum { + MODEL_CLIP_FILE_DUMMY_PROPERTY +}; +ModelClipFile* model_clip_file_new (void); +ModelClipFile* model_clip_file_construct (GType object_type); +static void model_clip_file_finalize (ModelClipFile* obj); +GType valid_document_get_type (void); +ValidDocument* valid_document_dup (const ValidDocument* self); +void valid_document_free (ValidDocument* self); +void valid_document_copy (const ValidDocument* self, ValidDocument* dest); +void valid_document_destroy (ValidDocument* self); +void valid_document_init (ValidDocument *self, gboolean valid, const char* document); +GType state_change_fixture_get_type (void); +gpointer model_xml_element_ref (gpointer instance); +void model_xml_element_unref (gpointer instance); +GParamSpec* model_param_spec_xml_element (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_xml_element (GValue* value, gpointer v_object); +void model_value_take_xml_element (GValue* value, gpointer v_object); +gpointer model_value_get_xml_element (const GValue* value); +GType model_xml_element_get_type (void); +GType model_project_builder_get_type (void); +StateChangeFixture* state_change_fixture_dup (const StateChangeFixture* self); +void state_change_fixture_free (StateChangeFixture* self); +void state_change_fixture_copy (const StateChangeFixture* self, StateChangeFixture* dest); +void state_change_fixture_destroy (StateChangeFixture* self); +ModelXmlTreeLoader* model_xml_tree_loader_new (const char* document); +ModelXmlTreeLoader* model_xml_tree_loader_construct (GType object_type, const char* document); +gpointer model_xml_tree_loader_ref (gpointer instance); +void model_xml_tree_loader_unref (gpointer instance); +GParamSpec* model_param_spec_xml_tree_loader (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void model_value_set_xml_tree_loader (GValue* value, gpointer v_object); +void model_value_take_xml_tree_loader (GValue* value, gpointer v_object); +gpointer model_value_get_xml_tree_loader (const GValue* value); +GType model_xml_tree_loader_get_type (void); +ModelLoaderHandler* model_loader_handler_new (void); +ModelLoaderHandler* model_loader_handler_construct (GType object_type); +GType model_loader_handler_get_type (void); +ModelProjectBuilder* model_project_builder_new (ModelLoaderHandler* handler); +ModelProjectBuilder* model_project_builder_construct (GType object_type, ModelLoaderHandler* handler); +void state_change_fixture_buildup (void* fixture); +void state_change_fixture_teardown (void* fixture); +void on_error_occurred (const char* message); +static void _on_error_occurred_model_project_builder_error_occurred (ModelProjectBuilder* _sender, const char* _error_, gpointer self); +gboolean model_project_builder_check_project (ModelProjectBuilder* self, ModelXmlElement* root); +void model_project_builder_build_project (ModelProjectBuilder* self, ModelXmlElement* root); +void check_document (void* fixture); +static void _vala_ValidDocument_array_free (ValidDocument* array, gint array_length); +static void _state_change_fixture_buildup_gtest_func (void* fixture, gpointer self); +static void _check_document_gtest_func (void* fixture, gpointer self); +static void _state_change_fixture_teardown_gtest_func (void* fixture, gpointer self); +ProjectLoaderSuite* project_loader_suite_new (void); +ProjectLoaderSuite* project_loader_suite_new (void); + + +static void g_cclosure_user_marshal_VOID__MODEL_CLIP_FETCHER (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data); + +#line 14 "ProjectLoading.vala" +ModelClipFetcher* model_clip_fetcher_construct (GType object_type, const char* filename) { +#line 248 "ProjectLoading.c" + ModelClipFetcher* self; + char* _tmp0_; +#line 14 "ProjectLoading.vala" + g_return_val_if_fail (filename != NULL, NULL); +#line 253 "ProjectLoading.c" + self = (ModelClipFetcher*) g_type_create_instance (object_type); +#line 15 "ProjectLoading.vala" + self->priv->filename = (_tmp0_ = g_strdup (filename), _g_free0 (self->priv->filename), _tmp0_); +#line 257 "ProjectLoading.c" + return self; +} + + +#line 14 "ProjectLoading.vala" +ModelClipFetcher* model_clip_fetcher_new (const char* filename) { +#line 14 "ProjectLoading.vala" + return model_clip_fetcher_construct (MODEL_TYPE_CLIP_FETCHER, filename); +#line 266 "ProjectLoading.c" +} + + +#line 17 "ProjectLoading.vala" +char* model_clip_fetcher_get_filename (ModelClipFetcher* self) { +#line 272 "ProjectLoading.c" + char* result = NULL; +#line 17 "ProjectLoading.vala" + g_return_val_if_fail (MODEL_IS_CLIP_FETCHER (self), NULL); +#line 276 "ProjectLoading.c" + result = g_strdup (self->priv->filename); +#line 18 "ProjectLoading.vala" + return result; +#line 280 "ProjectLoading.c" +} + + +static void model_value_clip_fetcher_init (GValue* value) { + value->data[0].v_pointer = NULL; +} + + +static void model_value_clip_fetcher_free_value (GValue* value) { + if (value->data[0].v_pointer) { + model_clip_fetcher_unref (value->data[0].v_pointer); + } +} + + +static void model_value_clip_fetcher_copy_value (const GValue* src_value, GValue* dest_value) { + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = model_clip_fetcher_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + + +static gpointer model_value_clip_fetcher_peek_pointer (const GValue* value) { + return value->data[0].v_pointer; +} + + +static gchar* model_value_clip_fetcher_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + if (collect_values[0].v_pointer) { + ModelClipFetcher* object; + object = collect_values[0].v_pointer; + if (object->parent_instance.g_class == NULL) { + return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) { + return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } + value->data[0].v_pointer = model_clip_fetcher_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + + +static gchar* model_value_clip_fetcher_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + ModelClipFetcher** object_p; + object_p = collect_values[0].v_pointer; + if (!object_p) { + return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); + } + if (!value->data[0].v_pointer) { + *object_p = NULL; + } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) { + *object_p = value->data[0].v_pointer; + } else { + *object_p = model_clip_fetcher_ref (value->data[0].v_pointer); + } + return NULL; +} + + +GParamSpec* model_param_spec_clip_fetcher (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) { + ModelParamSpecClipFetcher* spec; + g_return_val_if_fail (g_type_is_a (object_type, MODEL_TYPE_CLIP_FETCHER), NULL); + spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags); + G_PARAM_SPEC (spec)->value_type = object_type; + return G_PARAM_SPEC (spec); +} + + +gpointer model_value_get_clip_fetcher (const GValue* value) { + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_CLIP_FETCHER), NULL); + return value->data[0].v_pointer; +} + + +void model_value_set_clip_fetcher (GValue* value, gpointer v_object) { + ModelClipFetcher* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_CLIP_FETCHER)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_CLIP_FETCHER)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + model_clip_fetcher_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + model_clip_fetcher_unref (old); + } +} + + +void model_value_take_clip_fetcher (GValue* value, gpointer v_object) { + ModelClipFetcher* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_CLIP_FETCHER)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_CLIP_FETCHER)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + model_clip_fetcher_unref (old); + } +} + + +static void model_clip_fetcher_class_init (ModelClipFetcherClass * klass) { + model_clip_fetcher_parent_class = g_type_class_peek_parent (klass); + MODEL_CLIP_FETCHER_CLASS (klass)->finalize = model_clip_fetcher_finalize; + g_type_class_add_private (klass, sizeof (ModelClipFetcherPrivate)); + g_signal_new ("ready", MODEL_TYPE_CLIP_FETCHER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__MODEL_CLIP_FETCHER, G_TYPE_NONE, 1, MODEL_TYPE_CLIP_FETCHER); +} + + +static void model_clip_fetcher_instance_init (ModelClipFetcher * self) { + self->priv = MODEL_CLIP_FETCHER_GET_PRIVATE (self); + self->ref_count = 1; +} + + +static void model_clip_fetcher_finalize (ModelClipFetcher* obj) { + ModelClipFetcher * self; + self = MODEL_CLIP_FETCHER (obj); + _g_free0 (self->error_string); + _model_clip_file_unref0 (self->clipfile); + _g_free0 (self->priv->filename); +} + + +GType model_clip_fetcher_get_type (void) { + static volatile gsize model_clip_fetcher_type_id__volatile = 0; + if (g_once_init_enter (&model_clip_fetcher_type_id__volatile)) { + static const GTypeValueTable g_define_type_value_table = { model_value_clip_fetcher_init, model_value_clip_fetcher_free_value, model_value_clip_fetcher_copy_value, model_value_clip_fetcher_peek_pointer, "p", model_value_clip_fetcher_collect_value, "p", model_value_clip_fetcher_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (ModelClipFetcherClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_clip_fetcher_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelClipFetcher), 0, (GInstanceInitFunc) model_clip_fetcher_instance_init, &g_define_type_value_table }; + static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) }; + GType model_clip_fetcher_type_id; + model_clip_fetcher_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ModelClipFetcher", &g_define_type_info, &g_define_type_fundamental_info, 0); + g_once_init_leave (&model_clip_fetcher_type_id__volatile, model_clip_fetcher_type_id); + } + return model_clip_fetcher_type_id__volatile; +} + + +gpointer model_clip_fetcher_ref (gpointer instance) { + ModelClipFetcher* self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + + +void model_clip_fetcher_unref (gpointer instance) { + ModelClipFetcher* self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + MODEL_CLIP_FETCHER_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + + +#line 23 "ProjectLoading.vala" +ModelClipFile* model_clip_file_construct (GType object_type) { +#line 451 "ProjectLoading.c" + ModelClipFile* self; + self = (ModelClipFile*) g_type_create_instance (object_type); + return self; +} + + +#line 23 "ProjectLoading.vala" +ModelClipFile* model_clip_file_new (void) { +#line 23 "ProjectLoading.vala" + return model_clip_file_construct (MODEL_TYPE_CLIP_FILE); +#line 462 "ProjectLoading.c" +} + + +static void model_value_clip_file_init (GValue* value) { + value->data[0].v_pointer = NULL; +} + + +static void model_value_clip_file_free_value (GValue* value) { + if (value->data[0].v_pointer) { + model_clip_file_unref (value->data[0].v_pointer); + } +} + + +static void model_value_clip_file_copy_value (const GValue* src_value, GValue* dest_value) { + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = model_clip_file_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + + +static gpointer model_value_clip_file_peek_pointer (const GValue* value) { + return value->data[0].v_pointer; +} + + +static gchar* model_value_clip_file_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + if (collect_values[0].v_pointer) { + ModelClipFile* object; + object = collect_values[0].v_pointer; + if (object->parent_instance.g_class == NULL) { + return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) { + return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } + value->data[0].v_pointer = model_clip_file_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + + +static gchar* model_value_clip_file_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + ModelClipFile** object_p; + object_p = collect_values[0].v_pointer; + if (!object_p) { + return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); + } + if (!value->data[0].v_pointer) { + *object_p = NULL; + } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) { + *object_p = value->data[0].v_pointer; + } else { + *object_p = model_clip_file_ref (value->data[0].v_pointer); + } + return NULL; +} + + +GParamSpec* model_param_spec_clip_file (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) { + ModelParamSpecClipFile* spec; + g_return_val_if_fail (g_type_is_a (object_type, MODEL_TYPE_CLIP_FILE), NULL); + spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags); + G_PARAM_SPEC (spec)->value_type = object_type; + return G_PARAM_SPEC (spec); +} + + +gpointer model_value_get_clip_file (const GValue* value) { + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_CLIP_FILE), NULL); + return value->data[0].v_pointer; +} + + +void model_value_set_clip_file (GValue* value, gpointer v_object) { + ModelClipFile* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_CLIP_FILE)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_CLIP_FILE)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + model_clip_file_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + model_clip_file_unref (old); + } +} + + +void model_value_take_clip_file (GValue* value, gpointer v_object) { + ModelClipFile* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_CLIP_FILE)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_CLIP_FILE)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + model_clip_file_unref (old); + } +} + + +static void model_clip_file_class_init (ModelClipFileClass * klass) { + model_clip_file_parent_class = g_type_class_peek_parent (klass); + MODEL_CLIP_FILE_CLASS (klass)->finalize = model_clip_file_finalize; +} + + +static void model_clip_file_instance_init (ModelClipFile * self) { + self->ref_count = 1; +} + + +static void model_clip_file_finalize (ModelClipFile* obj) { + ModelClipFile * self; + self = MODEL_CLIP_FILE (obj); + _g_free0 (self->filename); +} + + +GType model_clip_file_get_type (void) { + static volatile gsize model_clip_file_type_id__volatile = 0; + if (g_once_init_enter (&model_clip_file_type_id__volatile)) { + static const GTypeValueTable g_define_type_value_table = { model_value_clip_file_init, model_value_clip_file_free_value, model_value_clip_file_copy_value, model_value_clip_file_peek_pointer, "p", model_value_clip_file_collect_value, "p", model_value_clip_file_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (ModelClipFileClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_clip_file_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelClipFile), 0, (GInstanceInitFunc) model_clip_file_instance_init, &g_define_type_value_table }; + static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) }; + GType model_clip_file_type_id; + model_clip_file_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ModelClipFile", &g_define_type_info, &g_define_type_fundamental_info, 0); + g_once_init_leave (&model_clip_file_type_id__volatile, model_clip_file_type_id); + } + return model_clip_file_type_id__volatile; +} + + +gpointer model_clip_file_ref (gpointer instance) { + ModelClipFile* self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + + +void model_clip_file_unref (gpointer instance) { + ModelClipFile* self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + MODEL_CLIP_FILE_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + + +#line 32 "ProjectLoading.vala" +void valid_document_init (ValidDocument *self, gboolean valid, const char* document) { +#line 628 "ProjectLoading.c" + char* _tmp0_; +#line 32 "ProjectLoading.vala" + g_return_if_fail (document != NULL); +#line 632 "ProjectLoading.c" + memset (self, 0, sizeof (ValidDocument)); +#line 33 "ProjectLoading.vala" + (*self).valid = valid; +#line 34 "ProjectLoading.vala" + (*self).document = (_tmp0_ = g_strdup (document), _g_free0 ((*self).document), _tmp0_); +#line 638 "ProjectLoading.c" +} + + +void valid_document_copy (const ValidDocument* self, ValidDocument* dest) { + dest->valid = self->valid; + dest->document = g_strdup (self->document); +} + + +void valid_document_destroy (ValidDocument* self) { + _g_free0 (self->document); +} + + +ValidDocument* valid_document_dup (const ValidDocument* self) { + ValidDocument* dup; + dup = g_new0 (ValidDocument, 1); + valid_document_copy (self, dup); + return dup; +} + + +void valid_document_free (ValidDocument* self) { + valid_document_destroy (self); + g_free (self); +} + + +GType valid_document_get_type (void) { + static volatile gsize valid_document_type_id__volatile = 0; + if (g_once_init_enter (&valid_document_type_id__volatile)) { + GType valid_document_type_id; + valid_document_type_id = g_boxed_type_register_static ("ValidDocument", (GBoxedCopyFunc) valid_document_dup, (GBoxedFreeFunc) valid_document_free); + g_once_init_leave (&valid_document_type_id__volatile, valid_document_type_id); + } + return valid_document_type_id__volatile; +} + + +static gpointer _model_xml_element_ref0 (gpointer self) { + return self ? model_xml_element_ref (self) : NULL; +} + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +void state_change_fixture_copy (const StateChangeFixture* self, StateChangeFixture* dest) { + dest->root = _model_xml_element_ref0 (self->root); + dest->project_builder = _g_object_ref0 (self->project_builder); + dest->valid = self->valid; +} + + +void state_change_fixture_destroy (StateChangeFixture* self) { + _model_xml_element_unref0 (self->root); + _g_object_unref0 (self->project_builder); +} + + +StateChangeFixture* state_change_fixture_dup (const StateChangeFixture* self) { + StateChangeFixture* dup; + dup = g_new0 (StateChangeFixture, 1); + state_change_fixture_copy (self, dup); + return dup; +} + + +void state_change_fixture_free (StateChangeFixture* self) { + state_change_fixture_destroy (self); + g_free (self); +} + + +GType state_change_fixture_get_type (void) { + static volatile gsize state_change_fixture_type_id__volatile = 0; + if (g_once_init_enter (&state_change_fixture_type_id__volatile)) { + GType state_change_fixture_type_id; + state_change_fixture_type_id = g_boxed_type_register_static ("StateChangeFixture", (GBoxedCopyFunc) state_change_fixture_dup, (GBoxedFreeFunc) state_change_fixture_free); + g_once_init_leave (&state_change_fixture_type_id__volatile, state_change_fixture_type_id); + } + return state_change_fixture_type_id__volatile; +} + + +#line 49 "ProjectLoading.vala" +void state_change_fixture_buildup (void* fixture) { +#line 728 "ProjectLoading.c" + StateChangeFixture* state_change_fixture; + ModelXmlTreeLoader* tree_loader; + ModelXmlElement* _tmp0_; + ModelProjectBuilder* _tmp2_; + ModelLoaderHandler* _tmp1_; +#line 50 "ProjectLoading.vala" + state_change_fixture = (StateChangeFixture*) fixture; +#line 51 "ProjectLoading.vala" + tree_loader = model_xml_tree_loader_new (project_documents[current_document].document); +#line 52 "ProjectLoading.vala" + (*state_change_fixture).root = (_tmp0_ = _model_xml_element_ref0 (tree_loader->root), _model_xml_element_unref0 ((*state_change_fixture).root), _tmp0_); +#line 53 "ProjectLoading.vala" + (*state_change_fixture).project_builder = (_tmp2_ = model_project_builder_new (_tmp1_ = model_loader_handler_new ()), _g_object_unref0 ((*state_change_fixture).project_builder), _tmp2_); +#line 742 "ProjectLoading.c" + _g_object_unref0 (_tmp1_); +#line 54 "ProjectLoading.vala" + (*state_change_fixture).valid = project_documents[current_document].valid; +#line 55 "ProjectLoading.vala" + current_document = current_document + 1; +#line 748 "ProjectLoading.c" + _model_xml_tree_loader_unref0 (tree_loader); +} + + +#line 58 "ProjectLoading.vala" +void state_change_fixture_teardown (void* fixture) { +#line 755 "ProjectLoading.c" + StateChangeFixture* state_change_fixture; + ModelXmlElement* _tmp0_; + ModelProjectBuilder* _tmp1_; +#line 59 "ProjectLoading.vala" + state_change_fixture = (StateChangeFixture*) fixture; +#line 60 "ProjectLoading.vala" + (*state_change_fixture).root = (_tmp0_ = NULL, _model_xml_element_unref0 ((*state_change_fixture).root), _tmp0_); +#line 61 "ProjectLoading.vala" + (*state_change_fixture).project_builder = (_tmp1_ = NULL, _g_object_unref0 ((*state_change_fixture).project_builder), _tmp1_); +#line 765 "ProjectLoading.c" +} + + +#line 66 "ProjectLoading.vala" +void on_error_occurred (const char* message) { +#line 67 "ProjectLoading.vala" + g_test_message ("received error: %s", message); +#line 68 "ProjectLoading.vala" + document_valid = FALSE; +#line 775 "ProjectLoading.c" +} + + +#line 66 "ProjectLoading.vala" +static void _on_error_occurred_model_project_builder_error_occurred (ModelProjectBuilder* _sender, const char* _error_, gpointer self) { +#line 781 "ProjectLoading.c" + on_error_occurred (_error_); +} + + +#line 73 "ProjectLoading.vala" +void check_document (void* fixture) { +#line 788 "ProjectLoading.c" + StateChangeFixture* state_change_fixture; + const char* _tmp0_; + ModelXmlElement* root; + ModelProjectBuilder* project_builder; +#line 74 "ProjectLoading.vala" + state_change_fixture = (StateChangeFixture*) fixture; +#line 795 "ProjectLoading.c" + _tmp0_ = NULL; +#line 77 "ProjectLoading.vala" + if ((*state_change_fixture).valid) { +#line 77 "ProjectLoading.vala" + _tmp0_ = "valid"; +#line 801 "ProjectLoading.c" + } else { +#line 77 "ProjectLoading.vala" + _tmp0_ = "invalid"; +#line 805 "ProjectLoading.c" + } +#line 76 "ProjectLoading.vala" + g_test_message ("checking document expecting to be %s", _tmp0_); +#line 79 "ProjectLoading.vala" + root = _model_xml_element_ref0 ((*state_change_fixture).root); +#line 80 "ProjectLoading.vala" + project_builder = _g_object_ref0 ((*state_change_fixture).project_builder); +#line 82 "ProjectLoading.vala" + document_valid = TRUE; +#line 83 "ProjectLoading.vala" + g_signal_connect (project_builder, "error-occurred", (GCallback) _on_error_occurred_model_project_builder_error_occurred, NULL); +#line 87 "ProjectLoading.vala" + if (model_project_builder_check_project (project_builder, root)) { +#line 88 "ProjectLoading.vala" + model_project_builder_build_project (project_builder, root); +#line 821 "ProjectLoading.c" + } +#line 89 "ProjectLoading.vala" + g_assert (document_valid == (*state_change_fixture).valid); +#line 90 "ProjectLoading.vala" + g_test_message ("finished executing check document"); +#line 827 "ProjectLoading.c" + _model_xml_element_unref0 (root); + _g_object_unref0 (project_builder); +} + + +static void _vala_ValidDocument_array_free (ValidDocument* array, gint array_length) { + if (array != NULL) { + int i; + for (i = 0; i < array_length; i = i + 1) { + valid_document_destroy (&array[i]); + } + } + g_free (array); +} + + +#line 49 "ProjectLoading.vala" +static void _state_change_fixture_buildup_gtest_func (void* fixture, gpointer self) { +#line 846 "ProjectLoading.c" + state_change_fixture_buildup (fixture); +} + + +#line 73 "ProjectLoading.vala" +static void _check_document_gtest_func (void* fixture, gpointer self) { +#line 853 "ProjectLoading.c" + check_document (fixture); +} + + +#line 58 "ProjectLoading.vala" +static void _state_change_fixture_teardown_gtest_func (void* fixture, gpointer self) { +#line 860 "ProjectLoading.c" + state_change_fixture_teardown (fixture); +} + + +#line 95 "ProjectLoading.vala" +ProjectLoaderSuite* project_loader_suite_new (void) { +#line 867 "ProjectLoading.c" + ProjectLoaderSuite* self; + ValidDocument* _tmp37_; + ValidDocument* _tmp36_ = NULL; + ValidDocument _tmp0_ = {0}; + ValidDocument _tmp1_ = {0}; + ValidDocument _tmp2_ = {0}; + ValidDocument _tmp3_ = {0}; + ValidDocument _tmp4_ = {0}; + ValidDocument _tmp5_ = {0}; + ValidDocument _tmp6_ = {0}; + ValidDocument _tmp7_ = {0}; + ValidDocument _tmp8_ = {0}; + ValidDocument _tmp9_ = {0}; + ValidDocument _tmp10_ = {0}; + ValidDocument _tmp11_ = {0}; + ValidDocument _tmp12_ = {0}; + ValidDocument _tmp13_ = {0}; + ValidDocument _tmp14_ = {0}; + ValidDocument _tmp15_ = {0}; + ValidDocument _tmp16_ = {0}; + ValidDocument _tmp17_ = {0}; + ValidDocument _tmp18_ = {0}; + ValidDocument _tmp19_ = {0}; + ValidDocument _tmp20_ = {0}; + ValidDocument _tmp21_ = {0}; + ValidDocument _tmp22_ = {0}; + ValidDocument _tmp23_ = {0}; + ValidDocument _tmp24_ = {0}; + ValidDocument _tmp25_ = {0}; + ValidDocument _tmp26_ = {0}; + ValidDocument _tmp27_ = {0}; + ValidDocument _tmp28_ = {0}; + ValidDocument _tmp29_ = {0}; + ValidDocument _tmp30_ = {0}; + ValidDocument _tmp31_ = {0}; + ValidDocument _tmp32_ = {0}; + ValidDocument _tmp33_ = {0}; + ValidDocument _tmp34_ = {0}; + ValidDocument _tmp35_ = {0}; + gint length; +#line 96 "ProjectLoading.vala" + self = (ProjectLoaderSuite*) g_test_create_suite ("ProjectLoaderSuite"); +#line 98 "ProjectLoading.vala" + current_document = 0; +#line 99 "ProjectLoading.vala" + project_documents = (_tmp37_ = (_tmp36_ = g_new0 (ValidDocument, 36), _tmp36_[0] = (valid_document_init (&_tmp0_, TRUE, "" ""), _tmp0_), _tmp36_[1] = (valid_document_init (&_tmp1_, TRUE, "" ""), _tmp1_), _tmp36_[2] = (valid_document_init (&_tmp2_, TRUE, "" ""), _tmp2_), _tmp36_[3] = (valid_document_init (&_tmp3_, TRUE, "" ""), _tmp3_), _tmp36_[4] = (valid_document_init (&_tmp4_, TRUE, "" ""), _tmp4_), _tmp36_[5] = (valid_document_init (&_tmp5_, TRUE, "" ""), _tmp5_), _tmp36_[6] = (valid_document_init (&_tmp6_, TRUE, "" ""), _tmp6_), _tmp36_[7] = (valid_document_init (&_tmp7_, TRUE, "" ""), _tmp7_), _tmp36_[8] = (valid_document_init (&_tmp8_, TRUE, ""), _tmp8_), _tmp36_[9] = (valid_document_init (&_tmp9_, TRUE, "" ""), _tmp9_), _tmp36_[10] = (valid_document_init (&_tmp10_, TRUE, "" ""), _tmp10_), _tmp36_[11] = (valid_document_init (&_tmp11_, TRUE, "" ""), _tmp11_), _tmp36_[12] = (valid_document_init (&_tmp12_, FALSE, ""), _tmp12_), _tmp36_[13] = (valid_document_init (&_tmp13_, FALSE, ""), _tmp13_), _tmp36_[14] = (valid_document_init (&_tmp14_, FALSE, "" ""), _tmp14_), _tmp36_[15] = (valid_document_init (&_tmp15_, FALSE, ""), _tmp15_), _tmp36_[16] = (valid_document_init (&_tmp16_, FALSE, ""), _tmp16_), _tmp36_[17] = (valid_document_init (&_tmp17_, FALSE, ""), _tmp17_), _tmp36_[18] = (valid_document_init (&_tmp18_, FALSE, ""), _tmp18_), _tmp36_[19] = (valid_document_init (&_tmp19_, FALSE, ""), _tmp19_), _tmp36_[20] = (valid_document_init (&_tmp20_, FALSE, ""), _tmp20_), _tmp36_[21] = (valid_document_init (&_tmp21_, FALSE, ""), _tmp21_), _tmp36_[22] = (valid_document_init (&_tmp22_, FALSE, ""), _tmp22_), _tmp36_[23] = (valid_document_init (&_tmp23_, FALSE, ""), _tmp23_), _tmp36_[24] = (valid_document_init (&_tmp24_, FALSE, ""), _tmp24_), _tmp36_[25] = (valid_document_init (&_tmp25_, FALSE, ""), _tmp25_), _tmp36_[26] = (valid_document_init (&_tmp26_, FALSE, ""), _tmp26_), _tmp36_[27] = (valid_document_init (&_tmp27_, FALSE, ""), _tmp27_), _tmp36_[28] = (valid_document_init (&_tmp28_, FALSE, ""), _tmp28_), _tmp36_[29] = (valid_document_init (&_tmp29_, FALSE, ""), _tmp29_), _tmp36_[30] = (valid_document_init (&_tmp30_, FALSE, ""), _tmp30_), _tmp36_[31] = (valid_document_init (&_tmp31_, FALSE, ""), _tmp31_), _tmp36_[32] = (valid_document_init (&_tmp32_, FALSE, "" ""), _tmp32_), _tmp36_[33] = (valid_document_init (&_tmp33_, FALSE, ""), _tmp33_), _tmp36_[34] = (valid_document_init (&_tmp34_, FALSE, "" ""), _tmp34_), _tmp36_[35] = (valid_document_init (&_tmp35_, FALSE, ""), _tmp35_), _tmp36_), project_documents = (_vala_ValidDocument_array_free (project_documents, project_documents_length1), NULL), project_documents_length1 = 36, _project_documents_size_ = project_documents_length1, _tmp37_); +#line 152 "ProjectLoading.vala" + length = project_documents_length1; +#line 916 "ProjectLoading.c" + { + gint i; +#line 154 "ProjectLoading.vala" + i = 0; +#line 921 "ProjectLoading.c" + { + gboolean _tmp38_; +#line 154 "ProjectLoading.vala" + _tmp38_ = TRUE; +#line 154 "ProjectLoading.vala" + while (TRUE) { +#line 928 "ProjectLoading.c" + gboolean _tmp39_ = FALSE; +#line 154 "ProjectLoading.vala" + if (!_tmp38_) { +#line 154 "ProjectLoading.vala" + i = i + 1; +#line 934 "ProjectLoading.c" + } +#line 154 "ProjectLoading.vala" + _tmp38_ = FALSE; +#line 154 "ProjectLoading.vala" + if (!(i < length)) { +#line 154 "ProjectLoading.vala" + break; +#line 942 "ProjectLoading.c" + } +#line 155 "ProjectLoading.vala" + if (g_test_thorough ()) { +#line 155 "ProjectLoading.vala" + _tmp39_ = TRUE; +#line 948 "ProjectLoading.c" + } else { +#line 155 "ProjectLoading.vala" + _tmp39_ = project_documents[i].valid; +#line 952 "ProjectLoading.c" + } +#line 155 "ProjectLoading.vala" + if (_tmp39_) { +#line 956 "ProjectLoading.c" + char* _tmp40_; +#line 156 "ProjectLoading.vala" + g_test_suite_add ((GTestSuite*) self, g_test_create_case (_tmp40_ = g_strdup_printf ("Document%d", i), (gsize) sizeof (StateChangeFixture), NULL, (void (*) (void)) _state_change_fixture_buildup_gtest_func, (void (*) (void)) _check_document_gtest_func, (void (*) (void)) _state_change_fixture_teardown_gtest_func)); +#line 960 "ProjectLoading.c" + _g_free0 (_tmp40_); + } + } + } + } + return self; +} + + + +static void g_cclosure_user_marshal_VOID__MODEL_CLIP_FETCHER (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) { + typedef void (*GMarshalFunc_VOID__MODEL_CLIP_FETCHER) (gpointer data1, gpointer arg_1, gpointer data2); + register GMarshalFunc_VOID__MODEL_CLIP_FETCHER callback; + register GCClosure * cc; + register gpointer data1, data2; + cc = (GCClosure *) closure; + g_return_if_fail (n_param_values == 2); + if (G_CCLOSURE_SWAP_DATA (closure)) { + data1 = closure->data; + data2 = param_values->data[0].v_pointer; + } else { + data1 = param_values->data[0].v_pointer; + data2 = closure->data; + } + callback = (GMarshalFunc_VOID__MODEL_CLIP_FETCHER) (marshal_data ? marshal_data : cc->callback); + callback (data1, model_value_get_clip_fetcher (param_values + 1), data2); +} + + + diff --git a/src/test/debug/ProjectLoading.o b/src/test/debug/ProjectLoading.o new file mode 100644 index 0000000..996ed4b Binary files /dev/null and b/src/test/debug/ProjectLoading.o differ diff --git a/src/test/debug/test.c b/src/test/debug/test.c new file mode 100644 index 0000000..4844d0d --- /dev/null +++ b/src/test/debug/test.c @@ -0,0 +1,52 @@ +/* test.c generated by valac, the Vala compiler + * generated from test.vala, do not modify */ + +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include + +typedef GTestSuite ProjectLoaderSuite; + + + +ProjectLoaderSuite* project_loader_suite_new (void); +ProjectLoaderSuite* project_loader_suite_new (void); +void _vala_main (char** args, int args_length1); + + + +#line 8 "test.vala" +void _vala_main (char** args, int args_length1) { +#line 9 "test.vala" + g_test_init (&args_length1, &args, NULL); +#line 10 "test.vala" + g_test_suite_add_suite (g_test_get_root (), (GTestSuite*) project_loader_suite_new ()); +#line 11 "test.vala" + g_test_run (); +#line 34 "test.c" +} + + +#line 8 "test.vala" +int main (int argc, char ** argv) { +#line 40 "test.c" + g_thread_init (NULL); +#line 8 "test.vala" + g_type_init (); +#line 8 "test.vala" + _vala_main (argv, argc); +#line 8 "test.vala" + return 0; +#line 48 "test.c" +} + + + + diff --git a/src/test/debug/test.o b/src/test/debug/test.o new file mode 100644 index 0000000..84f1d0e Binary files /dev/null and b/src/test/debug/test.o differ diff --git a/src/test/debug/util.c b/src/test/debug/util.c new file mode 100644 index 0000000..d270645 --- /dev/null +++ b/src/test/debug/util.c @@ -0,0 +1,1673 @@ +/* util.c generated by valac, the Vala compiler + * generated from util.vala, do not modify */ + +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define _g_free0(var) (var = (g_free (var), NULL)) + +#define TYPE_FRACTION (fraction_get_type ()) +typedef struct _Fraction Fraction; + +#define TYPE_TIME_CODE (time_code_get_type ()) +typedef struct _TimeCode TimeCode; +#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL))) +#define _g_checksum_free0(var) ((var == NULL) ? NULL : (var = (g_checksum_free (var), NULL))) +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +#define _cairo_destroy0(var) ((var == NULL) ? NULL : (var = (cairo_destroy (var), NULL))) +#define _gst_object_unref0(var) ((var == NULL) ? NULL : (var = (gst_object_unref (var), NULL))) + +typedef enum { + MEDIA_ERROR_MISSING_PLUGIN +} MediaError; +#define MEDIA_ERROR media_error_quark () +struct _Fraction { + gint numerator; + gint denominator; +}; + +struct _TimeCode { + gint hour; + gint minute; + gint second; + gint frame; + gboolean drop_code; +}; + +typedef enum { + GDK_Control_L, + GDK_Control_R, + GDK_Down, + GDK_equal, + GDK_Escape, + GDK_KP_Add, + GDK_KP_Enter, + GDK_KP_Subtract, + GDK_Left, + GDK_minus, + GDK_plus, + GDK_Return, + GDK_Right, + GDK_Shift_L, + GDK_Shift_R, + GDK_underscore, + GDK_Up +} KeySyms; + + +extern gboolean debug_enabled; +gboolean debug_enabled = FALSE; +extern GdkModifierType GDK_SHIFT_ALT_CONTROL_MASK; +GdkModifierType GDK_SHIFT_ALT_CONTROL_MASK = (GDK_SHIFT_MASK | GDK_MOD1_MASK) | GDK_CONTROL_MASK; + +GQuark media_error_quark (void); +float float_abs (float f); +gboolean float_within (double f, double epsilon); +gint sign (gint x); +gint stricmp (const char* str1, const char* str2); +char** copy_array (char** source, int source_length1, int* result_length1); +void print_debug (const char* text); +GType fraction_get_type (void); +Fraction* fraction_dup (const Fraction* self); +void fraction_free (Fraction* self); +void fraction_init (Fraction *self, gint numerator, gint denominator); +void fraction_init_from_string (Fraction *self, const char* s); +gboolean fraction_equal (Fraction *self, Fraction* f); +gint fraction_nearest_int (Fraction *self); +char* fraction_to_string (Fraction *self); +GType time_code_get_type (void); +TimeCode* time_code_dup (const TimeCode* self); +void time_code_free (TimeCode* self); +void time_code_get_from_length (TimeCode *self, gint64 length); +char* time_code_to_string (TimeCode *self); +gboolean time_in_range (gint64 time, gint64 center, gint64 delta); +char* isolate_filename (const char* path); +char* get_file_extension (const char* path); +char* append_extension (const char* path, const char* extension); +gboolean version_at_least (const char* v, const char* w); +gboolean get_file_md5_checksum (const char* filename, char** checksum); +void save_file_md5_checksum (const char* filename, const char* checksum); +gboolean md5_checksum_on_file (const char* filename, char** checksum); +void parse_color (const char* color, GdkColor* result); +GtkWidget* get_widget (GtkUIManager* manager, const char* name); +#define LINE_WIDTH 1.0 +#define RADIUS 15.0 +#define ANTIALIAS CAIRO_ANTIALIAS_DEFAULT +void draw_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height); +void draw_right_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height); +void draw_left_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height); +void draw_square_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x, gint y, gint width, gint height); +gboolean is_drop_frame_rate (Fraction* r); +gint64 frame_to_time_with_rate (gint frame, Fraction* rate); +gint time_to_frame_with_rate (gint64 time, Fraction* rate); +void frame_to_time (gint frame, Fraction* rate, TimeCode* result); +char* frame_to_string (gint frame, Fraction* rate); +void breakup_time (gint64 time, gint* hours, gint* minutes, double* seconds); +char* time_to_HHMMSS (gint64 time); +char* time_to_string (gint64 time); +GstElement* make_element_with_name (const char* element_name, const char* display_name, GError** error); +GstElement* make_element (const char* name, GError** error); +static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func); +static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func); +static gint _vala_array_length (gpointer array); +static int _vala_strcmp0 (const char * str1, const char * str2); + +const GtkTargetEntry drag_target_entries[1] = {{"text/uri-list", (guint) 0, (guint) 0}}; + + +GQuark media_error_quark (void) { + return g_quark_from_static_string ("media_error-quark"); +} + + +#line 12 "util.vala" +float float_abs (float f) { +#line 141 "util.c" + float result = 0.0F; +#line 13 "util.vala" + if (f < 0.0f) { +#line 145 "util.c" + result = -f; +#line 14 "util.vala" + return result; +#line 149 "util.c" + } + result = f; +#line 15 "util.vala" + return result; +#line 154 "util.c" +} + + +#line 18 "util.vala" +gboolean float_within (double f, double epsilon) { +#line 160 "util.c" + gboolean result = FALSE; + result = float_abs ((float) f) < epsilon; +#line 19 "util.vala" + return result; +#line 165 "util.c" +} + + +#line 22 "util.vala" +gint sign (gint x) { +#line 171 "util.c" + gint result = 0; + gint _tmp0_ = 0; +#line 23 "util.vala" + if (x == 0) { +#line 176 "util.c" + result = 0; +#line 24 "util.vala" + return result; +#line 180 "util.c" + } +#line 25 "util.vala" + if (x < 0) { +#line 25 "util.vala" + _tmp0_ = -1; +#line 186 "util.c" + } else { +#line 25 "util.vala" + _tmp0_ = 1; +#line 190 "util.c" + } + result = _tmp0_; +#line 25 "util.vala" + return result; +#line 195 "util.c" +} + + +#line 28 "util.vala" +gint stricmp (const char* str1, const char* str2) { +#line 201 "util.c" + gint result = 0; + char* temp_str1; + char* temp_str2; +#line 28 "util.vala" + g_return_val_if_fail (str1 != NULL, 0); +#line 28 "util.vala" + g_return_val_if_fail (str2 != NULL, 0); +#line 29 "util.vala" + temp_str1 = g_utf8_casefold (str1, (gssize) (-1)); +#line 30 "util.vala" + temp_str2 = g_utf8_casefold (str2, (gssize) (-1)); +#line 213 "util.c" + result = g_utf8_collate (temp_str1, temp_str2); + _g_free0 (temp_str1); + _g_free0 (temp_str2); +#line 32 "util.vala" + return result; +#line 219 "util.c" +} + + +#line 36 "util.vala" +char** copy_array (char** source, int source_length1, int* result_length1) { +#line 225 "util.c" + char** result = NULL; + char** _tmp0_; + gint _destination_size_; + gint destination_length1; + char** destination; + gint i; + char** _tmp2_; + destination = (_tmp0_ = g_new0 (char*, source_length1 + 1), destination_length1 = source_length1, _destination_size_ = destination_length1, _tmp0_); +#line 38 "util.vala" + i = 0; +#line 236 "util.c" + { + char** item_collection; + int item_collection_length1; + int item_it; +#line 39 "util.vala" + item_collection = source; +#line 243 "util.c" + item_collection_length1 = source_length1; + for (item_it = 0; item_it < source_length1; item_it = item_it + 1) { + char* item; + item = g_strdup (item_collection[item_it]); + { + char* _tmp1_; +#line 40 "util.vala" + destination[i] = (_tmp1_ = g_strdup (item), _g_free0 (destination[i]), _tmp1_); +#line 41 "util.vala" + i = i + 1; +#line 254 "util.c" + _g_free0 (item); + } + } + } + result = (_tmp2_ = destination, *result_length1 = destination_length1, _tmp2_); +#line 43 "util.vala" + return result; +#line 262 "util.c" + destination = (_vala_array_free (destination, destination_length1, (GDestroyNotify) g_free), NULL); +} + + +#line 50 "util.vala" +void print_debug (const char* text) { +#line 50 "util.vala" + g_return_if_fail (text != NULL); +#line 51 "util.vala" + if (!debug_enabled) { +#line 52 "util.vala" + return; +#line 275 "util.c" + } +#line 54 "util.vala" + g_debug ("util.vala:54: %s", text); +#line 279 "util.c" +} + + +#line 61 "util.vala" +void fraction_init (Fraction *self, gint numerator, gint denominator) { +#line 285 "util.c" + memset (self, 0, sizeof (Fraction)); +#line 62 "util.vala" + (*self).numerator = numerator; +#line 63 "util.vala" + (*self).denominator = denominator; +#line 291 "util.c" +} + + +#line 66 "util.vala" +void fraction_init_from_string (Fraction *self, const char* s) { +#line 297 "util.c" + char** _tmp1_; + gint _elements_size_; + gint elements_length1; + char** _tmp0_; + char** elements; +#line 66 "util.vala" + g_return_if_fail (s != NULL); +#line 305 "util.c" + memset (self, 0, sizeof (Fraction)); + elements = (_tmp1_ = _tmp0_ = g_strsplit (s, "/", 0), elements_length1 = _vala_array_length (_tmp0_), _elements_size_ = elements_length1, _tmp1_); +#line 68 "util.vala" + if (elements_length1 != 2) { +#line 69 "util.vala" + (*self).numerator = 0; +#line 70 "util.vala" + (*self).denominator = 0; +#line 314 "util.c" + } else { +#line 72 "util.vala" + (*self).numerator = atoi (elements[0]); +#line 73 "util.vala" + (*self).denominator = atoi (elements[1]); +#line 320 "util.c" + } + elements = (_vala_array_free (elements, elements_length1, (GDestroyNotify) g_free), NULL); +} + + +#line 77 "util.vala" +gboolean fraction_equal (Fraction *self, Fraction* f) { +#line 328 "util.c" + gboolean result = FALSE; +#line 78 "util.vala" + if (float_abs (((*self).numerator / ((float) (*self).denominator)) - ((*f).numerator / ((float) (*f).denominator))) <= (1000.0f / 1001.0f)) { +#line 332 "util.c" + result = TRUE; +#line 80 "util.vala" + return result; +#line 336 "util.c" + } + result = FALSE; +#line 81 "util.vala" + return result; +#line 341 "util.c" +} + + +#line 84 "util.vala" +gint fraction_nearest_int (Fraction *self) { +#line 347 "util.c" + gint result = 0; + result = (gint) ((((double) (*self).numerator) / (*self).denominator) + 0.5); +#line 85 "util.vala" + return result; +#line 352 "util.c" +} + + +#line 88 "util.vala" +char* fraction_to_string (Fraction *self) { +#line 358 "util.c" + char* result = NULL; + result = g_strdup_printf ("%d/%d", (*self).numerator, (*self).denominator); +#line 89 "util.vala" + return result; +#line 363 "util.c" +} + + +Fraction* fraction_dup (const Fraction* self) { + Fraction* dup; + dup = g_new0 (Fraction, 1); + memcpy (dup, self, sizeof (Fraction)); + return dup; +} + + +void fraction_free (Fraction* self) { + g_free (self); +} + + +GType fraction_get_type (void) { + static volatile gsize fraction_type_id__volatile = 0; + if (g_once_init_enter (&fraction_type_id__volatile)) { + GType fraction_type_id; + fraction_type_id = g_boxed_type_register_static ("Fraction", (GBoxedCopyFunc) fraction_dup, (GBoxedFreeFunc) fraction_free); + g_once_init_leave (&fraction_type_id__volatile, fraction_type_id); + } + return fraction_type_id__volatile; +} + + +#line 101 "util.vala" +void time_code_get_from_length (TimeCode *self, gint64 length) { +#line 102 "util.vala" + length = length / ((gint64) GST_SECOND); +#line 104 "util.vala" + (*self).hour = (gint) (length / 3600); +#line 105 "util.vala" + (*self).minute = (gint) ((length % 3600) / 60); +#line 106 "util.vala" + (*self).second = (gint) ((length % 3600) % 60); +#line 107 "util.vala" + (*self).frame = 0; +#line 403 "util.c" +} + + +#line 110 "util.vala" +char* time_code_to_string (TimeCode *self) { +#line 409 "util.c" + char* result = NULL; + char* ret; + char* _tmp3_; + char* _tmp2_; + char* _tmp5_; + char* _tmp4_; + char* _tmp9_; + char* _tmp8_; +#line 111 "util.vala" + ret = g_strdup (""); +#line 112 "util.vala" + if ((*self).hour != 0) { +#line 422 "util.c" + char* _tmp1_; + char* _tmp0_; +#line 113 "util.vala" + ret = (_tmp1_ = g_strconcat (ret, _tmp0_ = g_strdup_printf ("%.2d:", (*self).hour), NULL), _g_free0 (ret), _tmp1_); +#line 427 "util.c" + _g_free0 (_tmp0_); + } +#line 115 "util.vala" + ret = (_tmp3_ = g_strconcat (ret, _tmp2_ = g_strdup_printf ("%.2d:", (*self).minute), NULL), _g_free0 (ret), _tmp3_); +#line 432 "util.c" + _g_free0 (_tmp2_); +#line 116 "util.vala" + ret = (_tmp5_ = g_strconcat (ret, _tmp4_ = g_strdup_printf ("%.2d", (*self).second), NULL), _g_free0 (ret), _tmp5_); +#line 436 "util.c" + _g_free0 (_tmp4_); +#line 118 "util.vala" + if ((*self).drop_code) { +#line 440 "util.c" + char* _tmp6_; +#line 119 "util.vala" + ret = (_tmp6_ = g_strconcat (ret, ";", NULL), _g_free0 (ret), _tmp6_); +#line 444 "util.c" + } else { + char* _tmp7_; +#line 121 "util.vala" + ret = (_tmp7_ = g_strconcat (ret, ":", NULL), _g_free0 (ret), _tmp7_); +#line 449 "util.c" + } +#line 122 "util.vala" + ret = (_tmp9_ = g_strconcat (ret, _tmp8_ = g_strdup_printf ("%.2d", (*self).frame), NULL), _g_free0 (ret), _tmp9_); +#line 453 "util.c" + _g_free0 (_tmp8_); + result = ret; +#line 124 "util.vala" + return result; +#line 458 "util.c" +} + + +TimeCode* time_code_dup (const TimeCode* self) { + TimeCode* dup; + dup = g_new0 (TimeCode, 1); + memcpy (dup, self, sizeof (TimeCode)); + return dup; +} + + +void time_code_free (TimeCode* self) { + g_free (self); +} + + +GType time_code_get_type (void) { + static volatile gsize time_code_type_id__volatile = 0; + if (g_once_init_enter (&time_code_type_id__volatile)) { + GType time_code_type_id; + time_code_type_id = g_boxed_type_register_static ("TimeCode", (GBoxedCopyFunc) time_code_dup, (GBoxedFreeFunc) time_code_free); + g_once_init_leave (&time_code_type_id__volatile, time_code_type_id); + } + return time_code_type_id__volatile; +} + + +#line 128 "util.vala" +gboolean time_in_range (gint64 time, gint64 center, gint64 delta) { +#line 488 "util.c" + gboolean result = FALSE; + gint64 diff; +#line 129 "util.vala" + diff = time - center; +#line 493 "util.c" + result = llabs (diff) <= delta; +#line 130 "util.vala" + return result; +#line 497 "util.c" +} + + +#line 133 "util.vala" +char* isolate_filename (const char* path) { +#line 503 "util.c" + char* result = NULL; + char* str; + gint _tmp1__length1; + char** _tmp1_; + char** _tmp0_; + char* _tmp2_; +#line 133 "util.vala" + g_return_val_if_fail (path != NULL, NULL); +#line 134 "util.vala" + str = g_path_get_basename (path); +#line 514 "util.c" + result = (_tmp2_ = g_strdup ((_tmp1_ = _tmp0_ = g_strsplit (str, ".", 0), _tmp1__length1 = _vala_array_length (_tmp0_), _tmp1_)[0]), _tmp1_ = (_vala_array_free (_tmp1_, _tmp1__length1, (GDestroyNotify) g_free), NULL), _tmp2_); + _g_free0 (str); +#line 135 "util.vala" + return result; +#line 519 "util.c" + _g_free0 (str); +} + + +#line 138 "util.vala" +char* get_file_extension (const char* path) { +#line 526 "util.c" + char* result = NULL; + const char* dot; + const char* _tmp0_; +#line 138 "util.vala" + g_return_val_if_fail (path != NULL, NULL); +#line 139 "util.vala" + dot = g_utf8_strrchr (path, (gssize) (-1), (gunichar) '.'); +#line 534 "util.c" + _tmp0_ = NULL; +#line 140 "util.vala" + if (dot == NULL) { +#line 140 "util.vala" + _tmp0_ = ""; +#line 540 "util.c" + } else { +#line 140 "util.vala" + _tmp0_ = g_utf8_next_char (dot); +#line 544 "util.c" + } + result = g_strdup (_tmp0_); +#line 140 "util.vala" + return result; +#line 549 "util.c" +} + + +#line 143 "util.vala" +char* append_extension (const char* path, const char* extension) { +#line 555 "util.c" + char* result = NULL; + char* _tmp0_; + gboolean _tmp1_; + char* _tmp2_; + char* _tmp3_; +#line 143 "util.vala" + g_return_val_if_fail (path != NULL, NULL); +#line 143 "util.vala" + g_return_val_if_fail (extension != NULL, NULL); +#line 144 "util.vala" + if ((_tmp1_ = _vala_strcmp0 (_tmp0_ = get_file_extension (path), extension) == 0, _g_free0 (_tmp0_), _tmp1_)) { +#line 567 "util.c" + result = g_strdup (path); +#line 145 "util.vala" + return result; +#line 571 "util.c" + } + result = (_tmp3_ = g_strconcat (_tmp2_ = g_strconcat (path, ".", NULL), extension, NULL), _g_free0 (_tmp2_), _tmp3_); +#line 147 "util.vala" + return result; +#line 576 "util.c" +} + + +#line 152 "util.vala" +gboolean version_at_least (const char* v, const char* w) { +#line 582 "util.c" + gboolean result = FALSE; + char** _tmp1_; + gint _va_size_; + gint va_length1; + char** _tmp0_; + char** va; + char** _tmp3_; + gint _wa_size_; + gint wa_length1; + char** _tmp2_; + char** wa; +#line 152 "util.vala" + g_return_val_if_fail (v != NULL, FALSE); +#line 152 "util.vala" + g_return_val_if_fail (w != NULL, FALSE); +#line 598 "util.c" + va = (_tmp1_ = _tmp0_ = g_strsplit (v, ".", 0), va_length1 = _vala_array_length (_tmp0_), _va_size_ = va_length1, _tmp1_); + wa = (_tmp3_ = _tmp2_ = g_strsplit (w, ".", 0), wa_length1 = _vala_array_length (_tmp2_), _wa_size_ = wa_length1, _tmp3_); + { + gint i; +#line 155 "util.vala" + i = 0; +#line 605 "util.c" + { + gboolean _tmp4_; +#line 155 "util.vala" + _tmp4_ = TRUE; +#line 155 "util.vala" + while (TRUE) { +#line 612 "util.c" + gint vi; + gint wi; +#line 155 "util.vala" + if (!_tmp4_) { +#line 155 "util.vala" + i = i + 1; +#line 619 "util.c" + } +#line 155 "util.vala" + _tmp4_ = FALSE; +#line 155 "util.vala" + if (!(i < wa_length1)) { +#line 155 "util.vala" + break; +#line 627 "util.c" + } +#line 156 "util.vala" + if (i >= va_length1) { +#line 631 "util.c" + result = FALSE; + va = (_vala_array_free (va, va_length1, (GDestroyNotify) g_free), NULL); + wa = (_vala_array_free (wa, wa_length1, (GDestroyNotify) g_free), NULL); +#line 157 "util.vala" + return result; +#line 637 "util.c" + } +#line 158 "util.vala" + vi = atoi (va[i]); +#line 159 "util.vala" + wi = atoi (wa[i]); +#line 160 "util.vala" + if (vi > wi) { +#line 645 "util.c" + result = TRUE; + va = (_vala_array_free (va, va_length1, (GDestroyNotify) g_free), NULL); + wa = (_vala_array_free (wa, wa_length1, (GDestroyNotify) g_free), NULL); +#line 161 "util.vala" + return result; +#line 651 "util.c" + } +#line 162 "util.vala" + if (wi > vi) { +#line 655 "util.c" + result = FALSE; + va = (_vala_array_free (va, va_length1, (GDestroyNotify) g_free), NULL); + wa = (_vala_array_free (wa, wa_length1, (GDestroyNotify) g_free), NULL); +#line 163 "util.vala" + return result; +#line 661 "util.c" + } + } + } + } + result = TRUE; + va = (_vala_array_free (va, va_length1, (GDestroyNotify) g_free), NULL); + wa = (_vala_array_free (wa, wa_length1, (GDestroyNotify) g_free), NULL); +#line 165 "util.vala" + return result; +#line 671 "util.c" +} + + +#line 168 "util.vala" +gboolean get_file_md5_checksum (const char* filename, char** checksum) { +#line 677 "util.c" + gboolean result = FALSE; + GError * _inner_error_; + char* new_filename; + gsize buffer_length = 0UL; +#line 168 "util.vala" + g_return_val_if_fail (filename != NULL, FALSE); +#line 684 "util.c" + if (checksum != NULL) { + *checksum = NULL; + } + _inner_error_ = NULL; +#line 169 "util.vala" + new_filename = append_extension (filename, "md5"); +#line 691 "util.c" + { + char* _tmp1_; + char* _tmp0_ = NULL; +#line 173 "util.vala" + g_file_get_contents (new_filename, &_tmp0_, &buffer_length, &_inner_error_); +#line 173 "util.vala" + *checksum = (_tmp1_ = _tmp0_, _g_free0 (*checksum), _tmp1_); +#line 699 "util.c" + if (_inner_error_ != NULL) { + if (_inner_error_->domain == G_FILE_ERROR) { + goto __catch2_g_file_error; + } + _g_free0 (new_filename); + g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return FALSE; + } + } + goto __finally2; + __catch2_g_file_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { + result = FALSE; + _g_error_free0 (e); + _g_free0 (new_filename); +#line 175 "util.vala" + return result; +#line 722 "util.c" + } + } + __finally2: + if (_inner_error_ != NULL) { + _g_free0 (new_filename); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return FALSE; + } + result = buffer_length == 32; + _g_free0 (new_filename); +#line 178 "util.vala" + return result; +#line 736 "util.c" +} + + +#line 181 "util.vala" +void save_file_md5_checksum (const char* filename, const char* checksum) { +#line 742 "util.c" + GError * _inner_error_; + char* new_filename; +#line 181 "util.vala" + g_return_if_fail (filename != NULL); +#line 181 "util.vala" + g_return_if_fail (checksum != NULL); +#line 749 "util.c" + _inner_error_ = NULL; +#line 182 "util.vala" + new_filename = append_extension (filename, "md5"); +#line 753 "util.c" + { +#line 185 "util.vala" + g_file_set_contents (new_filename, checksum, -1, &_inner_error_); +#line 757 "util.c" + if (_inner_error_ != NULL) { + if (_inner_error_->domain == G_FILE_ERROR) { + goto __catch3_g_file_error; + } + _g_free0 (new_filename); + g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } + } + goto __finally3; + __catch3_g_file_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { +#line 187 "util.vala" + g_error ("util.vala:187: Cannot save md5 file %s!\n", new_filename); +#line 777 "util.c" + _g_error_free0 (e); + } + } + __finally3: + if (_inner_error_ != NULL) { + _g_free0 (new_filename); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return; + } + _g_free0 (new_filename); +} + + +#line 191 "util.vala" +gboolean md5_checksum_on_file (const char* filename, char** checksum) { +#line 794 "util.c" + gboolean result = FALSE; + GError * _inner_error_; + char* file_buffer; + gsize len = 0UL; + GChecksum* c; + char* _tmp2_; +#line 191 "util.vala" + g_return_val_if_fail (filename != NULL, FALSE); +#line 803 "util.c" + if (checksum != NULL) { + *checksum = NULL; + } + _inner_error_ = NULL; + file_buffer = NULL; + { + char* _tmp1_; + char* _tmp0_ = NULL; +#line 196 "util.vala" + g_file_get_contents (filename, &_tmp0_, &len, &_inner_error_); +#line 196 "util.vala" + file_buffer = (_tmp1_ = _tmp0_, _g_free0 (file_buffer), _tmp1_); +#line 816 "util.c" + if (_inner_error_ != NULL) { + if (_inner_error_->domain == G_FILE_ERROR) { + goto __catch4_g_file_error; + } + _g_free0 (file_buffer); + g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return FALSE; + } + } + goto __finally4; + __catch4_g_file_error: + { + GError * e; + e = _inner_error_; + _inner_error_ = NULL; + { + result = FALSE; + _g_error_free0 (e); + _g_free0 (file_buffer); +#line 198 "util.vala" + return result; +#line 839 "util.c" + } + } + __finally4: + if (_inner_error_ != NULL) { + _g_free0 (file_buffer); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); + g_clear_error (&_inner_error_); + return FALSE; + } +#line 201 "util.vala" + c = g_checksum_new (G_CHECKSUM_MD5); +#line 202 "util.vala" + g_checksum_update (c, (guchar*) file_buffer, len); +#line 203 "util.vala" + *checksum = (_tmp2_ = g_strdup (g_checksum_get_string (c)), _g_free0 (*checksum), _tmp2_); +#line 855 "util.c" + result = TRUE; + _g_free0 (file_buffer); + _g_checksum_free0 (c); +#line 204 "util.vala" + return result; +#line 861 "util.c" +} + + +#line 239 "util.vala" +void parse_color (const char* color, GdkColor* result) { +#line 867 "util.c" + GdkColor c = {0}; +#line 239 "util.vala" + g_return_if_fail (color != NULL); +#line 241 "util.vala" + if (!gdk_color_parse (color, &c)) { +#line 242 "util.vala" + g_error ("util.vala:242: can't parse color"); +#line 875 "util.c" + } + *result = c; +#line 243 "util.vala" + return; +#line 880 "util.c" +} + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 246 "util.vala" +GtkWidget* get_widget (GtkUIManager* manager, const char* name) { +#line 891 "util.c" + GtkWidget* result = NULL; + GtkWidget* widget; +#line 246 "util.vala" + g_return_val_if_fail (GTK_IS_UI_MANAGER (manager), NULL); +#line 246 "util.vala" + g_return_val_if_fail (name != NULL, NULL); +#line 247 "util.vala" + widget = _g_object_ref0 (gtk_ui_manager_get_widget (manager, name)); +#line 248 "util.vala" + if (widget == NULL) { +#line 249 "util.vala" + g_error ("util.vala:249: can't find widget"); +#line 904 "util.c" + } + result = widget; +#line 250 "util.vala" + return result; +#line 909 "util.c" +} + + +#line 262 "util.vala" +void draw_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height) { +#line 915 "util.c" + gboolean _tmp0_ = FALSE; + double x1; + double y1; + cairo_t* cairo_window; +#line 262 "util.vala" + g_return_if_fail (GDK_IS_WINDOW (window)); +#line 264 "util.vala" + if (width == 0) { +#line 264 "util.vala" + _tmp0_ = TRUE; +#line 926 "util.c" + } else { +#line 264 "util.vala" + _tmp0_ = height == 0; +#line 930 "util.c" + } +#line 264 "util.vala" + if (_tmp0_) { +#line 265 "util.vala" + return; +#line 936 "util.c" + } +#line 267 "util.vala" + x1 = (double) (x0 + width); +#line 268 "util.vala" + y1 = (double) (y0 + height); +#line 270 "util.vala" + cairo_window = gdk_cairo_create (GDK_DRAWABLE (window)); +#line 271 "util.vala" + gdk_cairo_set_source_color (cairo_window, color); +#line 272 "util.vala" + cairo_set_antialias (cairo_window, ANTIALIAS); +#line 274 "util.vala" + if ((width / 2) < RADIUS) { +#line 275 "util.vala" + if ((height / 2) < RADIUS) { +#line 276 "util.vala" + cairo_move_to (cairo_window, (double) x0, (y0 + y1) / 2); +#line 277 "util.vala" + cairo_curve_to (cairo_window, (double) x0, (double) y0, (double) x0, (double) y0, (x0 + x1) / 2, (double) y0); +#line 278 "util.vala" + cairo_curve_to (cairo_window, x1, (double) y0, x1, (double) y0, x1, (y0 + y1) / 2); +#line 279 "util.vala" + cairo_curve_to (cairo_window, x1, y1, x1, y1, (x1 + x0) / 2, y1); +#line 280 "util.vala" + cairo_curve_to (cairo_window, (double) x0, y1, (double) x0, y1, (double) x0, (y0 + y1) / 2); +#line 962 "util.c" + } else { +#line 282 "util.vala" + cairo_move_to (cairo_window, (double) x0, y0 + RADIUS); +#line 283 "util.vala" + cairo_curve_to (cairo_window, (double) x0, (double) y0, (double) x0, (double) y0, (x0 + x1) / 2, (double) y0); +#line 284 "util.vala" + cairo_curve_to (cairo_window, x1, (double) y0, x1, (double) y0, x1, y0 + RADIUS); +#line 285 "util.vala" + cairo_line_to (cairo_window, x1, y1 - RADIUS); +#line 286 "util.vala" + cairo_curve_to (cairo_window, x1, y1, x1, y1, (x1 + x0) / 2, y1); +#line 287 "util.vala" + cairo_curve_to (cairo_window, (double) x0, y1, (double) x0, y1, (double) x0, y1 - RADIUS); +#line 976 "util.c" + } + } else { +#line 290 "util.vala" + if ((height / 2) < RADIUS) { +#line 291 "util.vala" + cairo_move_to (cairo_window, (double) x0, (y0 + y1) / 2); +#line 292 "util.vala" + cairo_curve_to (cairo_window, (double) x0, (double) y0, (double) x0, (double) y0, x0 + RADIUS, (double) y0); +#line 293 "util.vala" + cairo_line_to (cairo_window, x1 - RADIUS, (double) y0); +#line 294 "util.vala" + cairo_curve_to (cairo_window, x1, (double) y0, x1, (double) y0, x1, (y0 + y1) / 2); +#line 295 "util.vala" + cairo_curve_to (cairo_window, x1, y1, x1, y1, x1 - RADIUS, y1); +#line 296 "util.vala" + cairo_line_to (cairo_window, x0 + RADIUS, y1); +#line 297 "util.vala" + cairo_curve_to (cairo_window, (double) x0, y1, (double) x0, y1, (double) x0, (y0 + y1) / 2); +#line 995 "util.c" + } else { +#line 299 "util.vala" + cairo_move_to (cairo_window, (double) x0, y0 + RADIUS); +#line 300 "util.vala" + cairo_curve_to (cairo_window, (double) x0, (double) y0, (double) x0, (double) y0, x0 + RADIUS, (double) y0); +#line 301 "util.vala" + cairo_line_to (cairo_window, x1 - RADIUS, (double) y0); +#line 302 "util.vala" + cairo_curve_to (cairo_window, x1, (double) y0, x1, (double) y0, x1, y0 + RADIUS); +#line 303 "util.vala" + cairo_line_to (cairo_window, x1, y1 - RADIUS); +#line 304 "util.vala" + cairo_curve_to (cairo_window, x1, y1, x1, y1, x1 - RADIUS, y1); +#line 305 "util.vala" + cairo_line_to (cairo_window, x0 + RADIUS, y1); +#line 306 "util.vala" + cairo_curve_to (cairo_window, (double) x0, y1, (double) x0, y1, (double) x0, y1 - RADIUS); +#line 1013 "util.c" + } + } +#line 309 "util.vala" + cairo_close_path (cairo_window); +#line 311 "util.vala" + if (filled) { +#line 312 "util.vala" + cairo_fill (cairo_window); +#line 1022 "util.c" + } else { +#line 314 "util.vala" + cairo_set_line_width (cairo_window, LINE_WIDTH); +#line 315 "util.vala" + cairo_stroke (cairo_window); +#line 1028 "util.c" + } + _cairo_destroy0 (cairo_window); +} + + +#line 319 "util.vala" +void draw_right_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height) { +#line 1036 "util.c" + gboolean _tmp0_ = FALSE; + double x1; + double y1; + cairo_t* cairo_window; +#line 319 "util.vala" + g_return_if_fail (GDK_IS_WINDOW (window)); +#line 321 "util.vala" + if (width == 0) { +#line 321 "util.vala" + _tmp0_ = TRUE; +#line 1047 "util.c" + } else { +#line 321 "util.vala" + _tmp0_ = height == 0; +#line 1051 "util.c" + } +#line 321 "util.vala" + if (_tmp0_) { +#line 322 "util.vala" + return; +#line 1057 "util.c" + } +#line 324 "util.vala" + x1 = (double) (x0 + width); +#line 325 "util.vala" + y1 = (double) (y0 + height); +#line 327 "util.vala" + cairo_window = gdk_cairo_create (GDK_DRAWABLE (window)); +#line 328 "util.vala" + gdk_cairo_set_source_color (cairo_window, color); +#line 329 "util.vala" + cairo_set_antialias (cairo_window, ANTIALIAS); +#line 331 "util.vala" + if ((width / 2) < RADIUS) { +#line 332 "util.vala" + if ((height / 2) < RADIUS) { +#line 333 "util.vala" + cairo_move_to (cairo_window, (double) x0, (double) y0); +#line 334 "util.vala" + cairo_line_to (cairo_window, (x0 + x1) / 2, (double) y0); +#line 335 "util.vala" + cairo_curve_to (cairo_window, x1, (double) y0, x1, (double) y0, x1, (y0 + y1) / 2); +#line 336 "util.vala" + cairo_curve_to (cairo_window, x1, y1, x1, y1, (x1 + x0) / 2, y1); +#line 337 "util.vala" + cairo_line_to (cairo_window, (double) x0, y1); +#line 338 "util.vala" + cairo_line_to (cairo_window, (double) x0, (double) y0); +#line 1085 "util.c" + } else { +#line 340 "util.vala" + cairo_move_to (cairo_window, (double) x0, (double) y0); +#line 341 "util.vala" + cairo_line_to (cairo_window, (x0 + x1) / 2, (double) y0); +#line 342 "util.vala" + cairo_curve_to (cairo_window, x1, (double) y0, x1, (double) y0, x1, y0 + RADIUS); +#line 343 "util.vala" + cairo_line_to (cairo_window, x1, y1 - RADIUS); +#line 344 "util.vala" + cairo_curve_to (cairo_window, x1, y1, x1, y1, (x1 + x0) / 2, y1); +#line 345 "util.vala" + cairo_line_to (cairo_window, (double) x0, y1); +#line 346 "util.vala" + cairo_line_to (cairo_window, (double) x0, (double) y0); +#line 1101 "util.c" + } + } else { +#line 349 "util.vala" + if ((height / 2) < RADIUS) { +#line 350 "util.vala" + cairo_move_to (cairo_window, (double) x0, (double) y0); +#line 351 "util.vala" + cairo_line_to (cairo_window, x1 - RADIUS, (double) y0); +#line 352 "util.vala" + cairo_curve_to (cairo_window, x1, (double) y0, x1, (double) y0, x1, (y0 + y1) / 2); +#line 353 "util.vala" + cairo_curve_to (cairo_window, x1, y1, x1, y1, x1 - RADIUS, y1); +#line 354 "util.vala" + cairo_line_to (cairo_window, (double) x0, y1); +#line 355 "util.vala" + cairo_line_to (cairo_window, (double) x0, (double) y0); +#line 1118 "util.c" + } else { +#line 357 "util.vala" + cairo_move_to (cairo_window, (double) x0, (double) y0); +#line 358 "util.vala" + cairo_line_to (cairo_window, x1 - RADIUS, (double) y0); +#line 359 "util.vala" + cairo_curve_to (cairo_window, x1, (double) y0, x1, (double) y0, x1, y0 + RADIUS); +#line 360 "util.vala" + cairo_line_to (cairo_window, x1, y1 - RADIUS); +#line 361 "util.vala" + cairo_curve_to (cairo_window, x1, y1, x1, y1, x1 - RADIUS, y1); +#line 362 "util.vala" + cairo_line_to (cairo_window, (double) x0, y1); +#line 363 "util.vala" + cairo_line_to (cairo_window, (double) x0, (double) y0); +#line 1134 "util.c" + } + } +#line 366 "util.vala" + cairo_close_path (cairo_window); +#line 368 "util.vala" + if (filled) { +#line 369 "util.vala" + cairo_fill (cairo_window); +#line 1143 "util.c" + } else { +#line 371 "util.vala" + cairo_set_line_width (cairo_window, LINE_WIDTH); +#line 372 "util.vala" + cairo_stroke (cairo_window); +#line 1149 "util.c" + } + _cairo_destroy0 (cairo_window); +} + + +#line 376 "util.vala" +void draw_left_rounded_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x0, gint y0, gint width, gint height) { +#line 1157 "util.c" + gboolean _tmp0_ = FALSE; + double x1; + double y1; + cairo_t* cairo_window; +#line 376 "util.vala" + g_return_if_fail (GDK_IS_WINDOW (window)); +#line 378 "util.vala" + if (width == 0) { +#line 378 "util.vala" + _tmp0_ = TRUE; +#line 1168 "util.c" + } else { +#line 378 "util.vala" + _tmp0_ = height == 0; +#line 1172 "util.c" + } +#line 378 "util.vala" + if (_tmp0_) { +#line 379 "util.vala" + return; +#line 1178 "util.c" + } +#line 381 "util.vala" + x1 = (double) (x0 + width); +#line 382 "util.vala" + y1 = (double) (y0 + height); +#line 384 "util.vala" + cairo_window = gdk_cairo_create (GDK_DRAWABLE (window)); +#line 385 "util.vala" + gdk_cairo_set_source_color (cairo_window, color); +#line 386 "util.vala" + cairo_set_antialias (cairo_window, ANTIALIAS); +#line 388 "util.vala" + if ((width / 2) < RADIUS) { +#line 389 "util.vala" + if ((height / 2) < RADIUS) { +#line 390 "util.vala" + cairo_move_to (cairo_window, (double) x0, (y0 + y1) / 2); +#line 391 "util.vala" + cairo_curve_to (cairo_window, (double) x0, (double) y0, (double) x0, (double) y0, (x0 + x1) / 2, (double) y0); +#line 392 "util.vala" + cairo_line_to (cairo_window, x1, (double) y0); +#line 393 "util.vala" + cairo_line_to (cairo_window, x1, y1); +#line 394 "util.vala" + cairo_line_to (cairo_window, (x1 + x0) / 2, y1); +#line 395 "util.vala" + cairo_curve_to (cairo_window, (double) x0, y1, (double) x0, y1, (double) x0, (y0 + y1) / 2); +#line 1206 "util.c" + } else { +#line 397 "util.vala" + cairo_move_to (cairo_window, (double) x0, y0 + RADIUS); +#line 398 "util.vala" + cairo_curve_to (cairo_window, (double) x0, (double) y0, (double) x0, (double) y0, (x0 + x1) / 2, (double) y0); +#line 399 "util.vala" + cairo_line_to (cairo_window, x1, (double) y0); +#line 400 "util.vala" + cairo_line_to (cairo_window, x1, y1); +#line 401 "util.vala" + cairo_line_to (cairo_window, (x1 + x0) / 2, y1); +#line 402 "util.vala" + cairo_curve_to (cairo_window, (double) x0, y1, (double) x0, y1, (double) x0, y1 - RADIUS); +#line 1220 "util.c" + } + } else { +#line 405 "util.vala" + if ((height / 2) < RADIUS) { +#line 406 "util.vala" + cairo_move_to (cairo_window, (double) x0, (y0 + y1) / 2); +#line 407 "util.vala" + cairo_curve_to (cairo_window, (double) x0, (double) y0, (double) x0, (double) y0, x0 + RADIUS, (double) y0); +#line 408 "util.vala" + cairo_line_to (cairo_window, x1, (double) y0); +#line 409 "util.vala" + cairo_line_to (cairo_window, x1, y1); +#line 410 "util.vala" + cairo_line_to (cairo_window, x0 + RADIUS, y1); +#line 411 "util.vala" + cairo_curve_to (cairo_window, (double) x0, y1, (double) x0, y1, (double) x0, (y0 + y1) / 2); +#line 1237 "util.c" + } else { +#line 413 "util.vala" + cairo_move_to (cairo_window, (double) x0, y0 + RADIUS); +#line 414 "util.vala" + cairo_curve_to (cairo_window, (double) x0, (double) y0, (double) x0, (double) y0, x0 + RADIUS, (double) y0); +#line 415 "util.vala" + cairo_line_to (cairo_window, x1, (double) y0); +#line 416 "util.vala" + cairo_line_to (cairo_window, x1, y1); +#line 417 "util.vala" + cairo_line_to (cairo_window, x0 + RADIUS, y1); +#line 418 "util.vala" + cairo_curve_to (cairo_window, (double) x0, y1, (double) x0, y1, (double) x0, y1 - RADIUS); +#line 1251 "util.c" + } + } +#line 421 "util.vala" + cairo_close_path (cairo_window); +#line 423 "util.vala" + if (filled) { +#line 424 "util.vala" + cairo_fill (cairo_window); +#line 1260 "util.c" + } else { +#line 426 "util.vala" + cairo_set_line_width (cairo_window, LINE_WIDTH); +#line 427 "util.vala" + cairo_stroke (cairo_window); +#line 1266 "util.c" + } + _cairo_destroy0 (cairo_window); +} + + +#line 431 "util.vala" +void draw_square_rectangle (GdkWindow* window, GdkColor* color, gboolean filled, gint x, gint y, gint width, gint height) { +#line 1274 "util.c" + gboolean _tmp0_ = FALSE; + cairo_t* cairo_window; +#line 431 "util.vala" + g_return_if_fail (GDK_IS_WINDOW (window)); +#line 433 "util.vala" + if (width == 0) { +#line 433 "util.vala" + _tmp0_ = TRUE; +#line 1283 "util.c" + } else { +#line 433 "util.vala" + _tmp0_ = height == 0; +#line 1287 "util.c" + } +#line 433 "util.vala" + if (_tmp0_) { +#line 434 "util.vala" + return; +#line 1293 "util.c" + } +#line 436 "util.vala" + cairo_window = gdk_cairo_create (GDK_DRAWABLE (window)); +#line 437 "util.vala" + gdk_cairo_set_source_color (cairo_window, color); +#line 438 "util.vala" + cairo_set_antialias (cairo_window, ANTIALIAS); +#line 440 "util.vala" + cairo_rectangle (cairo_window, (double) x, (double) y, (double) width, (double) height); +#line 442 "util.vala" + if (filled) { +#line 443 "util.vala" + cairo_fill (cairo_window); +#line 1307 "util.c" + } else { +#line 445 "util.vala" + cairo_set_line_width (cairo_window, LINE_WIDTH); +#line 446 "util.vala" + cairo_stroke (cairo_window); +#line 1313 "util.c" + } + _cairo_destroy0 (cairo_window); +} + + +#line 452 "util.vala" +gboolean is_drop_frame_rate (Fraction* r) { +#line 1321 "util.c" + gboolean result = FALSE; + gboolean _tmp0_ = FALSE; + gboolean _tmp1_ = FALSE; +#line 453 "util.vala" + if ((*r).numerator == 2997) { +#line 453 "util.vala" + _tmp1_ = (*r).denominator == 100; +#line 1329 "util.c" + } else { +#line 453 "util.vala" + _tmp1_ = FALSE; +#line 1333 "util.c" + } +#line 453 "util.vala" + if (_tmp1_) { +#line 453 "util.vala" + _tmp0_ = TRUE; +#line 1339 "util.c" + } else { + gboolean _tmp2_ = FALSE; +#line 454 "util.vala" + if ((*r).numerator == 30000) { +#line 454 "util.vala" + _tmp2_ = (*r).denominator == 1001; +#line 1346 "util.c" + } else { +#line 454 "util.vala" + _tmp2_ = FALSE; +#line 1350 "util.c" + } +#line 454 "util.vala" + _tmp0_ = _tmp2_; +#line 1354 "util.c" + } + result = _tmp0_; +#line 453 "util.vala" + return result; +#line 1359 "util.c" +} + + +#line 457 "util.vala" +gint64 frame_to_time_with_rate (gint frame, Fraction* rate) { +#line 1365 "util.c" + gint64 result = 0LL; + gint64 time; +#line 458 "util.vala" + time = (gint64) gst_util_uint64_scale ((guint64) frame, (guint64) (GST_SECOND * (*rate).denominator), (guint64) (*rate).numerator); +#line 1370 "util.c" + result = time; +#line 459 "util.vala" + return result; +#line 1374 "util.c" +} + + +#line 462 "util.vala" +gint time_to_frame_with_rate (gint64 time, Fraction* rate) { +#line 1380 "util.c" + gint result = 0; + gint frame; + gint _tmp0_ = 0; +#line 463 "util.vala" + frame = (gint) gst_util_uint64_scale ((guint64) time, (guint64) (*rate).numerator, (guint64) (GST_SECOND * (*rate).denominator)); +#line 469 "util.vala" + if (time >= frame_to_time_with_rate (frame + 1, rate)) { +#line 469 "util.vala" + _tmp0_ = frame + 1; +#line 1390 "util.c" + } else { +#line 469 "util.vala" + _tmp0_ = frame; +#line 1394 "util.c" + } + result = _tmp0_; +#line 469 "util.vala" + return result; +#line 1399 "util.c" +} + + +#line 472 "util.vala" +void frame_to_time (gint frame, Fraction* rate, TimeCode* result) { +#line 1405 "util.c" + gint frame_rate; + TimeCode _tmp0_ = {0}; + TimeCode t; + gint64 secs; +#line 473 "util.vala" + frame_rate = 0; +#line 475 "util.vala" + t = (_tmp0_); +#line 477 "util.vala" + t.drop_code = FALSE; +#line 478 "util.vala" + if ((*rate).denominator == 1) { +#line 479 "util.vala" + frame_rate = (*rate).numerator; +#line 1420 "util.c" + } else { +#line 480 "util.vala" + if (is_drop_frame_rate (rate)) { +#line 1424 "util.c" + gint FRAMES_PER_MINUTE; + gint FRAMES_PER_10_MINUTES; + gint block; + gint minute_in_block; + gint minutes; +#line 481 "util.vala" + t.drop_code = TRUE; +#line 482 "util.vala" + frame_rate = 30; +#line 485 "util.vala" + FRAMES_PER_MINUTE = (30 * 60) - 2; +#line 486 "util.vala" + FRAMES_PER_10_MINUTES = (10 * FRAMES_PER_MINUTE) + 2; +#line 488 "util.vala" + block = frame / FRAMES_PER_10_MINUTES; +#line 489 "util.vala" + minute_in_block = ((frame % FRAMES_PER_10_MINUTES) - 2) / FRAMES_PER_MINUTE; +#line 490 "util.vala" + minutes = (10 * block) + minute_in_block; +#line 491 "util.vala" + frame = frame + ((2 * minutes) - (2 * block)); +#line 1446 "util.c" + } else { +#line 495 "util.vala" + frame_rate = (*rate).numerator / (*rate).denominator; +#line 1450 "util.c" + } + } +#line 498 "util.vala" + t.frame = frame % frame_rate; +#line 500 "util.vala" + secs = (gint64) (frame / frame_rate); +#line 501 "util.vala" + t.hour = ((gint) secs) / 3600; +#line 502 "util.vala" + t.minute = (((gint) secs) % 3600) / 60; +#line 503 "util.vala" + t.second = (((gint) secs) % 3600) % 60; +#line 1463 "util.c" + *result = t; +#line 505 "util.vala" + return; +#line 1467 "util.c" +} + + +#line 508 "util.vala" +char* frame_to_string (gint frame, Fraction* rate) { +#line 1473 "util.c" + char* result = NULL; + TimeCode _tmp1_; + TimeCode _tmp0_ = {0}; + result = time_code_to_string ((_tmp1_ = (frame_to_time (frame, rate, &_tmp0_), _tmp0_), &_tmp1_)); +#line 509 "util.vala" + return result; +#line 1480 "util.c" +} + + +#line 512 "util.vala" +void breakup_time (gint64 time, gint* hours, gint* minutes, double* seconds) { +#line 1486 "util.c" + gint64 the_time; + gint64 minute; + gint64 hour; +#line 513 "util.vala" + the_time = time; +#line 514 "util.vala" + minute = (gint64) (GST_SECOND * 60); +#line 515 "util.vala" + hour = minute * 60; +#line 516 "util.vala" + *hours = (gint) (the_time / hour); +#line 517 "util.vala" + the_time = the_time % hour; +#line 518 "util.vala" + *minutes = (gint) (the_time / minute); +#line 519 "util.vala" + the_time = the_time % minute; +#line 520 "util.vala" + *seconds = ((double) the_time) / GST_SECOND; +#line 1506 "util.c" +} + + +#line 523 "util.vala" +char* time_to_HHMMSS (gint64 time) { +#line 1512 "util.c" + char* result = NULL; + gint hours = 0; + gint minutes = 0; + double seconds = 0.0; +#line 528 "util.vala" + breakup_time (time, &hours, &minutes, &seconds); +#line 1519 "util.c" + result = g_strdup_printf ("%02d:%02d:%05.2lf", hours, minutes, seconds); +#line 529 "util.vala" + return result; +#line 1523 "util.c" +} + + +#line 532 "util.vala" +char* time_to_string (gint64 time) { +#line 1529 "util.c" + char* result = NULL; + gint hours = 0; + gint minutes = 0; + double seconds = 0.0; + char* return_value; + gboolean _tmp0_ = FALSE; +#line 537 "util.vala" + breakup_time (time, &hours, &minutes, &seconds); +#line 538 "util.vala" + return_value = g_strdup_printf ("%1.2lfs", seconds); +#line 539 "util.vala" + if (hours > 0) { +#line 539 "util.vala" + _tmp0_ = TRUE; +#line 1544 "util.c" + } else { +#line 539 "util.vala" + _tmp0_ = minutes > 0; +#line 1548 "util.c" + } +#line 539 "util.vala" + if (_tmp0_) { +#line 1552 "util.c" + char* _tmp2_; + char* _tmp1_; +#line 540 "util.vala" + return_value = (_tmp2_ = g_strconcat (_tmp1_ = g_strdup_printf ("%dm ", minutes), return_value, NULL), _g_free0 (return_value), _tmp2_); +#line 1557 "util.c" + _g_free0 (_tmp1_); + } +#line 543 "util.vala" + if (hours > 0) { +#line 1562 "util.c" + char* _tmp4_; + char* _tmp3_; +#line 544 "util.vala" + return_value = (_tmp4_ = g_strconcat (_tmp3_ = g_strdup_printf ("%dh ", hours), return_value, NULL), _g_free0 (return_value), _tmp4_); +#line 1567 "util.c" + _g_free0 (_tmp3_); + } + result = return_value; +#line 547 "util.vala" + return result; +#line 1573 "util.c" +} + + +#line 550 "util.vala" +GstElement* make_element_with_name (const char* element_name, const char* display_name, GError** error) { +#line 1579 "util.c" + GstElement* result = NULL; + GError * _inner_error_; + GstElement* e; +#line 550 "util.vala" + g_return_val_if_fail (element_name != NULL, NULL); +#line 1585 "util.c" + _inner_error_ = NULL; +#line 552 "util.vala" + e = gst_element_factory_make (element_name, display_name); +#line 553 "util.vala" + if (e == NULL) { +#line 1591 "util.c" + char* _tmp0_; + GError* _tmp1_; + _inner_error_ = (_tmp1_ = g_error_new_literal (MEDIA_ERROR, MEDIA_ERROR_MISSING_PLUGIN, _tmp0_ = g_strdup_printf ("Could not create element %s(%s)", element_name, display_name)), _g_free0 (_tmp0_), _tmp1_); + { + g_propagate_error (error, _inner_error_); + _gst_object_unref0 (e); + return NULL; + } + } + result = e; +#line 557 "util.vala" + return result; +#line 1604 "util.c" +} + + +#line 560 "util.vala" +GstElement* make_element (const char* name, GError** error) { +#line 1610 "util.c" + GstElement* result = NULL; + GError * _inner_error_; + GstElement* _tmp0_; +#line 560 "util.vala" + g_return_val_if_fail (name != NULL, NULL); +#line 1616 "util.c" + _inner_error_ = NULL; +#line 561 "util.vala" + _tmp0_ = make_element_with_name (name, NULL, &_inner_error_); +#line 1620 "util.c" + if (_inner_error_ != NULL) { + g_propagate_error (error, _inner_error_); + return NULL; + } + result = _tmp0_; +#line 561 "util.vala" + return result; +#line 1628 "util.c" +} + + +static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) { + if ((array != NULL) && (destroy_func != NULL)) { + int i; + for (i = 0; i < array_length; i = i + 1) { + if (((gpointer*) array)[i] != NULL) { + destroy_func (((gpointer*) array)[i]); + } + } + } +} + + +static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) { + _vala_array_destroy (array, array_length, destroy_func); + g_free (array); +} + + +static gint _vala_array_length (gpointer array) { + int length; + length = 0; + if (array) { + while (((gpointer*) array)[length]) { + length++; + } + } + return length; +} + + +static int _vala_strcmp0 (const char * str1, const char * str2) { + if (str1 == NULL) { + return -(str1 != str2); + } + if (str2 == NULL) { + return str1 != str2; + } + return strcmp (str1, str2); +} + + + + diff --git a/src/test/debug/util.o b/src/test/debug/util.o new file mode 100644 index 0000000..53e8742 Binary files /dev/null and b/src/test/debug/util.o differ diff --git a/src/test/marina/ProjectLoading.vala b/src/test/marina/ProjectLoading.vala new file mode 100644 index 0000000..488fac2 --- /dev/null +++ b/src/test/marina/ProjectLoading.vala @@ -0,0 +1,162 @@ +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +namespace Model { + +public class ClipFetcher { + public string error_string; + public ClipFile clipfile; + string filename; + + public ClipFetcher(string filename) { + this.filename = filename; + } + public string get_filename() { + return filename; + } + public signal void ready(ClipFetcher fetcher); +} + +public class ClipFile { + public string filename; +} +} + +// Describes an XML Document and if the test should consider it a valid or an invalid document +struct ValidDocument { + public bool valid; + public string document; + public ValidDocument(bool valid, string document) { + this.valid = valid; + this.document = document; + } +} + +ValidDocument[] project_documents; // The set of documents for building the test suite +int current_document; // Index of the document for the test we are currently building + +// StateChangeFixture holds the root of an XML tree describing a project, the TreeBuilder +// and if the XML tree is expected to be valid or not +struct StateChangeFixture { + public Model.XmlElement root; + public Model.ProjectBuilder project_builder; + public bool valid; +} + +void state_change_fixture_buildup(void *fixture) { + StateChangeFixture* state_change_fixture = (StateChangeFixture*)fixture; + Model.XmlTreeLoader tree_loader = new Model.XmlTreeLoader(project_documents[current_document].document); + state_change_fixture->root = tree_loader.root; + state_change_fixture->project_builder = new Model.ProjectBuilder(new Model.LoaderHandler()); + state_change_fixture->valid = project_documents[current_document].valid; + ++current_document; +} + +void state_change_fixture_teardown(void *fixture) { + StateChangeFixture* state_change_fixture = (StateChangeFixture*)fixture; + state_change_fixture->root = null; + state_change_fixture->project_builder = null; +} + +bool document_valid; // if a document is invalid, on_error_occurred will set this variable to false + +void on_error_occurred(string? message) { + Test.message("received error: %s", message); + document_valid = false; +} + +// The actual test code. It builds the given document and then asserts that the result is what +// was expected. +void check_document(void *fixture) { + StateChangeFixture* state_change_fixture = (StateChangeFixture*)fixture; + + Test.message("checking document expecting to be %s", + state_change_fixture->valid ? "valid" : "invalid"); + + Model.XmlElement root = state_change_fixture->root; + Model.ProjectBuilder project_builder = state_change_fixture->project_builder; + + document_valid = true; + project_builder.error_occurred.connect(on_error_occurred); + + // We call check project to check the integrity of the file skeleton. + // If it's good, then we can load all the pieces of the file (library, tracks). + if (project_builder.check_project(root)) + project_builder.build_project(root); + assert(document_valid == state_change_fixture->valid); + Test.message("finished executing check document"); +} + + +class ProjectLoaderSuite : TestSuite { + public ProjectLoaderSuite() { + base("ProjectLoaderSuite"); + + current_document = 0; + project_documents = { + ValidDocument(true, "" + + ""), + ValidDocument(true, "" + + ""), + ValidDocument(true, "" + + ""), + ValidDocument(true, "" + + ""), + ValidDocument(true, "" + + ""), + ValidDocument(true, "" + + ""), + ValidDocument(true, "" + + ""), + ValidDocument(true, "" + +""), + ValidDocument(true, ""), + ValidDocument(true, "" + + ""), + ValidDocument(true, "" + + ""), + ValidDocument(true, "" + + ""), + ValidDocument(false, ""), + ValidDocument(false, ""), + ValidDocument(false, "" + + ""), + ValidDocument(false, ""), + ValidDocument(false, ""), + ValidDocument(false, ""), + ValidDocument(false, ""), + ValidDocument(false, ""), + ValidDocument(false, ""), + ValidDocument(false, ""), + ValidDocument(false, ""), + ValidDocument(false, ""), + ValidDocument(false, ""), + ValidDocument(false, ""), + ValidDocument(false, ""), + ValidDocument(false, ""), + ValidDocument(false, ""), + ValidDocument(false, ""), + ValidDocument(false, ""), + ValidDocument(false, ""), + ValidDocument(false, "" + + ""), + ValidDocument(false, ""), + ValidDocument(false, "" + +""), + ValidDocument(false, "") + }; + + int length = project_documents.length; + + for (int i = 0; i < length; ++i) { + if (Test.thorough() || project_documents[i].valid) { + add(new TestCase("Document%d".printf(i), state_change_fixture_buildup, + check_document, state_change_fixture_teardown, sizeof(StateChangeFixture))); + } + } + } +} + diff --git a/src/test/sources.mk b/src/test/sources.mk new file mode 100644 index 0000000..7806b8e --- /dev/null +++ b/src/test/sources.mk @@ -0,0 +1,4 @@ +$(SRC_PREFIX)SRC_FILES += \ + test.vala \ + marina/ProjectLoading.vala \ + diff --git a/src/test/test.vala b/src/test/test.vala new file mode 100644 index 0000000..2546341 --- /dev/null +++ b/src/test/test.vala @@ -0,0 +1,12 @@ +/* Copyright 2009 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + + +void main(string[] args) { + Test.init(ref args); + TestSuite.get_root().add_suite(new ProjectLoaderSuite()); + Test.run(); +} diff --git a/www/index.html b/www/index.html new file mode 100644 index 0000000..d230976 --- /dev/null +++ b/www/index.html @@ -0,0 +1,11 @@ + + +Fillmore multitrack recorder for N900 + + +

Fillmore multitrack recorder

+

A port to maemo 5 for the N900

+

Coming soon...

+

Meanwhile visit https://garage.maemo.org/projects/fillmore/ for more information.

+ +