view widgets/PropertyStack.cpp @ 1551:e79731086b0f

Fixes to NoteLayer, particularly to calculation of vertical scale when model unit is not Hz. To avoid inconsistency we now behave as if the unit is always Hz from the point of view of the external API and display, converting at the point where we obtain values from the events themselves. Also various fixes to editing.

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

/*
    Sonic Visualiser
    An audio file viewer and annotation editor.
    Centre for Digital Music, Queen Mary, University of London.
    This file copyright 2006 Chris Cannam.
    
    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.  See the file
    COPYING included with this distribution for more information.
*/

#include "PropertyStack.h"
#include "PropertyBox.h"
#include "base/PropertyContainer.h"
#include "view/View.h"
#include "layer/Layer.h"
#include "layer/LayerFactory.h"
#include "widgets/NotifyingTabBar.h"
#include "widgets/IconLoader.h"
#include "base/Command.h"
#include "widgets/CommandHistory.h"
#include "layer/ShowLayerCommand.h"

#include "WidgetScale.h"

#include <QIcon>
#include <QTabWidget>

#include <iostream>

//#define DEBUG_PROPERTY_STACK 1

PropertyStack::PropertyStack(QWidget *parent, View *client) :
    QTabWidget(parent),
    m_client(client)
{
    NotifyingTabBar *bar = new NotifyingTabBar();
    bar->setDrawBase(false);

    connect(bar, SIGNAL(mouseEntered()), this, SLOT(mouseEnteredTabBar()));
    connect(bar, SIGNAL(mouseLeft()), this, SLOT(mouseLeftTabBar()));
    connect(bar, SIGNAL(activeTabClicked()), this, SLOT(activeTabClicked()));

    setTabBar(bar);

    setElideMode(Qt::ElideNone); 
    tabBar()->setUsesScrollButtons(true); 
    tabBar()->setIconSize(WidgetScale::scaleQSize(QSize(16, 16)));

    repopulate();

    connect(this, SIGNAL(currentChanged(int)),
            this, SLOT(selectedContainerChanged(int)));

    connect(m_client, SIGNAL(propertyContainerAdded(PropertyContainer *)),
            this, SLOT(propertyContainerAdded(PropertyContainer *)));

    connect(m_client, SIGNAL(propertyContainerRemoved(PropertyContainer *)),
            this, SLOT(propertyContainerRemoved(PropertyContainer *)));

    connect(m_client, SIGNAL(propertyContainerPropertyChanged(PropertyContainer *)),
            this, SLOT(propertyContainerPropertyChanged(PropertyContainer *)));

    connect(m_client, SIGNAL(propertyContainerPropertyRangeChanged(PropertyContainer *)),
            this, SLOT(propertyContainerPropertyRangeChanged(PropertyContainer *)));

    connect(m_client, SIGNAL(propertyContainerNameChanged(PropertyContainer *)),
            this, SLOT(propertyContainerNameChanged(PropertyContainer *)));

    connect(this, SIGNAL(propertyContainerSelected(View *, PropertyContainer *)),
            m_client, SLOT(propertyContainerSelected(View *, PropertyContainer *)));
}

PropertyStack::~PropertyStack()
{
}

void
PropertyStack::repopulate()
{
    blockSignals(true);

#ifdef DEBUG_PROPERTY_STACK
    SVDEBUG << "PropertyStack[" << this << "]::repopulate" << endl;
#endif
    
#ifdef DEBUG_PROPERTY_STACK
    SVDEBUG << "PropertyStack[" << this << "]::repopulate: removing tabs" << endl;
#endif
    while (count() > 0) {
        removeTab(0);
    }

#ifdef DEBUG_PROPERTY_STACK
    SVDEBUG << "PropertyStack[" << this << "]::repopulate: deleting boxes" << endl;
#endif
    for (size_t i = 0; i < m_boxes.size(); ++i) {
#ifdef DEBUG_PROPERTY_STACK
        SVDEBUG << "(" << i << " of " << m_boxes.size() << ": " << m_boxes[i]->getContainer()->getPropertyContainerName() << ")" << endl;
#endif
        delete m_boxes[i];
    }

#ifdef DEBUG_PROPERTY_STACK
    SVDEBUG << "PropertyStack[" << this << "]::repopulate: done, clearing m_boxes" << endl;
#endif
    m_boxes.clear();
    
    for (int i = 0; i < m_client->getPropertyContainerCount(); ++i) {

        PropertyContainer *container = m_client->getPropertyContainer(i);
        QString name = container->getPropertyContainerName();
        
#ifdef DEBUG_PROPERTY_STACK
        SVDEBUG << "PropertyStack[" << this << "]::repopulate: client " << m_client
                << " returns container " << container << " (name " << name
                << ") at position " << i << endl;
#endif

        PropertyBox *box = new PropertyBox(container);

        connect(box, SIGNAL(showLayer(bool)), this, SLOT(showLayer(bool)));
        connect(box, SIGNAL(contextHelpChanged(const QString &)),
                this, SIGNAL(contextHelpChanged(const QString &)));

        Layer *layer = dynamic_cast<Layer *>(container);
        if (layer) {
            box->layerVisibilityChanged(!layer->isLayerDormant(m_client));
        }

        QString shortName = name;

        if (layer) {
            shortName = LayerFactory::getInstance()->getLayerPresentationName
                (LayerFactory::getInstance()->getLayerType(layer));
            if (layer->getLayerPresentationName() != "") {
                name = layer->getLayerPresentationName();
            }
        }

        bool nameDiffers = (name != shortName);
        shortName = QString("&%1 %2").arg(i + 1).arg(shortName);

        QString iconName = container->getPropertyContainerIconName();

        QIcon icon(IconLoader().load(iconName));
        if (icon.isNull()) {
            addTab(box, shortName);
            if (nameDiffers) {
                setTabToolTip(i, name);
            }
        } else {
            addTab(box, icon, QString("&%1").arg(i + 1));
            setTabToolTip(i, name);
        }

        m_boxes.push_back(box);
    }    

    blockSignals(false);
}

bool
PropertyStack::containsContainer(PropertyContainer *pc) const
{
    for (int i = 0; i < m_client->getPropertyContainerCount(); ++i) {
        PropertyContainer *container = m_client->getPropertyContainer(i);
        if (pc == container) return true;
    }

    return false;
}

int
PropertyStack::getContainerIndex(PropertyContainer *pc) const
{
    // This is used to obtain an index to be passed to setCurrentIndex
    // -- which is the index of the property container's box in our
    // stack of boxes. That is not the same thing as the index of the
    // container (i.e. the layer) in the view: the view reorders its
    // containers whenever one is raised to the top, while our boxes
    // remain in the same order. So we must find this container in the
    // box list, not in the view.

    for (int i = 0; in_range_for(m_boxes, i); ++i) {
        PropertyContainer *container = m_boxes[i]->getContainer();
        if (pc == container) {
            return i;
        }
    }

    return false;
}

void
PropertyStack::propertyContainerAdded(PropertyContainer *
#ifdef DEBUG_PROPERTY_STACK
                                      c
#endif
    )
{
    if (sender() != m_client) return;
#ifdef DEBUG_PROPERTY_STACK
    SVDEBUG << "PropertyStack::propertyContainerAdded(" << (c ? c->getPropertyContainerName() : "(none)") << ")" << endl;
#endif
    repopulate();
}

void
PropertyStack::propertyContainerRemoved(PropertyContainer *
#ifdef DEBUG_PROPERTY_STACK
                                      c
#endif
    )
{
    if (sender() != m_client) return;
#ifdef DEBUG_PROPERTY_STACK
    SVDEBUG << "PropertyStack::propertyContainerAdded(" << (c ? c->getPropertyContainerName() : "(none)") << ")" << endl;
#endif
    repopulate();
}

void
PropertyStack::propertyContainerPropertyChanged(PropertyContainer *pc)
{
    Layer *layer = dynamic_cast<Layer *>(pc);
    for (unsigned int i = 0; i < m_boxes.size(); ++i) {
        if (pc == m_boxes[i]->getContainer()) {
            m_boxes[i]->propertyContainerPropertyChanged(pc);
            if (layer) {
                m_boxes[i]->layerVisibilityChanged
                    (!layer->isLayerDormant(m_client));
            }
        }
    }
}

void
PropertyStack::propertyContainerPropertyRangeChanged(PropertyContainer *pc)
{
    for (unsigned int i = 0; i < m_boxes.size(); ++i) {
        if (pc == m_boxes[i]->getContainer()) {
            m_boxes[i]->propertyContainerPropertyRangeChanged(pc);
        }
    }
}

void
PropertyStack::propertyContainerNameChanged(PropertyContainer *)
{
    if (sender() != m_client) return;
    repopulate();
}

void
PropertyStack::showLayer(bool show)
{
    QObject *obj = sender();
    
    for (unsigned int i = 0; i < m_boxes.size(); ++i) {
        if (obj == m_boxes[i]) {
            Layer *layer = dynamic_cast<Layer *>(m_boxes[i]->getContainer());
            if (layer) {
                CommandHistory::getInstance()->addCommand
                    (new ShowLayerCommand(m_client, layer, show,
                                          tr("Change Layer Visibility")));
                return;
            }
        }
    }
}

void
PropertyStack::selectedContainerChanged(int n)
{
    if (n >= int(m_boxes.size())) return;
    emit propertyContainerSelected(m_client, m_boxes[n]->getContainer());
}

void
PropertyStack::mouseEnteredTabBar()
{
    emit contextHelpChanged(tr("Click to change the current active layer"));
}

void
PropertyStack::mouseLeftTabBar()
{
    emit contextHelpChanged("");
}

void
PropertyStack::activeTabClicked()
{
    emit viewSelected(m_client);
}