| |
| |
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| namespace { |
| |
| // Global variables |
| |
| typedef std::pair<std::string, TTool::ToolTargetType> ToolKey; |
| typedef std::map<ToolKey, TTool *> ToolTable; |
| ToolTable *toolTable = 0; |
| |
| std::set<std::string> *toolNames = 0; |
| |
| |
| |
| |
| |
| struct DummyTool final : public TTool { |
| ToolType getToolType() const override { |
| return TTool::LevelReadTool; |
| } |
| ToolTargetType getTargetType() const { |
| return TTool::NoTarget; |
| } |
| int getCursorId() const override { |
| return ToolCursor::ForbiddenCursor; |
| } |
| |
| DummyTool() : TTool("T_Dummy") {} |
| |
| } theDummyTool; |
| |
| |
| |
| class ToolSelector { |
| std::string m_toolName; |
| |
| public: |
| ToolSelector(std::string toolName) : m_toolName(toolName) {} |
| |
| void selectTool() { |
| TTool::Application *app = TTool::getApplication(); |
| if (app) app->getCurrentTool()->setTool(QString::fromStdString(m_toolName)); |
| } |
| }; |
| |
| |
| |
| |
| |
| TFrameId getNewFrameId(TXshSimpleLevel *sl, int row) { |
| TFrameId fid(row + 1); |
| if (sl->isFid(fid)) { |
| fid = TFrameId(fid.getNumber(), 'a'); |
| while (fid.getLetter() < 'z' && sl->isFid(fid)) |
| fid = TFrameId(fid.getNumber(), fid.getLetter() + 1); |
| } |
| return fid; |
| } |
| |
| } |
| |
| |
| |
| |
| |
| TTool::Application *TTool::m_application = 0; |
| std::set<TFrameId> TTool::m_selectedFrames = std::set<TFrameId>(); |
| bool TTool::m_isLevelCreated = false; |
| bool TTool::m_isFrameCreated = false; |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| std::vector<int> TTool::m_cellsData; |
| |
| |
| |
| |
| |
| TTool::TTool(std::string name) |
| : m_name(name) |
| , m_viewer(0) |
| , m_targetType(NoTarget) |
| , m_enabled(true) |
| , m_active(false) |
| , m_picking(false) {} |
| |
| |
| |
| TTool *TTool::getTool(std::string toolName, ToolTargetType targetType) { |
| if (!toolTable) return 0; |
| ToolTable::iterator it = |
| toolTable->find(std::make_pair(toolName, targetType)); |
| if (it == toolTable->end()) return 0; |
| return it->second; |
| } |
| |
| |
| |
| void TTool::bind(int targetType) { |
| m_targetType = targetType; |
| |
| if (!toolTable) toolTable = new ToolTable(); |
| |
| if (!toolNames) toolNames = new std::set<std::string>(); |
| |
| std::string name = getName(); |
| if (toolNames->count(name) == 0) { |
| toolNames->insert(name); |
| |
| |
| toolTable->insert( |
| std::make_pair(std::make_pair(name, ToonzImage), &theDummyTool)); |
| toolTable->insert( |
| std::make_pair(std::make_pair(name, VectorImage), &theDummyTool)); |
| toolTable->insert( |
| std::make_pair(std::make_pair(name, RasterImage), &theDummyTool)); |
| toolTable->insert( |
| std::make_pair(std::make_pair(name, MeshImage), &theDummyTool)); |
| |
| ToolSelector *toolSelector = new ToolSelector(name); |
| CommandManager::instance()->setHandler( |
| name.c_str(), new CommandHandlerHelper<ToolSelector>( |
| toolSelector, &ToolSelector::selectTool)); |
| } |
| |
| if (targetType & ToonzImage) |
| (*toolTable)[std::make_pair(name, ToonzImage)] = this; |
| if (targetType & VectorImage) |
| (*toolTable)[std::make_pair(name, VectorImage)] = this; |
| if (targetType & RasterImage) |
| (*toolTable)[std::make_pair(name, RasterImage)] = this; |
| if (targetType & MeshImage) |
| (*toolTable)[std::make_pair(name, MeshImage)] = this; |
| } |
| |
| |
| |
| ToolOptionsBox *TTool::createOptionsBox() { |
| TPaletteHandle *currPalette = |
| m_application->getPaletteController()->getCurrentLevelPalette(); |
| ToolHandle *currTool = m_application->getCurrentTool(); |
| return new GenericToolOptionsBox(0, this, currPalette, 0, currTool); |
| } |
| |
| |
| |
| double TTool::getPixelSize() const { |
| return m_viewer ? m_viewer->getPixelSize() : 1.0; |
| } |
| |
| |
| |
| TXshCell TTool::getImageCell() { |
| assert(m_application); |
| |
| TXshCell result; |
| |
| TFrameHandle *currentFrame = m_application->getCurrentFrame(); |
| TXshLevelHandle *currentLevel = m_application->getCurrentLevel(); |
| |
| if (currentFrame->isEditingLevel()) { |
| if (TXshLevel *xl = currentLevel->getLevel()) { |
| if (TXshSimpleLevel *sl = xl->getSimpleLevel()) { |
| result.m_level = xl; |
| result.m_frameId = currentFrame->getFid(); |
| } |
| } |
| } else { |
| if (TXsheet *xsh = m_application->getCurrentXsheet()->getXsheet()) { |
| if (!m_application->getCurrentObject()->isSpline()) { |
| int row = currentFrame->getFrame(); |
| int col = m_application->getCurrentColumn()->getColumnIndex(); |
| |
| result = xsh->getCell(row, col); |
| } |
| } |
| } |
| |
| return result; |
| } |
| |
| |
| |
| TImage *TTool::getImage(bool toBeModified, int subsampling) { |
| assert(m_application); |
| |
| if (m_application->getCurrentFrame()->isPlaying()) |
| toBeModified = |
| false; |
| |
| const TXshCell &cell = getImageCell(); |
| if (cell.isEmpty()) { |
| TObjectHandle *currentObject = m_application->getCurrentObject(); |
| return currentObject->isSpline() ? currentObject->getSplineImage() |
| : (TImage *)0; |
| } else |
| return cell.getImage(toBeModified, subsampling).getPointer(); |
| } |
| |
| |
| |
| TImage *TTool::touchImage() { |
| if (!m_application) return 0; |
| |
| m_cellsData.clear(); |
| |
| m_isLevelCreated = false; |
| m_isFrameCreated = false; |
| Preferences *pref = Preferences::instance(); |
| |
| bool isAutoCreateEnabled = pref->isAutoCreateEnabled(); |
| bool animationSheetEnabled = pref->isAnimationSheetEnabled(); |
| bool isAutoStretchEnabled = pref->isAutoStretchEnabled(); |
| |
| TFrameHandle *currentFrame = m_application->getCurrentFrame(); |
| TXshLevelHandle *currentLevel = m_application->getCurrentLevel(); |
| |
| if (currentFrame->isEditingLevel()) { |
| |
| |
| |
| TXshLevel *xl = currentLevel->getLevel(); |
| if (!xl) return 0; |
| TXshSimpleLevel *sl = xl->getSimpleLevel(); |
| if (!sl || sl->isEmpty()) return 0; |
| |
| TFrameId fid = currentFrame->getFid(); |
| TImageP img = sl->getFrame(fid, true); |
| if (!img) { |
| |
| if (sl->isSubsequence() || sl->isReadOnly() || !isAutoCreateEnabled) |
| return 0; |
| |
| |
| img = sl->createEmptyFrame(); |
| sl->setFrame(fid, img); |
| currentLevel->notifyLevelChange(); |
| m_isFrameCreated = true; |
| } |
| return img.getPointer(); |
| } else { |
| |
| if (m_application->getCurrentObject()->isSpline()) return 0; |
| |
| TSceneHandle *currentScene = m_application->getCurrentScene(); |
| ToonzScene *scene = currentScene->getScene(); |
| int row = currentFrame->getFrame(); |
| int col = m_application->getCurrentColumn()->getColumnIndex(); |
| if (col < 0) return 0; |
| |
| TXsheetHandle *currentXsheet = m_application->getCurrentXsheet(); |
| TXsheet *xsh = currentXsheet->getXsheet(); |
| if (!xsh) return 0; |
| |
| TXshCell cell = xsh->getCell(row, col); |
| TXshSimpleLevel *sl = cell.getSimpleLevel(); |
| |
| if (sl != 0) { |
| |
| if (isAutoCreateEnabled && animationSheetEnabled && row > 0 && |
| xsh->getCell(row - 1, col) == xsh->getCell(row, col)) { |
| |
| |
| |
| int r0 = row, r1 = row; |
| if (isAutoStretchEnabled) |
| while (xsh->getCell(r1 + 1, col) == cell) r1++; |
| |
| |
| TFrameId fid = getNewFrameId(sl, row); |
| |
| TImageP img = sl->createEmptyFrame(); |
| m_isFrameCreated = true; |
| |
| sl->setFrame(fid, img); |
| |
| cell = TXshCell(sl, fid); |
| |
| |
| for (int r = r0; r <= r1; r++) xsh->setCell(r, col, cell); |
| |
| currentXsheet->notifyXsheetChanged(); |
| currentScene->notifyCastChange(); |
| currentLevel->notifyLevelChange(); |
| m_cellsData.push_back(r0); |
| m_cellsData.push_back(r1); |
| m_cellsData.push_back(0); |
| } |
| |
| return cell.getImage(true).getPointer(); |
| } |
| |
| |
| if (!isAutoCreateEnabled) return 0; |
| |
| |
| int r0, r1; |
| xsh->getCellRange(col, r0, r1); |
| |
| if (animationSheetEnabled && r0 <= r1) { |
| |
| |
| |
| |
| |
| int a = row - 1, b = row + 1; |
| while (a >= r0 && xsh->getCell(a, col).isEmpty()) a--; |
| while (b <= r1 && xsh->getCell(b, col).isEmpty()) b++; |
| |
| |
| if (a >= r0) { |
| |
| sl = xsh->getCell(a, col).getSimpleLevel(); |
| } else if (b <= r1) { |
| sl = xsh->getCell(b, col).getSimpleLevel(); |
| } |
| if (sl) { |
| |
| |
| |
| |
| |
| |
| |
| TFrameId fid = getNewFrameId(sl, row); |
| |
| TImageP img = sl->createEmptyFrame(); |
| m_isFrameCreated = true; |
| |
| sl->setFrame(fid, img); |
| |
| cell = TXshCell(sl, fid); |
| xsh->setCell(row, col, cell); |
| |
| |
| if (!isAutoStretchEnabled) { |
| m_cellsData.push_back(row); |
| m_cellsData.push_back(row); |
| m_cellsData.push_back(2); |
| } else { |
| if (a >= r0) { |
| |
| TXshCell aCell = xsh->getCell(a, col); |
| for (int i = a + 1; i < row; i++) xsh->setCell(i, col, aCell); |
| m_cellsData.push_back(a + 1); |
| m_cellsData.push_back(row - 1); |
| m_cellsData.push_back(1); |
| |
| if (b <= r1 && xsh->getCell(b, col).getSimpleLevel() == sl) { |
| |
| for (int i = row + 1; i < b; i++) xsh->setCell(i, col, cell); |
| m_cellsData.push_back(row); |
| m_cellsData.push_back(b - 1); |
| m_cellsData.push_back(2); |
| } else { |
| m_cellsData.push_back(row); |
| m_cellsData.push_back(row); |
| m_cellsData.push_back(2); |
| } |
| } else if (b <= r1) { |
| |
| for (int i = row + 1; i < b; i++) xsh->setCell(i, col, cell); |
| m_cellsData.push_back(row); |
| m_cellsData.push_back(b - 1); |
| m_cellsData.push_back(2); |
| } |
| } |
| } |
| |
| currentXsheet->notifyXsheetChanged(); |
| currentScene->notifyCastChange(); |
| currentLevel->notifyLevelChange(); |
| return cell.getImage(true).getPointer(); |
| } |
| |
| if (row > 0 && xsh->getCell(row - 1, col).getSimpleLevel() != 0 && |
| !animationSheetEnabled) { |
| sl = xsh->getCell(row - 1, col).getSimpleLevel(); |
| if (sl->getType() != OVL_XSHLEVEL || |
| sl->getPath().getFrame() != TFrameId::NO_FRAME) { |
| |
| |
| |
| currentLevel->setLevel(sl); |
| if (sl->isSubsequence() || sl->isReadOnly()) return 0; |
| TFrameId fid = sl->index2fid(sl->getFrameCount()); |
| TImageP img = sl->createEmptyFrame(); |
| m_isFrameCreated = true; |
| sl->setFrame(fid, img); |
| cell = TXshCell(sl, fid); |
| xsh->setCell(row, col, cell); |
| currentXsheet->notifyXsheetChanged(); |
| currentScene->notifyCastChange(); |
| currentLevel->notifyLevelChange(); |
| return img.getPointer(); |
| } |
| } |
| |
| |
| |
| int levelType = pref->getDefLevelType(); |
| TXshLevel *xl = scene->createNewLevel(levelType); |
| sl = xl->getSimpleLevel(); |
| m_isLevelCreated = true; |
| |
| |
| TFrameId fid = animationSheetEnabled ? getNewFrameId(sl, row) : TFrameId(1); |
| TImageP img = sl->createEmptyFrame(); |
| m_isFrameCreated = true; |
| sl->setFrame(fid, img); |
| cell = TXshCell(sl, fid); |
| xsh->setCell(row, col, cell); |
| if (animationSheetEnabled) { |
| m_cellsData.push_back(row); |
| m_cellsData.push_back(row); |
| m_cellsData.push_back(2); |
| } |
| |
| currentXsheet->notifyXsheetChanged(); |
| currentScene->notifyCastChange(); |
| currentLevel->notifyLevelChange(); |
| return img.getPointer(); |
| } |
| } |
| |
| |
| |
| void TTool::updateToolsPropertiesTranslation() { |
| ToolTable::iterator tt, tEnd(toolTable->end()); |
| for (tt = toolTable->begin(); tt != tEnd; ++tt) |
| tt->second->updateTranslation(); |
| } |
| |
| |
| |
| void TTool::invalidate(const TRectD &rect) { |
| if (m_viewer) { |
| if (rect.isEmpty()) |
| m_viewer->GLInvalidateAll(); |
| else { |
| TPointD dpiScale(1, 1); |
| TXshSimpleLevel *sl = |
| getApplication()->getCurrentLevel()->getSimpleLevel(); |
| if (sl) dpiScale = getCurrentDpiScale(sl, getCurrentFid()); |
| m_viewer->GLInvalidateRect(getCurrentColumnMatrix() * |
| TScale(dpiScale.x, dpiScale.y) * rect); |
| } |
| } |
| } |
| |
| |
| |
| int TTool::pick(const TPointD &p) { |
| if (!m_viewer) return 0; |
| |
| m_picking = true; |
| int ret = m_viewer->pick(p); |
| m_picking = false; |
| |
| return ret; |
| } |
| |
| |
| |
| TXsheet *TTool::getXsheet() const { |
| if (!m_application) return 0; |
| return m_application->getCurrentXsheet()->getXsheet(); |
| } |
| |
| |
| |
| int TTool::getFrame() { |
| if (!m_application) return 0; |
| return m_application->getCurrentFrame()->getFrame(); |
| } |
| |
| |
| |
| int TTool::getColumnIndex() { |
| if (!m_application) return 0; |
| return m_application->getCurrentColumn()->getColumnIndex(); |
| } |
| |
| |
| |
| TStageObjectId TTool::getObjectId() { |
| if (!m_application) return TStageObjectId(); |
| return m_application->getCurrentObject()->getObjectId(); |
| } |
| |
| |
| |
| TTool::Application *TTool::getApplication() { |
| if (m_application == 0) |
| assert(!"you MUST call the TTool::setApplication function in the main of the program!"); |
| return m_application; |
| } |
| |
| |
| |
| |
| |
| |
| |
| void TTool::notifyImageChanged() { |
| onImageChanged(); |
| |
| if (!m_application) return; |
| |
| m_application->getCurrentScene()->setDirtyFlag(true); |
| if (m_application->getCurrentFrame()->isEditingLevel()) { |
| TXshLevel *xl = m_application->getCurrentLevel()->getLevel(); |
| if (!xl) return; |
| TXshSimpleLevel *sl = xl->getSimpleLevel(); |
| if (!sl) return; |
| TFrameId fid = m_application->getCurrentFrame()->getFid(); |
| sl->touchFrame(fid); |
| |
| IconGenerator::instance()->invalidate(sl, fid); |
| IconGenerator::instance()->invalidateSceneIcon(); |
| } else { |
| TXsheet *xsh = m_application->getCurrentXsheet()->getXsheet(); |
| if (!xsh) return; |
| |
| TObjectHandle *currentObject = m_application->getCurrentObject(); |
| |
| if (currentObject->isSpline()) { |
| m_application->getCurrentObject()->commitSplineChanges(); |
| TStageObject *pegbar = xsh->getStageObject(currentObject->getObjectId()); |
| IconGenerator::instance()->invalidate(pegbar->getSpline()); |
| } else { |
| int row = m_application->getCurrentFrame()->getFrame(); |
| int col = m_application->getCurrentColumn()->getColumnIndex(); |
| if (col < 0) return; |
| TXshCell cell = xsh->getCell(row, col); |
| TXshSimpleLevel *sl = cell.getSimpleLevel(); |
| if (sl) { |
| IconGenerator::instance()->invalidate(sl, cell.m_frameId); |
| sl->touchFrame(cell.m_frameId); |
| IconGenerator::instance()->invalidateSceneIcon(); |
| } |
| } |
| } |
| m_application->getCurrentLevel()->notifyLevelChange(); |
| } |
| |
| |
| |
| |
| |
| void TTool::notifyImageChanged(const TFrameId &fid) { |
| onImageChanged(); |
| |
| if (!m_application) return; |
| |
| m_application->getCurrentScene()->setDirtyFlag(true); |
| if (m_application->getCurrentFrame()->isEditingLevel()) { |
| TXshLevel *xl = m_application->getCurrentLevel()->getLevel(); |
| if (!xl) return; |
| TXshSimpleLevel *sl = xl->getSimpleLevel(); |
| if (!sl) return; |
| sl->setDirtyFlag(true); |
| IconGenerator::instance()->invalidate(sl, fid); |
| IconGenerator::instance()->invalidateSceneIcon(); |
| } else { |
| int row = m_application->getCurrentFrame()->getFrame(); |
| int col = m_application->getCurrentColumn()->getColumnIndex(); |
| if (col < 0) return; |
| TXsheet *xsh = m_application->getCurrentXsheet()->getXsheet(); |
| if (!xsh) return; |
| TXshCell cell = xsh->getCell(row, col); |
| TXshSimpleLevel *sl = cell.getSimpleLevel(); |
| if (sl) { |
| IconGenerator::instance()->invalidate(sl, fid); |
| IconGenerator::instance()->invalidateSceneIcon(); |
| sl->setDirtyFlag(true); |
| } |
| } |
| m_application->getCurrentLevel()->notifyLevelChange(); |
| } |
| |
| |
| |
| TFrameId TTool::getCurrentFid() const { |
| if (!m_application) return TFrameId(); |
| |
| TFrameHandle *fh = m_application->getCurrentFrame(); |
| |
| if (fh->isEditingLevel()) return fh->getFid(); |
| |
| int row = m_application->getCurrentFrame()->getFrame(); |
| int col = m_application->getCurrentColumn()->getColumnIndex(); |
| TXshCell cell = |
| m_application->getCurrentXsheet()->getXsheet()->getCell(row, col); |
| if (cell.isEmpty()) return TFrameId::NO_FRAME; |
| |
| return cell.getFrameId(); |
| } |
| |
| |
| |
| TAffine TTool::getCurrentColumnMatrix() const { |
| return getColumnMatrix(m_application->getCurrentColumn()->getColumnIndex()); |
| } |
| |
| |
| |
| TAffine TTool::getCurrentColumnParentMatrix() const { |
| if (!m_application) return TAffine(); |
| |
| TFrameHandle *fh = m_application->getCurrentFrame(); |
| if (fh->isEditingLevel()) return TAffine(); |
| int frame = fh->getFrame(); |
| int columnIndex = m_application->getCurrentColumn()->getColumnIndex(); |
| TXsheet *xsh = m_application->getCurrentXsheet()->getXsheet(); |
| TStageObjectId parentId = |
| xsh->getStageObjectParent(TStageObjectId::ColumnId(columnIndex)); |
| return xsh->getPlacement(parentId, frame); |
| } |
| |
| |
| |
| TAffine TTool::getCurrentObjectParentMatrix() const { |
| if (!m_application) return TAffine(); |
| |
| TXsheet *xsh = m_application->getCurrentXsheet()->getXsheet(); |
| int frame = m_application->getCurrentFrame()->getFrame(); |
| TStageObjectId currentObjectId = |
| m_application->getCurrentObject()->getObjectId(); |
| if (currentObjectId == TStageObjectId::NoneId) return TAffine(); |
| TStageObjectId parentId = xsh->getStageObjectParent(currentObjectId); |
| if (parentId == TStageObjectId::NoneId) |
| return TAffine(); |
| else |
| return xsh->getPlacement(parentId, frame); |
| } |
| |
| |
| |
| TAffine TTool::getColumnMatrix(int columnIndex) const { |
| if (!m_application) return TAffine(); |
| |
| TFrameHandle *fh = m_application->getCurrentFrame(); |
| if (fh->isEditingLevel()) return TAffine(); |
| int frame = fh->getFrame(); |
| TXsheet *xsh = m_application->getCurrentXsheet()->getXsheet(); |
| TStageObjectId columnId = TStageObjectId::ColumnId(columnIndex); |
| TAffine columnPlacement = xsh->getPlacement(columnId, frame); |
| double columnZ = xsh->getZ(columnId, frame); |
| |
| TStageObjectId cameraId = xsh->getStageObjectTree()->getCurrentCameraId(); |
| TStageObject *camera = xsh->getStageObject(cameraId); |
| TAffine cameraPlacement = camera->getPlacement(frame); |
| double cameraZ = camera->getZ(frame); |
| |
| TStageObject *object = xsh->getStageObject(columnId); |
| TAffine placement; |
| TStageObject::perspective(placement, cameraPlacement, cameraZ, |
| columnPlacement, columnZ, |
| object->getGlobalNoScaleZ()); |
| |
| return placement; |
| } |
| |
| |
| |
| TAffine TTool::getCurrentObjectParentMatrix2() const { |
| TTool::Application *app = m_application; |
| TFrameHandle *fh = app->getCurrentFrame(); |
| if (fh->isEditingLevel()) return TAffine(); |
| int frame = fh->getFrame(); |
| TXsheet *xsh = app->getCurrentXsheet()->getXsheet(); |
| TStageObjectId id = app->getCurrentObject()->getObjectId(); |
| double objZ = xsh->getZ(id, frame); |
| TStageObjectId parentId = xsh->getStageObjectParent(id); |
| if (parentId == TStageObjectId::NoneId) return TAffine(); |
| id = parentId; |
| TAffine objPlacement = xsh->getPlacement(id, frame); |
| |
| TStageObjectId cameraId = xsh->getStageObjectTree()->getCurrentCameraId(); |
| TStageObject *camera = xsh->getStageObject(cameraId); |
| TAffine cameraPlacement = camera->getPlacement(frame); |
| double cameraZ = camera->getZ(frame); |
| |
| TAffine placement; |
| TStageObject::perspective(placement, cameraPlacement, cameraZ, objPlacement, |
| objZ, 0); |
| return placement; |
| } |
| |
| |
| |
| void TTool::updateMatrix() { |
| assert(m_application); |
| |
| if (m_application->getCurrentObject()->isSpline()) |
| setMatrix(getCurrentObjectParentMatrix2()); |
| else |
| setMatrix(getCurrentColumnMatrix()); |
| } |
| |
| |
| |
| void TTool::resetInputMethod() { |
| if (m_viewer) m_viewer->resetInputMethod(); |
| } |
| |
| |
| |
| bool TTool::isColumnLocked(int columnIndex) const { |
| if (columnIndex < 0) return false; |
| TXsheet *xsh = getXsheet(); |
| TXshColumn *column = xsh->getColumn(columnIndex); |
| return column->isLocked(); |
| } |
| |
| |
| |
| QString TTool::updateEnabled() { |
| |
| if (m_application->getCurrentFrame()->isPlaying()) |
| return (enable(false), QString()); |
| |
| |
| int toolType = getToolType(); |
| int targetType = getTargetType(); |
| |
| if (toolType == TTool::GenericTool) return (enable(true), QString()); |
| |
| |
| TXsheet *xsh = m_application->getCurrentXsheet()->getXsheet(); |
| |
| int rowIndex = m_application->getCurrentFrame()->getFrame(); |
| int columnIndex = m_application->getCurrentColumn()->getColumnIndex(); |
| TXshColumn *column = (columnIndex >= 0) ? xsh->getColumn(columnIndex) : 0; |
| |
| TXshLevel *xl = m_application->getCurrentLevel()->getLevel(); |
| TXshSimpleLevel *sl = xl ? xl->getSimpleLevel() : 0; |
| int levelType = sl ? sl->getType() : NO_XSHLEVEL; |
| |
| TStageObject *obj = |
| xsh->getStageObject(TStageObjectId::ColumnId(columnIndex)); |
| bool spline = m_application->getCurrentObject()->isSpline(); |
| |
| bool filmstrip = m_application->getCurrentFrame()->isEditingLevel(); |
| |
| |
| if (m_name == T_StylePicker && |
| Preferences::instance()->isMultiLayerStylePickerEnabled()) |
| return (enable(true), QString()); |
| |
| |
| if (column && !filmstrip) { |
| if (column->isLocked()) |
| return (enable(false), QObject::tr("The current column is locked.")); |
| |
| else if (!column->isCamstandVisible()) |
| return (enable(false), QObject::tr("The current column is hidden.")); |
| |
| else if (column->getSoundColumn()) |
| return (enable(false), |
| QObject::tr("It is not possible to edit the audio column.")); |
| |
| else if (column->getSoundTextColumn()) |
| return ( |
| enable(false), |
| QObject::tr( |
| "Note columns can only be edited in the xsheet or timeline.")); |
| |
| if (toolType == TTool::ColumnTool) { |
| |
| if (column->getLevelColumn() && !(targetType & LevelColumns)) |
| return ( |
| enable(false), |
| QObject::tr("The current tool cannot be used on a Level column.")); |
| |
| if (column->getMeshColumn() && !(targetType & MeshColumns)) |
| return ( |
| enable(false), |
| QObject::tr("The current tool cannot be used on a Mesh column.")); |
| } |
| } |
| |
| |
| if (toolType == TTool::ColumnTool) { |
| if (filmstrip) |
| return ( |
| enable(false), |
| QObject::tr("The current tool cannot be used in Level Strip mode.")); |
| |
| if ((!column || column->isEmpty()) && !(targetType & TTool::EmptyTarget)) |
| return (enable(false), QString()); |
| } |
| |
| |
| if (toolType & TTool::LevelTool) { |
| |
| if (spline) { |
| return (targetType & Splines) |
| ? (enable(true), QString()) |
| : (enable(false), QObject::tr("The current tool cannot be " |
| "used to edit a motion path.")); |
| } |
| |
| |
| if (!xl) |
| return (targetType & EmptyTarget) ? (enable(true), QString()) |
| : (enable(false), QString()); |
| |
| |
| if (!sl) |
| return (enable(false), |
| QObject::tr("The current level is not editable.")); |
| |
| |
| |
| |
| { |
| if ((levelType == PLI_XSHLEVEL) && !(targetType & VectorImage)) |
| return ( |
| enable(false), |
| QObject::tr("The current tool cannot be used on a Vector Level.")); |
| |
| if ((levelType == TZP_XSHLEVEL) && !(targetType & ToonzImage)) |
| return ( |
| enable(false), |
| QObject::tr("The current tool cannot be used on a Toonz Level.")); |
| |
| if ((levelType == OVL_XSHLEVEL) && !(targetType & RasterImage)) |
| return ( |
| enable(false), |
| QObject::tr("The current tool cannot be used on a Raster Level.")); |
| |
| if ((levelType == MESH_XSHLEVEL) && !(targetType & MeshImage)) |
| return ( |
| enable(false), |
| QObject::tr("The current tool cannot be used on a Mesh Level.")); |
| } |
| |
| |
| if ((levelType & LEVELCOLUMN_XSHLEVEL) && !filmstrip) { |
| |
| const TStageObjectId &parentId = obj->getParent(); |
| if (parentId.isColumn() && obj->getParentHandle()[0] != 'H') { |
| TXshSimpleLevel *parentSl = |
| xsh->getCell(rowIndex, parentId.getIndex()).getSimpleLevel(); |
| if (parentSl && parentSl->getType() == MESH_XSHLEVEL) |
| return ( |
| enable(false), |
| QObject::tr( |
| "The current tool cannot be used on a mesh-deformed level")); |
| } |
| } |
| |
| |
| if (toolType == TTool::LevelWriteTool) { |
| |
| if (sl->isReadOnly()) { |
| const std::set<TFrameId> &editableFrames = sl->getEditableRange(); |
| TFrameId currentFid = getCurrentFid(); |
| |
| if (editableFrames.find(currentFid) == editableFrames.end()) |
| return ( |
| enable(false), |
| QObject::tr( |
| "The current frame is locked: any editing is forbidden.")); |
| } |
| |
| |
| if (sl->getPath().getType() == |
| "psd" || |
| sl->is16BitChannelLevel() || |
| |
| sl->getProperties()->getBpp() == |
| 1) |
| |
| return (enable(false), |
| QObject::tr("The current level is not editable.")); |
| } |
| } |
| |
| return (enable(true), QString()); |
| } |
| |
| |
| |
| void TTool::setSelectedFrames(const std::set<TFrameId> &selectedFrames) { |
| m_selectedFrames = selectedFrames; |
| onSelectedFramesChanged(); |
| } |
| |