domain_provider.h

Go to the documentation of this file.

/*
    Copyright (C) 2023 Paul Davis <paul@linuxaudiosystems.com>
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 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 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., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
 
#pragma once
 
#include "pbd/signals.h"
#include "pbd/stateful.h"
 
#include "temporal/types.h"
 
namespace Temporal {
 
class TimeDomainProvider  {
  public:
        explicit TimeDomainProvider () : have_domain (false), parent (nullptr) {}
        explicit TimeDomainProvider (TimeDomain td) : have_domain (true), domain (td), parent (nullptr) {}
        TimeDomainProvider (TimeDomain td, TimeDomainProvider const & p) : have_domain (true), domain (td), parent (&p) { listen(); }
 
        /* Copy constructor - note how a constructor that only set the parent would have the same signature. */
        TimeDomainProvider (TimeDomainProvider const & other) : have_domain (other.have_domain), domain (other.domain), parent (other.parent) { listen(); }
 
        /* The extra bool argument is just to differentiate this from the copy constructor above */
        TimeDomainProvider (TimeDomainProvider const & parnt, bool) : have_domain (false), parent (&parnt) { listen(); }
 
        virtual ~TimeDomainProvider() {}
 
        /* replicates part of Stateful API but we do not want inheritance */
 
        XMLNode& get_state () const;
        int set_state (const XMLNode&, int version);
 
        TimeDomainProvider& operator= (TimeDomainProvider const & other) {
                if (this != &other) {
                        parent_connection.disconnect ();
                        have_domain = other.have_domain;
                        domain = other.domain;
                        parent = other.parent;
                        listen ();
                }
                return *this;
        }
 
        TimeDomain time_domain() const { if (have_domain) return domain; if (parent) return parent->time_domain(); return AudioTime; }
 
        bool has_own_time_domain() const { return have_domain; }
        void clear_time_domain () { have_domain = false; TimeDomainChanged(); /* EMIT SIGNAL */ }
        void set_time_domain (TimeDomain td) { have_domain = true; domain = td; time_domain_changed(); TimeDomainChanged(); /* EMIT SIGNAL */}
 
        TimeDomainProvider const * time_domain_parent() const { return parent; }
        bool has_time_domain_parent() const { return (bool) parent; }
        void clear_time_domain_parent () { parent = nullptr; TimeDomainChanged (); /* EMIT SIGNAL */ }
        void set_time_domain_parent (TimeDomainProvider const & p) {
                parent_connection.disconnect ();
                TimeDomain old_domain = time_domain();
                parent = &p;
                have_domain = false;
                TimeDomain new_domain = time_domain ();
                if (old_domain != new_domain) {
                        TimeDomainChanged ();
                }
        }
 
        mutable PBD::Signal<void()> TimeDomainChanged;
 
        virtual void time_domain_changed() {
                /* Forward a time domain change to children */
                TimeDomainChanged();
        }
 
  protected:
        void listen () {
                if (parent) {
                        parent->TimeDomainChanged.connect_same_thread (parent_connection, std::bind (&TimeDomainProvider::time_domain_changed, this));
                }
        }
 
  private:
        bool have_domain;
        TimeDomain domain;
        TimeDomainProvider const * parent;
        PBD::ScopedConnection parent_connection;
};
 
}