browserwidget.cpp

   1 // Copyright 2005 Ben Hutchings <ben@decadentplace.org.uk>.
   2 // See the file "COPYING" for licence details.
   3
   4 #include "browserwidget.hpp"
   5
   6 #include <cassert>
   7
   8 #include <gtkmozembed_internal.h>
   9
  10 BrowserWidget::BrowserWidget()
  11         : Gtk::Bin(GTK_BIN(gtk_moz_embed_new()))
  12 {
  13 }
  14 BrowserWidget::~BrowserWidget()
  15 {
  16 }
  17
  18 GtkMozEmbed * BrowserWidget::gobj()
  19 {
  20     return GTK_MOZ_EMBED(gobject_);
  21 }
  22 const GtkMozEmbed * BrowserWidget::gobj() const
  23 {
  24     return GTK_MOZ_EMBED(gobject_);
  25 }
  26
  27 void BrowserWidget::load_uri(const char * uri)
  28 {
  29     gtk_moz_embed_load_url(gobj(), uri);
  30 }
  31 void BrowserWidget::load_uri(const std::string & uri)
  32 {
  33     return load_uri(uri.c_str());
  34 }
  35 void BrowserWidget::stop_load()
  36 {
  37     gtk_moz_embed_stop_load(gobj());
  38 }
  39 void BrowserWidget::go_back()
  40 {
  41     gtk_moz_embed_go_back(gobj());
  42 }
  43 void BrowserWidget::go_forward()
  44 {
  45     gtk_moz_embed_go_forward(gobj());
  46 }
  47 void BrowserWidget::reload(gint32 flags)
  48 {
  49     gtk_moz_embed_reload(gobj(), flags);
  50 }
  51
  52 bool BrowserWidget::can_go_back() const
  53 {
  54     return gtk_moz_embed_can_go_back(const_cast<GtkMozEmbed *>(gobj()));
  55 }
  56 bool BrowserWidget::can_go_forward() const
  57 {
  58     return gtk_moz_embed_can_go_forward(const_cast<GtkMozEmbed *>(gobj()));
  59 }
  60
  61 namespace
  62 {
  63     template<typename T>
  64     class c_scoped_ptr
  65     {
  66     public:
  67         explicit c_scoped_ptr(T * p = 0) : p_(p) {}
  68         ~c_scoped_ptr() { free(p_); }
  69         T * get() const { return p_; }
  70         T * release()
  71         {
  72             T * p = p_;
  73             p_ = NULL;
  74             return p;
  75         }
  76         void reset(T * p = 0)
  77         {
  78             free(p_);
  79             p_ = p;
  80         }
  81     private:
  82         T * p_;
  83     };
  84 }
  85
  86 std::string BrowserWidget::get_link_message() const
  87 {
  88     c_scoped_ptr<char> str(
  89         gtk_moz_embed_get_link_message(const_cast<GtkMozEmbed *>(gobj())));
  90     return std::string(str.get());
  91 }
  92 std::string BrowserWidget::get_js_status() const
  93 {
  94     c_scoped_ptr<char> str(
  95         gtk_moz_embed_get_js_status(const_cast<GtkMozEmbed *>(gobj())));
  96     return std::string(str.get());
  97 }
  98 std::string BrowserWidget::get_title() const
  99 {
 100     c_scoped_ptr<char> str(
 101         gtk_moz_embed_get_title(const_cast<GtkMozEmbed *>(gobj())));
 102     return std::string(str.get());
 103 }
 104 std::string BrowserWidget::get_location() const
 105 {
 106     c_scoped_ptr<char> str(
 107         gtk_moz_embed_get_location(const_cast<GtkMozEmbed *>(gobj())));
 108     return std::string(str.get());
 109 }
 110 already_AddRefed<nsIWebBrowser> BrowserWidget::get_browser()
 111 {
 112     nsIWebBrowser * result = 0;
 113     gtk_moz_embed_get_nsIWebBrowser(gobj(), &result);
 114     assert(result);
 115     return dont_AddRef(result);
 116 }
 117
 118 namespace
 119 {
 120     void BrowserWidget_signal_link_message_callback(GtkMozEmbed * self, void * data)
 121     {
 122         typedef SigC::Slot0<void> SlotType;
 123
 124         if (Glib::ObjectBase::_get_current_wrapper((GObject *)self))
 125         {
 126             try
 127             {
 128                 if (SigC::SlotNode * const slot =
 129                     Glib::SignalProxyNormal::data_to_slot(data))
 130                     (*(SlotType::Proxy)(slot->proxy_))(slot);
 131             }
 132             catch(...)
 133             {
 134                 Glib::exception_handlers_invoke();
 135             }
 136         }
 137     }
 138
 139     const Glib::SignalProxyInfo BrowserWidget_signal_link_message_info =
 140     {
 141         "link_message",
 142         (GCallback) &BrowserWidget_signal_link_message_callback,
 143         (GCallback) &BrowserWidget_signal_link_message_callback
 144     };
 145
 146     void BrowserWidget_signal_js_status_callback(GtkMozEmbed * self, void * data)
 147     {
 148         typedef SigC::Slot0<void> SlotType;
 149
 150         if (Glib::ObjectBase::_get_current_wrapper((GObject *)self))
 151         {
 152             try
 153             {
 154                 if (SigC::SlotNode * const slot =
 155                     Glib::SignalProxyNormal::data_to_slot(data))
 156                     (*(SlotType::Proxy)(slot->proxy_))(slot);
 157             }
 158             catch(...)
 159             {
 160                 Glib::exception_handlers_invoke();
 161             }
 162         }
 163     }
 164
 165     const Glib::SignalProxyInfo BrowserWidget_signal_js_status_info =
 166     {
 167         "js_status",
 168         (GCallback) &BrowserWidget_signal_js_status_callback,
 169         (GCallback) &BrowserWidget_signal_js_status_callback
 170     };
 171
 172     void BrowserWidget_signal_location_callback(GtkMozEmbed * self, void * data)
 173     {
 174         typedef SigC::Slot0<void> SlotType;
 175
 176         if (Glib::ObjectBase::_get_current_wrapper((GObject *)self))
 177         {
 178             try
 179             {
 180                 if (SigC::SlotNode * const slot =
 181                     Glib::SignalProxyNormal::data_to_slot(data))
 182                     (*(SlotType::Proxy)(slot->proxy_))(slot);
 183             }
 184             catch(...)
 185             {
 186                 Glib::exception_handlers_invoke();
 187             }
 188         }
 189     }
 190
 191     const Glib::SignalProxyInfo BrowserWidget_signal_location_info =
 192     {
 193         "location",
 194         (GCallback) &BrowserWidget_signal_location_callback,
 195         (GCallback) &BrowserWidget_signal_location_callback
 196     };
 197
 198     void BrowserWidget_signal_title_callback(GtkMozEmbed * self, void * data)
 199     {
 200         typedef SigC::Slot0<void> SlotType;
 201
 202         if (Glib::ObjectBase::_get_current_wrapper((GObject *)self))
 203         {
 204             try
 205             {
 206                 if (SigC::SlotNode * const slot =
 207                     Glib::SignalProxyNormal::data_to_slot(data))
 208                     (*(SlotType::Proxy)(slot->proxy_))(slot);
 209             }
 210             catch(...)
 211             {
 212                 Glib::exception_handlers_invoke();
 213             }
 214         }
 215     }
 216
 217     const Glib::SignalProxyInfo BrowserWidget_signal_title_info =
 218     {
 219         "title",
 220         (GCallback) &BrowserWidget_signal_title_callback,
 221         (GCallback) &BrowserWidget_signal_title_callback
 222     };
 223
 224     void BrowserWidget_signal_progress_callback(
 225         GtkMozEmbed * self, gint p0, gint p1, void * data)
 226     {
 227         typedef SigC::Slot2<void, gint, gint> SlotType;
 228
 229         if (Glib::ObjectBase::_get_current_wrapper((GObject *)self))
 230         {
 231             try
 232             {
 233                 if (SigC::SlotNode * const slot =
 234                     Glib::SignalProxyNormal::data_to_slot(data))
 235                     (*(SlotType::Proxy)(slot->proxy_))(p0, p1, slot);
 236             }
 237             catch(...)
 238             {
 239                 Glib::exception_handlers_invoke();
 240             }
 241         }
 242     }
 243
 244     const Glib::SignalProxyInfo BrowserWidget_signal_progress_info =
 245     {
 246         "progress",
 247         (GCallback) &BrowserWidget_signal_progress_callback,
 248         (GCallback) &BrowserWidget_signal_progress_callback
 249     };
 250
 251     void BrowserWidget_signal_net_state_callback(
 252         GtkMozEmbed * self, const char * p0, gint p1, guint p2, void * data)
 253     {
 254         typedef SigC::Slot3<void, const char *, gint, guint> SlotType;
 255
 256         if (Glib::ObjectBase::_get_current_wrapper((GObject *)self))
 257         {
 258             try
 259             {
 260                 if (SigC::SlotNode * const slot =
 261                     Glib::SignalProxyNormal::data_to_slot(data))
 262                     (*(SlotType::Proxy)(slot->proxy_))(p0, p1, p2, slot);
 263             }
 264             catch(...)
 265             {
 266                 Glib::exception_handlers_invoke();
 267             }
 268         }
 269     }
 270
 271     const Glib::SignalProxyInfo BrowserWidget_signal_net_state_info =
 272     {
 273         "net_state_all",
 274         (GCallback) &BrowserWidget_signal_net_state_callback,
 275         (GCallback) &BrowserWidget_signal_net_state_callback
 276     };
 277
 278     void BrowserWidget_signal_net_start_callback(GtkMozEmbed * self, void * data)
 279     {
 280         typedef SigC::Slot0<void> SlotType;
 281
 282         if (Glib::ObjectBase::_get_current_wrapper((GObject *)self))
 283         {
 284             try
 285             {
 286                 if (SigC::SlotNode * const slot =
 287                     Glib::SignalProxyNormal::data_to_slot(data))
 288                     (*(SlotType::Proxy)(slot->proxy_))(slot);
 289             }
 290             catch(...)
 291             {
 292                 Glib::exception_handlers_invoke();
 293             }
 294         }
 295     }
 296
 297     const Glib::SignalProxyInfo BrowserWidget_signal_net_start_info =
 298     {
 299         "net_start",
 300         (GCallback) &BrowserWidget_signal_net_start_callback,
 301         (GCallback) &BrowserWidget_signal_net_start_callback
 302     };
 303
 304     void BrowserWidget_signal_net_stop_callback(GtkMozEmbed * self, void * data)
 305     {
 306         typedef SigC::Slot0<void> SlotType;
 307
 308         if (Glib::ObjectBase::_get_current_wrapper((GObject *)self))
 309         {
 310             try
 311             {
 312                 if (SigC::SlotNode * const slot =
 313                     Glib::SignalProxyNormal::data_to_slot(data))
 314                     (*(SlotType::Proxy)(slot->proxy_))(slot);
 315             }
 316             catch(...)
 317             {
 318                 Glib::exception_handlers_invoke();
 319             }
 320         }
 321     }
 322
 323     const Glib::SignalProxyInfo BrowserWidget_signal_net_stop_info =
 324     {
 325         "net_stop",
 326         (GCallback) &BrowserWidget_signal_net_stop_callback,
 327         (GCallback) &BrowserWidget_signal_net_stop_callback
 328     };
 329
 330     void BrowserWidget_signal_new_window_callback(
 331         GtkMozEmbed * self, GtkMozEmbed ** p0, guint p1, void * data)
 332     {
 333         typedef SigC::Slot1<BrowserWidget *, guint> SlotType;
 334
 335         if (Glib::ObjectBase::_get_current_wrapper((GObject *)self))
 336         {
 337             try
 338             {
 339                 if (SigC::SlotNode * const slot =
 340                     Glib::SignalProxyNormal::data_to_slot(data))
 341                 {
 342                     if (BrowserWidget * result =
 343                         (*(SlotType::Proxy)(slot->proxy_))(p1, slot))
 344                     {
 345                         *p0 = result->gobj();
 346                         return;
 347                     }
 348                 }
 349             }
 350             catch(...)
 351             {
 352                 Glib::exception_handlers_invoke();
 353             }
 354         }
 355
 356         *p0 = NULL;
 357         return;
 358     }
 359
 360     const Glib::SignalProxyInfo BrowserWidget_signal_new_window_info =
 361     {
 362         "new_window",
 363         (GCallback) &BrowserWidget_signal_new_window_callback,
 364         (GCallback) &BrowserWidget_signal_new_window_callback
 365     };
 366
 367     void BrowserWidget_signal_visibility_callback(
 368         GtkMozEmbed * self, gboolean p0, void * data)
 369     {
 370         typedef SigC::Slot1<void, bool> SlotType;
 371
 372         if (Glib::ObjectBase::_get_current_wrapper((GObject *)self))
 373         {
 374             try
 375             {
 376                 if (SigC::SlotNode * const slot =
 377                     Glib::SignalProxyNormal::data_to_slot(data))
 378                     (*(SlotType::Proxy)(slot->proxy_))(p0, slot);
 379             }
 380             catch(...)
 381             {
 382                 Glib::exception_handlers_invoke();
 383             }
 384         }
 385     }
 386
 387     const Glib::SignalProxyInfo BrowserWidget_signal_visibility_info =
 388     {
 389         "visibility",
 390         (GCallback) &BrowserWidget_signal_visibility_callback,
 391         (GCallback) &BrowserWidget_signal_visibility_callback
 392     };
 393
 394     void BrowserWidget_signal_destroy_browser_callback(
 395         GtkMozEmbed * self, void * data)
 396     {
 397         typedef SigC::Slot0<void> SlotType;
 398
 399         if (Glib::ObjectBase::_get_current_wrapper((GObject *)self))
 400         {
 401             try
 402             {
 403                 if (SigC::SlotNode * const slot =
 404                     Glib::SignalProxyNormal::data_to_slot(data))
 405                     (*(SlotType::Proxy)(slot->proxy_))(slot);
 406             }
 407             catch(...)
 408             {
 409                 Glib::exception_handlers_invoke();
 410             }
 411         }
 412     }
 413
 414     const Glib::SignalProxyInfo BrowserWidget_signal_destroy_info =
 415     {
 416         "destroy_browser",
 417         (GCallback) &BrowserWidget_signal_destroy_browser_callback,
 418         (GCallback) &BrowserWidget_signal_destroy_browser_callback
 419     };
 420
 421     gint BrowserWidget_signal_open_uri_callback(
 422         GtkMozEmbed * self, const char * p0, void * data)
 423     {
 424         typedef SigC::Slot1<bool, const char *> SlotType;
 425
 426         if (Glib::ObjectBase::_get_current_wrapper((GObject *)self))
 427         {
 428             try
 429             {
 430                 if (SigC::SlotNode * const slot =
 431                     Glib::SignalProxyNormal::data_to_slot(data))
 432                     return (*(SlotType::Proxy)(slot->proxy_))(p0, slot);
 433             }
 434             catch(...)
 435             {
 436                 Glib::exception_handlers_invoke();
 437             }
 438         }
 439
 440         return 0;
 441     }
 442
 443     const Glib::SignalProxyInfo BrowserWidget_signal_open_uri_info =
 444     {
 445         "open_uri",
 446         (GCallback) &BrowserWidget_signal_open_uri_callback,
 447         (GCallback) &BrowserWidget_signal_open_uri_callback
 448     };
 449
 450 } // namespace
 451
 452 Glib::SignalProxy0<void> BrowserWidget::signal_link_message()
 453 {
 454     return Glib::SignalProxy0<void>(this, &BrowserWidget_signal_link_message_info);
 455 }
 456 Glib::SignalProxy0<void> BrowserWidget::signal_js_status()
 457 {
 458     return Glib::SignalProxy0<void>(this, &BrowserWidget_signal_js_status_info);
 459 }
 460 Glib::SignalProxy0<void> BrowserWidget::signal_location()
 461 {
 462     return Glib::SignalProxy0<void>(this, &BrowserWidget_signal_location_info);
 463 }
 464 Glib::SignalProxy0<void> BrowserWidget::signal_title()
 465 {
 466     return Glib::SignalProxy0<void>(this, &BrowserWidget_signal_title_info);
 467 }
 468 Glib::SignalProxy2<void, gint /*cur*/, gint /*max*/> BrowserWidget::signal_progress()
 469 {
 470     return Glib::SignalProxy2<void, gint, gint>(
 471         this, &BrowserWidget_signal_progress_info);
 472 }
 473 Glib::SignalProxy3<void, const char *, gint /*flags*/, guint /*status*/>
 474 BrowserWidget::signal_net_state()
 475 {
 476     return Glib::SignalProxy3<void, const char *, gint, guint>(
 477         this, &BrowserWidget_signal_net_state_info);
 478 }
 479 Glib::SignalProxy0<void> BrowserWidget::signal_net_start()
 480 {
 481     return Glib::SignalProxy0<void>(this, &BrowserWidget_signal_net_start_info);
 482 }
 483 Glib::SignalProxy0<void> BrowserWidget::signal_net_stop()
 484 {
 485     return Glib::SignalProxy0<void>(this, &BrowserWidget_signal_net_stop_info);
 486 }
 487 Glib::SignalProxy1<BrowserWidget *, guint /*chromemask*/> BrowserWidget::signal_new_window()
 488 {
 489     return Glib::SignalProxy1<BrowserWidget *, guint>(
 490         this, &BrowserWidget_signal_new_window_info);
 491 }
 492 Glib::SignalProxy1<void, bool /*visibility*/> BrowserWidget::signal_visibility()
 493 {
 494     return Glib::SignalProxy1<void, bool>(
 495         this, &BrowserWidget_signal_visibility_info);
 496 }
 497 Glib::SignalProxy0<void> BrowserWidget::signal_destroy()
 498 {
 499     return Glib::SignalProxy0<void>(this, &BrowserWidget_signal_destroy_info);
 500 }
 501 Glib::SignalProxy1<bool, const char * /*uri*/> BrowserWidget::signal_open_uri()
 502 {
 503     return Glib::SignalProxy1<bool, const char *>(
 504         this, &BrowserWidget_signal_open_uri_info);
 505 }
 506
 507 BrowserWidget::BrowserWidget(GObject * gobject, bool take_copy)
 508 {
 509     assert(GTK_MOZ_EMBED(gobject));
 510     gobject_ = gobject;
 511     if (take_copy)
 512         reference();
 513 }
 514 Glib::ObjectBase * BrowserWidget::wrap_new(GObject * gobject)
 515 {
 516     return new BrowserWidget(gobject, false);
 517 }
 518
 519 void BrowserWidget::init()
 520 {
 521     gtk_moz_embed_set_comp_path(MOZ_LIB_DIR);
 522     wrap_register(gtk_moz_embed_get_type(), wrap_new);
 523 }
 524
 525 namespace Glib
 526 {
 527     BrowserWidget * wrap(GtkMozEmbed * object, bool take_copy)
 528     {
 529         return dynamic_cast<BrowserWidget *>(
 530             Glib::wrap_auto((GObject*)(object), take_copy));
 531     }
 532 }