← Back to branch summary

~ubuntu-branches/ubuntu/precise/kompozer/precise

« back to all changes in this revision

Viewing changes to mozilla/embedding/browser/gtk/tests/TestGtkEmbed.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Anthony Yarusso
  • Date: 2007-08-27 01:11:03 UTC
  • Revision ID: james.westby@ubuntu.com-20070827011103-2jgf4s6532gqu2ka
Tags: upstream-0.7.10
Import upstream version 0.7.10

Show diffs side-by-side

added added

removed removed

Lines of Context:
mozilla/embedding/browser/gtk/tests/TestGtkEmbed.cpp
 
1
/*
 
2
 * The contents of this file are subject to the Mozilla Public
 
3
 * License Version 1.1 (the "License"); you may not use this file
 
4
 * except in compliance with the License. You may obtain a copy of
 
5
 * the License at http://www.mozilla.org/MPL/
 
6
 * 
 
7
 * Software distributed under the License is distributed on an "AS
 
8
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 
9
 * implied. See the License for the specific language governing
 
10
 * rights and limitations under the License.
 
11
 * 
 
12
 * The Original Code is mozilla.org code.
 
13
 * 
 
14
 * The Initial Developer of the Original Code is Christopher Blizzard.
 
15
 * Portions created by Christopher Blizzard are Copyright (C)
 
16
 * Christopher Blizzard.  All Rights Reserved.
 
17
 * 
 
18
 * Contributor(s):
 
19
 *   Christopher Blizzard <blizzard@mozilla.org>
 
20
 */
 
21
 
 
22
#include "gtkmozembed.h"
 
23
#include <gtk/gtk.h>
 
24
#include <stdio.h>
 
25
#include <string.h>
 
26
#include <stdlib.h>
 
27
 
 
28
// mozilla specific headers
 
29
#include "nsIDOMKeyEvent.h"
 
30
#include "nsIDOMMouseEvent.h"
 
31
#include "prenv.h"
 
32
 
 
33
#ifdef NS_TRACE_MALLOC
 
34
#include "nsTraceMalloc.h"
 
35
#endif
 
36
 
 
37
#ifdef MOZ_JPROF
 
38
#include "jprof.h"
 
39
#endif
 
40
 
 
41
typedef struct _TestGtkBrowser {
 
42
  GtkWidget  *topLevelWindow;
 
43
  GtkWidget  *topLevelVBox;
 
44
  GtkWidget  *menuBar;
 
45
  GtkWidget  *fileMenuItem;
 
46
  GtkWidget  *fileMenu;
 
47
  GtkWidget  *fileOpenNewBrowser;
 
48
  GtkWidget  *fileStream;
 
49
  GtkWidget  *fileClose;
 
50
  GtkWidget  *fileQuit;
 
51
  GtkWidget  *toolbarHBox;
 
52
  GtkWidget  *toolbar;
 
53
  GtkWidget  *backButton;
 
54
  GtkWidget  *stopButton;
 
55
  GtkWidget  *forwardButton;
 
56
  GtkWidget  *reloadButton;
 
57
  GtkWidget  *urlEntry;
 
58
  GtkWidget  *mozEmbed;
 
59
  GtkWidget  *progressAreaHBox;
 
60
  GtkWidget  *progressBar;
 
61
  GtkWidget  *statusAlign;
 
62
  GtkWidget  *statusBar;
 
63
  const char *statusMessage;
 
64
  int         loadPercent;
 
65
  int         bytesLoaded;
 
66
  int         maxBytesLoaded;
 
67
  char       *tempMessage;
 
68
  gboolean menuBarOn;
 
69
  gboolean toolBarOn;
 
70
  gboolean locationBarOn;
 
71
  gboolean statusBarOn;
 
72
 
 
73
} TestGtkBrowser;
 
74
 
 
75
// the list of browser windows currently open
 
76
GList *browser_list = g_list_alloc();
 
77
 
 
78
static TestGtkBrowser *new_gtk_browser    (guint32 chromeMask);
 
79
static void            set_browser_visibility (TestGtkBrowser *browser,
 
80
                                               gboolean visibility);
 
81
 
 
82
static int num_browsers = 0;
 
83
 
 
84
// callbacks from the UI
 
85
static void     back_clicked_cb    (GtkButton   *button, 
 
86
                                    TestGtkBrowser *browser);
 
87
static void     stop_clicked_cb    (GtkButton   *button,
 
88
                                    TestGtkBrowser *browser);
 
89
static void     forward_clicked_cb (GtkButton   *button,
 
90
                                    TestGtkBrowser *browser);
 
91
static void     reload_clicked_cb  (GtkButton   *button,
 
92
                                    TestGtkBrowser *browser);
 
93
static void     url_activate_cb    (GtkEditable *widget, 
 
94
                                    TestGtkBrowser *browser);
 
95
static void     menu_open_new_cb   (GtkMenuItem *menuitem,
 
96
                                    TestGtkBrowser *browser);
 
97
static void     menu_stream_cb     (GtkMenuItem *menuitem,
 
98
                                    TestGtkBrowser *browser);
 
99
static void     menu_close_cb      (GtkMenuItem *menuitem,
 
100
                                    TestGtkBrowser *browser);
 
101
static void     menu_quit_cb       (GtkMenuItem *menuitem,
 
102
                                    TestGtkBrowser *browser);
 
103
static gboolean delete_cb          (GtkWidget *widget, GdkEventAny *event,
 
104
                                    TestGtkBrowser *browser);
 
105
static void     destroy_cb         (GtkWidget *widget,
 
106
                                    TestGtkBrowser *browser);
 
107
 
 
108
// callbacks from the widget
 
109
static void location_changed_cb  (GtkMozEmbed *embed, TestGtkBrowser *browser);
 
110
static void title_changed_cb     (GtkMozEmbed *embed, TestGtkBrowser *browser);
 
111
static void load_started_cb      (GtkMozEmbed *embed, TestGtkBrowser *browser);
 
112
static void load_finished_cb     (GtkMozEmbed *embed, TestGtkBrowser *browser);
 
113
static void net_state_change_cb  (GtkMozEmbed *embed, gint flags,
 
114
                                  guint status, TestGtkBrowser *browser);
 
115
static void net_state_change_all_cb (GtkMozEmbed *embed, const char *uri,
 
116
                                     gint flags, guint status,
 
117
                                     TestGtkBrowser *browser);
 
118
static void progress_change_cb   (GtkMozEmbed *embed, gint cur, gint max,
 
119
                                  TestGtkBrowser *browser);
 
120
static void progress_change_all_cb (GtkMozEmbed *embed, const char *uri,
 
121
                                    gint cur, gint max,
 
122
                                    TestGtkBrowser *browser);
 
123
static void link_message_cb      (GtkMozEmbed *embed, TestGtkBrowser *browser);
 
124
static void js_status_cb         (GtkMozEmbed *embed, TestGtkBrowser *browser);
 
125
static void new_window_cb        (GtkMozEmbed *embed,
 
126
                                  GtkMozEmbed **retval, guint chromemask,
 
127
                                  TestGtkBrowser *browser);
 
128
static void visibility_cb        (GtkMozEmbed *embed, 
 
129
                                  gboolean visibility,
 
130
                                  TestGtkBrowser *browser);
 
131
static void destroy_brsr_cb      (GtkMozEmbed *embed, TestGtkBrowser *browser);
 
132
static gint open_uri_cb          (GtkMozEmbed *embed, const char *uri,
 
133
                                  TestGtkBrowser *browser);
 
134
static void size_to_cb           (GtkMozEmbed *embed, gint width,
 
135
                                  gint height, TestGtkBrowser *browser);
 
136
static gint dom_key_down_cb      (GtkMozEmbed *embed, nsIDOMKeyEvent *event,
 
137
                                  TestGtkBrowser *browser);
 
138
static gint dom_key_press_cb     (GtkMozEmbed *embed, nsIDOMKeyEvent *event,
 
139
                                  TestGtkBrowser *browser);
 
140
static gint dom_key_up_cb        (GtkMozEmbed *embed, nsIDOMKeyEvent *event,
 
141
                                  TestGtkBrowser *browser);
 
142
static gint dom_mouse_down_cb    (GtkMozEmbed *embed, nsIDOMMouseEvent *event,
 
143
                                  TestGtkBrowser *browser);
 
144
static gint dom_mouse_up_cb      (GtkMozEmbed *embed, nsIDOMMouseEvent *event,
 
145
                                  TestGtkBrowser *browser);
 
146
static gint dom_mouse_click_cb   (GtkMozEmbed *embed, nsIDOMMouseEvent *event,
 
147
                                  TestGtkBrowser *browser);
 
148
static gint dom_mouse_dbl_click_cb (GtkMozEmbed *embed, 
 
149
                                  nsIDOMMouseEvent *event,
 
150
                                  TestGtkBrowser *browser);
 
151
static gint dom_mouse_over_cb    (GtkMozEmbed *embed, nsIDOMMouseEvent *event,
 
152
                                  TestGtkBrowser *browser);
 
153
static gint dom_mouse_out_cb     (GtkMozEmbed *embed, nsIDOMMouseEvent *event,
 
154
                                  TestGtkBrowser *browser);
 
155
 
 
156
// callbacks from the singleton object
 
157
static void new_window_orphan_cb (GtkMozEmbedSingle *embed,
 
158
                                  GtkMozEmbed **retval, guint chromemask,
 
159
                                  gpointer data);
 
160
 
 
161
// some utility functions
 
162
static void update_status_bar_text  (TestGtkBrowser *browser);
 
163
static void update_temp_message     (TestGtkBrowser *browser,
 
164
                                     const char *message);
 
165
static void update_nav_buttons      (TestGtkBrowser *browser);
 
166
 
 
167
int
 
168
main(int argc, char **argv)
 
169
{
 
170
#ifdef NS_TRACE_MALLOC
 
171
  argc = NS_TraceMallocStartupArgs(argc, argv);
 
172
#endif
 
173
 
 
174
  gtk_set_locale();
 
175
  gtk_init(&argc, &argv);
 
176
 
 
177
#ifdef MOZ_JPROF
 
178
  setupProfilingStuff();
 
179
#endif
 
180
 
 
181
  char *home_path;
 
182
  char *full_path;
 
183
  home_path = PR_GetEnv("HOME");
 
184
  if (!home_path) {
 
185
    fprintf(stderr, "Failed to get HOME\n");
 
186
    exit(1);
 
187
  }
 
188
  
 
189
  full_path = g_strdup_printf("%s/%s", home_path, ".TestGtkEmbed");
 
190
  
 
191
  gtk_moz_embed_set_profile_path(full_path, "TestGtkEmbed");
 
192
 
 
193
  TestGtkBrowser *browser = new_gtk_browser(GTK_MOZ_EMBED_FLAG_DEFAULTCHROME);
 
194
 
 
195
  // set our minimum size
 
196
  gtk_widget_set_usize(browser->mozEmbed, 400, 400);
 
197
 
 
198
  set_browser_visibility(browser, TRUE);
 
199
 
 
200
  if (argc > 1)
 
201
    gtk_moz_embed_load_url(GTK_MOZ_EMBED(browser->mozEmbed), argv[1]);
 
202
 
 
203
  // get the singleton object and hook up to its new window callback
 
204
  // so we can create orphaned windows.
 
205
 
 
206
  GtkMozEmbedSingle *single;
 
207
 
 
208
  single = gtk_moz_embed_single_get();
 
209
  if (!single) {
 
210
    fprintf(stderr, "Failed to get singleton embed object!\n");
 
211
    exit(1);
 
212
  }
 
213
 
 
214
  gtk_signal_connect(GTK_OBJECT(single), "new_window_orphan",
 
215
                     GTK_SIGNAL_FUNC(new_window_orphan_cb), NULL);
 
216
 
 
217
  gtk_main();
 
218
}
 
219
 
 
220
static TestGtkBrowser *
 
221
new_gtk_browser(guint32 chromeMask)
 
222
{
 
223
  guint32         actualChromeMask = chromeMask;
 
224
  TestGtkBrowser *browser = 0;
 
225
 
 
226
  num_browsers++;
 
227
 
 
228
  browser = g_new0(TestGtkBrowser, 1);
 
229
 
 
230
  browser_list = g_list_prepend(browser_list, browser);
 
231
 
 
232
  browser->menuBarOn = FALSE;
 
233
  browser->toolBarOn = FALSE;
 
234
  browser->locationBarOn = FALSE;
 
235
  browser->statusBarOn = FALSE;
 
236
 
 
237
  g_print("new_gtk_browser\n");
 
238
 
 
239
  if (chromeMask == GTK_MOZ_EMBED_FLAG_DEFAULTCHROME)
 
240
    actualChromeMask = GTK_MOZ_EMBED_FLAG_ALLCHROME;
 
241
 
 
242
  if (actualChromeMask & GTK_MOZ_EMBED_FLAG_MENUBARON)
 
243
  {
 
244
    browser->menuBarOn = TRUE;
 
245
    g_print("\tmenu bar\n");
 
246
  }
 
247
  if (actualChromeMask & GTK_MOZ_EMBED_FLAG_TOOLBARON)
 
248
  {
 
249
    browser->toolBarOn = TRUE;
 
250
    g_print("\ttool bar\n");
 
251
  }
 
252
  if (actualChromeMask & GTK_MOZ_EMBED_FLAG_LOCATIONBARON)
 
253
  {
 
254
    browser->locationBarOn = TRUE;
 
255
    g_print("\tlocation bar\n");
 
256
  }
 
257
  if (actualChromeMask & GTK_MOZ_EMBED_FLAG_STATUSBARON)
 
258
  {
 
259
    browser->statusBarOn = TRUE;
 
260
    g_print("\tstatus bar\n");
 
261
  }
 
262
 
 
263
  // create our new toplevel window
 
264
  browser->topLevelWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 
265
  // new vbox
 
266
  browser->topLevelVBox = gtk_vbox_new(FALSE, 0);
 
267
  // add it to the toplevel window
 
268
  gtk_container_add(GTK_CONTAINER(browser->topLevelWindow),
 
269
                    browser->topLevelVBox);
 
270
  // create our menu bar
 
271
  browser->menuBar = gtk_menu_bar_new();
 
272
  // create the file menu
 
273
  browser->fileMenuItem = gtk_menu_item_new_with_label("File");
 
274
  browser->fileMenu = gtk_menu_new();
 
275
  gtk_menu_item_set_submenu (GTK_MENU_ITEM(browser->fileMenuItem),
 
276
                             browser->fileMenu);
 
277
 
 
278
  browser->fileOpenNewBrowser = 
 
279
    gtk_menu_item_new_with_label("Open New Browser");
 
280
  gtk_menu_append(GTK_MENU(browser->fileMenu),
 
281
                  browser->fileOpenNewBrowser);
 
282
  
 
283
  browser->fileStream =
 
284
    gtk_menu_item_new_with_label("Test Stream");
 
285
  gtk_menu_append(GTK_MENU(browser->fileMenu),
 
286
                  browser->fileStream);
 
287
 
 
288
  browser->fileClose =
 
289
    gtk_menu_item_new_with_label("Close");
 
290
  gtk_menu_append(GTK_MENU(browser->fileMenu),
 
291
                  browser->fileClose);
 
292
 
 
293
  browser->fileQuit =
 
294
    gtk_menu_item_new_with_label("Quit");
 
295
  gtk_menu_append(GTK_MENU(browser->fileMenu),
 
296
                  browser->fileQuit);
 
297
  
 
298
  // append it
 
299
  gtk_menu_bar_append(GTK_MENU_BAR(browser->menuBar), browser->fileMenuItem);
 
300
 
 
301
  // add it to the vbox
 
302
  gtk_box_pack_start(GTK_BOX(browser->topLevelVBox),
 
303
                     browser->menuBar,
 
304
                     FALSE, // expand
 
305
                     FALSE, // fill
 
306
                     0);    // padding
 
307
  // create the hbox that will contain the toolbar and the url text entry bar
 
308
  browser->toolbarHBox = gtk_hbox_new(FALSE, 0);
 
309
  // add that hbox to the vbox
 
310
  gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), 
 
311
                     browser->toolbarHBox,
 
312
                     FALSE, // expand
 
313
                     FALSE, // fill
 
314
                     0);    // padding
 
315
  // new horiz toolbar with buttons + icons
 
316
#ifdef MOZ_WIDGET_GTK
 
317
  browser->toolbar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL,
 
318
                                     GTK_TOOLBAR_BOTH);
 
319
#endif /* MOZ_WIDGET_GTK */
 
320
 
 
321
#ifdef MOZ_WIDGET_GTK2
 
322
  browser->toolbar = gtk_toolbar_new();
 
323
  gtk_toolbar_set_orientation(GTK_TOOLBAR(browser->toolbar),
 
324
                              GTK_ORIENTATION_HORIZONTAL);
 
325
  gtk_toolbar_set_style(GTK_TOOLBAR(browser->toolbar),
 
326
                        GTK_TOOLBAR_BOTH);
 
327
#endif /* MOZ_WIDGET_GTK2 */
 
328
 
 
329
  // add it to the hbox
 
330
  gtk_box_pack_start(GTK_BOX(browser->toolbarHBox), browser->toolbar,
 
331
                   FALSE, // expand
 
332
                   FALSE, // fill
 
333
                   0);    // padding
 
334
  // new back button
 
335
  browser->backButton =
 
336
    gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
 
337
                            "Back",
 
338
                            "Go Back",
 
339
                            "Go Back",
 
340
                            0, // XXX replace with icon
 
341
                            GTK_SIGNAL_FUNC(back_clicked_cb),
 
342
                            browser);
 
343
  // new stop button
 
344
  browser->stopButton = 
 
345
    gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
 
346
                            "Stop",
 
347
                            "Stop",
 
348
                            "Stop",
 
349
                            0, // XXX replace with icon
 
350
                            GTK_SIGNAL_FUNC(stop_clicked_cb),
 
351
                            browser);
 
352
  // new forward button
 
353
  browser->forwardButton =
 
354
    gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
 
355
                            "Forward",
 
356
                            "Forward",
 
357
                            "Forward",
 
358
                            0, // XXX replace with icon
 
359
                            GTK_SIGNAL_FUNC(forward_clicked_cb),
 
360
                            browser);
 
361
  // new reload button
 
362
  browser->reloadButton = 
 
363
    gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
 
364
                            "Reload",
 
365
                            "Reload",
 
366
                            "Reload",
 
367
                            0, // XXX replace with icon
 
368
                            GTK_SIGNAL_FUNC(reload_clicked_cb),
 
369
                            browser);
 
370
  // create the url text entry
 
371
  browser->urlEntry = gtk_entry_new();
 
372
  // add it to the hbox
 
373
  gtk_box_pack_start(GTK_BOX(browser->toolbarHBox), browser->urlEntry,
 
374
                     TRUE, // expand
 
375
                     TRUE, // fill
 
376
                     0);    // padding
 
377
  // create our new gtk moz embed widget
 
378
  browser->mozEmbed = gtk_moz_embed_new();
 
379
  // add it to the toplevel vbox
 
380
  gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), browser->mozEmbed,
 
381
                     TRUE, // expand
 
382
                     TRUE, // fill
 
383
                     0);   // padding
 
384
  // create the new hbox for the progress area
 
385
  browser->progressAreaHBox = gtk_hbox_new(FALSE, 0);
 
386
  // add it to the vbox
 
387
  gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), browser->progressAreaHBox,
 
388
                     FALSE, // expand
 
389
                     FALSE, // fill
 
390
                     0);   // padding
 
391
  // create our new progress bar
 
392
  browser->progressBar = gtk_progress_bar_new();
 
393
  // add it to the hbox
 
394
  gtk_box_pack_start(GTK_BOX(browser->progressAreaHBox), browser->progressBar,
 
395
                     FALSE, // expand
 
396
                     FALSE, // fill
 
397
                     0); // padding
 
398
  
 
399
  // create our status area and the alignment object that will keep it
 
400
  // from expanding
 
401
  browser->statusAlign = gtk_alignment_new(0, 0, 1, 1);
 
402
  gtk_widget_set_usize(browser->statusAlign, 1, -1);
 
403
  // create the status bar
 
404
  browser->statusBar = gtk_statusbar_new();
 
405
  gtk_container_add(GTK_CONTAINER(browser->statusAlign), browser->statusBar);
 
406
  // add it to the hbox
 
407
  gtk_box_pack_start(GTK_BOX(browser->progressAreaHBox), browser->statusAlign,
 
408
                     TRUE, // expand
 
409
                     TRUE, // fill
 
410
                     0);   // padding
 
411
  // by default none of the buttons are marked as sensitive.
 
412
  gtk_widget_set_sensitive(browser->backButton, FALSE);
 
413
  gtk_widget_set_sensitive(browser->stopButton, FALSE);
 
414
  gtk_widget_set_sensitive(browser->forwardButton, FALSE);
 
415
  gtk_widget_set_sensitive(browser->reloadButton, FALSE);
 
416
  
 
417
  // catch the destruction of the toplevel window
 
418
  gtk_signal_connect(GTK_OBJECT(browser->topLevelWindow), "delete_event",
 
419
                     GTK_SIGNAL_FUNC(delete_cb), browser);
 
420
 
 
421
  // hook up the activate signal to the right callback
 
422
  gtk_signal_connect(GTK_OBJECT(browser->urlEntry), "activate",
 
423
                     GTK_SIGNAL_FUNC(url_activate_cb), browser);
 
424
 
 
425
  // hook up to the open new browser activation
 
426
  gtk_signal_connect(GTK_OBJECT(browser->fileOpenNewBrowser), "activate",
 
427
                     GTK_SIGNAL_FUNC(menu_open_new_cb), browser);
 
428
  // hook up to the stream test
 
429
  gtk_signal_connect(GTK_OBJECT(browser->fileStream), "activate",
 
430
                     GTK_SIGNAL_FUNC(menu_stream_cb), browser);
 
431
  // close this window
 
432
  gtk_signal_connect(GTK_OBJECT(browser->fileClose), "activate",
 
433
                     GTK_SIGNAL_FUNC(menu_close_cb), browser);
 
434
  // quit the application
 
435
  gtk_signal_connect(GTK_OBJECT(browser->fileQuit), "activate",
 
436
                     GTK_SIGNAL_FUNC(menu_quit_cb), browser);
 
437
 
 
438
  // hook up the location change to update the urlEntry
 
439
  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "location",
 
440
                     GTK_SIGNAL_FUNC(location_changed_cb), browser);
 
441
  // hook up the title change to update the window title
 
442
  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "title",
 
443
                     GTK_SIGNAL_FUNC(title_changed_cb), browser);
 
444
  // hook up the start and stop signals
 
445
  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_start",
 
446
                     GTK_SIGNAL_FUNC(load_started_cb), browser);
 
447
  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_stop",
 
448
                     GTK_SIGNAL_FUNC(load_finished_cb), browser);
 
449
  // hook up to the change in network status
 
450
  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_state",
 
451
                     GTK_SIGNAL_FUNC(net_state_change_cb), browser);
 
452
  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_state_all",
 
453
                     GTK_SIGNAL_FUNC(net_state_change_all_cb), browser);
 
454
  // hookup to changes in progress
 
455
  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "progress",
 
456
                     GTK_SIGNAL_FUNC(progress_change_cb), browser);
 
457
  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "progress_all",
 
458
                     GTK_SIGNAL_FUNC(progress_change_all_cb), browser);
 
459
  // hookup to changes in over-link message
 
460
  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "link_message",
 
461
                     GTK_SIGNAL_FUNC(link_message_cb), browser);
 
462
  // hookup to changes in js status message
 
463
  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "js_status",
 
464
                     GTK_SIGNAL_FUNC(js_status_cb), browser);
 
465
  // hookup to see whenever a new window is requested
 
466
  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "new_window",
 
467
                     GTK_SIGNAL_FUNC(new_window_cb), browser);
 
468
  // hookup to any requested visibility changes
 
469
  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "visibility",
 
470
                     GTK_SIGNAL_FUNC(visibility_cb), browser);
 
471
  // hookup to the signal that says that the browser requested to be
 
472
  // destroyed
 
473
  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "destroy_browser",
 
474
                     GTK_SIGNAL_FUNC(destroy_brsr_cb), browser);
 
475
  // hookup to the signal that is called when someone clicks on a link
 
476
  // to load a new uri
 
477
  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "open_uri",
 
478
                     GTK_SIGNAL_FUNC(open_uri_cb), browser);
 
479
  // this signal is emitted when there's a request to change the
 
480
  // containing browser window to a certain height, like with width
 
481
  // and height args for a window.open in javascript
 
482
  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "size_to",
 
483
                     GTK_SIGNAL_FUNC(size_to_cb), browser);
 
484
  // key event signals
 
485
  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_key_down",
 
486
                     GTK_SIGNAL_FUNC(dom_key_down_cb), browser);
 
487
  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_key_press",
 
488
                     GTK_SIGNAL_FUNC(dom_key_press_cb), browser);
 
489
  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_key_up",
 
490
                     GTK_SIGNAL_FUNC(dom_key_up_cb), browser);
 
491
  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_down",
 
492
                     GTK_SIGNAL_FUNC(dom_mouse_down_cb), browser);
 
493
  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_up",
 
494
                     GTK_SIGNAL_FUNC(dom_mouse_up_cb), browser);
 
495
  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_click",
 
496
                     GTK_SIGNAL_FUNC(dom_mouse_click_cb), browser);
 
497
  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_dbl_click",
 
498
                     GTK_SIGNAL_FUNC(dom_mouse_dbl_click_cb), browser);
 
499
  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_over",
 
500
                     GTK_SIGNAL_FUNC(dom_mouse_over_cb), browser);
 
501
  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_out",
 
502
                     GTK_SIGNAL_FUNC(dom_mouse_out_cb), browser);
 
503
  // hookup to when the window is destroyed
 
504
  gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "destroy",
 
505
                     GTK_SIGNAL_FUNC(destroy_cb), browser);
 
506
  
 
507
  // set the chrome type so it's stored in the object
 
508
  gtk_moz_embed_set_chrome_mask(GTK_MOZ_EMBED(browser->mozEmbed),
 
509
                                actualChromeMask);
 
510
 
 
511
  return browser;
 
512
}
 
513
 
 
514
void
 
515
set_browser_visibility (TestGtkBrowser *browser, gboolean visibility)
 
516
{
 
517
  if (!visibility)
 
518
  {
 
519
    gtk_widget_hide(browser->topLevelWindow);
 
520
    return;
 
521
  }
 
522
  
 
523
  if (browser->menuBarOn)
 
524
    gtk_widget_show_all(browser->menuBar);
 
525
  else
 
526
    gtk_widget_hide_all(browser->menuBar);
 
527
 
 
528
  // since they are on the same line here...
 
529
  if (browser->toolBarOn || browser->locationBarOn)
 
530
    gtk_widget_show_all(browser->toolbarHBox);
 
531
  else 
 
532
    gtk_widget_hide_all(browser->toolbarHBox);
 
533
 
 
534
  if (browser->statusBarOn)
 
535
    gtk_widget_show_all(browser->progressAreaHBox);
 
536
  else
 
537
    gtk_widget_hide_all(browser->progressAreaHBox);
 
538
 
 
539
  gtk_widget_show(browser->mozEmbed);
 
540
  gtk_widget_show(browser->topLevelVBox);
 
541
  gtk_widget_show(browser->topLevelWindow);
 
542
}
 
543
 
 
544
void
 
545
back_clicked_cb (GtkButton *button, TestGtkBrowser *browser)
 
546
{
 
547
  gtk_moz_embed_go_back(GTK_MOZ_EMBED(browser->mozEmbed));
 
548
}
 
549
 
 
550
void
 
551
stop_clicked_cb (GtkButton *button, TestGtkBrowser *browser)
 
552
{
 
553
  g_print("stop_clicked_cb\n");
 
554
  gtk_moz_embed_stop_load(GTK_MOZ_EMBED(browser->mozEmbed));
 
555
}
 
556
 
 
557
void
 
558
forward_clicked_cb (GtkButton *button, TestGtkBrowser *browser)
 
559
{
 
560
  g_print("forward_clicked_cb\n");
 
561
  gtk_moz_embed_go_forward(GTK_MOZ_EMBED(browser->mozEmbed));
 
562
}
 
563
 
 
564
void
 
565
reload_clicked_cb  (GtkButton *button, TestGtkBrowser *browser)
 
566
{
 
567
  g_print("reload_clicked_cb\n");
 
568
  GdkModifierType state = (GdkModifierType)0;
 
569
  gint x, y;
 
570
  gdk_window_get_pointer(NULL, &x, &y, &state);
 
571
  
 
572
  gtk_moz_embed_reload(GTK_MOZ_EMBED(browser->mozEmbed),
 
573
                       (state & GDK_SHIFT_MASK) ?
 
574
                       GTK_MOZ_EMBED_FLAG_RELOADBYPASSCACHE : 
 
575
                       GTK_MOZ_EMBED_FLAG_RELOADNORMAL);
 
576
}
 
577
 
 
578
void 
 
579
stream_clicked_cb  (GtkButton   *button, TestGtkBrowser *browser)
 
580
{
 
581
  const char *data;
 
582
  const char *data2;
 
583
  data = "<html>Hi";
 
584
  data2 = " there</html>\n";
 
585
  g_print("stream_clicked_cb\n");
 
586
  gtk_moz_embed_open_stream(GTK_MOZ_EMBED(browser->mozEmbed),
 
587
                            "file://", "text/html");
 
588
  gtk_moz_embed_append_data(GTK_MOZ_EMBED(browser->mozEmbed),
 
589
                            data, strlen(data));
 
590
  gtk_moz_embed_append_data(GTK_MOZ_EMBED(browser->mozEmbed),
 
591
                            data2, strlen(data2));
 
592
  gtk_moz_embed_close_stream(GTK_MOZ_EMBED(browser->mozEmbed));
 
593
}
 
594
 
 
595
void
 
596
url_activate_cb    (GtkEditable *widget, TestGtkBrowser *browser)
 
597
{
 
598
  gchar *text = gtk_editable_get_chars(widget, 0, -1);
 
599
  g_print("loading url %s\n", text);
 
600
  gtk_moz_embed_load_url(GTK_MOZ_EMBED(browser->mozEmbed), text);
 
601
  g_free(text);
 
602
}
 
603
 
 
604
void
 
605
menu_open_new_cb   (GtkMenuItem *menuitem, TestGtkBrowser *browser)
 
606
{
 
607
  g_print("opening new browser.\n");
 
608
  TestGtkBrowser *newBrowser = 
 
609
    new_gtk_browser(GTK_MOZ_EMBED_FLAG_DEFAULTCHROME);
 
610
  gtk_widget_set_usize(newBrowser->mozEmbed, 400, 400);
 
611
  set_browser_visibility(newBrowser, TRUE);
 
612
}
 
613
 
 
614
void
 
615
menu_stream_cb     (GtkMenuItem *menuitem, TestGtkBrowser *browser)
 
616
{
 
617
  g_print("menu_stream_cb\n");
 
618
  const char *data;
 
619
  const char *data2;
 
620
  data = "<html>Hi";
 
621
  data2 = " there</html>\n";
 
622
  g_print("stream_clicked_cb\n");
 
623
  gtk_moz_embed_open_stream(GTK_MOZ_EMBED(browser->mozEmbed),
 
624
                            "file://", "text/html");
 
625
  gtk_moz_embed_append_data(GTK_MOZ_EMBED(browser->mozEmbed),
 
626
                            data, strlen(data));
 
627
  gtk_moz_embed_append_data(GTK_MOZ_EMBED(browser->mozEmbed),
 
628
                            data2, strlen(data2));
 
629
  gtk_moz_embed_close_stream(GTK_MOZ_EMBED(browser->mozEmbed));
 
630
}
 
631
 
 
632
void
 
633
menu_close_cb (GtkMenuItem *menuitem, TestGtkBrowser *browser)
 
634
{
 
635
  gtk_widget_destroy(browser->topLevelWindow);
 
636
}
 
637
 
 
638
void
 
639
menu_quit_cb (GtkMenuItem *menuitem, TestGtkBrowser *browser)
 
640
{
 
641
  TestGtkBrowser *tmpBrowser;
 
642
  GList *tmp_list = browser_list;
 
643
  tmpBrowser = (TestGtkBrowser *)tmp_list->data;
 
644
  while (tmpBrowser) {
 
645
    tmp_list = tmp_list->next;
 
646
    gtk_widget_destroy(tmpBrowser->topLevelWindow);
 
647
    tmpBrowser = (TestGtkBrowser *)tmp_list->data;
 
648
  }
 
649
}
 
650
 
 
651
gboolean
 
652
delete_cb(GtkWidget *widget, GdkEventAny *event, TestGtkBrowser *browser)
 
653
{
 
654
  g_print("delete_cb\n");
 
655
  gtk_widget_destroy(widget);
 
656
  return TRUE;
 
657
}
 
658
 
 
659
void
 
660
destroy_cb         (GtkWidget *widget, TestGtkBrowser *browser)
 
661
{
 
662
  GList *tmp_list;
 
663
  g_print("destroy_cb\n");
 
664
  num_browsers--;
 
665
  tmp_list = g_list_find(browser_list, browser);
 
666
  browser_list = g_list_remove_link(browser_list, tmp_list);
 
667
  if (browser->tempMessage)
 
668
    g_free(browser->tempMessage);
 
669
  if (num_browsers == 0)
 
670
    gtk_main_quit();
 
671
}
 
672
 
 
673
void
 
674
location_changed_cb (GtkMozEmbed *embed, TestGtkBrowser *browser)
 
675
{
 
676
  char *newLocation;
 
677
  int   newPosition = 0;
 
678
  g_print("location_changed_cb\n");
 
679
  newLocation = gtk_moz_embed_get_location(embed);
 
680
  if (newLocation)
 
681
  {
 
682
    gtk_editable_delete_text(GTK_EDITABLE(browser->urlEntry), 0, -1);
 
683
    gtk_editable_insert_text(GTK_EDITABLE(browser->urlEntry),
 
684
                             newLocation, strlen(newLocation), &newPosition);
 
685
    g_free(newLocation);
 
686
  }
 
687
  else
 
688
    g_print("failed to get location!\n");
 
689
  // always make sure to clear the tempMessage.  it might have been
 
690
  // set from the link before a click and we wouldn't have gotten the
 
691
  // callback to unset it.
 
692
  update_temp_message(browser, 0);
 
693
  // update the nav buttons on a location change
 
694
  update_nav_buttons(browser);
 
695
}
 
696
 
 
697
void
 
698
title_changed_cb    (GtkMozEmbed *embed, TestGtkBrowser *browser)
 
699
{
 
700
  char *newTitle;
 
701
  g_print("title_changed_cb\n");
 
702
  newTitle = gtk_moz_embed_get_title(embed);
 
703
  if (newTitle)
 
704
  {
 
705
    gtk_window_set_title(GTK_WINDOW(browser->topLevelWindow), newTitle);
 
706
    g_free(newTitle);
 
707
  }
 
708
  
 
709
}
 
710
 
 
711
void
 
712
load_started_cb     (GtkMozEmbed *embed, TestGtkBrowser *browser)
 
713
{
 
714
  g_print("load_started_cb\n");
 
715
  gtk_widget_set_sensitive(browser->stopButton, TRUE);
 
716
  gtk_widget_set_sensitive(browser->reloadButton, FALSE);
 
717
  browser->loadPercent = 0;
 
718
  browser->bytesLoaded = 0;
 
719
  browser->maxBytesLoaded = 0;
 
720
  update_status_bar_text(browser);
 
721
}
 
722
 
 
723
void
 
724
load_finished_cb    (GtkMozEmbed *embed, TestGtkBrowser *browser)
 
725
{
 
726
  g_print("load_finished_cb\n");
 
727
  gtk_widget_set_sensitive(browser->stopButton, FALSE);
 
728
  gtk_widget_set_sensitive(browser->reloadButton, TRUE);
 
729
  browser->loadPercent = 0;
 
730
  browser->bytesLoaded = 0;
 
731
  browser->maxBytesLoaded = 0;
 
732
  update_status_bar_text(browser);
 
733
  gtk_progress_set_percentage(GTK_PROGRESS(browser->progressBar), 0);
 
734
}
 
735
 
 
736
 
 
737
void
 
738
net_state_change_cb (GtkMozEmbed *embed, gint flags, guint status,
 
739
                     TestGtkBrowser *browser)
 
740
{
 
741
  g_print("net_state_change_cb %d\n", flags);
 
742
  if (flags & GTK_MOZ_EMBED_FLAG_IS_REQUEST) {
 
743
    if (flags & GTK_MOZ_EMBED_FLAG_REDIRECTING)
 
744
    browser->statusMessage = "Redirecting to site...";
 
745
    else if (flags & GTK_MOZ_EMBED_FLAG_TRANSFERRING)
 
746
    browser->statusMessage = "Transferring data from site...";
 
747
    else if (flags & GTK_MOZ_EMBED_FLAG_NEGOTIATING)
 
748
    browser->statusMessage = "Waiting for authorization...";
 
749
  }
 
750
 
 
751
  if (status == GTK_MOZ_EMBED_STATUS_FAILED_DNS)
 
752
    browser->statusMessage = "Site not found.";
 
753
  else if (status == GTK_MOZ_EMBED_STATUS_FAILED_CONNECT)
 
754
    browser->statusMessage = "Failed to connect to site.";
 
755
  else if (status == GTK_MOZ_EMBED_STATUS_FAILED_TIMEOUT)
 
756
    browser->statusMessage = "Failed due to connection timeout.";
 
757
  else if (status == GTK_MOZ_EMBED_STATUS_FAILED_USERCANCELED)
 
758
    browser->statusMessage = "User canceled connecting to site.";
 
759
 
 
760
  if (flags & GTK_MOZ_EMBED_FLAG_IS_DOCUMENT) {
 
761
    if (flags & GTK_MOZ_EMBED_FLAG_START)
 
762
      browser->statusMessage = "Loading site...";
 
763
    else if (flags & GTK_MOZ_EMBED_FLAG_STOP)
 
764
      browser->statusMessage = "Done.";
 
765
  }
 
766
 
 
767
  update_status_bar_text(browser);
 
768
  
 
769
}
 
770
 
 
771
void net_state_change_all_cb (GtkMozEmbed *embed, const char *uri,
 
772
                                     gint flags, guint status,
 
773
                                     TestGtkBrowser *browser)
 
774
{
 
775
  //  g_print("net_state_change_all_cb %s %d %d\n", uri, flags, status);
 
776
}
 
777
 
 
778
void progress_change_cb   (GtkMozEmbed *embed, gint cur, gint max,
 
779
                           TestGtkBrowser *browser)
 
780
{
 
781
  g_print("progress_change_cb cur %d max %d\n", cur, max);
 
782
 
 
783
  // avoid those pesky divide by zero errors
 
784
  if (max < 1)
 
785
  {
 
786
    gtk_progress_set_activity_mode(GTK_PROGRESS(browser->progressBar), FALSE);
 
787
    browser->loadPercent = 0;
 
788
    browser->bytesLoaded = cur;
 
789
    browser->maxBytesLoaded = 0;
 
790
    update_status_bar_text(browser);
 
791
  }
 
792
  else
 
793
  {
 
794
    browser->bytesLoaded = cur;
 
795
    browser->maxBytesLoaded = max;
 
796
    if (cur > max)
 
797
      browser->loadPercent = 100;
 
798
    else
 
799
      browser->loadPercent = (cur * 100) / max;
 
800
    update_status_bar_text(browser);
 
801
    gtk_progress_set_percentage(GTK_PROGRESS(browser->progressBar), browser->loadPercent / 100.0);
 
802
  }
 
803
  
 
804
}
 
805
 
 
806
void progress_change_all_cb (GtkMozEmbed *embed, const char *uri,
 
807
                             gint cur, gint max,
 
808
                             TestGtkBrowser *browser)
 
809
{
 
810
  //g_print("progress_change_all_cb %s cur %d max %d\n", uri, cur, max);
 
811
}
 
812
 
 
813
void
 
814
link_message_cb      (GtkMozEmbed *embed, TestGtkBrowser *browser)
 
815
{
 
816
  char *message;
 
817
  g_print("link_message_cb\n");
 
818
  message = gtk_moz_embed_get_link_message(embed);
 
819
  if (!message || !*message)
 
820
    update_temp_message(browser, 0);
 
821
  else
 
822
    update_temp_message(browser, message);
 
823
  if (message)
 
824
    g_free(message);
 
825
}
 
826
 
 
827
void
 
828
js_status_cb (GtkMozEmbed *embed, TestGtkBrowser *browser)
 
829
{
 
830
 char *message;
 
831
  g_print("js_status_cb\n");
 
832
  message = gtk_moz_embed_get_js_status(embed);
 
833
  if (!message || !*message)
 
834
    update_temp_message(browser, 0);
 
835
  else
 
836
    update_temp_message(browser, message);
 
837
  if (message)
 
838
    g_free(message);
 
839
}
 
840
 
 
841
void
 
842
new_window_cb (GtkMozEmbed *embed, GtkMozEmbed **newEmbed, guint chromemask, TestGtkBrowser *browser)
 
843
{
 
844
  g_print("new_window_cb\n");
 
845
  g_print("embed is %p chromemask is %d\n", (void *)embed, chromemask);
 
846
  TestGtkBrowser *newBrowser = new_gtk_browser(chromemask);
 
847
  gtk_widget_set_usize(newBrowser->mozEmbed, 400, 400);
 
848
  *newEmbed = GTK_MOZ_EMBED(newBrowser->mozEmbed);
 
849
  g_print("new browser is %p\n", (void *)*newEmbed);
 
850
}
 
851
 
 
852
void
 
853
visibility_cb (GtkMozEmbed *embed, gboolean visibility, TestGtkBrowser *browser)
 
854
{
 
855
  g_print("visibility_cb %d\n", visibility);
 
856
  set_browser_visibility(browser, visibility);
 
857
}
 
858
 
 
859
void
 
860
destroy_brsr_cb      (GtkMozEmbed *embed, TestGtkBrowser *browser)
 
861
{
 
862
  g_print("destroy_brsr_cb\n");
 
863
  gtk_widget_destroy(browser->topLevelWindow);
 
864
}
 
865
 
 
866
gint
 
867
open_uri_cb          (GtkMozEmbed *embed, const char *uri, TestGtkBrowser *browser)
 
868
{
 
869
  g_print("open_uri_cb %s\n", uri);
 
870
 
 
871
  // interrupt this test load
 
872
  if (!strcmp(uri, "http://people.redhat.com/blizzard/monkeys.txt"))
 
873
    return TRUE;
 
874
  // don't interrupt anything
 
875
  return FALSE;
 
876
}
 
877
 
 
878
void
 
879
size_to_cb (GtkMozEmbed *embed, gint width, gint height,
 
880
            TestGtkBrowser *browser)
 
881
{
 
882
  g_print("*** size_to_cb %d %d\n", width, height);
 
883
  gtk_widget_set_usize(browser->mozEmbed, width, height);
 
884
}
 
885
 
 
886
gint dom_key_down_cb      (GtkMozEmbed *embed, nsIDOMKeyEvent *event,
 
887
                           TestGtkBrowser *browser)
 
888
{
 
889
  PRUint32 keyCode = 0;
 
890
  //  g_print("dom_key_down_cb\n");
 
891
  event->GetKeyCode(&keyCode);
 
892
  // g_print("key code is %d\n", keyCode);
 
893
  return NS_OK;
 
894
}
 
895
 
 
896
gint dom_key_press_cb     (GtkMozEmbed *embed, nsIDOMKeyEvent *event,
 
897
                           TestGtkBrowser *browser)
 
898
{
 
899
  PRUint32 keyCode = 0;
 
900
  // g_print("dom_key_press_cb\n");
 
901
  event->GetCharCode(&keyCode);
 
902
  // g_print("char code is %d\n", keyCode);
 
903
  return NS_OK;
 
904
}
 
905
 
 
906
gint dom_key_up_cb        (GtkMozEmbed *embed, nsIDOMKeyEvent *event,
 
907
                           TestGtkBrowser *browser)
 
908
{
 
909
  PRUint32 keyCode = 0;
 
910
  // g_print("dom_key_up_cb\n");
 
911
  event->GetKeyCode(&keyCode);
 
912
  // g_print("key code is %d\n", keyCode);
 
913
  return NS_OK;
 
914
}
 
915
 
 
916
gint dom_mouse_down_cb    (GtkMozEmbed *embed, nsIDOMMouseEvent *event,
 
917
                           TestGtkBrowser *browser)
 
918
{
 
919
  //  g_print("dom_mouse_down_cb\n");
 
920
  return NS_OK;
 
921
 }
 
922
 
 
923
gint dom_mouse_up_cb      (GtkMozEmbed *embed, nsIDOMMouseEvent *event,
 
924
                           TestGtkBrowser *browser)
 
925
{
 
926
  //  g_print("dom_mouse_up_cb\n");
 
927
  return NS_OK;
 
928
}
 
929
 
 
930
gint dom_mouse_click_cb   (GtkMozEmbed *embed, nsIDOMMouseEvent *event,
 
931
                           TestGtkBrowser *browser)
 
932
{
 
933
  //  g_print("dom_mouse_click_cb\n");
 
934
  PRUint16 button;
 
935
  event->GetButton(&button);
 
936
  printf("button was %d\n", button);
 
937
  return NS_OK;
 
938
}
 
939
 
 
940
gint dom_mouse_dbl_click_cb (GtkMozEmbed *embed, nsIDOMMouseEvent *event,
 
941
                             TestGtkBrowser *browser)
 
942
{
 
943
  //  g_print("dom_mouse_dbl_click_cb\n");
 
944
  return NS_OK;
 
945
}
 
946
 
 
947
gint dom_mouse_over_cb    (GtkMozEmbed *embed, nsIDOMMouseEvent *event,
 
948
                           TestGtkBrowser *browser)
 
949
{
 
950
  //g_print("dom_mouse_over_cb\n");
 
951
  return NS_OK;
 
952
}
 
953
 
 
954
gint dom_mouse_out_cb     (GtkMozEmbed *embed, nsIDOMMouseEvent *event,
 
955
                           TestGtkBrowser *browser)
 
956
{
 
957
  //g_print("dom_mouse_out_cb\n");
 
958
  return NS_OK;
 
959
}
 
960
 
 
961
void new_window_orphan_cb (GtkMozEmbedSingle *embed,
 
962
                           GtkMozEmbed **retval, guint chromemask,
 
963
                           gpointer data)
 
964
{
 
965
  g_print("new_window_orphan_cb\n");
 
966
  g_print("chromemask is %d\n", chromemask);
 
967
  TestGtkBrowser *newBrowser = new_gtk_browser(chromemask);
 
968
  *retval = GTK_MOZ_EMBED(newBrowser->mozEmbed);
 
969
  g_print("new browser is %p\n", (void *)*retval);
 
970
}
 
971
 
 
972
// utility functions
 
973
 
 
974
void
 
975
update_status_bar_text(TestGtkBrowser *browser)
 
976
{
 
977
  gchar message[256];
 
978
  
 
979
  gtk_statusbar_pop(GTK_STATUSBAR(browser->statusBar), 1);
 
980
  if (browser->tempMessage)
 
981
    gtk_statusbar_push(GTK_STATUSBAR(browser->statusBar), 1, browser->tempMessage);
 
982
  else
 
983
  {
 
984
    if (browser->loadPercent)
 
985
    {
 
986
      g_snprintf(message, 255, "%s (%d%% complete, %d bytes of %d loaded)", browser->statusMessage, browser->loadPercent, browser->bytesLoaded, browser->maxBytesLoaded);
 
987
    }
 
988
    else if (browser->bytesLoaded)
 
989
    {
 
990
      g_snprintf(message, 255, "%s (%d bytes loaded)", browser->statusMessage, browser->bytesLoaded);
 
991
    }
 
992
    else if (browser->statusMessage == NULL)
 
993
    {
 
994
      g_snprintf(message, 255, " ");
 
995
    }
 
996
    else
 
997
    {
 
998
      g_snprintf(message, 255, "%s", browser->statusMessage);
 
999
    }
 
1000
    gtk_statusbar_push(GTK_STATUSBAR(browser->statusBar), 1, message);
 
1001
  }
 
1002
}
 
1003
 
 
1004
void
 
1005
update_temp_message(TestGtkBrowser *browser, const char *message)
 
1006
{
 
1007
  if (browser->tempMessage)
 
1008
    g_free(browser->tempMessage);
 
1009
  if (message)
 
1010
    browser->tempMessage = g_strdup(message);
 
1011
  else
 
1012
    browser->tempMessage = 0;
 
1013
  // now that we've updated the temp message, redraw the status bar
 
1014
  update_status_bar_text(browser);
 
1015
}
 
1016
 
 
1017
 
 
1018
void
 
1019
update_nav_buttons      (TestGtkBrowser *browser)
 
1020
{
 
1021
  gboolean can_go_back;
 
1022
  gboolean can_go_forward;
 
1023
  can_go_back = gtk_moz_embed_can_go_back(GTK_MOZ_EMBED(browser->mozEmbed));
 
1024
  can_go_forward = gtk_moz_embed_can_go_forward(GTK_MOZ_EMBED(browser->mozEmbed));
 
1025
  if (can_go_back)
 
1026
    gtk_widget_set_sensitive(browser->backButton, TRUE);
 
1027
  else
 
1028
    gtk_widget_set_sensitive(browser->backButton, FALSE);
 
1029
  if (can_go_forward)
 
1030
    gtk_widget_set_sensitive(browser->forwardButton, TRUE);
 
1031
  else
 
1032
    gtk_widget_set_sensitive(browser->forwardButton, FALSE);
 
1033
 }
 
1034