// ----------------------------------------------------------------------------
// -- 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;
}
void
Operation::draw_patient_info(const Glib::RefPtr<Gtk::PrintContext>& print)
{
Cairo::RefPtr<Cairo::Context> cairo = print->get_cairo_context();
Glib::RefPtr<Pango::Layout> layout = print->create_pango_layout();
Pango::FontDescription font_desc("sans 12");
layout->set_font_description(font_desc);
layout->set_width(width_ * Pango::SCALE);
DICOM::SummaryInfo* info = const_cast<DICOM::SummaryInfo*>(&dicom_info_);
DICOM::PatientInfo* patient = info->get_patient_info();
//Set and mark up the text to print:
Glib::ustring marked_up_form_text;
Glib::ustring txt = DICOM::format_person_name(patient->get_name());
marked_up_form_text += "<b>Patient's name</b>: " + txt + "\n";
marked_up_form_text += "<b>Sex</b>: " + info->get_patient_sex() + "\n";
DICOM::PatientAge age = info->get_patient_age();
marked_up_form_text += "<b>Age</b>: " + age.age_string() + "\n\n";
layout->set_markup(marked_up_form_text);
layout->show_in_cairo_context(cairo);
int w, h;
layout->get_pixel_size( w, h);
cairo->rel_move_to( 0, h);
cairo->stroke_preserve();
}
void GraficoDeTorta::dibujarArco(const Cairo::RefPtr<Cairo::Context>& c,int x, int y, int radio, float angulo0, float angulo1,float r, float g, float b){
c->set_source_rgb(1,1,1);
c->set_line_width(2);
c->arc(x,y,radio, angulo0, angulo1);
c->line_to(x,y);
c->close_path();
c->stroke_preserve();
c->set_source_rgb(r,g,b);
c->fill();
}
void
Operation::draw_title(const Glib::RefPtr<Gtk::PrintContext>& print)
{
double pos_x, pos_y;
Cairo::RefPtr<Cairo::Context> cairo = print->get_cairo_context();
DICOM::SummaryInfo* info = const_cast<DICOM::SummaryInfo*>(&dicom_info_);
DICOM::StudyInfo* study = info->get_study_info();
// Show Institution Name
cairo->set_font_size(title_font_size_);
Cairo::TextExtents cur_ext, prev_ext;
cairo->get_text_extents( study->get_institution_name(), cur_ext);
pos_x = (width_ - cur_ext.width) / 2.;
pos_y = cur_ext.height + OFFSET;
cairo->move_to( pos_x, pos_y);
cairo->show_text(study->get_institution_name());
// Show Institution Address
prev_ext = cur_ext;
cairo->set_font_size(subtitle_font_size_);
cairo->get_text_extents( study->get_institution_address(), cur_ext);
pos_x = -(prev_ext.width + prev_ext.x_bearing +
cur_ext.width + cur_ext.x_bearing) / 2.;
pos_y = cur_ext.height + OFFSET;
cairo->rel_move_to( pos_x, pos_y);
cairo->show_text(study->get_institution_address());
// Show Study Description
prev_ext = cur_ext;
cairo->set_font_size(title_font_size_);
cairo->get_text_extents( study->get_description(), cur_ext);
pos_x = -(prev_ext.width + prev_ext.x_bearing +
cur_ext.width + cur_ext.x_bearing) / 2.;
pos_y = cur_ext.height + OFFSET;
cairo->rel_move_to( pos_x, pos_y);
cairo->show_text(study->get_description());
pos_x = -(width_ + cur_ext.width) / 2.;
pos_y = cur_ext.height + OFFSET;
cairo->rel_move_to( pos_x, pos_y);
cairo->stroke_preserve();
}
//! 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();
}
bool level_editor::tileset_display::on_expose_event(GdkEventExpose* event) {
Glib::RefPtr<Gdk::Window> window = get_window();
if (!window || !m_surface)
return true;
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->set_source(m_surface, 0, 0);
cr->paint();
// Show selection rectangle when we are selecting
if (m_selecting
|| ((m_select_x != m_select_end_x || m_select_y != m_select_end_y)
&& m_preferences.sticky_tile_selection)) {
const int x = std::min(m_select_x, m_select_end_x) * m_tile_width;
const int y = std::min(m_select_y, m_select_end_y) * m_tile_height;
const int w = (std::abs(m_select_x - m_select_end_x))
* m_tile_width;
const int h = (std::abs(m_select_y - m_select_end_y))
* m_tile_height;
cr->save();
cr->rectangle(x, y, w, h);
// TODO: move selection color somewhere else (preferences?)
cr->set_source_rgb(0.7, 1, 1);
if (m_preferences.selection_background) {
cr->stroke_preserve();
cr->set_source_rgba(0.7, 1, 0, 0.2);
cr->fill();
} else {
cr->stroke();
}
cr->restore();
}
return true;
}
/**
* Draws a curve for the speed graph.
*/
void GtkGraph::draw(std::queue<double> q, double height, double increment, double maxValue, const Cairo::RefPtr<Cairo::Context>& cr)
{
// wizards use computers
// computers use numbers
// no magic
double offset = increment * (m_displaySize - q.size());
cr->move_to(0, height);
for(unsigned i = 0; i< (m_displaySize - q.size());++i)
cr->line_to(i*increment, height);
double oldy;
if(q.empty()) return;
oldy = height - (q.front() * height / maxValue);
cr->line_to(offset, oldy);
q.pop();
double x = increment + offset;
while(!q.empty())
{
double y = height - (q.front() * height / maxValue);
cr->curve_to(x - increment/2, oldy, x - increment/2, y, x, y);
q.pop();
oldy = y;
x += increment;
}
if(gt::Settings::settings["GraphStyle"] == "Fill")
{
cr->stroke_preserve();
Gdk::Cairo::set_source_rgba(cr, Gdk::RGBA(gt::Settings::settings[(upl) ? "GraphUploadFillColor" : "GraphDownloadFillColor"]));
cr->line_to(x - increment, height);
cr->line_to(0,height);
auto k = Gdk::RGBA(gt::Settings::settings[(upl) ? "GraphUploadFillColor" : "GraphDownloadFillColor"]);
cr->set_source_rgba(k.get_red(), k.get_green(), k.get_blue(), k.get_alpha() * 0.5);
cr->fill();
}
else cr->stroke();
}
void Renderer::renderLabels(const Cairo::RefPtr<Cairo::Context>& cr,
std::vector<shared_ptr<LabelType> >& labels,
AssetCache& cache) const
{
cr->save();
cr->set_line_join(Cairo::LINE_JOIN_ROUND);
for (auto it = labels.rbegin(); it != labels.rend(); it++)
{
const shared_ptr<LabelType>& label = *it;
const Style* s = label->style;
cr->set_font_size(s->font_size);
cr->move_to(label->origin.x, label->origin.y);
cr->set_font_face(cache.getFont(
s->font_family.str(),
s->font_style == Style::STYLE_ITALIC ? Cairo::FONT_SLANT_ITALIC : Cairo::FONT_SLANT_NORMAL,
s->font_weight == Style::WEIGHT_BOLD ? Cairo::FONT_WEIGHT_BOLD : Cairo::FONT_WEIGHT_NORMAL
));
cr->text_path(label->text.str());
if (s->text_halo_radius > 0.0)
{
cr->set_source_color(s->text_halo_color);
cr->set_line_width(s->text_halo_radius*2.0);
cr->stroke_preserve();
}
cr->set_source_color(s->text_color);
cr->fill();
}
cr->restore();
}
//! Debug function that prints identifier on the tile
void Renderer::printTileId(const Cairo::RefPtr<Cairo::Context>& cr,
const shared_ptr<TileIdentifier>& id) const
{
cr->save();
cr->set_font_size(10);
cr->move_to(5.0, TILE_SIZE - 10);
std::ostringstream labelstrm;
labelstrm << "X: " << id->getX() << " Y: " << id->getY();
labelstrm << " Zoom: " << id->getZoom();
labelstrm << " Style: " << id->getStylesheetPath();
std::string label = labelstrm.str();
cr->text_path(label.c_str());
cr->set_source_rgba(1.0, 1.0, 1.0, 1.0);
cr->set_line_width(2.0);
cr->stroke_preserve();
cr->set_source_rgba(0.0, 0.0, 0.0, 1.0);
cr->fill();
cr->restore();
}
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 stroke_preserve__(){
cr_->stroke_preserve();
}
void OutputFile::generate() {
unsigned E=es.size();
bool cleanupRoutes=false;
if(routes==NULL) {
cleanupRoutes=true;
routes = new vector<straightener::Route*>(E);
for(unsigned i=0;i<E;i++) {
straightener::Route* r=new straightener::Route(2);
r->xs[0]=rs[es[i].first]->getCentreX();
r->ys[0]=rs[es[i].first]->getCentreY();
r->xs[1]=rs[es[i].second]->getCentreX();
r->ys[1]=rs[es[i].second]->getCentreY();
(*routes)[i]=r;
}
}
#if defined (CAIRO_HAS_SVG_SURFACE) && defined (CAIRO_HAS_PDF_SURFACE)
double width,height,r=2;
if(rects) r=rs[0]->width()/2;
double xmin=DBL_MAX, ymin=xmin;
double xmax=-DBL_MAX, ymax=xmax;
for (unsigned i=0;i<rs.size();i++) {
double x=rs[i]->getCentreX(), y=rs[i]->getCentreY();
xmin=min(xmin,x);
ymin=min(ymin,y);
xmax=max(xmax,x);
ymax=max(ymax,y);
}
xmax+=2*r;
ymax+=2*r;
xmin-=2*r;
ymin-=2*r;
width=xmax-xmin;
height=ymax-ymin;
Cairo::RefPtr<Cairo::Context> cr;
openCairo(cr,width,height);
/* set background colour
cr->save(); // save the state of the context
cr->set_source_rgb(0.86, 0.85, 0.47);
cr->paint(); // fill image with the color
cr->restore(); // color is back to black now
*/
cr->set_line_width(1.);
cr->set_font_size(8);
cr->save();
if(rc) for(Clusters::const_iterator c=rc->clusters.begin();c!=rc->clusters.end();c++) {
draw_cluster_boundary(cr,**c,xmin,ymin);
}
if(curvedEdges)
draw_curved_edges(cr,es,xmin,ymin);
else
draw_edges(cr,*routes,xmin,ymin);
Cairo::TextExtents te;
for (unsigned i=0;i<rs.size();i++) {
if(!rects) {
double x=rs[i]->getCentreX()-xmin, y=rs[i]->getCentreY()-ymin;
cr->arc(x,y,r, 0.0, 2.0 * M_PI);
cr->fill();
} else {
double x=rs[i]->getMinX()-xmin+0.5, y=rs[i]->getMinY()-ymin+0.5;
std::string str;
if(labels.size()==rs.size()) {
str=labels[i];
} else {
std::stringstream s; s<<i;
str=s.str();
}
cr->get_text_extents(str,te);
/*
double llx = x-te.width/2.-1;
double lly = y-te.height/2.-1;
cr->rectangle(llx,lly,te.width+2,te.height+2);
*/
cr->rectangle(x,y,
rs[i]->width()-1,rs[i]->height()-1);
cr->stroke_preserve();
cr->save();
cr->set_source_rgba(245./255., 233./255., 177./255., 0.6);
cr->fill();
cr->restore();
if(labels.size()==rs.size()) {
cr->move_to(x-te.x_bearing+te.width/2.,y-te.y_bearing+te.height/2.);
cr->show_text(str);
}
cr->stroke();
}
}
cr->show_page();
std::cout << "Wrote file \"" << fname << "\"" << std::endl;
#else
std::cout <<
"WARNING: cola::OutputFile::generate(): No SVG file produced." <<
std::endl <<
" You must have cairomm (and cairo with SVG support) " <<
"this to work." << std::endl;
#endif
if(cleanupRoutes) {
for(unsigned i=0;i<E;i++) {
delete (*routes)[i];
}
delete routes;
}
}
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;
}
}
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
}
void guiRenderer2D::drawMatrices(const Cairo::RefPtr<Cairo::Context>& cr, int width, int height, bool screenshot) {
cr->scale(m_scaleFactor, m_scaleFactor); // Scale sensor to fit the active window
cr->translate(m_offsetX, m_offsetY); // Center figure on drawable/surface
cr->set_line_width(0.25);
for(uint m = 0; m < m_frameManager->getNumMatrices(); m++) {
matrixInfo &matrix = m_frameManager->getMatrixInfo(m);
// TSFrame* tsFrame = m_frameManager->getCurrentFrame();
TSFrame* tsFrame = m_frameManager->getCurrentFilteredFrame();
for(uint y = 0; y < matrix.cells_y; y++) {
for(uint x = 0; x < matrix.cells_x; x++) {
bool maskedStatic = m_frameManager->getStaticMask(m, x, y);
bool maskedDynamic = m_frameManager->getDynamicMask(m, x, y);
uint cellID = matrix.texel_offset + y * matrix.cells_x + x;
float value = tsFrame->cells[cellID];
if(maskedStatic) {
RGB color = determineColor(value);
// Draw sensor cell rectangle
cr->rectangle(m_rectangleTopLeftX[cellID], m_rectangleTopLeftY[cellID], m_rectangleWidth[cellID], m_rectangleHeight[cellID]);
cr->set_source_rgb(0.0, 0.0, 0.0);
cr->stroke_preserve(); // Cell outline
if(maskedDynamic) {
if(value > 0.0) {
cr->set_source_rgb(color.r, color.g, color.b); // Active cells
} else {
cr->set_source_rgb(1.0, 1.0, 1.0); // Inactive cells
}
} else {
cr->set_source_rgb(0.8, 0.8, 0.8); // Disabled cells
}
cr->fill();
}
// Highlight selected cells
if(m_frameManager->isSelected(cellID)) {
cr->rectangle(m_rectangleTopLeftX[cellID], m_rectangleTopLeftY[cellID], m_rectangleWidth[cellID], m_rectangleHeight[cellID]);
cr->set_source_rgba(0.0, 1.0, 0.0, 0.5); // Fill active cells
cr->fill();
}
if(screenshot) {
if(maskedStatic) {
// Print values
Cairo::RefPtr<Cairo::ToyFontFace> font = Cairo::ToyFontFace::create("LMSans10", Cairo::FONT_SLANT_NORMAL, Cairo::FONT_WEIGHT_NORMAL);
cr->set_font_face(font);
cr->set_font_size(matrix.texel_width/3);
std::ostringstream ss;
ss << value;
std::string valueStr = ss.str();
Cairo::TextExtents te;
cr->get_text_extents(valueStr, te);
cr->move_to(m_matrixCellCenterX[cellID]-te.width/2, m_matrixCellCenterY[cellID]+te.height/2);
cr->set_source_rgb(0.0, 0.0, 0.0);
cr->show_text(valueStr);
}
}
}
}
if(!screenshot) {
{
// Print Matrix IDs
Cairo::RefPtr<Cairo::ToyFontFace> font = Cairo::ToyFontFace::create("LMSans10", Cairo::FONT_SLANT_NORMAL, Cairo::FONT_WEIGHT_NORMAL);
cr->set_font_face(font);
cr->set_font_size(matrix.cells_x*matrix.texel_width);
std::ostringstream ss;
ss << m;
std::string idString = ss.str();
Cairo::TextExtents te;
cr->get_text_extents(idString, te);
cr->move_to(m_newCenterX[m]-te.width/2, m_newCenterY[m]+te.height/2);
cr->set_source_rgba(0.3, 0.3, 0.3, 0.3);
cr->show_text(idString);
}
}
}
}
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();
}
}
/**
* Does something when the block bar is drawn.
*/
bool GtkBlockBar::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
{
const double width = (double)get_allocation().get_width();
const double height = (double)get_allocation().get_height();
double increment = width / (double)m_blocks.size();
for(unsigned i = 0; i < m_blocks.size(); ++i)
{
if(m_blocks[i])
Gdk::Cairo::set_source_rgba(cr, get_style_context()->get_color());
else
Gdk::Cairo::set_source_rgba(cr, get_style_context()->get_background_color());
double start = i * increment;
cr->rectangle(start, 0, increment, height);
cr->stroke_preserve();
cr->fill();
}
return true;
}
