/** Drawing event handler. */
virtual bool
on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
{
switch (_curShape) {
case SHAPE_RECTANGLE:
cr->rectangle(20, 20, 200, 100);
cr->set_source_rgb(0, 0.8, 0);
cr->fill_preserve();
break;
case SHAPE_ELLIPSE:
cr->arc(150, 100, 90, 0, 2 * 3.14);
cr->set_source_rgb(0.8, 0, 0);
cr->fill_preserve();
break;
case SHAPE_TRIANGLE:
cr->move_to(40, 40);
cr->line_to(200, 40);
cr->line_to(120, 160);
cr->line_to(40, 40);
cr->set_source_rgb(0.8, 0, 0.8);
cr->fill_preserve();
cr->set_line_cap(Cairo::LINE_CAP_ROUND);
cr->set_line_join(Cairo::LINE_JOIN_ROUND);
break;
}
cr->set_line_width(3);
cr->set_source_rgb(0, 0, 0);
cr->stroke();
return true;
}
bool
ButtonWidget::on_expose_event(GdkEventExpose* event)
{
Gtk::DrawingArea::on_expose_event(event);
Glib::RefPtr<Gdk::Window> window = get_window();
if(window)
{
Cairo::RefPtr<Cairo::Context> cr = window->create_cairo_context();
int w = get_allocation().get_width() - 10;
int h = get_allocation().get_height() - 10;
cr->set_source_rgb(0.0, 0.0, 0.0);
cr->set_line_width(1.0);
cr->translate(5, 5);
cr->rectangle(0, 0, w, h);
if (down)
cr->fill_preserve();
cr->stroke();
if (down)
cr->set_source_rgb(1.0, 1.0, 1.0);
// FIXME: There are better ways to center text
if (name.size() == 2)
cr->move_to(w/2-6, h/2+3);
else
cr->move_to(w/2-4, h/2+3);
cr->show_text(name);
}
return true;
}
void GraphicalItem::drawRoundedRectangle(
const Cairo::RefPtr<Cairo::Context>& context,
int x, int y,
int width, int height,
double aspect,
double corner_radius,
double red, double green, double blue)
{
double radius = corner_radius / aspect;
double degrees = M_PI / 180.0;
context->begin_new_sub_path();
context->arc(x + width - radius, y + radius, radius,
-90 * degrees, 0 * degrees);
context->arc(x + width - radius, y + height - radius,
radius, 0 * degrees, 90 * degrees);
context->arc(x + radius, y + height - radius, radius,
90 * degrees, 180 * degrees);
context->arc(x + radius, y + radius, radius,
180 * degrees, 270 * degrees);
context->close_path();
context->set_source_rgb(red, green, blue);
context->fill_preserve();
setColor(Settings::settings().getForegroundColor(), context);
context->stroke();
}
static void
skillgui_cairo_render_bezier(GVJ_t * job, pointf * A, int n, int arrow_at_start,
int arrow_at_end, int filled)
{
#ifdef USE_GVPLUGIN_TIMETRACKER
__tt.ping_start(__ttc_bezier);
++__num_bezier;
#endif
//printf("Bezier\n");
SkillGuiCairoRenderInstructor *cri = (SkillGuiCairoRenderInstructor *)job->context;
Cairo::RefPtr<Cairo::Context> cairo = cri->get_cairo();
obj_state_t *obj = job->obj;
skillgui_cairo_set_penstyle(cairo, job);
cairo->move_to(A[0].x, -A[0].y);
for (int i = 1; i < n; i += 3)
cairo->curve_to(A[i].x, -A[i].y, A[i + 1].x, -A[i + 1].y,
A[i + 2].x, -A[i + 2].y);
if (filled) {
skillgui_cairo_set_color(cairo, &(obj->fillcolor));
cairo->fill_preserve();
}
skillgui_cairo_set_color(cairo, &(obj->pencolor));
cairo->stroke();
#ifdef USE_GVPLUGIN_TIMETRACKER
__tt.ping_end(__ttc_bezier);
#endif
}
bool on_expose_event(GdkEventExpose* ev) {
Glib::RefPtr< Gdk::Window > window = get_window();
if (window) {
Cairo::RefPtr< Cairo::Context > ctx = window->create_cairo_context();
Gtk::Allocation alloc = get_allocation();
const int height = alloc.get_height();
const int width = alloc.get_width();
ctx->scale(width, height); //escala para que ocupe siempre toda la pantalla. Notar que es ancho y después alto.
ctx->set_line_width(ANCHO_LINEA);
// contorno
ctx->move_to(0.0, 1.0); // muevo hacia el punto inicial, que arbitrariamente elegí que fuera el de la izquierda abajo
ctx->line_to(0.0, 0.0); // línea hacia el punto de arriba a la izquierda
ctx->line_to(1.0, 0.0); // línea hacia el punto de arriba a la derecha
ctx->line_to(1.0, 1.0); // línea hacia el punto de abajo a la derecha
ctx->close_path(); // cierro el camino
ctx->save(); // salvo porque voy a cambiar el color
ctx->set_source_rgb(1.0, 1.0, 1.0); // seteo el color al blanco
ctx->fill_preserve(); // relleno todo el cuadrado, preservando el camino para dibujar el contorno
ctx->restore();
ctx->stroke(); // pinto el camino en negro
// triángulo azul de abajo
ctx->move_to(0.0, 1.0); // muevo hacia el punto inicial, que arbitrariamente elegí que fuera el de la izquierda
ctx->line_to(0.5, 0.5); // línea hacia el punto del medio
ctx->line_to(1.0, 1.0); // línea hacia el punto de abajo a la derecha
ctx->close_path(); // cierro el camino
ctx->save(); // salvo porque voy a cambiar el color
ctx->set_source_rgb(0.0, 0.0, 1.0); // seteo el color al azul
ctx->fill_preserve(); // relleno todo triángulo, preservando el camino para dibujar el contorno
ctx->restore();
ctx->stroke(); // pinto el camino en negro
// triángulo azul de arriba
ctx->move_to(0.0, 0.0); // muevo hacia el punto inicial, que arbitrariamente elegí que fuera el de la izquierda
ctx->line_to(0.5, 0.5); // línea hacia el punto del medio
ctx->line_to(1.0, 0.0); // línea hacia el punto de arriba a la derecha
ctx->close_path(); // cierro el camino
ctx->save(); // salvo porque voy a cambiar el color
ctx->set_source_rgb(0.0, 0.0, 1.0); // seteo el color al azul
ctx->fill_preserve(); // relleno todo triángulo, preservando el camino para dibujar el contorno
ctx->restore();
ctx->stroke(); // pinto el camino en negro
}
return true;
}
virtual bool on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
{
Gtk::Allocation allocation = get_allocation();
const int width = allocation.get_width();
const int height = allocation.get_height();
if(!drawing)
{
sort(objects.begin(), objects.end(), PlaneObjectColection::compare);
}
drawing=1;
unsigned int i;
unsigned int j;
cr->set_line_width(2);
Coordenate temp;
for(i=0; i<objects.size(); i++)
{
if(objects[i].get_num_nodos()<2 || objects[i].z>=camera.z) continue;
cr->save();
temp=get_draw_location(objects[i].get_nodo_position(0), width, height, 26.5/M_PI);
cr->line_to(temp.x, temp.y);
cr->move_to(temp.x, temp.y);
for(j=1; j<objects[i].get_num_nodos(); j++)
{
temp=get_draw_location(objects[i].get_nodo_position(j), width, height, 26.5/M_PI);
cr->line_to(temp.x, temp.y);
}
temp=get_draw_location(objects[i].get_nodo_position(0), width, height, 26.5/M_PI);
cr->line_to(temp.x, temp.y);
temp=get_draw_location(objects[i].get_nodo_position(1), width, height, 26.5/M_PI);
cr->line_to(temp.x, temp.y);
cr->set_source_rgba(double(objects[i].fill_color.red)/255, double(objects[i].fill_color.green)/255, double(objects[i].fill_color.blue)/255, double(objects[i].fill_color.alpha)/255);
cr->fill_preserve();
cr->set_source_rgba(double(objects[i].line_color.red)/255, double(objects[i].line_color.green)/255, double(objects[i].line_color.blue)/255, double(objects[i].line_color.alpha)/255);
cr->stroke();
cr->restore();
}
return 1;
}
// ----------------------------------------------------------------------------
// -- Function : draw_bar(cr)
// --
// -- Takes : cr = point to a cairo reference
// --
// -- Purpose : Assumes value is already between 1 and 0! Draws the bar
// on the provided cairo reference.
void BarWidget::draw_bar(Cairo::RefPtr<Cairo::Context> cr)
{
// Get our bar coords
Size size = get_avail_rect();
Size* s = &size;
// Draw the bg first
cr->set_line_width(bar_bg_border_width);
cr->rectangle(s->x, s->y, s->width, s->height);
// -- bg border
if (draw_bar_bg_border)
{
bar_bg_border_color->set_source(cr);
cr->stroke_preserve();
}
// -- bg
if (draw_bar_bg)
{
bar_bg_color->set_source(cr);
cr->fill_preserve();
}
// Clear the path
cr->begin_new_path();
// -- Now we're drawing the value bar
// Modify the size by our value / percent
// If we're horz, modify the width.
// If we're vert, modify the height.
if (vertical)
s->height = s->height * m_value;
else
s->width = s->width * m_value;
// New path, draw!
cr->set_line_width(bar_border_width);
cr->rectangle(s->x, s->y, s->width, s->height);
// -- bar border
if (draw_bar_border)
{
bar_border_color->set_source(cr);
cr->stroke_preserve();
}
// -- Draw the bar
bar_color->set_source(cr);
cr->fill();
// clean up
cr->begin_new_path();
s = nullptr;
}
//! Only renders the shield background, the text is rendered in renderLabels
void Renderer::renderShields(const Cairo::RefPtr<Cairo::Context>& cr,
std::vector<shared_ptr<Shield> >& shields) const
{
cr->save();
cr->set_line_join(Cairo::LINE_JOIN_ROUND);
for (auto& shield : shields)
{
const Style* s = shield->style;
double x0, y0, height, width;
double border = ceil(s->shield_frame_width/2.0 + s->shield_casing_width);
x0 = shield->shield.minX + border;
y0 = shield->shield.minY + border;
width = shield->shield.getWidth() - 2*border;
height = shield->shield.getHeight() - 2*border;
if ((int) s->shield_frame_width % 2 == 1) {
x0 -= 0.5;
y0 -= 0.5;
}
if (s->shield_shape == Style::ShieldShape::ROUNDED) {
cr->arc(x0 + height/2.0, y0 + height/2.0,
height/2.0, boost::math::constants::pi<double>()/2.0, 3.0*boost::math::constants::pi<double>()/2.0);
cr->arc(x0 + width - height/2.0, y0 + height/2.0,
height/2.0, 3.0*boost::math::constants::pi<double>()/2.0, boost::math::constants::pi<double>()/2.0);
cr->close_path();
} else
cr->rectangle(x0, y0, width, height);
// shield casing
if (s->shield_casing_width > 0) {
cr->set_source_color(s->shield_casing_color),
cr->set_line_width(s->shield_frame_width + s->shield_casing_width * 2.0);
cr->stroke_preserve();
}
// shield background
cr->set_source_color(s->shield_color),
cr->fill_preserve();
// shield frame
cr->set_source_color(s->shield_frame_color),
cr->set_line_width(s->shield_frame_width);
cr->stroke();
}
cr->restore();
}
void BezierPath::Invocation::draw(const Cairo::RefPtr<Cairo::Context> & cr)
{
if (!path) return;
//Execute the bezier path.
path->execute(cr);
//Stroke, fill or do both.
if (stroke && fill) {
cr->fill_preserve();
cr->stroke();
}
else if (stroke) cr->stroke();
else if (fill) cr->fill();
}
void NodeSurface::DrawRoundedRectangle(
Cairo::RefPtr<Cairo::Context> refCairo,
double x,
double y,
double width,
double height,
double radius,
double red,
double green,
double blue,
bool selected )
{
refCairo->save();
if ( (radius > height/2.0) || (radius > width/2.0) )
{
radius = std::min<double>(height / 2, width / 2);
}
refCairo->move_to( x, y + radius );
refCairo->arc( x + radius, y + radius, radius, sk_pi, -sk_pi / 2.0 );
refCairo->line_to( x + width - radius, y );
refCairo->arc( x + width - radius, y + radius, radius, -sk_pi / 2.0, 0 );
refCairo->line_to( x + width, y + height - radius );
refCairo->arc( x + width - radius, y + height - radius, radius, 0, sk_pi / 2.0 );
refCairo->line_to( x + radius, y + height );
refCairo->arc( x + radius, y + height - radius, radius, sk_pi / 2.0, sk_pi );
refCairo->close_path();
refCairo->set_source_rgb( red, green, blue );
refCairo->fill_preserve();
if ( selected == true )
{
refCairo->set_source_rgb( 1.0, 0.0, 0.0 );
refCairo->set_line_width( 2 );
refCairo->stroke();
}
else
{
refCairo->set_source_rgb( 0.0, 0.0, 0.0 );
refCairo->set_line_width( 1 );
refCairo->stroke();
}
refCairo->restore();
}
void enigma_rotor_window::draw_wheel_pos(Cairo::RefPtr<Cairo::Context> cr, gunichar new_pos)
{
wheel_pos = new_pos;
const char *trans_2 = "00000000011111111112222222";
const char *trans_1 = "12345678901234567890123456";
int win_size = ((int)(padded_size)) - 1;
cr->save();
// Draw background of rotor window as a rectangle filled with the rotor background colour
cr->set_source_rgb(rotor_r, rotor_g, rotor_b);
cr->rectangle(x - win_size / 2, y - win_size / 2, win_size, win_size); // Set path
cr->fill_preserve(); // Fill everyting inside the path and preserve the path
// Draw black border around the path, i.e. the rectangle that represents the rotor window
cr->set_line_width(1.0);
cr->set_source_rgb(BLACK);
cr->stroke();
cr->restore();
cr->save();
// Set colour in which to draw the rotor position
if (!is_greek)
cr->set_source_rgb(BLACK); // Default is black
else
cr->set_source_rgb(RED); // The greek wheel on M4 has red markings
if (!is_numeric)
{
// rotor position is displayed as character A-Z
print_char(cr, x, y, new_pos, font_size_char);
}
else
{
// rotor position is displayed as a number 01, 02, ..., 26
print_char(cr, x - char_width_numeric / 2, y, trans_2[new_pos - 'A'], font_size_numeric);
print_char(cr, x + char_width_numeric / 2, y, trans_1[new_pos - 'A'], font_size_numeric);
}
cr->restore();
}
void GraphicalItem::drawRectangle(const Cairo::RefPtr<Cairo::Context>& context,
int x, int y,
int width, int height,
double red, double green, double blue)
{
context->begin_new_sub_path();
context->move_to(x, y);
context->line_to(x + width, y);
context->line_to(x + width, y + height);
context->line_to(x, y + height);
context->line_to(x, y);
context->close_path();
context->set_source_rgb(red, green, blue);
context->fill_preserve();
setColor(Settings::settings().getForegroundColor(), context);
context->stroke();
}
static void
skillgui_cairo_render_ellipse(GVJ_t *job, pointf *A, int filled)
{
#ifdef USE_GVPLUGIN_TIMETRACKER
__tt.ping_start(__ttc_ellipse);
++__num_ellipse;
#endif
//printf("Render ellipse\n");
SkillGuiCairoRenderInstructor *cri = (SkillGuiCairoRenderInstructor *)job->context;
Cairo::RefPtr<Cairo::Context> cairo = cri->get_cairo();
obj_state_t *obj = job->obj;
Cairo::Matrix old_matrix;
cairo->get_matrix(old_matrix);
skillgui_cairo_set_penstyle(cairo, job);
cairo->translate(A[0].x, -A[0].y);
double rx = A[1].x - A[0].x;
double ry = A[1].y - A[0].y;
cairo->scale(1, ry / rx);
cairo->move_to(rx, 0);
cairo->arc(0, 0, rx, 0, 2 * M_PI);
cairo->close_path();
cairo->set_matrix(old_matrix);
if (filled) {
skillgui_cairo_set_color(cairo, &(obj->fillcolor));
cairo->fill_preserve();
}
skillgui_cairo_set_color(cairo, &(obj->pencolor));
cairo->stroke();
#ifdef USE_GVPLUGIN_TIMETRACKER
__tt.ping_end(__ttc_ellipse);
#endif
}
static void
skillgui_cairo_render_polygon(GVJ_t *job, pointf *A, int n, int filled)
{
#ifdef USE_GVPLUGIN_TIMETRACKER
__tt.ping_start(__ttc_polygon);
++__num_polygon;
#endif
//printf("Polygon\n");
SkillGuiCairoRenderInstructor *cri = (SkillGuiCairoRenderInstructor *)job->context;
Cairo::RefPtr<Cairo::Context> cairo = cri->get_cairo();
obj_state_t *obj = job->obj;
skillgui_cairo_set_penstyle(cairo, job);
cairo->move_to(A[0].x, -A[0].y);
for (int i = 1; i < n; ++i) {
cairo->line_to(A[i].x, -A[i].y);
}
cairo->close_path();
if (filled) {
skillgui_cairo_set_color(cairo, &(obj->fillcolor));
cairo->fill_preserve();
}
// HACK to workaround graphviz bug any get the Tim style...
if ( obj->type == CLUSTER_OBJTYPE ) {
obj->pencolor.u.RGBA[0] = 0.666;
obj->pencolor.u.RGBA[1] = 0.666;
obj->pencolor.u.RGBA[2] = 1.0;
obj->pencolor.u.RGBA[3] = 1.0;
}
skillgui_cairo_set_color(cairo, &(obj->pencolor));
cairo->stroke();
#ifdef USE_GVPLUGIN_TIMETRACKER
__tt.ping_end(__ttc_polygon);
#endif
}
bool CPagePreview::on_expose_event(GdkEventExpose *event)
{
std::cout << "Fired!\n";
Glib::RefPtr<Gdk::Window> window = get_window();
if(window)
{
// get the cairo context amd allocation
Cairo::RefPtr<Cairo::Context> cr = window->create_cairo_context();
Gtk::Allocation allocation = get_allocation();
const int width = allocation.get_width();
const int height = allocation.get_height();
// coordinates for the center of the window
int xc, yc;
xc = width / 2;
yc = height / 2;
// clip to the area indicated by the expose event so that we only redraw
// the portion of the window that needs to be redrawn
cr->rectangle(event->area.x, event->area.y,
event->area.width, event->area.height);
cr->clip();
double border = 0.05;
double offset = 2.0;
// draw a neat shadow
cr->set_source_rgba(0.0,0.0,0.0,0.4);
cr->begin_new_path();
cr->move_to( width*border+offset,height*border+offset );
cr->line_to( width*(1.0-border)+offset,height*border+offset );
cr->line_to( width*(1.0-border)+offset,height*(1.0-border)+offset );
cr->line_to( width*border+offset,height*(1.0-border)+offset );
cr->close_path();
cr->fill();
// draw the page outline
cr->set_source_rgb(0.0,0.0,0.0); // black
cr->set_line_width( 1.0 );
cr->begin_new_sub_path();
cr->move_to( width*border-offset,height*border-offset );
cr->line_to( width*(1.0-border)-offset,height*border-offset );
cr->line_to( width*(1.0-border)-offset,height*(1.0-border)-offset );
cr->line_to( width*border-offset,height*(1.0-border)-offset );
cr->close_path();
cr->stroke_preserve();
// fill the page with white
cr->save();
cr->set_source_rgb(1.0,1.0,1.0); // white
cr->fill_preserve();
cr->restore();
// and the image preview
ImagePixbuf->render_to_drawable( get_window(),
get_style()->get_black_gc(),
0,
0,
(width-ImagePixbuf->get_width())/2,
(height-ImagePixbuf->get_height())/2,
ImagePixbuf->get_width(), //image->get_width(),
ImagePixbuf->get_height(), //image->get_height(),
Gdk::RGB_DITHER_NONE,0,0 ); // */
return true;
}
}
/** Draw laser segments as produced by leg tracker application.
* @param itf either Laser360Interface or Laser720Interface
* @param window Gdk window
* @param cr Cairo context to draw to. It is assumed that possible transformations
* have been setup before.
*/
void
LaserDrawingArea::draw_segments(const fawkes::Interface* itf,
Glib::RefPtr<Gdk::Window> &window,
const Cairo::RefPtr<Cairo::Context> &cr)
{
size_t nd = __laser_segmentation_if->maxlenof_distances();
const float nd_factor = 360.0 / nd;
float *distances;
const fawkes::Laser360Interface* itf360 = NULL;
const fawkes::Laser720Interface* itf720 = NULL;
if ((itf360 = dynamic_cast<const fawkes::Laser360Interface*>(itf))) {
distances = itf360->distances();
} else if ((itf720 = dynamic_cast<const fawkes::Laser720Interface*>(itf))) {
distances = itf720->distances();
} else {
throw fawkes::Exception("Interface is neither Laser360Interface nor Laser720Interface");
}
cr->save();
/* DRAW SEGMENTS (draw the segment interiors again with other color*/
if( __laser_segmentation_if && __laser_segmentation_if->has_writer()){
if(!__break_drawing)
__laser_segmentation_if->read();
float * segmentations = __laser_segmentation_if->distances();
size_t nd = __laser_segmentation_if->maxlenof_distances();
// cr->set_source_rgba(0,0,0,0.5);
cr->set_source_rgb(1,1,0);
if ( __draw_mode == MODE_POINTS ) {
for (size_t i = 0; i < nd; i += __resolution) {
if( segmentations[i]==0) continue; // dont draw the segment borders
if ( distances[i] == 0 || ! std::isfinite(distances[i])) continue;
float anglerad = deg2rad(i * nd_factor);
cr->move_to(0, 0);
cr->line_to(distances[i] * sin(anglerad),
distances[i] * -cos(anglerad));
}
cr->stroke();
} else {//if ( __draw_mode == MODE_LINES ) {
float radius = 4 / __zoom_factor;
for (size_t i = 0; i < nd; i += __resolution) {
if( segmentations[i]==0) continue; // dont draw the segment borders
if ( distances[i] == 0 ) continue;
float anglerad = deg2rad(i * nd_factor);
float x = distances[i] * sin(anglerad);
float y = distances[i] * -cos(anglerad);
// circles replaced by rectangles, they are a *lot* faster
//cr->move_to(x, y);
//cr->arc(x, y, radius, 0, 2*M_PI);
cr->rectangle(x, y, radius, radius);
}
cr->fill_preserve();
cr->stroke();
}
/*else {
cr->move_to(0, - distances[0]);
for (size_t i = __resolution; i <= nd + __resolution; i += __resolution) {
if ( distances[i] == 0 ) continue;
float anglerad = deg2rad(i % 360);
cr->line_to(distances[i % 360] * sin(anglerad),
distances[i % 360] * -cos(anglerad));
}
cr->stroke();
}
*/
}
cr->restore();
}
/** Draw Beams of an interface.
* Draws the beams as lines, circles or hull, depending on draw mode.
* @param itf either Laser360Interface or Laser720Interface
* @param window Gdk window
* @param cr Cairo context to draw to. It is assumed that possible transformations
* have been setup before.
*/
void
LaserDrawingArea::draw_beams(const fawkes::Interface *itf,
Glib::RefPtr<Gdk::Window> &window,
const Cairo::RefPtr<Cairo::Context> &cr)
{
float *distances;
size_t nd;
bool clockwise;
const fawkes::Laser360Interface* itf360 = NULL;
const fawkes::Laser720Interface* itf720 = NULL;
if ((itf360 = dynamic_cast<const fawkes::Laser360Interface*>(itf))) {
distances = itf360->distances();
nd = itf360->maxlenof_distances();
clockwise = itf360->is_clockwise_angle();
} else if ((itf720 = dynamic_cast<const fawkes::Laser720Interface*>(itf))) {
distances = itf720->distances();
nd = itf720->maxlenof_distances();
clockwise = itf720->is_clockwise_angle();
} else {
throw fawkes::Exception("Interface is neither Laser360Interface nor Laser720Interface");
}
const float nd_factor = 360.0 / nd;
float *revdists = NULL;
if (! clockwise) {
// re-arrange to clockwise
revdists = (float *)new float[nd];
for (size_t i = 0; i < nd; ++i) {
revdists[nd - i] = distances[i];
}
distances = revdists;
}
cr->scale(__zoom_factor, __zoom_factor);
cr->rotate(__rotation);
cr->set_line_width(1. / __zoom_factor);
draw_scalebox(window, cr);
if ( __draw_mode == MODE_LINES ) {
for (size_t i = 0; i < nd; i += __resolution) {
if ( distances[i] == 0 || ! std::isfinite(distances[i]) ) continue;
const float anglerad = deg2rad(i * nd_factor);
cr->move_to(0, 0);
cr->line_to(distances[i] * sin(anglerad),
distances[i] * -cos(anglerad));
}
cr->stroke();
} else if ( __draw_mode == MODE_POINTS ) {
const float radius = 4 / __zoom_factor;
for (size_t i = 0; i < nd; i += __resolution) {
if ( distances[i] == 0 ) continue;
float anglerad = deg2rad(i * nd_factor);
float x = distances[i] * sin(anglerad);
float y = distances[i] * -cos(anglerad);
// circles replaced by rectangles, they are a *lot* faster
//cr->move_to(x, y);
//cr->arc(x, y, radius, 0, 2*M_PI);
cr->rectangle(x, y, radius, radius);
}
cr->fill_preserve();
cr->stroke();
} else {
cr->move_to(0, - distances[0]);
for (size_t i = __resolution; i <= nd + __resolution; i += __resolution) {
if ( distances[i] == 0 ) continue;
const float anglerad = normalize_rad(deg2rad(i * nd_factor));
cr->line_to(distances[i % nd] * sin(anglerad),
distances[i % nd] * -cos(anglerad));
}
cr->stroke();
}
if (revdists) delete[] revdists;
}
/** Expose event handler.
* @param event event info structure.
* @return signal return value
*/
bool
LaserDrawingArea::on_expose_event(GdkEventExpose* event)
#endif
{
// This is where we draw on the window
Glib::RefPtr<Gdk::Window> window = get_window();
if(window) {
Gtk::Allocation allocation = get_allocation();
if(__first_draw)
{
__first_draw = false;
const int width = allocation.get_width();
const int height = allocation.get_height();
// coordinates for the center of the window
__xc = width / 2;
__yc = height / 2;
}
#if GTK_VERSION_LT(3,0)
Cairo::RefPtr<Cairo::Context> cr = window->create_cairo_context();
#endif
cr->set_line_width(1.0);
cr->set_source_rgb(1, 1, 1);
#if GTK_VERSION_LT(3,0)
// clip to the area indicated by the expose event so that we only
// redraw the portion of the window that needs to be redrawn
cr->rectangle(event->area.x, event->area.y,
event->area.width, event->area.height);
cr->fill_preserve();
cr->clip();
#else
cr->paint();
#endif
cr->set_source_rgb(0, 0, 0);
//cr->set_source_rgba(0,0,0,1);
// __last_xc += __translation_x;
// __last_yc += __translation_y;
cr->translate(__xc, __yc);
cr->save();
if (! __connected) {
Cairo::TextExtents te;
std::string t = "Not connected to BlackBoard";
cr->set_source_rgb(1, 0, 0);
cr->set_font_size(20);
cr->get_text_extents(t, te);
cr->move_to(- te.width / 2, -te.height / 2);
cr->show_text(t);
} else if ( __laser_ifs.empty() ) {
Cairo::TextExtents te;
std::string t = "No interface opened";
cr->set_source_rgb(1, 0, 0);
cr->set_font_size(20);
cr->get_text_extents(t, te);
cr->move_to(- te.width / 2, -te.height / 2);
cr->show_text(t);
} else if (! all_laser_ifs_have_writer() ) {
Cairo::TextExtents te;
std::string t = "No writer for ";
for (std::list<InterfaceColorPair>::const_iterator it = __laser_ifs.begin();
it != __laser_ifs.end(); ++it) {
fawkes::Interface* itf = it->first;
if (!itf->has_writer()) {
t += itf->uid();
t += ' ';
}
}
cr->set_source_rgb(1, 0, 0);
cr->set_font_size(20);
cr->get_text_extents(t, te);
cr->move_to(- te.width / 2, -te.height / 2);
cr->show_text(t);
} else {
if (! __break_drawing) {
for (std::list<InterfaceColorPair>::const_iterator it = __laser_ifs.begin();
it != __laser_ifs.end(); ++it) {
fawkes::Interface* laser_if = it->first;
laser_if->read();
}
}
for (std::list<InterfaceColorPair>::const_iterator it = __laser_ifs.begin();
it != __laser_ifs.end(); ++it) {
const fawkes::Interface* laser_if = it->first;
const Color& color = it->second;
cr->save();
cr->set_source_rgb(color.r, color.g, color.b);
draw_beams(laser_if, window, cr);
cr->restore();
}
if (__robot_drawer) __robot_drawer->draw_robot(window, cr);
for (std::list<InterfaceColorPair>::const_iterator it = __laser_ifs.begin();
it != __laser_ifs.end(); ++it) {
const fawkes::Interface* laser_if = it->first;
const Color& color = it->second;
cr->save();
cr->set_source_rgb(color.r, color.g, color.b);
draw_segments(laser_if, window, cr);
cr->restore();
}
draw_persons_legs(window, cr);
if(__switch_if != NULL && __switch_if->has_writer()){
SwitchInterface::EnableSwitchMessage *esm = new SwitchInterface::EnableSwitchMessage();
__switch_if->msgq_enqueue(esm);
}
}
cr->restore();
cr->save();
cr->rotate(0.5 * M_PI + __rotation);
cr->scale(-__zoom_factor, __zoom_factor);
cr->set_line_width(1. / __zoom_factor);
if (__visdisp_if) {
__visdisp->process_messages();
__visdisp->draw(cr);
}
const float radius = 0.01;
if (__line_if) {
__line_if->read();
if (__line_if->has_writer() &&
__line_if->is_valid() && __line_if->is_visible()) {
cr->set_source_rgb(1, 0, 0);
/*
std::vector<double> dashes(1);
dashes[0] = 0.1;
cr->set_dash(dashes, 0);
*/
cr->rectangle(__line_if->world_x() - radius * 0.5, __line_if->world_y() - radius * 0.5, radius, radius);
cr->rectangle(__line_if->relative_x() - radius * 0.5, __line_if->relative_y() - radius * 0.5, radius, radius);
cr->fill_preserve();
cr->stroke();
cr->move_to(__line_if->world_x(), __line_if->world_y());
cr->line_to(__line_if->relative_x(), __line_if->relative_y());
cr->stroke();
}
}
cr->restore();
}
return true;
}
bool CalibrationArea::on_expose_event(GdkEventExpose *event)
{
// check that screensize did not change
if (display_width != get_width() ||
display_height != get_height()) {
set_display_size(get_width(), get_height());
}
Glib::RefPtr<Gdk::Window> window = get_window();
if (window) {
Cairo::RefPtr<Cairo::Context> cr = window->create_cairo_context();
cr->save();
cr->rectangle(event->area.x, event->area.y, event->area.width, event->area.height);
cr->clip();
// Print the text
cr->set_font_size(font_size);
double text_height = -1;
double text_width = -1;
Cairo::TextExtents extent;
for (int i = 0; i != help_lines; i++) {
cr->get_text_extents(help_text[i], extent);
text_width = std::max(text_width, extent.width);
text_height = std::max(text_height, extent.height);
}
text_height += 2;
double x = (display_width - text_width) / 2;
double y = (display_height - text_height) / 2 - 60;
cr->set_line_width(2);
cr->rectangle(x - 10, y - (help_lines*text_height) - 10,
text_width + 20, (help_lines*text_height) + 20);
// Print help lines
y -= 3;
for (int i = help_lines-1; i != -1; i--) {
cr->get_text_extents(help_text[i], extent);
cr->move_to(x + (text_width-extent.width)/2, y);
cr->show_text(help_text[i]);
y -= text_height;
}
cr->stroke();
// Draw the points
for (int i = 0; i <= calibrator->get_numclicks(); i++) {
// set color: already clicked or not
if (i < calibrator->get_numclicks())
cr->set_source_rgb(1.0, 1.0, 1.0);
else
cr->set_source_rgb(0.8, 0.0, 0.0);
cr->set_line_width(1);
cr->move_to(X[i] - cross_lines, Y[i]);
cr->rel_line_to(cross_lines*2, 0);
cr->move_to(X[i], Y[i] - cross_lines);
cr->rel_line_to(0, cross_lines*2);
cr->stroke();
cr->arc(X[i], Y[i], cross_circle, 0.0, 2.0 * M_PI);
cr->stroke();
}
// Draw the clock background
cr->arc(display_width/2, display_height/2, clock_radius/2, 0.0, 2.0 * M_PI);
cr->set_source_rgb(0.5, 0.5, 0.5);
cr->fill_preserve();
cr->stroke();
cr->set_line_width(clock_line_width);
cr->arc(display_width/2, display_height/2, (clock_radius - clock_line_width)/2,
3/2.0*M_PI, (3/2.0*M_PI) + ((double)time_elapsed/(double)max_time) * 2*M_PI);
cr->set_source_rgb(0.0, 0.0, 0.0);
cr->stroke();
// Draw the message (if any)
if (message != NULL) {
// Frame the message
cr->set_font_size(font_size);
Cairo::TextExtents extent;
cr->get_text_extents(this->message, extent);
text_width = extent.width;
text_height = extent.height;
x = (display_width - text_width) / 2;
y = (display_height - text_height + clock_radius) / 2 + 60;
cr->set_line_width(2);
cr->rectangle(x - 10, y - text_height - 10,
text_width + 20, text_height + 25);
// Print the message
cr->move_to(x, y);
cr->show_text(this->message);
cr->stroke();
}
cr->restore();
}
return true;
}
void Fader(Cairo::RefPtr<Cairo::Context> cr, float x, float y, float value, float rms, float falloff)
{
// draw invisible from the last widget
cr->set_source_rgba(0,0,0,0);
cr->move_to( x, y );
cr->stroke();
x = x + 4; // global move widget relative to positioning
// Create the linear gradient diagonal
//Cairo::RefPtr< Cairo::LinearGradient > linGrad = Cairo::LinearGradient::create (x, y, 100, 100);
// Set grandient colors
//linGrad->add_color_stop_rgb (0, 10 / 255.f, 246 / 255.f, 98 / 255.f );
//linGrad->add_color_stop_rgb (1, 192 / 255.f, 246 / 255.f, 98 / 255.f );
// Draw rectangle and fill with gradient
cairo_pattern_t *pat;
pat = cairo_pattern_create_linear (0.0, 0.0, 0.0, 400.0);
cairo_pattern_add_color_stop_rgb(pat, 0, 0 / 255.f, 153 / 255.f, 255 / 255.f );
cairo_pattern_add_color_stop_rgb(pat, 1, 26 / 255.f, 26 / 255.f, 26 / 255.f );
cr->rectangle (x, y, 12, 94);
cairo_set_source(cr->cobj(), pat);
cairo_fill (cr->cobj());
cairo_pattern_destroy (pat);
// red area on top of fader graphic
cr->rectangle ( x, y, 12, 25 );
setColour(cr, COLOUR_ORANGE_1 );
cr->fill();
float tmpRms = (1-rms);
//std::cout << "Falloff: " << falloff << " RMS " << rms << std::endl;
if ( falloff > rms )
{
//std::cout << "Falloff > RMS" << std::endl;
tmpRms = (1-falloff);
falloff -= 0.1;
}
else
{
falloff = rms;
}
//std::cout << " tmpRms " << tmpRms << " drawPx: " << tmpRms * 94 << std::endl;
cr->rectangle ( x, y, 12, 94 * tmpRms );
setColour(cr, COLOUR_GREY_2 );
cr->fill();
// draw fader <|
float playheadX = x + 12;
float playheadY = y + (92 * ( 1.f - value));
setColour(cr, COLOUR_ORANGE_1 );
cr->set_line_width(0.8);
cr->move_to( playheadX, playheadY );
cr->line_to( playheadX + 10, playheadY + 5.5 );
cr->line_to( playheadX + 10, playheadY - 5.5 );
cr->close_path();
cr->fill_preserve();
// draw fader |>
cr->move_to( x, playheadY );
cr->line_to( x - 10, playheadY + 5.5 );
cr->line_to( x - 10, playheadY - 5.5 );
cr->close_path();
cr->fill_preserve();
cr->stroke();
// line between fader markers |> --- <|
setColour(cr, COLOUR_GREY_4 );
cr->set_line_width(2);
cr->move_to( x, playheadY );
cr->line_to( x + 12, playheadY );
cr->stroke();
}
bool SamplerWidget::on_expose_event(GdkEventExpose* event)
{
// This is where we draw on the window
Glib::RefPtr<Gdk::Window> window = get_window();
if(window) // Only run if Window does exist
{
allocation = get_allocation();
int width = allocation.get_width();
int height = allocation.get_height();
//std::cout << "Width: " << width << std::endl;
//std::cout << "Height: " << height << std::endl;
//std::cout << "Height / 12: " << height /12.0 << std::endl;
// coordinates for the center of the window
int xc, yc;
xc = width / 2;
yc = height / 2;
Cairo::RefPtr<Cairo::Context> cr = window->create_cairo_context();
// clip to the area indicated by the expose event so that we only redraw
// the portion of the window that needs to be redrawn
//cr -> set_source_rgba(0 , 0, 0 , 1);
cr->rectangle(event->area.x, event->area.y,
event->area.width, event->area.height);
//cr->rectangle(0,0,event->area.x,event->area.y);
//cr->stroke_preserve();
cr->clip();
cr -> set_line_join (Cairo::LINE_JOIN_ROUND);
cr -> move_to( 7, 7);
cr -> line_to( width-7, 7);
cr -> line_to( width-7, height-7);
cr -> line_to( 7, height-7);
cr -> close_path();
// Draw outline shape
cr -> set_source_rgb (0.1,0.1,0.1);
cr -> fill_preserve();
if (!padOnBool)
{
cr->set_source_rgba( 0.6, 0.6, 0.6, 0.5);
cr->set_line_width ( 10.0);
cr->stroke();
}
else
{
cr->set_source_rgba( 1.0,0.4,0.0, 0.8);
cr->set_line_width ( 10.4);
cr->stroke();
}
/* Pan functionality Not yet implemented in sampler.
// Draw Pan line: pixel pan = width * pan
cr -> set_line_cap (Cairo::LINE_CAP_ROUND);
cr -> set_line_width ( 4.8);
cr -> set_source_rgba( 1.0,0.8,0.8,0.8);
cr -> move_to ( width/2 + ((width*pan)/2) , height - (height*volume) + 20);
cr -> line_to ( width/2 + ((width*pan)/2) , height - (height*volume) - 20);
cr -> stroke();
*/
// Draw Volume line: pixel vol = height * volume
cr -> set_line_width ( 5.1);
cr -> set_source_rgb( 0.2,0.2,0.2);
cr -> move_to ( 10 , (height - ((height-20)*volume))-8 );
cr -> line_to ( width-10, (height - ((height-20)*volume))-8 );
cr -> line_to ( width-10, height-10);
cr -> line_to ( 10, height-10);
cr -> close_path();
cr -> fill();
// Draw Mode: Loop/Hit
if ( !loopSampleBool)
{
cr->set_line_width ( 2.2);
cr->set_source_rgb(0.2,0.2,0.2);
cr->move_to(width/5,(height/5)*2);
cr->line_to((width/5)*3,(height/5)*2);
cr->line_to((width/5)*3,(height/5)*1);
cr->line_to((width/5)*4,height/2); // point of arrow
cr->line_to((width/5)*3,(height/5)*4);
cr->line_to((width/5)*3,(height/5)*3);
cr->line_to(width/5,(height/5)*3);
cr->close_path();
cr->fill_preserve();
cr->set_source_rgb(0.0,0.9,0.0);
cr->stroke();
}
else // Loop Sample
{
cr -> set_source_rgb(0.2,0.2,0.2);
cr -> arc_negative (width/2, height/2, ((height + width)/8)-5 , 6.0, 0.6); // inner curve
cr -> arc (width/2, height/2, ((height + width)/6)-5 , 0.5, 6.1); // outer curve
cr -> line_to ((width-width/3.5) + width/8 , height/2 - height/18 ); // right point of arrow
cr -> line_to ( width-width/3.5, height/2 + height/18 ); // point of arrow
cr -> line_to ((width-width/3.5) - width/8 , height/2 - height/18 ); // left point of arrow
cr -> close_path();
cr -> fill_preserve();
cr -> set_line_width(1.9);
cr -> set_source_rgb(0.0,0.9,0.0);
cr -> stroke();
}
// Impose orange volume line (over SampleLoop/Play)
cr -> move_to ( 10 , (height - ((height-20)*volume))-8 );
cr -> line_to ( width-10, (height - ((height-20)*volume))-8 );
cr -> set_source_rgb(1.0,0.4,0.0);
cr -> stroke();
// Draw Text in center. Audio Clip name.
cr -> set_source_rgb( 1.0,0.4,0.0);
cr -> select_font_face ("Impact" , Cairo::FONT_SLANT_NORMAL,Cairo::FONT_WEIGHT_NORMAL);
cr -> set_font_size ( 3 + xc/4 );
Cairo::TextExtents extents;
std::transform(sampleName.begin(), sampleName.end(), sampleName.begin(), toupper);
cr -> get_text_extents(sampleName, extents);
cr -> move_to ( xc - extents.width/2 , height/2+height/18);
cr -> show_text (sampleName); // sampleName defined in hpp as std::string
}
return true;
}
void area___::test__(){
int width, height;
width=da_->get_allocation().get_width();
height=da_->get_allocation().get_height();
double m_radius=0.42;
double m_line_width=0.05;
// scale to unit square and translate (0, 0) to be (0.5, 0.5), i.e.
// the center of the window
cr_->scale(width, height);
cr_->translate(0.5, 0.5);
cr_->set_line_width(m_line_width);
cr_->save();
cr_->set_source_rgba(0.337, 0.612, 0.117, 0.9); // green
cr_->paint();
cr_->restore();
cr_->arc(0, 0, m_radius, 0, 2 * M_PI);
cr_->save();
cr_->set_source_rgba(1.0, 1.0, 1.0, 0.8);
cr_->fill_preserve();
cr_->restore();
cr_->stroke_preserve();
cr_->clip();
//clock ticks
for (int i = 0; i < 12; i++)
{
double inset = 0.05;
cr_->save();
cr_->set_line_cap(Cairo::LINE_CAP_ROUND);
if(i % 3 != 0)
{
inset *= 0.8;
cr_->set_line_width(0.03);
}
cr_->move_to(
(m_radius - inset) * cos (i * M_PI / 6),
(m_radius - inset) * sin (i * M_PI / 6));
cr_->line_to (
m_radius * cos (i * M_PI / 6),
m_radius * sin (i * M_PI / 6));
cr_->stroke();
cr_->restore(); // stack-pen-size
}
// store the current time
time_t rawtime;
time(&rawtime);
struct tm * timeinfo = localtime (&rawtime);
// compute the angles of the indicators of our clock
double minutes = timeinfo->tm_min * M_PI / 30;
double hours = timeinfo->tm_hour * M_PI / 6;
double seconds= timeinfo->tm_sec * M_PI / 30;
cout<<timeinfo->tm_min<<","<<timeinfo->tm_hour<<","<<timeinfo->tm_sec<<endl;
cr_->save();
cr_->set_line_cap(Cairo::LINE_CAP_ROUND);
// draw the seconds hand
cr_->save();
cr_->set_line_width(m_line_width / 3);
cr_->set_source_rgba(0.7, 0.7, 0.7, 0.8); // gray
cr_->move_to(0, 0);
cr_->line_to(sin(seconds) * (m_radius * 0.9),
-cos(seconds) * (m_radius * 0.9));
cr_->stroke();
cr_->restore();
// draw the minutes hand
cr_->set_source_rgba(0.117, 0.337, 0.612, 0.9); // blue
cr_->move_to(0, 0);
cr_->line_to(sin(minutes + seconds / 60) * (m_radius * 0.8),
-cos(minutes + seconds / 60) * (m_radius * 0.8));
cr_->stroke();
// draw the hours hand
cr_->set_source_rgba(0.337, 0.612, 0.117, 0.9); // green
cr_->move_to(0, 0);
cr_->line_to(sin(hours + minutes / 12.0) * (m_radius * 0.5),
-cos(hours + minutes / 12.0) * (m_radius * 0.5));
cr_->stroke();
cr_->restore();
// draw a little dot in the middle
cr_->arc(0, 0, m_line_width / 3.0, 0, 2 * M_PI);
cr_->fill();
}
void fill_preserve__(){
cr_->fill_preserve();
}
void
Renderer_Ducks::render_vfunc(
const Glib::RefPtr<Gdk::Drawable>& drawable,
const Gdk::Rectangle& /*expose_area*/
)
{
assert(get_work_area());
if(!get_work_area())
return;
const synfig::Point window_start(get_work_area()->get_window_tl());
const float pw(get_pw()),ph(get_ph());
const bool solid_lines(get_work_area()->solid_lines);
bool alternative = get_work_area()->get_alternative_mode();
const std::list<etl::handle<Duckmatic::Bezier> >& bezier_list(get_work_area()->bezier_list());
const std::list<handle<Duckmatic::Stroke> >& stroke_list(get_work_area()->stroke_list());
Glib::RefPtr<Pango::Layout> layout(Pango::Layout::create(get_work_area()->get_pango_context()));
Cairo::RefPtr<Cairo::Context> cr = drawable->create_cairo_context();
cr->save();
cr->set_line_cap(Cairo::LINE_CAP_BUTT);
cr->set_line_join(Cairo::LINE_JOIN_MITER);
// Render the strokes
for(std::list<handle<Duckmatic::Stroke> >::const_iterator iter=stroke_list.begin();iter!=stroke_list.end();++iter)
{
cr->save();
std::list<synfig::Point>::iterator iter2;
for(iter2=(*iter)->stroke_data->begin();iter2!=(*iter)->stroke_data->end();++iter2)
{
cr->line_to(
((*iter2)[0]-window_start[0])/pw,
((*iter2)[1]-window_start[1])/ph
);
}
cr->set_line_width(1.0);
cr->set_source_rgb(
colorconv_synfig2gdk((*iter)->color).get_red_p(),
colorconv_synfig2gdk((*iter)->color).get_green_p(),
colorconv_synfig2gdk((*iter)->color).get_blue_p()
);
cr->stroke();
cr->restore();
}
// Render the beziers
for(std::list<handle<Duckmatic::Bezier> >::const_iterator iter=bezier_list.begin();iter!=bezier_list.end();++iter)
{
Point p1((*iter)->p1->get_trans_point()-window_start);
Point p2((*iter)->p2->get_trans_point()-window_start);
Point c1((*iter)->c1->get_trans_point()-window_start);
Point c2((*iter)->c2->get_trans_point()-window_start);
p1[0]/=pw;p1[1]/=ph;
p2[0]/=pw;p2[1]/=ph;
c1[0]/=pw;c1[1]/=ph;
c2[0]/=pw;c2[1]/=ph;
cr->save();
cr->move_to(p1[0], p1[1]);
cr->curve_to(c1[0], c1[1], c2[0], c2[1], p2[0], p2[1]);
/*
if (solid_lines)
{
cr->set_source_rgb(0,0,0); // DUCK_COLOR_BEZIER_1
cr->set_line_width(3.0);
cr->stroke_preserve();
cr->set_source_rgb(175.0/255.0,175.0/255.0,175.0/255.0); //DUCK_COLOR_BEZIER_2
cr->set_line_width(1.0);
cr->stroke();
}
else
*/
{
//Solid line background
cr->set_line_width(1.0);
cr->set_source_rgb(0,0,0); // DUCK_COLOR_BEZIER_1
cr->stroke_preserve();
//Dashes
cr->set_source_rgb(175.0/255.0,175.0/255.0,175.0/255.0); //DUCK_COLOR_BEZIER_2
std::valarray<double> dashes(2);
dashes[0]=5.0;
dashes[1]=5.0;
cr->set_dash(dashes, 0);
cr->stroke();
}
cr->restore();
}
const DuckList duck_list(get_work_area()->get_duck_list());
std::list<ScreenDuck> screen_duck_list;
const float radius((abs(pw)+abs(ph))*4);
etl::handle<Duck> hover_duck(get_work_area()->find_duck(get_work_area()->get_cursor_pos(),radius, get_work_area()->get_type_mask()));
// Render the ducks
for(std::list<handle<Duck> >::const_iterator iter=duck_list.begin();iter!=duck_list.end();++iter)
{
// If this type of duck has been masked, then skip it
if(!(*iter)->get_type() || (!(get_work_area()->get_type_mask() & (*iter)->get_type())))
continue;
Point sub_trans_point((*iter)->get_sub_trans_point());
Point sub_trans_origin((*iter)->get_sub_trans_origin());
if (App::restrict_radius_ducks &&
(*iter)->is_radius())
{
if (sub_trans_point[0] < sub_trans_origin[0])
sub_trans_point[0] = sub_trans_origin[0];
if (sub_trans_point[1] < sub_trans_origin[1])
sub_trans_point[1] = sub_trans_origin[1];
}
Point point((*iter)->get_transform_stack().perform(sub_trans_point));
Point origin((*iter)->get_transform_stack().perform(sub_trans_origin));
point[0]=(point[0]-window_start[0])/pw;
point[1]=(point[1]-window_start[1])/ph;
bool has_connect = (*iter)->get_tangent()
|| ((*iter)->get_type()&( Duck::TYPE_ANGLE
| Duck::TYPE_SKEW
| Duck::TYPE_SCALE_X
| Duck::TYPE_SCALE_Y ));
if((*iter)->get_connect_duck())
{
has_connect=true;
origin=(*iter)->get_connect_duck()->get_trans_point();
}
origin[0]=(origin[0]-window_start[0])/pw;
origin[1]=(origin[1]-window_start[1])/ph;
bool selected(get_work_area()->duck_is_selected(*iter));
bool hover(*iter==hover_duck || (*iter)->get_hover());
if(get_work_area()->get_selected_value_node())
{
synfigapp::ValueDesc value_desc((*iter)->get_value_desc());
if (value_desc.is_valid() &&
((value_desc.is_value_node() && get_work_area()->get_selected_value_node() == value_desc.get_value_node()) ||
(value_desc.parent_is_value_node() && get_work_area()->get_selected_value_node() == value_desc.get_parent_value_node())))
{
cr->save();
cr->rectangle(
round_to_int(point[0]-5),
round_to_int(point[1]-5),
10,
10
);
cr->set_line_width(2.0);
cr->set_source_rgb(1, 0, 0); //DUCK_COLOR_SELECTED
cr->stroke();
cr->restore();
}
}
if((*iter)->get_box_duck())
{
Point boxpoint((*iter)->get_box_duck()->get_trans_point());
boxpoint[0]=(boxpoint[0]-window_start[0])/pw;
boxpoint[1]=(boxpoint[1]-window_start[1])/ph;
Point tl(min(point[0],boxpoint[0]),min(point[1],boxpoint[1]));
cr->save();
cr->rectangle(
round_to_int(tl[0]),
round_to_int(tl[1]),
round_to_int(abs(boxpoint[0]-point[0])),
round_to_int(abs(boxpoint[1]-point[1]))
);
// Solid white box
cr->set_line_width(1.0);
cr->set_source_rgb(1,1,1); //DUCK_COLOR_BOX_1
cr->stroke_preserve();
// Dashes
cr->set_source_rgb(0,0,0); //DUCK_COLOR_BOX_2
std::valarray<double> dashes(2);
dashes[0]=5.0;
dashes[1]=5.0;
cr->set_dash(dashes, 0);
cr->stroke();
cr->restore();
}
if((*iter)->is_axes_tracks())
{
Point pos((*iter)->get_point());
Point points[] = {
(*iter)->get_sub_trans_origin(),
(*iter)->get_sub_trans_point(Point(pos[0],0)),
(*iter)->get_sub_trans_point(),
(*iter)->get_sub_trans_point(Point(0,pos[1])),
(*iter)->get_sub_trans_origin()
};
cr->save();
for(int i = 0; i < 5; i++) {
Point p((*iter)->get_transform_stack().perform(points[i]));
Real x = (p[0]-window_start[0])/pw;
Real y = (p[1]-window_start[1])/ph;
if (i == 0) cr->move_to(x, y); else cr->line_to(x, y);
}
// Solid white box
cr->set_line_width(1.0);
cr->set_source_rgb(1,1,1); //DUCK_COLOR_BOX_1
cr->stroke_preserve();
// Dashes
cr->set_source_rgb(0,0,0); //DUCK_COLOR_BOX_2
std::valarray<double> dashes(2);
dashes[0]=5.0;
dashes[1]=5.0;
cr->set_dash(dashes, 0);
cr->stroke();
cr->restore();
}
ScreenDuck screen_duck;
screen_duck.pos=point;
screen_duck.selected=selected;
screen_duck.hover=hover;
screen_duck.has_alternative=(*iter)->get_alternative_value_desc().is_valid();
if(!(*iter)->get_editable(alternative))
screen_duck.color=(DUCK_COLOR_NOT_EDITABLE);
else if((*iter)->get_tangent())
if(0){
// Tangents have different color depending on the split state (disabled for now)
//
// Check if we can reach the canvas and set the time to
// evaluate the split value accordingly
synfig::Canvas::Handle canvas_h(get_work_area()->get_canvas());
synfig::Time time(canvas_h?canvas_h->get_time():synfig::Time(0));
// Retrieve the split value of the bline point.
const synfigapp::ValueDesc& v_d((*iter)->get_value_desc());
synfig::LinkableValueNode::Handle parent;
if(v_d.parent_is_linkable_value_node())
{
parent=v_d.get_parent_value_node();
bool split;
synfig::ValueNode::Handle child(parent->get_link("split"));
if(synfig::ValueNode_Animated::Handle::cast_dynamic(child))
{
synfig::ValueNode_Animated::Handle animated_child(synfig::ValueNode_Animated::Handle::cast_dynamic(child));
split=animated_child->new_waypoint_at_time(time).get_value(time).get(split);
}
else if(synfig::ValueNode_Const::Handle::cast_dynamic(child))
{
synfig::ValueNode_Const::Handle const_child(synfig::ValueNode_Const::Handle::cast_dynamic(child));
split=(const_child->get_value()).get(split);
}
screen_duck.color=(split? DUCK_COLOR_TANGENT_2 : DUCK_COLOR_TANGENT_1);
}
else
screen_duck.color=DUCK_COLOR_TANGENT_1;
} else {
// All tangents are the same color
screen_duck.color=((*iter)->get_scalar()<0 ? DUCK_COLOR_TANGENT_1 : DUCK_COLOR_TANGENT_1);
}
else if((*iter)->get_type()&Duck::TYPE_VERTEX)
screen_duck.color=DUCK_COLOR_VERTEX;
else if((*iter)->get_type()&Duck::TYPE_RADIUS)
screen_duck.color=((*iter)->is_linear() ? DUCK_COLOR_LINEAR : DUCK_COLOR_RADIUS);
else if((*iter)->get_type()&Duck::TYPE_WIDTH)
screen_duck.color=DUCK_COLOR_WIDTH;
else if((*iter)->get_type()&Duck::TYPE_ANGLE)
screen_duck.color=(DUCK_COLOR_ANGLE);
else if((*iter)->get_type()&Duck::TYPE_WIDTHPOINT_POSITION)
screen_duck.color=(DUCK_COLOR_WIDTHPOINT_POSITION);
else
screen_duck.color=DUCK_COLOR_OTHER;
screen_duck_list.push_front(screen_duck);
if(has_connect)
{
cr->save();
cr->move_to(origin[0], origin[1]);
cr->line_to(point[0], point[1]);
if(solid_lines)
{
// Outside
cr->set_line_width(3.0);
cr->set_source_rgb(0,0,0); //DUCK_COLOR_CONNECT_OUTSIDE
cr->stroke_preserve();
// Inside
cr->set_line_width(1.0);
cr->set_source_rgb(159.0/255,239.0/255,239.0/255); //DUCK_COLOR_CONNECT_INSIDE
cr->stroke();
}
else
{
// White background
cr->set_line_width(1.0);
cr->set_source_rgb(0,0,0); //DUCK_COLOR_CONNECT_OUTSIDE
cr->stroke_preserve();
// Dashes on top of the background
cr->set_source_rgb(159.0/255,239.0/255,239.0/255); //DUCK_COLOR_CONNECT_INSIDE
std::valarray<double> dashes(2);
dashes[0]=5.0;
dashes[1]=5.0;
cr->set_dash(dashes, 0);
cr->stroke();
}
cr->restore();
}
if((*iter)->is_radius())
{
if (!(*iter)->is_linear())
{
const Real mag((point-origin).mag());
cr->save();
cr->arc(
origin[0],
origin[1],
mag,
0,
M_PI*2
);
if(solid_lines)
{
cr->set_line_width(3.0);
cr->set_source_rgb(0,0,0);
cr->stroke_preserve();
cr->set_source_rgb(175.0/255.0,175.0/255.0,175.0/255.0);
}
else
{
cr->set_source_rgb(1.0,1.0,1.0);
// Operator difference was added in Cairo 1.9.4
// It currently isn't supported by Cairomm
#if CAIRO_VERSION >= 10904
cairo_set_operator(cr->cobj(), CAIRO_OPERATOR_DIFFERENCE);
#else
// Fallback: set color to black
cr->set_source_rgb(0,0,0);
#endif
}
cr->set_line_width(1.0);
cr->stroke();
cr->restore();
}
if(hover)
{
Real mag;
if ((*iter)->get_exponential()){
mag = log((*iter)->get_point().mag());
}
else if (App::restrict_radius_ducks)
{
Point sub_trans_point((*iter)->get_sub_trans_point());
Point sub_trans_origin((*iter)->get_sub_trans_origin());
if (sub_trans_point[0] < sub_trans_origin[0])
sub_trans_point[0] = sub_trans_origin[0];
if (sub_trans_point[1] < sub_trans_origin[1])
sub_trans_point[1] = sub_trans_origin[1];
Point point((*iter)->get_transform_stack().perform(sub_trans_point));
Point origin((*iter)->get_transform_stack().perform(sub_trans_origin));
mag = (point-origin).mag();
}
else
mag = ((*iter)->get_trans_point()-(*iter)->get_trans_origin()).mag();
Distance real_mag(mag, Distance::SYSTEM_UNITS);
if (!(*iter)->get_exponential())
real_mag.convert(App::distance_system,get_work_area()->get_rend_desc());
cr->save();
layout->set_text(real_mag.get_string());
cr->set_source_rgb(0,0,0); // DUCK_COLOR_WIDTH_TEXT_1
cr->move_to(
point[0]+1+6,
point[1]+1-8
);
layout->show_in_cairo_context(cr);
cr->stroke();
cr->set_source_rgb(1,0,1); // DUCK_COLOR_WIDTH_TEXT_2
cr->move_to(
point[0]+6,
point[1]-8
);
layout->show_in_cairo_context(cr);
cr->stroke();
cr->restore();
}
}
if((*iter)->get_type()&&Duck::TYPE_WIDTHPOINT_POSITION)
{
if(hover)
{
synfig::Canvas::Handle canvas_h(get_work_area()->get_canvas());
synfig::Time time(canvas_h?canvas_h->get_time():synfig::Time(0));
synfigapp::ValueDesc value_desc((*iter)->get_value_desc());
synfig::ValueNode_WPList::Handle wplist=NULL;
ValueNode_Composite::Handle wpoint_composite=NULL;
Real radius=0.0;
Real new_value;
Point p(sub_trans_point-sub_trans_origin);
if(value_desc.parent_is_value_node())
wplist=synfig::ValueNode_WPList::Handle::cast_dynamic(value_desc.get_parent_value_node());
if(wplist)
{
bool wplistloop(wplist->get_loop());
synfig::ValueNode_BLine::Handle bline(synfig::ValueNode_BLine::Handle::cast_dynamic(wplist->get_bline()));
wpoint_composite=ValueNode_Composite::Handle::cast_dynamic(value_desc.get_value_node());
if(bline && wpoint_composite)
{
bool blineloop(bline->get_loop());
bool homogeneous=false;
// Retrieve the homogeneous layer parameter
std::set<Node*>::iterator iter;
for(iter=wplist->parent_set.begin();iter!=wplist->parent_set.end();++iter)
{
Layer::Handle layer;
layer=Layer::Handle::cast_dynamic(*iter);
if(layer && layer->get_name() == "advanced_outline")
{
homogeneous=layer->get_param("homogeneous").get(bool());
break;
}
}
WidthPoint wp((*wpoint_composite)(time).get(WidthPoint()));
if(wplistloop)
{
// The wplist is looped. This may require a position parameter
// outside the range of 0-1, so make sure that the position doesn't
// change drastically.
// First normalise the current position
Real value_old(wp.get_norm_position(wplistloop));
Real value_old_b(wp.get_bound_position(wplistloop));
// If it is homogeneous then convert it to standard
value_old=homogeneous?hom_to_std((*bline)(time), value_old, wplistloop, blineloop):value_old;
// grab a new position given by duck's position on the bline
Real value_new = synfig::find_closest_point((*bline)(time), p , radius, blineloop);
// calculate the difference between old and new positions
Real difference = fmod( fmod(value_new - value_old, 1.0) + 1.0 , 1.0);
//fmod is called twice to avoid negative values
if (difference > 0.5)
difference=difference-1.0;
// calculate a new value for the position
new_value=value_old+difference;
// restore the homogeneous value if needed
new_value = homogeneous?std_to_hom((*bline)(time), new_value, wplistloop, blineloop):new_value;
// this is the difference between the new value and the old value inside the boundaries
Real bound_diff((wp.get_lower_bound() + new_value*(wp.get_upper_bound()-wp.get_lower_bound()))-value_old_b);
// add the new diff to the current value
new_value = wp.get_position() + bound_diff;
}
else
{
// grab a new position given by duck's position on the bline
new_value = synfig::find_closest_point((*bline)(time), p , radius, blineloop);
// if it is homogeneous then convert to it
new_value=homogeneous?std_to_hom((*bline)(time), new_value, wplistloop, blineloop):new_value;
// convert the value inside the boundaries
new_value = wp.get_lower_bound()+new_value*(wp.get_upper_bound()-wp.get_lower_bound());
}
cr->save();
layout->set_text(strprintf("%2.3f", new_value));
cr->set_source_rgb(0,0,0); // DUCK_COLOR_WIDTH_TEXT_1
cr->move_to(
point[0]+1+6,
point[1]+1-18
);
layout->show_in_cairo_context(cr);
cr->stroke();
cr->set_source_rgb(1,0,1); // DUCK_COLOR_WIDTH_TEXT_2
cr->move_to(
point[0]+6,
point[1]-18
);
layout->show_in_cairo_context(cr);
cr->stroke();
cr->restore();
}
}
}
}
}
for(;screen_duck_list.size();screen_duck_list.pop_front())
{
Gdk::Color color(screen_duck_list.front().color);
double radius = 4;
double outline = 1;
bool duck_alternative = alternative && screen_duck_list.front().has_alternative;
// Draw the hovered duck last (on top of everything)
if(screen_duck_list.front().hover && !screen_duck_list.back().hover && screen_duck_list.size()>1)
{
screen_duck_list.push_back(screen_duck_list.front());
continue;
}
cr->save();
if(!screen_duck_list.front().selected)
{
color.set_red(color.get_red()*2/3);
color.set_green(color.get_green()*2/3);
color.set_blue(color.get_blue()*2/3);
}
if(screen_duck_list.front().hover)
{
radius += 1;
outline += 1;
}
cr->arc(
screen_duck_list.front().pos[0],
screen_duck_list.front().pos[1],
radius,
0,
M_PI*2
);
cr->set_source_rgba(
color.get_red_p(),
color.get_green_p(),
color.get_blue_p(),
duck_alternative ? 0.5 : 1.0
);
cr->fill_preserve();
cr->set_line_width(outline);
cr->set_source_rgba(0,0,0,1); //DUCK_COLOR_OUTLINE
cr->stroke();
cr->restore();
}
}
void FrequencyGraph( Cairo::RefPtr<Cairo::Context> cr, bool active, float x, float y, float xS, float yS, EqualizerState state)
{
cr->set_line_cap( Cairo::LINE_CAP_ROUND );
cr->set_line_join( Cairo::LINE_JOIN_ROUND);
int xSize = xS;
int ySize = yS;
// works but a bit simple
cr -> move_to( x , y );
cr -> line_to( x + xSize, y );
cr -> line_to( x + xSize, y + ySize );
cr -> line_to( x , y + ySize );
cr -> close_path();
// Draw outline shape
cr -> set_source_rgb (0.1,0.1,0.1);
cr -> fill();
// draw "frequency guides"
std::valarray< double > dashes(2);
dashes[0] = 2.0;
dashes[1] = 2.0;
cr->set_dash (dashes, 0.0);
cr->set_line_width(1.0);
cr->set_source_rgb (0.4,0.4,0.4);
for ( int i = 0; i < 4; i++ )
{
cr->move_to( x + ((xSize / 4.f)*i), y );
cr->line_to( x + ((xSize / 4.f)*i), y + ySize );
}
for ( int i = 0; i < 4; i++ )
{
cr->move_to( x , y + ((ySize / 4.f)*i) );
cr->line_to( x +xSize, y + ((ySize / 4.f)*i) );
}
cr->stroke();
cr->unset_dash();
// set colour based on active or not
if ( active )
setColour(cr, COLOUR_BLUE_1, 0.2 );
else
setColour(cr, COLOUR_GREY_1, 0.2 );
int tmpX = x;
int tmpY = y;
// precalculate some variables
float oldGainPix = (ySize / 60.f) * (state.gain[0] - 0.5 ) * 40;
float oldXLoc = 0;
float qPix = ((xSize * 0.2) / 3.f );
//float oldCutoff = 0;
// move to bottom left, draw line to middle left
cr->move_to( tmpX, tmpY + ySize );
cr->line_to( tmpX, tmpY + (ySize * 0.5) - oldGainPix );
for ( int i = 0; i < 4; i++ )
{
//float cutoff = state.cutoffFreq[i] / 20000;
float gainPix = (ySize / 60.f) * (state.gain[i] - 0.5 ) * 40;
float xLoc = xSize * 0.2 * (i+1);
//std::cout << "I: " << i << " GainPix: " << gainPix << " tmpY - gainPix" << tmpY - gainPix << std::endl;
cr->curve_to( tmpX + oldXLoc + qPix, tmpY + (ySize * 0.5) - oldGainPix ,// control point 1
tmpX + xLoc - qPix , tmpY + (ySize * 0.5) - gainPix , // control point 2
tmpX + xLoc , tmpY + (ySize * 0.5) - gainPix ); // end of curve
// update variables for next iter
oldGainPix = gainPix;
oldXLoc = xLoc;
//oldCutoff = cutoff;
}
// last bit of curve to the right edge
cr->curve_to( tmpX + oldXLoc + qPix, tmpY + (ySize * 0.5) - oldGainPix, // control point 1
tmpX + xSize - qPix, tmpY + (ySize * 0.5) - oldGainPix, // control point 2
tmpX + xSize , tmpY + (ySize * 0.5) - oldGainPix); // end of curve
cr->line_to( tmpX + xSize , tmpY + ySize );
cr->close_path();
cr->fill_preserve();
cr->set_line_width(2.5);
if ( active )
setColour(cr, COLOUR_BLUE_1 );
else
setColour(cr, COLOUR_GREY_1 );
cr->stroke();
// outline
cr->rectangle( x, y , xS, yS );
cr->set_line_width(3);
if ( active )
setColour(cr, COLOUR_GREY_2 );
else
setColour(cr, COLOUR_GREY_3 );
cr->stroke();
//std::cout << "LupppWidget::FrequencyGraph() called!" << std::endl;
}
bool ClockDrawArea::on_draw(const Cairo::RefPtr<Cairo::Context>& context){
//Get the drawing area
auto allocation = get_allocation();
const int width = allocation.get_width();
const int height = allocation.get_height();
//Set the scale to a unit square
context->scale(width, height);
//Set (0.5, 0.5) to (0, 0). convenient to draw with arc.
context->translate(0.5, 0.5);
//Paint the background of the window;
context->save();
context->set_source_rgba(0.337, 0.612, 0.117, 0.9);
context->paint();
context->restore();
//Draw the outer edge of the clock
context->set_line_width(3 * m_LineWidth);
context->arc(0, 0, m_Radius, 0, 2 * M_PI);
//Paint the background color of the clock
context->save();
context->set_source_rgba(1.0, 1.0, 1.0, 0.8);
context->fill_preserve();
context->restore();
//Draw a center point for good looking
context->stroke();
context->arc(0, 0, 0.05 * m_Radius, 0, 2 * M_PI);
context->stroke();
//Draw ticks
context->save();
double l = 1;
for(int i = 0; i <= 11; i++){
if((i % 3) == 0) {
l = m_Radius * 0.8;
}else{
l = m_Radius * 0.9;
}
context->move_to(l * cos(i * 2* M_PI /12), l * sin(i * 2 * M_PI /12));
context->line_to(m_Radius * cos(i * 2 * M_PI /12), m_Radius * sin(i * 2 * M_PI /12));
}
context->stroke();
context->restore();
//Get the current time from system and save info to a timeinfo struct
time_t rawTime;
time(&rawTime);
struct tm * timeinfo = localtime(&rawTime);
//Calculate the angle of hands of the clock
auto radSeconds = (timeinfo->tm_sec * 2 * M_PI /60) - M_PI/2;
auto radMinutes = (timeinfo->tm_min * 2 * M_PI /60) - M_PI/2;
auto radHours = (timeinfo->tm_hour * 2 * M_PI /12) - M_PI/2 + timeinfo->tm_min * 2 * M_PI /(60 * 12);
//Draw the hands of the clock
context->save();
//The hand of seconds
context->set_source_rgba(0.823, 0.322, 0.155, 0.9);
context->set_line_width(m_LineWidth);
l = 0.9 * m_Radius;
context->move_to(0,0);
context->line_to(l * cos(radSeconds), l * sin(radSeconds));
context->stroke();
//The hand of minutes
context->set_source_rgba(0.632, 0.802, 0.266, 0.9);
context->set_line_width(2 * m_LineWidth);
l = 0.8 * m_Radius;
context->move_to(0,0);
context->line_to(l * cos(radMinutes), l * sin(radMinutes));
context->stroke();
//The hand of hours
context->set_source_rgba(0.104, 0.582, 0.723, 0.9);
context->set_line_width(3 * m_LineWidth);
l = 0.65 * m_Radius;
context->move_to(0,0);
context->line_to(l * cos(radHours), l * sin(radHours));
context->stroke();
context->restore();
return true;
}
void MyWidget::drawWidget()
{
Painter p(this);
if (m_color) {
p.setSourceRGB(1.0, 0, 0);
} else {
p.setSourceRGB(0, 0, 0);
}
p.translate(minimumSize().width() / 2.0, minimumSize().height() / 2.0);
p.setLineWidth(m_lineWidth);
p.arc(0, 0, m_radius, 0, 2 * M_PI);
p.save();
p.setSourceRGBA(1.0, 1.0, 1.0, 0.8);
p.fillPreserve();
p.restore();
p.strokePreserve();
p.clip();
for (int i = 0; i < 12; ++i) {
double inset = 30;
p.save();
p.setLineCap(Painter::RoundLineCap);
if(i % 3 != 0) {
inset *= 0.8;
p.setLineWidth(1.0);
}
p.moveTo((m_radius - inset) * cos (i * M_PI / 6.0),
(m_radius - inset) * sin (i * M_PI / 6.0));
p.lineTo(m_radius * cos (i * M_PI / 6.0),
m_radius * sin (i * M_PI / 6.0));
p.stroke();
p.restore();
}
// store the current time
time_t rawtime;
time(&rawtime);
struct tm * timeinfo = localtime (&rawtime);
// compute the angles of the indicators of our clock
double minutes = timeinfo->tm_min * M_PI / 30;
double hours = timeinfo->tm_hour * M_PI / 6;
double seconds= timeinfo->tm_sec * M_PI / 30;
p.save();
p.setLineCap(Painter::RoundLineCap);
// draw the seconds hand
p.save();
p.setLineWidth(m_lineWidth);
p.setSourceRGBA(0.7, 0.7, 0.7, 0.8);
p.moveTo(0, 0);
p.lineTo(sin(seconds) * (m_radius * 0.9),
-cos(seconds) * (m_radius * 0.9));
p.stroke();
p.restore();
// draw the minutes hand
p.setSourceRGBA(0.117, 0.337, 0.612, 0.9);
p.moveTo(0, 0);
p.lineTo(sin(minutes + seconds / 60.0) * (m_radius * 0.8),
-cos(minutes + seconds / 60.0) * (m_radius * 0.8));
p.stroke();
// draw the hours hand
p.setSourceRGBA(0.337, 0.612, 0.117, 0.9);
p.moveTo(0, 0);
p.lineTo(sin(hours + minutes / 12.0) * (m_radius * 0.5),
-cos(hours + minutes / 12.0) * (m_radius * 0.5));
p.stroke();
p.restore();
p.setSourceRGBA(1, 0, 0, 0.5);
p.arc(0, 0, m_lineWidth * 2.0, 0, 2.0 * M_PI);
p.fill();
#if 0
// This is where we draw on the window
Glib::RefPtr<Gdk::Window> window = get_window();
if(window)
{
Gtk::Allocation allocation = get_allocation();
const int width = allocation.get_width();
const int height = allocation.get_height();
Cairo::RefPtr<Cairo::Context> cr = window->create_cairo_context();
if(event)
{
// clip to the area indicated by the expose event so that we only
// redraw the portion of the window that needs to be redrawn
cr->rectangle(event->area.x, event->area.y,
event->area.width, event->area.height);
cr->clip();
}
// background gradient
{
Cairo::RefPtr<Cairo::LinearGradient> pat = Cairo::LinearGradient::create(0.0, 0.0, 0.0, height);
pat->add_color_stop_rgb(1.0, 1.0, 1.0, 1.0);
pat->add_color_stop_rgb(0.0, 0.0, 0.0, 0.0);
cr->rectangle(0, 0, width, height);
cr->set_source(pat);
cr->fill();
}
// scale to unit square and translate (0, 0) to be (0.5, 0.5), i.e.
// the center of the window
cr->scale(width, height);
cr->translate(0.5, 0.5);
cr->set_line_width(m_line_width);
cr->arc(0, 0, m_radius, 0, 2 * M_PI);
cr->save();
cr->set_source_rgba(1.0, 1.0, 1.0, 0.8);
cr->fill_preserve();
cr->restore();
cr->stroke_preserve();
cr->clip();
//clock ticks
for (int i = 0; i < 12; i++)
{
double inset = 0.05;
cr->save();
cr->set_line_cap(Cairo::LINE_CAP_ROUND);
if(i % 3 != 0)
{
inset *= 0.8;
cr->set_line_width(0.03);
}
cr->move_to(
(m_radius - inset) * cos (i * M_PI / 6),
(m_radius - inset) * sin (i * M_PI / 6));
cr->line_to (
m_radius * cos (i * M_PI / 6),
m_radius * sin (i * M_PI / 6));
cr->stroke();
cr->restore(); /* stack-pen-size */
}
// store the current time
time_t rawtime;
time(&rawtime);
struct tm * timeinfo = localtime (&rawtime);
// compute the angles of the indicators of our clock
double minutes = timeinfo->tm_min * M_PI / 30;
double hours = timeinfo->tm_hour * M_PI / 6;
double seconds= timeinfo->tm_sec * M_PI / 30;
cr->save();
cr->set_line_cap(Cairo::LINE_CAP_ROUND);
// draw the seconds hand
cr->save();
cr->set_line_width(m_line_width / 3);
cr->set_source_rgba(0.7, 0.7, 0.7, 0.8); // gray
cr->move_to(0, 0);
cr->line_to(sin(seconds) * (m_radius * 0.9),
-cos(seconds) * (m_radius * 0.9));
cr->stroke();
cr->restore();
// draw the minutes hand
cr->set_source_rgba(0.117, 0.337, 0.612, 0.9); // blue
cr->move_to(0, 0);
cr->line_to(sin(minutes + seconds / 60) * (m_radius * 0.8),
-cos(minutes + seconds / 60) * (m_radius * 0.8));
cr->stroke();
// draw the hours hand
cr->set_source_rgba(0.337, 0.612, 0.117, 0.9); // green
cr->move_to(0, 0);
cr->line_to(sin(hours + minutes / 12.0) * (m_radius * 0.5),
-cos(hours + minutes / 12.0) * (m_radius * 0.5));
cr->stroke();
cr->restore();
// draw a little dot in the middle
cr->arc(0, 0, m_line_width / 3.0, 0, 2 * M_PI);
cr->fill();
}
#endif
}
bool GHighPass::on_expose_event(GdkEventExpose* event)
{
// This is where we draw on the window
Glib::RefPtr<Gdk::Window> window = get_window();
if(window) // Only run if Window does exist
{
Gtk::Allocation allocation = get_allocation();
int width = allocation.get_width();
int height = allocation.get_height();
// clip to the area indicated by the expose event so that we only redraw
// the portion of the window that needs to be redrawn
Cairo::RefPtr<Cairo::Context> cr = window->create_cairo_context();
cr->rectangle(event->area.x, event->area.y,
event->area.width, event->area.height);
cr->clip();
cr->rectangle(event->area.x, event->area.y,
event->area.width, event->area.height);
setColour(cr, COLOUR_GREY_3 );
cr->fill();
//cout << "HighPass getting state ID " << ID << endl;
float cutoffRangeZeroOne = stateStore->effectState.at(ID).values[0];
cutoff = cutoffRangeZeroOne;
bool active = stateStore->effectState.at(ID).active;
bool globalUnit = stateStore->effectState.at(ID).globalUnit;
int x = 0;
int y = 0;
xSize = 73;
ySize = 37;
// works but a bit simple
cr -> move_to( x , y );
cr -> line_to( x + xSize, y );
cr -> line_to( x + xSize, y + ySize );
cr -> line_to( x , y + ySize );
cr -> close_path();
// Draw outline shape
cr -> set_source_rgb (0.1,0.1,0.1);
cr -> fill();
// draw "frequency guides"
std::valarray< double > dashes(2);
dashes[0] = 2.0;
dashes[1] = 2.0;
cr->set_dash (dashes, 0.0);
cr->set_line_width(1.0);
cr->set_source_rgb (0.4,0.4,0.4);
for ( int i = 0; i < 3; i++ )
{
cr->move_to( x + ((xSize / 3.f)*i), y );
cr->line_to( x + ((xSize / 3.f)*i), y + ySize );
}
for ( int i = 0; i < 3; i++ )
{
cr->move_to( x , y + ((ySize / 3.f)*i) );
cr->line_to( x +xSize, y + ((ySize / 3.f)*i) );
}
cr->stroke();
cr->unset_dash();
// move to bottom left, draw line to middle left
cr->move_to( x + xSize-2 , y + ySize );
cr->line_to( x + xSize-2 , y + (ySize/2));
int startHorizontalLine = xSize* (cutoff + 0.4);
if ( startHorizontalLine > 75 )
startHorizontalLine = 75;
cr->line_to( startHorizontalLine, y + (ySize/2) ); // horizontal line to start of curve
int xSize1CP1 = xSize* (cutoff +0.1);
int xSize1CP2 = xSize* (cutoff +0.08);
int xSize1End = xSize* cutoff;
if ( xSize1CP1 > 75 )
xSize1CP1 = 75;
if ( xSize1CP2 > 75 )
xSize1CP2 = 75;
if ( xSize1End > 75 )
xSize1End = 75;
cr->curve_to( xSize1CP1, y+(ySize*0.5), // control point 1
xSize1CP2, y+(ySize*0.3), // control point 2
xSize1End, y+(ySize*0.3)); // end of curve 1, start curve 2
int xSize2CP1 = xSize* (cutoff - 0.03);
int xSize2CP2 = xSize* (cutoff - 0.08);
int xSize2End = xSize* (cutoff - 0.15);
if ( xSize2CP1 > 75 )
xSize2CP1 = 75;
if ( xSize2CP2 > 75 )
xSize2CP2 = 75;
if ( xSize2End > 75 )
xSize2End = 75;
cr->curve_to( xSize2CP1, y+(ySize*0.3), // control point 1
xSize2CP2, y+(ySize*0.3), // control point 2
xSize2End, y+(ySize) ); // end of curve on floor
if (active)
setColour(cr, COLOUR_BLUE_1, 0.2 );
else
setColour(cr, COLOUR_GREY_1, 0.2 );
cr->close_path();
cr->fill_preserve();
// stroke cutoff line
cr->set_line_width(2.5);
if ( active )
setColour(cr, COLOUR_BLUE_1 );
else
setColour(cr, COLOUR_GREY_1 );
cr->stroke();
// click center
if ( globalUnit )
{
if ( active )
setColour(cr, COLOUR_GREEN_1, 0.9 );
else
setColour(cr, COLOUR_GREY_1,0.9 );
cr->move_to( xSize * cutoff - 5, ySize*q - 5 );
cr->line_to( xSize * cutoff + 5, ySize*q + 5 );
cr->move_to( xSize * cutoff - 5, ySize*q + 5 );
cr->line_to( xSize * cutoff + 5, ySize*q - 5 );
cr->stroke();
}
else
{
if ( active )
setColour(cr, COLOUR_ORANGE_1, 0.9 );
else
setColour(cr, COLOUR_GREY_1, 0.9 );
cr->arc( xSize*cutoff, ySize*q, 7, 0, 6.2830 );
cr->stroke();
}
// dials
Dial(cr, active, 70, 140, cutoffRangeZeroOne, DIAL_MODE_NORMAL);
Dial(cr, active, 150,140, q , DIAL_MODE_NORMAL);
// outline
setColour(cr, COLOUR_GREY_3 );
cr->rectangle( x, y , xSize, ySize );
cr->set_line_width(3);
setColour(cr, COLOUR_GREY_2 );
cr->stroke();
/*
if ( state.selected )
{
cr->rectangle(0, 0, 74, 216);
setColour( cr, COLOUR_PURPLE_1 );
cr->set_line_width(1);
cr->stroke();
}
*/
}
return true;
}