void CanvasWidget::layoutDone()
{
if (updateCanvasSize())
{
Super::layoutDone();
}
}
CanvasWidget::CanvasWidget(std::shared_ptr<const render::ProgramSettings> render, const Vector2& size) :
m_render(render)
{
m_computedSize = size;
setSize(size);
updateCanvasSize();
}
void TrackEditor::addTracks(unsigned int nbNewTracks,
InstrumentId id,
int position)
{
Composition &comp = m_doc->getComposition();
addCommandToHistory(new AddTracksCommand(&comp, nbNewTracks, id, position));
updateCanvasSize();
}
void TrackEditor::slotCommandExecuted()
{
// ??? This routine doesn't belong here. It is doing things for other
// objects. Those objects should take care of themselves.
// ??? Is there a way to do this at a more relevant time? Like when
// the Composition changes, instead for every command that is
// executed regardless of whether that command changes the
// Composition?
// ??? RosegardenMainViewWidget also connects
// CompositionView::slotUpdateAll() to commandExecuted().
bool compositionNeedsRefresh = m_doc->getComposition().
getRefreshStatus(m_compositionRefreshStatusId).needsRefresh();
// If the composition has changed, redraw the CompositionView's
// contents.
if (compositionNeedsRefresh) {
// ??? Need to investigate each of these calls and see if we can
// implement them in a more appropriate way. E.g. can
// CompositionView take care of itself?
// ??? It would be more logical if CompositionView redrew its
// contents and repainted itself in response to a change
// to the Composition. The change notification would need
// to be called responsibly (e.g. not for every single
// modification to an event while recording!). And observers
// would need to be smart about detecting relevant changes
// and avoiding work. It's the same old story.
// In case the composition has grown.
// ??? CompositionView should take care of this.
updateCanvasSize();
// In case any tracks have been added, deleted, or changed.
// ??? TrackButtons should take care of this.
m_trackButtons->slotUpdateTracks();
// Redraw the contents.
// ??? CompositionView should take care of this.
m_compositionView->deleteCachedPreviews();
m_compositionView->updateContents();
Composition &composition = m_doc->getComposition();
// ??? Composition should take care of have_segments.
if (composition.getNbSegments() == 0) {
emit stateChange("have_segments", false);
emit stateChange("have_selection", false);
} else {
emit stateChange("have_segments", true);
// ??? CompositionView should take care of have_selection.
if (m_compositionView->haveSelection())
emit stateChange("have_selection", true);
else
emit stateChange("have_selection", false);
}
// Clear the composition refresh flag.
m_doc->getComposition().
getRefreshStatus(m_compositionRefreshStatusId).
setNeedsRefresh(false);
}
// Send a paint event to all children.
// ??? Painting every time a command is executed is overkill. We should
// only paint when relevant changes are made to the Composition.
// ??? The children should paint themselves in response to changes.
// TrackEditor shouldn't care.
update();
}
