Imported version 0.1
[videolink.git] / 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 }