BSE: migrate all Project methods into bseapi.idl
authorTim Janik <timj@gnu.org>
Tue, 31 May 2016 14:11:15 +0000 (16:11 +0200)
committerTim Janik <timj@gnu.org>
Wed, 12 Oct 2016 23:10:43 +0000 (01:10 +0200)
Signed-off-by: Tim Janik <timj@gnu.org>
bse/Makefile.am
bse/bseapi.idl
bse/bseproject.cc
bse/bseproject.hh
bse/bseproject.proc [deleted file]

index 95e249b..994ed58 100644 (file)
@@ -116,7 +116,7 @@ idl_dummy_files = $(strip   \
 # BSE procedure sources
 bse_proc_sources = $(strip \
        bseeditablesample.proc  \
-       bsejanitor.proc                                                         bseproject.proc         \
+       bsejanitor.proc         \
                                                                                bsesource.proc          \
                                bseitem.proc                                    bsewaveosc.proc         \
 )
index 68edcc6..0379f34 100644 (file)
@@ -850,13 +850,13 @@ interface Project : Container {
   void         clean_dirty         (); ///< Clear a project's dirty flags.
   bool         is_dirty            (); ///< Check whether a project needs saving.
   SuperSeq     get_supers          (); ///< Retrieve all Super type objects of this project.
-  //Error        store_bse           (Super super, String file_name, bool self_contained);
-  //Song         create_song         (String name); ///< Create a song for this project.
-  //WaveRepo     get_wave_repo       ();            ///< Retrieve the project's unique wave repository.
-  //CSynth       create_csynth       (String name); ///< Create a synthsizer network for this project.
-  //MidiSynth    create_midi_synth   (String name); ///< Create a MIDI synthesizer network for this project.
-  //MidiNotifier get_midi_notifier   ();            ///< Retrieve the project's midi notifier object.
-  //void         remove_snet         (SNet snet);   ///< Remove an existing synthesizer network from this project.
+  Error        store_bse           (Super super, String file_name, bool self_contained);
+  Song         create_song         (String name); ///< Create a song for this project.
+  WaveRepo     get_wave_repo       ();            ///< Retrieve the project's unique wave repository.
+  CSynth       create_csynth       (String name); ///< Create a synthsizer network for this project.
+  MidiSynth    create_midi_synth   (String name); ///< Create a MIDI synthesizer network for this project.
+  MidiNotifier get_midi_notifier   ();            ///< Retrieve the project's midi notifier object.
+  void         remove_snet         (SNet snet);   ///< Remove an existing synthesizer network from this project.
   Error        restore_from_file   (String file_name); ///< Load a project from file.
   /// Inject a MIDI control event into the project's MIDI receiver.
   void         inject_midi_control (int32 midi_channel, int32 midi_control, float64 control_value);
index b102bbe..ef9d37f 100644 (file)
@@ -1,6 +1,6 @@
 // Licensed GNU LGPL v2.1 or later: http://www.gnu.org/licenses/lgpl.html
 #include "bseproject.hh"
-
+#include "bsemidisynth.hh"
 #include "bsesuper.hh"
 #include "bsestorage.hh"
 #include "bsesong.hh"
@@ -1191,4 +1191,122 @@ ProjectImpl::get_supers ()
   return sseq;
 }
 
+void
+ProjectImpl::remove_snet (SNetIface &snet_iface)
+{
+  BseProject *self = as<BseProject*>();
+  SNetImpl &snet = dynamic_cast<SNetImpl&> (snet_iface);
+  assert_return (snet.parent() == this);
+  return_unless (BSE_SOURCE_PREPARED (self) == false);
+  BseItem *child = snet.as<BseItem*>();
+  BseUndoStack *ustack = bse_item_undo_open (self, __func__);
+  // backup object references to undo stack
+  bse_container_uncross_undoable (BSE_CONTAINER (self), child);
+  // implement "undo" of bse_container_remove_backedup, i.e. redo
+  UndoDescriptor<SNetImpl> snet_descriptor = undo_descriptor (snet);
+  auto lambda = [snet_descriptor] (ProjectImpl &self, BseUndoStack *ustack) -> Error {
+    SNetImpl &snet = self.undo_resolve (snet_descriptor);
+    self.remove_snet (snet);
+    return Error::NONE;
+  };
+  push_undo_to_redo (__func__, *this, lambda);
+  // backup and remove (without redo queueing)
+  bse_container_remove_backedup (BSE_CONTAINER (self), child, ustack);
+  // done
+  bse_item_undo_close (ustack);
+}
+
+Error
+ProjectImpl::store_bse (SuperIface &super_iface, const String &file_name, bool self_contained)
+{
+  BseProject *self = as<BseProject*>();
+  SuperImpl *super = dynamic_cast<SuperImpl*> (&super_iface);
+  BseSuper *bsesuper = super ? super->as<BseSuper*>() : NULL;
+  if (super)
+    assert_return (super->parent() == this, Error::INTERNAL);
+  return bse_project_store_bse (self, bsesuper, file_name.c_str(), self_contained);
+}
+
+SongIfaceP
+ProjectImpl::create_song (const String &name)
+{
+  BseProject *self = as<BseProject*>();
+  BseUndoStack *ustack = bse_item_undo_open (self, __func__);
+  BseSong *song = (BseSong*) bse_container_new_child (self, BSE_TYPE_SONG, NULL);
+  if (song)
+    {
+      if (!name.empty())
+        bse_item_set (song, "uname", name.c_str(), NULL);
+      UndoDescriptor<SongImpl> song_descriptor = undo_descriptor (*song->as<SongImpl*>());
+      auto remove_song_lambda = [song_descriptor] (ProjectImpl &self, BseUndoStack *ustack) -> Error {
+        SongImpl &song = self.undo_resolve (song_descriptor);
+        self.remove_snet (song);
+        return Error::NONE;
+      };
+      push_undo (__func__, *this, remove_song_lambda);
+    }
+  bse_item_undo_close (ustack);
+  return song->as<SongIfaceP>();
+}
+
+CSynthIfaceP
+ProjectImpl::create_csynth (const String &name)
+{
+  BseProject *self = as<BseProject*>();
+  BseUndoStack *ustack = bse_item_undo_open (self, __func__);
+  BseCSynth *csynth = (BseCSynth*) bse_container_new_child (self, BSE_TYPE_CSYNTH, NULL);
+  if (csynth)
+    {
+      if (!name.empty())
+        bse_item_set (csynth, "uname", name.c_str(), NULL);
+      UndoDescriptor<CSynthImpl> csynth_descriptor = undo_descriptor (*csynth->as<CSynthImpl*>());
+      auto remove_csynth_lambda = [csynth_descriptor] (ProjectImpl &self, BseUndoStack *ustack) -> Error {
+        CSynthImpl &csynth = self.undo_resolve (csynth_descriptor);
+        self.remove_snet (csynth);
+        return Error::NONE;
+      };
+      push_undo (__func__, *this, remove_csynth_lambda);
+    }
+  bse_item_undo_close (ustack);
+  return csynth->as<CSynthIfaceP>();
+}
+
+MidiSynthIfaceP
+ProjectImpl::create_midi_synth (const String &name)
+{
+  BseProject *self = as<BseProject*>();
+  BseUndoStack *ustack = bse_item_undo_open (self, __func__);
+  BseMidiSynth *midi_synth = (BseMidiSynth*) bse_container_new_child (self, BSE_TYPE_MIDI_SYNTH, NULL);
+  if (midi_synth)
+    {
+      if (!name.empty())
+        bse_item_set (midi_synth, "uname", name.c_str(), NULL);
+      UndoDescriptor<MidiSynthImpl> midi_synth_descriptor = undo_descriptor (*midi_synth->as<MidiSynthImpl*>());
+      auto remove_midi_synth_lambda = [midi_synth_descriptor] (ProjectImpl &self, BseUndoStack *ustack) -> Error {
+        MidiSynthImpl &midi_synth = self.undo_resolve (midi_synth_descriptor);
+        self.remove_snet (midi_synth);
+        return Error::NONE;
+      };
+      push_undo (__func__, *this, remove_midi_synth_lambda);
+    }
+  bse_item_undo_close (ustack);
+  return midi_synth->as<MidiSynthIfaceP>();
+}
+
+WaveRepoIfaceP
+ProjectImpl::get_wave_repo ()
+{
+  BseProject *self = as<BseProject*>();
+  BseWaveRepo *wrepo = bse_project_get_wave_repo (self);
+  return wrepo ? wrepo->as<WaveRepoIfaceP>() : NULL;
+}
+
+MidiNotifierIfaceP
+ProjectImpl::get_midi_notifier ()
+{
+  BseProject *self = as<BseProject*>();
+  BseMidiNotifier *notifier = bse_project_get_midi_notifier (self);
+  return notifier ? notifier->as<MidiNotifierIfaceP>() : NULL;
+}
+
 } // Bse
index 1147b1c..2d6aa28 100644 (file)
@@ -98,6 +98,13 @@ public:
   virtual Error              restore_from_file   (const String &file_name) override;
   virtual ProjectState       get_state           () override;
   virtual SuperSeq           get_supers          () override;
+  virtual Error              store_bse           (SuperIface &super, const String &file_name, bool self_contained) override;
+  virtual SongIfaceP         create_song         (const String &name) override;
+  virtual WaveRepoIfaceP     get_wave_repo       () override;
+  virtual CSynthIfaceP       create_csynth       (const String &name) override;
+  virtual MidiSynthIfaceP    create_midi_synth   (const String &name) override;
+  virtual MidiNotifierIfaceP get_midi_notifier   () override;
+  virtual void               remove_snet         (SNetIface &snet) override;
 };
 
 } // Bse
diff --git a/bse/bseproject.proc b/bse/bseproject.proc
deleted file mode 100644 (file)
index 4e00b72..0000000
+++ /dev/null
@@ -1,259 +0,0 @@
-// Licensed GNU LGPL v2.1 or later: http://www.gnu.org/licenses/lgpl.html
-#include <bse/bseplugin.hh>
-#include <bse/bseprocedure.hh>
-#include <bse/bseproject.hh>
-#include <bse/bsestorage.hh>
-#include <bse/bsesong.hh>
-#include <bse/bseundostack.hh>
-#include <bse/bsewaverepo.hh>
-#include <bse/bsecsynth.hh>
-#include <bse/bsemidisynth.hh>
-#include <bse/bsemidifile.hh>
-#include <bse/bsemidireceiver.hh>
-#include <bse/bsemidinotifier.hh>
-#include <bse/bseengine.hh>
-#include "bsecxxplugin.hh"
-#include "bsebuiltin_externs.cc"
-
-
-AUTHORS = "Tim Janik <timj@gtk.org>";
-LICENSE = "GNU Lesser General Public License";
-
-
-
-METHOD (BseProject, get-midi-notifier) {
-  HELP  = "Retrieve the project's midi notifier object.";
-  IN    = bse_param_spec_object ("project", "Project", NULL, BSE_TYPE_PROJECT, SFI_PARAM_STANDARD);
-  OUT   = bse_param_spec_object ("midi_notifier", NULL, NULL, BSE_TYPE_MIDI_NOTIFIER, SFI_PARAM_STANDARD);
-} BODY (BseProcedureClass *proc,
-        const GValue      *in_values,
-        GValue            *out_values)
-{
-  /* extract parameter values */
-  BseProject *self = (BseProject*) bse_value_get_object (in_values++);
-
-  /* check parameters */
-  if (!BSE_IS_PROJECT (self))
-    return Bse::Error::PROC_PARAM_INVAL;
-
-  BseMidiNotifier *notifier = bse_project_get_midi_notifier (self);
-
-  /* set output parameters */
-  bse_value_set_object (out_values++, G_OBJECT (notifier));
-
-  return Bse::Error::NONE;
-}
-
-
-
-METHOD (BseProject, store-bse, "File/Store") {
-  HELP  = "Save supers of a project into a BSE file. "
-          "If no super is specified, the project itself is stored.";
-  IN    = bse_param_spec_object ("project", "Project", NULL,
-                                 BSE_TYPE_PROJECT, SFI_PARAM_STANDARD);
-  IN    = bse_param_spec_object ("super", "Super", NULL,
-                                 BSE_TYPE_SUPER, SFI_PARAM_STANDARD);
-  IN    = sfi_pspec_string ("file-name", "File", "Destination file name",
-                            NULL, SFI_PARAM_STANDARD);
-  IN    = sfi_pspec_bool ("self-contained", "Self Contained",
-                          "Whether references to other objects (e.g. samples) should "
-                          "be stored or whether to include everything in a self-contained .bse file",
-                          FALSE, SFI_PARAM_STANDARD);
-  OUT   = bse_param_spec_genum ("error", "Error", "Error indicating possible failures",
-                                BSE_TYPE_ERROR_TYPE, Bse::Error::NONE,
-                                SFI_PARAM_STANDARD);
-} BODY (BseProcedureClass *proc,
-        const GValue      *in_values,
-        GValue            *out_values)
-{
-  /* extract parameter values */
-  BseProject *project = (BseProject*) bse_value_get_object (in_values++);
-  BseSuper *super = (BseSuper*) bse_value_get_object (in_values++);
-  const char *file_name = sfi_value_get_string (in_values++);
-  gboolean self_contained = sfi_value_get_bool (in_values++);
-  Bse::Error error;
-
-  /* check parameters */
-  if (!BSE_IS_PROJECT (project) || !file_name)
-    return Bse::Error::PROC_PARAM_INVAL;
-  if (super && BSE_ITEM (super)->parent != BSE_ITEM (project))
-    return Bse::Error::PROC_PARAM_INVAL;
-
-  error = bse_project_store_bse (project, super, file_name, self_contained);
-
-  /* set output parameters */
-  g_value_set_enum (out_values++, int (error));
-
-  return Bse::Error::NONE;
-}
-
-METHOD (BseProject, create-song) {
-  HELP  = "Create a song for this project.";
-  IN    = bse_param_spec_object ("project", "Project", "The project",
-                                 BSE_TYPE_PROJECT, SFI_PARAM_STANDARD);
-  IN    = sfi_pspec_string ("name", "Name", "Song name",
-                            NULL, SFI_PARAM_STANDARD);
-  OUT   = bse_param_spec_object ("song", "Song", "The new song",
-                                 BSE_TYPE_SONG, SFI_PARAM_STANDARD);
-} BODY (BseProcedureClass *proc,
-        const GValue      *in_values,
-        GValue            *out_values)
-{
-  /* extract parameter values */
-  BseContainer *container = (BseContainer*) bse_value_get_object (in_values++);
-  const char *name = sfi_value_get_string (in_values++);
-  BseUndoStack *ustack;
-  BseItem *child;
-
-  /* check parameters */
-  if (!BSE_IS_PROJECT (container))
-    return Bse::Error::PROC_PARAM_INVAL;
-
-  /* action */
-  ustack = bse_item_undo_open (container, "create-song");
-  child = (BseItem*) bse_container_new_child (container, BSE_TYPE_SONG, NULL);
-  if (name)
-    bse_item_set (child, "uname", name, NULL);
-  bse_item_push_undo_proc (container, "remove-snet", child);
-  bse_item_undo_close (ustack);
-
-  /* set output parameters */
-  bse_value_set_object (out_values++, child);
-
-  return Bse::Error::NONE;
-}
-
-METHOD (BseProject, get-wave-repo) {
-  HELP  = "Ensure the project has a wave repository";
-  IN    = bse_param_spec_object ("project", "Project", "The project",
-                                 BSE_TYPE_PROJECT, SFI_PARAM_STANDARD);
-  OUT   = bse_param_spec_object ("wrepo", "Wave Repo", "The project's unique wave repo",
-                                 BSE_TYPE_WAVE_REPO, SFI_PARAM_STANDARD);
-} BODY (BseProcedureClass *proc,
-        const GValue      *in_values,
-        GValue            *out_values)
-{
-  /* extract parameter values */
-  BseProject *project = (BseProject*) bse_value_get_object (in_values++);
-  BseWaveRepo *wrepo = NULL;
-
-  /* check parameters */
-  if (!BSE_IS_PROJECT (project))
-    return Bse::Error::PROC_PARAM_INVAL;
-
-  /* action */
-  wrepo = bse_project_get_wave_repo (project);
-
-  /* set output parameters */
-  bse_value_set_object (out_values++, wrepo);
-
-  return Bse::Error::NONE;
-}
-
-METHOD (BseProject, create-csynth) {
-  HELP  = "Create a synthsizer network for this project.";
-  IN    = bse_param_spec_object ("project", "Project", "The project",
-                                 BSE_TYPE_PROJECT, SFI_PARAM_STANDARD);
-  IN    = sfi_pspec_string ("name", "Name", "Synth network name",
-                            NULL, SFI_PARAM_STANDARD);
-  OUT   = bse_param_spec_object ("csynth", "Synthesizer Network", "New synth network",
-                                 BSE_TYPE_CSYNTH, SFI_PARAM_STANDARD);
-} BODY (BseProcedureClass *proc,
-        const GValue      *in_values,
-        GValue            *out_values)
-{
-  /* extract parameter values */
-  BseContainer *container = (BseContainer*) bse_value_get_object (in_values++);
-  const char *name = sfi_value_get_string (in_values++);
-  BseUndoStack *ustack;
-  BseItem *child;
-
-  /* check parameters */
-  if (!BSE_IS_PROJECT (container))
-    return Bse::Error::PROC_PARAM_INVAL;
-
-  /* action */
-  ustack = bse_item_undo_open (container, "create-csynth");
-  child = (BseItem*) bse_container_new_child (container, BSE_TYPE_CSYNTH, NULL);
-  if (name)
-    bse_item_set (child, "uname", name, NULL);
-  bse_item_push_undo_proc (container, "remove-snet", child);
-  bse_item_undo_close (ustack);
-
-  /* set output parameters */
-  bse_value_set_object (out_values++, child);
-
-  return Bse::Error::NONE;
-}
-
-METHOD (BseProject, create-midi-synth) {
-  HELP  = "Create a MIDI synthesizer network for this project.";
-  IN    = bse_param_spec_object ("project", "Project", "The project",
-                                 BSE_TYPE_PROJECT, SFI_PARAM_STANDARD);
-  IN    = sfi_pspec_string ("name", "Name", "MIDI synth name",
-                            NULL, SFI_PARAM_STANDARD);
-  OUT   = bse_param_spec_object ("midi_synth", "MIDI Synthesizer", "New MIDI synth",
-                                 BSE_TYPE_MIDI_SYNTH, SFI_PARAM_STANDARD);
-} BODY (BseProcedureClass *proc,
-        const GValue      *in_values,
-        GValue            *out_values)
-{
-  /* extract parameter values */
-  BseContainer *container = (BseContainer*) bse_value_get_object (in_values++);
-  const char *name = sfi_value_get_string (in_values++);
-  BseUndoStack *ustack;
-  BseItem *child;
-
-  /* check parameters */
-  if (!BSE_IS_PROJECT (container))
-    return Bse::Error::PROC_PARAM_INVAL;
-
-  /* action */
-  ustack = bse_item_undo_open (container, "create-midi-synth");
-  child = (BseItem*) bse_container_new_child (container, BSE_TYPE_MIDI_SYNTH, NULL);
-  if (name)
-    bse_item_set (child, "uname", name, NULL);
-  bse_item_push_undo_proc (container, "remove-snet", child);
-  bse_item_undo_close (ustack);
-
-  /* set output parameters */
-  bse_value_set_object (out_values++, child);
-
-  return Bse::Error::NONE;
-}
-
-METHOD (BseProject, remove-snet) {
-  HELP  = "Remove an existing synthesizer network from this project.";
-  IN    = bse_param_spec_object ("project", "Project", "The project",
-                                 BSE_TYPE_PROJECT, SFI_PARAM_STANDARD);
-  IN    = bse_param_spec_object ("snet", "SNet", "Synthesizer Network",
-                                 BSE_TYPE_SNET, SFI_PARAM_STANDARD);
-} BODY (BseProcedureClass *proc,
-        const GValue      *in_values,
-        GValue            *out_values)
-{
-  /* extract parameter values */
-  BseContainer *self = (BseContainer*) bse_value_get_object (in_values++);
-  BseItem *child = (BseItem*) bse_value_get_object (in_values++);
-  BseUndoStack *ustack;
-
-  /* check parameters */
-  if (!BSE_IS_PROJECT (self) || !BSE_IS_SNET (child) || child->parent != (BseItem*) self)
-    return Bse::Error::PROC_PARAM_INVAL;
-
-  /* action */
-  if (!BSE_SOURCE_PREPARED (self))
-    {
-      ustack = bse_item_undo_open (self, "remove-child %s", bse_object_debug_name (child));
-      /* remove object references */
-      bse_container_uncross_undoable (BSE_CONTAINER (self), child);
-      /* how to get rid of the item once backed up */
-      bse_item_push_redo_proc (self, "remove-snet", child);
-      /* remove (without redo queueing) */
-      bse_container_remove_backedup (BSE_CONTAINER (self), child, ustack);
-      /* done */
-      bse_item_undo_close (ustack);
-    }
-
-  return Bse::Error::NONE;
-}