1207 lines
40 KiB
C++
1207 lines
40 KiB
C++
#include "SpriteEditor.h"
|
|
#include "SpritePicker.h"
|
|
#include "TilePicker.h"
|
|
#include "ColorWells.h"
|
|
#include "ColorEditor.h"
|
|
#include "BorderPanel.h"
|
|
#include "labels.h"
|
|
#include "SelectionManager.h"
|
|
#include "GridOverlay.h"
|
|
|
|
|
|
|
|
extern ColorWells *mainColorStack;
|
|
extern SpritePicker *mainSpritePicker;
|
|
extern TilePicker *mainTilePicker;
|
|
|
|
extern ColorEditor *mainColorEditor;
|
|
|
|
|
|
extern int gameWidth, gameHeight;
|
|
|
|
|
|
extern TextGL *largeTextFixed;
|
|
|
|
|
|
|
|
template <>
|
|
void SizeLimitedVector<SpriteResource>::deleteElementOfType(
|
|
SpriteResource inElement ) {
|
|
// no delete necessary
|
|
}
|
|
|
|
|
|
|
|
SpriteEditor::SpriteEditor( ScreenGL *inScreen )
|
|
: Editor( inScreen ),
|
|
mUndoStack( MAX_UNDOS, false ) {
|
|
|
|
mCloseButton->setToolTip( "tip_closeEdit_sprite" );
|
|
|
|
/*
|
|
LabelGL *titleLabel = new LabelGL( 0.75, 0.5, 0.25,
|
|
0.1, "Tile Editor", largeText );
|
|
|
|
|
|
|
|
mSidePanel->add( titleLabel );
|
|
*/
|
|
|
|
mSidePanel->add( mainColorStack );
|
|
|
|
mainColorStack->addActionListener( this );
|
|
|
|
|
|
mSidePanel->add( mainSpritePicker );
|
|
|
|
mainSpritePicker->addActionListener( this );
|
|
|
|
|
|
mPickerTransButton = mainSpritePicker->getTransButton();
|
|
|
|
mPickerTransButton->addActionListener( this );
|
|
|
|
|
|
|
|
mEditColorButton =
|
|
new EditButtonGL(
|
|
mainColorStack->getAnchorX() - 9,
|
|
mainColorStack->getAnchorY() + mainColorStack->getHeight() - 7,
|
|
8,
|
|
8 );
|
|
|
|
mSidePanel->add( mEditColorButton );
|
|
|
|
mEditColorButton->addActionListener( this );
|
|
mEditColorButton->setToolTip( "tip_edit_color" );
|
|
|
|
|
|
mEditPaletteButton =
|
|
new EditButtonGL(
|
|
mainColorStack->getAnchorX() - 9,
|
|
mainColorStack->getAnchorY() + mainColorStack->getHeight() - 51,
|
|
8,
|
|
8 );
|
|
|
|
mSidePanel->add( mEditPaletteButton );
|
|
|
|
mEditPaletteButton->addActionListener( this );
|
|
mEditPaletteButton->setToolTip( "tip_edit_palette" );
|
|
|
|
/*
|
|
// 1-pixel wide white border
|
|
// inner panel to provide a 1-pixel wide black gap
|
|
|
|
BorderPanel *workingColorBorderPanel =
|
|
new BorderPanel( 256, 206, 48, 14,
|
|
new Color( 0, 0, 0, 1 ),
|
|
new Color( 1, 1, 1, 1 ),
|
|
1 );
|
|
|
|
|
|
// smaller to leave black gap
|
|
GUIPanelGL *workingColorPanel = new GUIPanelGL( 258, 208, 44, 10,
|
|
mWorkingColor );
|
|
|
|
mSidePanel->add( workingColorBorderPanel );
|
|
workingColorBorderPanel->add( workingColorPanel );
|
|
|
|
|
|
mAddButton = new AddButtonGL( 272, 184, 16, 16 );
|
|
mSidePanel->add( mAddButton );
|
|
mAddButton->addActionListener( this );
|
|
|
|
*/
|
|
|
|
|
|
double offset = P;
|
|
|
|
double buttonSize = (gameHeight - 2 * offset - 8) / P;
|
|
|
|
|
|
rgbaColor c = { { 0,0,0,255 } };
|
|
|
|
|
|
|
|
for( int y=0; y<P; y++ ) {
|
|
for( int x=0; x<P; x++ ) {
|
|
|
|
mButtonGrid[y][x] = new HighlightColorButtonGL(
|
|
c,
|
|
8 + x * buttonSize,
|
|
gameWidth - ( 48 + (y + 1) * buttonSize ),
|
|
buttonSize,
|
|
buttonSize );
|
|
|
|
|
|
mMainPanel->add( mButtonGrid[y][x] );
|
|
|
|
mButtonGrid[y][x]->addActionListener( this );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
mToolSet = new DrawToolSet( 2, 42 );
|
|
mMainPanel->add( mToolSet );
|
|
mToolSet->addActionListener( this );
|
|
|
|
|
|
|
|
mSelectionButton = new SelectableButtonGL(
|
|
new Sprite( "selection.tga", true ),
|
|
1,
|
|
mToolSet->getAnchorX() + mToolSet->getWidth() + 5, 42,
|
|
20, 20 );
|
|
|
|
mMainPanel->add( mSelectionButton );
|
|
|
|
mSelectionButton->setSelected( false );
|
|
|
|
mSelectionButton->addActionListener( this );
|
|
|
|
mSelectionButton->setToolTip( "tip_selection" );
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
EightPixelLabel *fieldLabel = new EightPixelLabel( 150, 54,
|
|
"spriteName" );
|
|
mMainPanel->add( fieldLabel );
|
|
|
|
|
|
|
|
int fieldHeight = 8;
|
|
int fieldWidth = 8 * 10;
|
|
|
|
const char *defaultText = "default";
|
|
|
|
mNameField = new TextFieldGL( 150,
|
|
43,
|
|
fieldWidth,
|
|
fieldHeight,
|
|
1,
|
|
defaultText,
|
|
largeTextFixed,
|
|
new Color( 0.75, 0.75, 0.75 ),
|
|
new Color( 0.75, 0.75, 0.75 ),
|
|
new Color( 0.15, 0.15, 0.15 ),
|
|
new Color( 0.75, 0.75, 0.75 ),
|
|
10,
|
|
false );
|
|
mMainPanel->add( mNameField );
|
|
|
|
mNameField->setFocus( true );
|
|
//mNameField->lockFocus( true );
|
|
|
|
mNameField->setCursorPosition( strlen( defaultText ) );
|
|
|
|
mNameField->addActionListener( this );
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// center add button
|
|
double gridEdge = 8 + P * buttonSize;
|
|
|
|
double extra = gameHeight - gridEdge;
|
|
|
|
|
|
// center it vertically on sprite picker
|
|
double addY = mainSpritePicker->getAnchorY() +
|
|
mainSpritePicker->getHeight() - 15;
|
|
|
|
double sideButtonsX = gridEdge + (extra - 16) / 2;
|
|
|
|
mAddButton = new AddButtonGL( sideButtonsX,
|
|
addY,
|
|
16, 16 );
|
|
mMainPanel->add( mAddButton );
|
|
mAddButton->addActionListener( this );
|
|
mAddButton->setToolTip( "tip_addSprite" );
|
|
|
|
mAddAction = false;
|
|
|
|
|
|
double miniButtonSize = P + 4;
|
|
|
|
mMiniViewButton = new TwoSpriteButtonGL(
|
|
NULL, NULL,
|
|
1,
|
|
gridEdge + ( extra - miniButtonSize ) / 2,
|
|
addY - 24,
|
|
miniButtonSize,
|
|
miniButtonSize );
|
|
|
|
mMainPanel->add( mMiniViewButton );
|
|
|
|
|
|
|
|
|
|
mTransformToolSet = new TransformToolSet( sideButtonsX,
|
|
mMiniViewButton->getAnchorY()
|
|
- 8 - 100,
|
|
true ) ;
|
|
|
|
mMainPanel->add( mTransformToolSet );
|
|
|
|
mTransformToolSet->addActionListener( this );
|
|
|
|
|
|
// old:
|
|
// align with grid bottom
|
|
double undoButtonY = gameWidth - ( 48 + P * buttonSize );
|
|
|
|
// new
|
|
// down more to make room for Trans button
|
|
undoButtonY -= 10;
|
|
|
|
|
|
mUndoButton = new UndoButtonGL( sideButtonsX, undoButtonY, 16, 16 );
|
|
mMainPanel->add( mUndoButton );
|
|
mUndoButton->addActionListener( this );
|
|
mUndoButton->setEnabled( false );
|
|
|
|
mRedoButton = new RedoButtonGL( sideButtonsX, undoButtonY + 19, 16, 16 );
|
|
mMainPanel->add( mRedoButton );
|
|
mRedoButton->addActionListener( this );
|
|
mRedoButton->setEnabled( false );
|
|
|
|
|
|
|
|
mEraseButton = new SelectableButtonGL(
|
|
new Sprite( "erase.tga", true ),
|
|
1,
|
|
sideButtonsX - 2, undoButtonY + 20 + 17, 20, 20 );
|
|
|
|
mMainPanel->add( mEraseButton );
|
|
|
|
mEraseButton->setSelected( false );
|
|
|
|
mEraseButton->addActionListener( this );
|
|
|
|
mEraseButton->setToolTip( "tip_erase" );
|
|
|
|
|
|
|
|
setSpriteToEdit( mainSpritePicker->getSelectedResource() );
|
|
|
|
|
|
mPenDown = false;
|
|
|
|
|
|
// listen for tile changes
|
|
mainTilePicker->addActionListener( this );
|
|
|
|
|
|
|
|
// fully-opaque gray to avoid color distortions
|
|
Color gridColor( 0.25, 0.25, 0.25, 1.0 );
|
|
|
|
GridOverlay *overlay = new GridOverlay(
|
|
8,
|
|
gameWidth - ( 48 + P * buttonSize ),
|
|
P * buttonSize, P * buttonSize,
|
|
P,
|
|
gridColor );
|
|
|
|
mMainPanel->add( overlay );
|
|
|
|
|
|
postConstruction();
|
|
}
|
|
|
|
|
|
|
|
SpriteEditor::~SpriteEditor() {
|
|
mSidePanel->remove( mainColorStack );
|
|
mSidePanel->remove( mainSpritePicker );
|
|
}
|
|
|
|
|
|
|
|
void SpriteEditor::setSpriteToEdit( SpriteResource inSprite ) {
|
|
mSpriteToEdit = inSprite;
|
|
|
|
for( int y=0; y<P; y++ ) {
|
|
for( int x=0; x<P; x++ ) {
|
|
|
|
mButtonGrid[y][x]->setColor( mSpriteToEdit.getColor( x, y ) );
|
|
mButtonGrid[y][x]->setHighlight(
|
|
mSpriteToEdit.getTrans( x, y ) );
|
|
}
|
|
}
|
|
refreshMiniView();
|
|
|
|
char *name = mSpriteToEdit.getSpriteName();
|
|
|
|
mNameField->setText( name );
|
|
mNameField->setCursorPosition( strlen( name ) );
|
|
|
|
delete [] name;
|
|
}
|
|
|
|
|
|
|
|
void SpriteEditor::refreshMiniView() {
|
|
char useTrans = mainSpritePicker->isTransOn();
|
|
|
|
// don't use cached version
|
|
mMiniViewButton->setFrontSprite( mSpriteToEdit.getSprite( useTrans,
|
|
false ) );
|
|
|
|
if( useTrans ) {
|
|
// backdrop behind sprite when transparency shown
|
|
mMiniViewButton->setSprite(
|
|
mainTilePicker->getBackgroundTile().getSprite() );
|
|
}
|
|
else {
|
|
// no backdrop
|
|
mMiniViewButton->setSprite( NULL );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
char SpriteEditor::recursiveFill( int inX, int inY,
|
|
rgbaColor inOldColor,
|
|
char inOldTrans,
|
|
rgbaColor inNewColor,
|
|
drawTool inTool ) {
|
|
|
|
char fillable =
|
|
// filling non-trans area, and colors match
|
|
( !inOldTrans &&
|
|
! mSpriteToEdit.getTrans( inX, inY ) &&
|
|
equal( mSpriteToEdit.getColor( inX, inY ), inOldColor ) )
|
|
|
|
// or filling a trans area, and this pixel is trans
|
|
||
|
|
( inOldTrans && mSpriteToEdit.getTrans( inX, inY ) );
|
|
|
|
|
|
char alreadyFilled =
|
|
! mSpriteToEdit.getTrans( inX, inY )
|
|
&&
|
|
equal( mSpriteToEdit.getColor( inX, inY ), inNewColor );
|
|
|
|
|
|
|
|
if( fillable && ! alreadyFilled ) {
|
|
|
|
mButtonGrid[inY][inX]->setColor( inNewColor );
|
|
mSpriteToEdit.editSprite( inX, inY, inNewColor );
|
|
|
|
// always turn trans off wherever user draws with colors
|
|
mSpriteToEdit.editTrans( inX, inY, false );
|
|
mButtonGrid[inY][inX]->setHighlight( false );
|
|
|
|
// call on neighbors
|
|
if( inTool == fill || inTool == horLine ) {
|
|
if( inX > 0 ) {
|
|
recursiveFill( inX - 1, inY, inOldColor, inOldTrans,
|
|
inNewColor, inTool );
|
|
}
|
|
if( inX < P - 1 ) {
|
|
recursiveFill( inX + 1, inY, inOldColor, inOldTrans,
|
|
inNewColor, inTool );
|
|
}
|
|
}
|
|
|
|
if( inTool == fill || inTool == verLine ) {
|
|
if( inY > 0 ) {
|
|
recursiveFill( inX, inY - 1, inOldColor, inOldTrans,
|
|
inNewColor, inTool );
|
|
}
|
|
if( inY < P - 1 ) {
|
|
recursiveFill( inX, inY + 1, inOldColor, inOldTrans,
|
|
inNewColor, inTool );
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
|
|
char SpriteEditor::recursiveFill( int inX, int inY,
|
|
rgbaColor inOldColor,
|
|
char inOldTrans, char inNewTrans,
|
|
drawTool inTool ) {
|
|
|
|
if( equal( mSpriteToEdit.getColor( inX, inY ), inOldColor )
|
|
&&
|
|
mSpriteToEdit.getTrans( inX, inY ) == inOldTrans
|
|
&&
|
|
mSpriteToEdit.getTrans( inX, inY ) != inNewTrans ) {
|
|
|
|
mButtonGrid[inY][inX]->setHighlight( inNewTrans );
|
|
mSpriteToEdit.editTrans( inX, inY, inNewTrans );
|
|
|
|
// call on neighbors
|
|
if( inTool == fill || inTool == horLine ) {
|
|
if( inX > 0 ) {
|
|
recursiveFill( inX - 1, inY, inOldColor,
|
|
inOldTrans, inNewTrans, inTool );
|
|
}
|
|
if( inX < P - 1 ) {
|
|
recursiveFill( inX + 1, inY, inOldColor,
|
|
inOldTrans, inNewTrans, inTool );
|
|
}
|
|
}
|
|
|
|
if( inTool == fill || inTool == verLine ) {
|
|
if( inY > 0 ) {
|
|
recursiveFill( inX, inY - 1, inOldColor,
|
|
inOldTrans, inNewTrans, inTool );
|
|
}
|
|
if( inY < P - 1 ) {
|
|
recursiveFill( inX, inY + 1, inOldColor,
|
|
inOldTrans, inNewTrans, inTool );
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
|
|
char SpriteEditor::recursiveSelectionFill( int inX, int inY,
|
|
rgbaColor inOldColor,
|
|
char inOldTrans,
|
|
char inOldSelection,
|
|
char inNewSelection,
|
|
drawTool inTool ) {
|
|
|
|
if( ( equal( mSpriteToEdit.getColor( inX, inY ), inOldColor )
|
|
||
|
|
( inOldTrans && mSpriteToEdit.getTrans( inX, inY ) ) )
|
|
&&
|
|
SelectionManager::isInSelection( inX, inY ) == inOldSelection
|
|
&&
|
|
SelectionManager::isInSelection( inX, inY ) != inNewSelection ) {
|
|
|
|
SelectionManager::toggleSelection( inX, inY, inNewSelection );
|
|
|
|
mButtonGrid[inY][inX]->setSelection( inNewSelection );
|
|
|
|
if( inNewSelection ) {
|
|
SelectionManager::setColor(
|
|
inX, inY,
|
|
mSpriteToEdit.getColor( inX, inY ) );
|
|
SelectionManager::setTrans(
|
|
inX, inY,
|
|
mSpriteToEdit.getTrans( inX, inY ) );
|
|
}
|
|
|
|
// call on neighbors
|
|
if( inTool == fill || inTool == horLine ) {
|
|
if( inX > 0 ) {
|
|
recursiveSelectionFill( inX - 1, inY, inOldColor,
|
|
inOldTrans,
|
|
inOldSelection, inNewSelection,
|
|
inTool );
|
|
}
|
|
if( inX < P - 1 ) {
|
|
recursiveSelectionFill( inX + 1, inY, inOldColor,
|
|
inOldTrans,
|
|
inOldSelection, inNewSelection,
|
|
inTool );
|
|
}
|
|
}
|
|
|
|
if( inTool == fill || inTool == verLine ) {
|
|
if( inY > 0 ) {
|
|
recursiveSelectionFill( inX, inY - 1, inOldColor,
|
|
inOldTrans,
|
|
inOldSelection, inNewSelection,
|
|
inTool );
|
|
}
|
|
if( inY < P - 1 ) {
|
|
recursiveSelectionFill( inX, inY + 1, inOldColor,
|
|
inOldTrans,
|
|
inOldSelection, inNewSelection,
|
|
inTool );
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
void SpriteEditor::toggleErase() {
|
|
mEraseButton->setSelected( ! mEraseButton->getSelected() );
|
|
|
|
char showErase = mEraseButton->getSelected();
|
|
|
|
/*
|
|
// FIXME
|
|
for( int y=0; y<P; y++ ) {
|
|
for( int x=0; x<P; x++ ) {
|
|
mButtonGrid[y][x]->setHighlight(
|
|
mSpriteToEdit.getTrans( x, y ) && showTrans );
|
|
}
|
|
}
|
|
*/
|
|
|
|
|
|
if( showErase && mSelectionButton->getSelected() ) {
|
|
// only one on at a time
|
|
toggleSelection();
|
|
}
|
|
|
|
|
|
|
|
// update display of trans in mini view
|
|
refreshMiniView();
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void SpriteEditor::toggleSelection() {
|
|
mSelectionButton->setSelected( ! mSelectionButton->getSelected() );
|
|
|
|
char showSel = mSelectionButton->getSelected();
|
|
|
|
for( int y=0; y<P; y++ ) {
|
|
for( int x=0; x<P; x++ ) {
|
|
mButtonGrid[y][x]->setSelection(
|
|
SelectionManager::isInSelection( x, y ) && showSel );
|
|
}
|
|
}
|
|
|
|
// commit selection only when it is turned on
|
|
// (right before it is turned off, the last edits of selection have updated
|
|
// the selected colors)
|
|
if( showSel ) {
|
|
// copy colors
|
|
for( int y=0; y<P; y++ ) {
|
|
for( int x=0; x<P; x++ ) {
|
|
if( SelectionManager::isInSelection( x, y ) ) {
|
|
SelectionManager::setColor(
|
|
x, y,
|
|
mSpriteToEdit.getColor( x, y ) );
|
|
SelectionManager::setTrans(
|
|
x, y,
|
|
mSpriteToEdit.getTrans( x, y ) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if( showSel && mEraseButton->getSelected() ) {
|
|
// only one on at a time
|
|
toggleErase();
|
|
}
|
|
|
|
clearStampOverlay();
|
|
}
|
|
|
|
|
|
|
|
void SpriteEditor::clearStampOverlay() {
|
|
// turn all overlays off
|
|
for( int by=0; by<P; by++ ) {
|
|
for( int bx=0; bx<P; bx++ ) {
|
|
mButtonGrid[by][bx]->
|
|
setOverlay( false );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void SpriteEditor::colorEditorClosed() {
|
|
// it might have been closed by an EditPalette button press
|
|
if( mainColorEditor->mEditPalettePressed ) {
|
|
showPaletteEditor();
|
|
}
|
|
}
|
|
|
|
|
|
void SpriteEditor::actionPerformed( GUIComponent *inTarget ) {
|
|
// superclass
|
|
Editor::actionPerformed( inTarget );
|
|
|
|
|
|
if( inTarget == mainColorStack ) {
|
|
// new color picked on stack
|
|
|
|
// non-erase mode
|
|
if( mEraseButton->getSelected() ) {
|
|
toggleErase();
|
|
}
|
|
}
|
|
else if( inTarget == mainSpritePicker ) {
|
|
if( ! mAddAction &&
|
|
! mainSpritePicker->wasLastActionFromPress() ) {
|
|
|
|
// will change sprite
|
|
|
|
mUndoStack.push_back( mSpriteToEdit );
|
|
mUndoButton->setEnabled( true );
|
|
|
|
setSpriteToEdit( mainSpritePicker->getSelectedResource() );
|
|
|
|
// new branch... "redo" future now impossible
|
|
mRedoStack.deleteAll();
|
|
mRedoButton->setEnabled( false );
|
|
}
|
|
}
|
|
else if( inTarget == mPickerTransButton ) {
|
|
refreshMiniView();
|
|
}
|
|
else if( inTarget == mainTilePicker ) {
|
|
// tile change... tile used behind sprite transparency
|
|
refreshMiniView();
|
|
}
|
|
else if( inTarget == mNameField ) {
|
|
|
|
mUndoStack.push_back( mSpriteToEdit );
|
|
mUndoButton->setEnabled( true );
|
|
|
|
// new branch... "redo" future now impossible
|
|
mRedoStack.deleteAll();
|
|
mRedoButton->setEnabled( false );
|
|
|
|
mSpriteToEdit.editSpriteName( mNameField->getText() );
|
|
}
|
|
else if( inTarget == mAddButton ) {
|
|
addSprite();
|
|
}
|
|
else if( inTarget == mEditColorButton ) {
|
|
mainColorEditor->setEditPaletteButtonVisible( true );
|
|
showColorEditor();
|
|
}
|
|
else if( inTarget == mEditPaletteButton ) {
|
|
showPaletteEditor();
|
|
}
|
|
else if( inTarget == mUndoButton ) {
|
|
int lastIndex = mUndoStack.size() - 1;
|
|
|
|
SpriteResource last = *( mUndoStack.getElement( lastIndex ) );
|
|
mUndoStack.deleteElement( lastIndex );
|
|
if( mUndoStack.size() == 0 ) {
|
|
mUndoButton->setEnabled( false );
|
|
}
|
|
|
|
mRedoStack.push_back( mSpriteToEdit );
|
|
mRedoButton->setEnabled( true );
|
|
|
|
setSpriteToEdit( last );
|
|
}
|
|
else if( inTarget == mRedoButton ) {
|
|
int nextIndex = mRedoStack.size() - 1;
|
|
|
|
SpriteResource next = *( mRedoStack.getElement( nextIndex ) );
|
|
mRedoStack.deleteElement( nextIndex );
|
|
if( mRedoStack.size() == 0 ) {
|
|
mRedoButton->setEnabled( false );
|
|
}
|
|
|
|
mUndoStack.push_back( mSpriteToEdit );
|
|
mUndoButton->setEnabled( true );
|
|
|
|
setSpriteToEdit( next );
|
|
}
|
|
else if( inTarget == mEraseButton ) {
|
|
toggleErase();
|
|
}
|
|
else if( inTarget == mSelectionButton ) {
|
|
toggleSelection();
|
|
}
|
|
else if( inTarget == mTransformToolSet ) {
|
|
mUndoStack.push_back( mSpriteToEdit );
|
|
mUndoButton->setEnabled( true );
|
|
|
|
// new branch... "redo" future now impossible
|
|
mRedoStack.deleteAll();
|
|
mRedoButton->setEnabled( false );
|
|
|
|
SpriteResource oldSpriteState = mSpriteToEdit;
|
|
|
|
switch( mTransformToolSet->getLastPressed() ) {
|
|
case flipH: {
|
|
for( int y=0; y<P; y++ ) {
|
|
for( int x=0; x<P; x++ ) {
|
|
rgbaColor flipColor =
|
|
oldSpriteState.getColor( P - x - 1, y );
|
|
char flipTrans =
|
|
oldSpriteState.getTrans( P - x - 1, y );
|
|
|
|
mButtonGrid[y][x]->setColor( flipColor );
|
|
|
|
mSpriteToEdit.editSprite( x, y, flipColor );
|
|
mSpriteToEdit.editTrans( x, y, flipTrans );
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case flipV: {
|
|
for( int y=0; y<P; y++ ) {
|
|
for( int x=0; x<P; x++ ) {
|
|
rgbaColor flipColor =
|
|
oldSpriteState.getColor( x, P - y - 1 );
|
|
char flipTrans =
|
|
oldSpriteState.getTrans( x, P - y - 1 );
|
|
|
|
mButtonGrid[y][x]->setColor( flipColor );
|
|
|
|
mSpriteToEdit.editSprite( x, y, flipColor );
|
|
mSpriteToEdit.editTrans( x, y, flipTrans );
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
case rotateCCW: {
|
|
for( int y=0; y<P; y++ ) {
|
|
for( int x=0; x<P; x++ ) {
|
|
rgbaColor flipColor =
|
|
oldSpriteState.getColor( P - y - 1, x );
|
|
char flipTrans =
|
|
oldSpriteState.getTrans( P - y - 1, x );
|
|
|
|
mButtonGrid[y][x]->setColor( flipColor );
|
|
|
|
mSpriteToEdit.editSprite( x, y, flipColor );
|
|
mSpriteToEdit.editTrans( x, y, flipTrans );
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
case rotateCW: {
|
|
for( int y=0; y<P; y++ ) {
|
|
for( int x=0; x<P; x++ ) {
|
|
rgbaColor flipColor =
|
|
oldSpriteState.getColor( y, P - x - 1 );
|
|
char flipTrans =
|
|
oldSpriteState.getTrans( y, P - x - 1 );
|
|
|
|
mButtonGrid[y][x]->setColor( flipColor );
|
|
|
|
mSpriteToEdit.editSprite( x, y, flipColor );
|
|
mSpriteToEdit.editTrans( x, y, flipTrans );
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
case clear: {
|
|
rgbaColor black;
|
|
black.comp.r = 0;
|
|
black.comp.g = 0;
|
|
black.comp.b = 0;
|
|
black.comp.a = 255;
|
|
|
|
for( int y=0; y<P; y++ ) {
|
|
for( int x=0; x<P; x++ ) {
|
|
mButtonGrid[y][x]->setColor( black );
|
|
mSpriteToEdit.editSprite( x, y, black );
|
|
mSpriteToEdit.editTrans( x, y, true );
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case colorize: {
|
|
rgbaColor c =
|
|
mainColorStack->getSelectedColor();
|
|
|
|
for( int y=0; y<P; y++ ) {
|
|
for( int x=0; x<P; x++ ) {
|
|
rgbaColor oldColor = mSpriteToEdit.getColor( x, y );
|
|
|
|
// multiply all components to apply color
|
|
for( int b=0; b<3; b++ ) {
|
|
oldColor.bytes[b] = (unsigned char)(
|
|
( oldColor.bytes[b] * c.bytes[b] )
|
|
/ 255 );
|
|
}
|
|
|
|
mButtonGrid[y][x]->setColor( oldColor );
|
|
mSpriteToEdit.editSprite( x, y, oldColor );
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
}
|
|
|
|
|
|
char showTrans = true;
|
|
|
|
for( int y=0; y<P; y++ ) {
|
|
for( int x=0; x<P; x++ ) {
|
|
mButtonGrid[y][x]->setHighlight(
|
|
mSpriteToEdit.getTrans( x, y ) && showTrans );
|
|
}
|
|
}
|
|
|
|
refreshMiniView();
|
|
}
|
|
else if( inTarget == mToolSet ) {
|
|
clearStampOverlay();
|
|
}
|
|
else if( !mainColorEditor->getDragging() ){
|
|
// check grid
|
|
// but only if not in the middle of drag-picking a color in the editor
|
|
|
|
|
|
char found = false;
|
|
|
|
for( int y=0; y<P && !found; y++ ) {
|
|
for( int x=0; x<P && !found; x++ ) {
|
|
if( inTarget == mButtonGrid[y][x] &&
|
|
! mButtonGrid[y][x]->wasLastActionHover() ) {
|
|
found = true;
|
|
|
|
SpriteResource oldSpriteState = mSpriteToEdit;
|
|
char changed = false;
|
|
|
|
switch( mToolSet->getSelected() ) {
|
|
case pen: {
|
|
if( mEraseButton->getSelected() ) {
|
|
// add transparency with pen
|
|
|
|
if( !mPenDown ) {
|
|
// set ink until released
|
|
mTransInk = true;
|
|
|
|
mPenDown = true;
|
|
changed = true;
|
|
}
|
|
|
|
// use ink already set
|
|
mSpriteToEdit.editTrans( x, y, mTransInk );
|
|
|
|
mButtonGrid[y][x]->setHighlight( mTransInk );
|
|
refreshMiniView();
|
|
}
|
|
else if( mSelectionButton->getSelected() ) {
|
|
// edit selection with pen
|
|
|
|
if( !mPenDown ) {
|
|
// set ink until released
|
|
mSelectionInk =
|
|
! SelectionManager::
|
|
isInSelection( x, y );
|
|
|
|
mPenDown = true;
|
|
changed = true;
|
|
}
|
|
|
|
// use ink already set
|
|
SelectionManager::toggleSelection(
|
|
x, y, mSelectionInk );
|
|
|
|
mButtonGrid[y][x]->setSelection(
|
|
mSelectionInk );
|
|
|
|
if( mSelectionInk ) {
|
|
SelectionManager::setColor(
|
|
x, y,
|
|
mSpriteToEdit.getColor( x, y ) );
|
|
|
|
SelectionManager::setTrans(
|
|
x, y,
|
|
mSpriteToEdit.getTrans( x, y ) );
|
|
}
|
|
}
|
|
else {
|
|
if( mainColorEditor->isVisible() ) {
|
|
// push edited color onto stack first
|
|
mainColorEditor->addColor();
|
|
}
|
|
|
|
|
|
// edit pixel colors
|
|
rgbaColor c =
|
|
mainColorStack->getSelectedColor();
|
|
|
|
if( ! equal(
|
|
c,
|
|
mSpriteToEdit.getColor( x, y ) )
|
|
||
|
|
mSpriteToEdit.getTrans( x, y ) ) {
|
|
|
|
mButtonGrid[y][x]->setColor( c );
|
|
mSpriteToEdit.editSprite( x, y, c );
|
|
|
|
// always turn trans off wherever user
|
|
// draws with colors
|
|
mSpriteToEdit.editTrans( x, y, false );
|
|
mButtonGrid[y][x]->setHighlight( false );
|
|
|
|
refreshMiniView();
|
|
|
|
// don't count single pen dots as undoable
|
|
// until pen is released
|
|
// save undo state only on on initial
|
|
// presses
|
|
if( !mPenDown ) {
|
|
mPenDown = true;
|
|
changed = true;
|
|
}
|
|
}
|
|
}
|
|
if( !mButtonGrid[y][x]->isPressed() ) {
|
|
// a release
|
|
mPenDown = false;
|
|
}
|
|
}
|
|
break;
|
|
case horLine:
|
|
case verLine:
|
|
case fill:
|
|
if( mEraseButton->getSelected() ) {
|
|
// add to trans
|
|
if( !mPenDown ) {
|
|
mTransInk = true;
|
|
}
|
|
|
|
changed = recursiveFill(
|
|
x, y,
|
|
mSpriteToEdit.getColor( x, y ),
|
|
mSpriteToEdit.getTrans( x, y ),
|
|
mTransInk,
|
|
mToolSet->getSelected() );
|
|
|
|
refreshMiniView();
|
|
|
|
if( !mPenDown ) {
|
|
mPenDown = true;
|
|
}
|
|
if( !mButtonGrid[y][x]->isPressed() ) {
|
|
// a release
|
|
mPenDown = false;
|
|
}
|
|
}
|
|
else if( mSelectionButton->getSelected() ) {
|
|
if( !mPenDown ) {
|
|
mSelectionInk = ! SelectionManager::
|
|
isInSelection( x, y );
|
|
}
|
|
|
|
recursiveSelectionFill(
|
|
x, y,
|
|
mSpriteToEdit.getColor( x, y ),
|
|
mSpriteToEdit.getTrans( x, y ),
|
|
SelectionManager::
|
|
isInSelection( x, y ),
|
|
mSelectionInk,
|
|
mToolSet->getSelected() );
|
|
|
|
if( !mPenDown ) {
|
|
mPenDown = true;
|
|
}
|
|
if( !mButtonGrid[y][x]->isPressed() ) {
|
|
// a release
|
|
mPenDown = false;
|
|
}
|
|
}
|
|
else {
|
|
if( mainColorEditor->isVisible() ) {
|
|
// push edited color onto stack first
|
|
mainColorEditor->addColor();
|
|
}
|
|
|
|
changed = recursiveFill(
|
|
x, y,
|
|
mSpriteToEdit.getColor( x, y ),
|
|
mSpriteToEdit.getTrans( x, y ),
|
|
mainColorStack->getSelectedColor(),
|
|
mToolSet->getSelected() );
|
|
refreshMiniView();
|
|
}
|
|
break;
|
|
case pickColor:
|
|
if( mSpriteToEdit.getTrans( x, y ) ) {
|
|
// trans ink here, switch to erase mode
|
|
// thus "picking up" trans ink
|
|
|
|
if( ! mEraseButton->getSelected() ) {
|
|
toggleErase();
|
|
}
|
|
}
|
|
else {
|
|
// pick up color
|
|
mainColorStack->pushColor(
|
|
mSpriteToEdit.getColor( x, y ) );
|
|
|
|
// non-erase mode
|
|
if( mEraseButton->getSelected() ) {
|
|
toggleErase();
|
|
}
|
|
}
|
|
break;
|
|
case stamp: {
|
|
if( !mPenDown ) {
|
|
changed = true;
|
|
mPenDown = true;
|
|
}
|
|
// insert colors from selection
|
|
|
|
intPair center =
|
|
SelectionManager::getSelectionCenter();
|
|
|
|
for( int sy=0; sy<P; sy++ ) {
|
|
for( int sx=0; sx<P; sx++ ) {
|
|
if( SelectionManager::isInSelection(
|
|
sx, sy ) ) {
|
|
|
|
int iy = y + sy - center.y;
|
|
int ix = x + sx - center.x;
|
|
|
|
if( iy < P && ix < P
|
|
&&
|
|
iy >= 0 && ix >= 0 ) {
|
|
rgbaColor c = SelectionManager::
|
|
getColor( sx, sy );
|
|
|
|
char t = SelectionManager::
|
|
getTrans( sx, sy );
|
|
|
|
// always turn trans off wherever
|
|
// user draws with colors,
|
|
// unless that spot in selection is
|
|
// trans
|
|
|
|
mButtonGrid[iy][ix]->setColor( c );
|
|
mButtonGrid[iy][ix]->setHighlight(
|
|
t );
|
|
|
|
mSpriteToEdit.editSprite(
|
|
ix, iy, c );
|
|
mSpriteToEdit.editTrans(
|
|
ix, iy, t );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
refreshMiniView();
|
|
|
|
if( !mButtonGrid[y][x]->isPressed() ) {
|
|
// a release
|
|
mPenDown = false;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
|
|
|
|
if( changed ) {
|
|
mUndoStack.push_back( oldSpriteState );
|
|
mUndoButton->setEnabled( true );
|
|
|
|
// new branch... "redo" future now impossible
|
|
mRedoStack.deleteAll();
|
|
mRedoButton->setEnabled( false );
|
|
}
|
|
|
|
|
|
|
|
}
|
|
else if( inTarget == mButtonGrid[y][x] &&
|
|
mButtonGrid[y][x]->wasLastActionHover() ) {
|
|
found = true;
|
|
|
|
if( mToolSet->getSelected() == stamp ) {
|
|
|
|
// preview of selection that will be inserted
|
|
// upon click
|
|
|
|
// first, turn all overlays off
|
|
for( int by=0; by<P; by++ ) {
|
|
for( int bx=0; bx<P; bx++ ) {
|
|
mButtonGrid[by][bx]->
|
|
setOverlay( false );
|
|
}
|
|
}
|
|
|
|
intPair center =
|
|
SelectionManager::getSelectionCenter();
|
|
|
|
for( int sy=0; sy<P; sy++ ) {
|
|
for( int sx=0; sx<P; sx++ ) {
|
|
if( SelectionManager::isInSelection(
|
|
sx, sy ) ) {
|
|
|
|
int iy = y + sy - center.y;
|
|
int ix = x + sx - center.x;
|
|
|
|
if( iy < P && ix < P
|
|
&&
|
|
iy >= 0 && ix >= 0 ) {
|
|
rgbaColor c = SelectionManager::
|
|
getColor( sx, sy );
|
|
char t = SelectionManager::
|
|
getTrans( sx, sy );
|
|
|
|
mButtonGrid[iy][ix]->
|
|
setOverlayColor( c );
|
|
mButtonGrid[iy][ix]->
|
|
setOverlayTrans( t );
|
|
|
|
mButtonGrid[iy][ix]->
|
|
setOverlay( true );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void SpriteEditor::editorClosing() {
|
|
addSprite();
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void SpriteEditor::addSprite() {
|
|
mAddAction = true;
|
|
mSpriteToEdit.finishEdit();
|
|
mainSpritePicker->setSelectedResource( mSpriteToEdit, true );
|
|
mAddAction = false;
|
|
}
|