1702 lines
52 KiB
C++
1702 lines
52 KiB
C++
|
|
|
|
#include "toonzqt/paletteviewergui.h"
|
|
|
|
// TnzQt includes
|
|
#include "toonzqt/styleselection.h"
|
|
#include "toonzqt/trepetitionguard.h"
|
|
#include "toonzqt/gutil.h"
|
|
#include "toonzqt/paletteviewer.h"
|
|
#include "toonzqt/selectioncommandids.h"
|
|
#include "toonzqt/stylenameeditor.h"
|
|
#include "toonzqt/viewcommandids.h"
|
|
#include "palettedata.h"
|
|
|
|
// TnzLib includes
|
|
#include "toonz/palettecmd.h"
|
|
#include "toonz/txshlevel.h"
|
|
#include "toonz/studiopalette.h"
|
|
#include "toonz/txsheethandle.h"
|
|
#include "toonz/tframehandle.h"
|
|
#include "toonz/imagestyles.h"
|
|
#include "toonz/preferences.h"
|
|
|
|
// TnzCore includes
|
|
#include "tcolorstyles.h"
|
|
#include "tundo.h"
|
|
#include "tenv.h"
|
|
|
|
// Qt includes
|
|
#include <QPainter>
|
|
#include <QMouseEvent>
|
|
#include <QKeyEvent>
|
|
#include <QMenuBar>
|
|
#include <QToolTip>
|
|
#include <QDrag>
|
|
#include <QAction>
|
|
#include <QShortcut>
|
|
|
|
// enable to set font size for style name separately from other texts
|
|
TEnv::IntVar EnvSoftwareCurrentFontSize_StyleName("SoftwareCurrentFontSize_StyleName", 11);
|
|
|
|
using namespace PaletteViewerGUI;
|
|
using namespace DVGui;
|
|
|
|
//=============================================================================
|
|
/*! \namespace PaletteViewerGUI
|
|
\brief Provides a collection of widget to show \b palette.
|
|
*/
|
|
|
|
//=============================================================================
|
|
/*! \enum PaletteViewerGUI::PaletteViewType
|
|
\brief Useful to mark different palette viewer type.
|
|
|
|
There are three possible palette to view:
|
|
\li level palette, palette of current level;
|
|
\li cleanup palette, current scene cleanup palette;
|
|
\li studio palette.
|
|
*/
|
|
|
|
//=============================================================================
|
|
/*! \class PaletteViewerGUI::PageViewer
|
|
\brief The PageViewer class provides an object to view and manage palettes page.
|
|
|
|
Inherits \b QFrame and \b TSelection::View.
|
|
|
|
This object allows to show and manage a single palette page. An enum type
|
|
\b PaletteViewerGUI::PageViewer::ViewMode, getViewMode(), specify visualization
|
|
mode, it is possible set it using setViewMode(). Class manage all mouse event,
|
|
move, press, drag and drop.
|
|
*/
|
|
/*! \enum PaletteViewerGUI::PageViewer::ViewMode
|
|
Useful to mark different page view moed:
|
|
\li SmallChips: displays styles as small squares; the name of the style is
|
|
displayed as tooltip.
|
|
\li SmallChipsWithName:
|
|
displays styles as small squares with the name insde.
|
|
\li LargeChips: displays the styles on top of the name of the style.
|
|
\li List: List displays style thumbnails next to their names in a list;
|
|
if the palette styles are referring to a studio palette, its
|
|
path will be displayed along with the style name.
|
|
*/
|
|
/*! \fn TPalette::Page* PageViewer::getPage() const
|
|
Return current page.
|
|
*/
|
|
/*! \fn ViewMode PageViewer::getViewMode() const
|
|
Return current page view mode \b PaletteViewerGUI::PageViewer::ViewMode.
|
|
*/
|
|
/*! \fn void TPalette::onSelectionChanged()
|
|
Update current page view.
|
|
*/
|
|
PageViewer::PageViewer(QWidget *parent, PaletteViewType viewType, bool hasPasteColors)
|
|
: QFrame(parent), m_page(0), m_chipsOrigin(2, 2), m_chipPerRow(0), m_viewMode(SmallChips), m_styleSelection(new TStyleSelection()), m_frameHandle(0), m_renameTextField(new LineEdit(this)), m_dropPositionIndex(-1), m_dropPageCreated(false), m_startDrag(false), m_viewType(viewType), m_nameDisplayMode(Style), m_hasPasteColors(hasPasteColors), m_changeStyleCommand(0)
|
|
{
|
|
setFrameStyle(QFrame::StyledPanel);
|
|
setObjectName("PageViewer");
|
|
setFocusPolicy(Qt::StrongFocus);
|
|
CommandManager *cmd = CommandManager::instance();
|
|
QAction *pasteValueAct = cmd->getAction(MI_PasteInto);
|
|
addAction(pasteValueAct);
|
|
if (m_hasPasteColors) {
|
|
QAction *pasteColorsAct = cmd->getAction(MI_PasteColors);
|
|
addAction(pasteColorsAct);
|
|
}
|
|
|
|
m_styleNameEditor = new StyleNameEditor(this);
|
|
m_styleNameEditor->hide();
|
|
|
|
m_renameTextField->hide();
|
|
m_renameTextField->setObjectName("RenameColorTextField");
|
|
connect(m_renameTextField, SIGNAL(editingFinished()), this, SLOT(onStyleRenamed()));
|
|
m_styleSelection->setView(this);
|
|
setAcceptDrops(true);
|
|
|
|
// applying default chip sizes
|
|
ViewMode defaultChipSize;
|
|
switch (m_viewType) {
|
|
case LEVEL_PALETTE:
|
|
defaultChipSize = (ViewMode)ChipSizeManager::instance()->chipSize_Palette;
|
|
break;
|
|
case CLEANUP_PALETTE:
|
|
defaultChipSize = (ViewMode)ChipSizeManager::instance()->chipSize_Cleanup;
|
|
break;
|
|
case STUDIO_PALETTE:
|
|
defaultChipSize = (ViewMode)ChipSizeManager::instance()->chipSize_Studio;
|
|
break;
|
|
default:
|
|
defaultChipSize = (ViewMode)2;
|
|
break;
|
|
}
|
|
setViewMode(defaultChipSize);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
PageViewer::~PageViewer()
|
|
{
|
|
delete m_styleSelection;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void PageViewer::setPaletteHandle(TPaletteHandle *paletteHandle)
|
|
{
|
|
TPaletteHandle *previousPalette = getPaletteHandle();
|
|
if (previousPalette == paletteHandle)
|
|
return;
|
|
|
|
if (previousPalette)
|
|
disconnect(previousPalette, SIGNAL(colorStyleChanged()), this, SLOT(update()));
|
|
|
|
m_styleSelection->setPaletteHandle(paletteHandle);
|
|
connect(paletteHandle, SIGNAL(colorStyleChanged()), SLOT(update()));
|
|
|
|
m_styleNameEditor->setPaletteHandle(paletteHandle);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TPaletteHandle *PageViewer::getPaletteHandle() const
|
|
{
|
|
return m_styleSelection->getPaletteHandle();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void PageViewer::setXsheetHandle(TXsheetHandle *xsheetHandle)
|
|
{
|
|
m_styleSelection->setXsheetHandle(xsheetHandle);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TXsheetHandle *PageViewer::getXsheetHandle() const
|
|
{
|
|
return m_styleSelection->getXsheetHandle();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! for clearing the cache when executing paste style command from StyleSelection
|
|
*/
|
|
void PageViewer::setLevelHandle(TXshLevelHandle *levelHandle)
|
|
{
|
|
m_styleSelection->setLevelHandle(levelHandle);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void PageViewer::setFrameHandle(TFrameHandle *frameHandle)
|
|
{
|
|
m_frameHandle = frameHandle;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TFrameHandle *PageViewer::getFrameHandle() const
|
|
{
|
|
return m_frameHandle;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void PageViewer::setCurrentStyleIndex(int index)
|
|
{
|
|
getPaletteHandle()->setStyleIndex(index);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int PageViewer::getCurrentStyleIndex() const
|
|
{
|
|
return getPaletteHandle()->getStyleIndex();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Set current page to \b page and update view.
|
|
*/
|
|
void PageViewer::setPage(TPalette::Page *page)
|
|
{
|
|
m_page = page;
|
|
computeSize();
|
|
update();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Return chip count contained in current page.
|
|
*/
|
|
int PageViewer::getChipCount() const
|
|
{
|
|
return m_page ? m_page->getStyleCount() : 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Set current view mode \b PaletteViewerGUI::PageViewer::ViewMode to \b viewMode and update view.
|
|
*/
|
|
void PageViewer::setViewMode(ViewMode viewMode)
|
|
{
|
|
if (m_viewMode == viewMode)
|
|
return;
|
|
m_viewMode = viewMode;
|
|
computeSize();
|
|
update();
|
|
|
|
//keep new view mode for reproducing the same mode when a new palette is made
|
|
switch (m_viewType) {
|
|
case LEVEL_PALETTE:
|
|
ChipSizeManager::instance()->chipSize_Palette = (int)m_viewMode;
|
|
break;
|
|
case CLEANUP_PALETTE:
|
|
ChipSizeManager::instance()->chipSize_Cleanup = (int)m_viewMode;
|
|
break;
|
|
case STUDIO_PALETTE:
|
|
ChipSizeManager::instance()->chipSize_Studio = (int)m_viewMode;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Return current chip index by position \b pos.
|
|
N.B. Cannot return chip index > max.
|
|
*/
|
|
int PageViewer::posToIndex(const QPoint &pos) const
|
|
{
|
|
if (m_chipPerRow == 0)
|
|
return -1;
|
|
QSize chipSize = getChipSize();
|
|
int j = (pos.x() - m_chipsOrigin.x()) / chipSize.width();
|
|
int i = (pos.y() - m_chipsOrigin.y()) / chipSize.height();
|
|
int index = i * m_chipPerRow + j;
|
|
// if(index<0 || index>=getChipCount()) return -1;
|
|
return index;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Return item rect of chip identified by \b index. Item rect is the rect of
|
|
chip + name.
|
|
*/
|
|
QRect PageViewer::getItemRect(int index) const
|
|
{
|
|
if (m_chipPerRow == 0)
|
|
return QRect();
|
|
int row = index / m_chipPerRow;
|
|
int col = index - (row * m_chipPerRow);
|
|
int x0 = m_chipsOrigin.x();
|
|
int y0 = m_chipsOrigin.y();
|
|
QSize chipSize = getChipSize();
|
|
int chipLx = chipSize.width();
|
|
int chipLy = chipSize.height();
|
|
QRect rect(x0 + chipLx * col, y0 + chipLy * row, chipLx, chipLy);
|
|
return rect;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Return rect of color area of chip identified by \b index.
|
|
*/
|
|
QRect PageViewer::getColorChipRect(int index) const
|
|
{
|
|
QRect rect = getItemRect(index);
|
|
if (rect.isNull())
|
|
return rect;
|
|
if (m_viewMode == LargeChips)
|
|
rect.setHeight(20);
|
|
else if (m_viewMode == List)
|
|
rect.setWidth(rect.height());
|
|
return rect;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Return rect of chip identified by \b index name. (Not in \b SmallChips).
|
|
*/
|
|
QRect PageViewer::getColorNameRect(int index) const
|
|
{
|
|
QRect rect = getItemRect(index);
|
|
if (rect.isNull())
|
|
return rect;
|
|
if (m_viewMode == LargeChips)
|
|
rect.adjust(-10, 14, 10, -14);
|
|
else if (m_viewMode == MediumChips)
|
|
rect.adjust(-15, 7, 15, -7);
|
|
else if (m_viewMode == List)
|
|
rect.setLeft(rect.left() + rect.height());
|
|
else
|
|
return rect;
|
|
return rect;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Add color to current page; if indexInPage == -1 add color at the bottom of page.
|
|
*/
|
|
void PageViewer::drop(int dstIndexInPage, const QMimeData *mimeData)
|
|
{
|
|
assert(m_page);
|
|
TPalette *palette = m_page->getPalette();
|
|
if (!palette)
|
|
return;
|
|
int dstPageIndex = m_page->getIndex();
|
|
if ((m_page->getStyleId(0) == 0 || m_page->getStyleId(1) == 1) && dstIndexInPage < 2)
|
|
dstIndexInPage = 2;
|
|
if (dstIndexInPage < 0)
|
|
dstIndexInPage = m_page->getStyleCount();
|
|
|
|
const PaletteData *paletteData = dynamic_cast<const PaletteData *>(mimeData);
|
|
|
|
if (!paletteData || !paletteData->hasStyleIndeces())
|
|
return;
|
|
|
|
TPalette *srcPalette = paletteData->getPalette();
|
|
int srcPageIndex = paletteData->getPageIndex();
|
|
std::set<int> srcIndicesInPage = paletteData->getIndicesInPage();
|
|
|
|
if (m_dropPageCreated) {
|
|
//Rimuovo e reinserisco la pagina inizializzando l'undo.
|
|
palette->setDirtyFlag(true);
|
|
int pageIndex = palette->getPageCount() - 1;
|
|
palette->erasePage(pageIndex);
|
|
if (dstPageIndex != srcPageIndex && pageIndex == dstPageIndex) {
|
|
TUndoManager::manager()->beginBlock();
|
|
PaletteCmd::addPage(getPaletteHandle());
|
|
} else
|
|
m_dropPageCreated = false;
|
|
getPaletteHandle()->notifyPaletteChanged();
|
|
}
|
|
if (srcPalette == palette) {
|
|
PaletteCmd::arrangeStyles(getPaletteHandle(), dstPageIndex, dstIndexInPage, srcPageIndex, srcIndicesInPage);
|
|
|
|
//seleziono gli stili spostati
|
|
clearSelection();
|
|
std::set<int>::const_reverse_iterator i;
|
|
int k = 0;
|
|
for (i = srcIndicesInPage.rbegin(); i != srcIndicesInPage.rend(); ++i, ++k) {
|
|
int index = 0;
|
|
if (*i <= dstIndexInPage)
|
|
index = dstIndexInPage - k - 1;
|
|
else
|
|
index = dstIndexInPage + k;
|
|
m_styleSelection->select(dstPageIndex, index, true);
|
|
}
|
|
} else //when dropping the style into another palette
|
|
{
|
|
std::vector<TColorStyle *> styles;
|
|
std::set<int>::iterator it;
|
|
for (it = srcIndicesInPage.begin(); it != srcIndicesInPage.end(); ++it) {
|
|
int indexInPage = *it;
|
|
styles.push_back(srcPalette->getPage(srcPageIndex)->getStyle(indexInPage));
|
|
}
|
|
|
|
PaletteCmd::addStyles(getPaletteHandle(), dstPageIndex, dstIndexInPage, styles);
|
|
}
|
|
|
|
if (m_dropPageCreated) {
|
|
m_dropPageCreated = false;
|
|
TUndoManager::manager()->endBlock();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Create an empty page to receive drop.
|
|
*/
|
|
void PageViewer::createDropPage()
|
|
{
|
|
if (m_dropPageCreated)
|
|
return;
|
|
m_dropPageCreated = true;
|
|
assert(m_page);
|
|
TPalette *palette = m_page->getPalette();
|
|
if (palette)
|
|
PaletteCmd::addPage(getPaletteHandle(), L"", false);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void PageViewer::clearSelection()
|
|
{
|
|
m_styleSelection->selectNone();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Return page chip size, it depend from current \b PaletteViewerGUI::PageViewer::ViewMode.
|
|
*/
|
|
QSize PageViewer::getChipSize() const
|
|
{
|
|
if (m_viewMode == SmallChips || m_viewMode == SmallChipsWithName)
|
|
return QSize(48, 33);
|
|
else if (m_viewMode == MediumChips)
|
|
return QSize(98, 38);
|
|
else if (m_viewMode == LargeChips)
|
|
return QSize(155, 53);
|
|
else
|
|
return QSize(width(), 22);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Draw a single chip style \b style in \b chipRect.
|
|
*/
|
|
void PageViewer::drawColorChip(QPainter &p, QRect &chipRect, TColorStyle *style)
|
|
{
|
|
TRaster32P icon = style->getIcon(qsize2Dimension(chipRect.size()));
|
|
p.drawPixmap(chipRect.left(), chipRect.top(), rasterToQPixmap(icon, false));
|
|
p.drawRect(chipRect);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Draw style \b style name in \b nameRect.
|
|
*/
|
|
void PageViewer::drawColorName(QPainter &p, QRect &nameRect, TColorStyle *style, int styleIndex)
|
|
{
|
|
if (m_viewMode == SmallChips && style->getFlags() == 0)
|
|
return;
|
|
TPalette *palette = (m_page) ? m_page->getPalette() : 0;
|
|
|
|
QString name = QString::fromStdWString(style->getName());
|
|
if (m_viewMode == List) {
|
|
p.setPen(getTextColor());
|
|
|
|
std::pair<TFilePath, int> g = StudioPalette::instance()->getSourceStyle(style);
|
|
if (g.first != TFilePath() && g.second >= 0)
|
|
name += " " + toQString(g.first) + ":" + QString::number(g.second);
|
|
if (style->getFlags() != 0)
|
|
name += "(autopaint)";
|
|
|
|
p.drawText(nameRect.adjusted(6, 4, -6, -4), name);
|
|
|
|
QColor borderCol(getTextColor());
|
|
borderCol.setAlphaF(0.3);
|
|
p.setPen(borderCol);
|
|
}
|
|
|
|
if (m_viewMode == SmallChips && style->getFlags() != 0) {
|
|
QRect rect(nameRect.left(), nameRect.top(), 9, 9);
|
|
p.fillRect(rect, QBrush(Qt::white));
|
|
p.drawRect(rect);
|
|
p.drawText(rect, Qt::AlignCenter, "a");
|
|
}
|
|
if (m_viewMode == SmallChipsWithName && name != "" && name != "color") {
|
|
QRect rect = nameRect;
|
|
QPen oldPen = p.pen();
|
|
TPixel32 color = style->getMainColor();
|
|
int v = (int)(0.299 * color.r + 0.587 * color.g + 0.114 * color.b);
|
|
p.setPen(v > 127 ? Qt::black : Qt::white);
|
|
int textWidth = QFontMetrics(p.font()).width(name);
|
|
if (textWidth < rect.width() - 2)
|
|
p.drawText(rect, Qt::AlignCenter, name);
|
|
else
|
|
p.drawText(rect.adjusted(2, 0, 0, 0), Qt::AlignLeft | Qt::AlignVCenter, name);
|
|
p.setPen(oldPen);
|
|
}
|
|
|
|
if (m_viewMode == LargeChips) {
|
|
QString index = QString::number(styleIndex);
|
|
QFont font = p.font();
|
|
int fontSize = font.pointSize();
|
|
if (fontSize == -1)
|
|
fontSize = font.pixelSize();
|
|
int lenght = index.length() * fontSize;
|
|
int w = (lenght > 11) ? (lenght) : 11;
|
|
int h = 11;
|
|
int x0 = nameRect.right() - w + 1;
|
|
int y0 = nameRect.top() - h - 1;
|
|
p.drawText(nameRect.adjusted(6, 1, -6, -1), name);
|
|
QRect indexRect(x0, y0, w, h);
|
|
p.fillRect(indexRect, QBrush(Qt::white));
|
|
p.drawRect(indexRect);
|
|
p.drawText(indexRect, Qt::AlignCenter, index);
|
|
|
|
QFont f = p.font();
|
|
f.setFamily("Calibri");
|
|
p.setFont(f);
|
|
if (style->getFlags() != 0) {
|
|
QRect rect(nameRect.left(), y0, w, h);
|
|
p.fillRect(rect, QBrush(Qt::white));
|
|
p.drawRect(rect);
|
|
p.drawText(rect.adjusted(0, +1, 0, +1), Qt::AlignCenter, "A");
|
|
}
|
|
TTextureStyle *ts = dynamic_cast<TTextureStyle *>(style);
|
|
if (ts) {
|
|
QRect rect(nameRect.left() + ((style->getFlags() != 0) ? w : 0), y0, w, h);
|
|
p.fillRect(rect, QBrush(Qt::white));
|
|
p.drawRect(rect);
|
|
p.drawText(rect.adjusted(0, +1, 0, +1), Qt::AlignCenter, ts->isPattern() ? "P" : "T");
|
|
}
|
|
}
|
|
|
|
p.drawRect(nameRect);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Draw the toggle to know if \b style is linked to a studio palette.
|
|
*/
|
|
void PageViewer::drawToggleLink(QPainter &p, QRect &chipRect, TColorStyle *style)
|
|
{
|
|
std::wstring globalName = style->getGlobalName();
|
|
if (globalName != L"" &&
|
|
(globalName[0] == L'-' || globalName[0] == L'+')) {
|
|
TPixel32 c = style->getMainColor();
|
|
int x = chipRect.topRight().x() - 6;
|
|
int y = chipRect.topRight().y();
|
|
QRect rect(x, y, 7, 7);
|
|
|
|
p.fillRect(rect, QBrush(Qt::white));
|
|
p.setPen(Qt::black);
|
|
p.drawRect(rect);
|
|
|
|
if (globalName[0] == L'+') {
|
|
QPointF a(x + 2, y + 2);
|
|
QPointF b(x + 2, y + 5);
|
|
QPointF c(x + 5, y + 2);
|
|
QPointF d(x + 5, y + 5);
|
|
p.drawLine(a, b);
|
|
p.drawLine(a, c);
|
|
p.drawLine(a, d);
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Pain current page styles using current view mode.
|
|
*/
|
|
void PageViewer::paintEvent(QPaintEvent *e)
|
|
{
|
|
QPainter p(this);
|
|
if (m_chipPerRow == 0) {
|
|
p.drawText(QPoint(5, 25), tr("- No Styles -"));
|
|
return;
|
|
}
|
|
|
|
// currentStyle e palette
|
|
TPalette *palette = (m_page) ? m_page->getPalette() : 0;
|
|
if (!palette)
|
|
return;
|
|
|
|
// [i0,i1] = range celle visibili
|
|
QRect visibleRect = e->rect();
|
|
int i0 = posToIndex(visibleRect.topLeft());
|
|
if (i0 < 0)
|
|
i0 = 0;
|
|
int i1 = posToIndex(visibleRect.bottomRight());
|
|
if (i1 >= getChipCount())
|
|
i1 = getChipCount() - 1;
|
|
|
|
if (m_viewMode == List) {
|
|
// disegno le celle
|
|
int i;
|
|
int currentStyleIndexInPage = -1;
|
|
for (i = i0; i <= i1; i++) {
|
|
TColorStyle *style = m_page->getStyle(i);
|
|
int styleIndex = m_page->getStyleId(i);
|
|
if (getCurrentStyleIndex() == styleIndex)
|
|
currentStyleIndexInPage = i;
|
|
|
|
QRect chipRect = getColorChipRect(i);
|
|
drawColorChip(p, chipRect, style);
|
|
|
|
// name, index and shortcut
|
|
QRect nameRect = getColorNameRect(i);
|
|
drawColorName(p, nameRect, style, styleIndex);
|
|
|
|
// selezione
|
|
if (m_styleSelection->isSelected(m_page->getIndex(), i)) {
|
|
p.setPen(Qt::white);
|
|
QRect itemRect = getItemRect(i);
|
|
p.drawRect(itemRect);
|
|
p.drawRect(chipRect.adjusted(1, 1, -1, -1));
|
|
}
|
|
// stile corrente
|
|
if (i == currentStyleIndexInPage && 0 <= i && i < getChipCount()) {
|
|
QRect rect = getItemRect(i);
|
|
|
|
p.setPen(QColor(180, 210, 255));
|
|
p.drawRect(rect.adjusted(1, 1, -1, -1));
|
|
|
|
p.setPen(Qt::white);
|
|
p.drawRect(rect.adjusted(2, 2, -2, -2));
|
|
p.setPen(Qt::black);
|
|
p.drawRect(rect.adjusted(3, 3, -3, -3));
|
|
|
|
if (!m_styleSelection->isSelected(m_page->getIndex(), i)) {
|
|
p.setPen(QColor(225, 225, 225));
|
|
p.drawRect(rect.adjusted(1, 1, -1, -1));
|
|
}
|
|
}
|
|
|
|
// toggle link
|
|
drawToggleLink(p, chipRect, m_page->getStyle(i));
|
|
}
|
|
} else {
|
|
int currentStyleIndex = getCurrentStyleIndex();
|
|
int i;
|
|
for (i = i0; i <= i1; i++) {
|
|
TColorStyle *style = m_page->getStyle(i);
|
|
int styleIndex = m_page->getStyleId(i);
|
|
|
|
//draw white frame if the style is selected or current
|
|
if (m_styleSelection->isSelected(m_page->getIndex(), i) || currentStyleIndex == styleIndex) {
|
|
QRect itemRect = getItemRect(i).adjusted(-1, -2, 1, 2);
|
|
p.setPen(Qt::NoPen);
|
|
p.setBrush(Qt::white);
|
|
p.drawRoundRect(itemRect, 7, 25);
|
|
}
|
|
//paint style
|
|
QRect chipRect = getItemRect(i).adjusted(4, 4, -5, -5);
|
|
|
|
QColor styleColor((int)style->getMainColor().r,
|
|
(int)style->getMainColor().g,
|
|
(int)style->getMainColor().b);
|
|
// draw with MainColor for TSolidColorStyle(3), TColorCleanupStyle(2001) and TBlackCleanupStyle(2002)
|
|
if (style->getTagId() == 3 || style->getTagId() == 2001 || style->getTagId() == 2002) {
|
|
//iwsw commented out temporaly
|
|
//if (Preferences::instance()->isDoColorCorrectionByUsing3DLutEnabled())
|
|
// Ghibli3DLutConverter::instance()->convert(styleColor);
|
|
|
|
p.fillRect(chipRect, QBrush(styleColor));
|
|
|
|
// if the style is not 100% opac, draw the bottom part of the chip with the pixmap with alpha
|
|
if ((int)style->getMainColor().m != (int)style->getMainColor().maxChannelValue) {
|
|
QRect bottomRect = chipRect;
|
|
if (m_viewMode == LargeChips) {
|
|
bottomRect.adjust(0, bottomRect.height() - 12, 0, 0);
|
|
} else
|
|
bottomRect.adjust(0, bottomRect.height() - 6, 0, 0);
|
|
|
|
TRaster32P icon = style->getIcon(qsize2Dimension(bottomRect.size()));
|
|
p.drawPixmap(bottomRect.left(), bottomRect.top(), rasterToQPixmap(icon));
|
|
}
|
|
//Use white line for dark color. Use black line for light color.
|
|
int val = (int)style->getMainColor().r * 30 +
|
|
(int)style->getMainColor().g * 59 +
|
|
(int)style->getMainColor().b * 11;
|
|
if (val < 12800)
|
|
p.setPen(Qt::white);
|
|
else
|
|
p.setPen(Qt::black);
|
|
|
|
} else {
|
|
TRaster32P icon = style->getIcon(qsize2Dimension(chipRect.size()));
|
|
p.drawPixmap(chipRect.left(), chipRect.top(), rasterToQPixmap(icon));
|
|
|
|
if (m_viewMode == LargeChips) {
|
|
p.setPen(Qt::NoPen);
|
|
p.setBrush(QColor(0, 0, 0, 140));
|
|
QRect zabutonRect = chipRect.adjusted(0, 12, 0, -12);
|
|
p.drawRect(zabutonRect);
|
|
}
|
|
p.setPen(Qt::white);
|
|
}
|
|
p.setBrush(Qt::NoBrush);
|
|
|
|
//diagonal line indicates that the style color is changed after linked from studio palette
|
|
if (style->getIsEditedFlag()) {
|
|
//draw diagonal line
|
|
p.drawLine(chipRect.topRight(), chipRect.bottomLeft());
|
|
|
|
//keep center blank for style name
|
|
if (m_viewMode != SmallChips) {
|
|
QRect colorNameRect = chipRect;
|
|
if (m_viewMode == MediumChips)
|
|
colorNameRect.adjust(2, 9, -2, -8);
|
|
else //LargeChip
|
|
colorNameRect.adjust(2, 16, -2, -13);
|
|
|
|
p.fillRect(colorNameRect, QBrush(styleColor));
|
|
}
|
|
}
|
|
|
|
//draw style name
|
|
QFont preFont = p.font();
|
|
QFont tmpFont = p.font();
|
|
|
|
if (m_viewMode != SmallChips) {
|
|
|
|
if (m_viewMode == MediumChips) {
|
|
tmpFont.setPixelSize(EnvSoftwareCurrentFontSize_StyleName);
|
|
p.setFont(tmpFont);
|
|
} else if (m_viewMode == LargeChips) {
|
|
tmpFont.setPixelSize(EnvSoftwareCurrentFontSize_StyleName + 2);
|
|
p.setFont(tmpFont);
|
|
}
|
|
|
|
std::wstring name = style->getName();
|
|
std::wstring origName = style->getOriginalName();
|
|
|
|
//display the name (style name and original name) according to the name display mode
|
|
if (m_nameDisplayMode == Style)
|
|
p.drawText(chipRect, Qt::AlignCenter, QString::fromStdWString(name));
|
|
else if (m_nameDisplayMode == Original) {
|
|
if (origName != L"") {
|
|
tmpFont.setItalic(true);
|
|
p.setFont(tmpFont);
|
|
p.drawText(chipRect, Qt::AlignCenter, QString::fromStdWString(origName));
|
|
} else // if there is no original name, then display the style name in brackets
|
|
p.drawText(chipRect, Qt::AlignCenter, QString::fromStdWString(L"( " + name + L" )"));
|
|
} else if (m_nameDisplayMode == StyleAndOriginal) {
|
|
p.drawText(chipRect, Qt::AlignCenter, QString::fromStdWString(name));
|
|
|
|
//display original name only whne LargeChip view
|
|
if (m_viewMode == LargeChips && origName != L"") {
|
|
tmpFont.setItalic(true);
|
|
tmpFont.setPixelSize(tmpFont.pixelSize() - 3);
|
|
p.setFont(tmpFont);
|
|
p.drawText(chipRect.adjusted(4, 4, -4, -4), Qt::AlignLeft | Qt::AlignTop, QString::fromStdWString(origName));
|
|
}
|
|
}
|
|
}
|
|
|
|
// draw the frame border if the style is selected or current
|
|
if (m_styleSelection->isSelected(m_page->getIndex(), i) || currentStyleIndex == styleIndex) {
|
|
p.setBrush(Qt::NoBrush);
|
|
p.drawRect(chipRect.adjusted(3, 3, -3, -3));
|
|
}
|
|
|
|
// draw border
|
|
p.setPen(Qt::black);
|
|
p.setBrush(Qt::NoBrush);
|
|
p.drawRect(chipRect);
|
|
|
|
// draw style index
|
|
tmpFont.setPointSize(9);
|
|
tmpFont.setItalic(false);
|
|
p.setFont(tmpFont);
|
|
int indexWidth = fontMetrics().width(QString().setNum(styleIndex)) + 4;
|
|
QRect indexRect(chipRect.bottomRight() + QPoint(-indexWidth, -14), chipRect.bottomRight());
|
|
p.setPen(Qt::black);
|
|
p.setBrush(Qt::white);
|
|
p.drawRect(indexRect);
|
|
p.drawText(indexRect, Qt::AlignCenter, QString().setNum(styleIndex));
|
|
// revert font set
|
|
p.setFont(preFont);
|
|
// revert brush
|
|
p.setBrush(Qt::NoBrush);
|
|
|
|
//draw link indicator
|
|
drawToggleLink(p, chipRect, style);
|
|
}
|
|
}
|
|
|
|
// indicatore di drop
|
|
if (m_dropPositionIndex >= 0) {
|
|
QRect itemRect = getItemRect(m_dropPositionIndex);
|
|
QRect rect;
|
|
if (m_viewMode == List)
|
|
rect = QRect(itemRect.left(), itemRect.top() - 1, itemRect.width(), 2);
|
|
else
|
|
rect = QRect(itemRect.left() - 1, itemRect.top(), 2, itemRect.height());
|
|
p.setPen(Qt::black);
|
|
p.drawRect(rect);
|
|
p.setPen(Qt::white);
|
|
p.drawRect(rect.adjusted(-1, -1, 1, 1));
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Recall computeSize().
|
|
*/
|
|
void PageViewer::resizeEvent(QResizeEvent *)
|
|
{
|
|
computeSize();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! If current page is empty return; otherwise select or unselect chip in regard
|
|
to event position.
|
|
*/
|
|
void PageViewer::mousePressEvent(QMouseEvent *event)
|
|
{
|
|
if (!m_page)
|
|
return;
|
|
TPalette *palette = m_page->getPalette();
|
|
QPoint pos = event->pos();
|
|
int indexInPage = posToIndex(pos);
|
|
m_startDrag = false;
|
|
if (!m_page)
|
|
return;
|
|
int pageIndex = m_page->getIndex();
|
|
|
|
// disable style selection in the cleanup palette in order to avoid editing the styles by mistake.
|
|
if (m_viewType == CLEANUP_PALETTE) {
|
|
if (0 <= indexInPage && indexInPage < getChipCount()) {
|
|
//Right-click is available
|
|
if (event->button() == Qt::RightButton) {
|
|
m_styleSelection->makeCurrent();
|
|
m_styleSelection->selectNone();
|
|
m_styleSelection->select(pageIndex);
|
|
m_styleSelection->select(pageIndex, indexInPage, true);
|
|
}
|
|
//Changing the current style is still available
|
|
setCurrentStyleIndex(m_page->getStyleId(indexInPage));
|
|
}
|
|
update();
|
|
return;
|
|
}
|
|
|
|
if (event->button() == Qt::RightButton) {
|
|
m_styleSelection->makeCurrent();
|
|
//if you are clicking on the color chip
|
|
if (0 <= indexInPage && indexInPage < getChipCount()) {
|
|
//Se pageIndex non e' selezionato lo seleziono
|
|
if (!m_styleSelection->isSelected(pageIndex, indexInPage)) {
|
|
m_styleSelection->select(pageIndex);
|
|
m_styleSelection->select(pageIndex, indexInPage, true);
|
|
}
|
|
//Cambio l'indice corrente
|
|
setCurrentStyleIndex(m_page->getStyleId(indexInPage));
|
|
} else {
|
|
m_styleSelection->selectNone();
|
|
m_styleSelection->select(pageIndex);
|
|
}
|
|
update();
|
|
//update locks when the styleSelection becomes current
|
|
updateCommandLocks();
|
|
return;
|
|
}
|
|
m_dragStartPosition = pos;
|
|
if (indexInPage < 0 || indexInPage >= getChipCount()) {
|
|
// l'utente ha fatto click fuori dai color chip. vuole deselezionare tutto
|
|
// (lasciando la selezione attiva, per un eventuale paste)
|
|
m_styleSelection->select(pageIndex);
|
|
m_styleSelection->makeCurrent();
|
|
|
|
update();
|
|
//update locks when the styleSelection becomes current
|
|
updateCommandLocks();
|
|
return;
|
|
} else {
|
|
//O si sta selezonando un nuovo item O si vuole iniziare un drag
|
|
if (m_styleSelection->isSelected(pageIndex, indexInPage) &&
|
|
event->modifiers() == Qt::ControlModifier &&
|
|
!m_page->getPalette()->isLocked())
|
|
m_startDrag = true;
|
|
else
|
|
select(indexInPage, event);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! If left botton is pressed start drag.
|
|
*/
|
|
void PageViewer::mouseMoveEvent(QMouseEvent *event)
|
|
{
|
|
if (!m_page)
|
|
return;
|
|
if (m_viewType == CLEANUP_PALETTE)
|
|
return;
|
|
|
|
// continuo solo se e' un drag (bottone sinistro premuto)
|
|
if (!(event->buttons() & Qt::LeftButton))
|
|
return;
|
|
|
|
if (m_page->getPalette()->isLocked())
|
|
return;
|
|
|
|
// Se spingo ctrl mentre mi sto muovendo con almeno un item selezionato abilito la possibilita' di fare drag.
|
|
if (!m_startDrag &&
|
|
event->modifiers() == Qt::ControlModifier &&
|
|
!m_styleSelection->isEmpty() &&
|
|
(event->pos() - m_dragStartPosition).manhattanLength() > 12)
|
|
m_startDrag = true;
|
|
// faccio partire il drag&drop solo se mi sono mosso di una certa quantita'
|
|
if ((event->pos() - m_dragStartPosition).manhattanLength() > 20 && m_startDrag) {
|
|
assert(m_styleSelection && !m_styleSelection->isEmpty());
|
|
startDragDrop();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void PageViewer::mouseReleaseEvent(QMouseEvent *event)
|
|
{
|
|
if (!m_page)
|
|
return;
|
|
TPalette *palette = m_page->getPalette();
|
|
QPoint pos = event->pos();
|
|
int indexInPage = posToIndex(pos);
|
|
if (m_startDrag && m_dropPositionIndex == -1 && event->modifiers() == Qt::ControlModifier)
|
|
select(indexInPage, event);
|
|
m_startDrag = false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! If double click position is not in a chip rect return; otherwise if is in
|
|
name rect open a text field, if is in color rect open a style editor.
|
|
*/
|
|
void PageViewer::mouseDoubleClickEvent(QMouseEvent *e)
|
|
{
|
|
int index = posToIndex(e->pos());
|
|
if (index < 0 || index >= getChipCount())
|
|
return;
|
|
TColorStyle *style = m_page->getStyle(index);
|
|
if (!style)
|
|
return;
|
|
|
|
if (m_page->getPalette()->isLocked())
|
|
return;
|
|
|
|
if (m_viewMode != SmallChips) {
|
|
QRect nameRect = getColorNameRect(index);
|
|
if (nameRect.contains(e->pos())) {
|
|
std::wstring styleName = style->getName();
|
|
LineEdit *fld = m_renameTextField;
|
|
fld->setText(QString::fromStdWString(styleName));
|
|
fld->setGeometry(nameRect);
|
|
fld->show();
|
|
fld->selectAll();
|
|
fld->setFocus(Qt::OtherFocusReason);
|
|
fld->setAlignment(Qt::AlignCenter);
|
|
return;
|
|
}
|
|
}
|
|
|
|
m_styleNameEditor->show();
|
|
m_styleNameEditor->raise();
|
|
m_styleNameEditor->activateWindow();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void PageViewer::createMenuAction(QMenu &menu, const char *id, QString name, const char *slot)
|
|
{
|
|
bool ret = true;
|
|
QAction *act = menu.addAction(name);
|
|
std::string slotName(slot);
|
|
slotName = std::string("1") + slotName;
|
|
ret = connect(act, SIGNAL(triggered()), slotName.c_str());
|
|
assert(ret);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void PageViewer::addNewColor()
|
|
{
|
|
PaletteCmd::createStyle(getPaletteHandle(), getPage());
|
|
computeSize();
|
|
update();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void PageViewer::addNewPage()
|
|
{
|
|
PaletteCmd::addPage(getPaletteHandle());
|
|
update();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/*! Create and open the Right-click menu in page.
|
|
*/
|
|
void PageViewer::contextMenuEvent(QContextMenuEvent *event)
|
|
{
|
|
QMenu menu(this);
|
|
|
|
CommandManager *cmd = CommandManager::instance();
|
|
|
|
menu.addAction(cmd->getAction(MI_Copy));
|
|
QAction *pasteValueAct = cmd->getAction(MI_PasteValues);
|
|
menu.addAction(pasteValueAct);
|
|
QAction *pasteColorsAct = cmd->getAction(MI_PasteColors);
|
|
menu.addAction(pasteColorsAct);
|
|
QAction *pasteNamesAct = cmd->getAction(MI_PasteNames);
|
|
menu.addAction(pasteNamesAct);
|
|
QAction *pasteAct = cmd->getAction(MI_Paste);
|
|
menu.addAction(pasteAct);
|
|
QAction *cutAct = cmd->getAction(MI_Cut);
|
|
menu.addAction(cutAct);
|
|
|
|
menu.addSeparator();
|
|
QAction *clearAct = cmd->getAction(MI_Clear);
|
|
menu.addAction(clearAct);
|
|
|
|
menu.addSeparator();
|
|
QAction *openPltGizmoAct = cmd->getAction("MI_OpenPltGizmo");
|
|
menu.addAction(openPltGizmoAct);
|
|
QAction *openStyleControlAct = cmd->getAction("MI_OpenStyleControl");
|
|
menu.addAction(openStyleControlAct);
|
|
|
|
//Verifica se lo stile e' link.
|
|
//Abilita e disabilita le voci di menu' in base a dove si e' cliccato.
|
|
int index = posToIndex(event->pos());
|
|
int indexPage = m_page ? m_page->getIndex() : -1;
|
|
|
|
bool isLocked = m_page ? m_page->getPalette()->isLocked() : false;
|
|
|
|
//remove links from studio palette
|
|
if (m_viewType == LEVEL_PALETTE && m_styleSelection && !m_styleSelection->isEmpty() && !isLocked) {
|
|
menu.addSeparator();
|
|
QAction *removeLinkAct = menu.addAction(tr("Remove Links"));
|
|
connect(removeLinkAct, SIGNAL(triggered()), this, SLOT(removeLink()));
|
|
}
|
|
|
|
if (((indexPage == 0 && index > 0) || (indexPage > 0 && index >= 0)) && index < getChipCount() && !isLocked) {
|
|
//iwsw commented out temporarly
|
|
/*
|
|
wstring globalName = m_page->getStyle(index)->getGlobalName();
|
|
if (m_viewType != STUDIO_PALETTE &&
|
|
globalName != L"" &&
|
|
(globalName[0] == L'-' || globalName[0] == L'+'))
|
|
{
|
|
createMenuAction(menu, "MI_ToggleLinkToStudioPalette", tr("Toggle Link to Studio Palette"), "toggleLink()");
|
|
createMenuAction(menu, "MI_RemoveReferenceToStudioPalette", tr("Remove Reference to Studio Palette"), "eraseToggleLink()");
|
|
}
|
|
*/
|
|
if (pasteValueAct)
|
|
pasteValueAct->setEnabled(true);
|
|
if (pasteColorsAct)
|
|
pasteColorsAct->setEnabled(true);
|
|
|
|
pasteNamesAct->setEnabled(true);
|
|
pasteAct->setEnabled(true);
|
|
cutAct->setEnabled(true);
|
|
clearAct->setEnabled(true);
|
|
} else {
|
|
if (pasteValueAct)
|
|
pasteValueAct->setEnabled(false);
|
|
if (pasteColorsAct)
|
|
pasteColorsAct->setEnabled(false);
|
|
|
|
pasteNamesAct->setEnabled(false);
|
|
pasteAct->setEnabled(!isLocked);
|
|
cutAct->setEnabled(false);
|
|
clearAct->setEnabled(false);
|
|
}
|
|
|
|
// get color from the original studio palette
|
|
if (m_viewType == LEVEL_PALETTE && m_styleSelection && !m_styleSelection->isEmpty() && !isLocked) {
|
|
menu.addSeparator();
|
|
QAction *getBackOriginalAct = cmd->getAction("MI_GetColorFromStudioPalette");
|
|
menu.addAction(getBackOriginalAct);
|
|
}
|
|
|
|
//iwsw commented out temporarly
|
|
/*
|
|
if (m_viewType != STUDIO_PALETTE)
|
|
{
|
|
menu.addSeparator();
|
|
menu.addAction(cmd->getAction(MI_EraseUnusedStyles));
|
|
}
|
|
*/
|
|
if (m_page)
|
|
{
|
|
QAction *newStyle = menu.addAction(tr("New Style"));
|
|
connect(newStyle, SIGNAL(triggered()), SLOT(addNewColor()));
|
|
QAction *newPage = menu.addAction(tr("New Page"));
|
|
connect(newPage, SIGNAL(triggered()), SLOT(addNewPage()));
|
|
}
|
|
menu.exec(event->globalPos());
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Accept drag enter event if evant data ha format \b TStyleSelection::getMimeType().
|
|
*/
|
|
void PageViewer::dragEnterEvent(QDragEnterEvent *event)
|
|
{
|
|
if (!m_page)
|
|
return;
|
|
const PaletteData *paletteData = dynamic_cast<const PaletteData *>(event->mimeData());
|
|
if (paletteData && paletteData->hasStyleIndeces()) {
|
|
if ((m_viewType == CLEANUP_PALETTE && !paletteData->getPalette()->isCleanupPalette()) ||
|
|
(m_viewType == LEVEL_PALETTE && paletteData->getPalette()->isCleanupPalette())) {
|
|
event->ignore();
|
|
return;
|
|
}
|
|
int index = posToIndex(event->pos());
|
|
// non si puo' spostare qualcosa nelle prime due posizioni di pagina 0
|
|
// (occupate da BG e FG)
|
|
if (m_page->getIndex() == 0 && index < 2)
|
|
index = 2;
|
|
if (index < 0)
|
|
index = 0;
|
|
else if (index > m_page->getStyleCount())
|
|
index = m_page->getStyleCount();
|
|
m_dropPositionIndex = index;
|
|
update();
|
|
event->acceptProposedAction();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! If current page exist and index in event position is different from dropped
|
|
index set right drop position index and accept event.
|
|
*/
|
|
void PageViewer::dragMoveEvent(QDragMoveEvent *event)
|
|
{
|
|
if (!m_page)
|
|
return;
|
|
int index = posToIndex(event->pos());
|
|
if (index != m_dropPositionIndex) {
|
|
if ((m_page->getStyleId(0) == 0 || m_page->getStyleId(1) == 1) && index < 2)
|
|
index = 2;
|
|
if (index < 0)
|
|
index = 0;
|
|
else if (index > m_page->getStyleCount())
|
|
index = m_page->getStyleCount();
|
|
m_dropPositionIndex = index;
|
|
update();
|
|
event->acceptProposedAction();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! If event data has correct format drop it in current drop position index.
|
|
*/
|
|
void PageViewer::dropEvent(QDropEvent *event)
|
|
{
|
|
int dstIndexInPage = m_dropPositionIndex;
|
|
m_dropPositionIndex = -1;
|
|
update();
|
|
if (!dynamic_cast<const PaletteData *>(event->mimeData()))
|
|
return;
|
|
drop(dstIndexInPage, event->mimeData());
|
|
event->acceptProposedAction();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Set to -1 drag position index and update view.
|
|
*/
|
|
void PageViewer::dragLeaveEvent(QDragLeaveEvent *event)
|
|
{
|
|
m_dropPositionIndex = -1;
|
|
update();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Start drag and drop; if current page exist set drag and drop event data.
|
|
*/
|
|
void PageViewer::startDragDrop()
|
|
{
|
|
TRepetitionGuard guard;
|
|
if (!guard.hasLock())
|
|
return;
|
|
|
|
assert(m_page);
|
|
TPalette *palette = m_page->getPalette();
|
|
if (!palette || !m_page || !m_styleSelection)
|
|
return;
|
|
int pageIndex = m_page->getIndex();
|
|
|
|
if (!m_styleSelection->canHandleStyles())
|
|
return;
|
|
|
|
PaletteData *paletteData = new PaletteData();
|
|
paletteData->setPaletteData(palette, pageIndex, m_styleSelection->getIndicesInPage());
|
|
QDrag *drag = new QDrag(this);
|
|
drag->setMimeData(paletteData);
|
|
Qt::DropAction dropAction = drag->exec(Qt::MoveAction);
|
|
if (m_dropPageCreated) {
|
|
m_dropPageCreated = false;
|
|
int pageIndex = palette->getPageCount() - 1;
|
|
if (palette->getPage(pageIndex)->getStyleCount() == 0) {
|
|
palette->erasePage(pageIndex);
|
|
getPaletteHandle()->notifyPaletteChanged();
|
|
} else
|
|
palette->setDirtyFlag(true);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void PageViewer::keyPressEvent(QKeyEvent *e)
|
|
{
|
|
int key = e->key();
|
|
|
|
if (key == Qt::Key_Up) { //Row = frame precedente a quello settato
|
|
int frameIndex = m_frameHandle->getFrameIndex() - 1;
|
|
if (frameIndex < 0)
|
|
return;
|
|
m_frameHandle->setFrameIndex(frameIndex);
|
|
} else if (key == Qt::Key_Down) { //Row = frame successivo a quello settato
|
|
int frameIndex = m_frameHandle->getFrameIndex() + 1;
|
|
m_frameHandle->setFrameIndex(frameIndex);
|
|
} else {
|
|
CommandManager *cManager = CommandManager::instance();
|
|
|
|
if (key == cManager->getKeyFromShortcut(cManager->getShortcutFromId(V_ZoomIn)))
|
|
zoomInChip();
|
|
else if (key == cManager->getKeyFromShortcut(cManager->getShortcutFromId(V_ZoomOut)))
|
|
zoomOutChip();
|
|
else
|
|
e->ignore();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void PageViewer::showEvent(QShowEvent *)
|
|
{
|
|
TPaletteHandle *paletteHandle = getPaletteHandle();
|
|
if (!paletteHandle)
|
|
return;
|
|
connect(paletteHandle, SIGNAL(colorStyleChanged()), SLOT(update()), Qt::UniqueConnection);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void PageViewer::hideEvent(QHideEvent *)
|
|
{
|
|
TPaletteHandle *paletteHandle = getPaletteHandle();
|
|
if (!paletteHandle)
|
|
return;
|
|
disconnect(paletteHandle, SIGNAL(colorStyleChanged()), this, SLOT(update()));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Manage page tooltip.
|
|
*/
|
|
bool PageViewer::event(QEvent *e)
|
|
{
|
|
if (m_page && e->type() == QEvent::ToolTip) {
|
|
QHelpEvent *helpEvent = dynamic_cast<QHelpEvent *>(e);
|
|
QString toolTip;
|
|
QPoint pos = helpEvent->pos();
|
|
int indexInPage = posToIndex(pos);
|
|
if (0 <= indexInPage && indexInPage < m_page->getStyleCount()) {
|
|
TColorStyle *style = m_page->getStyle(indexInPage);
|
|
if (style) {
|
|
int styleIndex = m_page->getStyleId(indexInPage);
|
|
toolTip = "#" + QString::number(styleIndex) + " " + QString::fromStdWString(style->getName());
|
|
|
|
int shortcutKey = m_page->getPalette()->getStyleShortcut(styleIndex);
|
|
if (shortcutKey > 0)
|
|
toolTip += QString::fromStdWString(std::wstring(L" (") + (wchar_t)shortcutKey + L")");
|
|
}
|
|
}
|
|
if (toolTip != "")
|
|
QToolTip::showText(helpEvent->globalPos(), toolTip);
|
|
else
|
|
QToolTip::hideText();
|
|
e->accept();
|
|
}
|
|
return QFrame::event(e);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Add chip identified by \b indexInPage to style selection if it was not
|
|
selected; remove it from style selection otherwise. Manage CTRL SHIFT
|
|
pressed case.
|
|
*/
|
|
void PageViewer::select(int indexInPage, QMouseEvent *event)
|
|
{
|
|
bool selected = false;
|
|
assert(m_page);
|
|
TPalette *palette = m_page->getPalette();
|
|
int pageIndex = m_page->getIndex();
|
|
bool on = true;
|
|
|
|
bool wasSelected = m_styleSelection->isSelected(pageIndex, indexInPage);
|
|
if (event->modifiers() == Qt::NoModifier)
|
|
m_styleSelection->selectNone();
|
|
else if (event->modifiers() == Qt::CTRL && wasSelected)
|
|
on = false;
|
|
else if (event->modifiers() == Qt::SHIFT && !m_styleSelection->isEmpty()) {
|
|
// premuto shift. la selezione si estende fino ai piu' vicini colori selezionati (prima e dopo)
|
|
// a e' b diventeranno gli estremi della selezione
|
|
int a = -1, b = -1, i = 0;
|
|
for (i = 0; i < m_page->getStyleCount(); i++)
|
|
if (m_styleSelection->isSelected(pageIndex, i)) {
|
|
if (i < indexInPage)
|
|
a = i;
|
|
else if (i > indexInPage) {
|
|
b = i;
|
|
break;
|
|
}
|
|
}
|
|
if (a >= 0 && b >= 0) {
|
|
assert(a < indexInPage && indexInPage < b);
|
|
a++;
|
|
b--;
|
|
} else if (a >= 0) {
|
|
assert(b < 0 && a < indexInPage);
|
|
a++;
|
|
b = indexInPage;
|
|
} else if (b >= 0) {
|
|
assert(a < 0 && indexInPage < b);
|
|
b--;
|
|
a = indexInPage;
|
|
} else
|
|
a = b = indexInPage;
|
|
for (i = a; i <= b; i++) {
|
|
m_styleSelection->select(pageIndex, i, true);
|
|
selected = true;
|
|
}
|
|
}
|
|
|
|
bool isStyleChanged = false;
|
|
if (on)
|
|
selected = true;
|
|
int styleIndex = m_page->getStyleId(indexInPage);
|
|
if (selected) {
|
|
setCurrentStyleIndex(styleIndex);
|
|
|
|
ChangeStyleCommand *changeStyleCommand = getChangeStyleCommand();
|
|
if (changeStyleCommand)
|
|
isStyleChanged = changeStyleCommand->onStyleChanged();
|
|
}
|
|
if (!isStyleChanged) {
|
|
m_styleSelection->select(pageIndex, indexInPage, on);
|
|
m_styleSelection->makeCurrent();
|
|
updateCommandLocks();
|
|
}
|
|
update();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Compute page size in regard to chip count.
|
|
*/
|
|
void PageViewer::computeSize()
|
|
{
|
|
if (!m_page) {
|
|
m_chipPerRow = 0;
|
|
return;
|
|
}
|
|
int w = parentWidget()->width();
|
|
int chipCount = getChipCount();
|
|
QSize chipSize = getChipSize();
|
|
m_chipPerRow = m_viewMode == List ? 1 : (w - 8) / chipSize.width();
|
|
if (m_chipPerRow == 0)
|
|
m_chipPerRow = 1;
|
|
int rowCount = (chipCount + m_chipPerRow - 1) / m_chipPerRow;
|
|
setMinimumSize(w, rowCount * chipSize.height() + 10);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! If palette, referred to current page, exist and is animated set it to
|
|
current frame.
|
|
*/
|
|
void PageViewer::onFrameChanged()
|
|
{
|
|
TPalette *palette = (m_page) ? m_page->getPalette() : 0;
|
|
if (palette && palette->isAnimated())
|
|
update();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Rename current style and update its view in current page.
|
|
*/
|
|
//recall from m_renameTextField
|
|
void PageViewer::onStyleRenamed()
|
|
{
|
|
m_renameTextField->hide();
|
|
std::wstring newName = m_renameTextField->text().toStdWString();
|
|
assert(getPaletteHandle());
|
|
PaletteCmd::renamePaletteStyle(getPaletteHandle(), newName);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Recall \b TStyleSelection::toggleLink() to current page style selection.
|
|
*/
|
|
void PageViewer::toggleLink()
|
|
{
|
|
if (!m_page || !m_styleSelection || m_styleSelection->isEmpty())
|
|
return;
|
|
m_styleSelection->toggleLink();
|
|
update();
|
|
emit changeWindowTitleSignal();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Recall \b TStyleSelection::eraseToggleLink() to current page style selection.
|
|
*/
|
|
void PageViewer::eraseToggleLink()
|
|
{
|
|
if (!m_page || !m_styleSelection || m_styleSelection->isEmpty())
|
|
return;
|
|
m_styleSelection->eraseToggleLink();
|
|
}
|
|
|
|
//=============================================================================
|
|
/*! \class PaletteViewerGUI::PaletteTabBar
|
|
\brief The PaletteTabBar class provides a bar with tab to show and manage palette
|
|
page.
|
|
|
|
Inherits \b QTabBar.
|
|
This object allows to move a tab with mouseMoveEvent, rename a tab in
|
|
doubleClickevent and create a new tab in drag and drop.
|
|
*/
|
|
/*! \fn void PaletteTabBar::setPageViewer(PageViewer *pageViewer)
|
|
Set current tab bar page to \b pageViewer.
|
|
|
|
\fn void PaletteTabBar::tabTextChanged(int index)
|
|
This signal is emitted when tab associated text change.
|
|
|
|
\fn void PaletteTabBar::movePage(int srcIndex, int dstIndex)
|
|
This signal is emitted to notify tab position change.
|
|
*/
|
|
PaletteTabBar::PaletteTabBar(QWidget *parent, bool hasPageCommand)
|
|
: QTabBar(parent), m_renameTextField(new LineEdit(this)), m_renameTabIndex(-1), m_pageViewer(0), m_hasPageCommand(hasPageCommand)
|
|
{
|
|
setObjectName("PaletteTabBar");
|
|
setDrawBase(false);
|
|
m_renameTextField->hide();
|
|
connect(m_renameTextField, SIGNAL(editingFinished()), this, SLOT(updateTabName()));
|
|
if (m_hasPageCommand)
|
|
setAcceptDrops(true);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Hide rename text field and recall \b QTabBar::mousePressEvent().
|
|
*/
|
|
void PaletteTabBar::mousePressEvent(QMouseEvent *event)
|
|
{
|
|
m_renameTextField->hide();
|
|
QTabBar::mousePressEvent(event);
|
|
m_pageViewer->getSelection()->select(currentIndex());
|
|
m_pageViewer->getSelection()->makeCurrent();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! If left button is pressed and a tab is selected emit signal \b movePage.
|
|
In any case recall \b QTabBar::mousePressEvent().
|
|
*/
|
|
void PaletteTabBar::mouseMoveEvent(QMouseEvent *event)
|
|
{
|
|
if (event->buttons() == Qt::LeftButton && event->modifiers() == Qt::ControlModifier && !m_pageViewer->getPage()->getPalette()->isLocked()) {
|
|
int srcIndex = currentIndex();
|
|
int dstIndex = tabAt(event->pos());
|
|
if (dstIndex >= 0 && dstIndex < count() && dstIndex != srcIndex) {
|
|
QRect rect = tabRect(srcIndex);
|
|
int x = event->pos().x();
|
|
if (x < rect.left() || x > rect.right()) {
|
|
emit movePage(srcIndex, dstIndex);
|
|
}
|
|
}
|
|
}
|
|
QTabBar::mouseMoveEvent(event);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Set a text field with focus in event position to edit tab name.
|
|
*/
|
|
void PaletteTabBar::mouseDoubleClickEvent(QMouseEvent *event)
|
|
{
|
|
if (!m_hasPageCommand)
|
|
return;
|
|
if (m_pageViewer->getPage()->getPalette()->isLocked())
|
|
return;
|
|
int index = tabAt(event->pos());
|
|
if (index < 0)
|
|
return;
|
|
m_renameTabIndex = index;
|
|
LineEdit *fld = m_renameTextField;
|
|
fld->setText(tabText(index));
|
|
fld->setGeometry(tabRect(index));
|
|
fld->setAlignment(Qt::AlignCenter);
|
|
fld->show();
|
|
fld->selectAll();
|
|
fld->setFocus(Qt::OtherFocusReason);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! If event data is a paletteData accept drag event; otherwise return.
|
|
*/
|
|
void PaletteTabBar::dragEnterEvent(QDragEnterEvent *event)
|
|
{
|
|
if (!m_hasPageCommand)
|
|
return;
|
|
const PaletteData *paletteData = dynamic_cast<const PaletteData *>(event->mimeData());
|
|
if (!paletteData)
|
|
return;
|
|
if ((m_pageViewer->getViewType() == CLEANUP_PALETTE && !paletteData->getPalette()->isCleanupPalette()) ||
|
|
(m_pageViewer->getViewType() == LEVEL_PALETTE && paletteData->getPalette()->isCleanupPalette())) {
|
|
event->ignore();
|
|
return;
|
|
}
|
|
event->acceptProposedAction();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! If tab in event position exist set it as current, otherwise create a new tab
|
|
recalling PageViewer::createDropPage().
|
|
*/
|
|
void PaletteTabBar::dragMoveEvent(QDragMoveEvent *event)
|
|
{
|
|
if (!m_hasPageCommand)
|
|
return;
|
|
const PaletteData *paletteData = dynamic_cast<const PaletteData *>(event->mimeData());
|
|
if (!paletteData)
|
|
return;
|
|
if (paletteData->getPalette() == m_pageViewer->getPage()->getPalette() && paletteData->hasOnlyPalette())
|
|
return;
|
|
int tabIndex = tabAt(event->pos());
|
|
if (0 <= tabIndex && tabIndex < count())
|
|
setCurrentIndex(tabIndex);
|
|
else
|
|
m_pageViewer->createDropPage();
|
|
event->acceptProposedAction();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! Recall PageViewer::drop().
|
|
*/
|
|
void PaletteTabBar::dropEvent(QDropEvent *event)
|
|
{
|
|
if (!m_hasPageCommand)
|
|
return;
|
|
if (!dynamic_cast<const PaletteData *>(event->mimeData()))
|
|
return;
|
|
m_pageViewer->drop(-1, event->mimeData());
|
|
event->acceptProposedAction();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! If current rename tab index is a valid index, set tab text to rename text
|
|
field text; hide the rename text field and emit tabTextChanged() signal.
|
|
*/
|
|
void PaletteTabBar::updateTabName()
|
|
{
|
|
int index = m_renameTabIndex;
|
|
if (index < 0)
|
|
return;
|
|
m_renameTabIndex = -1;
|
|
if (m_renameTextField->text() != "")
|
|
setTabText(index, m_renameTextField->text());
|
|
m_renameTextField->hide();
|
|
emit tabTextChanged(index);
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
/*!
|
|
\class PaletteViewerGUI::PaletteIconWidget
|
|
|
|
\brief PaletteIconWidget class provides a widget to show a palette icon.
|
|
*/
|
|
|
|
#if QT_VERSION >= 0x050500
|
|
PaletteIconWidget::PaletteIconWidget(QWidget *parent, Qt::WindowFlags flags)
|
|
#else
|
|
PaletteIconWidget::PaletteIconWidget(QWidget *parent, Qt::WFlags flags)
|
|
#endif
|
|
: QWidget(parent, flags), m_isOver(false)
|
|
{
|
|
setFixedSize(30, 20);
|
|
setToolTip(QObject::tr("Palette"));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
PaletteIconWidget::~PaletteIconWidget()
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void PaletteIconWidget::paintEvent(QPaintEvent *)
|
|
{
|
|
QPainter p(this);
|
|
|
|
if (m_isOver) {
|
|
static QPixmap dragPaletteIconPixmapOver(":Resources/dragpalette_over.png");
|
|
p.drawPixmap(5, 2, dragPaletteIconPixmapOver);
|
|
} else {
|
|
static QPixmap dragPaletteIconPixmap(":Resources/dragpalette.png");
|
|
p.drawPixmap(5, 2, dragPaletteIconPixmap);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void PaletteIconWidget::mousePressEvent(QMouseEvent *me)
|
|
{
|
|
if (me->button() != Qt::LeftButton) {
|
|
me->ignore();
|
|
return;
|
|
}
|
|
|
|
m_mousePressPos = me->pos();
|
|
m_dragged = false;
|
|
|
|
me->accept();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void PaletteIconWidget::mouseMoveEvent(QMouseEvent *me)
|
|
{
|
|
if ((me->pos() - m_mousePressPos).manhattanLength() > 20 &&
|
|
!m_dragged) {
|
|
m_dragged = true;
|
|
emit startDrag();
|
|
}
|
|
|
|
me->accept();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void PaletteIconWidget::enterEvent(QEvent *event)
|
|
{
|
|
m_isOver = true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void PaletteIconWidget::leaveEvent(QEvent *event)
|
|
{
|
|
m_isOver = false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void PageViewer::zoomInChip()
|
|
{
|
|
ViewMode currentView = getViewMode();
|
|
if (currentView == List || currentView == LargeChips)
|
|
return;
|
|
else if (currentView == SmallChips)
|
|
setViewMode(MediumChips);
|
|
else if (currentView == MediumChips)
|
|
setViewMode(LargeChips);
|
|
}
|
|
void PageViewer::zoomOutChip()
|
|
{
|
|
ViewMode currentView = getViewMode();
|
|
if (currentView == List || currentView == SmallChips)
|
|
return;
|
|
else if (currentView == LargeChips)
|
|
setViewMode(MediumChips);
|
|
else if (currentView == MediumChips)
|
|
setViewMode(SmallChips);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void PageViewer::setNameDisplayMode(NameDisplayMode mode)
|
|
{
|
|
if (m_nameDisplayMode == mode)
|
|
return;
|
|
m_nameDisplayMode = mode;
|
|
|
|
update();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! lock the commands when the styleSelection set to current
|
|
*/
|
|
void PageViewer::updateCommandLocks()
|
|
{
|
|
if (!m_page)
|
|
return;
|
|
//iwasawa
|
|
|
|
bool isLocked = m_page->getPalette()->isLocked();
|
|
|
|
CommandManager *cmd = CommandManager::instance();
|
|
|
|
cmd->getAction("MI_Paste")->setEnabled(!isLocked);
|
|
cmd->getAction("MI_PasteValues")->setEnabled(!isLocked);
|
|
cmd->getAction("MI_PasteColors")->setEnabled(!isLocked);
|
|
cmd->getAction("MI_Clear")->setEnabled(!isLocked);
|
|
cmd->getAction("MI_BlendColors")->setEnabled(!isLocked);
|
|
cmd->getAction("MI_PasteNames")->setEnabled(!isLocked);
|
|
cmd->getAction("MI_GetColorFromStudioPalette")->setEnabled(!isLocked);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*! remove link and revert to the normal style
|
|
*/
|
|
void PageViewer::removeLink()
|
|
{
|
|
if (!m_page || !m_styleSelection || m_styleSelection->isEmpty())
|
|
return;
|
|
|
|
if (m_styleSelection->removeLink())
|
|
emit changeWindowTitleSignal();
|
|
}
|