2016-03-19 06:57:51 +13:00
# include "toonzqt/studiopaletteviewer.h"
// TnzQt includes
# include "toonzqt/menubarcommand.h"
# include "toonzqt/paletteviewer.h"
# include "toonzqt/dvdialog.h"
# include "toonzqt/trepetitionguard.h"
# include "toonzqt/gutil.h"
# include "toonzqt/icongenerator.h"
# include "toonzqt/intfield.h"
# include "palettesscanpopup.h"
# include "palettedata.h"
// TnzLib includes
# include "toonz/studiopalettecmd.h"
# include "toonz/tpalettehandle.h"
# include "toonz/txshsimplelevel.h"
# include "toonz/toonzscene.h"
# include "toonz/sceneproperties.h"
# include "toonz/txsheethandle.h"
# include "toonz/txshlevelhandle.h"
// TnzCore includes
# include "tconvert.h"
# include "tundo.h"
# include "tsystem.h"
# include "../toonz/menubarcommandids.h"
// Qt includes
# include <QHeaderView>
# include <QContextMenuEvent>
# include <QMenu>
# include <QUrl>
# include <QPainter>
# include <QVBoxLayout>
# include <QToolBar>
# include <QInputDialog>
# include <QPushButton>
# include <QDrag>
# include <time.h>
using namespace std ;
using namespace PaletteViewerGUI ;
using namespace DVGui ;
//=============================================================================
namespace
{
//-----------------------------------------------------------------------------
/*! Return true if path is in folder \b rootPath of \b StudioPalette.
*/
bool isInStudioPaletteFolder ( TFilePath path , TFilePath rootPath )
{
if ( path . getType ( ) ! = " tpl " )
return false ;
StudioPalette * studioPalette = StudioPalette : : instance ( ) ;
std : : vector < TFilePath > childrenPath ;
studioPalette - > getChildren ( childrenPath , rootPath ) ;
int i ;
for ( i = 0 ; i < ( int ) childrenPath . size ( ) ; i + + ) {
if ( path = = childrenPath [ i ] )
return true ;
else if ( isInStudioPaletteFolder ( path , childrenPath [ i ] ) )
return true ;
}
return false ;
}
//-----------------------------------------------------------------------------
/*! Return true if path is in a \b StudioPalette folder.
*/
bool isInStudioPalette ( TFilePath path )
{
if ( path . getType ( ) ! = " tpl " )
return false ;
StudioPalette * studioPalette = StudioPalette : : instance ( ) ;
if ( isInStudioPaletteFolder ( path , studioPalette - > getLevelPalettesRoot ( ) ) )
return true ;
if ( isInStudioPaletteFolder ( path , studioPalette - > getProjectPalettesRoot ( ) ) )
return true ;
return false ;
}
//-----------------------------------------------------------------------------
} //namespace
//-----------------------------------------------------------------------------
//=============================================================================
// StudioPaletteTreeViewer
//-----------------------------------------------------------------------------
StudioPaletteTreeViewer : : StudioPaletteTreeViewer ( QWidget * parent ,
TPaletteHandle * studioPaletteHandle ,
TPaletteHandle * levelPaletteHandle ,
TXsheetHandle * xsheetHandle ,
TXshLevelHandle * currentLevelHandle )
: QTreeWidget ( parent ) , m_dropItem ( 0 ) , m_studioPaletteHandle ( studioPaletteHandle ) , m_levelPaletteHandle ( levelPaletteHandle ) , m_currentLevelHandle ( currentLevelHandle ) , m_xsheetHandle ( xsheetHandle ) , m_folderIcon ( QIcon ( ) ) , m_levelPaletteIcon ( QIcon ( ) ) , m_studioPaletteIcon ( QIcon ( ) )
{
setIndentation ( 14 ) ;
setAlternatingRowColors ( true ) ;
header ( ) - > close ( ) ;
setUniformRowHeights ( true ) ;
setIconSize ( QSize ( 21 , 17 ) ) ;
QList < QTreeWidgetItem * > paletteItems ;
QString open = QString ( " :Resources/folder_close.png " ) ;
QString close = QString ( " :Resources/folder_open.png " ) ;
m_folderIcon . addFile ( close , QSize ( 21 , 17 ) , QIcon : : Normal , QIcon : : On ) ;
m_folderIcon . addFile ( open , QSize ( 21 , 17 ) , QIcon : : Normal , QIcon : : Off ) ;
QString levelPaletteIcon = QString ( " :Resources/palette.png " ) ;
m_levelPaletteIcon . addPixmap ( levelPaletteIcon , QIcon : : Normal , QIcon : : On ) ;
QString studioPaletteIcon = QString ( " :Resources/studiopalette.png " ) ;
m_studioPaletteIcon . addPixmap ( studioPaletteIcon , QIcon : : Normal , QIcon : : On ) ;
StudioPalette * studioPalette = StudioPalette : : instance ( ) ;
TFilePath levelPalettePath = studioPalette - > getLevelPalettesRoot ( ) ;
paletteItems . append ( createRootItem ( levelPalettePath ) ) ;
TFilePath projectPalettePath = studioPalette - > getProjectPalettesRoot ( ) ;
if ( TSystem : : doesExistFileOrLevel ( projectPalettePath ) )
paletteItems . append ( createRootItem ( projectPalettePath ) ) ;
insertTopLevelItems ( 0 , paletteItems ) ;
bool ret = connect ( this , SIGNAL ( itemChanged ( QTreeWidgetItem * , int ) ) , SLOT ( onItemChanged ( QTreeWidgetItem * , int ) ) ) ;
ret = ret & & connect ( this , SIGNAL ( itemClicked ( QTreeWidgetItem * , int ) ) , SLOT ( onItemClicked ( QTreeWidgetItem * , int ) ) ) ;
ret = ret & & connect ( this , SIGNAL ( currentItemChanged ( QTreeWidgetItem * , QTreeWidgetItem * ) ) ,
SLOT ( onCurrentItemChanged ( QTreeWidgetItem * , QTreeWidgetItem * ) ) ) ;
ret = ret & & connect ( this , SIGNAL ( itemClicked ( QTreeWidgetItem * , int ) ) , this , SLOT ( onTreeItemExpanded ( QTreeWidgetItem * ) ) ) ;
//refresh tree with shortcut key
QAction * refreshAct = CommandManager : : instance ( ) - > getAction ( MI_RefreshTree ) ;
ret = ret & & connect ( refreshAct , SIGNAL ( triggered ( ) ) , this , SLOT ( onRefreshTreeShortcutTriggered ( ) ) ) ;
addAction ( refreshAct ) ;
m_palettesScanPopup = new PalettesScanPopup ( ) ;
setAcceptDrops ( true ) ;
//Per la selezione multipla
setSelectionMode ( QAbstractItemView : : ExtendedSelection ) ;
StudioPalette : : instance ( ) - > addListener ( this ) ;
TProjectManager : : instance ( ) - > addListener ( this ) ;
refresh ( ) ;
assert ( ret ) ;
}
//-----------------------------------------------------------------------------
StudioPaletteTreeViewer : : ~ StudioPaletteTreeViewer ( )
{
StudioPalette : : instance ( ) - > removeListener ( this ) ;
TProjectManager : : instance ( ) - > removeListener ( this ) ;
}
//-----------------------------------------------------------------------------
void StudioPaletteTreeViewer : : setCurrentLevelHandle ( TXshLevelHandle * currentLevelHandle )
{
m_currentLevelHandle = currentLevelHandle ;
}
//---------------------------------------------------------------------------
void StudioPaletteTreeViewer : : setLevelPaletteHandle ( TPaletteHandle * paletteHandle )
{
m_levelPaletteHandle = paletteHandle ;
}
//-----------------------------------------------------------------------------
void StudioPaletteTreeViewer : : setStdPaletteHandle ( TPaletteHandle * studioPaletteHandle )
{
m_studioPaletteHandle = studioPaletteHandle ;
}
//-----------------------------------------------------------------------------
QTreeWidgetItem * StudioPaletteTreeViewer : : createRootItem ( TFilePath path )
{
QString rootName = QString : : fromStdWString ( path . getWideName ( ) ) ;
if ( rootName ! = " Toonz Palettes " )
rootName = " Project Palettes " ;
QTreeWidgetItem * rootItem = new QTreeWidgetItem ( ( QTreeWidget * ) 0 , QStringList ( rootName ) ) ;
rootItem - > setIcon ( 0 , m_folderIcon ) ;
rootItem - > setData ( 1 , Qt : : UserRole , toQString ( path ) ) ;
refreshItem ( rootItem ) ;
return rootItem ;
}
//-----------------------------------------------------------------------------
bool StudioPaletteTreeViewer : : isRootItem ( QTreeWidgetItem * item )
{
assert ( item ) ;
TFilePath path = getItemPath ( item ) ;
StudioPalette * studioPalette = StudioPalette : : instance ( ) ;
if ( path = = studioPalette - > getLevelPalettesRoot ( ) | |
path = = studioPalette - > getProjectPalettesRoot ( ) )
return true ;
return false ;
}
//-----------------------------------------------------------------------------
QTreeWidgetItem * StudioPaletteTreeViewer : : createItem ( const TFilePath path )
{
StudioPalette * studioPalette = StudioPalette : : instance ( ) ;
QString itemName = toQString ( TFilePath ( path . getWideName ( ) ) ) ;
QTreeWidgetItem * item = new QTreeWidgetItem ( ( QTreeWidget * ) 0 , QStringList ( itemName ) ) ;
if ( studioPalette - > isPalette ( path ) ) {
if ( studioPalette - > hasGlobalName ( path ) )
item - > setIcon ( 0 , m_studioPaletteIcon ) ;
else
item - > setIcon ( 0 , m_levelPaletteIcon ) ;
} else if ( studioPalette - > isFolder ( path ) )
item - > setIcon ( 0 , m_folderIcon ) ;
item - > setData ( 1 , Qt : : UserRole , toQString ( path ) ) ;
item - > setFlags ( item - > flags ( ) | Qt : : ItemIsEditable ) ;
return item ;
}
//-----------------------------------------------------------------------------
TFilePath StudioPaletteTreeViewer : : getItemPath ( QTreeWidgetItem * item )
{
TFilePath path = ( item ) ? TFilePath ( item - > data ( 1 , Qt : : UserRole ) . toString ( ) . toStdWString ( ) )
: TFilePath ( ) ;
return path ;
}
//-----------------------------------------------------------------------------
TFilePath StudioPaletteTreeViewer : : getCurrentFolderPath ( )
{
return getItemPath ( currentItem ( ) ) ;
}
//-----------------------------------------------------------------------------
QTreeWidgetItem * StudioPaletteTreeViewer : : getItem ( const TFilePath path )
{
QList < QTreeWidgetItem * > oldItems = findItems ( QString ( " " ) , Qt : : MatchContains , 0 ) ;
if ( oldItems . isEmpty ( ) )
return 0 ;
int i ;
for ( i = 0 ; i < ( int ) oldItems . size ( ) ; i + + ) {
TFilePath oldItemPath ( oldItems [ i ] - > data ( 1 , Qt : : UserRole ) . toString ( ) . toStdWString ( ) ) ;
if ( oldItemPath = = path )
return oldItems [ i ] ;
else {
QTreeWidgetItem * item = getFolderItem ( oldItems [ i ] , path ) ;
if ( item )
return item ;
}
}
return 0 ;
}
//-----------------------------------------------------------------------------
QTreeWidgetItem * StudioPaletteTreeViewer : : getFolderItem ( QTreeWidgetItem * parent , const TFilePath path )
{
int childrenCount = parent - > childCount ( ) ;
int i ;
for ( i = 0 ; i < childrenCount ; i + + ) {
QTreeWidgetItem * item = parent - > child ( i ) ;
if ( getItemPath ( item ) = = path )
return item ;
else {
item = getFolderItem ( item , path ) ;
if ( item )
return item ;
}
}
return 0 ;
}
//-----------------------------------------------------------------------------
void StudioPaletteTreeViewer : : resetDropItem ( )
{
if ( ! m_dropItem )
return ;
m_dropItem - > setTextColor ( 0 , Qt : : black ) ;
m_dropItem = 0 ;
}
//-----------------------------------------------------------------------------
void StudioPaletteTreeViewer : : refresh ( )
{
m_openedItems . clear ( ) ;
StudioPalette * studioPalette = StudioPalette : : instance ( ) ;
TFilePath levelPalettePath = studioPalette - > getLevelPalettesRoot ( ) ;
refreshItem ( getItem ( levelPalettePath ) ) ;
TFilePath projectPalettePath = studioPalette - > getProjectPalettesRoot ( ) ;
if ( ! TSystem : : doesExistFileOrLevel ( projectPalettePath ) )
return ;
refreshItem ( getItem ( projectPalettePath ) ) ;
//refresh all expanded items
QList < QTreeWidgetItem * > items = findItems ( QString ( " " ) , Qt : : MatchContains | Qt : : MatchRecursive , 0 ) ;
if ( items . isEmpty ( ) )
return ;
for ( int i = 0 ; i < ( int ) items . size ( ) ; i + + )
if ( items [ i ] - > isExpanded ( ) )
refreshItem ( items [ i ] ) ;
}
//-----------------------------------------------------------------------------
/*!When expand a tree, prepare the child items of it
*/
void StudioPaletteTreeViewer : : onTreeItemExpanded ( QTreeWidgetItem * item )
{
if ( ! item )
return ;
//if this item was not yet opened, then get the children of this item
if ( ! m_openedItems . contains ( item ) )
refreshItem ( item ) ;
//expand the item
item - > setExpanded ( ! item - > isExpanded ( ) ) ;
}
//-----------------------------------------------------------------------------
/*! Refresh tree only when this widget has focus
*/
void StudioPaletteTreeViewer : : onRefreshTreeShortcutTriggered ( )
{
if ( hasFocus ( ) )
refresh ( ) ;
}
//-----------------------------------------------------------------------------
/*! Update the content of item
*/
void StudioPaletteTreeViewer : : refreshItem ( QTreeWidgetItem * item )
{
TFilePath folderPath = getItemPath ( item ) ;
assert ( folderPath ! = TFilePath ( ) ) ;
//correct only tpl files and folders
std : : vector < TFilePath > childrenPath ;
StudioPalette : : instance ( ) - > getChildren ( childrenPath , folderPath ) ;
int currentChildCount = item - > childCount ( ) ;
std : : vector < QTreeWidgetItem * > currentChildren ;
int i ;
for ( i = 0 ; i < currentChildCount ; i + + )
currentChildren . push_back ( item - > child ( i ) ) ;
int childrenPathCount = childrenPath . size ( ) ;
int itemIndex = 0 ;
int pathIndex = 0 ;
while ( itemIndex < currentChildCount | | pathIndex < childrenPathCount ) {
TFilePath path = ( pathIndex < childrenPathCount ) ? childrenPath [ pathIndex ] : TFilePath ( ) ;
QTreeWidgetItem * currentItem = ( itemIndex < currentChildCount ) ? currentChildren [ itemIndex ] : 0 ;
TFilePath currentItemPath = getItemPath ( currentItem ) ;
if ( path = = currentItemPath ) {
itemIndex + + ;
pathIndex + + ;
} else if ( ( ! path . isEmpty ( ) & & path < currentItemPath ) | |
currentItemPath . isEmpty ( ) ) {
currentItem = createItem ( path ) ;
item - > insertChild ( itemIndex , currentItem ) ;
itemIndex + + ;
pathIndex + + ;
} else {
assert ( currentItemPath < path | | path . isEmpty ( ) ) ;
assert ( currentItem ) ;
item - > removeChild ( currentItem ) ;
itemIndex + + ;
}
}
m_openedItems . insert ( item ) ;
}
//-----------------------------------------------------------------------------
void StudioPaletteTreeViewer : : resetProjectPaletteFolder ( )
{
int projectPaletteIndex = 1 ;
TFilePath projectPalettePath = StudioPalette : : instance ( ) - > getProjectPalettesRoot ( ) ;
// Prendo l'item del project palette.
QTreeWidgetItem * projectPaletteItem = topLevelItem ( projectPaletteIndex ) ;
if ( projectPaletteItem ) {
// Se il path dell'item e' uguale a quello del project palette corrente ritorno.
if ( getItemPath ( projectPaletteItem ) = = projectPalettePath )
return ;
// Altrimenti lo rimuovo.
removeItemWidget ( projectPaletteItem , 0 ) ;
delete projectPaletteItem ;
//clear the item list in order to search the folder from scratch
m_openedItems . clear ( ) ;
//Toonz Palette is not changed, so resurrect the ToonzPaletteRoot
m_openedItems . insert ( topLevelItem ( 0 ) ) ;
}
if ( ! TSystem : : doesExistFileOrLevel ( projectPalettePath ) )
return ;
// Creo il nuovo item con il nuovo project folder e lo inserisco nell'albero.
// Items in the ProjectPaletteRoot are refreshed here. Stored in openedItems as well.
QTreeWidgetItem * newProjectPaletteItem = createRootItem ( projectPalettePath ) ;
insertTopLevelItem ( projectPaletteIndex , newProjectPaletteItem ) ;
setCurrentItem ( 0 ) ;
}
//-----------------------------------------------------------------------------
void StudioPaletteTreeViewer : : onItemClicked ( QTreeWidgetItem * item , int column )
{
if ( currentItem ( ) & & m_studioPaletteHandle & & m_currentPalette . getPointer ( ) ) {
// if(m_studioPaletteHandle->getPalette() != m_currentPalette.getPointer())
{
m_studioPaletteHandle - > setPalette ( m_currentPalette . getPointer ( ) ) ;
m_studioPaletteHandle - > notifyPaletteSwitched ( ) ;
StudioPaletteCmd : : updateAllLinkedStyles ( m_levelPaletteHandle , m_xsheetHandle ) ;
}
}
}
//-----------------------------------------------------------------------------
void StudioPaletteTreeViewer : : onItemChanged ( QTreeWidgetItem * item , int column )
{
if ( item ! = currentItem ( ) | | isRootItem ( item ) )
return ;
wstring name = item - > text ( column ) . toStdWString ( ) ;
TFilePath oldPath = getCurrentFolderPath ( ) ;
if ( oldPath . isEmpty ( ) | | name . empty ( ) | | oldPath . getWideName ( ) = = name )
return ;
TFilePath newPath ( oldPath . getParentDir ( ) + TFilePath ( name + toWideString ( oldPath . getDottedType ( ) ) ) ) ;
try {
StudioPaletteCmd : : movePalette ( newPath , oldPath ) ;
} catch ( TException & e ) {
error ( QString ( toString ( e . getMessage ( ) ) . c_str ( ) ) ) ;
item - > setText ( column , QString : : fromStdWString ( oldPath . getWideName ( ) ) ) ;
} catch ( . . . ) {
error ( " Can't rename file " ) ;
item - > setText ( column , QString : : fromStdWString ( oldPath . getWideName ( ) ) ) ;
}
refreshItem ( getItem ( oldPath . getParentDir ( ) ) ) ;
setCurrentItem ( getItem ( newPath ) ) ;
}
//-----------------------------------------------------------------------------
/*! Called when the current palette is switched
*/
void StudioPaletteTreeViewer : : onCurrentItemChanged ( QTreeWidgetItem * current , QTreeWidgetItem * previous )
{
TFilePath oldPath = getItemPath ( previous ) ;
TFilePath newPath = getCurrentFolderPath ( ) ;
if ( ! m_studioPaletteHandle )
return ;
if ( m_currentPalette . getPointer ( ) & & m_currentPalette - > getDirtyFlag ( ) ) {
TFilePath oldPath = StudioPalette : : instance ( ) - > getPalettePath ( m_currentPalette - > getGlobalName ( ) ) ;
if ( oldPath = = newPath )
return ;
wstring gname = m_currentPalette - > getGlobalName ( ) ;
QString question ;
question = " The current palette " + QString : : fromStdWString ( oldPath . getWideString ( ) ) + " \n in the studio palette has been modified. Do you want to save your changes? " ;
2016-04-19 20:43:43 +12:00
int ret = DVGui : : MsgBox ( question , QObject : : tr ( " Save " ) , QObject : : tr ( " Discard " ) , QObject : : tr ( " Cancel " ) , 0 ) ;
2016-03-19 06:57:51 +13:00
if ( ret = = 3 ) {
setCurrentItem ( getItem ( oldPath ) ) ;
return ;
}
if ( ret = = 1 ) {
//If the palette is level palette (i.e. NOT stdio palette), just overwrite it
if ( gname . empty ( ) )
StudioPalette : : instance ( ) - > save ( oldPath , m_currentPalette . getPointer ( ) ) ;
else
StudioPalette : : instance ( ) - > setPalette ( oldPath , m_currentPalette . getPointer ( ) , false ) ;
}
m_currentPalette - > setDirtyFlag ( false ) ;
}
//load palette here
m_currentPalette = StudioPalette : : instance ( ) - > getPalette ( newPath , false ) ;
m_studioPaletteHandle - > setPalette ( m_currentPalette . getPointer ( ) ) ;
m_studioPaletteHandle - > notifyPaletteSwitched ( ) ;
}
//-----------------------------------------------------------------------------
void StudioPaletteTreeViewer : : addNewPalette ( )
{
if ( ! currentItem ( ) ) {
error ( " Error: No folder selected. " ) ;
return ;
}
TFilePath newPath ;
try {
newPath = StudioPaletteCmd : : createPalette ( getCurrentFolderPath ( ) , " " , 0 ) ;
} catch ( TException & e ) {
error ( " Can't create palette: " + QString ( toString ( e . getMessage ( ) ) . c_str ( ) ) ) ;
} catch ( . . . ) {
error ( " Can't create palette " ) ;
}
refreshItem ( currentItem ( ) ) ;
setCurrentItem ( getItem ( newPath ) ) ;
}
//-----------------------------------------------------------------------------
void StudioPaletteTreeViewer : : addNewFolder ( )
{
if ( ! currentItem ( ) ) {
error ( " Error: No folder selected. " ) ;
return ;
}
TFilePath newPath ;
try {
newPath = StudioPaletteCmd : : addFolder ( getCurrentFolderPath ( ) ) ;
} catch ( TException & e ) {
error ( " Can't create palette folder: " + QString ( toString ( e . getMessage ( ) ) . c_str ( ) ) ) ;
} catch ( . . . ) {
error ( " Can't create palette folder " ) ;
}
refreshItem ( currentItem ( ) ) ;
setCurrentItem ( getItem ( newPath ) ) ;
}
//-----------------------------------------------------------------------------
/*! Convert level palette to studio palette.
*/
void StudioPaletteTreeViewer : : convertToStudioPalette ( )
{
TFilePath path = getItemPath ( currentItem ( ) ) ;
StudioPalette * studioPalette = StudioPalette : : instance ( ) ;
if ( studioPalette - > isPalette ( path ) ) {
TPalette * palette = studioPalette - > getPalette ( path ) ;
if ( ! palette ) {
error ( " Can't touch palette " ) ;
return ;
}
if ( m_currentPalette - > getPaletteName ( ) ! = palette - > getPaletteName ( ) ) {
error ( " Can't touch palette " ) ;
return ;
}
QString question ;
question = QString : : fromStdWString ( L " Convert " + path . getWideString ( ) + L " to Studio Palette and Overwrite. \n Are you sure ? " ) ;
2016-04-19 20:43:43 +12:00
int ret = DVGui : : MsgBox ( question , QObject : : tr ( " Yes " ) , QObject : : tr ( " No " ) ) ;
2016-03-19 06:57:51 +13:00
if ( ret = = 0 | | ret = = 2 )
return ;
// apply global name
time_t ltime ;
time ( & ltime ) ;
wstring gname = toWideString ( ( int ) ltime ) + L " _ " + toWideString ( rand ( ) ) ;
m_currentPalette - > setGlobalName ( gname ) ;
studioPalette - > setStylesGlobalNames ( m_currentPalette . getPointer ( ) ) ;
studioPalette - > save ( path , m_currentPalette . getPointer ( ) ) ;
m_currentPalette - > setDirtyFlag ( false ) ;
currentItem ( ) - > setIcon ( 0 , m_studioPaletteIcon ) ;
} else
error ( " Can't find palette " ) ;
}
//-----------------------------------------------------------------------------
void StudioPaletteTreeViewer : : deleteItem ( QTreeWidgetItem * item )
{
QTreeWidgetItem * parent = item - > parent ( ) ;
if ( ! parent )
return ;
if ( item - > childCount ( ) > 0 ) {
QString question ;
question = tr ( " This folder is not empty. Delete anyway? " ) ;
2016-04-19 20:43:43 +12:00
int ret = DVGui : : MsgBox ( question , QObject : : tr ( " Yes " ) , QObject : : tr ( " No " ) ) ;
2016-03-19 06:57:51 +13:00
if ( ret = = 0 | | ret = = 2 )
return ;
}
TFilePath path = getItemPath ( item ) ;
StudioPalette * studioPalette = StudioPalette : : instance ( ) ;
if ( studioPalette - > isFolder ( path ) ) {
try {
StudioPaletteCmd : : deleteFolder ( path ) ;
} catch ( TException & e ) {
error ( " Can't delete folder: " + QString ( toString ( e . getMessage ( ) ) . c_str ( ) ) ) ;
} catch ( . . . ) {
error ( " Can't delete folder " ) ;
}
} else {
assert ( studioPalette - > isPalette ( path ) ) ;
try {
StudioPaletteCmd : : deletePalette ( path ) ;
} catch ( TException & e ) {
error ( " Can't delete palette: " + QString ( toString ( e . getMessage ( ) ) . c_str ( ) ) ) ;
} catch ( . . . ) {
error ( " Can't delete palette " ) ;
}
}
refreshItem ( parent ) ;
}
//-----------------------------------------------------------------------------
void StudioPaletteTreeViewer : : deleteItems ( )
{
QList < QTreeWidgetItem * > items = selectedItems ( ) ;
int count = items . size ( ) ;
if ( count = = 0 ) {
error ( " Nothing to delete " ) ;
return ;
}
int i ;
TUndoManager : : manager ( ) - > beginBlock ( ) ;
for ( i = 0 ; i < count ; i + + )
deleteItem ( items [ i ] ) ;
TUndoManager : : manager ( ) - > endBlock ( ) ;
}
//-----------------------------------------------------------------------------
void StudioPaletteTreeViewer : : searchForPalette ( )
{
m_palettesScanPopup - > setCurrentFolder ( getCurrentFolderPath ( ) ) ;
int ret = m_palettesScanPopup - > exec ( ) ;
if ( ret = = QDialog : : Accepted )
refresh ( ) ;
}
//-----------------------------------------------------------------------------
class InvalidateIconsUndo : public TUndo
{
TPaletteP m_targetPalette , m_oldPalette , m_newPalette ;
TXshLevelHandle * m_levelHandle ;
public :
InvalidateIconsUndo ( TXshLevelHandle * levelHandle )
: m_levelHandle ( levelHandle )
{
}
void undo ( ) const
{
TXshLevel * level = m_levelHandle - > getLevel ( ) ;
if ( level ) {
std : : vector < TFrameId > fids ;
level - > getFids ( fids ) ;
invalidateIcons ( level , fids ) ;
}
}
void redo ( ) const
{
undo ( ) ;
}
int getSize ( ) const
{
return sizeof ( * this ) ;
}
} ;
//----------------------------------------------------------------------
//-----------------------------------------------------------------------------
2016-04-19 20:43:43 +12:00
class AdjustPaletteDialog : public DVGui : : Dialog
2016-03-19 06:57:51 +13:00
{
private :
IntField * m_tolerance ;
public :
int getTolerance ( ) { return m_tolerance - > getValue ( ) ; }
AdjustPaletteDialog ( )
: Dialog ( 0 , true , true , " Adjust Current Level to This Palette " )
{
setWindowTitle ( tr ( " Adjust Current Level to This Palette " ) ) ;
beginVLayout ( ) ;
m_tolerance = new IntField ( this ) ;
m_tolerance - > setRange ( 0 , 255 ) ;
m_tolerance - > setValue ( 0 ) ;
addWidget ( tr ( " Tolerance " ) , m_tolerance ) ;
endVLayout ( ) ;
QPushButton * okBtn = new QPushButton ( tr ( " Apply " ) , this ) ;
okBtn - > setDefault ( true ) ;
QPushButton * cancelBtn = new QPushButton ( tr ( " Cancel " ) , this ) ;
bool ret = connect ( okBtn , SIGNAL ( clicked ( ) ) , this , SLOT ( accept ( ) ) ) ;
ret = ret & & connect ( cancelBtn , SIGNAL ( clicked ( ) ) , this , SLOT ( reject ( ) ) ) ;
assert ( ret ) ;
addButtonBarWidget ( okBtn , cancelBtn ) ;
}
} ;
//-------------------------------------------------------------------------------------------------
void StudioPaletteTreeViewer : : loadInCurrentPaletteAndAdaptLevel ( )
{
QList < QTreeWidgetItem * > items = selectedItems ( ) ;
assert ( items . size ( ) = = 1 ) ;
TPalette * palette = m_levelPaletteHandle - > getPalette ( ) ;
if ( ! palette )
return ;
TPalette * newPalette = StudioPalette : : instance ( ) - > getPalette ( getItemPath ( items [ 0 ] ) , true ) ;
if ( ! newPalette )
return ;
AdjustPaletteDialog apd ;
if ( apd . exec ( ) ! = QDialog : : Accepted )
return ;
/* awful patch: since in StudioPaletteCmd(defined in toonzlib) I cannot use the invalidateIcons(defined in toonzqt)
i do invalidate icons from here using a " fake TUndo " , named InvalidateIconsUndo .
And , since I need to refresh icons at the end of the processing , i have to put that fake undo twice , one before and one after .
this way , when the user do either an undo or a redo operation , I am ensured that the last operation is the icon refresh . . .
*/
TUndoManager : : manager ( ) - > beginBlock ( ) ;
TUndoManager : : manager ( ) - > add ( new InvalidateIconsUndo ( m_currentLevelHandle ) ) ;
StudioPaletteCmd : : loadIntoCurrentPalette ( m_levelPaletteHandle , newPalette , m_currentLevelHandle , apd . getTolerance ( ) ) ;
TUndoManager : : manager ( ) - > add ( new InvalidateIconsUndo ( m_currentLevelHandle ) ) ;
TUndoManager : : manager ( ) - > endBlock ( ) ;
InvalidateIconsUndo ( m_currentLevelHandle ) . undo ( ) ;
}
//-----------------------------------------------------------------------------
void StudioPaletteTreeViewer : : loadInCurrentPalette ( )
{
QList < QTreeWidgetItem * > items = selectedItems ( ) ;
int count = items . size ( ) ;
if ( count = = 0 )
return ;
TPalette * palette = m_levelPaletteHandle - > getPalette ( ) ;
if ( ! palette )
return ;
if ( palette - > isLocked ( ) ) {
2016-04-19 20:43:43 +12:00
DVGui : : warning ( " Palette is Locked! " ) ;
2016-03-19 06:57:51 +13:00
return ;
}
TPalette * newPalette = StudioPalette : : instance ( ) - > getPalette ( getItemPath ( items [ 0 ] ) , false ) ;
if ( ! newPalette )
return ;
if ( m_xsheetHandle ) {
int ret = DVGui : : eraseStylesInDemand ( palette , m_xsheetHandle , newPalette ) ;
if ( ret = = 0 )
return ;
}
StudioPaletteCmd : : loadIntoCurrentPalette ( m_levelPaletteHandle , newPalette ) ;
m_currentLevelHandle - > notifyLevelChange ( ) ;
TXshLevel * level = m_currentLevelHandle - > getLevel ( ) ;
if ( level ) {
std : : vector < TFrameId > fids ;
level - > getFids ( fids ) ;
invalidateIcons ( level , fids ) ;
}
int i ;
for ( i = 1 ; i < count ; i + + ) {
TFilePath path = getItemPath ( items [ i ] ) ;
StudioPaletteCmd : : mergeIntoCurrentPalette ( m_levelPaletteHandle , path ) ;
}
// in order to update the title bar of palette viewer
m_levelPaletteHandle - > getPalette ( ) - > setDirtyFlag ( true ) ;
m_levelPaletteHandle - > notifyPaletteChanged ( ) ;
}
//-----------------------------------------------------------------------------
void StudioPaletteTreeViewer : : replaceCurrentPalette ( )
{
QList < QTreeWidgetItem * > items = selectedItems ( ) ;
int count = items . size ( ) ;
if ( count = = 0 )
return ;
//exec confirmation dialog
TPalette * current = m_levelPaletteHandle - > getPalette ( ) ;
if ( ! current )
return ;
QString label ;
if ( count ! = 1 ) //replacing to multiple palettes
label = QString : : fromStdWString ( L " Replacing all selected palettes with the palette \" " + current - > getPaletteName ( ) + L " \" . \n Are you sure ? " ) ;
else {
TPalette * dstPalette = StudioPalette : : instance ( ) - > getPalette ( getItemPath ( items [ 0 ] ) ) ;
if ( ! dstPalette )
return ;
label = QString : : fromStdWString ( L " Replacing the palette \" " + dstPalette - > getPaletteName ( ) + L " \" with the palette \" " + current - > getPaletteName ( ) + L " \" . \n Are you sure ? " ) ;
}
2016-04-19 20:43:43 +12:00
int ret = DVGui : : MsgBox ( label , QObject : : tr ( " Replace " ) , QObject : : tr ( " Cancel " ) , 1 ) ;
2016-03-19 06:57:51 +13:00
if ( ret = = 0 | | ret = = 2 )
return ;
TUndoManager : : manager ( ) - > beginBlock ( ) ;
int i ;
for ( i = 0 ; i < count ; i + + )
StudioPaletteCmd : : replaceWithCurrentPalette ( m_levelPaletteHandle , m_studioPaletteHandle , getItemPath ( items [ i ] ) ) ;
TUndoManager : : manager ( ) - > endBlock ( ) ;
if ( m_currentPalette )
m_currentPalette - > setDirtyFlag ( false ) ;
//in order to update display
onCurrentItemChanged ( currentItem ( ) , currentItem ( ) ) ;
}
//-----------------------------------------------------------------------------
void StudioPaletteTreeViewer : : mergeToCurrentPalette ( )
{
QList < QTreeWidgetItem * > items = selectedItems ( ) ;
int count = items . size ( ) ;
if ( count = = 0 )
return ;
TUndoManager : : manager ( ) - > beginBlock ( ) ;
int i ;
for ( i = 0 ; i < count ; i + + )
StudioPaletteCmd : : mergeIntoCurrentPalette ( m_levelPaletteHandle , getItemPath ( items [ i ] ) ) ;
TUndoManager : : manager ( ) - > endBlock ( ) ;
}
//-----------------------------------------------------------------------------
void StudioPaletteTreeViewer : : paintEvent ( QPaintEvent * event )
{
QTreeWidget : : paintEvent ( event ) ;
QPainter p ( viewport ( ) ) ;
if ( m_dropItem ) {
p . setPen ( QColor ( 50 , 105 , 200 ) ) ;
p . drawRect ( visualItemRect ( m_dropItem ) ) ;
}
}
//-----------------------------------------------------------------------------
void StudioPaletteTreeViewer : : contextMenuEvent ( QContextMenuEvent * event )
{
TFilePath path = getCurrentFolderPath ( ) ;
StudioPalette * studioPalette = StudioPalette : : instance ( ) ;
//Menu' per la selezione singola
QList < QTreeWidgetItem * > items = selectedItems ( ) ;
int count = items . size ( ) ;
if ( count = = 1 ) {
// Verify if click position is in a row containing an item.
QRect rect = visualItemRect ( currentItem ( ) ) ;
if ( ! QRect ( 0 , rect . y ( ) , width ( ) , rect . height ( ) ) . contains ( event - > pos ( ) ) )
return ;
bool isFolder = ( studioPalette - > isFolder ( path ) ) ;
QMenu menu ( this ) ;
if ( isFolder ) {
createMenuAction ( menu , " " , tr ( " New Palette " ) , " addNewPalette() " ) ;
createMenuAction ( menu , " " , tr ( " New Folder " ) , " addNewFolder() " ) ;
}
if ( studioPalette - > isFolder ( path ) & &
studioPalette - > getLevelPalettesRoot ( ) ! = path & &
studioPalette - > getProjectPalettesRoot ( ) ! = path ) {
menu . addSeparator ( ) ;
createMenuAction ( menu , " " , tr ( " Delete Folder " ) , " deleteItems() " ) ;
} else if ( studioPalette - > isPalette ( path ) ) {
if ( m_studioPaletteHandle - > getPalette ( ) ) {
createMenuAction ( menu , " MI_LoadIntoCurrentPalette " , tr ( " Load into Current Palette " ) , " loadInCurrentPalette() " ) ;
createMenuAction ( menu , " MI_AdjustCurrentLevelToPalette " , tr ( " Adjust Current Level to This Palette " ) , " loadInCurrentPaletteAndAdaptLevel() " ) ;
createMenuAction ( menu , " MI_MergeToCurrentPalette " , tr ( " Merge to Current Palette " ) , " mergeToCurrentPalette() " ) ;
if ( ! m_studioPaletteHandle - > getPalette ( ) - > isLocked ( ) ) {
createMenuAction ( menu , " MI_ReplaceWithCurrentPalette " , tr ( " Replace with Current Palette " ) , " replaceCurrentPalette() " ) ;
menu . addSeparator ( ) ;
createMenuAction ( menu , " MI_DeletePalette " , tr ( " Delete Palette " ) , " deleteItems() " ) ;
}
}
if ( ! studioPalette - > hasGlobalName ( path ) ) {
menu . addSeparator ( ) ;
createMenuAction ( menu , " " , tr ( " Convert to Studio Palette and Overwrite " ) , " convertToStudioPalette() " ) ;
}
}
if ( isFolder ) {
menu . addSeparator ( ) ;
createMenuAction ( menu , " " , tr ( " Search for Palettes " ) , " searchForPalette() " ) ;
}
menu . exec ( event - > globalPos ( ) ) ;
return ;
}
//Menu' per la selezione multipla
// Verify if click position is in a row containing an item.
bool areAllPalette = true ;
bool isClickInSelection = false ;
int i ;
for ( i = 0 ; i < count ; i + + ) {
QTreeWidgetItem * item = items [ i ] ;
QRect rect = visualItemRect ( item ) ;
if ( QRect ( 0 , rect . y ( ) , width ( ) , rect . height ( ) ) . contains ( event - > pos ( ) ) )
isClickInSelection = true ;
TFilePath path = getItemPath ( item ) ;
if ( studioPalette - > isFolder ( path ) )
areAllPalette = false ;
}
if ( ! isClickInSelection )
return ;
QMenu menu ( this ) ;
if ( areAllPalette ) {
createMenuAction ( menu , " " , tr ( " Load into Current Palette " ) , " loadInCurrentPalette() " ) ;
createMenuAction ( menu , " " , tr ( " Merge to Current Palette " ) , " mergeToCurrentPalette() " ) ;
createMenuAction ( menu , " " , tr ( " Replace with Current Palette " ) , " replaceCurrentPalette() " ) ;
menu . addSeparator ( ) ;
}
createMenuAction ( menu , " " , tr ( " Delete " ) , " deleteItems() " ) ;
menu . exec ( event - > globalPos ( ) ) ;
}
//-----------------------------------------------------------------------------
void StudioPaletteTreeViewer : : createMenuAction ( QMenu & menu , const char * id , QString name , const char * slot )
{
QAction * act = menu . addAction ( name ) ;
string slotName ( slot ) ;
slotName = string ( " 1 " ) + slotName ;
connect ( act , SIGNAL ( triggered ( ) ) , slotName . c_str ( ) ) ;
}
//-----------------------------------------------------------------------------
void StudioPaletteTreeViewer : : mouseMoveEvent ( QMouseEvent * event )
{
// If left button is not pressed return; is not drag event.
if ( ! ( event - > buttons ( ) & Qt : : LeftButton ) )
return ;
startDragDrop ( ) ;
}
//-----------------------------------------------------------------------------
void StudioPaletteTreeViewer : : startDragDrop ( )
{
TRepetitionGuard guard ;
if ( ! guard . hasLock ( ) )
return ;
QDrag * drag = new QDrag ( this ) ;
QMimeData * mimeData = new QMimeData ;
QList < QUrl > urls ;
QList < QTreeWidgetItem * > items = selectedItems ( ) ;
int i ;
for ( i = 0 ; i < items . size ( ) ; i + + ) {
//Sposto solo le palette.
TFilePath path = getItemPath ( items [ i ] ) ;
if ( ! path . isEmpty ( ) & &
( path . getType ( ) = = " tpl " | | path . getType ( ) = = " pli " | |
path . getType ( ) = = " tlv " | | path . getType ( ) = = " tnz " ) )
urls . append ( pathToUrl ( path ) ) ;
}
if ( urls . isEmpty ( ) )
return ;
mimeData - > setUrls ( urls ) ;
drag - > setMimeData ( mimeData ) ;
Qt : : DropAction dropAction = drag - > exec ( Qt : : CopyAction | Qt : : MoveAction ) ;
viewport ( ) - > update ( ) ;
}
//-----------------------------------------------------------------------------
void StudioPaletteTreeViewer : : dragEnterEvent ( QDragEnterEvent * event )
{
const QMimeData * mimeData = event - > mimeData ( ) ;
const PaletteData * paletteData = dynamic_cast < const PaletteData * > ( mimeData ) ;
if ( acceptResourceDrop ( mimeData - > urls ( ) ) ) {
QList < QUrl > urls = mimeData - > urls ( ) ;
int count = urls . size ( ) ;
if ( count = = 0 )
return ;
//Controllo che almeno un url del drag sia una palette da spostare.
bool isPalette = false ;
int i ;
for ( i = 0 ; i < count ; i + + ) {
QUrl url = urls [ i ] ;
TFilePath path ( url . toLocalFile ( ) . toStdWString ( ) ) ;
if ( ! path . isEmpty ( ) & &
( path . getType ( ) = = " tpl " | | path . getType ( ) = = " pli " | |
path . getType ( ) = = " tlv " | | path . getType ( ) = = " tnz " ) ) {
isPalette = true ;
break ;
}
}
if ( ! isPalette )
return ;
event - > acceptProposedAction ( ) ;
} else if ( paletteData & & paletteData - > hasOnlyPalette ( ) )
event - > acceptProposedAction ( ) ;
viewport ( ) - > update ( ) ;
}
//-----------------------------------------------------------------------------
void StudioPaletteTreeViewer : : dragMoveEvent ( QDragMoveEvent * event )
{
QTreeWidgetItem * item = itemAt ( event - > pos ( ) ) ;
TFilePath newPath = getItemPath ( item ) ;
if ( m_dropItem )
m_dropItem - > setTextColor ( 0 , Qt : : black ) ;
if ( item ) {
m_dropItem = item ;
event - > acceptProposedAction ( ) ;
} else {
m_dropItem = 0 ;
event - > ignore ( ) ;
}
viewport ( ) - > update ( ) ;
}
//-----------------------------------------------------------------------------
void StudioPaletteTreeViewer : : dropEvent ( QDropEvent * event )
{
# ifdef BRAVODEMO
DVGui : : featureNotAvelaible ( ) ;
# else
TFilePath newPath = getItemPath ( m_dropItem ) ;
resetDropItem ( ) ;
const QMimeData * mimeData = event - > mimeData ( ) ;
const PaletteData * paletteData = dynamic_cast < const PaletteData * > ( mimeData ) ;
if ( paletteData ) {
if ( paletteData - > hasOnlyPalette ( ) ) {
TPalette * palette = paletteData - > getPalette ( ) ;
if ( ! palette )
return ;
try {
StudioPaletteCmd : : createPalette ( newPath , toString ( palette - > getPaletteName ( ) ) , palette ) ;
} catch ( TException & e ) {
error ( " Can't create palette: " + QString ( toString ( e . getMessage ( ) ) . c_str ( ) ) ) ;
} catch ( . . . ) {
error ( " Can't create palette " ) ;
}
}
return ;
}
if ( ! mimeData - > hasUrls ( ) | | mimeData - > urls ( ) . size ( ) = = 0 )
return ;
QList < QUrl > urls = mimeData - > urls ( ) ;
TUndoManager : : manager ( ) - > beginBlock ( ) ;
int i ;
for ( i = 0 ; i < urls . size ( ) ; i + + ) {
QUrl url = urls [ i ] ;
TFilePath path = TFilePath ( url . toLocalFile ( ) . toStdWString ( ) ) ;
StudioPalette * studioPalette = StudioPalette : : instance ( ) ;
if ( path = = newPath | | path . getParentDir ( ) = = newPath )
continue ;
if ( isInStudioPalette ( path ) ) {
TFilePath newPalettePath = newPath + TFilePath ( path . getWideName ( ) + toWideString ( path . getDottedType ( ) ) ) ;
try {
StudioPaletteCmd : : movePalette ( newPalettePath , path ) ;
} catch ( TException & e ) {
error ( " Can't rename palette: " + QString ( toString ( e . getMessage ( ) ) . c_str ( ) ) ) ;
} catch ( . . . ) {
error ( " Can't rename palette " ) ;
}
}
}
TUndoManager : : manager ( ) - > endBlock ( ) ;
event - > setDropAction ( Qt : : CopyAction ) ;
event - > accept ( ) ;
# endif
}
//-----------------------------------------------------------------------------
void StudioPaletteTreeViewer : : dragLeaveEvent ( QDragLeaveEvent * event )
{
resetDropItem ( ) ;
update ( ) ;
}
//=============================================================================
// StudioPaletteViewer
//-----------------------------------------------------------------------------
StudioPaletteViewer : : StudioPaletteViewer ( QWidget * parent ,
TPaletteHandle * studioPaletteHandle ,
TPaletteHandle * levelPaletteHandle ,
TFrameHandle * frameHandle ,
TXsheetHandle * xsheetHandle ,
TXshLevelHandle * currentLevelHandle )
: QSplitter ( parent )
{
// style sheet
setObjectName ( " StudioPaletteViewer " ) ;
setFrameStyle ( QFrame : : StyledPanel ) ;
setAcceptDrops ( true ) ;
setOrientation ( Qt : : Vertical ) ;
//First Splitter Widget
QWidget * treeWidget = new QWidget ( this ) ;
QVBoxLayout * treeVLayout = new QVBoxLayout ( treeWidget ) ;
treeVLayout - > setMargin ( 0 ) ;
treeVLayout - > setSpacing ( 0 ) ;
m_studioPaletteTreeViewer =
new StudioPaletteTreeViewer ( treeWidget , studioPaletteHandle , levelPaletteHandle , xsheetHandle , currentLevelHandle ) ;
treeVLayout - > addWidget ( m_studioPaletteTreeViewer ) ;
treeWidget - > setLayout ( treeVLayout ) ;
//Second Splitter Widget
PaletteViewer * studioPaletteViewer = new PaletteViewer ( this , PaletteViewerGUI : : STUDIO_PALETTE ) ;
studioPaletteViewer - > setObjectName ( " PaletteViewerInStudioPalette " ) ;
studioPaletteViewer - > setXsheetHandle ( xsheetHandle ) ;
studioPaletteViewer - > setPaletteHandle ( studioPaletteHandle ) ;
studioPaletteViewer - > setFrameHandle ( frameHandle ) ;
addWidget ( treeWidget ) ;
addWidget ( studioPaletteViewer ) ;
setFocusProxy ( studioPaletteViewer ) ;
}
//-----------------------------------------------------------------------------
StudioPaletteViewer : : ~ StudioPaletteViewer ( )
{
}
//-----------------------------------------------------------------------------
/*! In order to save current palette from the tool button in the PageViewer.
*/
TFilePath StudioPaletteViewer : : getCurrentItemPath ( )
{
return m_studioPaletteTreeViewer - > getCurrentItemPath ( ) ;
}