git.maemo.org Git - fillmore/blob - src/marina/marina/marina.vapi

   1 /* marina.vapi generated by valac, do not modify. */
   2
   3 [CCode (cprefix = "View", lower_case_cprefix = "view_")]
   4 namespace View {
   5         [CCode (cheader_filename = "marina.h")]
   6         public class AudioMeter : Gtk.DrawingArea {
   7                 public AudioMeter (Model.AudioTrack track);
   8                 public void on_channel_count_changed (int number_of_channels);
   9                 public bool on_expose_event (Gdk.EventExpose event);
  10                 public void on_level_changed (double level_left, double level_right);
  11         }
  12         [CCode (cheader_filename = "marina.h")]
  13         public class AudioOutput : View.MediaConnector {
  14                 public AudioOutput (Gst.Caps caps) throws GLib.Error;
  15                 public override void connect (View.MediaEngine media_engine, Gst.Pipeline pipeline, Gst.Element[] elements);
  16                 public override void do_disconnect (View.MediaEngine media_engine, Gst.Pipeline pipeline, Gst.Element[] elements);
  17         }
  18         [CCode (cheader_filename = "marina.h")]
  19         public class ClickTrack : GLib.Object {
  20                 public ClickTrack (View.MediaEngine engine, Model.Project project) throws GLib.Error;
  21         }
  22         [CCode (cheader_filename = "marina.h")]
  23         public class MediaAudioTrack : View.MediaTrack {
  24                 public MediaAudioTrack (View.MediaEngine media_engine, Model.AudioTrack track) throws GLib.Error;
  25                 protected override Gst.Element empty_element () throws GLib.Error;
  26                 public override Gst.Element? get_element ();
  27                 public override void unlink_pad (Gst.Pad pad, Gst.Element track_element);
  28                 public signal void level_changed (double level_left, double level_right);
  29         }
  30         [CCode (cheader_filename = "marina.h")]
  31         public abstract class MediaConnector : GLib.Object {
  32                 [CCode (cprefix = "VIEW_MEDIA_CONNECTOR_MEDIA_TYPES_", cheader_filename = "marina.h")]
  33                 public enum MediaTypes {
  34                         Audio,
  35                         Video
  36                 }
  37                 protected int AudioIndex;
  38                 protected int VideoIndex;
  39                 protected MediaConnector (View.MediaConnector.MediaTypes media_types);
  40                 public abstract void connect (View.MediaEngine media_engine, Gst.Pipeline pipeline, Gst.Element[] elements);
  41                 public abstract void do_disconnect (View.MediaEngine media_engine, Gst.Pipeline pipeline, Gst.Element[] elements);
  42                 protected bool has_audio ();
  43                 protected bool has_video ();
  44         }
  45         [CCode (cheader_filename = "marina.h")]
  46         public class MediaEngine : MultiFileProgressInterface, GLib.Object {
  47                 public Gst.Element adder;
  48                 public Gst.Element converter;
  49                 protected Gst.State gst_state;
  50                 public Gst.Pipeline pipeline;
  51                 protected PlayState play_state;
  52                 public bool playing;
  53                 public int64 position;
  54                 public Gst.Bin record_bin;
  55                 public Model.Clip record_region;
  56                 public Model.AudioTrack record_track;
  57                 public MediaEngine (Model.Project project, bool include_video) throws GLib.Error;
  58                 protected Gst.Caps build_audio_caps (int num_channels);
  59                 public static void can_run () throws GLib.Error;
  60                 public void close ();
  61                 public void connect_output (View.MediaConnector connector);
  62                 public void disconnect_output (View.MediaConnector connector);
  63                 protected virtual void do_null_state_export (int64 length);
  64                 public void do_play (PlayState new_state);
  65                 protected bool do_state_change ();
  66                 public Gst.Element get_audio_silence () throws GLib.Error;
  67                 public PlayState get_play_state ();
  68                 public Gst.Caps get_project_audio_caps ();
  69                 public Gst.Caps get_project_audio_export_caps ();
  70                 protected Gst.Caps get_record_audio_caps ();
  71                 public int get_sample_depth ();
  72                 public int get_sample_rate ();
  73                 public int get_sample_width ();
  74                 public void go (int64 pos);
  75                 public void on_callback_pulse ();
  76                 public void on_load_complete ();
  77                 public void on_track_added (Model.Track track);
  78                 public virtual void pause ();
  79                 public void post_record ();
  80                 public void record (Model.AudioTrack track);
  81                 public void set_gst_state (Gst.State state);
  82                 public void set_play_state (PlayState play_state);
  83                 public void start_export (string filename);
  84                 public void start_record (Model.Clip region) throws GLib.Error;
  85                 public signal void callback_pulse ();
  86                 public signal void error_occurred (string major_message, string? minor_message);
  87                 public signal void level_changed (Gst.Object source, double level_left, double level_right);
  88                 public signal void link_for_export (Gst.Element mux);
  89                 public signal void link_for_playback (Gst.Element mux);
  90                 public signal void playstate_changed ();
  91                 public signal void position_changed (int64 position);
  92                 public signal void post_export (bool canceled);
  93                 public signal void pre_export (int64 length);
  94                 public signal void prepare_window ();
  95                 public signal void record_completed ();
  96         }
  97         [CCode (cheader_filename = "marina.h")]
  98         public abstract class MediaTrack : GLib.Object {
  99                 protected Gst.Bin composition;
 100                 protected Gst.Element default_source;
 101                 protected weak View.MediaEngine media_engine;
 102                 protected Gst.Element sink;
 103                 public MediaTrack (View.MediaEngine media_engine, Model.Track track) throws GLib.Error;
 104                 protected abstract Gst.Element empty_element () throws GLib.Error;
 105                 public abstract Gst.Element? get_element ();
 106                 public abstract void link_new_pad (Gst.Pad pad, Gst.Element track_element);
 107                 public abstract void unlink_pad (Gst.Pad pad, Gst.Element track_element);
 108                 public signal void error_occurred (string major_message, string? minor_message);
 109                 public signal void track_removed (View.MediaTrack track);
 110         }
 111         [CCode (cheader_filename = "marina.h")]
 112         public class MediaVideoTrack : View.MediaTrack {
 113                 public MediaVideoTrack (View.MediaEngine media_engine, Model.Track track, Gst.Element converter) throws GLib.Error;
 114                 protected override Gst.Element empty_element () throws GLib.Error;
 115                 public override Gst.Element? get_element ();
 116                 public override void link_new_pad (Gst.Pad pad, Gst.Element track_element);
 117                 public override void unlink_pad (Gst.Pad pad, Gst.Element track_element);
 118         }
 119         [CCode (cheader_filename = "marina.h")]
 120         public class OggVorbisExport : View.MediaConnector {
 121                 public OggVorbisExport (View.MediaConnector.MediaTypes media_types, string filename, Gst.Caps caps) throws GLib.Error;
 122                 public override void connect (View.MediaEngine media_engine, Gst.Pipeline pipeline, Gst.Element[] elements);
 123                 public override void do_disconnect (View.MediaEngine media_engine, Gst.Pipeline pipeline, Gst.Element[] elements);
 124                 public string get_filename ();
 125         }
 126         [CCode (cheader_filename = "marina.h")]
 127         public class Ruler : Gtk.DrawingArea {
 128                 public Ruler (Model.TimeSystem provider, int height);
 129                 public override bool button_press_event (Gdk.EventButton event);
 130                 public override bool expose_event (Gdk.EventExpose event);
 131                 public override bool motion_notify_event (Gdk.EventMotion event);
 132                 public signal void position_changed (int x);
 133         }
 134         [CCode (cheader_filename = "marina.h")]
 135         public class StatusBar : Gtk.DrawingArea {
 136                 public StatusBar (Model.Project p, Model.TimeSystem provider, int height);
 137                 public override bool expose_event (Gdk.EventExpose e);
 138                 public void on_position_changed (int64 new_position);
 139         }
 140         [CCode (cheader_filename = "marina.h")]
 141         public class VideoOutput : View.MediaConnector {
 142                 public VideoOutput (Gtk.Widget output_widget) throws GLib.Error;
 143                 public override void connect (View.MediaEngine media_engine, Gst.Pipeline pipeline, Gst.Element[] elements);
 144                 public override void do_disconnect (View.MediaEngine media_engine, Gst.Pipeline pipeline, Gst.Element[] elements);
 145         }
 146 }
 147 [CCode (cprefix = "Model", lower_case_cprefix = "model_")]
 148 namespace Model {
 149         [CCode (cheader_filename = "marina.h")]
 150         public class AddClipCommand : Model.Command {
 151                 public AddClipCommand (Model.Project project, Model.ClipFile clip_file);
 152                 public override void apply ();
 153                 public override string description ();
 154                 public override bool merge (Model.Command command);
 155                 public override void undo ();
 156         }
 157         [CCode (cheader_filename = "marina.h")]
 158         public class AudioTrack : Model.Track {
 159                 public const int INVALID_CHANNEL_COUNT;
 160                 public AudioTrack (Model.Project project, string display_name);
 161                 public void _set_pan (double new_value);
 162                 public void _set_volume (double new_volume);
 163                 public override bool check (Model.Clip clip);
 164                 public bool get_num_channels (out int num);
 165                 public double get_pan ();
 166                 public double get_volume ();
 167                 public override Model.MediaType media_type ();
 168                 protected override string name ();
 169                 public override void on_clip_updated (Model.Clip clip);
 170                 public void on_level_changed (double level_left, double level_right);
 171                 public void set_default_num_channels (int num);
 172                 public void set_pan (double new_value);
 173                 public void set_volume (double new_volume);
 174                 public override void write_attributes (GLib.FileStream f);
 175                 public signal void channel_count_changed (int channel_count);
 176                 public signal void level_changed (double level_left, double level_right);
 177                 public signal void parameter_changed (Model.Parameter parameter, double new_value);
 178         }
 179         [CCode (cheader_filename = "marina.h")]
 180         public class BarBeatTimeSystem : Model.TimeSystem, Model.TimeSystemBase {
 181                 public BarBeatTimeSystem (Model.TempoInformation tempo_information);
 182         }
 183         [CCode (cheader_filename = "marina.h")]
 184         public class BpmCommand : Model.Command {
 185                 public BpmCommand (Model.Project project, int new_bpm);
 186                 public override void apply ();
 187                 public override string description ();
 188                 public override bool merge (Model.Command command);
 189                 public override void undo ();
 190         }
 191         [CCode (cheader_filename = "marina.h")]
 192         public class Clip : GLib.Object {
 193                 public Model.ClipFile clipfile;
 194                 public bool is_recording;
 195                 public string name;
 196                 public Model.MediaType type;
 197                 public Clip (Model.ClipFile clipfile, Model.MediaType t, string name, int64 start, int64 media_start, int64 duration, bool is_recording);
 198                 public Model.Clip copy ();
 199                 public void gnonlin_connect ();
 200                 public void gnonlin_disconnect ();
 201                 public bool is_trimmed ();
 202                 public bool overlap_pos (int64 start, int64 length);
 203                 public void save (GLib.FileStream f, int id);
 204                 public void set_media_start_duration (int64 media_start, int64 duration);
 205                 public int64 snap (Model.Clip other, int64 pad);
 206                 public bool snap_coord (out int64 s, int64 span);
 207                 public void trim (int64 delta, Gdk.WindowEdge edge);
 208                 public int64 duration { get; set; }
 209                 public int64 end { get; }
 210                 public int64 media_start { get; }
 211                 public int64 start { get; set; }
 212                 public signal void duration_changed (int64 duration);
 213                 public signal void media_start_changed (int64 media_start);
 214                 public signal void moved (Model.Clip clip);
 215                 public signal void removed (Model.Clip clip);
 216                 public signal void start_changed (int64 start);
 217                 public signal void updated (Model.Clip clip);
 218         }
 219         [CCode (cheader_filename = "marina.h")]
 220         public class ClipAddCommand : Model.Command {
 221                 public ClipAddCommand (Model.Track track, Model.Clip clip, int64 original_time, int64 new_start);
 222                 public override void apply ();
 223                 public override string description ();
 224                 public override bool merge (Model.Command command);
 225                 public override void undo ();
 226         }
 227         [CCode (cheader_filename = "marina.h")]
 228         public class ClipCommand : Model.Command {
 229                 [CCode (cprefix = "MODEL_CLIP_COMMAND_ACTION_", cheader_filename = "marina.h")]
 230                 public enum Action {
 231                         APPEND,
 232                         DELETE
 233                 }
 234                 public ClipCommand (Model.ClipCommand.Action action, Model.Track track, Model.Clip clip, int64 time, bool select);
 235                 public override void apply ();
 236                 public override string description ();
 237                 public override bool merge (Model.Command command);
 238                 public override void undo ();
 239         }
 240         [CCode (cheader_filename = "marina.h")]
 241         public class ClipFetcher : Model.Fetcher {
 242                 public ClipFetcher (string filename) throws GLib.Error;
 243                 public string get_filename ();
 244                 protected override void on_pad_added (Gst.Pad pad);
 245                 protected override void on_state_change (Gst.Bus bus, Gst.Message message);
 246                 public signal void clipfile_online (bool online);
 247         }
 248         [CCode (cheader_filename = "marina.h")]
 249         public class ClipFile : GLib.Object {
 250                 public Gst.Caps audio_caps;
 251                 public string filename;
 252                 public Gdk.Pixbuf thumbnail;
 253                 public Gst.Caps video_caps;
 254                 public ClipFile (string filename, int64 length = 0);
 255                 public bool get_dimensions (out int w, out int h);
 256                 public bool get_frame_rate (out Fraction rate);
 257                 public bool get_num_channels (out int channels);
 258                 public bool get_num_channels_string (out string s);
 259                 public bool get_sample_rate (out int rate);
 260                 public bool get_video_format (out uint32 fourcc);
 261                 public bool has_caps_structure (Model.MediaType m);
 262                 public bool is_of_type (Model.MediaType t);
 263                 public bool is_online ();
 264                 public void set_online (bool o);
 265                 public void set_thumbnail (Gdk.Pixbuf b);
 266                 public int64 length { get; set; }
 267                 public signal void updated ();
 268         }
 269         [CCode (cheader_filename = "marina.h")]
 270         public class ClipFileDeleteCommand : Model.Command {
 271                 public ClipFileDeleteCommand (Model.Project p, Model.ClipFile cf);
 272                 public override void apply ();
 273                 public override string description ();
 274                 public override bool merge (Model.Command command);
 275                 public override void undo ();
 276         }
 277         [CCode (cheader_filename = "marina.h")]
 278         public class ClipImporter : MultiFileProgressInterface, GLib.Object {
 279                 public ClipImporter ();
 280                 public void add_filename (string filename);
 281                 public void start () throws GLib.Error;
 282                 public signal void clip_complete (Model.ClipFile f);
 283                 public signal void error_occurred (string error);
 284                 public signal void importing_started (int num_clips);
 285         }
 286         [CCode (cheader_filename = "marina.h")]
 287         public class ClipRevertCommand : Model.Command {
 288                 public ClipRevertCommand (Model.Track track, Model.Clip clip);
 289                 public override void apply ();
 290                 public override string description ();
 291                 public override bool merge (Model.Command command);
 292                 public override void undo ();
 293         }
 294         [CCode (cheader_filename = "marina.h")]
 295         public class ClipSplitCommand : Model.Command {
 296                 [CCode (cprefix = "MODEL_CLIP_SPLIT_COMMAND_ACTION_", cheader_filename = "marina.h")]
 297                 public enum Action {
 298                         SPLIT,
 299                         JOIN
 300                 }
 301                 public ClipSplitCommand (Model.ClipSplitCommand.Action action, Model.Track track, int64 time);
 302                 public override void apply ();
 303                 public override string description ();
 304                 public override bool merge (Model.Command command);
 305                 public override void undo ();
 306         }
 307         [CCode (cheader_filename = "marina.h")]
 308         public class ClipTrimCommand : Model.Command {
 309                 public ClipTrimCommand (Model.Track track, Model.Clip clip, int64 delta, Gdk.WindowEdge edge);
 310                 public override void apply ();
 311                 public override string description ();
 312                 public override bool merge (Model.Command command);
 313                 public override void undo ();
 314         }
 315         [CCode (ref_function = "model_command_ref", unref_function = "model_command_unref", cheader_filename = "marina.h")]
 316         public abstract class Command {
 317                 public Command ();
 318                 public abstract void apply ();
 319                 public abstract string description ();
 320                 public abstract bool merge (Model.Command command);
 321                 public abstract void undo ();
 322         }
 323         [CCode (cheader_filename = "marina.h")]
 324         public abstract class Fetcher : GLib.Object {
 325                 public Model.ClipFile clipfile;
 326                 protected Gst.Element decodebin;
 327                 public string error_string;
 328                 protected Gst.Element filesrc;
 329                 protected Gst.Pipeline pipeline;
 330                 public Fetcher ();
 331                 protected void do_error (string error);
 332                 protected void on_error (Gst.Bus bus, Gst.Message message);
 333                 protected abstract void on_pad_added (Gst.Pad pad);
 334                 protected abstract void on_state_change (Gst.Bus bus, Gst.Message message);
 335                 protected void on_warning (Gst.Bus bus, Gst.Message message);
 336                 public signal void ready (Model.Fetcher fetcher);
 337         }
 338         [CCode (ref_function = "model_fetcher_completion_ref", unref_function = "model_fetcher_completion_unref", cheader_filename = "marina.h")]
 339         public class FetcherCompletion {
 340                 public FetcherCompletion ();
 341                 public virtual void complete (Model.Fetcher fetcher);
 342         }
 343         [CCode (ref_function = "model_gap_ref", unref_function = "model_gap_unref", cheader_filename = "marina.h")]
 344         public class Gap {
 345                 public int64 end;
 346                 public int64 start;
 347                 public Gap (int64 start, int64 end);
 348                 public Model.Gap intersect (Model.Gap g);
 349                 public bool is_empty ();
 350         }
 351         [CCode (cheader_filename = "marina.h")]
 352         public class LibraryImporter : GLib.Object {
 353                 public Model.ClipImporter importer;
 354                 protected Model.Project project;
 355                 public LibraryImporter (Model.Project p);
 356                 public void add_file (string filename) throws GLib.Error;
 357                 protected virtual void append_existing_clipfile (Model.ClipFile f);
 358                 protected virtual void on_clip_complete (Model.ClipFile f);
 359                 public void start () throws GLib.Error;
 360                 public signal void started (Model.ClipImporter i, int num);
 361         }
 362         [CCode (cheader_filename = "marina.h")]
 363         public class LoaderHandler : GLib.Object {
 364                 public LoaderHandler ();
 365                 public virtual bool commit_click (string[] attr_names, string[] attr_values);
 366                 public virtual bool commit_clip (string[] attr_names, string[] attr_values);
 367                 public virtual bool commit_clipfile (string[] attr_names, string[] attr_values);
 368                 public virtual bool commit_library (string[] attr_names, string[] attr_values);
 369                 public virtual bool commit_library_preference (string[] attr_names, string[] attr_values);
 370                 public virtual bool commit_marina (string[] attr_names, string[] attr_values);
 371                 public virtual bool commit_tempo_entry (string[] attr_names, string[] attr_values);
 372                 public virtual bool commit_time_signature_entry (string[] attr_names, string[] attr_values);
 373                 public virtual bool commit_track (string[] attr_names, string[] attr_values);
 374                 public virtual void leave_clip ();
 375                 public virtual void leave_clipfile ();
 376                 public virtual void leave_library ();
 377                 public virtual void leave_marina ();
 378                 public virtual void leave_track ();
 379                 public signal void complete ();
 380                 public signal void load_error (string error_message);
 381         }
 382         [CCode (cheader_filename = "marina.h")]
 383         public class MediaLoaderHandler : Model.LoaderHandler {
 384                 protected Model.Track current_track;
 385                 protected weak Model.Project the_project;
 386                 public MediaLoaderHandler (Model.Project the_project);
 387                 public override bool commit_click (string[] attr_names, string[] attr_values);
 388                 public override bool commit_clip (string[] attr_names, string[] attr_values);
 389                 public override bool commit_clipfile (string[] attr_names, string[] attr_values);
 390                 public override bool commit_library (string[] attr_names, string[] attr_values);
 391                 public override bool commit_library_preference (string[] attr_names, string[] attr_values);
 392                 public override bool commit_marina (string[] attr_names, string[] attr_values);
 393                 public override bool commit_tempo_entry (string[] attr_names, string[] attr_values);
 394                 public override bool commit_time_signature_entry (string[] attr_names, string[] attr_values);
 395                 public override bool commit_track (string[] attr_names, string[] attr_values);
 396                 public override void leave_library ();
 397                 public override void leave_track ();
 398         }
 399         [CCode (cheader_filename = "marina.h")]
 400         public class ParameterCommand : Model.Command {
 401                 public ParameterCommand (Model.AudioTrack target, Model.Parameter parameter, double new_value, double old_value);
 402                 public override void apply ();
 403                 public override string description ();
 404                 public override bool merge (Model.Command command);
 405                 public override void undo ();
 406         }
 407         [CCode (cheader_filename = "marina.h")]
 408         public abstract class Project : Model.TempoInformation, GLib.Object {
 409                 public static Fraction INVALID_FRAME_RATE;
 410                 public bool click_during_play;
 411                 public bool click_during_record;
 412                 public double click_volume;
 413                 protected Gee.ArrayList<Model.ClipFile> clipfiles;
 414                 public Fraction default_framerate;
 415                 public Model.LibraryImporter importer;
 416                 public Gee.ArrayList<Model.Track> inactive_tracks;
 417                 public bool library_visible;
 418                 public int library_width;
 419                 public Model.ProjectLoader loader;
 420                 public View.MediaEngine media_engine;
 421                 protected string project_file;
 422                 public bool snap_to_clip;
 423                 public Gee.ArrayList<Model.Track> tracks;
 424                 public Model.UndoManager undo_manager;
 425                 public const string FILLMORE_FILE_EXTENSION;
 426                 public const string FILLMORE_FILE_FILTER;
 427                 public const string LOMBARD_FILE_EXTENSION;
 428                 public const string LOMBARD_FILE_FILTER;
 429                 public const string[] authors;
 430                 public Project (string? filename, bool include_video) throws GLib.Error;
 431                 public void _add_clipfile (Model.ClipFile clipfile) throws GLib.Error;
 432                 public void _remove_clipfile (Model.ClipFile cf);
 433                 public void _set_bpm (int bpm);
 434                 public void _set_time_signature (Fraction time_signature);
 435                 public void add (Model.Track track, Model.ClipFile clipfile, int64 time);
 436                 public void add_clipfile (Model.ClipFile clipfile);
 437                 public void add_inactive_track (Model.Track track);
 438                 public virtual void add_track (Model.Track track);
 439                 public void append (Model.Track track, Model.ClipFile clipfile);
 440                 public bool can_delete_gap (Model.Gap gap);
 441                 public bool can_export ();
 442                 public bool can_trim (out bool left);
 443                 public void clear ();
 444                 public bool clipfile_on_track (string filename);
 445                 public void close ();
 446                 public void create_clip_fetcher (Model.FetcherCompletion fetcher_completion, string filename) throws GLib.Error;
 447                 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);
 448                 public void delete_gap (Model.Gap gap);
 449                 protected virtual void do_append (Model.Track track, Model.ClipFile clipfile, string name, int64 insert_time);
 450                 public void do_command (Model.Command the_command);
 451                 public Model.AudioTrack? find_audio_track ();
 452                 public Model.ClipFile? find_clipfile (string filename);
 453                 public Model.VideoTrack? find_video_track ();
 454                 public abstract string get_app_name ();
 455                 public string get_audio_path ();
 456                 public abstract TimeCode get_clip_time (Model.ClipFile f);
 457                 public Model.ClipFile? get_clipfile (int index);
 458                 public int get_clipfile_index (Model.ClipFile find);
 459                 public string get_file_display_name ();
 460                 public int get_file_version ();
 461                 public int64 get_length ();
 462                 public string get_license ();
 463                 public virtual string? get_project_file ();
 464                 public string get_version ();
 465                 public void go_end ();
 466                 public void go_next ();
 467                 public void go_previous ();
 468                 public void go_start ();
 469                 public virtual void insert_track (int index, Model.Track track);
 470                 public bool is_duplicate_track_name (Model.Track? track, string new_name);
 471                 public bool is_project_extension (string filename);
 472                 public virtual void load (string? fname);
 473                 public void on_clip_removed (Model.Track t, Model.Clip clip);
 474                 public void on_error_occurred (string major_error, string? minor_error);
 475                 public void on_importer_clip_complete (Model.ClipFetcher fetcher);
 476                 public void on_load_started (string filename);
 477                 public void on_playstate_changed ();
 478                 public bool playhead_on_clip ();
 479                 public bool playhead_on_contiguous_clip ();
 480                 public void print_graph (Gst.Bin bin, string file_name);
 481                 public void remove_clipfile (string filename);
 482                 public void remove_track (Model.Track track);
 483                 public void remove_track_at (int index);
 484                 public void reseek ();
 485                 public virtual void save (string? filename);
 486                 public void save_library (GLib.FileStream f);
 487                 public void set_bpm (int bpm);
 488                 public void set_default_framerate (Fraction rate);
 489                 public void set_name (string? filename);
 490                 public void set_time_signature (Fraction time_signature);
 491                 public int64 snap_clip (Model.Clip c, int64 span);
 492                 public void snap_coord (out int64 coord, int64 span);
 493                 public void split_at_playhead ();
 494                 public Model.Track? track_from_clip (Model.Clip clip);
 495                 public int64 transport_get_position ();
 496                 public void transport_go (int64 position);
 497                 public bool transport_is_playing ();
 498                 public bool transport_is_recording ();
 499                 public void trim_to_playhead ();
 500                 public void undo ();
 501                 public signal void cleared ();
 502                 public signal void clipfile_added (Model.ClipFile c);
 503                 public signal void clipfile_removed (Model.ClipFile clip_file);
 504                 public signal void closed ();
 505                 public signal void error_occurred (string major_message, string? minor_message);
 506                 public virtual signal void load_complete ();
 507                 public signal void load_error (string error);
 508                 public signal void name_changed (string? project_file);
 509                 public signal void playstate_changed (PlayState playstate);
 510                 public signal void track_added (Model.Track track);
 511                 public signal void track_removed (Model.Track track);
 512         }
 513         [CCode (cheader_filename = "marina.h")]
 514         public class ProjectLoader : GLib.Object {
 515                 public ProjectLoader (Model.LoaderHandler loader_handler, string? file_name);
 516                 public void load ();
 517                 public signal void load_complete ();
 518                 public signal void load_error (string error);
 519                 public signal void load_started (string filename);
 520         }
 521         [CCode (cheader_filename = "marina.h")]
 522         public class ThumbnailFetcher : Model.Fetcher {
 523                 public ThumbnailFetcher (Model.ClipFile f, int64 time) throws GLib.Error;
 524                 protected override void on_pad_added (Gst.Pad pad);
 525                 protected override void on_state_change (Gst.Bus bus, Gst.Message message);
 526         }
 527         [CCode (cheader_filename = "marina.h")]
 528         public class TimeSignatureCommand : Model.Command {
 529                 public TimeSignatureCommand (Model.Project project, Fraction new_time_signature);
 530                 public override void apply ();
 531                 public override string description ();
 532                 public override bool merge (Model.Command command);
 533                 public override void undo ();
 534         }
 535         [CCode (cheader_filename = "marina.h")]
 536         public abstract class TimeSystemBase : GLib.Object {
 537                 public float pixel_percentage;
 538                 public int64 pixel_snap_time;
 539                 public float pixels_per_second;
 540                 public const int PIXEL_SNAP_INTERVAL;
 541                 public TimeSystemBase ();
 542                 protected int correct_seconds_value (float seconds, int div, int fps);
 543                 public float get_pixel_percentage ();
 544                 public int64 get_pixel_snap_time ();
 545                 public int time_to_xpos (int64 time);
 546                 public int time_to_xsize (int64 time);
 547                 public int64 xpos_to_time (int x);
 548                 public int64 xsize_to_time (int size);
 549         }
 550         [CCode (cheader_filename = "marina.h")]
 551         public class TimecodeTimeSystem : Model.TimeSystem, Model.TimeSystemBase {
 552                 public Fraction frame_rate_fraction;
 553                 public TimecodeTimeSystem ();
 554         }
 555         [CCode (cheader_filename = "marina.h")]
 556         public class TimelineImporter : Model.LibraryImporter {
 557                 public TimelineImporter (Model.Track track, Model.Project p, int64 time_to_add, bool both_tracks);
 558                 protected override void append_existing_clipfile (Model.ClipFile f);
 559                 protected override void on_clip_complete (Model.ClipFile f);
 560         }
 561         [CCode (cheader_filename = "marina.h")]
 562         public abstract class Track : GLib.Object {
 563                 public Gee.ArrayList<Model.Clip> clips;
 564                 public string display_name;
 565                 protected weak Model.Project project;
 566                 public Track (Model.Project project, string display_name);
 567                 public void _append_at_time (Model.Clip c, int64 time, bool select);
 568                 public void _delete_clip (Model.Clip clip);
 569                 public void _join (int64 position);
 570                 public void _move (Model.Clip c, int64 pos);
 571                 public void _revert_to_original (Model.Clip c);
 572                 public void _split_at (int64 position);
 573                 public void _trim (Model.Clip clip, int64 delta, Gdk.WindowEdge edge);
 574                 public void add (Model.Clip c, int64 pos, bool select);
 575                 public void append_at_time (Model.Clip c, int64 time, bool select);
 576                 public bool are_contiguous_clips (int64 position);
 577                 protected abstract bool check (Model.Clip clip);
 578                 public bool clip_is_near (Model.Clip clip, int64 range, out int64 adjustment);
 579                 public bool contains_clipfile (Model.ClipFile f);
 580                 public void delete_all_clips ();
 581                 public void delete_clip (Model.Clip clip);
 582                 public void delete_gap (Model.Gap g);
 583                 public void do_clip_paste (Model.Clip clip, int64 position);
 584                 public void find_containing_gap (int64 time, out Model.Gap g);
 585                 public Model.Gap find_first_gap (int64 start);
 586                 public Model.Clip? find_nearest_clip_edge (int64 time, out bool after);
 587                 public Model.Clip? find_overlapping_clip (int64 start, int64 length);
 588                 public Model.Clip? get_clip (int i);
 589                 public Model.Clip? get_clip_by_position (int64 pos);
 590                 public int get_clip_index (Model.Clip c);
 591                 public string get_display_name ();
 592                 public bool get_is_selected ();
 593                 public int64 get_length ();
 594                 public int64 get_time_from_pos (Model.Clip clip, bool after);
 595                 public void hide ();
 596                 public void join (int64 position);
 597                 public abstract Model.MediaType media_type ();
 598                 public void move (Model.Clip c, int64 pos, int64 original_time);
 599                 protected abstract string name ();
 600                 public int64 next_edit (int64 pos);
 601                 public virtual void on_clip_updated (Model.Clip clip);
 602                 public int64 previous_edit (int64 pos);
 603                 public void remove_clip_from_array (Model.Clip pos);
 604                 public void revert_to_original (Model.Clip clip);
 605                 public void save (GLib.FileStream f);
 606                 public void set_display_name (string new_display_name);
 607                 public void set_selected (bool is_selected);
 608                 public int64 snap_clip (Model.Clip c, int64 span);
 609                 public bool snap_coord (out int64 coord, int64 span);
 610                 public void split_at (int64 position);
 611                 public void trim (Model.Clip clip, int64 delta, Gdk.WindowEdge edge);
 612                 public virtual void write_attributes (GLib.FileStream f);
 613                 public signal void clip_added (Model.Clip clip, bool select);
 614                 public signal void clip_removed (Model.Clip clip);
 615                 public signal void error_occurred (string major_error, string? minor_error);
 616                 public signal void track_hidden (Model.Track track);
 617                 public signal void track_removed (Model.Track track);
 618                 public signal void track_renamed (Model.Track track);
 619                 public signal void track_selection_changed (Model.Track track);
 620         }
 621         [CCode (cheader_filename = "marina.h")]
 622         public class TransactionCommand : Model.Command {
 623                 public TransactionCommand (bool open, string transaction_description);
 624                 public override void apply ();
 625                 public override string description ();
 626                 public bool in_transaction ();
 627                 public override bool merge (Model.Command command);
 628                 public override void undo ();
 629         }
 630         [CCode (ref_function = "model_undo_manager_ref", unref_function = "model_undo_manager_unref", cheader_filename = "marina.h")]
 631         public class UndoManager {
 632                 public UndoManager ();
 633                 public void do_command (Model.Command the_command);
 634                 public void end_transaction (string description);
 635                 public string get_undo_title ();
 636                 public void mark_clean ();
 637                 public void reset ();
 638                 public void start_transaction (string description);
 639                 public void undo ();
 640                 public bool can_undo { get; }
 641                 public bool in_undo { get; set; }
 642                 public bool is_dirty { get; }
 643                 public signal void dirty_changed (bool is_dirty);
 644                 public signal void undo_changed (bool can_undo);
 645         }
 646         [CCode (cheader_filename = "marina.h")]
 647         public class VideoTrack : Model.Track {
 648                 public VideoTrack (Model.Project project);
 649                 protected override bool check (Model.Clip clip);
 650                 public int get_current_frame (int64 time);
 651                 public bool get_framerate (out Fraction rate);
 652                 public override Model.MediaType media_type ();
 653                 protected override string name ();
 654                 public int64 next_frame (int64 position);
 655                 public int64 previous_frame (int64 position);
 656         }
 657         [CCode (ref_function = "model_xml_element_ref", unref_function = "model_xml_element_unref", cheader_filename = "marina.h")]
 658         public class XmlElement {
 659                 public string[] attribute_names;
 660                 public string[] attribute_values;
 661                 public XmlElement (string name, string[] attribute_names, string[] attribute_values, Model.XmlElement? parent);
 662                 public void add_child (Model.XmlElement child_element);
 663                 public Gee.ArrayList<Model.XmlElement> children { get; }
 664                 public string name { get; set; }
 665                 public Model.XmlElement? parent { get; set; }
 666         }
 667         [CCode (ref_function = "model_xml_tree_loader_ref", unref_function = "model_xml_tree_loader_unref", cheader_filename = "marina.h")]
 668         public class XmlTreeLoader {
 669                 public Model.XmlElement root;
 670                 public XmlTreeLoader (string document);
 671         }
 672         [CCode (cheader_filename = "marina.h")]
 673         public interface TempoInformation {
 674                 public abstract int get_bpm ();
 675                 public abstract Fraction get_time_signature ();
 676                 public signal void bpm_changed (int bpm);
 677                 public signal void time_signature_changed (Fraction time_signature);
 678         }
 679         [CCode (cheader_filename = "marina.h")]
 680         public interface TimeSystem : GLib.Object {
 681                 public abstract void calculate_pixel_step (float inc, float pixel_min, float pixel_div);
 682                 public abstract int frame_to_xsize (int frame);
 683                 public abstract string? get_display_string (int token);
 684                 public abstract int get_next_position (int token);
 685                 public abstract int get_pixel_height (int token);
 686                 public abstract float get_pixel_percentage ();
 687                 public abstract int64 get_pixel_snap_time ();
 688                 public abstract int get_start_token (int xsize);
 689                 public abstract string get_time_duration (int64 time);
 690                 public abstract string get_time_string (int64 time);
 691                 public abstract int time_to_xpos (int64 time);
 692                 public abstract int time_to_xsize (int64 time);
 693                 public abstract int64 xpos_to_time (int x);
 694                 public abstract int xsize_to_frame (int xsize);
 695                 public abstract int64 xsize_to_time (int x);
 696                 public signal void geometry_changed ();
 697         }
 698         [CCode (cprefix = "MODEL_MEDIA_TYPE_", cheader_filename = "marina.h")]
 699         public enum MediaType {
 700                 AUDIO,
 701                 VIDEO
 702         }
 703         [CCode (cprefix = "MODEL_PARAMETER_", cheader_filename = "marina.h")]
 704         public enum Parameter {
 705                 PAN,
 706                 VOLUME
 707         }
 708 }
 709 [CCode (cprefix = "DialogUtils", lower_case_cprefix = "dialog_utils_")]
 710 namespace DialogUtils {
 711         [CCode (type_id = "DIALOG_UTILS_TYPE_FILTER_DESCRIPTION_STRUCT", cheader_filename = "marina.h")]
 712         public struct filter_description_struct {
 713                 public string name;
 714                 public string extension;
 715         }
 716         [CCode (cheader_filename = "marina.h")]
 717         public static Gtk.ResponseType add_cancel (string message);
 718         [CCode (cheader_filename = "marina.h")]
 719         public static bool confirm_replace (Gtk.Window? parent, string filename);
 720         [CCode (cheader_filename = "marina.h")]
 721         public static Gtk.ResponseType delete_cancel (string message);
 722         [CCode (cheader_filename = "marina.h")]
 723         public static Gtk.ResponseType delete_keep (string message);
 724         [CCode (cheader_filename = "marina.h")]
 725         public static void error (string major_message, string? minor_message);
 726         [CCode (cheader_filename = "marina.h")]
 727         public static bool open (Gtk.Window parent, DialogUtils.filter_description_struct[] filter_descriptions, bool allow_multiple, bool allow_all, out GLib.SList<string> filenames);
 728         [CCode (cheader_filename = "marina.h")]
 729         public static bool save (Gtk.Window parent, string title, bool create_directory, DialogUtils.filter_description_struct[] filter_descriptions, ref string filename);
 730         [CCode (cheader_filename = "marina.h")]
 731         public static Gtk.ResponseType save_close_cancel (Gtk.Window? parent, string? title, string message);
 732         [CCode (cheader_filename = "marina.h")]
 733         public static void show_clip_properties (Gtk.Window parent, ClipView? selected_clip, Model.ClipFile? clip_file, Fraction? frames_per_second);
 734         [CCode (cheader_filename = "marina.h")]
 735         public static void warning (string major_message, string? minor_message);
 736 }
 737 [CCode (cprefix = "Logging", lower_case_cprefix = "logging_")]
 738 namespace Logging {
 739         [CCode (cprefix = "LOGGING_FACILITY_", cheader_filename = "marina.h")]
 740         public enum Facility {
 741                 SIGNAL_HANDLERS,
 742                 DEVELOPER_WARNINGS,
 743                 GRAPH,
 744                 LOADING,
 745                 IMPORT,
 746                 SINGLEDECODEBIN
 747         }
 748         [CCode (cprefix = "LOGGING_LEVEL_", cheader_filename = "marina.h")]
 749         public enum Level {
 750                 CRITICAL,
 751                 HIGH,
 752                 MEDIUM,
 753                 LOW,
 754                 INFO,
 755                 VERBOSE
 756         }
 757         [CCode (cheader_filename = "marina.h")]
 758         public static void emit (GLib.Object object, Logging.Facility facility, Logging.Level level, string message);
 759         [CCode (cheader_filename = "marina.h")]
 760         public static void set_logging_level (Logging.Level new_level);
 761 }
 762 [CCode (cprefix = "PLAY_STATE_", cheader_filename = "marina.h")]
 763 public enum PlayState {
 764         STOPPED,
 765         PRE_PLAY,
 766         PLAYING,
 767         PRE_RECORD_NULL,
 768         PRE_RECORD,
 769         RECORDING,
 770         POST_RECORD,
 771         PRE_EXPORT,
 772         EXPORTING,
 773         CANCEL_EXPORT,
 774         LOADING,
 775         CLOSING,
 776         CLOSED
 777 }
 778 [CCode (cprefix = "GDK_", has_type_id = false, cheader_filename = "gdk/gdkkeysyms.h")]
 779 public enum KeySyms {
 780         Control_L,
 781         Control_R,
 782         Down,
 783         equal,
 784         Escape,
 785         KP_Add,
 786         KP_Enter,
 787         KP_Subtract,
 788         Left,
 789         minus,
 790         plus,
 791         Return,
 792         Right,
 793         Shift_L,
 794         Shift_R,
 795         underscore,
 796         Up
 797 }
 798 [CCode (cprefix = "MEDIA_ERROR_", cheader_filename = "marina.h")]
 799 public errordomain MediaError {
 800         MISSING_PLUGIN,
 801 }
 802 [CCode (ref_function = "app_dirs_ref", unref_function = "app_dirs_unref", cheader_filename = "marina.h")]
 803 public class AppDirs {
 804         public AppDirs ();
 805         public static GLib.File get_exec_dir ();
 806         public static GLib.File get_resources_dir ();
 807         public static void init (string arg0, string program_name);
 808         public static void terminate ();
 809 }
 810 [CCode (ref_function = "class_factory_ref", unref_function = "class_factory_unref", cheader_filename = "marina.h")]
 811 public class ClassFactory {
 812         public ClassFactory ();
 813         public static ClassFactory get_class_factory ();
 814         public virtual TrackView get_track_view (Model.Track track, TimeLine timeline);
 815         public static void set_class_factory (ClassFactory class_factory);
 816         public static void set_transport_delegate (TransportDelegate transport_delegate);
 817 }
 818 [CCode (cheader_filename = "marina.h")]
 819 public class ClipLibraryView : Gtk.EventBox {
 820         public static Gtk.Menu context_menu;
 821         public ClipLibraryView (Model.Project p, Model.TimeSystem time_provider, string? drag_message, Gdk.DragAction actions);
 822         public void delete_selection ();
 823         public override void drag_data_received (Gdk.DragContext context, int x, int y, Gtk.SelectionData selection_data, uint drag_info, uint time);
 824         public Gee.ArrayList<string> get_selected_files ();
 825         public bool has_selection ();
 826         public void on_clipfile_removed (Model.ClipFile f);
 827         public void select_all ();
 828         public void unselect_all ();
 829         public signal void selection_changed (bool selected);
 830 }
 831 [CCode (cheader_filename = "marina.h")]
 832 public class MultiFileProgress : Gtk.Window {
 833         public MultiFileProgress (Gtk.Window parent, int num_files, string dialog_title, MultiFileProgressInterface provider);
 834 }
 835 [CCode (ref_function = "track_clip_pair_ref", unref_function = "track_clip_pair_unref", cheader_filename = "marina.h")]
 836 public class TrackClipPair {
 837         public Model.Clip clip;
 838         public Model.Track track;
 839         public TrackClipPair (Model.Track track, Model.Clip clip);
 840 }
 841 [CCode (ref_function = "clipboard_ref", unref_function = "clipboard_unref", cheader_filename = "marina.h")]
 842 public class Clipboard {
 843         public Gee.ArrayList<TrackClipPair> clips;
 844         public Clipboard ();
 845         public void paste (Model.Track selected_track, int64 time);
 846         public void select (Gee.ArrayList<ClipView> selected_clips);
 847 }
 848 [CCode (cheader_filename = "marina.h")]
 849 public class TimeLine : Gtk.EventBox {
 850         public Clipboard clipboard;
 851         public Model.Project project;
 852         public weak Model.TimeSystem provider;
 853         public View.Ruler ruler;
 854         public Gee.ArrayList<ClipView> selected_clips;
 855         public Gee.ArrayList<TrackView> tracks;
 856         public const int BAR_HEIGHT;
 857         public const int BORDER;
 858         public const int RULER_HEIGHT;
 859         public TimeLine (Model.Project p, Model.TimeSystem provider, Gdk.DragAction actions);
 860         public override bool button_press_event (Gdk.EventButton event);
 861         public override bool button_release_event (Gdk.EventButton event);
 862         public void delete_selection ();
 863         public void deselect_all_clips ();
 864         public void do_clip_move (ClipView clip_view, int64 delta);
 865         public void do_copy ();
 866         public void do_cut ();
 867         public void do_paste (int64 pos);
 868         public override void drag_data_received (Gdk.DragContext context, int x, int y, Gtk.SelectionData selection_data, uint drag_info, uint time);
 869         public override bool expose_event (Gdk.EventExpose event);
 870         public Gtk.Widget? find_child (double x, double y);
 871         public bool gap_selected ();
 872         public bool is_clip_selected ();
 873         public override bool motion_notify_event (Gdk.EventMotion event);
 874         public void on_clip_view_added (ClipView clip_view);
 875         public void on_ruler_position_changed (int x);
 876         public void paste ();
 877         public void select_all ();
 878         public void update_pos (int event_x);
 879         public void zoom (float inc);
 880         public void zoom_to_project (double width);
 881         public signal void selection_changed (bool selected);
 882         public signal void track_changed ();
 883         public signal void trackview_added (TrackView trackview);
 884         public signal void trackview_removed (TrackView trackview);
 885 }
 886 [CCode (cheader_filename = "marina.h")]
 887 public class GapView : Gtk.DrawingArea {
 888         public Model.Gap gap;
 889         public GapView (int64 start, int64 length, int width, int height);
 890         public override bool expose_event (Gdk.EventExpose e);
 891         public void remove ();
 892         public void unselect ();
 893         public signal void removed (GapView gap_view);
 894         public signal void unselected (GapView gap_view);
 895 }
 896 [CCode (cheader_filename = "marina.h")]
 897 public class ClipView : Gtk.DrawingArea {
 898         public Model.Clip clip;
 899         public static Gtk.Menu context_menu;
 900         public int height;
 901         public int64 initial_time;
 902         public bool is_selected;
 903         public const int SNAP_DELTA;
 904         public ClipView (TransportDelegate transport_delegate, Model.Clip clip, Model.TimeSystem time_provider, int height);
 905         public void adjust_size (int height);
 906         public override bool button_press_event (Gdk.EventButton event);
 907         public override bool button_release_event (Gdk.EventButton event);
 908         public void delete_clip ();
 909         public void draw ();
 910         public override bool expose_event (Gdk.EventExpose event);
 911         public override bool motion_notify_event (Gdk.EventMotion event);
 912         public void on_clip_moved (Model.Clip clip);
 913         public void select ();
 914         public void snap (int64 amount);
 915         public signal void clip_deleted (Model.Clip clip);
 916         public signal void clip_moved (ClipView clip);
 917         public signal void move_begin (ClipView clip_view, bool copy);
 918         public signal void move_commit (ClipView clip_view, int64 delta);
 919         public signal void move_request (ClipView clip_view, int64 delta);
 920         public signal void selection_request (ClipView clip_view, bool extend_selection);
 921         public signal void trim_begin (ClipView clip_view, Gdk.WindowEdge edge);
 922         public signal void trim_commit (ClipView clip_view, Gdk.WindowEdge edge);
 923 }
 924 [CCode (cheader_filename = "marina.h")]
 925 public interface TrackView : Gtk.Widget {
 926         public abstract Gtk.Widget? find_child (double x, double y);
 927         public abstract Model.Track get_track ();
 928         public abstract int get_track_height ();
 929         public abstract void move_to_top (ClipView clip_view);
 930         public abstract void resize ();
 931         public abstract void select_all ();
 932         public signal void clip_view_added (ClipView clip_view);
 933 }
 934 [CCode (cheader_filename = "marina.h")]
 935 public interface MultiFileProgressInterface : GLib.Object {
 936         public abstract void cancel ();
 937         public abstract void complete ();
 938         public signal void done ();
 939         public signal void file_updated (string filename, int index);
 940         public signal void fraction_updated (double d);
 941 }
 942 [CCode (cheader_filename = "marina.h")]
 943 public interface TransportDelegate : GLib.Object {
 944         public abstract bool is_playing ();
 945         public abstract bool is_recording ();
 946         public abstract bool is_stopped ();
 947 }
 948 [CCode (type_id = "TYPE_FRACTION", cheader_filename = "marina.h")]
 949 public struct Fraction {
 950         public int numerator;
 951         public int denominator;
 952         public Fraction (int numerator, int denominator);
 953         public bool equal (Fraction f);
 954         public Fraction.from_string (string s);
 955         public int nearest_int ();
 956         public string to_string ();
 957 }
 958 [CCode (type_id = "TYPE_TIME_CODE", cheader_filename = "marina.h")]
 959 public struct TimeCode {
 960         public int hour;
 961         public int minute;
 962         public int second;
 963         public int frame;
 964         public bool drop_code;
 965         public void get_from_length (int64 length);
 966         public string to_string ();
 967 }
 968 [CCode (cheader_filename = "marina.h")]
 969 public const int CHANNELS_PER_TRACK_PLAYBACK;
 970 [CCode (cheader_filename = "marina.h")]
 971 public const int CHANNELS_PER_TRACK_RECORD;
 972 [CCode (cheader_filename = "marina.h")]
 973 public const Gtk.TargetEntry[] drag_target_entries;
 974 [CCode (cheader_filename = "marina.h")]
 975 public static bool debug_enabled;
 976 [CCode (cheader_filename = "marina.h")]
 977 public static Gdk.ModifierType GDK_SHIFT_ALT_CONTROL_MASK;
 978 [CCode (cheader_filename = "marina.h")]
 979 public static float float_abs (float f);
 980 [CCode (cheader_filename = "marina.h")]
 981 public static bool float_within (double f, double epsilon);
 982 [CCode (cheader_filename = "marina.h")]
 983 public static int sign (int x);
 984 [CCode (cheader_filename = "marina.h")]
 985 public static string[] copy_array (string[] source);
 986 [CCode (cheader_filename = "marina.h")]
 987 public static void print_debug (string text);
 988 [CCode (cheader_filename = "marina.h")]
 989 public static bool time_in_range (int64 time, int64 center, int64 delta);
 990 [CCode (cheader_filename = "marina.h")]
 991 public static string isolate_filename (string path);
 992 [CCode (cheader_filename = "marina.h")]
 993 public static string get_file_extension (string path);
 994 [CCode (cheader_filename = "marina.h")]
 995 public static string append_extension (string path, string extension);
 996 [CCode (cheader_filename = "marina.h")]
 997 public static bool version_at_least (string v, string w);
 998 [CCode (cheader_filename = "marina.h")]
 999 public static bool get_file_md5_checksum (string filename, out string checksum);
1000 [CCode (cheader_filename = "marina.h")]
1001 public static void save_file_md5_checksum (string filename, string checksum);
1002 [CCode (cheader_filename = "marina.h")]
1003 public static bool md5_checksum_on_file (string filename, out string checksum);
1004 [CCode (cheader_filename = "marina.h")]
1005 public static Gdk.Color parse_color (string color);
1006 [CCode (cheader_filename = "marina.h")]
1007 public static Gtk.Widget get_widget (Gtk.UIManager manager, string name);
1008 [CCode (cheader_filename = "marina.h")]
1009 public static void draw_rounded_rectangle (Gdk.Window window, Gdk.Color color, bool filled, int x0, int y0, int width, int height);
1010 [CCode (cheader_filename = "marina.h")]
1011 public static void draw_right_rounded_rectangle (Gdk.Window window, Gdk.Color color, bool filled, int x0, int y0, int width, int height);
1012 [CCode (cheader_filename = "marina.h")]
1013 public static void draw_left_rounded_rectangle (Gdk.Window window, Gdk.Color color, bool filled, int x0, int y0, int width, int height);
1014 [CCode (cheader_filename = "marina.h")]
1015 public static void draw_square_rectangle (Gdk.Window window, Gdk.Color color, bool filled, int x, int y, int width, int height);
1016 [CCode (cheader_filename = "marina.h")]
1017 public static bool is_drop_frame_rate (Fraction r);
1018 [CCode (cheader_filename = "marina.h")]
1019 public static int64 frame_to_time_with_rate (int frame, Fraction rate);
1020 [CCode (cheader_filename = "marina.h")]
1021 public static int time_to_frame_with_rate (int64 time, Fraction rate);
1022 [CCode (cheader_filename = "marina.h")]
1023 public static TimeCode frame_to_time (int frame, Fraction rate);
1024 [CCode (cheader_filename = "marina.h")]
1025 public static string frame_to_string (int frame, Fraction rate);
1026 [CCode (cheader_filename = "marina.h")]
1027 public static string time_to_HHMMSS (int64 time);
1028 [CCode (cheader_filename = "marina.h")]
1029 public static string time_to_string (int64 time);
1030 [CCode (cheader_filename = "marina.h")]
1031 public static Gst.Element make_element_with_name (string element_name, string? display_name) throws GLib.Error;
1032 [CCode (cheader_filename = "marina.h")]
1033 public static Gst.Element make_element (string name) throws GLib.Error;