root/branches/clutter-experiments/main.cc

// note: If we will end up using GObject + C++ the result will seem
// always an horrible hack. We need either a good (for our purposes)
// C++ interface (or binding) for Poppler and Clutter or to code the
// whole thing in C using GObjects.
#include <iostream>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <clutter/clutter.h>
#include <poppler.h>
#include <libintl.h>
#define _(String) gettext(String) 

#include "document.hh"
#include "page.hh"
#include "pdfcube.hh"

using namespace std;


void usage()
{
  cerr << _("pdfcube filename.pdf") << endl;
  exit(1);
}


/*
static gboolean
on_page_enter(ClutterActor* actor, ClutterEvent *event, gpointer data)
{
  double sx, sy;
  clutter_actor_get_scale(actor, &sx, &sy);
  if(sx > 1.0 || sy > 1.0) return FALSE;
  // Code snippet for a static member of the index class,
  // data should point to the index instance, so one can 
  // also click on a page and have its number.
  // FIXME: cancel previous animation before starting a new one.
  ClutterTimeline *timeline = clutter_timeline_new(20, 60);
  clutter_timeline_set_loop(timeline, TRUE);
  clutter_timeline_start(timeline);
  ClutterEffectTemplate *effect_template = 
    clutter_effect_template_new(timeline,
                                clutter_sine_half_func);
  clutter_effect_scale(effect_template, actor, 1.12, 1.12, NULL, NULL);
  g_object_unref(effect_template);
  g_object_unref(timeline);
  return TRUE;
}

static gboolean
on_page_leave(ClutterActor* actor, ClutterEvent *event, gpointer data)
{
  return TRUE;
}
*/
static gboolean
on_stage_button_press (ClutterStage *stage, ClutterEvent *event, gpointer data)
{
  gfloat x, y;
  clutter_event_get_coords (event, &x, &y);
  g_print ("Stage clicked at (%f, %f)\n", x, y);
  // clutter cluttered my first draw, so redraw on click to allow testing.
  // clutter_actor_queue_redraw(CLUTTER_ACTOR(stage));
  return TRUE; /* Stop further handling of this event. */
}

/**
 * The index class will contain methods to show all the pages in an
 * index page, to hilight a different page and to restore the selected
 * page in full screen.
 *
 */
class index
{
  // ...
  // 1. animate to index when tab is pressed
  // 2. navigate with the keyboard and/or mouse (see on_page_enter)
  // 3. animate to the single page choosen (clicked or previous on esc)
  //
};

/**
 * @brief Abstract animator class.
 *
 * Animations are for transitions between two pages. They start from
 * one page and go to another one. The prepare() method whoud be
 * called before starting and is indended to render the hi resolution
 * version of the needed pages and to setup the scene
 * graph. render(frame) is used to position the actors for the given
 * frame number and unprepare() will free the unneded hi-res versions.
 */
class animator
{
public:
  virtual ~animator() {}

  virtual void
  setup() = 0;
  
  virtual void
  render(int frame) = 0;
  
  virtual void
  tear_down() = 0;
};

class replace_animator : public animator
{
public:
  replace_animator(pdfcube::document& doc, int page_no) {};
  void
  setup() {}
  void
  render(int frame) {}
  void
  tear_down() {}
};


class cube_animator : public animator
{
public:
  cube_animator(pdfcube::document& doc, int page_no) {};
  void
  setup() {}
  void
  render(int frame) {}
  void
  tear_down() {}
};


/**
 * An animator factory returns an animator for the give page number of
 * a document.
 *
 */
class animator_factory
{
  animator* make_animator(pdfcube::document& doc, int page_no)
  {
    switch(doc.page(page_no).transition_type())
      {
      case POPPLER_PAGE_TRANSITION_REPLACE:
        return new replace_animator(doc, page_no);
      case POPPLER_PAGE_TRANSITION_BOX:
        return new cube_animator(doc, page_no);
      default:
        return new replace_animator(doc, page_no);
      }
    return NULL;
  }
};

// a main to quick-test some clutter api
int main(int argc, char* argv[])
{
  // --------------
  // Initialization
  // --------------

  pdfcube::app the_app;

  the_app.init(&argc, &argv);

  the_app.main_loop();

  /*
  // --------------------------
  // arrange pages in an index
  // TODO: move in an animation
  // --------------------------
  guint screen_w = 0;
  guint screen_h = 0;
  clutter_stage_fullscreen (CLUTTER_STAGE (stage));
  clutter_actor_get_size(CLUTTER_ACTOR(stage), &screen_w, &screen_h);

  double frows = ::sqrt(doc.n_pages());
  double fcols = std::ceil(((double)doc.n_pages())/std::floor(frows));

  int cols = std::floor(fcols);
  int rows = frows;

  double box_w = ((double)screen_w)/cols;
  double box_h = ((double)screen_h)/rows;
  double min_padding = 6;

  for(int ii(0); ii != doc.n_pages(); ++ii)
    {
      int row = ii%cols;
      int col = ii/cols;
      double box_x = ((double)row*screen_w)/cols;
      double box_y = ((double)col*screen_h)/rows;

      double aspect = doc.page(ii).aspect_ratio();
      
      double w = 0.0, h = 0.0;
      
      // Check if our slot ratio is less or more than owr own
      if(box_h > box_w/aspect)
        {
          w = box_w - min_padding*2;
          h = w/aspect;
        }
      else 
        {
          h = box_h - min_padding*2;
          w = h*aspect;
        }
      

      //cerr << w << ", " << h << ", " << aspect << endl;

      ClutterActor* page = 
        CLUTTER_ACTOR(doc.page(ii).actor(pdfcube::page::LOW_RES));
      clutter_actor_set_size(page, (int)w, (int)h);
      clutter_actor_set_position(page, 
                                 (int)(box_x + box_w/2),
                                 (int)(box_y + box_h/2));
      // THIS IS NOT RELATIVE TO ACTOR REAL SIZE, BUT TO ACTOR PERCEIVED SIZE
      clutter_actor_set_anchor_point_from_gravity(page, CLUTTER_GRAVITY_CENTER);
      clutter_group_add_many(CLUTTER_GROUP(stage), page, NULL);
      // Make actor reactive
      clutter_actor_set_reactive(page, TRUE);
      g_signal_connect (page, "enter-event",
                        G_CALLBACK (on_page_enter), NULL);
      g_signal_connect (page, "leave-event",
                        G_CALLBACK (on_page_leave), NULL);
    }

  // -------------------------

  // Connect a signal handler to handle mouse clicks and key presses
  //   on the stage: 
  g_signal_connect (stage, "button-press-event",
                    G_CALLBACK (on_stage_button_press), NULL);


  //clutter_stage_hide_cursor (CLUTTER_STAGE (stage));
  clutter_actor_show (stage);
  clutter_main ();
*/  
  return 0;
}