templatecommands.cpp

Go to the documentation of this file.

/*
    Copyright 2006-2019 The QElectroTech Team
    This file is part of QElectroTech.
    
    QElectroTech 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.
    
    QElectroTech 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 QElectroTech.  If not, see <http://www.gnu.org/licenses/>.
*/
#include "templatecommands.h"
#include "templatevisualcell.h"
#include "templateview.h"
#include "titleblockcell.h"
#include "dimension.h"
#define TITLEBLOCK_DEFAULT_ROW_HEIGHT TitleBlockDimension(25)
#define TITLEBLOCK_DEFAULT_COL_WIDTH  TitleBlockDimension(50)

ModifyTitleBlockCellCommand::ModifyTitleBlockCellCommand(TitleBlockCell *cell, QUndoCommand *parent) :
    QUndoCommand(parent),
    view_(nullptr),
    modified_cell_(cell)
{
}

ModifyTitleBlockCellCommand::~ModifyTitleBlockCellCommand() {
}

int ModifyTitleBlockCellCommand::id() const {
    return(MODIFY_TITLE_BLOCK_CELL_COMMAND_ID);
}

bool ModifyTitleBlockCellCommand::mergeWith(const QUndoCommand *command) {
    const ModifyTitleBlockCellCommand *other = static_cast<const ModifyTitleBlockCellCommand *>(command);
    if (other) {
        if (other -> modified_cell_ == modified_cell_) {
            if (other -> new_values_.keys() == new_values_.keys()) {
                new_values_ = other -> new_values_;
                return(true);
            }
        }
    }
    return(false);
}

void ModifyTitleBlockCellCommand::undo() {
    if (!modified_cell_) return;
    foreach (QString attribute, old_values_.keys()) {
        modified_cell_ -> setAttribute(attribute, old_values_[attribute]);
    }
    if (view_) view_ -> refresh();
}

void ModifyTitleBlockCellCommand::redo() {
    if (!modified_cell_) return;
    foreach (QString attribute, new_values_.keys()) {
        modified_cell_ -> setAttribute(attribute, new_values_[attribute]);
    }
    if (view_) view_ -> refresh();
}

TitleBlockCell *ModifyTitleBlockCellCommand::cell() const {
    return(modified_cell_);
}

void ModifyTitleBlockCellCommand::setCell(TitleBlockCell *modified_cell) {
    modified_cell_ = modified_cell;
}

TitleBlockTemplateView *ModifyTitleBlockCellCommand::view() const {
    return(view_);
}

void ModifyTitleBlockCellCommand::setView(TitleBlockTemplateView *view) {
    view_ = view;
}

void ModifyTitleBlockCellCommand::clear() {
    old_values_.clear();
    new_values_.clear();
}

void ModifyTitleBlockCellCommand::addModification(const QString &attribute, const QVariant &value, bool is_old_value) {
    if (is_old_value) {
        // the provided value is the old one; therefore, the one we fetch is the new one
        old_values_[attribute] = value;
        if (modified_cell_) {
            new_values_[attribute] = modified_cell_ -> attribute(attribute);
        }
    } else {
        // the provided value is the new one; therefore, we fetch the old one
        if (modified_cell_) {
            old_values_[attribute] = modified_cell_ -> attribute(attribute);
        }
        new_values_[attribute] = value;
    }
}

TitleBlockTemplateCommand::TitleBlockTemplateCommand(TitleBlockTemplate *tbtemplate, QUndoCommand *parent) :
    QUndoCommand(parent),
    tbtemplate_(tbtemplate),
    view_(nullptr)
{
}

TitleBlockTemplateCommand::~TitleBlockTemplateCommand() {
}

TitleBlockTemplate *TitleBlockTemplateCommand::titleBlockTemplate() const {
    return(tbtemplate_);
}

void TitleBlockTemplateCommand::setTitleBlockTemplate(TitleBlockTemplate *tbtemplate) {
    tbtemplate_ = tbtemplate;
}

TitleBlockTemplateView *TitleBlockTemplateCommand::view() const {
    return(view_);
}

void TitleBlockTemplateCommand::setView(TitleBlockTemplateView *view) {
    view_ = view;
}

void TitleBlockTemplateCommand::refreshView() {
    if (!view_) return;
    view_ -> refresh();
}

void TitleBlockTemplateCommand::refreshLayout() {
    if (!view_) return;
    view_ -> updateLayout();
}

ModifyTemplateGridCommand *ModifyTemplateGridCommand::addRow(TitleBlockTemplate *tbtemplate, int index) {
    if (!tbtemplate) return(nullptr);
    
    // create the command itself
    ModifyTemplateGridCommand *add_row_command = new ModifyTemplateGridCommand(tbtemplate);
    add_row_command -> setInsertion(true);
    add_row_command -> setType(true);
    add_row_command -> setCells(tbtemplate -> createRow());
    add_row_command -> setDimension(TITLEBLOCK_DEFAULT_ROW_HEIGHT);
    add_row_command -> setIndex(index);
    
    return(add_row_command);
}

ModifyTemplateGridCommand *ModifyTemplateGridCommand::addColumn(TitleBlockTemplate *tbtemplate, int index) {
    if (!tbtemplate) return(nullptr);
    
    // create the command itself
    ModifyTemplateGridCommand *add_column_command = new ModifyTemplateGridCommand(tbtemplate);
    add_column_command -> setInsertion(true);
    add_column_command -> setType(false);
    add_column_command -> setCells(tbtemplate -> createColumn());
    add_column_command -> setDimension(TITLEBLOCK_DEFAULT_COL_WIDTH);
    add_column_command -> setIndex(index);
    
    return(add_column_command);
}

ModifyTemplateGridCommand *ModifyTemplateGridCommand::deleteRow(TitleBlockTemplate *tbtemplate, int index) {
    if (!tbtemplate) return(nullptr);
    
    // create the command itself
    ModifyTemplateGridCommand *del_row_command = new ModifyTemplateGridCommand(tbtemplate);
    del_row_command -> setInsertion(false);
    del_row_command -> setType(true);
    del_row_command -> setIndex(index);
    
    return(del_row_command);
}

ModifyTemplateGridCommand *ModifyTemplateGridCommand::deleteColumn(TitleBlockTemplate *tbtemplate, int index) {
    if (!tbtemplate) return(nullptr);
    
    // create the command itself
    ModifyTemplateGridCommand *del_column_command = new ModifyTemplateGridCommand(tbtemplate);
    del_column_command -> setInsertion(false);
    del_column_command -> setType(false);
    del_column_command -> setIndex(index);
    
    return(del_column_command);
}

ModifyTemplateGridCommand::ModifyTemplateGridCommand(TitleBlockTemplate *tbtemplate, QUndoCommand *parent) :
    TitleBlockTemplateCommand(tbtemplate, parent),
    index_(-1),
    type_(true),
    dimension_(TITLEBLOCK_DEFAULT_ROW_HEIGHT),
    insertion_(true)
{
    updateText();
}

ModifyTemplateGridCommand::~ModifyTemplateGridCommand() {
}

int ModifyTemplateGridCommand::index() const {
    return(index_);
}

void ModifyTemplateGridCommand::setIndex(int index) {
    index_ = index;
}

QList<TitleBlockCell *> ModifyTemplateGridCommand::cells() const {
    return(cells_);
}

void ModifyTemplateGridCommand::setCells(const QList<TitleBlockCell *> &cells) {
    cells_ = cells;
}

TitleBlockDimension ModifyTemplateGridCommand::dimension() const {
    return dimension_;
}

void ModifyTemplateGridCommand::setDimension(const TitleBlockDimension &dimension) {
    dimension_ = dimension;
}

int ModifyTemplateGridCommand::type() const {
    return(type_);
}

void ModifyTemplateGridCommand::setType(bool type) {
    type_ = type;
    updateText();
}

bool ModifyTemplateGridCommand::isInsertion() const {
    return(insertion_);
}

void ModifyTemplateGridCommand::setInsertion(bool insertion) {
    insertion_ = insertion;
    updateText();
}

void ModifyTemplateGridCommand::undo() {
    apply(true);
}

void ModifyTemplateGridCommand::redo() {
    apply(false);
}

void ModifyTemplateGridCommand::updateText() {
    if (type_) {
        if (insertion_) {
            setText(QObject::tr("Insertion d'une ligne", "label used in the title block template editor undo list"));
        } else {
            setText(QObject::tr("Suppression d'une ligne", "label used in the title block template editor undo list"));
        }
    } else {
        if (insertion_) {
            setText(QObject::tr("Insertion d'une colonne", "label used in the title block template editor undo list"));
        } else {
            setText(QObject::tr("Suppression d'une colonne", "label used in the title block template editor undo list"));
        }
    }
}

/*
    This method takes care of the actual job when undoing / redoing a
    row/column insertion/removal.
    @param true to undo the change, false to apply it.
*/
void ModifyTemplateGridCommand::apply(bool undo) {
    if (!tbtemplate_ || index_ == -1) return;
    
    if (insertion_ ^ undo) {
        if (type_) {
            tbtemplate_ -> insertRow(dimension_.value, cells_, index_);
        } else {
            tbtemplate_ -> insertColumn(dimension_, cells_, index_);
        }
    } else {
        if (type_) {
            dimension_.value = tbtemplate_ -> rowDimension(index_);
            cells_ = tbtemplate_ -> takeRow(index_);
        } else {
            dimension_ = tbtemplate_ -> columnDimension(index_);
            cells_ = tbtemplate_ -> takeColumn(index_);
        }
    }
    
    // update the view, if any
    if (view_) {
        view_ -> updateLayout();
    }
}

ModifyTemplateDimension::ModifyTemplateDimension(TitleBlockTemplate *tbtemplate, QUndoCommand *parent) :
    TitleBlockTemplateCommand(tbtemplate, parent),
    index_(-1),
    type_(true),
    before_(TitleBlockDimension(-1)),
    after_(TitleBlockDimension(-1))
{
}

ModifyTemplateDimension::~ModifyTemplateDimension() {
}

int ModifyTemplateDimension::index() const {
    return(index_);
}

void ModifyTemplateDimension::setIndex(int index) {
    index_ = index;
}

int ModifyTemplateDimension::type() const {
    return type_;
}

void ModifyTemplateDimension::setType(bool type) {
    type_ = type;
    updateText();
}

TitleBlockDimension ModifyTemplateDimension::dimensionBefore() const {
    return(before_);
}

void ModifyTemplateDimension::setDimensionBefore(const TitleBlockDimension &dimension) {
    before_ = dimension;
}

TitleBlockDimension ModifyTemplateDimension::dimensionAfter() const {
    return(after_);
}

void ModifyTemplateDimension::setDimensionAfter(const TitleBlockDimension &dimension) {
    after_ = dimension;
}

void ModifyTemplateDimension::undo() {
    apply(before_);
}

void ModifyTemplateDimension::redo() {
    apply(after_);
}

void ModifyTemplateDimension::updateText() {
    if (type_) {
        setText(QObject::tr("Modification d'une ligne", "label used in the title block template editor undo list"));
    } else {
        setText(QObject::tr("Modification d'une colonne", "label used in the title block template editor undo list"));
    }
}

void ModifyTemplateDimension::apply(const TitleBlockDimension &dimension) {
    if (!tbtemplate_) return;
    if (type_) {
        tbtemplate_ -> setRowDimension(index_, dimension);
    } else {
        tbtemplate_ -> setColumnDimension(index_, dimension);
    }
    if (view_) {
        if (type_) {
            view_ -> rowsDimensionsChanged();
        } else {
            view_ -> columnsDimensionsChanged();
        }
    }
}

MergeCellsCommand::MergeCellsCommand(const TitleBlockTemplateCellsSet &merged_cells, TitleBlockTemplate *tbtemplate, QUndoCommand *parent) :
    TitleBlockTemplateCommand(tbtemplate, parent),
    spanning_cell_(nullptr),
    row_span_after_(-1),
    col_span_after_(-1)
{
    if (!canMerge(merged_cells, tbtemplate)) return;
    
    // the spanning cell is the top left cell
    TitleBlockTemplateVisualCell *top_left_cell = merged_cells.topLeftCell();
    if (!top_left_cell) return;
    spanning_cell_ = top_left_cell -> cell();
    if (!spanning_cell_) return;
    
    // store the spanner_cell attribute of each cell implied in the merge
    foreach(TitleBlockCell *cell, merged_cells.cells()) {
        spanner_cells_before_merge_.insert(cell, cell -> spanner_cell);
    }
    
    // store the former values of the row_span and col_span attributes of the spanning cell
    row_span_before_ = spanning_cell_ -> row_span;
    col_span_before_ = spanning_cell_ -> col_span;
    applied_row_span_before_ = spanning_cell_ -> applied_row_span;
    applied_col_span_before_ = spanning_cell_ -> applied_col_span;
    span_state_before_ = spanning_cell_ -> span_state;
    
    // calculate their new values after the merge operation
    TitleBlockCell *bottom_right_cell = getBottomRightCell(merged_cells);
    if (!bottom_right_cell) return;
    row_span_after_ = bottom_right_cell -> num_row - spanning_cell_ -> num_row;
    col_span_after_ = bottom_right_cell -> num_col - spanning_cell_ -> num_col;
    
    setText(
        QString(
            QObject::tr(
                "Fusion de %1 cellules",
                "label used in the title block template editor undo list; %1 is the number of merged cells"
            )
        ).arg(merged_cells.count())
    );
}

MergeCellsCommand::~MergeCellsCommand() {
}

bool MergeCellsCommand::canMerge(const TitleBlockTemplateCellsSet &merged_cells, TitleBlockTemplate *tbtemplate) {
    Q_UNUSED(tbtemplate)
    
    // basic checks
    if (!merged_cells.isRectangle()) return(false);
    if (merged_cells.count() < 2) return(false);
    
    // the spanning cell is the top left cell
    TitleBlockTemplateVisualCell *top_left_cell = merged_cells.topLeftCell();
    if (!top_left_cell || !top_left_cell -> cell()) return(false);
    
    if (!getBottomRightCell(merged_cells)) return(false);
    
    return(true);
}

bool MergeCellsCommand::isValid() const {
    // we consider having a non-zero spanning cell and positive spans makes a MergeCellsCommand valid
    return(spanning_cell_ && row_span_after_ != -1 && col_span_after_ != -1);
}

void MergeCellsCommand::undo() {
    if (!isValid()) return;
    
    // restore the original spanning_cell attribute of all impacted cells
    foreach (TitleBlockCell *cell, spanner_cells_before_merge_.keys()) {
        cell -> spanner_cell = spanner_cells_before_merge_[cell];
    }
    
    // restore the span-related attributes of the spanning cell
    spanning_cell_ -> row_span = row_span_before_;
    spanning_cell_ -> col_span = col_span_before_;
    spanning_cell_ -> applied_row_span = applied_row_span_before_;
    spanning_cell_ -> applied_col_span = applied_col_span_before_;
    spanning_cell_ -> span_state = span_state_before_;
    
    if (view_) view_ -> updateLayout();
}

void MergeCellsCommand::redo() {
    if (!isValid()) return;
    
    // set the spanning_cell attributes of spanned cells to the spanning cell
    foreach (TitleBlockCell *cell, spanner_cells_before_merge_.keys()) {
        if (cell == spanning_cell_) continue;
        cell -> spanner_cell = spanning_cell_;
    }
    
    // set the new values of the row_span and col_span attributes
    spanning_cell_ -> row_span = row_span_after_;
    spanning_cell_ -> col_span = col_span_after_;
    spanning_cell_ -> applied_row_span = row_span_after_;
    spanning_cell_ -> applied_col_span = col_span_after_;
    spanning_cell_ -> span_state = TitleBlockCell::Enabled;
    
    if (view_) view_ -> updateLayout();
}

TitleBlockCell *MergeCellsCommand::getBottomRightCell(const TitleBlockTemplateCellsSet &cells_set) {
    // first, we get the visual cell at the bottom right
    TitleBlockTemplateVisualCell *bottom_right_cell = cells_set.bottomRightCell();
    if (!bottom_right_cell) return(nullptr);
    
    // next, we get its logical cells: the painted one and the spanned ones (if any)
    QSet<TitleBlockCell *> logical_cells = bottom_right_cell -> cells();
    if (logical_cells.isEmpty()) return(nullptr);
    if (logical_cells.count() == 1) return(logical_cells.toList().first());
    
    // we then look for the bottom right logical cell
    int max_num_row = -1, max_num_col = -1;
    TitleBlockCell *candidate = nullptr;
    foreach(TitleBlockCell *cell, logical_cells) {
        if (cell -> num_row > max_num_row) max_num_row = cell -> num_row;
        if (cell -> num_col > max_num_col) max_num_col = cell -> num_col;
        if (cell -> num_row == max_num_row && cell -> num_col == max_num_col) {
            candidate = cell;
        }
    }
    return(candidate);
}

SplitCellsCommand::SplitCellsCommand(const TitleBlockTemplateCellsSet &splitted_cells, TitleBlockTemplate *tbtemplate, QUndoCommand *parent) :
    TitleBlockTemplateCommand(tbtemplate, parent),
    spanning_cell_(nullptr),
    row_span_before_(-1),
    col_span_before_(-1)
{
    if (!canSplit(splitted_cells, tbtemplate)) return;
    
    // retrieve values necessary for the undo operation
    spanning_cell_ = splitted_cells.first() -> cell();
    spanned_cells_ = tbtemplate_ -> spannedCells(spanning_cell_);
    row_span_before_ = spanning_cell_ -> row_span;
    col_span_before_ = spanning_cell_ -> col_span;
    applied_row_span_before_ = spanning_cell_ -> row_span;
    applied_col_span_before_ = spanning_cell_ -> col_span;
    span_state_before_ = spanning_cell_ -> span_state;
    
    setText(
        QString(
            QObject::tr(
                "Séparation d'une cellule en %1",
                "label used in the title block template editor undo list; %1 is the number of cells after the split"
            )
        ).arg(spanned_cells_.count() + 1)
    );
}

SplitCellsCommand::~SplitCellsCommand() {
}

bool SplitCellsCommand::canSplit(const TitleBlockTemplateCellsSet &splitted_cells, TitleBlockTemplate *tbtemplate) {
    Q_UNUSED(tbtemplate)
    
    // basic check: the command applies to a single visual cell only
    if (splitted_cells.count() != 1) return(false);
    
    // fetch the spanning cell
    TitleBlockCell *spanning_cell = splitted_cells.first() -> cell();
    if (!spanning_cell) return(false);
    
    // ensure the cell spans over other cells and therefore can be splitted
    if (!spanning_cell -> spans()) return(false);
    
    return(true);
}

bool SplitCellsCommand::isValid() const {
    // we consider having a non-zero spanning cell and at least one spanned cell makes a SplitCellsCommand valid
    return(spanning_cell_ && spanned_cells_.count());
}

void SplitCellsCommand::undo() {
    if (!isValid()) return;
    
    // the spanned cells are spanned again
    foreach(TitleBlockCell *cell, spanned_cells_) {
        cell -> spanner_cell = spanning_cell_;
    }
    
    // the spanning cell span again
    spanning_cell_ -> row_span = row_span_before_;
    spanning_cell_ -> col_span = col_span_before_;
    spanning_cell_ -> applied_row_span = applied_row_span_before_;
    spanning_cell_ -> applied_col_span = applied_col_span_before_;
    spanning_cell_ -> span_state = span_state_before_;
    
    if (view_) view_ -> updateLayout();
}

void SplitCellsCommand::redo() {
    if (!isValid()) return;
    
    // the spanned cells are not spanned anymore
    foreach(TitleBlockCell *cell, spanned_cells_) {
        cell -> spanner_cell = nullptr;
    }
    
    // the spanning cell does not span anymore
    spanning_cell_ -> row_span = 0;
    spanning_cell_ -> col_span = 0;
    tbtemplate_ -> checkCellSpan(spanning_cell_);
    
    if (view_) view_ -> updateLayout();
}


ChangeTemplateInformationsCommand::ChangeTemplateInformationsCommand(TitleBlockTemplate *tbt, const QString &old_info, const QString &new_info, QUndoCommand *parent) :
    QUndoCommand(QObject::tr("modification des informations complémentaires", "undo caption"), parent),
    tbtemplate_(tbt),
    old_information_(old_info),
    new_information_(new_info)
{
}

ChangeTemplateInformationsCommand::~ChangeTemplateInformationsCommand() {
}

void ChangeTemplateInformationsCommand::undo() {
    if (!tbtemplate_) return;
    tbtemplate_ -> setInformation(old_information_);
}

void ChangeTemplateInformationsCommand::redo() {
    tbtemplate_ -> setInformation(new_information_);
}

CutTemplateCellsCommand::CutTemplateCellsCommand(TitleBlockTemplate *tb_template, QUndoCommand *parent) :
    TitleBlockTemplateCommand(tb_template, parent)
{
}

CutTemplateCellsCommand::~CutTemplateCellsCommand() {
}

void CutTemplateCellsCommand::undo() {
    foreach (TitleBlockCell *cell, cut_cells_.keys()) {
        cell -> cell_type = cut_cells_.value(cell);
    }
    refreshView();
}

void CutTemplateCellsCommand::redo() {
    foreach (TitleBlockCell *cell, cut_cells_.keys()) {
        cell -> cell_type = TitleBlockCell::EmptyCell;
    }
    refreshView();
}

void CutTemplateCellsCommand::setCutCells(const QList<TitleBlockCell *> &cells) {
    foreach (TitleBlockCell *cell, cells) {
        cut_cells_.insert(cell, cell -> cell_type);
    }
    updateText();
}

void CutTemplateCellsCommand::updateText() {
    setText(QObject::tr("Couper %n cellule(s)", "undo caption", cut_cells_.count()));
}


PasteTemplateCellsCommand::PasteTemplateCellsCommand(TitleBlockTemplate *tb_template, QUndoCommand *parent) :
    TitleBlockTemplateCommand(tb_template, parent)
{
}

PasteTemplateCellsCommand::~PasteTemplateCellsCommand() {
}

void PasteTemplateCellsCommand::updateText() {
    setText(QObject::tr("Coller %n cellule(s)", "undo caption", erased_cells_.count()));
}

void PasteTemplateCellsCommand::undo() {
    bool span_management = erased_cells_.count() > 1;
    foreach (TitleBlockCell *cell, erased_cells_.keys()) {
        cell -> loadContentFromCell(erased_cells_.value(cell));
    }
    if (span_management) {
        // restore all span parameters as they were before the paste operation.
        tbtemplate_ -> setAllSpans(spans_before_);
        tbtemplate_ -> applyCellSpans();
        refreshLayout();
    } else {
        refreshView();
    }
}

void PasteTemplateCellsCommand::redo() {
    // we only play with spans when pasting more than one cell.
    bool span_management = erased_cells_.count() > 1;
    
    if (span_management) {
        // When pasting several cells, we may modify the span parameters of existing,
        // non-erased cells. The easiest way to ensure everything can be restored at its
        // initial state consists in saving the span parameters of every cell.
        if (spans_before_.isEmpty()) {
            spans_before_ = tbtemplate_ -> getAllSpans();
        }
    }
    
    // copy data from each pasted cell into each erased cell
    foreach (TitleBlockCell *cell, erased_cells_.keys()) {
        if (span_management) {
            // the erased cell may be spanned by another cell
            if (TitleBlockCell *spanning_cell = cell -> spanner_cell) {
                // for the moment, we simply cancel the whole spanning
                tbtemplate_ -> forgetSpanning(spanning_cell);
            }
        }
        
        // copy non-spans data
        TitleBlockCell pasted_cell = pasted_cells_.value(cell);
        cell -> loadContentFromCell(pasted_cell);
        
        if (span_management) {
            // copy spans data
            if ((pasted_cell.row_span != cell -> row_span) || (pasted_cell.col_span != cell -> col_span)) {
                tbtemplate_ -> forgetSpanning(cell);
                
                // Note: the code below is similar to TitleBlockTemplate::checkCell() but is more aggressive (spans deletion).
                // set the new/pasted span parameters
                cell -> row_span = qBound(0, pasted_cell.row_span, tbtemplate_ -> rowsCount() - 1 - cell -> num_row);
                cell -> col_span = qBound(0, pasted_cell.col_span, tbtemplate_ -> columnsCount() - 1 - cell -> num_col);
                
                if (cell -> row_span || cell -> col_span) {
                    // browse newly spanned cells...
                    foreach (TitleBlockCell *spanned_cell, tbtemplate_ -> spannedCells(cell, true)) {
                        // ... to ensure they are not already spanned by other cells
                        if (spanned_cell -> spanner_cell && spanned_cell -> spanner_cell != cell) {
                            // if so, simply cancel the whole spanning
                            tbtemplate_ -> forgetSpanning(spanned_cell -> spanner_cell);
                        }
                    }
                    
                    // set the spanner_cell attribute of newly spanned cells
                    tbtemplate_ -> applyCellSpan(cell);
                }
            }
        }
    }
    if (span_management) {
        refreshLayout();
    } else {
        refreshView();
    }
}

void PasteTemplateCellsCommand::addPastedCell(TitleBlockCell *cell, const TitleBlockCell &new_cell_content) {
    pasted_cells_.insert(cell, new_cell_content);
}

void PasteTemplateCellsCommand::addErasedCell(TitleBlockCell *cell, const TitleBlockCell &former_cell_content) {
    erased_cells_.insert(cell, former_cell_content);
    updateText();
}

void PasteTemplateCellsCommand::addCell(TitleBlockCell *cell, const TitleBlockCell &before, const TitleBlockCell &after) {
    addPastedCell(cell, after);
    addErasedCell(cell, before);
}