d4642c34e8
* remove syntax macros: CASE, __OR, and DEFAULT * define VC_EXTRALEAN * remove meaningless comments
672 lines
16 KiB
C++
672 lines
16 KiB
C++
|
|
|
|
// TnzBase includes
|
|
#include "tfx.h"
|
|
|
|
// TnzLib includes
|
|
#include "toonz/txshcolumn.h"
|
|
#include "toonz/txshlevelcolumn.h"
|
|
#include "toonz/txshsoundcolumn.h"
|
|
#include "toonz/txshpalettecolumn.h"
|
|
#include "toonz/txshzeraryfxcolumn.h"
|
|
#include "toonz/txshsoundtextcolumn.h"
|
|
#include "toonz/txshmeshcolumn.h"
|
|
#include "toonz/txshcell.h"
|
|
#include "toonz/txsheet.h"
|
|
#include "toonz/fxdag.h"
|
|
#include "toonz/tcolumnfxset.h"
|
|
#include "toonz/preferences.h"
|
|
#include "toonz/txshleveltypes.h"
|
|
|
|
//=============================================================================
|
|
//TXshCellColumn
|
|
|
|
TXshCellColumn::TXshCellColumn()
|
|
: m_first(0)
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TXshCellColumn::~TXshCellColumn()
|
|
{
|
|
m_cells.clear();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TXshCellColumn::getRange(int &r0, int &r1) const
|
|
{
|
|
int cellCount = m_cells.size();
|
|
r0 = m_first;
|
|
r1 = r0 + cellCount - 1;
|
|
int i;
|
|
for (i = 0; i < cellCount && m_cells[i].isEmpty(); i++) {
|
|
}
|
|
if (i >= cellCount) {
|
|
r0 = 0;
|
|
r1 = -1;
|
|
return 0;
|
|
}
|
|
r0 = m_first + i;
|
|
for (i = cellCount - 1; i >= 0 && m_cells[i].isEmpty(); i--) {
|
|
}
|
|
|
|
r1 = m_first + i;
|
|
return r1 - r0 + 1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TXshCellColumn::getRowCount() const
|
|
{
|
|
int i = m_cells.size();
|
|
for (; i > 0 && m_cells[i - 1].isEmpty(); i--) {
|
|
}
|
|
if (i == 0)
|
|
return 0;
|
|
else
|
|
return m_first + i;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TXshCellColumn::getMaxFrame() const
|
|
{
|
|
int r0, r1;
|
|
getRange(r0, r1);
|
|
return r1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TXshCellColumn::getFirstRow() const
|
|
{
|
|
return m_first;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
const TXshCell &TXshCellColumn::getCell(int row) const
|
|
{
|
|
static TXshCell emptyCell;
|
|
if (row < 0 || row < m_first ||
|
|
row >= m_first + (int)m_cells.size())
|
|
return emptyCell;
|
|
return m_cells[row - m_first];
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool TXshCellColumn::isCellEmpty(int row) const
|
|
{
|
|
return getCell(row).isEmpty();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//--- debug only
|
|
void TXshCellColumn::checkColumn() const
|
|
{
|
|
assert(m_first >= 0);
|
|
int r0, r1;
|
|
int range = getRange(r0, r1);
|
|
assert(range >= 0);
|
|
assert(range == (int)m_cells.size());
|
|
assert(getRowCount() >= 0);
|
|
|
|
TXshCell firstCell = getCell(m_first);
|
|
TXshCell lastCell = getCell(r1);
|
|
if (range == 0)
|
|
assert(firstCell.isEmpty() && lastCell.isEmpty());
|
|
else {
|
|
assert(firstCell.isEmpty() == 0);
|
|
assert(lastCell.isEmpty() == 0);
|
|
|
|
int maxFrame = getMaxFrame();
|
|
assert(maxFrame == r1);
|
|
assert(getCell(maxFrame).isEmpty() == 0);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TXshCellColumn::getCells(int row, int rowCount, TXshCell cells[])
|
|
{
|
|
const TXshCell emptyCell;
|
|
int first = m_first;
|
|
int i;
|
|
int cellCount = m_cells.size();
|
|
if (row < 0 || row + rowCount - 1 < first ||
|
|
row >= first + cellCount) {
|
|
for (i = 0; i < rowCount; i++)
|
|
cells[i] = emptyCell;
|
|
return;
|
|
}
|
|
|
|
int dst, src, n, delta;
|
|
n = rowCount;
|
|
delta = m_first - row;
|
|
if (delta < 0) { // le celle cominciano PRIMA della zona da leggere
|
|
dst = 0;
|
|
src = -delta;
|
|
} else { //le celle cominciano DOPO della zona da leggere
|
|
dst = delta;
|
|
src = 0;
|
|
n -= delta;
|
|
}
|
|
if (n + src > cellCount)
|
|
n = cellCount - src;
|
|
|
|
TXshCell *dstCell = cells;
|
|
TXshCell *endDstCell = dstCell + dst;
|
|
while (dstCell < endDstCell)
|
|
*dstCell++ = emptyCell;
|
|
endDstCell += n;
|
|
while (dstCell < endDstCell)
|
|
*dstCell++ = m_cells[src++];
|
|
endDstCell = cells + rowCount;
|
|
while (dstCell < endDstCell)
|
|
*dstCell++ = emptyCell;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool TXshCellColumn::setCell(int row, const TXshCell &cell)
|
|
{
|
|
if (!canSetCell(cell))
|
|
return false;
|
|
assert(row >= 0);
|
|
#ifndef NDEBUG
|
|
checkColumn();
|
|
#endif
|
|
if (m_cells.empty()) //se la colonna e' vuota
|
|
{
|
|
if (!cell.isEmpty()) {
|
|
m_cells.push_back(cell);
|
|
m_first = row;
|
|
//updateIcon();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
int oldCellCount = m_cells.size();
|
|
assert(oldCellCount > 0);
|
|
int lastRow = m_first + oldCellCount - 1;
|
|
|
|
if (row < m_first) //prima
|
|
{
|
|
if (cell.isEmpty())
|
|
return false; //non faccio nulla
|
|
int delta = m_first - row;
|
|
assert(delta > 0);
|
|
m_cells.insert(m_cells.begin(), delta - 1, TXshCell()); //celle vuote
|
|
m_cells.insert(m_cells.begin(), cell); //devo settare la prima comp. del vettore
|
|
m_first = row; //row 'e la nuova firstrow
|
|
//updateIcon();
|
|
#ifndef NDEBUG
|
|
checkColumn();
|
|
#endif
|
|
return true;
|
|
} else if (row > lastRow) //dopo
|
|
{
|
|
if (cell.isEmpty())
|
|
return false; //non faccio nulla
|
|
int count = row - lastRow - 1;
|
|
//se necessario, inserisco celle vuote
|
|
for (int i = 0; i < count; ++i)
|
|
m_cells.push_back(TXshCell());
|
|
m_cells.push_back(cell);
|
|
#ifndef NDEBUG
|
|
checkColumn();
|
|
#endif
|
|
return true;
|
|
}
|
|
//"[r0,r1]"
|
|
int index = row - m_first;
|
|
assert(0 <= index && index < (int)m_cells.size());
|
|
m_cells[index] = cell;
|
|
//if(index == 0) updateIcon();
|
|
if (cell.isEmpty()) {
|
|
if (row == lastRow) {
|
|
// verifico la presenza di celle bianche alla fine
|
|
while (!m_cells.empty() && m_cells.back().isEmpty())
|
|
m_cells.pop_back();
|
|
} else if (row == m_first) {
|
|
// verifico la presenza di celle bianche all'inizio
|
|
while (!m_cells.empty() && m_cells.front().isEmpty()) {
|
|
m_cells.erase(m_cells.begin());
|
|
m_first++;
|
|
}
|
|
}
|
|
if (m_cells.empty())
|
|
m_first = 0;
|
|
}
|
|
checkColumn();
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool TXshCellColumn::setCells(int row, int rowCount, const TXshCell cells[])
|
|
{
|
|
assert(row >= 0);
|
|
int i;
|
|
for (i = 0; i < rowCount; i++)
|
|
if (!canSetCell(cells[i]))
|
|
return false;
|
|
|
|
int oldCellCount = m_cells.size();
|
|
|
|
// le celle da settare sono [ra, rb]
|
|
int ra = row;
|
|
int rb = row + rowCount - 1;
|
|
assert(ra <= rb);
|
|
// le celle non vuote sono [c_ra, c_rb]
|
|
int c_rb = m_first + oldCellCount - 1;
|
|
|
|
if (row > c_rb) //sono oltre l'ultima riga
|
|
{
|
|
if (oldCellCount == 0)
|
|
m_first = row; //row 'e la nuova firstrow
|
|
int newCellCount = row - m_first + rowCount;
|
|
m_cells.resize(newCellCount);
|
|
} else if (row < m_first) {
|
|
int delta = m_first - row;
|
|
m_cells.insert(m_cells.begin(), delta, TXshCell());
|
|
m_first = row; //row e' la nuova firstrow
|
|
}
|
|
if (rb > c_rb) {
|
|
for (int i = 0; i < rb - c_rb; ++i)
|
|
m_cells.push_back(TXshCell());
|
|
}
|
|
|
|
int index = row - m_first;
|
|
assert(0 <= index && index < (int)m_cells.size());
|
|
for (int i = 0; i < rowCount; i++)
|
|
m_cells[index + i] = cells[i];
|
|
|
|
// verifico la presenza di celle bianche alla fine
|
|
while (!m_cells.empty() && m_cells.back().isEmpty()) {
|
|
m_cells.pop_back();
|
|
}
|
|
|
|
// verifico la presenza di celle bianche all'inizio
|
|
while (!m_cells.empty() && m_cells.front().isEmpty()) {
|
|
m_cells.erase(m_cells.begin());
|
|
m_first++;
|
|
}
|
|
if (m_cells.empty()) {
|
|
m_first = 0;
|
|
}
|
|
//updateIcon();
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TXshCellColumn::insertEmptyCells(int row, int rowCount)
|
|
{
|
|
if (m_cells.empty())
|
|
return; //se la colonna e' vuota non devo inserire celle
|
|
|
|
if (row >= m_first + (int)m_cells.size())
|
|
return; //dopo:non inserisco nulla
|
|
if (row <= m_first) //prima
|
|
{
|
|
m_first += rowCount;
|
|
} else //in mezzo
|
|
{
|
|
int delta = row - m_first;
|
|
std::vector<TXshCell>::iterator it = m_cells.begin();
|
|
std::advance(it, delta);
|
|
m_cells.insert(it, rowCount, TXshCell());
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// sbianca le celle [row, row+rowCount-1] (senza shiftare)
|
|
void TXshCellColumn::clearCells(int row, int rowCount)
|
|
{
|
|
if (rowCount <= 0)
|
|
return;
|
|
if (m_cells.empty())
|
|
return; //se la colonna e' vuota
|
|
|
|
// le celle da cancellare sono [ra, rb]
|
|
int ra = row;
|
|
int rb = row + rowCount - 1;
|
|
assert(ra <= rb);
|
|
|
|
int cellCount = m_cells.size();
|
|
|
|
// le celle non vuote sono [c_ra, c_rb]
|
|
int c_ra = m_first;
|
|
int c_rb = m_first + cellCount - 1;
|
|
assert(c_ra <= c_rb);
|
|
|
|
// se e' sotto o sopra le celle occupate non devo far nulla
|
|
if (rb < c_ra || ra > c_rb)
|
|
return;
|
|
|
|
// restringo l'area da cancellare in modo che comprenda solo celle non vuote
|
|
if (ra < c_ra)
|
|
ra = c_ra;
|
|
if (rb > c_rb)
|
|
rb = c_rb;
|
|
|
|
// devo "sbiancare" n celle
|
|
int n = rb - ra + 1;
|
|
assert(n >= 0);
|
|
|
|
if (n == cellCount) // ho cancellato tutto
|
|
{
|
|
m_cells.clear();
|
|
m_first = 0;
|
|
} else {
|
|
assert(ra - c_ra < (int)m_cells.size());
|
|
assert(ra - c_ra + n <= (int)m_cells.size());
|
|
//std::fill_n(&m_cells[ra-c_ra],n, TXshCell());
|
|
int i;
|
|
for (i = 0; i < n; i++)
|
|
m_cells[ra - c_ra + i] = TXshCell();
|
|
|
|
// verifico la presenza di celle bianche alla fine
|
|
while (!m_cells.empty() && m_cells.back().isEmpty()) {
|
|
m_cells.pop_back();
|
|
}
|
|
|
|
if (m_cells.empty()) {
|
|
m_first = 0;
|
|
} else {
|
|
// verifico la presenza di celle bianche all'inizio
|
|
while (!m_cells.empty() && m_cells.front().isEmpty()) {
|
|
m_cells.erase(m_cells.begin());
|
|
m_first++;
|
|
}
|
|
}
|
|
}
|
|
//updateIcon();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// rimuove le celle [row, row+rowCount-1] (shiftando)
|
|
void TXshCellColumn::removeCells(int row, int rowCount)
|
|
{
|
|
if (rowCount <= 0)
|
|
return;
|
|
if (m_cells.empty())
|
|
return; //se la colonna e' vuota
|
|
|
|
int cellCount = m_cells.size();
|
|
|
|
if (row >= m_first + cellCount)
|
|
return; //sono "sotto" l'ultima cella
|
|
if (row < m_first) {
|
|
if (row + rowCount <= m_first) //"sono sopra la prima cella"
|
|
{ // aggiorno solo m_first
|
|
m_first -= rowCount;
|
|
return;
|
|
}
|
|
rowCount += row - m_first;
|
|
m_first = row;
|
|
}
|
|
|
|
assert(row >= m_first);
|
|
// le celle sotto m_first+cellCount sono gia' vuote
|
|
if (rowCount > m_first + cellCount - row)
|
|
rowCount = m_first + cellCount - row;
|
|
if (rowCount <= 0)
|
|
return;
|
|
|
|
if (row == m_first) {
|
|
//cancello all'inizio
|
|
assert(rowCount <= cellCount);
|
|
std::vector<TXshCell>::iterator it = m_cells.begin();
|
|
std::vector<TXshCell>::iterator it2 = m_cells.begin();
|
|
std::advance(it2, rowCount);
|
|
m_cells.erase(it, it2);
|
|
// verifico la presenza di celle bianche all'inizio
|
|
while (!m_cells.empty() && m_cells.front().isEmpty()) {
|
|
m_cells.erase(m_cells.begin());
|
|
m_first++;
|
|
}
|
|
} else {
|
|
// cancello dopo l'inizio
|
|
int d = row - m_first;
|
|
std::vector<TXshCell>::iterator it = m_cells.begin();
|
|
std::vector<TXshCell>::iterator it2 = m_cells.begin();
|
|
std::advance(it, d);
|
|
std::advance(it2, d + rowCount);
|
|
m_cells.erase(it, it2);
|
|
if (row + rowCount == m_first + cellCount) {
|
|
// verifico la presenza di celle bianche alla fine
|
|
while (!m_cells.empty() && m_cells.back().isEmpty()) {
|
|
m_cells.pop_back();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (m_cells.empty()) {
|
|
m_first = 0;
|
|
}
|
|
//updateIcon();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool TXshCellColumn::getLevelRange(int row, int &r0, int &r1) const
|
|
{
|
|
r0 = r1 = row;
|
|
TXshCell cell = getCell(row);
|
|
if (cell.isEmpty())
|
|
return false;
|
|
while (r0 > 0 && getCell(r0 - 1).m_level.getPointer() == cell.m_level.getPointer())
|
|
r0--;
|
|
while (getCell(r1 + 1).m_level.getPointer() == cell.m_level.getPointer())
|
|
r1++;
|
|
return true;
|
|
}
|
|
|
|
//=============================================================================
|
|
//TXshColumn
|
|
|
|
void TXshColumn::setStatusWord(int status)
|
|
{
|
|
m_status = status;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TXshColumn *TXshColumn::createEmpty(int type)
|
|
{
|
|
switch (type) {
|
|
case eSoundType : return new TXshSoundColumn;
|
|
case eZeraryFxType : return new TXshZeraryFxColumn(0);
|
|
case ePaletteType : return new TXshPaletteColumn;
|
|
case eSoundTextType: return new TXshSoundTextColumn;
|
|
case eMeshType : return new TXshMeshColumn;
|
|
}
|
|
|
|
assert(type == eLevelType);
|
|
return new TXshLevelColumn;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TXshColumn::ColumnType TXshColumn::toColumnType(int levelType)
|
|
{
|
|
ColumnType colType = TXshColumn::eLevelType;
|
|
|
|
if (levelType & LEVELCOLUMN_XSHLEVEL)
|
|
colType = TXshColumn::eLevelType;
|
|
else if (levelType == ZERARYFX_XSHLEVEL)
|
|
colType = TXshColumn::eZeraryFxType;
|
|
else if (levelType == PLT_XSHLEVEL)
|
|
colType = TXshColumn::ePaletteType;
|
|
else if (levelType == SND_XSHLEVEL)
|
|
colType = TXshColumn::eSoundType;
|
|
else if (levelType == SND_TXT_XSHLEVEL)
|
|
colType = TXshColumn::eSoundTextType;
|
|
else if (levelType == MESH_XSHLEVEL)
|
|
colType = TXshColumn::eMeshType;
|
|
else
|
|
assert(!"Unkown level type!");
|
|
|
|
return colType;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool TXshColumn::isRendered() const
|
|
{
|
|
if (!getXsheet() || !getFx())
|
|
return false;
|
|
if (!isPreviewVisible())
|
|
return false;
|
|
return getXsheet()->getFxDag()->isRendered(getFx());
|
|
}
|
|
|
|
/*
|
|
bool TXshColumn::isReference() const
|
|
{
|
|
if(!getXsheet() || !getFx()) return true;
|
|
if(getXsheet()->getFxDag()->getTerminalFxs()->containsFx(getFx())) return false;
|
|
return getFx()->getOutputConnectionCount()==0;
|
|
}
|
|
*/
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool TXshColumn::isControl() const
|
|
{
|
|
if (!getXsheet() || !getFx())
|
|
return false;
|
|
return getXsheet()->getFxDag()->isControl(getFx());
|
|
/*
|
|
TFx *fx = getFx();
|
|
if(!fx) return false;
|
|
if(!getXsheet()) return false;
|
|
if(getXsheet()->getFxDag()->getTerminalFxs()->containsFx(getFx())) return false;
|
|
for(int i=0;i<fx->getOutputConnectionCount();i++)
|
|
{
|
|
TFxPort *port = fx->getOutputConnection(i);
|
|
if(port->getOwnerFx()->getInputPort(0) != port)
|
|
return true;
|
|
}
|
|
return false;
|
|
*/
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
#ifdef LEVO
|
|
void TXshColumn::setCamstandNextState()
|
|
{
|
|
setCamstandVisible(!isCamstandVisible());
|
|
|
|
if (Preferences::instance()->isCamStandOpacityEnabled()) {
|
|
// camera stand, 3-state-toggle: notvisible -> visible+nottransparent -> visible+transparent
|
|
if (isCamstandVisible()) {
|
|
if (isCamstandTransparent())
|
|
setCamstandVisible(false);
|
|
else
|
|
setCamstandTransparent(true);
|
|
} else {
|
|
setCamstandVisible(true);
|
|
setCamstandTransparent(false);
|
|
}
|
|
} else {
|
|
setCamstandTransparent(false);
|
|
setCamstandVisible(!isCamstandVisible());
|
|
}
|
|
}
|
|
#endif
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool TXshColumn::isCamstandVisible() const
|
|
{
|
|
return (m_status & eCamstandVisible) == 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*
|
|
bool TXshColumn::isCamstandTransparent() const
|
|
{
|
|
return (m_status&eCamstandTransparent)!=0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
void TXshColumn::setCamstandTransparent(bool on)
|
|
{
|
|
const int mask = eCamstandTransparent;
|
|
if(!on) m_status&=~mask; else m_status|=mask;
|
|
}
|
|
*/
|
|
|
|
void TXshColumn::setCamstandVisible(bool on)
|
|
{
|
|
const int mask = eCamstandVisible;
|
|
if (on)
|
|
m_status &= ~mask;
|
|
else
|
|
m_status |= mask;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool TXshColumn::isPreviewVisible() const
|
|
{
|
|
return (m_status & ePreviewVisible) == 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TXshColumn::setPreviewVisible(bool on)
|
|
{
|
|
const int mask = ePreviewVisible;
|
|
if (on)
|
|
m_status &= ~mask;
|
|
else
|
|
m_status |= mask;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool TXshColumn::isLocked() const
|
|
{
|
|
return (m_status & eLocked) != 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TXshColumn::lock(bool on)
|
|
{
|
|
const int mask = eLocked;
|
|
if (on)
|
|
m_status |= mask;
|
|
else
|
|
m_status &= ~mask;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool TXshColumn::isMask() const
|
|
{
|
|
return (m_status & eMasked) != 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TXshColumn::setIsMask(bool on)
|
|
{
|
|
const int mask = eMasked;
|
|
if (on)
|
|
m_status |= mask;
|
|
else
|
|
m_status &= ~mask;
|
|
}
|