bool CircuitWidget::on_expose_event(GdkEventExpose* event)
{
(void)event; // placate compiler..
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();
double xc = width/2.0;
double yc = height/2.0;
Cairo::RefPtr<Cairo::Context> cr = window->create_cairo_context();
circuitDrawer.renderCairo(cr->cobj());
cr->rectangle(event->area.x, event->area.y,
event->area.width, event->area.height);
cr->clip();
cr->rectangle (0, 0, width, height);
cr->set_source_rgb (1,1,1);
cr->fill ();
cr->translate (xc-ext.width/2.0-cx*scale, yc-ext.height/2.0-cy*scale);
if (circuit) {
rects = circuitDrawer.draw(*circuit, drawarch, drawparallel, ext, wirestart, wireend, scale, selections, ft_default, wirelabels);
generate_layout_rects ();
}
}
return true;
}
void RegionChooser::draw_keyboard(const Cairo::RefPtr<Cairo::Context>& cr,
int clip_low, int clip_high) {
const int h = KEYBOARD_HEIGHT;
const int w = get_width() - 1;
const int bh = int(h * 0.55);
Gdk::Cairo::set_source_rgba(cr, black);
cr->rectangle(0.5, h1 + 0.5, w, h - 1);
cr->stroke();
int x1 = key_to_x(20.5, w);
Gdk::Cairo::set_source_rgba(cr, grey1);
cr->rectangle(1, h1 + 1, x1 - 1, h - 2);
cr->fill();
int x2 = key_to_x(109.5, w);
Gdk::Cairo::set_source_rgba(cr, white);
cr->rectangle(x1 + 1, h1 + 1, x2 - x1 - 1, h - 2);
cr->fill();
Gdk::Cairo::set_source_rgba(cr, grey1);
cr->rectangle(x2 + 1, h1 + 1, w - x2 - 1, h - 2);
cr->fill();
Gdk::Cairo::set_source_rgba(cr, black);
int clipkey1 = std::max(0, x_to_key_right(clip_low - 1, w));
int clipkey2 = std::min(x_to_key_right(clip_high - 1, w) + 1, 128);
for (int i = clipkey1 ; i < clipkey2 ; i++) {
int note = (i + 3) % 12;
int x = key_to_x(i, w);
if (note == 1 || note == 4 || note == 6 ||
note == 9 || note == 11) {
// black key: short line in the middle, with a rectangle
// on top
int x2 = key_to_x(i + 0.5, w);
cr->move_to(x2 + 0.5, h1 + bh + 0.5);
cr->line_to(x2 + 0.5, h1 + h - 1);
cr->stroke();
int x3 = key_to_x(i + 1, w);
cr->rectangle(x, h1 + 1, x3 - x + 1, bh);
cr->fill();
} else if (note == 3 || note == 8) {
// C or F: long line to the left
cr->move_to(x + 0.5, h1 + 1);
cr->line_to(x + 0.5, h1 + h - 1);
cr->stroke();
}
if (key_pressed[i]) draw_key(cr, i);
if (note == 3) draw_digit(cr, i);
}
}
// ----------------------------------------------------------------------------
// -- 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 ListNode::draw_node(const Cairo::RefPtr<Cairo::Context> & cr, int x, int y) {
cr->rectangle(x, y, field_w, field_h * numFields);
cr->fill();
cr->set_source_rgb(0.0, 0.0, 0.0);
cr->set_line_width(2.0);
for (int i = 0; i < numFields; i++) {
cr->rectangle(x, y + (i * field_h), field_w, field_h);
cr->stroke();
}
}
void EmblemCellRenderer::do_render(const Cairo::RefPtr<Cairo::Context>& context, int widget, int background_area, Gdk::Rectangle &cell_area, int flags) {
context->translate(cell_area.get_x(), cell_area.get_y());
context->rectangle(0, 0, cell_area.get_width(), cell_area.get_height());
context->clip();
// TODO: Incorporate padding
context->push_group();
if (!this->_icon_name.empty()) {
Glib::RefPtr<Gdk::Pixbuf> pixbuf = this->_get_pixbuf(this->_icon_name, this->_icon_size);
context->set_operator(Cairo::OPERATOR_SOURCE);
// Assumes square icons; may break if we don't get the requested size
int height_offset = int((cell_area.get_height() - pixbuf->get_height())/2);
Gdk::Cairo::set_source_pixbuf(context, pixbuf, 0, height_offset);
context->rectangle(0, height_offset,
pixbuf->get_width(), pixbuf->get_height());
context->fill();
if (this->_tint_color) {
Gdk::RGBA* c = this->_tint_color;
gushort r = c->get_red();
gushort g = c->get_green();
gushort b = c->get_blue();
// Figure out the difference between our tint colour and an
// empirically determined (i.e., guessed) satisfying luma and
// adjust the base colours accordingly
double luma = (r + r + b + g + g + g) / 6.;
double extra_luma = (1.2 - luma) / 3.;
r = std::min(r + extra_luma, 1.);
g = std::min(g + extra_luma, 1.);
b = std::min(b + extra_luma, 1.);
context->set_source_rgba(r, g, b, 0.4);
context->set_operator(Cairo::OPERATOR_ATOP);
context->paint();
}
if (!this->_emblem_name.empty()) {
Glib::RefPtr<Gdk::Pixbuf> pixbuf = this->_get_pixbuf(this->_emblem_name, this->_emblem_size);
int x_offset = this->_icon_size - this->_emblem_size;
context->set_operator(Cairo::OPERATOR_OVER);
Gdk::Cairo::set_source_pixbuf(context, pixbuf, x_offset, 0);
context->rectangle(x_offset, 0,
cell_area.get_width(), this->_emblem_size);
context->fill();
}
}
context->pop_group_to_source();
context->set_operator(Cairo::OPERATOR_OVER);
context->paint();
}
void ItemView::drawBackground(const Cairo::RefPtr<Cairo::Context>& cr, const int width, const int height)
{
//fill background
if (isSelected())
{
cr->set_source_rgb(1, 1, 1);
cr->rectangle(0, 0, width, height);
cr->fill();
}
else
{
cr->set_source_rgb(0.98, 0.98, 0.98);
cr->rectangle(0, 0, width, height);
cr->fill();
}
//time area
Cairo::RefPtr<Cairo::LinearGradient> linearGradientTime = Cairo::LinearGradient::create(0, 0, 0, height);
//set color by status
ColorMode colorMode = getColorMode();
if (colorMode == COLOR_INACTIVE)
{
//gray
linearGradientTime->add_color_stop_rgb(0, 0.75, 0.75, 0.75);
linearGradientTime->add_color_stop_rgb(1, 0.65, 0.65, 0.65);
}
if (colorMode == COLOR_ALARM)
{
//orange
linearGradientTime->add_color_stop_rgb(0, 1.00, 0.60, 0.30);
linearGradientTime->add_color_stop_rgb(1, 0.90, 0.50, 0.20);
}
if (colorMode == COLOR_OK)
{
//green
linearGradientTime->add_color_stop_rgb(0, 0.40, 0.70, 0.45);
linearGradientTime->add_color_stop_rgb(1, 0.30, 0.60, 0.35);
}
cr->set_source(linearGradientTime);
cr->rectangle(0, 0, TIME_WIDTH, height);
cr->fill();
if (isSelected())
drawInnerShadow(cr, width, height);
}
bool CompVis::on_expose_event(GdkEventExpose* event) {
Glib::RefPtr<Gdk::Window> window = get_window();
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();
// 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();
rms_dB = 20*log10(rms);
thresh_fraction = (threshold - p_ports[p_threshold].min)/threshold_range;
rms_dB_fraction = (rms_dB - p_ports[p_threshold].min)/threshold_range;
// Draw the graph
cr->set_source_rgb(0.5,0.1,0.1);
cr->set_line_width(2);
cr->move_to(0,height);
if (rms_dB <= threshold) {
cr->line_to(rms_dB_fraction*width, height-rms_dB_fraction*height);
cr->line_to(rms_dB_fraction*width, height);
cr->line_to(0,height);
} else {
cr->line_to(thresh_fraction*width, height-thresh_fraction*height);
cr->line_to(rms_dB_fraction*width, height-(thresh_fraction*height + height*(rms_dB_fraction-thresh_fraction)/ratio));
cr->line_to(rms_dB_fraction*width, height);
cr->line_to(0,height);
}
cr->fill();
// draw the compression curve:
cr->set_source_rgb(0.1,0.1,0.1);
cr->move_to(0, height);
cr->line_to(thresh_fraction*width, height-thresh_fraction*height);
cr->line_to(width, height-(thresh_fraction*height + height*(1-thresh_fraction)/ratio));
cr->stroke();
// Draw the gain
cr->set_source_rgb(0.1,0.8,0.1);
cr->rectangle(0,(float)height - (float)height*gain, 10, height);
cr->fill();
return true;
}
void
Renderer_Dragbox::render_vfunc(
const Glib::RefPtr<Gdk::Window>& drawable,
const Gdk::Rectangle& /*expose_area*/
)
{
assert(get_work_area());
if(!get_work_area())
return;
// const synfig::Vector focus_point(get_work_area()->get_focus_point());
// Warning : Unused focus_point
int drawable_w = drawable->get_width();
int drawable_h = drawable->get_height();
Cairo::RefPtr<Cairo::Context> cr = drawable->create_cairo_context();
const synfig::Vector::value_type window_startx(get_work_area()->get_window_tl()[0]);
const synfig::Vector::value_type window_starty(get_work_area()->get_window_tl()[1]);
const float pw(get_pw()),ph(get_ph());
const synfig::Point& curr_point(get_curr_point());
const synfig::Point& drag_point(get_drag_point());
{
cr->save();
cr->set_line_cap(Cairo::LINE_CAP_BUTT);
cr->set_line_join(Cairo::LINE_JOIN_MITER);
cr->set_antialias(Cairo::ANTIALIAS_NONE);
cr->set_line_width(1.0);
cr->set_source_rgb(0,0,0);
std::valarray<double> dashes(2);
dashes[0]=5.0;
dashes[1]=5.0;
cr->set_dash(dashes, 0);
Point tl(std::min(drag_point[0],curr_point[0]),std::min(drag_point[1],curr_point[1]));
Point br(std::max(drag_point[0],curr_point[0]),std::max(drag_point[1],curr_point[1]));
tl[0]=(tl[0]-window_startx)/pw;
tl[1]=(tl[1]-window_starty)/ph;
br[0]=(br[0]-window_startx)/pw;
br[1]=(br[1]-window_starty)/ph;
if(tl[0]>br[0])
swap(tl[0],br[0]);
if(tl[1]>br[1])
swap(tl[1],br[1]);
cr->rectangle(
tl[0],
tl[1],
br[0]-tl[0],
br[1]-tl[1]
);
cr->stroke();
cr->restore();
}
}
/// Same as draw_buffer, with only the curr_item's full text
void
ViewDrawingArea::render_full_article()
{
// Dimensions of drawing area
Gtk::Allocation allocation = get_allocation();
const int height = allocation.get_height();
const int width = allocation.get_width();
Cairo::RefPtr<Cairo::Context> cr = _pixmap->create_cairo_context();
cr->reset_clip();
cr->rectangle (0.0, 0.0, width, height);
cr->clip();
cr->set_source_rgb (1.0, 1.0, 1.0);
cr->paint();
cr->set_source_rgb (0.0, 0.0, 0.0);
Item *item = AppContext::get().get_curr_item();
item->make_display_unit();
ItemDisplayUnit *du = item->get_display_unit();
du->render (cr, 0, -_vadj->get_value());
cr->show_page();
double h = du->get_height();
if (h > height)
_vadj->set_upper (h - height);
else
_vadj->set_upper (0);
_vadj->set_page_size (height);
_vadj->set_step_increment (height * 1.0/16.0);
_vadj->set_page_increment (height * 15.0/16.0);
_vadj->changed();
}
void enigma_rotor_window::draw(Cairo::RefPtr<Cairo::Context> cr)
{
vector<double> dashes;
// Pattern used to draw a dashed line (15 pixels of line followed by 15 "empty" pixels)
dashes.push_back(15.0);
dashes.push_back(15.0);
if (has_ellipse)
{
cr->save();
// Draw background ellipse
cr->set_source_rgb(bkg_r, bkg_g, bkg_b);
draw_ellipse(cr, x, y, ellipse_width, ellipse_height);
cr->fill();
// Draw black border of background ellipse
cr->set_source_rgb(BLACK);
cr->set_line_width(1.2);
draw_ellipse(cr, x, y, ellipse_width, ellipse_height);
cr->stroke();
cr->restore();
}
cr->save();
// Draw a line of width rotor_rim_width in the dash background colour
cr->set_line_width(rotor_rim_width);
cr->set_source_rgb(dash_bkg_r, dash_bkg_g, dash_bkg_b);
cr->move_to(x + window_size, y - (2 * window_size));
cr->line_to(x + window_size, y + (2 * window_size));
cr->stroke();
// Draw a dashed line in the dash colour inside the previously drawn line
// This creates the impression of "notches" on the handle/rim
cr->set_source_rgb(dash_r, dash_g, dash_b);
cr->set_dash(dashes, ((wheel_pos - 'A') & 1) * 15); // modifying the offset creates illusion of movement
cr->move_to(x + window_size, y - (2 * window_size));
cr->line_to(x + window_size, y + (2 * window_size));
cr->stroke();
// Draw border around handle/rim
cr->set_line_width(2.0);
cr->unset_dash();
cr->set_source_rgb(DARK_GREY);
cr->rectangle(x + padded_size, y - (2 * window_size), rotor_rim_width, (4 * window_size));
cr->stroke();
cr->restore();
draw_wheel_pos(cr, wheel_pos);
if (has_ellipse)
{
// Draw screws
upper->draw(cr);
lower->draw(cr);
}
}
//Lots of this function needs to be optimised, including the pixbuf/bitmap thing and having to draw pretty much double the squares
void Simple_GOL_Area::draw_sim_data(const Cairo::RefPtr<Cairo::Context>& cr, int window_width, int window_height)
{
time_t seconds = time(NULL);
std::cout << "Rendering Simulation " << seconds << "\n";
if (sim_data->get_size() != 0)
{
int data_width = sim_data->get_width();
int data_height = sim_data->get_height();
double step_value_x = double(window_width)/double(sim_data->get_width());
double step_value_y = double(window_height)/double(sim_data->get_height());
for(int i=0; i<data_width; i++)
{
for(int j=0; j<data_height; j++)
{
if(sim_data->get(i,j))
{
cr->set_source_rgb(1,1,1);
}
else
{
cr->set_source_rgb(0,0,0);
}
//Yet to figure out why I have to draw in the black squares as well.
cr->rectangle(int(i*step_value_x), int(j*step_value_y),
int((i+1)*step_value_x), int((j+1)*step_value_y));
//Use bitmap classes so that I don't have to fill every time
cr->fill();
}
}
}
}
bool Terminal::on_draw(const Cairo::RefPtr<Cairo::Context>& cr) {
Box::on_draw(cr);
cr->set_source_rgb(1, 0, 0);
cr->rectangle(dock_hint.x, dock_hint.y, dock_hint.x+dock_hint.width, dock_hint.y+dock_hint.height);
cr->fill();
}
/** 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 Canvas::on_expose_event(GdkEventExpose * evt) {
Glib::RefPtr<Gdk::Window> window = get_window();
if (!window) return false; // no window yet?
if (!seen_first_expose_event) {
seen_first_expose_event = true;
main->controlsWindow().starting_position();
}
Cairo::RefPtr<Cairo::Context> cr = window->create_cairo_context();
if (!surface) return true; // Haven't rendered yet? Nothing we can do
if (evt) {
cr->rectangle(evt->area.x, evt->area.y, evt->area.width, evt->area.height);
cr->clip();
}
cr->set_source(surface, 0, 0);
cr->paint();
if (main->dragrect.is_active() && main->dragrect.surface_valid()) {
cr->save();
cr->set_source(main->dragrect.get_surface(), 0, 0);
cr->paint();
cr->restore();
}
if (main->hud_active()) {
Cairo::RefPtr<Cairo::Surface>& sfc = main->get_hud_surface();
if (sfc)
cr->set_source(sfc, 0, 0); // TODO HUD position
cr->paint();
}
return true;
}
bool guiRenderer2D::on_expose_event(GdkEventExpose* event) {
Glib::RefPtr<Gdk::Window> window = get_window();
if(window) {
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
//printf("event->area.x: %d, event->area.y: %d, event->area.width: %d, event->area.height: %d\n", event->area.x, event->area.y, event->area.width, event->area.height );
cr->rectangle(event->area.x, event->area.y, event->area.width, event->area.height);
cr->clip();
}
// Background
// cr->set_source_rgb(0.0, 0.0, 0.0);
cr->set_source_rgb(1.0, 1.0, 1.0);
cr->paint();
if(m_isRendering && m_layoutAvailable) {
Gtk::Allocation allocation = get_allocation();
int width = allocation.get_width();
int height = allocation.get_height();
if(width != m_widgetWidth || height != m_widgetHeight ) { // Allocation changed
rescaleSensorLayout(width, height);
}
drawMatrices(cr, width, height, false);
}
}
return true;
}
void ItemView::drawReminderIcon(const Cairo::RefPtr<Cairo::Context>& cr, const int width, const int height)
{
cr->save();
//draw reminder icon
cr->set_antialias(Cairo::ANTIALIAS_NONE);
if (data.isReminder())
{
Gtk::Image* image = Resources::res->imgReminderIcon;
if (getColorMode() == COLOR_ALARM)
image = Resources::res->imgReminderOnIcon;
const Glib::RefPtr<Gdk::Pixbuf> icon = image->get_pixbuf();
const int iconLeft = (TIME_WIDTH * 0.5) - (icon->get_width() * 0.5);
const int iconTop = (height - icon->get_height()) - (PADDING * 3);
Gdk::Cairo::set_source_pixbuf(cr, icon, iconLeft, iconTop);
cr->rectangle(iconLeft, iconTop, icon->get_width(), icon->get_height());
cr->fill();
}
cr->restore();
}
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;
}
bool TrackOutput::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
{
// 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);
cr->set_source_rgb(0.1 , 0.1 , 0.1 );
cr->fill();
TrackOutputState* state = &stateStore->trackoutputState.at(ID);
if ( state->selected )
setColour(cr, COLOUR_GREY_3 );
else
setColour(cr, COLOUR_GREY_4 );
cr->rectangle(0, 0, 74, 102);
cr->fill();
Dial(cr,true, 7,4,state->pan,DIAL_MODE_PAN); // pan
Mute(cr, 9 , 41 , state->ID, state->mute ); // mute button
Solo(cr, 9 , 68 , state->ID, state->solo ); // solo button
Rec (cr, 9 , 85 , state->ID, state->recEnable); // rec button
Fader(cr,46 , 4 , state->volume, state->rms, state->falloff ); // fader
if ( state->selected )
{
cr->rectangle(0, -10, 74, 200);
setColour( cr, COLOUR_PURPLE_1 );
cr->set_line_width(1);
cr->stroke();
}
}
return true;
}
void renderLabels(Cairo::RefPtr<Cairo::Context> cr, std::vector<std::pair<string, FloatPoint> >& toPlace) {
cr->save();
cr->set_source_rgba(0.0, 0.0, 0.0, 0.5);
Cairo::RefPtr<Cairo::ToyFontFace> font = Cairo::ToyFontFace::create(DEFAULT_FONT, Cairo::FONT_SLANT_NORMAL, Cairo::FONT_WEIGHT_NORMAL);
cr->set_font_face(font);
cr->set_font_size(120.0);
cr->set_line_width(2.0);
Cairo::TextExtents textSize;
std::list<shared_ptr<Label> > labels;
int i = 0;
std::vector<shared_ptr<Style>> styles;
for (auto& pair : toPlace)
{
string& text = pair.first;
cr->get_text_extents(text, textSize);
shared_ptr<Style> s = boost::make_shared<Style>();
s->text = text;
styles.push_back(s);
FloatPoint center = pair.second + FloatPoint(textSize.width/2.0, textSize.height/2.0);
FloatRect owner = FloatRect(center.x, center.y, center.x, center.y);
FloatPoint origin = pair.second - FloatPoint(textSize.x_bearing, textSize.y_bearing);
shared_ptr<Label> l = boost::make_shared<Label>(FloatRect(pair.second, textSize.width, textSize.height), owner, s->text, s.get(), origin);
cr->rectangle(l->box.minX, l->box.minY, l->box.getWidth(), l->box.getHeight());
cr->stroke();
labels.push_back(l);
}
std::vector<shared_ptr<Label> > placed;
placeLabels(labels, placed);
for (auto& l: placed)
{
cr->set_source_rgba(0.0, 0.0, 0.0, 1.0);
cr->move_to(l->box.minX, l->box.maxY);
cr->show_text(l->style->text.str());
cr->fill();
cr->set_source_rgba(1.0, 0.0, 0.0, 0.5);
cr->rectangle(l->box.minX, l->box.minY, l->box.getWidth(), l->box.getHeight());
cr->fill();
}
cr->restore();
}
void
Renderer_BBox::render_vfunc(
const Glib::RefPtr<Gdk::Window>& drawable,
const Gdk::Rectangle& /*expose_area*/
)
{
assert(get_work_area());
if(!get_work_area())
return;
Cairo::RefPtr<Cairo::Context> cr = drawable->create_cairo_context();
const synfig::Vector::value_type window_startx(get_work_area()->get_window_tl()[0]);
const synfig::Vector::value_type window_starty(get_work_area()->get_window_tl()[1]);
const float pw(get_pw()),ph(get_ph());
const synfig::Point curr_point(get_bbox().get_min());
const synfig::Point drag_point(get_bbox().get_max());
if(get_bbox().area()<10000000000000000.0 && get_bbox().area()>0.00000000000000001)
{
Point tl(std::min(drag_point[0],curr_point[0]),std::min(drag_point[1],curr_point[1]));
Point br(std::max(drag_point[0],curr_point[0]),std::max(drag_point[1],curr_point[1]));
tl[0]=(tl[0]-window_startx)/pw;
tl[1]=(tl[1]-window_starty)/ph;
br[0]=(br[0]-window_startx)/pw;
br[1]=(br[1]-window_starty)/ph;
if(tl[0]>br[0])
swap(tl[0],br[0]);
if(tl[1]>br[1])
swap(tl[1],br[1]);
cr->save();
cr->set_line_cap(Cairo::LINE_CAP_BUTT);
cr->set_line_join(Cairo::LINE_JOIN_MITER);
cr->set_line_width(1.0);
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->rectangle(
int(tl[0])+0.5,
int(tl[1])+0.5,
int(br[0]-tl[0]+1),
int(br[1]-tl[1]+1)
);
cr->stroke();
cr->restore();
}
}
bool HelloWorld::on_canvas_expose(GdkEventExpose* event) {
Cairo::RefPtr<Cairo::Context> context = ara_canvas.get_window()->create_cairo_context();
context->rectangle(event->area.x, event->area.y, event->area.width,
event->area.height);
context->clip();
update_canvas();
return true;
}
bool AdvEnvGUIScope::on_expose_event(GdkEventExpose* event)
{
Glib::RefPtr<Gdk::Window> window = get_window();
if (window)
{
float len, x, y, xscale, yscale;
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();
cr->set_line_width(2.0);
cr->set_source_rgb(0.0, 0.0, 0.0);
cr->paint();
cr->set_source_rgb(0.0, 0.8, 0.0);
cr->rectangle(event->area.x, event->area.y, event->area.width, event->area.height);
cr->clip();
cr->move_to(width, height);
len = m_valueDelay + m_valueAttackTime1 + m_valueAttackTime2 + m_valueAttackTime3 + m_valueAttackTime4 + m_valueReleaseTime1 + m_valueReleaseTime2 + m_valueReleaseTime3 + SUSTAIN_LEN;
xscale = (float) width / len;
yscale = (float) (height - 6);
x = m_valueDelay * xscale;
cr->line_to((int) x, height);
x += m_valueAttackTime1 * xscale;
y = m_valueAttackLevel1 * yscale;
cr->line_to((int) x, height - (int) y);
x += m_valueAttackTime2 * xscale;
y = m_valueAttackLevel2 * yscale;
cr->line_to((int) x, height - (int) y);
x += m_valueAttackTime3 * xscale;
y = m_valueAttackLevel3 * yscale;
cr->line_to((int) x, height - (int) y);
x += m_valueAttackTime4 * xscale;
y = m_valueSustain * yscale;
cr->line_to((int) x, height - (int) y);
x += SUSTAIN_LEN * xscale;
cr->line_to((int) x, height - (int) y);
x += m_valueReleaseTime1 * xscale;
y = m_valueReleaseLevel1 * yscale;
cr->line_to((int) x, height - (int) y);
x += m_valueReleaseTime2 * xscale;
y = m_valueReleaseLevel2 * yscale;
cr->line_to((int) x, height - (int) y);
x += m_valueReleaseTime3 * xscale;
cr->line_to((int) x, height);
x = m_valueDelay * xscale;
cr->line_to((int) x, height);
cr->stroke();
}
return true;
}
void Simple_GOL_Area::draw_background(const Cairo::RefPtr<Cairo::Context>& cr)
{
Gtk::Allocation allocation = get_allocation();
const int width = allocation.get_width();
const int height = allocation.get_height();
cr->set_source_rgb(0,0,0);
cr->rectangle(0, 0, width, height);
cr->fill();
}
void Anchor::draw(const Cairo::RefPtr<Cairo::Context>& context) const
{
context->save();
context->move_to(mX,mY);
context->set_source_rgb(0., 1., 0.);
context->rectangle(mX, mY, ANCHOR_WIDTH, ANCHOR_HEIGHT);
context->fill();
context->restore();
}
static void copyCairoClip(const Cairo::RefPtr<Cairo::Context> &src, const Cairo::RefPtr<Cairo::Context> &dst) {
try {
vector<Cairo::Rectangle> rects;
src->copy_clip_rectangle_list(rects);
for (auto& rect : rects) {
//cout << "clip " << rect.x << "x" << rect.y << "+" << rect.width << "+" << rect.height << endl;
dst->rectangle(rect.x, rect.y, rect.width, rect.height);
}
dst->clip();
} catch (...) {
Cairo::Rectangle rect;
src->get_clip_extents(rect.x, rect.y, rect.width, rect.height);
rect.width -= rect.x;
rect.height -= rect.y;
//cout << "clip " << rect.x << "x" << rect.y << "+" << rect.width << "+" << rect.height << endl;
dst->rectangle(rect.x, rect.y, rect.width, rect.height);
dst->clip();
}
}
void ItemView::drawButton(const Cairo::RefPtr<Cairo::Context>& cr, Gtk::Image* image, Gdk::Rectangle rect)
{
const Glib::RefPtr<Gdk::Pixbuf> icon = image->get_pixbuf();
const int iconLeft = rect.get_x() + (rect.get_width() * 0.5) - (icon->get_width() * 0.5);
const int iconTop = rect.get_y() + (rect.get_height() * 0.5) - (icon->get_height() * 0.5);
Gdk::Cairo::set_source_pixbuf(cr, icon, iconLeft, iconTop);
cr->rectangle(iconLeft, iconTop, icon->get_width(), icon->get_height());
cr->fill();
}
bool MyArea_private::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
{
if (pixbuf == 0) return false;
cr->set_source_rgba(0xff, 0xff, 0xff, 0xff);
cr->rectangle(0, 0, 800, 640);
cr->fill();
Gdk::Cairo::set_source_pixbuf(cr, pixbuf);
cr->paint();
cr->stroke();
return true;
}
bool VistaDiagrama::on_expose_event(GdkEventExpose* event) {
this->set_size_request(this->ancho, this->alto);
// Gonzalo : TEST
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();
// 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();
cr->set_line_width(10.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->clip();
// draw red lines out from the center of the window
cr->set_line_cap(Cairo::LINE_CAP_ROUND);
cr->set_source_rgb(0.8, 0.0, 0.0);
cr->move_to(20, 20);
cr->line_to(xc, yc);
cr->line_to(20, height - 20);
cr->move_to(xc, yc);
cr->line_to(width - 20, yc);
cr->stroke();
//RefPtr<Context> cr = this->get_window()->create_cairo_context();
/*cr->set_source_rgba(1, 1, 1, 1); // white
cr->paint();
cr->set_source_rgba(0, 0, 0, 1); // negro
cr->move_to(0, 0);
cr->line_to(this->ancho, this->alto);
VistaEntidad * entidad = new VistaEntidad();
entidad->setposfin(10, 10);
entidad->setposfin(20, 20);
entidad->dibujar(cr);*/
}
//delete entidad;
return true;
}
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;
}
void HelloWorld::update_canvas(Cairo::RefPtr<Cairo::Context> &context) {
alc_allocation = ara_canvas.get_allocation();
int width = alc_allocation.get_width();
int height = alc_allocation.get_height();
cout << "width: " << width << ", height: " << height << endl;
context->save();
context->set_source_rgba(0, level, 0, 1);
context->scale(width, height);
context->rectangle(0, 0, 1, 1);
context->fill();
context->restore();
}