sgpemv2/src/cairo_widget.cc

// src/cairo_widget.cc - Copyright 2005, 2006, University
//               of Padova, dept. of Pure and Applied
//               Mathematics
//
// This file is part of SGPEMv2.
//
// This is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// SGPEMv2 is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with SGPEMv2; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA


#include "cairo_elements.hh"
#include "cairo_widget.hh"


#include <gdkmm/window.h>


#include <cassert>
#include <iostream>
#include <memory>

using namespace sgpem;


CairoWidget::CairoWidget()
    : Glib::ObjectBase("sgpem_CairoWidget"),
      Gtk::Widget(),
      _draw_w(1), _draw_h(1), _buf(NULL),
      _client_w(0), _client_h(0), _pixmap_w(0), _pixmap_h(0),
      _need_redraw(true),  _scaling_mode(scaling_none)
{
  set_flags(Gtk::NO_WINDOW);
}


CairoWidget::~CairoWidget()
{
}

CairoWidget::scaling_mode
CairoWidget::set_scaling_mode(CairoWidget::scaling_mode scaling)
{
  CairoWidget::scaling_mode old_scaling = _scaling_mode;
  _scaling_mode = scaling;
  return old_scaling;
}

CairoWidget::scaling_mode
CairoWidget::get_scaling_mode()
{
  return _scaling_mode;
}

void
CairoWidget::on_realize()
{
  // std::cout << " on_realize" << std::endl;
  if (is_realized()) return;

  Gtk::Widget::on_realize();
  ensure_style();

  GdkWindowAttr attributes;
  memset(&attributes, 0, sizeof(attributes));

  Gtk::Allocation alloc = get_allocation();

  attributes.x = alloc.get_x();
  attributes.y = alloc.get_y();
  attributes.width = alloc.get_width();
  attributes.height = alloc.get_height();
  attributes.wclass = GDK_INPUT_OUTPUT;
  attributes.event_mask = get_events() | GDK_EXPOSURE_MASK | GDK_ALL_EVENTS_MASK;
  attributes.window_type = GDK_WINDOW_CHILD;
  attributes.visual = get_visual()->gobj();
  attributes.colormap = get_colormap()->gobj();
  
  _client_w = alloc.get_width();
  _client_h = alloc.get_height();
  
  // std::cout << " on_realize, alloc.get_width() : " << alloc.get_width() << ", alloc.get_height() : " << alloc.get_height() << std::endl;

  static const gint attributes_mask = Gdk::WA_X | Gdk::WA_Y | Gdk::WA_WMCLASS
                                      | Gdk::WA_VISUAL | Gdk::WA_COLORMAP;

  Glib::RefPtr<Gdk::Window> window = Gdk::Window::create(get_parent_window(),
                                     &attributes,
                                     attributes_mask);

  unset_flags(Gtk::NO_WINDOW);
  set_window(window);
  window->set_user_data(gobj());

  // Not sure if the following line is needed:
  gtk_style_attach(get_style()->gobj(), window->gobj());
  get_style()->set_background(window, Gtk::STATE_ACTIVE);
}

void
CairoWidget::on_size_allocate(const Gtk::Allocation& allocation)
{
  // std::cout << " on_size_allocate, allocation.get_width() : " << allocation.get_width() << ", allocation.get_height() : " << allocation.get_height() << std::endl;
  set_allocation(allocation);

  if (is_realized())
  {
    get_window()->move_resize(allocation.get_x(), allocation.get_y(),
                              allocation.get_width(), allocation.get_height());
    _client_w = allocation.get_width();
    _client_h = allocation.get_height();
    _need_redraw = true;
  }

}

void
CairoWidget::on_size_request(Gtk::Requisition* requisition)
{
  // Gtk+ asks the desired widget dimension

  // std::cout << " on_size_request, requisition->width : " << requisition->width << ", requisition->height : " << requisition->height << std::endl;
  calc_widget_size(_client_w, _client_h);
  requisition->width  = _client_w;
  requisition->height = _client_h;

}


bool
CairoWidget::on_expose_event(GdkEventExpose* event)
{
   // std::cout << " on_expose_event START...";
  if (event == NULL || event->count > 0)
    return false;
  // std::cout << " on_expose_event CONTINUE." << std::endl;
    
    int actual_w = get_width();
    int actual_h = get_height();
    
    // std::cout << " get_width() : " << actual_w << ", get_height() : " << actual_h << std::endl;
    // std::cout << " _client_w : " << _client_w << ", _client_h : " << _client_h << std::endl;
    // std::cout << " _pixmap_w : " << _pixmap_w << ", _pixmap_h : " << _pixmap_h << std::endl;

  if(_need_redraw || actual_w!=_client_w || actual_h!=_client_h)
  {
    _need_redraw = false;
    _client_w = actual_w;
    _client_h = actual_h;
    // lazy technique: allocate only if growing...
    if(_client_w>_pixmap_w || _client_h>_pixmap_h)
    {
      // previdence in the code: allocate more than actually needed
      _pixmap_w = (size_t) (_client_w*1.2);
      _pixmap_h = (size_t) (_client_h*1.2);
      std::cout << " on_expose_event CREATE Pixmap. w : " << _pixmap_w << ", h : " << _pixmap_h<< std::endl;
      _buf = Gdk::Pixmap::create(get_window(), _pixmap_w, _pixmap_h);
    }
  
    // Draw the widget background as the first thing.
    // I've seen this is how it's done in the very Gtk+ toolkit
    // for the GtkProgressBar widget.
    GtkStyle* gStyle = get_style()->gobj();
    // std::cout << " on_expose_event gtk_paint_box." << std::endl;
    gtk_paint_box(gStyle, _buf->gobj(),
                  GTK_STATE_NORMAL, GTK_SHADOW_ETCHED_IN,
                  NULL, (GtkWidget*)this->gobj(), "through",
                  0, 0, _client_w, _client_h);
  
    cairo_t* ctx = gdk_cairo_create(_buf->gobj());
  
    // Determine the final drawing dimensions before to start drawing
    _draw_w = _draw_h = 0; // default no scaling
    calc_drawing_size(_draw_w, _draw_h);
    // do the drawing...
    if(_scaling_mode!=scaling_none && _draw_w>0 && _draw_h>0)
    {
      double sx = (double)_client_w/(double)_draw_w;
      double sy = (double)_client_h/(double)_draw_h;
      switch(_scaling_mode)
      {
        case scaling_none:
          sx = sy = 1.0;
          break;
        case scaling_to_w:
          sy = sx;
          break;
        case scaling_to_h:
          sx = sy;
          break;
        case scaling_min:
          if(sx<=sy)
            sy = sx;
          else
            sx = sy;
          break;
        case scaling_max:
          if(sx>=sy)
            sy = sx;
          else
            sx = sy;
          break;
        case scaling_all:
          // nothing to do...
          break;
      }
      cairo_scale(ctx, sx, sy);
    }
    // std::cout << " on_expose_event Dimensions, w : " << _draw_w << ", h : " << _draw_h << std::endl;
    draw_widget(ctx);
    cairo_destroy(ctx);
  }
  // calculated dinamically on update():
  // set_size_request(_draw_w, _draw_h);

  // Clip to redraw only the smallest possible area
  // Use double buffering or we're CPU-dead
  // Copy from the buffer to the screen
  if (_buf)
    get_window()->draw_drawable(get_style()->get_black_gc(), _buf,
                                event->area.x, event->area.y,
                                event->area.x, event->area.y,
                                event->area.width, event->area.height);

  return true;
}

bool
CairoWidget::on_button_press_event(GdkEventButton* event)
{
  return false;
}

void
CairoWidget::redraw()
{
  // Force redraw
  _need_redraw = true;
  queue_draw();
}


void
CairoWidget::calc_drawing_size(size_t& width, size_t& height) const
{
}

void
CairoWidget::calc_widget_size(size_t& width, size_t& height) const
{
}