void timeLine::paintEvent( QPaintEvent * )
{
QPainter p( this );
QColor bg_color = QApplication::palette().color( QPalette::Active,
QPalette::Background );
QLinearGradient g( 0, 0, 0, height() );
g.setColorAt( 0, bg_color.lighter( 150 ) );
g.setColorAt( 1, bg_color.darker( 150 ) );
p.fillRect( 0, 0, width(), height(), g );
p.setClipRect( m_xOffset, 0, width() - m_xOffset, height() );
p.setPen( QColor( 0, 0, 0 ) );
p.setOpacity( loopPointsEnabled() ? 0.9 : 0.2 );
p.drawPixmap( markerX( loopBegin() )+2, 2, *s_loopPointPixmap );
p.drawPixmap( markerX( loopEnd() )+2, 2, *s_loopPointPixmap );
p.setOpacity( 1.0 );
tact_t tact_num = m_begin.getTact();
int x = m_xOffset + s_posMarkerPixmap->width() / 2 -
( ( static_cast<Sint32>( m_begin * m_ppt ) /
midiTime::ticksPerTact() ) %
static_cast<int>( m_ppt ) );
QColor adas = engine::getLmmsStyle()->color(
LmmsStyle::TimelineForecolor );
p.setPen( adas );
for( int i = 0; x + i * m_ppt < width(); ++i )
{
const int cx = x + qRound( i * m_ppt );
p.drawLine( cx, 5, cx, height() - 6 );
++tact_num;
if( ( tact_num - 1 ) %
qMax( 1, qRound( 1.0f / 3.0f *
midiTime::ticksPerTact() / m_ppt ) ) == 0 )
{
const QString s = QString::number( tact_num );
p.drawText( cx + qRound( ( m_ppt - p.fontMetrics().
width( s ) ) / 2 ),
height() - p.fontMetrics().height() / 2, s );
}
}
p.setOpacity( 0.6 );
p.drawPixmap( m_posMarkerX, height() - s_posMarkerPixmap->height(),
*s_posMarkerPixmap );
}
void TimeLineWidget::paintEvent( QPaintEvent * )
{
QPainter p( this );
// Draw background
p.fillRect( 0, 0, width(), height(), p.background() );
// Clip so that we only draw everything starting from the offset
p.setClipRect( m_xOffset, 0, width() - m_xOffset, height() );
// Draw the loop rectangle
int const & loopRectMargin = getLoopRectangleVerticalPadding();
int const loopRectHeight = this->height() - 2 * loopRectMargin;
int const loopStart = markerX( loopBegin() ) + 8;
int const loopEndR = markerX( loopEnd() ) + 9;
int const loopRectWidth = loopEndR - loopStart;
bool const loopPointsActive = loopPointsEnabled();
// Draw the main rectangle (inner fill only)
QRect outerRectangle( loopStart, loopRectMargin, loopRectWidth - 1, loopRectHeight - 1 );
p.fillRect( outerRectangle, loopPointsActive ? getActiveLoopBrush() : getInactiveLoopBrush());
// Draw the bar lines and numbers
// Activate hinting on the font
QFont font = p.font();
font.setHintingPreference( QFont::PreferFullHinting );
p.setFont(font);
int const fontAscent = p.fontMetrics().ascent();
int const fontHeight = p.fontMetrics().height();
QColor const & barLineColor = getBarLineColor();
QColor const & barNumberColor = getBarNumberColor();
tact_t barNumber = m_begin.getTact();
int const x = m_xOffset + s_posMarkerPixmap->width() / 2 -
( ( static_cast<int>( m_begin * m_ppt ) / MidiTime::ticksPerTact() ) % static_cast<int>( m_ppt ) );
for( int i = 0; x + i * m_ppt < width(); ++i )
{
++barNumber;
if( ( barNumber - 1 ) %
qMax( 1, qRound( 1.0f / 3.0f *
MidiTime::ticksPerTact() / m_ppt ) ) == 0 )
{
const int cx = x + qRound( i * m_ppt );
p.setPen( barLineColor );
p.drawLine( cx, 5, cx, height() - 6 );
const QString s = QString::number( barNumber );
p.setPen( barNumberColor );
p.drawText( cx + 5, ((height() - fontHeight) / 2) + fontAscent, s );
}
}
// Draw the main rectangle (outer border)
p.setPen( loopPointsActive ? getActiveLoopColor() : getInactiveLoopColor() );
p.setBrush( Qt::NoBrush );
p.drawRect( outerRectangle );
// Draw the inner border outline (no fill)
QRect innerRectangle = outerRectangle.adjusted( 1, 1, -1, -1 );
p.setPen( loopPointsActive ? getActiveLoopInnerColor() : getInactiveLoopInnerColor() );
p.setBrush( Qt::NoBrush );
p.drawRect( innerRectangle );
// Draw the position marker
p.setOpacity( 0.6 );
p.drawPixmap( m_posMarkerX, height() - s_posMarkerPixmap->height(), *s_posMarkerPixmap );
}
void TimeLineWidget::saveSettings( QDomDocument & _doc, QDomElement & _this )
{
_this.setAttribute( "lp0pos", (int) loopBegin() );
_this.setAttribute( "lp1pos", (int) loopEnd() );
_this.setAttribute( "lpstate", m_loopPoints );
}
/**
Draw the polyhedron.
*/
void PolyhedronGeom::drawGL()
{
// No tesselation object allocated yet? Then do so once and for all...
if (tess==0)
{
tess = gluNewTess();
if (tess==0)
return;
}
// Set flag to 0 (i.e. no variables are present so far)
tess_data_flag = 0;
PrimVarAccess<vec3d> normals(*this, std::string("N"), NORMAL, 1, std::string("Nfaces"));
PrimVarAccess<double> texcoords(*this, std::string("st"), FLOAT, 2, std::string("stfaces"));
PrimVarAccess<vec3d> colors(*this, std::string("Cs"), COLOR, 1, std::string("Csfaces"));
vec3d* N;
vec3d* Cs;
GLfloat glcol[4] = {0,0,0,1};
double* st;
vec3d* vertsptr = verts.dataPtr();
int i,j;
int nfloats=3;
// Check which variables has to be passed to the vertex callback
// (this is the case when mode is > 2)
if (normals.mode>2)
{
tess_data_flag |= 0x01;
nfloats += 3;
}
if (texcoords.mode>2)
{
tess_data_flag |= 0x02;
nfloats += 2;
}
if (colors.mode>2)
{
tess_data_flag |= 0x04;
nfloats += 3;
}
dataMemManager.setDataSize(nfloats*sizeof(GLdouble));
gluTessCallback(tess, GLU_TESS_BEGIN, (TessCallback)(&onTessBegin));
gluTessCallback(tess, GLU_TESS_END, (TessCallback)(&onTessEnd));
gluTessCallback(tess, GLU_TESS_VERTEX, (TessCallback)(&onTessVertex));
gluTessProperty(tess, GLU_TESS_BOUNDARY_ONLY, GL_FALSE);
gluTessProperty(tess, GLU_TESS_TOLERANCE, 0);
gluTessProperty(tess, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ODD);
// Iterate over all polygons...
for(i=0; i<getNumPolys(); i++)
{
dataMemManager.reset();
// No normals? Then a face normal has to be calculated...
if (normals.mode==0)
{
vec3d Ng;
computeNormal(i, Ng);
glNormal3d(Ng.x, Ng.y, Ng.z);
}
// Process uniform variables...
if (normals.onFace(N))
glNormal3d(N->x, N->y, N->z);
if (texcoords.onFace(st))
glTexCoord2dv(st);
if (colors.onFace(Cs))
{
glcol[0] = GLfloat(Cs->x);
glcol[1] = GLfloat(Cs->y);
glcol[2] = GLfloat(Cs->z);
glMaterialfv(GL_FRONT, GL_DIFFUSE, glcol);
}
gluTessBeginPolygon(tess, 0);
// Iterate over all loops of polygon i...
for(j=0; j<getNumLoops(i); j++)
{
gluTessBeginContour(tess);
LoopIterator it = loopBegin(i, j);
LoopIterator itend = loopEnd(i, j);
vec3d* v;
for( ; it!=itend; it++)
{
int vidx = (*it);
v = vertsptr + vidx;
GLdouble* data = (GLdouble*)dataMemManager.newDataPtr();
GLdouble* p = data+3;
data[0] = v->x;
data[1] = v->y;
data[2] = v->z;
if (normals.onVertex(vidx, N))
{
p[0] = N->x;
p[1] = N->y;
p[2] = N->z;
p += 3;
}
if (texcoords.onVertex(vidx, st))
{
p[0] = st[0];
p[1] = st[1];
p += 2;
}
if (colors.onVertex(vidx, Cs))
{
p[0] = Cs->x;
p[1] = Cs->y;
p[2] = Cs->z;
}
gluTessVertex(tess, data, data);
}
gluTessEndContour(tess);
}
gluTessEndPolygon(tess);
}
/* for(i=0; i<getNumPolys(); i++)
{
for(j=0; j<getNumLoops(i); j++)
{
LoopIterator it = loopBegin(i, j);
LoopIterator itend = loopEnd(i, j);
vec3d* v;
glBegin(GL_LINE_LOOP);
for( ; it!=itend; it++)
{
v = vertsptr + (*it);
glVertex3d(v->x, v->y, v->z);
}
glEnd();
}
}*/
}
/**
Convert to TriMesh
*/
void PolyhedronGeom::convert(GeomObject* target)
{
TriMeshGeom* tm = dynamic_cast<TriMeshGeom*>(target);
vec3d* vertsptr = verts.dataPtr();
// Index of the corresponding facevarying (or facevertex) variable
int facevarindex = 0;
int i, j;
// Check if the target geom is really a TriMesh
if (tm==0)
{
throw ENotImplementedError("Conversion not supported by the PolyhedronGeom");
}
// No tesselation object allocated yet? Then do so once and for all...
if (tess==0)
{
tess = gluNewTess();
if (tess==0)
return;
}
PolyTriangulation polyTriangulation(*this);
// Remove any existing variable in the trimesh...
tm->deleteAllVariables();
dataMemManager.setDataSize(3*sizeof(GLdouble)+2*sizeof(int));
gluTessCallback(tess, GLU_TESS_BEGIN_DATA, (TessCallback)(&onTessBegin_triangulation));
gluTessCallback(tess, GLU_TESS_END_DATA, (TessCallback)(&onTessEnd_triangulation));
gluTessCallback(tess, GLU_TESS_VERTEX_DATA, (TessCallback)(&onTessVertex_triangulation));
gluTessProperty(tess, GLU_TESS_BOUNDARY_ONLY, GL_FALSE);
gluTessProperty(tess, GLU_TESS_TOLERANCE, 0);
gluTessProperty(tess, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ODD);
// Iterate over all polygons...
for(i=0; i<getNumPolys(); i++)
{
dataMemManager.reset();
gluTessBeginPolygon(tess, &polyTriangulation);
// Iterate over all loops of polygon i...
for(j=0; j<getNumLoops(i); j++)
{
gluTessBeginContour(tess);
LoopIterator it = loopBegin(i, j);
LoopIterator itend = loopEnd(i, j);
vec3d* v;
for( ; it!=itend; it++)
{
int vidx = (*it);
v = vertsptr + vidx;
GLdouble* loc = (GLdouble*)dataMemManager.newDataPtr();
loc[0] = v->x;
loc[1] = v->y;
loc[2] = v->z;
int* data = (int*)(loc+3);
data[0] = vidx; // Vertex index
data[1] = facevarindex; // facevarying variable index
gluTessVertex(tess, loc, data);
facevarindex++;
}
gluTessEndContour(tess);
}
gluTessEndPolygon(tess);
polyTriangulation.polyFinished();
}
polyTriangulation.initTriMesh(*tm);
}
