2016-03-19 06:57:51 +13:00
# include "edittoolgadgets.h"
# include "tgl.h"
# include "toonz/tfxhandle.h"
# include "toonz/tobjecthandle.h"
# include "toonz/tframehandle.h"
# include "toonz/txsheethandle.h"
# include "toonz/stage.h"
# include "tools/tool.h"
# include "tfx.h"
# include "tparamcontainer.h"
# include "toonz/tcolumnfx.h"
# include "tdoubleparam.h"
# include "tparamset.h"
# include "toonz/stage.h"
# include "tundo.h"
# include "tparamuiconcept.h"
# include "historytypes.h"
using namespace EditToolGadgets ;
GLdouble FxGadget : : m_selectedColor [ 3 ] = { 0.2 , 0.8 , 0.1 } ;
//*************************************************************************************
// FxGadgetUndo definition
//*************************************************************************************
class FxGadgetUndo : public TUndo
{
struct ParamData {
TDoubleParamP m_param ;
double m_oldValue , m_newValue ;
bool m_wasKeyframe ;
} ;
private :
std : : vector < ParamData > m_params ;
int m_frame ;
public :
FxGadgetUndo ( const std : : vector < TDoubleParamP > & params , int frame )
: m_frame ( frame )
{
m_params . resize ( params . size ( ) ) ;
for ( int i = 0 ; i < ( int ) params . size ( ) ; i + + ) {
m_params [ i ] . m_param = params [ i ] ;
m_params [ i ] . m_oldValue = params [ i ] - > getValue ( frame ) ;
m_params [ i ] . m_newValue = m_params [ i ] . m_oldValue ;
m_params [ i ] . m_wasKeyframe = m_params [ i ] . m_param - > isKeyframe ( frame ) ;
}
}
void onAdd ( )
{
for ( int i = 0 ; i < ( int ) m_params . size ( ) ; i + + ) {
m_params [ i ] . m_newValue = m_params [ i ] . m_param - > getValue ( m_frame ) ;
}
}
void undo ( ) const
{
for ( int i = 0 ; i < ( int ) m_params . size ( ) ; i + + ) {
if ( ! m_params [ i ] . m_wasKeyframe )
m_params [ i ] . m_param - > deleteKeyframe ( m_frame ) ;
else
m_params [ i ] . m_param - > setValue ( m_frame , m_params [ i ] . m_oldValue ) ;
}
}
void redo ( ) const
{
for ( int i = 0 ; i < ( int ) m_params . size ( ) ; i + + ) {
m_params [ i ] . m_param - > setValue ( m_frame , m_params [ i ] . m_newValue ) ;
}
}
int getSize ( ) const { return sizeof ( * this ) + m_params . size ( ) * sizeof ( ParamData ) ; }
QString getHistoryString ( )
{
QString str = QObject : : tr ( " Modify Fx Gadget " ) ;
for ( int i = 0 ; i < ( int ) m_params . size ( ) ; i + + ) {
str + = QString : : fromStdString ( m_params [ i ] . m_param - > getName ( ) ) ;
if ( i ! = ( int ) m_params . size ( ) - 1 )
str + = QString : : fromStdString ( " , " ) ;
}
str + = QString ( " Frame : %1 " ) . arg ( QString : : number ( m_frame + 1 ) ) ;
return str ;
}
int getHistoryType ( )
{
return HistoryType : : Fx ;
}
} ;
//*************************************************************************************
// GadgetDragTool definition
//*************************************************************************************
class GadgetDragTool : public DragTool
{
FxGadgetController * m_controller ;
FxGadget * m_gadget ;
public :
GadgetDragTool ( FxGadgetController * controller , FxGadget * gadget )
: m_controller ( controller ) , m_gadget ( gadget ) { }
TAffine getMatrix ( ) const { return m_controller - > getMatrix ( ) . inv ( ) ; }
void leftButtonDown ( const TPointD & pos , const TMouseEvent & e )
{
m_gadget - > createUndo ( ) ;
m_gadget - > leftButtonDown ( getMatrix ( ) * pos , e ) ;
}
void leftButtonDrag ( const TPointD & pos , const TMouseEvent & e )
{
m_gadget - > leftButtonDrag ( getMatrix ( ) * pos , e ) ;
}
void leftButtonUp ( const TPointD & pos , const TMouseEvent & e )
{
m_gadget - > leftButtonUp ( getMatrix ( ) * pos , e ) ;
m_gadget - > commitUndo ( ) ;
}
} ;
//*************************************************************************************
// FxGadget implementation
//*************************************************************************************
FxGadget : : FxGadget ( FxGadgetController * controller )
: m_id ( - 1 ) , m_selected ( false ) , m_controller ( controller ) , m_pixelSize ( 1 ) , m_undo ( 0 ) , m_scaleFactor ( 1 )
{
controller - > assignId ( this ) ;
}
//---------------------------------------------------------------------------
FxGadget : : ~ FxGadget ( )
{
for ( int i = 0 ; i < ( int ) m_params . size ( ) ; i + + )
m_params [ i ] - > removeObserver ( this ) ;
}
//---------------------------------------------------------------------------
void FxGadget : : addParam ( const TDoubleParamP & param )
{
m_params . push_back ( param ) ;
param - > addObserver ( this ) ;
}
//---------------------------------------------------------------------------
double FxGadget : : getValue ( const TDoubleParamP & param ) const
{
return param - > getValue ( m_controller - > getCurrentFrame ( ) ) ;
}
//---------------------------------------------------------------------------
void FxGadget : : setValue ( const TDoubleParamP & param , double value )
{
param - > setValue ( m_controller - > getCurrentFrame ( ) , value ) ;
}
//---------------------------------------------------------------------------
TPointD FxGadget : : getValue ( const TPointParamP & param ) const
{
return param - > getValue ( m_controller - > getCurrentFrame ( ) ) ;
}
//---------------------------------------------------------------------------
void FxGadget : : setValue ( const TPointParamP & param , const TPointD & pos )
{
param - > setValue ( m_controller - > getCurrentFrame ( ) , pos ) ;
}
//---------------------------------------------------------------------------
void FxGadget : : setPixelSize ( )
{
setPixelSize ( sqrt ( tglGetPixelSize2 ( ) ) ) ;
}
//---------------------------------------------------------------------------
void FxGadget : : drawTooltip ( const TPointD & tooltipPos , std : : string tooltipPosText )
{
double unit = sqrt ( tglGetPixelSize2 ( ) ) ;
glPushMatrix ( ) ;
glTranslated ( tooltipPos . x , tooltipPos . y , 0.0 ) ;
double sc = unit * 1.6 ;
glScaled ( sc , sc , 1 ) ;
tglDrawText ( TPointD ( 8 , - 3 ) , tooltipPosText ) ;
glPopMatrix ( ) ;
}
//---------------------------------------------------------------------------
void FxGadget : : drawDot ( const TPointD & pos )
{
double r = getPixelSize ( ) * 3 ;
tglDrawRect ( pos . x - r , pos . y - r , pos . x + r , pos . y + r ) ;
}
//---------------------------------------------------------------------------
void FxGadget : : onChange ( const TParamChange & )
{
m_controller - > invalidateViewer ( ) ;
}
//---------------------------------------------------------------------------
void FxGadget : : createUndo ( )
{
assert ( m_undo = = 0 ) ;
m_undo = new FxGadgetUndo ( m_params , m_controller - > getCurrentFrame ( ) ) ;
}
//---------------------------------------------------------------------------
void FxGadget : : commitUndo ( )
{
assert ( m_undo ) ;
TUndoManager : : manager ( ) - > add ( m_undo ) ;
m_undo = 0 ;
}
//*************************************************************************************
// Specific Gadget Concepts definition
//*************************************************************************************
class PointFxGadget : public FxGadget
{
TPointD m_pos ;
TDoubleParamP m_xParam , m_yParam ;
public :
PointFxGadget ( FxGadgetController * controller , const TPointParamP & param )
: FxGadget ( controller ) , m_xParam ( param - > getX ( ) ) , m_yParam ( param - > getY ( ) )
{
addParam ( m_xParam ) ;
addParam ( m_yParam ) ;
}
PointFxGadget ( FxGadgetController * controller , const TDoubleParamP & xParam , const TDoubleParamP & yParam )
: FxGadget ( controller ) , m_xParam ( xParam ) , m_yParam ( yParam )
{
addParam ( m_xParam ) ;
addParam ( m_yParam ) ;
}
void draw ( bool picking ) ;
TPointD getPoint ( ) const { return TPointD ( getValue ( m_xParam ) , getValue ( m_yParam ) ) ; }
void leftButtonDown ( const TPointD & pos , const TMouseEvent & ) ;
void leftButtonDrag ( const TPointD & pos , const TMouseEvent & ) ;
void leftButtonUp ( const TPointD & pos , const TMouseEvent & ) ;
} ;
//---------------------------------------------------------------------------
void PointFxGadget : : draw ( bool picking )
{
setPixelSize ( ) ;
if ( isSelected ( ) )
glColor3dv ( m_selectedColor ) ;
else
glColor3d ( 0 , 0 , 1 ) ;
glPushName ( getId ( ) ) ;
TPointD pos ( getPoint ( ) ) ;
double unit = getPixelSize ( ) ;
glPushMatrix ( ) ;
glTranslated ( pos . x , pos . y , 0 ) ;
double r = unit * 3 ;
double d = unit * 6 ;
glBegin ( GL_LINES ) ;
glVertex2d ( - d , 0 ) ;
glVertex2d ( - r , 0 ) ;
glVertex2d ( d , 0 ) ;
glVertex2d ( r , 0 ) ;
glVertex2d ( 0 , - d ) ;
glVertex2d ( 0 , - r ) ;
glVertex2d ( 0 , d ) ;
glVertex2d ( 0 , r ) ;
glEnd ( ) ;
tglDrawRect ( - r , - r , r , r ) ;
glPopMatrix ( ) ;
glPopName ( ) ;
if ( isSelected ( ) ) {
drawTooltip ( pos + TPointD ( 7 , 3 ) * unit , getLabel ( ) ) ;
}
}
//---------------------------------------------------------------------------
void PointFxGadget : : leftButtonDown ( const TPointD & pos , const TMouseEvent & )
{
}
//---------------------------------------------------------------------------
void PointFxGadget : : leftButtonDrag ( const TPointD & pos , const TMouseEvent & )
{
if ( m_xParam )
setValue ( m_xParam , pos . x ) ;
if ( m_yParam )
setValue ( m_yParam , pos . y ) ;
}
//---------------------------------------------------------------------------
void PointFxGadget : : leftButtonUp ( const TPointD & pos , const TMouseEvent & )
{
}
//=============================================================================
class RadiusFxGadget : public FxGadget
{
TDoubleParamP m_radius ;
TPointParamP m_center ;
public :
RadiusFxGadget (
FxGadgetController * controller ,
const TDoubleParamP & radius ,
const TPointParamP & center )
: FxGadget ( controller ) , m_radius ( radius ) , m_center ( center )
{
addParam ( radius ) ;
}
TPointD getCenter ( ) const ;
void draw ( bool picking ) ;
void leftButtonDown ( const TPointD & pos , const TMouseEvent & ) ;
void leftButtonDrag ( const TPointD & pos , const TMouseEvent & ) ;
void leftButtonUp ( const TPointD & pos , const TMouseEvent & ) ;
} ;
//---------------------------------------------------------------------------
TPointD RadiusFxGadget : : getCenter ( ) const
{
return m_center ? getValue ( m_center ) : TPointD ( ) ;
}
//---------------------------------------------------------------------------
void RadiusFxGadget : : draw ( bool picking )
{
if ( ! m_radius )
return ;
setPixelSize ( ) ;
if ( isSelected ( ) )
glColor3dv ( m_selectedColor ) ;
else
glColor3d ( 0 , 0 , 1 ) ;
glPushName ( getId ( ) ) ;
double radius = getValue ( m_radius ) ;
TPointD center = getCenter ( ) ;
glLineStipple ( 1 , 0xAAAA ) ;
glEnable ( GL_LINE_STIPPLE ) ;
tglDrawCircle ( center , radius ) ;
glDisable ( GL_LINE_STIPPLE ) ;
drawDot ( center + TPointD ( 0.707 , 0.707 ) * radius ) ;
glPopName ( ) ;
if ( isSelected ( ) ) {
drawTooltip ( center + TPointD ( 0.707 , 0.707 ) * radius , getLabel ( ) ) ;
}
}
//---------------------------------------------------------------------------
void RadiusFxGadget : : leftButtonDown ( const TPointD & pos , const TMouseEvent & )
{
}
//---------------------------------------------------------------------------
void RadiusFxGadget : : leftButtonDrag ( const TPointD & pos , const TMouseEvent & )
{
setValue ( m_radius , norm ( pos - getCenter ( ) ) ) ;
}
//---------------------------------------------------------------------------
void RadiusFxGadget : : leftButtonUp ( const TPointD & pos , const TMouseEvent & )
{
}
//=============================================================================
class DistanceFxGadget : public FxGadget
{
TDoubleParamP m_distance , m_angle ;
int m_grabPos ;
public :
DistanceFxGadget (
FxGadgetController * controller ,
const TDoubleParamP & distance ,
const TDoubleParamP & angle )
: FxGadget ( controller ) , m_distance ( distance ) , m_angle ( angle ) , m_grabPos ( 1 )
{
addParam ( distance ) ;
if ( angle )
addParam ( angle ) ;
}
TPointD getDirection ( ) const
{
if ( ! m_angle )
return TPointD ( 1.0 , 0.0 ) ;
double angle = getValue ( m_angle ) ;
return TPointD ( cos ( angle ) , sin ( angle ) ) ;
}
void draw ( bool picking ) ;
void leftButtonDown ( const TPointD & pos , const TMouseEvent & ) ;
void leftButtonDrag ( const TPointD & pos , const TMouseEvent & ) ;
void leftButtonUp ( const TPointD & pos , const TMouseEvent & ) ;
} ;
//---------------------------------------------------------------------------
void DistanceFxGadget : : draw ( bool picking )
{
if ( ! m_distance )
return ;
setPixelSize ( ) ;
glColor3d ( 0 , 0 , 1 ) ;
double d = getValue ( m_distance ) * getScaleFactor ( ) ;
TPointD dir ( getDirection ( ) ) ;
TPointD u = rotate90 ( dir ) * ( getPixelSize ( ) * 10 ) ;
tglDrawSegment ( - u , u ) ;
glPushName ( getId ( ) ) ;
TPointD b , c ;
b = dir * ( d * 0.5 ) ;
c = b - dir * d ;
tglDrawSegment ( b - u , b + u ) ;
tglDrawCircle ( b , getPixelSize ( ) * 5 ) ;
tglDrawSegment ( c - u , c + u ) ;
tglDrawCircle ( c , getPixelSize ( ) * 5 ) ;
glPopName ( ) ;
glLineStipple ( 1 , 0xAAAA ) ;
glEnable ( GL_LINE_STIPPLE ) ;
tglDrawSegment ( b , c ) ;
glDisable ( GL_LINE_STIPPLE ) ;
if ( isSelected ( ) ) {
drawTooltip ( b + TPointD ( 5 , 5 ) * getPixelSize ( ) , getLabel ( ) ) ;
}
}
//---------------------------------------------------------------------------
void DistanceFxGadget : : leftButtonDown ( const TPointD & pos , const TMouseEvent & )
{
m_grabPos = ( pos . x > 0.0 ) ? 1 : - 1 ;
}
//---------------------------------------------------------------------------
void DistanceFxGadget : : leftButtonDrag ( const TPointD & pos , const TMouseEvent & )
{
double v = ( pos * getDirection ( ) ) / getScaleFactor ( ) ;
v = v * 2 * m_grabPos ;
setValue ( m_distance , v ) ;
}
//---------------------------------------------------------------------------
void DistanceFxGadget : : leftButtonUp ( const TPointD & pos , const TMouseEvent & )
{
}
//=============================================================================
class AngleFxGadget : public FxGadget
{
TDoubleParamP m_param ;
TPointD m_pos ;
public :
AngleFxGadget ( FxGadgetController * controller , const TDoubleParamP & param , const TPointD & pos ) ;
void draw ( bool picking ) ;
void leftButtonDown ( const TPointD & pos , const TMouseEvent & ) ;
void leftButtonDrag ( const TPointD & pos , const TMouseEvent & ) ;
void leftButtonUp ( const TPointD & pos , const TMouseEvent & ) ;
} ;
//---------------------------------------------------------------------------
AngleFxGadget : : AngleFxGadget ( FxGadgetController * controller , const TDoubleParamP & param , const TPointD & pos )
: FxGadget ( controller ) , m_param ( param ) , m_pos ( pos )
{
addParam ( param ) ;
}
//---------------------------------------------------------------------------
void AngleFxGadget : : draw ( bool picking )
{
if ( isSelected ( ) )
glColor3dv ( m_selectedColor ) ;
else
glColor3d ( 0 , 0 , 1 ) ;
glPushName ( getId ( ) ) ;
double pixelSize = sqrt ( tglGetPixelSize2 ( ) ) ;
double r = pixelSize * 40 ;
double a = pixelSize * 10 , b = pixelSize * 5 ;
tglDrawCircle ( m_pos , r ) ;
double phi = getValue ( m_param ) ;
glPushMatrix ( ) ;
glTranslated ( m_pos . x , m_pos . y , 0 ) ;
glRotated ( phi , 0 , 0 , 1 ) ;
glBegin ( GL_LINES ) ;
glVertex2d ( 0 , 0 ) ;
glVertex2d ( r , 0 ) ;
glVertex2d ( r , 0 ) ;
glVertex2d ( r - a , b ) ;
glVertex2d ( r , 0 ) ;
glVertex2d ( r - a , - b ) ;
glEnd ( ) ;
glPopMatrix ( ) ;
glPopName ( ) ;
if ( isSelected ( ) ) {
drawTooltip ( m_pos + TPointD ( 0.707 , 0.707 ) * r , getLabel ( ) ) ;
}
}
//---------------------------------------------------------------------------
void AngleFxGadget : : leftButtonDown ( const TPointD & pos , const TMouseEvent & )
{
}
//---------------------------------------------------------------------------
void AngleFxGadget : : leftButtonDrag ( const TPointD & pos , const TMouseEvent & )
{
TPointD d = pos - m_pos ;
double phi = atan2 ( d . y , d . x ) ;
setValue ( m_param , TConsts : : invOf_pi_180 * phi ) ;
}
//---------------------------------------------------------------------------
void AngleFxGadget : : leftButtonUp ( const TPointD & pos , const TMouseEvent & )
{
}
//=============================================================================
class DiamondFxGadget : public FxGadget
{
TDoubleParamP m_param ;
public :
DiamondFxGadget ( FxGadgetController * controller , const TDoubleParamP & param )
: FxGadget ( controller ) , m_param ( param )
{
addParam ( param ) ;
}
void draw ( bool picking ) ;
void leftButtonDown ( const TPointD & pos , const TMouseEvent & ) { }
void leftButtonDrag ( const TPointD & pos , const TMouseEvent & ) ;
void leftButtonUp ( const TPointD & pos , const TMouseEvent & ) { }
} ;
//---------------------------------------------------------------------------
void DiamondFxGadget : : draw ( bool picking )
{
setPixelSize ( ) ;
if ( isSelected ( ) )
glColor3dv ( m_selectedColor ) ;
else
glColor3d ( 0 , 0 , 1 ) ;
glPushName ( getId ( ) ) ;
double size = getValue ( m_param ) ;
double r = 3 * getPixelSize ( ) ;
glLineStipple ( 1 , 0xAAAA ) ;
glEnable ( GL_LINE_STIPPLE ) ;
glBegin ( GL_LINES ) ;
glVertex2d ( - size + r , r ) ;
glVertex2d ( - r , size - r ) ;
glVertex2d ( r , size - r ) ;
glVertex2d ( size - r , r ) ;
glVertex2d ( size - r , - r ) ;
glVertex2d ( r , - size + r ) ;
glVertex2d ( - r , - size + r ) ;
glVertex2d ( - size + r , - r ) ;
glEnd ( ) ;
glDisable ( GL_LINE_STIPPLE ) ;
drawDot ( - size , 0 ) ;
drawDot ( size , 0 ) ;
drawDot ( 0 , - size ) ;
drawDot ( 0 , size ) ;
double d = getPixelSize ( ) * 3 ;
glPopName ( ) ;
if ( isSelected ( ) ) {
drawTooltip ( TPointD ( d , size - d ) , getLabel ( ) ) ;
}
}
//---------------------------------------------------------------------------
void DiamondFxGadget : : leftButtonDrag ( const TPointD & pos , const TMouseEvent & )
{
double sz = fabs ( pos . x ) + fabs ( pos . y ) ;
if ( sz < 0.1 )
sz = 0.1 ;
setValue ( m_param , sz ) ;
}
//=============================================================================
class SizeFxGadget : public FxGadget
{
TDoubleParamP m_lx , m_ly ;
public :
SizeFxGadget ( FxGadgetController * controller , const TDoubleParamP & lx , const TDoubleParamP & ly )
: FxGadget ( controller ) , m_lx ( lx ) , m_ly ( ly )
{
addParam ( lx ) ;
if ( ly )
addParam ( ly ) ;
}
void draw ( bool picking ) ;
void leftButtonDown ( const TPointD & pos , const TMouseEvent & ) { }
void leftButtonDrag ( const TPointD & pos , const TMouseEvent & ) ;
void leftButtonUp ( const TPointD & pos , const TMouseEvent & ) { }
} ;
//---------------------------------------------------------------------------
void SizeFxGadget : : draw ( bool picking )
{
setPixelSize ( ) ;
if ( isSelected ( ) )
glColor3dv ( m_selectedColor ) ;
else
glColor3d ( 0 , 0 , 1 ) ;
glPushName ( getId ( ) ) ;
double lx = getValue ( m_lx ) , ly = m_ly ? getValue ( m_ly ) : lx ;
double r = getPixelSize ( ) * 3 ;
glLineStipple ( 1 , 0xCCCC ) ;
glEnable ( GL_LINE_STIPPLE ) ;
glBegin ( GL_LINES ) ;
glVertex2d ( 0 , 0 ) ;
glVertex2d ( lx , 0 ) ;
glVertex2d ( 0 , 0 ) ;
glVertex2d ( 0 , ly ) ;
glVertex2d ( lx , 0 ) ;
glVertex2d ( lx , ly - r ) ;
glVertex2d ( 0 , ly ) ;
glVertex2d ( lx - r , ly ) ;
glEnd ( ) ;
glDisable ( GL_LINE_STIPPLE ) ;
drawDot ( lx , ly ) ;
double d = getPixelSize ( ) * 3 ;
glPopName ( ) ;
if ( isSelected ( ) ) {
drawTooltip ( TPointD ( lx , ly ) , getLabel ( ) ) ;
}
}
//---------------------------------------------------------------------------
void SizeFxGadget : : leftButtonDrag ( const TPointD & pos , const TMouseEvent & )
{
if ( m_ly )
setValue ( m_lx , tmax ( pos . x , 0.1 ) ) , setValue ( m_ly , tmax ( pos . y , 0.1 ) ) ;
else
setValue ( m_lx , tmax ( pos . x , pos . y , 0.1 ) ) ;
}
//=============================================================================
class RectFxGadget : public FxGadget
{
TDoubleParamP m_width , m_height ;
TPointParamP m_center ;
int m_picked ;
public :
enum { None ,
Corner ,
HorizontalSide ,
VerticalSide } ;
public :
RectFxGadget ( FxGadgetController * controller ,
const TDoubleParamP & width ,
const TDoubleParamP & height ,
const TPointParamP & center )
: FxGadget ( controller ) , m_width ( width ) , m_height ( height ) , m_center ( center ) , m_picked ( None )
{
addParam ( width ) ;
addParam ( height ) ;
if ( center )
addParam ( center - > getX ( ) ) , addParam ( center - > getY ( ) ) ;
}
TPointD getCenter ( ) const { return m_center ? getValue ( m_center ) : TPointD ( ) ; }
void draw ( bool picking ) ;
void leftButtonDown ( const TPointD & pos , const TMouseEvent & ) ;
void leftButtonDrag ( const TPointD & pos , const TMouseEvent & ) ;
void leftButtonUp ( const TPointD & pos , const TMouseEvent & ) { }
} ;
//---------------------------------------------------------------------------
void RectFxGadget : : draw ( bool picking )
{
setPixelSize ( ) ;
if ( isSelected ( ) )
glColor3dv ( m_selectedColor ) ;
else
glColor3d ( 0 , 0 , 1 ) ;
glPushName ( getId ( ) ) ;
glPushMatrix ( ) ;
TPointD center = getCenter ( ) ;
glTranslated ( center . x , center . y , 0 ) ;
double w_2 = 0.5 * getValue ( m_width ) ;
double h_2 = 0.5 * getValue ( m_height ) ;
double r = getPixelSize ( ) * 3 ;
glLineStipple ( 1 , 0xCCCC ) ;
glEnable ( GL_LINE_STIPPLE ) ;
glBegin ( GL_LINES ) ;
glVertex2d ( - w_2 + r , - h_2 ) ;
glVertex2d ( w_2 - r , - h_2 ) ;
glVertex2d ( - w_2 + r , h_2 ) ;
glVertex2d ( w_2 - r , h_2 ) ;
glVertex2d ( - w_2 , - h_2 + r ) ;
glVertex2d ( - w_2 , h_2 - r ) ;
glVertex2d ( w_2 , - h_2 + r ) ;
glVertex2d ( w_2 , h_2 - r ) ;
glEnd ( ) ;
glDisable ( GL_LINE_STIPPLE ) ;
drawDot ( w_2 , h_2 ) ;
drawDot ( - w_2 , h_2 ) ;
drawDot ( w_2 , - h_2 ) ;
drawDot ( - w_2 , - h_2 ) ;
glPopMatrix ( ) ;
}
//---------------------------------------------------------------------------
void RectFxGadget : : leftButtonDown ( const TPointD & ppos , const TMouseEvent & )
{
TPointD pos = ppos - getCenter ( ) ;
m_picked = None ;
double w_2 = 0.5 * getValue ( m_width ) ;
double h_2 = 0.5 * getValue ( m_height ) ;
double x = fabs ( pos . x ) ;
double y = fabs ( pos . y ) ;
double r = getPixelSize ( ) * 15 ;
if ( fabs ( w_2 - x ) < r & & fabs ( y - h_2 ) < r )
m_picked = Corner ;
else if ( fabs ( w_2 - x ) < r & & y < h_2 )
m_picked = VerticalSide ;
else if ( fabs ( h_2 - y ) < r & & x < w_2 )
m_picked = HorizontalSide ;
}
//---------------------------------------------------------------------------
void RectFxGadget : : leftButtonDrag ( const TPointD & ppos , const TMouseEvent & )
{
TPointD pos = ppos - getCenter ( ) ;
double w = fabs ( pos . x ) , h = fabs ( pos . y ) ;
if ( m_picked = = Corner | | m_picked = = VerticalSide )
setValue ( m_width , 2.0 * w ) ;
if ( m_picked = = Corner | | m_picked = = HorizontalSide )
setValue ( m_height , 2.0 * h ) ;
}
//=============================================================================
class PolarFxGadget : public FxGadget
{
TPointD m_pos ;
TDoubleParamP m_phiParam , m_lengthParam ;
public :
PolarFxGadget (
FxGadgetController * controller ,
const TPointD & pos ,
const TDoubleParamP & phiParam ,
const TDoubleParamP & lengthParam )
: FxGadget ( controller ) , m_pos ( pos ) , m_phiParam ( phiParam ) , m_lengthParam ( lengthParam )
{
addParam ( phiParam ) ;
addParam ( lengthParam ) ;
}
void draw ( bool picking )
{
setPixelSize ( ) ;
if ( isSelected ( ) )
glColor3dv ( m_selectedColor ) ;
else
glColor3d ( 0 , 0 , 1 ) ;
glPushName ( getId ( ) ) ;
double pixelSize = getPixelSize ( ) ;
double r = getValue ( m_lengthParam ) ;
double a = pixelSize * 10 , b = pixelSize * 5 , c = pixelSize * 4 ;
// tglDrawCircle(m_pos, r);
double phi = getValue ( m_phiParam ) ;
glPushMatrix ( ) ;
glTranslated ( m_pos . x , m_pos . y , 0 ) ;
glRotated ( phi , 0 , 0 , 1 ) ;
double rr = r - c ;
if ( rr > 0 ) {
glLineStipple ( 1 , 0xAAAA ) ;
glEnable ( GL_LINE_STIPPLE ) ;
glBegin ( GL_LINE_STRIP ) ;
glVertex2d ( 0 , 0 ) ;
glVertex2d ( rr , 0 ) ;
glEnd ( ) ;
glDisable ( GL_LINE_STIPPLE ) ;
}
glBegin ( GL_LINES ) ;
glVertex2d ( rr , 0 ) ;
glVertex2d ( rr - a , b ) ;
glVertex2d ( rr , 0 ) ;
glVertex2d ( rr - a , - b ) ;
glEnd ( ) ;
glTranslated ( r , 0 , 0 ) ;
glRotated ( - phi , 0 , 0 , 1 ) ;
drawDot ( 0 , 0 ) ;
glPopMatrix ( ) ;
glPopName ( ) ;
if ( isSelected ( ) ) {
double phiRad = TConsts : : pi_180 * phi ;
TPointD toolTipPos = m_pos + r * TPointD ( cos ( phiRad ) , sin ( phiRad ) ) ;
drawTooltip ( toolTipPos , getLabel ( ) ) ;
}
}
void leftButtonDown ( const TPointD & pos , const TMouseEvent & ) { }
void leftButtonDrag ( const TPointD & pos , const TMouseEvent & )
{
TPointD d = pos - m_pos ;
double phi = atan2 ( d . y , d . x ) ;
double length = norm ( d ) ;
setValue ( m_phiParam , TConsts : : invOf_pi_180 * phi ) ;
setValue ( m_lengthParam , length ) ;
}
void leftButtonUp ( const TPointD & pos , const TMouseEvent & ) { }
} ;
//=============================================================================
class VectorFxGadget : public FxGadget
{
TPointParamP m_pa , m_pb ;
int m_selected ;
public :
VectorFxGadget (
FxGadgetController * controller ,
const TPointParamP & pa ,
const TPointParamP & pb )
: FxGadget ( controller ) , m_pa ( pa ) , m_pb ( pb ) , m_selected ( 0 )
{
addParam ( pa - > getX ( ) ) ;
addParam ( pa - > getY ( ) ) ;
addParam ( pb - > getX ( ) ) ;
addParam ( pb - > getY ( ) ) ;
}
void draw ( bool picking )
{
setPixelSize ( ) ;
if ( isSelected ( ) )
glColor3dv ( m_selectedColor ) ;
else
glColor3d ( 0 , 0 , 1 ) ;
glPushName ( getId ( ) ) ;
double pixelSize = getPixelSize ( ) ;
TPointD pa = getValue ( m_pa ) ;
TPointD pb = getValue ( m_pb ) ;
TPointD dab = pb - pa ;
double ab2 = norm2 ( dab ) ;
if ( ab2 > 0.0001 ) {
double ab = sqrt ( ab2 ) ;
TPointD u = dab * ( 1.0 / ab ) ;
TPointD v = rotate90 ( u ) ;
double a = pixelSize * 10 , b = pixelSize * 5 ;
double c = pixelSize * 4 ;
TPointD pbb = pb - u * c ;
if ( ab - c > 0 ) {
glLineStipple ( 1 , 0xAAAA ) ;
glEnable ( GL_LINE_STIPPLE ) ;
tglDrawSegment ( pa , pbb ) ;
glDisable ( GL_LINE_STIPPLE ) ;
}
tglDrawSegment ( pbb , pbb - u * a + v * b ) ;
tglDrawSegment ( pbb , pbb - u * a - v * b ) ;
drawDot ( pa ) ;
drawDot ( pb ) ;
} else
drawDot ( pa ) ;
glPopName ( ) ;
}
void leftButtonDown ( const TPointD & pos , const TMouseEvent & ) { }
void leftButtonDrag ( const TPointD & pos , const TMouseEvent & ) { }
void leftButtonUp ( const TPointD & pos , const TMouseEvent & ) { }
} ;
//=============================================================================
class QuadFxGadget : public FxGadget
{
TPointParamP m_pa , m_pb , m_pc , m_pd ;
public :
QuadFxGadget (
FxGadgetController * controller ,
const TPointParamP & pa ,
const TPointParamP & pb ,
const TPointParamP & pc ,
const TPointParamP & pd )
: FxGadget ( controller ) , m_pa ( pa ) , m_pb ( pb ) , m_pc ( pc ) , m_pd ( pd )
{
addParam ( pa - > getX ( ) ) ;
addParam ( pa - > getY ( ) ) ;
addParam ( pb - > getX ( ) ) ;
addParam ( pb - > getY ( ) ) ;
addParam ( pc - > getX ( ) ) ;
addParam ( pc - > getY ( ) ) ;
addParam ( pd - > getX ( ) ) ;
addParam ( pd - > getY ( ) ) ;
}
void draw ( bool picking )
{
setPixelSize ( ) ;
if ( isSelected ( ) )
glColor3dv ( m_selectedColor ) ;
else
glColor3d ( 0 , 0 , 1 ) ;
//glPushName(getId());
double pixelSize = getPixelSize ( ) ;
TPointD pa = getValue ( m_pa ) ;
TPointD pb = getValue ( m_pb ) ;
TPointD pc = getValue ( m_pc ) ;
TPointD pd = getValue ( m_pd ) ;
glLineStipple ( 1 , 0xCCCC ) ;
glEnable ( GL_LINE_STIPPLE ) ;
glBegin ( GL_LINE_STRIP ) ;
tglVertex ( pa ) ;
tglVertex ( pb ) ;
tglVertex ( pc ) ;
tglVertex ( pd ) ;
tglVertex ( pa ) ;
glEnd ( ) ;
glDisable ( GL_LINE_STIPPLE ) ;
//glPopName();
}
void leftButtonDown ( const TPointD & pos , const TMouseEvent & ) { }
void leftButtonDrag ( const TPointD & pos , const TMouseEvent & ) { }
void leftButtonUp ( const TPointD & pos , const TMouseEvent & ) { }
} ;
//*************************************************************************************
// FxGadgetController implementation
//*************************************************************************************
FxGadgetController : : FxGadgetController ( TTool * tool )
: m_tool ( tool ) , m_fxHandle ( tool - > getApplication ( ) - > getCurrentFx ( ) ) , m_idBase ( 0 ) , m_nextId ( 0 ) , m_selectedGadget ( 0 ) , m_editingNonZeraryFx ( false )
{
m_idBase = m_nextId = 5000 ;
connect ( m_fxHandle , SIGNAL ( fxSwitched ( ) ) , this , SLOT ( onFxSwitched ( ) ) ) ;
connect (
tool - > getApplication ( ) - > getCurrentXsheet ( ) , SIGNAL ( xsheetChanged ( ) ) ,
this , SLOT ( onFxSwitched ( ) ) ) ;
onFxSwitched ( ) ;
}
//---------------------------------------------------------------------------
FxGadgetController : : ~ FxGadgetController ( )
{
clearGadgets ( ) ;
}
//---------------------------------------------------------------------------
void FxGadgetController : : clearGadgets ( )
{
std : : vector < FxGadget * > : : iterator it ;
for ( it = m_gadgets . begin ( ) ; it ! = m_gadgets . end ( ) ; + + it )
delete ( * it ) ;
m_gadgets . clear ( ) ;
m_idTable . clear ( ) ;
m_selectedGadget = 0 ;
m_nextId = m_idBase ;
}
//---------------------------------------------------------------------------
void FxGadgetController : : assignId ( FxGadget * gadget )
{
gadget - > setId ( m_nextId ) ;
m_idTable [ m_nextId ] = gadget ;
+ + m_nextId ;
}
//---------------------------------------------------------------------------
void FxGadgetController : : addGadget ( FxGadget * gadget )
{
m_gadgets . push_back ( gadget ) ;
}
//---------------------------------------------------------------------------
void FxGadgetController : : draw ( bool picking )
{
glPushMatrix ( ) ;
tglMultMatrix ( getMatrix ( ) ) ;
std : : vector < FxGadget * > : : iterator it ;
for ( it = m_gadgets . begin ( ) ; it ! = m_gadgets . end ( ) ; + + it )
( * it ) - > draw ( picking ) ;
glPopMatrix ( ) ;
}
//---------------------------------------------------------------------------
void FxGadgetController : : selectById ( unsigned int id )
{
std : : map < GLuint , FxGadget * > : : iterator it ;
it = m_idTable . find ( id ) ;
FxGadget * selectedGadget = it ! = m_idTable . end ( ) ? it - > second : 0 ;
if ( selectedGadget ! = m_selectedGadget ) {
if ( m_selectedGadget )
m_selectedGadget - > select ( false ) ;
m_selectedGadget = selectedGadget ;
if ( m_selectedGadget )
m_selectedGadget - > select ( true ) ;
}
}
//---------------------------------------------------------------------------
FxGadget * FxGadgetController : : allocateGadget ( const TParamUIConcept & uiConcept )
{
FxGadget * gadget = 0 ;
switch ( uiConcept . m_type ) {
case TParamUIConcept : : RADIUS : {
assert ( uiConcept . m_params . size ( ) > = 1 & & uiConcept . m_params . size ( ) < = 2 ) ;
TPointParamP center ( ( uiConcept . m_params . size ( ) > = 2 ) ? ( TPointParamP ) uiConcept . m_params [ 1 ] : TPointParamP ( ) ) ;
gadget = new RadiusFxGadget ( this , uiConcept . m_params [ 0 ] , center ) ;
2016-05-13 22:49:17 +12:00
break ;
2016-03-19 06:57:51 +13:00
}
2016-05-13 22:49:17 +12:00
case TParamUIConcept : : WIDTH :
2016-03-19 06:57:51 +13:00
{
assert ( uiConcept . m_params . size ( ) > = 1 & & uiConcept . m_params . size ( ) < = 2 ) ;
TDoubleParamP angle ( ( uiConcept . m_params . size ( ) > = 2 ) ? ( TDoubleParamP ) uiConcept . m_params [ 1 ] : TDoubleParamP ( ) ) ;
gadget = new DistanceFxGadget ( this , uiConcept . m_params [ 0 ] , angle ) ;
2016-05-13 22:49:17 +12:00
break ;
2016-03-19 06:57:51 +13:00
}
2016-05-13 22:49:17 +12:00
case TParamUIConcept : : ANGLE :
2016-03-19 06:57:51 +13:00
{
assert ( uiConcept . m_params . size ( ) = = 1 ) ;
gadget = new AngleFxGadget ( this , uiConcept . m_params [ 0 ] , TPointD ( ) ) ;
2016-05-13 22:49:17 +12:00
break ;
2016-03-19 06:57:51 +13:00
}
2016-05-13 22:49:17 +12:00
case TParamUIConcept : : POINT :
2016-03-19 06:57:51 +13:00
{
assert ( uiConcept . m_params . size ( ) = = 1 ) ;
gadget = new PointFxGadget ( this , uiConcept . m_params [ 0 ] ) ;
2016-05-13 22:49:17 +12:00
break ;
2016-03-19 06:57:51 +13:00
}
2016-05-13 22:49:17 +12:00
case TParamUIConcept : : POINT_2 :
2016-03-19 06:57:51 +13:00
{
assert ( uiConcept . m_params . size ( ) = = 2 ) ;
gadget = new PointFxGadget ( this , uiConcept . m_params [ 0 ] , uiConcept . m_params [ 1 ] ) ;
2016-05-13 22:49:17 +12:00
break ;
2016-03-19 06:57:51 +13:00
}
2016-05-13 22:49:17 +12:00
case TParamUIConcept : : VECTOR :
2016-03-19 06:57:51 +13:00
{
assert ( uiConcept . m_params . size ( ) = = 2 ) ;
gadget = new VectorFxGadget ( this , uiConcept . m_params [ 0 ] , uiConcept . m_params [ 1 ] ) ;
2016-05-13 22:49:17 +12:00
break ;
2016-03-19 06:57:51 +13:00
}
2016-05-13 22:49:17 +12:00
case TParamUIConcept : : POLAR :
2016-03-19 06:57:51 +13:00
{
assert ( uiConcept . m_params . size ( ) = = 2 ) ;
gadget = new PolarFxGadget ( this , TPointD ( ) , uiConcept . m_params [ 0 ] , uiConcept . m_params [ 1 ] ) ;
2016-05-13 22:49:17 +12:00
break ;
2016-03-19 06:57:51 +13:00
}
2016-05-13 22:49:17 +12:00
case TParamUIConcept : : SIZE :
2016-03-19 06:57:51 +13:00
{
assert ( uiConcept . m_params . size ( ) > = 1 & & uiConcept . m_params . size ( ) < = 2 ) ;
TDoubleParamP y ( ( uiConcept . m_params . size ( ) > = 2 ) ? ( TDoubleParamP ) uiConcept . m_params [ 1 ] : TDoubleParamP ( ) ) ;
gadget = new SizeFxGadget ( this , uiConcept . m_params [ 0 ] , y ) ;
2016-05-13 22:49:17 +12:00
break ;
2016-03-19 06:57:51 +13:00
}
2016-05-13 22:49:17 +12:00
case TParamUIConcept : : QUAD :
2016-03-19 06:57:51 +13:00
{
assert ( uiConcept . m_params . size ( ) = = 4 ) ;
gadget = new QuadFxGadget ( this ,
uiConcept . m_params [ 0 ] , uiConcept . m_params [ 1 ] , uiConcept . m_params [ 2 ] , uiConcept . m_params [ 3 ] ) ;
2016-05-13 22:49:17 +12:00
break ;
2016-03-19 06:57:51 +13:00
}
2016-05-13 22:49:17 +12:00
case TParamUIConcept : : RECT :
2016-03-19 06:57:51 +13:00
{
assert ( uiConcept . m_params . size ( ) > = 2 & & uiConcept . m_params . size ( ) < = 3 ) ;
TPointParamP center ( ( uiConcept . m_params . size ( ) > = 3 ) ? ( TPointParamP ) uiConcept . m_params [ 2 ] : TPointParamP ( ) ) ;
gadget = new RectFxGadget ( this , uiConcept . m_params [ 0 ] , uiConcept . m_params [ 1 ] , center ) ;
2016-05-13 22:49:17 +12:00
break ;
2016-03-19 06:57:51 +13:00
}
2016-05-13 22:49:17 +12:00
case TParamUIConcept : : DIAMOND :
2016-03-19 06:57:51 +13:00
{
assert ( uiConcept . m_params . size ( ) = = 1 ) ;
gadget = new DiamondFxGadget ( this , uiConcept . m_params [ 0 ] ) ;
2016-05-13 22:49:17 +12:00
break ;
2016-03-19 06:57:51 +13:00
}
2016-05-13 22:49:17 +12:00
}
2016-03-19 06:57:51 +13:00
if ( gadget )
gadget - > setLabel ( uiConcept . m_label ) ;
return gadget ;
}
//---------------------------------------------------------------------------
void FxGadgetController : : onFxSwitched ( )
{
clearGadgets ( ) ;
bool enabled = false ;
TFx * fx = m_fxHandle ? m_fxHandle - > getFx ( ) : 0 ;
if ( fx ) {
int referenceColumnIndex = fx - > getReferenceColumnIndex ( ) ;
if ( referenceColumnIndex = = - 1 ) {
TObjectHandle * oh = m_tool - > getApplication ( ) - > getCurrentObject ( ) ;
if ( ! oh - > getObjectId ( ) . isCamera ( ) ) {
oh - > setObjectId ( TStageObjectId : : CameraId ( 0 ) ) ;
}
enabled = true ;
} else if ( referenceColumnIndex = = m_tool - > getColumnIndex ( ) )
enabled = true ;
}
if ( fx & & enabled ) {
m_editingNonZeraryFx = true ;
TZeraryColumnFx * zfx = 0 ;
if ( ( zfx = dynamic_cast < TZeraryColumnFx * > ( fx ) ) | | dynamic_cast < TLevelColumnFx * > ( fx ) )
//WARNING! quick patch for huge bug: I added the || with TLevelColumnFx; before, the levels were considered as nonZeraryFx and the edit tool gadget was not displayed! Vinz
{
if ( zfx )
fx = zfx - > getZeraryFx ( ) ;
m_editingNonZeraryFx = false ;
}
// Parse the UI Concepts returned by the fx
TParamUIConcept * uiConcepts = 0 ;
int i , count ;
fx - > getParamUIs ( uiConcepts , count ) ;
for ( i = 0 ; i < count ; + + i ) {
FxGadget * gadget = allocateGadget ( uiConcepts [ i ] ) ;
if ( gadget )
addGadget ( gadget ) ;
}
delete [ ] uiConcepts ;
} else
m_editingNonZeraryFx = false ;
m_tool - > invalidate ( ) ;
}
//---------------------------------------------------------------------------
EditToolGadgets : : DragTool * FxGadgetController : : createDragTool ( int gadgetId )
{
selectById ( gadgetId ) ;
if ( m_selectedGadget )
return new GadgetDragTool ( this , m_selectedGadget ) ;
else
return 0 ;
}
//---------------------------------------------------------------------------
TAffine FxGadgetController : : getMatrix ( )
{
return m_tool - > getMatrix ( ) . inv ( ) * m_tool - > getCurrentColumnMatrix ( ) ;
}
//---------------------------------------------------------------------------
int FxGadgetController : : getCurrentFrame ( ) const
{
return m_tool - > getFrame ( ) ;
}
//---------------------------------------------------------------------------
void FxGadgetController : : invalidateViewer ( )
{
m_tool - > invalidate ( ) ;
}