gui/pythonmod/gnash-view.cpp

   1 // gnash-view.cpp: Gtk view widget for gnash
   2 //
   3 //   Copyright (C) 2009, 2010, 2011 Free Software Foundation, Inc.
   4 //
   5 // This program is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; either version 3 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software
  17 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18 //
  19
  20 #include "gnash-view.h"
  21 #include "gtk_canvas.h"
  22
  23 #include <gdk/gdk.h>
  24 #include <gdk/gdkkeysyms.h>
  25 #include <gtk/gtkbutton.h>
  26
  27 #include "log.h"
  28
  29 #include "VM.h"
  30 #include "movie_definition.h"
  31 #include "MovieFactory.h"
  32 #include "movie_root.h" // for Abstract callbacks
  33 #include "Renderer.h"
  34 #include "sound_handler.h"
  35 #include "MediaHandler.h"
  36 #include "RunResources.h" // for passing handlers and other data to the core.
  37 #include "VirtualClock.h"
  38 #include "SystemClock.h"
  39 #include "smart_ptr.h"
  40 #include "DisplayObject.h"
  41 #include "Global_as.h"
  42 #include "NamingPolicy.h"
  43 #include "StreamProvider.h"
  44
  45 enum
  46 {
  47         PROP_0,
  48         PROP_URI
  49 };
  50
  51 struct _GnashView {
  52         GtkBin base_instance;
  53
  54     GnashCanvas *canvas;
  55     const gchar *uri;
  56     guint advance_timer;
  57
  58     boost::shared_ptr<gnash::media::MediaHandler> media_handler;
  59     boost::shared_ptr<gnash::sound::sound_handler> sound_handler;
  60
  61     /// Handlers (for sound etc) for a libcore run.
  62     //
  63     /// This must be kept alive for the entire lifetime of the movie_root
  64     /// (currently: of the Gui).
  65     std::auto_ptr<gnash::RunResources> run_info;
  66
  67     boost::intrusive_ptr<gnash::movie_definition> movie_definition;
  68     gnash::Movie* movie;
  69     std::auto_ptr<gnash::movie_root> stage;
  70     std::auto_ptr<gnash::SystemClock> system_clock;
  71     std::auto_ptr<gnash::InterruptableVirtualClock> virtual_clock;
  72 };
  73
  74 G_DEFINE_TYPE(GnashView, gnash_view, GTK_TYPE_BIN)
  75
  76 static GObjectClass *parent_class = NULL;
  77
  78 static void gnash_view_class_init(GnashViewClass *gnash_view_class);
  79 static void gnash_view_init(GnashView *view);
  80 static void gnash_view_size_allocate (GtkWidget *widget, GtkAllocation *allocation);
  81 static void gnash_view_size_request (GtkWidget *widget, GtkRequisition *requisition);
  82 static void gnash_view_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
  83 static void gnash_view_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
  84 static void gnash_view_realize_cb(GtkWidget *widget, gpointer user_data);
  85
  86 static gboolean key_press_event_cb(GtkWidget *widget, GdkEventKey *event, gpointer data);
  87 static gboolean key_release_event_cb(GtkWidget *widget, GdkEventKey *event, gpointer data);
  88 static gboolean button_press_event_cb(GtkWidget *widget, GdkEventButton *event, gpointer data);
  89 static gboolean button_release_event_cb(GtkWidget *widget, GdkEventButton *event, gpointer data);
  90 static gboolean motion_notify_event_cb(GtkWidget *widget, GdkEventMotion *event, gpointer data);
  91
  92 static gnash::key::code gdk_to_gnash_key(guint key);
  93 static int gdk_to_gnash_modifier(int state);
  94 static gboolean gnash_view_advance_movie(GnashView *view);
  95 static void gnash_view_display(GnashView *view);
  96 static void gnash_view_load_movie(GnashView *view, const gchar *path);
  97
  98 GtkWidget *
  99 gnash_view_new (void)
 100 {
 101     return GTK_WIDGET(g_object_new (GNASH_TYPE_VIEW, NULL));
 102 }
 103
 104 const gchar *
 105 gnash_view_call (GnashView *view, const gchar *func_name, const gchar *input_data)
 106 {
 107     gnash::VM& vm = view->stage->getVM();
 108         gnash::as_value obj;
 109
 110     gnash::as_value func = getMember(*getObject(view->movie), getURI(vm, func_name));
 111
 112     if( !func.is_function() ) {
 113         return NULL;
 114     }
 115
 116     gnash::as_value result;
 117     if( input_data ) {
 118         result = callMethod(getObject(view->movie),
 119                 getURI(vm, func_name), gnash::as_value(input_data));
 120     } else {
 121         result = callMethod(getObject(view->movie), getURI(vm, func_name));
 122     }
 123     if( !result.is_string() ) {
 124         return NULL;
 125     }
 126
 127     return result.to_string().c_str();
 128 }
 129
 130 static void
 131 gnash_view_class_init(GnashViewClass *gnash_view_class)
 132 {
 133     GNASH_REPORT_FUNCTION;
 134
 135     parent_class = (GObjectClass *) g_type_class_peek_parent(gnash_view_class);
 136
 137         GObjectClass *g_object_class = G_OBJECT_CLASS (gnash_view_class);
 138     GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (gnash_view_class);
 139
 140     widget_class->size_allocate = gnash_view_size_allocate;
 141     widget_class->size_request = gnash_view_size_request;
 142
 143         g_object_class->get_property = gnash_view_get_property;
 144         g_object_class->set_property = gnash_view_set_property;
 145
 146         g_object_class_install_property (g_object_class,
 147                                          PROP_URI,
 148                                          g_param_spec_string ("uri",
 149                                                               "URI to movie",
 150                                                               "URI to the SWF movie to display",
 151                                                               NULL,
 152                                                               (GParamFlags)G_PARAM_READWRITE));
 153 }
 154
 155 static void
 156 gnash_view_set_property (GObject      *object,
 157                          guint         prop_id,
 158                          const GValue *value,
 159                          GParamSpec   *pspec)
 160 {
 161     GnashView *view = GNASH_VIEW (object);
 162
 163     switch (prop_id)
 164     {
 165     case PROP_URI:
 166         if(view->movie_definition.get() != NULL) {
 167             g_warning("Cannot change the movie URI once the view has been initialized.");
 168             return;
 169         }
 170         view->uri = g_strdup(g_value_get_string (value));
 171         break;
 172     default:
 173         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 174     }
 175 }
 176
 177 static void
 178 gnash_view_get_property (GObject *object,
 179                          guint prop_id,
 180                          GValue *value,
 181                          GParamSpec *pspec)
 182 {
 183     GnashView *view = GNASH_VIEW (object);
 184
 185         switch (prop_id)
 186         {
 187         case PROP_URI:
 188                 g_value_set_string (value, view->uri);
 189                 break;
 190         default:
 191                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 192         }
 193 }
 194
 195 static void
 196 gnash_view_init(GnashView *view)
 197 {
 198     GNASH_REPORT_FUNCTION;
 199
 200     view->uri = NULL;
 201     view->advance_timer = 0;
 202
 203         g_signal_connect (GTK_WIDGET(view), "realize",
 204                           G_CALLBACK (gnash_view_realize_cb), NULL);
 205
 206     // Initializations that can happen before realization come here. The rest
 207     // come after realize, in gnash_view_realize_cb.
 208     gnash::LogFile& dbglogfile = gnash::LogFile::getDefaultInstance();
 209     dbglogfile.setVerbosity(3);
 210
 211     // Use the default media handler.
 212     // TODO: allow setting this.
 213     view->media_handler.reset(gnash::media::MediaFactory::instance().get(""));
 214
 215     // Init sound
 216 #ifdef SOUND_SDL
 217     try {
 218         view->sound_handler.reset(gnash::sound::create_sound_handler_sdl(
 219                 view->media_handler.get()));
 220     } catch (gnash::SoundException& ex) {
 221         gnash::log_error(_("Could not create sound handler: %s."
 222                            " Will continue w/out sound."), ex.what());
 223     }
 224     gnash::log_error(_("Sound requested but no sound support compiled in"));
 225 #endif
 226
 227     view->canvas = GNASH_CANVAS(gnash_canvas_new());
 228     std::string nullstr;
 229     gnash_canvas_setup(view->canvas, nullstr, nullstr, 0, NULL);
 230     gtk_container_add (GTK_CONTAINER (view), GTK_WIDGET(view->canvas));
 231     gtk_widget_show (GTK_WIDGET(view->canvas));
 232
 233     gtk_widget_add_events(GTK_WIDGET(view->canvas), GDK_BUTTON_PRESS_MASK
 234                         | GDK_BUTTON_RELEASE_MASK
 235                         | GDK_KEY_RELEASE_MASK
 236                         | GDK_KEY_PRESS_MASK
 237                         | GDK_POINTER_MOTION_MASK);
 238
 239     g_signal_connect_object(GTK_WIDGET(view->canvas), "key-press-event",
 240                    G_CALLBACK(key_press_event_cb), view, (GConnectFlags)0);
 241     g_signal_connect_object(GTK_WIDGET(view->canvas), "key-release-event",
 242                    G_CALLBACK(key_release_event_cb), view, (GConnectFlags)0);
 243     g_signal_connect_object(GTK_WIDGET(view->canvas), "button-press-event",
 244                    G_CALLBACK(button_press_event_cb), view, (GConnectFlags)0);
 245     g_signal_connect_object(GTK_WIDGET(view->canvas), "button-release-event",
 246                    G_CALLBACK(button_release_event_cb), view, (GConnectFlags)0);
 247     g_signal_connect_object(GTK_WIDGET(view->canvas), "motion-notify-event",
 248                    G_CALLBACK(motion_notify_event_cb), view, (GConnectFlags)0);
 249 }
 250
 251 static void
 252 gnash_view_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
 253 {
 254     GnashView *view = GNASH_VIEW(widget);
 255     widget->allocation = *allocation;
 256     gtk_widget_size_allocate (GTK_BIN(widget)->child, allocation);
 257
 258     if( view->stage.get() != NULL) {
 259         view->stage->setDimensions(allocation->width, allocation->height);
 260
 261         boost::shared_ptr<gnash::Renderer> renderer = gnash_canvas_get_renderer(view->canvas);
 262         float xscale = allocation->width / view->movie_definition->get_width_pixels();
 263         float yscale = allocation->height / view->movie_definition->get_height_pixels();
 264                 renderer->set_scale(xscale, yscale);
 265     }
 266 }
 267
 268 static void
 269 gnash_view_size_request (GtkWidget *widget, GtkRequisition *requisition)
 270 {
 271     GnashView *view = GNASH_VIEW(widget);
 272     if( view->movie_definition.get() == NULL ) {
 273         requisition->width = 0;
 274         requisition->height = 0;
 275     } else {
 276         requisition->width = view->movie_definition->get_width_pixels();
 277         requisition->height = view->movie_definition->get_height_pixels();
 278     }
 279 }
 280
 281 static void
 282 gnash_view_realize_cb(GtkWidget *widget, gpointer /*user_data*/)
 283 {
 284     GNASH_REPORT_FUNCTION;
 285     GnashView *view = GNASH_VIEW(widget);
 286
 287     // Some initializations need to happen after the widget has been realized.
 288     if(view->movie_definition.get() == NULL) {
 289         gtk_widget_realize(GTK_WIDGET(view->canvas));
 290         gnash_view_load_movie(view, view->uri);
 291     }
 292 }
 293
 294 static gboolean
 295 key_press_event_cb(GtkWidget */*widget*/, GdkEventKey *event, gpointer data)
 296 {
 297     GNASH_REPORT_FUNCTION;
 298     GnashView *view = GNASH_VIEW(data);
 299     if (view->stage.get() == NULL)
 300         return FALSE;
 301
 302     gnash::key::code c = gdk_to_gnash_key(event->keyval);
 303
 304     if (c != gnash::key::INVALID) {
 305         if( view->stage->keyEvent(c, true) )
 306             gnash_view_display(view);
 307         return TRUE;
 308     }
 309
 310     return FALSE;
 311 }
 312
 313 static gboolean
 314 key_release_event_cb(GtkWidget */*widget*/, GdkEventKey *event, gpointer data)
 315 {
 316     GNASH_REPORT_FUNCTION;
 317     GnashView *view = GNASH_VIEW(data);
 318     if (view->stage.get() == NULL)
 319         return FALSE;
 320
 321     gnash::key::code c = gdk_to_gnash_key(event->keyval);
 322
 323     if (c != gnash::key::INVALID) {
 324         if( view->stage->keyEvent(c, false) )
 325             gnash_view_display(view);
 326         return TRUE;
 327     }
 328
 329     return FALSE;
 330 }
 331
 332 static gboolean
 333 button_press_event_cb(GtkWidget */*widget*/, GdkEventButton *event, gpointer data)
 334 {
 335     GNASH_REPORT_FUNCTION;
 336     GnashView *view = GNASH_VIEW(data);
 337     if (view->stage.get() == NULL)
 338         return FALSE;
 339
 340     /// Double- and triple-clicks should not send an extra event!
 341     /// Flash has no built-in double click.
 342     if (event->type != GDK_BUTTON_PRESS) return FALSE;
 343
 344     gtk_widget_grab_focus(GTK_WIDGET(view->canvas));
 345
 346     view->stage->mouseClick(true);
 347
 348     return TRUE;
 349 }
 350
 351 static gboolean
 352 button_release_event_cb(GtkWidget* /*widget*/, GdkEventButton* /*event*/,
 353         gpointer data)
 354 {
 355     GNASH_REPORT_FUNCTION;
 356     GnashView *view = GNASH_VIEW(data);
 357     if (view->stage.get() == NULL)
 358         return FALSE;
 359
 360     view->stage->mouseClick(false);
 361
 362     return TRUE;
 363 }
 364
 365 static gboolean
 366 motion_notify_event_cb(GtkWidget */*widget*/, GdkEventMotion *event, gpointer data)
 367 {
 368     //GNASH_REPORT_FUNCTION;
 369
 370     GtkWidget *widget = GTK_WIDGET(data);
 371     GnashView *view = GNASH_VIEW(data);
 372     float xscale = widget->allocation.width / view->movie_definition->get_width_pixels();
 373     float yscale = widget->allocation.height / view->movie_definition->get_height_pixels();
 374
 375         // A stage pseudopixel is user pixel / _xscale wide
 376         boost::int32_t x = event->x / xscale;
 377
 378         // A stage pseudopixel is user pixel / _yscale high
 379         boost::int32_t y = event->y / yscale;
 380
 381         if ( view->stage->mouseMoved(x, y) )
 382         {
 383                 // any action triggered by the
 384                 // event required screen refresh
 385         gnash_view_display(view);
 386         }
 387
 388         gnash::DisplayObject* activeEntity = view->stage->getActiveEntityUnderPointer();
 389         if ( activeEntity )
 390         {
 391                 if ( activeEntity->isSelectableTextField() )
 392                 {
 393                     GdkCursor *gdkcursor = gdk_cursor_new(GDK_XTERM);
 394                     gdk_window_set_cursor (widget->window, NULL);
 395             gdk_cursor_unref(gdkcursor);
 396                 }
 397                 else if ( activeEntity->allowHandCursor() )
 398                 {
 399                     GdkCursor *gdkcursor = gdk_cursor_new(GDK_HAND2);
 400                     gdk_window_set_cursor (widget->window, NULL);
 401             gdk_cursor_unref(gdkcursor);
 402                 }
 403                 else
 404                 {
 405                     gdk_window_set_cursor (widget->window, NULL);
 406                 }
 407         }
 408         else
 409         {
 410             gdk_window_set_cursor (widget->window, NULL);
 411         }
 412
 413     return TRUE;
 414 }
 415
 416 static void
 417 gnash_view_load_movie(GnashView *view, const gchar *uri)
 418 {
 419
 420     gnash::URL url(uri);
 421
 422     // The RunResources should be populated before parsing.
 423     view->run_info.reset(new gnash::RunResources());
 424     view->run_info->setSoundHandler(view->sound_handler);
 425
 426     std::auto_ptr<gnash::NamingPolicy> np(new gnash::IncrementalRename(url));
 427     boost::shared_ptr<gnash::StreamProvider> sp(
 428             new gnash::StreamProvider(url, url, np));
 429     view->run_info->setStreamProvider(sp);
 430
 431     gnash::RcInitFile& rcfile = gnash::RcInitFile::getDefaultInstance();
 432
 433     if ( url.protocol() == "file" ) {
 434         const std::string& str_path(url.path());
 435
 436         size_t lastSlash = str_path.find_last_of('/');
 437         std::string dir = str_path.substr(0, lastSlash + 1);
 438         rcfile.addLocalSandboxPath(dir);
 439         gnash::log_debug(_("%s appended to local sandboxes"), dir.c_str());
 440
 441         rcfile.addLocalSandboxPath(str_path);
 442         gnash::log_debug(_("%s appended to local sandboxes"), str_path.c_str());
 443     }
 444
 445     // Load the actual movie.
 446     view->movie_definition = gnash::MovieFactory::makeMovie(url,
 447             *view->run_info, url.str().c_str(), false);
 448
 449     g_return_if_fail(view->movie_definition.get() != NULL);
 450
 451     // NOTE: it's important that _systemClock is constructed
 452     //       before and destroyed after _virtualClock !
 453     view->system_clock.reset(new gnash::SystemClock());
 454     view->virtual_clock.reset(new gnash::InterruptableVirtualClock(*view->system_clock));
 455     view->stage.reset(new gnash::movie_root(*view->movie_definition, *view->virtual_clock, *view->run_info));
 456
 457     view->movie_definition->completeLoad();
 458
 459     view->advance_timer = g_timeout_add_full(G_PRIORITY_LOW, 10,
 460             (GSourceFunc)gnash_view_advance_movie, view, NULL);
 461
 462     gtk_widget_queue_resize (GTK_WIDGET(view));
 463
 464     //view->movie.reset (view->movie_definition->createMovie());
 465
 466     std::map<std::string, std::string> variables;
 467     gnash::URL::parse_querystring(url.querystring(), variables);
 468
 469     gnash::Movie* m = view->stage->init(view->movie_definition.get(), variables);
 470     view->movie = m;
 471
 472     view->stage->set_background_alpha(1.0f);
 473
 474     // @todo since we registered the sound handler, shouldn't we know
 475     //       already what it is ?!
 476     gnash::sound::sound_handler* s = view->stage->runResources().soundHandler();
 477     if ( s ) s->unpause();
 478
 479     gnash::log_debug("Starting virtual clock");
 480     view->virtual_clock->resume();
 481
 482     gnash_view_advance_movie(view);
 483 }
 484
 485 static gboolean
 486 gnash_view_advance_movie(GnashView *view)
 487 {
 488     view->stage->advance();
 489
 490     gnash_view_display(view);
 491
 492     return TRUE;
 493 }
 494
 495 static void
 496 gnash_view_display(GnashView *view)
 497 {
 498     gnash::InvalidatedRanges changed_ranges;
 499     changed_ranges.setWorld();
 500
 501     boost::shared_ptr<gnash::Renderer> renderer = gnash_canvas_get_renderer(view->canvas);
 502     renderer->set_invalidated_regions(changed_ranges);
 503     gdk_window_invalidate_rect(GTK_WIDGET(view->canvas)->window, NULL, false);
 504
 505     gnash_canvas_before_rendering(view->canvas, view->stage.get());
 506         view->stage->display();
 507
 508     gdk_window_process_updates(GTK_WIDGET(view->canvas)->window, false);
 509 }
 510
 511 static gnash::key::code
 512 gdk_to_gnash_key(guint key)
 513 {
 514     gnash::key::code c(gnash::key::INVALID);
 515
 516     // ascii 32-126 in one range:
 517     if (key >= GDK_space && key <= GDK_asciitilde) {
 518         c = (gnash::key::code) ((key - GDK_space) + gnash::key::SPACE);
 519     }
 520
 521     // Function keys:
 522     else if (key >= GDK_F1 && key <= GDK_F15)   {
 523         c = (gnash::key::code) ((key - GDK_F1) + gnash::key::F1);
 524     }
 525
 526     // Keypad:
 527     else if (key >= GDK_KP_0 && key <= GDK_KP_9) {
 528         c = (gnash::key::code) ((key - GDK_KP_0) + gnash::key::KP_0);
 529     }
 530
 531     // Extended ascii:
 532     else if (key >= GDK_nobreakspace && key <= GDK_ydiaeresis) {
 533         c = (gnash::key::code) ((key - GDK_nobreakspace) +
 534                 gnash::key::NOBREAKSPACE);
 535     }
 536
 537     // non-character keys don't correlate, so use a look-up table.
 538     else {
 539         struct {
 540             guint             gdk;
 541             gnash::key::code  gs;
 542         } table[] = {
 543             { GDK_BackSpace, gnash::key::BACKSPACE },
 544             { GDK_Tab, gnash::key::TAB },
 545             { GDK_Clear, gnash::key::CLEAR },
 546             { GDK_Return, gnash::key::ENTER },
 547
 548             { GDK_Shift_L, gnash::key::SHIFT },
 549             { GDK_Shift_R, gnash::key::SHIFT },
 550             { GDK_Control_L, gnash::key::CONTROL },
 551             { GDK_Control_R, gnash::key::CONTROL },
 552             { GDK_Alt_L, gnash::key::ALT },
 553             { GDK_Alt_R, gnash::key::ALT },
 554             { GDK_Caps_Lock, gnash::key::CAPSLOCK },
 555
 556             { GDK_Escape, gnash::key::ESCAPE },
 557
 558             { GDK_Page_Down, gnash::key::PGDN },
 559             { GDK_Page_Up, gnash::key::PGUP },
 560             { GDK_Home, gnash::key::HOME },
 561             { GDK_End, gnash::key::END },
 562             { GDK_Left, gnash::key::LEFT },
 563             { GDK_Up, gnash::key::UP },
 564             { GDK_Right, gnash::key::RIGHT },
 565             { GDK_Down, gnash::key::DOWN },
 566             { GDK_Insert, gnash::key::INSERT },
 567             { GDK_Delete, gnash::key::DELETEKEY },
 568
 569             { GDK_Help, gnash::key::HELP },
 570             { GDK_Num_Lock, gnash::key::NUM_LOCK },
 571
 572             { GDK_VoidSymbol, gnash::key::INVALID }
 573         };
 574
 575         for (int i = 0; table[i].gdk != GDK_VoidSymbol; i++) {
 576             if (key == table[i].gdk) {
 577                 c = table[i].gs;
 578                 break;
 579             }
 580         }
 581     }
 582
 583     return c;
 584 }
 585
 586 static int
 587 gdk_to_gnash_modifier(int state)
 588 {
 589     int modifier = gnash::key::GNASH_MOD_NONE;
 590
 591     if (state & GDK_SHIFT_MASK) {
 592       modifier = modifier | gnash::key::GNASH_MOD_SHIFT;
 593     }
 594     if (state & GDK_CONTROL_MASK) {
 595       modifier = modifier | gnash::key::GNASH_MOD_CONTROL;
 596     }
 597     if (state & GDK_MOD1_MASK) {
 598       modifier = modifier | gnash::key::GNASH_MOD_ALT;
 599     }
 600
 601     return modifier;
 602 }
 603