← Back to branch summary

~ubuntu-branches/ubuntu/natty/miro/natty

« back to all changes in this revision

Viewing changes to windows/plat/frontends/widgets/XULRunnerBrowser/MiroBrowserEmbed.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Bryce Harrington
  • Date: 2011-01-22 02:46:33 UTC
  • mfrom: (1.4.10 upstream) (1.7.5 experimental)
  • Revision ID: james.westby@ubuntu.com-20110122024633-kjme8u93y2il5nmf
Tags: 3.5.1-1ubuntu1
* Merge from debian.  Remaining ubuntu changes:
  - Use python 2.7 instead of python 2.6
  - Relax dependency on python-dbus to >= 0.83.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
windows/plat/frontends/widgets/XULRunnerBrowser/MiroBrowserEmbed.cpp
 
1
/*
 
2
 * Miro - an RSS based video player application
 
3
 * Copyright (C) 2005-2010 Participatory Culture Foundation
 
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 2 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
 * In addition, as a special exception, the copyright holders give
 
20
 * permission to link the code of portions of this program with the OpenSSL
 
21
 * library.
 
22
 *
 
23
 * You must obey the GNU General Public License in all respects for all of
 
24
 * the code used other than OpenSSL. If you modify file(s) with this
 
25
 * exception, you may extend this exception to your version of the file(s),
 
26
 * but you are not obligated to do so. If you do not wish to do so, delete
 
27
 * this exception statement from your version. If you delete this exception
 
28
 * statement from all source files in the program, then also delete it here.
 
29
**/
 
30
 
 
31
/*
 
32
 * MiroBrowserEmbed.cpp
 
33
 *
 
34
 * Implementation of our embedded xulrunner browser.
 
35
 */
 
36
 
 
37
#include <windows.h>
 
38
#include <Python.h>
 
39
#include "nsCOMPtr.h"
 
40
#include "nsComponentManagerUtils.h"
 
41
#include "nsEmbedCID.h"
 
42
#include "nsEmbedString.h"
 
43
#include "nsIDOMWindow.h"
 
44
#include "nsIInterfaceRequestorUtils.h"
 
45
#include "nsISupportsImpl.h"
 
46
#include "nsIWebBrowser.h"
 
47
#include "nsIWebBrowserFocus.h"
 
48
#include "docshell/nsDocShellCID.h"
 
49
#include "docshell/nsIDocShellTreeItem.h"
 
50
#include "docshell/nsIWebNavigationInfo.h"
 
51
#include "necko/nsIURI.h"
 
52
#include "xpcom/nsServiceManagerUtils.h"
 
53
 
 
54
#include "MiroBrowserEmbed.h"
 
55
#include "xulrunnerbrowser.h"
 
56
#include "FixFocus.h"
 
57
 
 
58
#include <stdio.h>
 
59
#include <string.h>
 
60
 
 
61
MiroBrowserEmbed::MiroBrowserEmbed()
 
62
{
 
63
    mWindow = nsnull;
 
64
    mFocusCallback = nsnull;
 
65
}
 
66
 
 
67
MiroBrowserEmbed::~MiroBrowserEmbed()
 
68
{
 
69
    log_info("destroying MiroBrowserEmbed");
 
70
}
 
71
 
 
72
nsresult MiroBrowserEmbed::init(unsigned long parentWindow, int x, 
 
73
        int y, int width, int height)
 
74
{
 
75
    nsresult rv;
 
76
 
 
77
    mWebBrowser = do_CreateInstance(NS_WEBBROWSER_CONTRACTID, &rv);
 
78
    NS_ENSURE_SUCCESS(rv, rv);
 
79
    mWindow = reinterpret_cast<nativeWindow>(parentWindow);
 
80
 
 
81
    mWebBrowser->SetContainerWindow(static_cast<nsIWebBrowserChrome*>(this));
 
82
 
 
83
    nsCOMPtr<nsIDocShellTreeItem> dsti = do_QueryInterface(mWebBrowser);
 
84
    dsti->SetItemType(nsIDocShellTreeItem::typeContentWrapper);
 
85
 
 
86
    nsCOMPtr<nsIBaseWindow> browserBaseWindow(do_QueryInterface(mWebBrowser));
 
87
    browserBaseWindow->InitWindow(mWindow, nsnull, x, y, width, height);
 
88
    browserBaseWindow->Create();
 
89
    browserBaseWindow->SetVisibility(PR_TRUE);
 
90
    browserBaseWindow->SetEnabled(PR_TRUE);
 
91
 
 
92
    install_focus_fixes((HWND)mWindow);
 
93
    rv = mWebBrowser->GetParentURIContentListener(
 
94
            getter_AddRefs(mParentContentListener));
 
95
    NS_ENSURE_SUCCESS(rv, rv);
 
96
    rv = mWebBrowser->SetParentURIContentListener(
 
97
            static_cast<nsIURIContentListener *>(this));
 
98
    NS_ENSURE_SUCCESS(rv, rv);
 
99
 
 
100
    nsCOMPtr<nsIWeakReference> weakRef;
 
101
    rv = GetWeakReference(getter_AddRefs(weakRef));
 
102
    NS_ENSURE_SUCCESS(rv, rv);
 
103
 
 
104
    rv = mWebBrowser->AddWebBrowserListener(weakRef,
 
105
            NS_GET_IID(nsIWebProgressListener));
 
106
    NS_ENSURE_SUCCESS(rv, rv);
 
107
    mWebNavigation = do_QueryInterface(mWebBrowser);
 
108
    return NS_OK;
 
109
}
 
110
 
 
111
nsresult MiroBrowserEmbed::disable()
 
112
{
 
113
    nsresult rv;
 
114
    nsCOMPtr<nsIBaseWindow> browserBaseWindow(do_QueryInterface(mWebBrowser));
 
115
 
 
116
    rv = browserBaseWindow->SetVisibility(PR_FALSE);
 
117
    NS_ENSURE_SUCCESS(rv, rv);
 
118
    rv = browserBaseWindow->SetEnabled(PR_FALSE);
 
119
    NS_ENSURE_SUCCESS(rv, rv);
 
120
    return NS_OK;
 
121
}
 
122
 
 
123
nsresult MiroBrowserEmbed::enable()
 
124
{
 
125
    nsresult rv;
 
126
    nsCOMPtr<nsIBaseWindow> browserBaseWindow(do_QueryInterface(mWebBrowser));
 
127
 
 
128
    rv = browserBaseWindow->SetVisibility(PR_TRUE);
 
129
    NS_ENSURE_SUCCESS(rv, rv);
 
130
    rv = browserBaseWindow->SetEnabled(PR_TRUE);
 
131
    NS_ENSURE_SUCCESS(rv, rv);
 
132
    rv = browserBaseWindow->Repaint(PR_FALSE);
 
133
    NS_ENSURE_SUCCESS(rv, rv);
 
134
    return NS_OK;
 
135
}
 
136
 
 
137
void MiroBrowserEmbed::destroy()
 
138
{
 
139
    nsCOMPtr<nsIBaseWindow> browserBaseWindow(do_QueryInterface(mWebBrowser));
 
140
    browserBaseWindow->Destroy();
 
141
}
 
142
 
 
143
PRBool MiroBrowserEmbed::is_enabled()
 
144
{
 
145
    PRBool enabled;
 
146
    nsCOMPtr<nsIBaseWindow> browserBaseWindow(do_QueryInterface(mWebBrowser));
 
147
    browserBaseWindow->GetEnabled(&enabled);
 
148
    return enabled;
 
149
}
 
150
 
 
151
// Load a URI into the browser
 
152
nsresult MiroBrowserEmbed::loadURI(const char* uri)
 
153
{
 
154
    mWebNavigation->LoadURI(NS_ConvertASCIItoUTF16(uri).get(),
 
155
            nsIWebNavigation::LOAD_FLAGS_NONE, 0, 0, 0);
 
156
    return NS_OK;
 
157
}
 
158
 
 
159
nsresult MiroBrowserEmbed::getCurrentURI(char ** uri)
 
160
{
 
161
    nsresult rv;
 
162
    nsCAutoString specString;
 
163
    nsIURI *aURI;
 
164
 
 
165
    rv = mWebNavigation->GetCurrentURI(&aURI);
 
166
    NS_ENSURE_SUCCESS(rv, rv);
 
167
 
 
168
    rv = aURI->GetSpec(specString);
 
169
    NS_ENSURE_SUCCESS(rv, rv);
 
170
 
 
171
    *uri = (char *) specString.get();
 
172
    return NS_OK;
 
173
}
 
174
 
 
175
nsresult MiroBrowserEmbed::getCurrentTitle(char ** aTitle, int* length)
 
176
{
 
177
    nsresult rv;
 
178
    nsISHistory *history;
 
179
    nsIHistoryEntry *historyentry;
 
180
    wchar_t *title;
 
181
    PRInt32 index;
 
182
 
 
183
    rv = mWebNavigation->GetSessionHistory(&history);
 
184
    NS_ENSURE_SUCCESS(rv, rv);
 
185
 
 
186
    rv = history->GetIndex(&index);
 
187
    NS_ENSURE_SUCCESS(rv, rv);
 
188
 
 
189
    rv = history->GetEntryAtIndex(index, PR_FALSE, &historyentry);
 
190
    NS_ENSURE_SUCCESS(rv, rv);
 
191
 
 
192
    rv = historyentry->GetTitle(&title);
 
193
    NS_ENSURE_SUCCESS(rv, rv);
 
194
 
 
195
    *aTitle = (char *)title;
 
196
    *length = (wcslen(title) + 1) * 2;
 
197
    return NS_OK;
 
198
}
 
199
 
 
200
// Called when the parent window changes size
 
201
nsresult MiroBrowserEmbed::resize(int x, int y, int width, int height)
 
202
{
 
203
    nsCOMPtr<nsIBaseWindow>browserBaseWindow(
 
204
            do_QueryInterface(mWebBrowser));
 
205
    if(!browserBaseWindow) return NS_ERROR_FAILURE;
 
206
    return browserBaseWindow->SetPositionAndSize(x, y, width, height,
 
207
            PR_TRUE);
 
208
}
 
209
 
 
210
// Give the browser keyboard focus
 
211
nsresult MiroBrowserEmbed::focus()
 
212
{
 
213
    nsCOMPtr<nsIWebBrowserFocus> browserFocus(
 
214
            do_GetInterface(mWebBrowser));
 
215
    if(!browserFocus) return NS_ERROR_FAILURE;
 
216
    return browserFocus->Activate();
 
217
}
 
218
 
 
219
// Set the focus callback.  This will be called when the user tabs through all
 
220
// the elements in the browser and the next Widget should be given focus.
 
221
void MiroBrowserEmbed::SetFocusCallback(focusCallback callback, void* data)
 
222
{
 
223
    mFocusCallback = callback;
 
224
    mFocusCallbackData = data;
 
225
}
 
226
 
 
227
void MiroBrowserEmbed::SetURICallback(uriCallback callback, void* data)
 
228
{
 
229
    mURICallback = callback;
 
230
    mURICallbackData = data;
 
231
}
 
232
 
 
233
void MiroBrowserEmbed::SetNetworkCallback(networkCallback callback, void* data)
 
234
{
 
235
    mNetworkCallback = callback;
 
236
    mNetworkCallbackData = data;
 
237
}
 
238
 
 
239
int MiroBrowserEmbed::canGoBack()
 
240
{
 
241
    PRBool retval;
 
242
    mWebNavigation->GetCanGoBack(&retval);
 
243
    return retval;
 
244
}
 
245
 
 
246
int MiroBrowserEmbed::canGoForward()
 
247
{
 
248
    PRBool retval;
 
249
    mWebNavigation->GetCanGoForward(&retval);
 
250
    return retval;
 
251
}
 
252
 
 
253
void MiroBrowserEmbed::goBack()
 
254
{
 
255
    mWebNavigation->GoBack();
 
256
}
 
257
 
 
258
void MiroBrowserEmbed::goForward()
 
259
{
 
260
    mWebNavigation->GoForward();
 
261
}
 
262
 
 
263
void MiroBrowserEmbed::stop()
 
264
{
 
265
    mWebNavigation->Stop(nsIWebNavigation::STOP_ALL);
 
266
}
 
267
 
 
268
void MiroBrowserEmbed::reload()
 
269
{
 
270
    mWebNavigation->Reload(nsIWebNavigation::LOAD_FLAGS_NONE);
 
271
}
 
272
 
 
273
//*****************************************************************************
 
274
// MiroBrowserEmbed::nsISupports
 
275
//*****************************************************************************   
 
276
 
 
277
NS_IMPL_ADDREF(MiroBrowserEmbed)
 
278
NS_IMPL_RELEASE(MiroBrowserEmbed)
 
279
 
 
280
NS_INTERFACE_MAP_BEGIN(MiroBrowserEmbed)
 
281
   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIWebBrowserChrome)
 
282
   NS_INTERFACE_MAP_ENTRY(nsIWebBrowserChrome)
 
283
   NS_INTERFACE_MAP_ENTRY(nsIEmbeddingSiteWindow)
 
284
   NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor)
 
285
   NS_INTERFACE_MAP_ENTRY(nsIWebBrowserChromeFocus)
 
286
   NS_INTERFACE_MAP_ENTRY(nsIURIContentListener)
 
287
   NS_INTERFACE_MAP_ENTRY(nsIWebProgressListener)
 
288
   NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
 
289
NS_INTERFACE_MAP_END
 
290
 
 
291
 
 
292
//*****************************************************************************
 
293
// MiroBrowserEmbed::nsIWebBrowserChrome
 
294
//*****************************************************************************   
 
295
 
 
296
NS_IMETHODIMP MiroBrowserEmbed::SetStatus(PRUint32 aType, const PRUnichar* aStatus)
 
297
{
 
298
 
 
299
    return NS_OK;
 
300
}
 
301
 
 
302
NS_IMETHODIMP MiroBrowserEmbed::GetWebBrowser(nsIWebBrowser** aWebBrowser)
 
303
{
 
304
    NS_ENSURE_ARG_POINTER(aWebBrowser);
 
305
    *aWebBrowser = mWebBrowser;
 
306
    NS_IF_ADDREF(*aWebBrowser);
 
307
    return NS_OK;
 
308
}
 
309
 
 
310
NS_IMETHODIMP MiroBrowserEmbed::SetWebBrowser(nsIWebBrowser* aWebBrowser)
 
311
{
 
312
    mWebBrowser = aWebBrowser;
 
313
    return NS_OK;
 
314
}
 
315
 
 
316
NS_IMETHODIMP MiroBrowserEmbed::GetChromeFlags(PRUint32* aChromeMask)
 
317
{
 
318
    *aChromeMask = mChromeFlags;
 
319
    return NS_OK;
 
320
}
 
321
 
 
322
NS_IMETHODIMP MiroBrowserEmbed::SetChromeFlags(PRUint32 aChromeMask)
 
323
{
 
324
    mChromeFlags = aChromeMask;
 
325
    return NS_OK;
 
326
}
 
327
 
 
328
NS_IMETHODIMP MiroBrowserEmbed::DestroyBrowserWindow(void)
 
329
{
 
330
    log_warning("DestroyBrowserWindow() not implemented");
 
331
    return NS_OK;
 
332
}
 
333
 
 
334
 
 
335
// IN: The desired browser client area dimensions.
 
336
NS_IMETHODIMP MiroBrowserEmbed::SizeBrowserTo(PRInt32 aWidth, PRInt32 aHeight)
 
337
{
 
338
  return NS_OK;
 
339
}
 
340
 
 
341
 
 
342
NS_IMETHODIMP MiroBrowserEmbed::ShowAsModal(void)
 
343
{
 
344
  mContinueModalLoop = PR_TRUE;
 
345
  //AppCallbacks::RunEventLoop(mContinueModalLoop);
 
346
 
 
347
  return NS_OK;
 
348
}
 
349
 
 
350
NS_IMETHODIMP MiroBrowserEmbed::IsWindowModal(PRBool *_retval)
 
351
{
 
352
    *_retval = PR_FALSE;
 
353
    return NS_ERROR_NOT_IMPLEMENTED;
 
354
}
 
355
 
 
356
NS_IMETHODIMP MiroBrowserEmbed::ExitModalEventLoop(nsresult aStatus)
 
357
{
 
358
  mContinueModalLoop = PR_FALSE;
 
359
  return NS_OK;
 
360
}
 
361
 
 
362
 
 
363
//*****************************************************************************
 
364
// MiroBrowserEmbed::nsIWebBrowserChromeFocus
 
365
//*****************************************************************************   
 
366
NS_IMETHODIMP MiroBrowserEmbed::FocusNextElement()
 
367
{
 
368
    if(mFocusCallback && is_enabled())
 
369
        mFocusCallback(PR_TRUE, mFocusCallbackData);
 
370
    return NS_OK;
 
371
}
 
372
 
 
373
NS_IMETHODIMP MiroBrowserEmbed::FocusPrevElement()
 
374
{
 
375
    if(mFocusCallback && is_enabled())
 
376
        mFocusCallback(PR_FALSE, mFocusCallbackData);
 
377
    return NS_OK;
 
378
}
 
379
 
 
380
 
 
381
//*****************************************************************************
 
382
// MiroBrowserEmbed::nsIEmbeddingSiteWindow
 
383
//*****************************************************************************   
 
384
 
 
385
NS_IMETHODIMP MiroBrowserEmbed::SetDimensions(PRUint32 aFlags, PRInt32 x, PRInt32 y, PRInt32 cx, PRInt32 cy)
 
386
{
 
387
    return NS_ERROR_NOT_IMPLEMENTED;
 
388
}
 
389
 
 
390
NS_IMETHODIMP MiroBrowserEmbed::GetDimensions(PRUint32 aFlags, PRInt32 *x, PRInt32 *y, PRInt32 *cx, PRInt32 *cy)
 
391
{
 
392
    if (aFlags & nsIEmbeddingSiteWindow::DIM_FLAGS_POSITION)
 
393
    {
 
394
        *x = 0;
 
395
        *y = 0;
 
396
    }
 
397
    if (aFlags & nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_INNER ||
 
398
        aFlags & nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_OUTER)
 
399
    {
 
400
        *cx = 0;
 
401
        *cy = 0;
 
402
    }
 
403
    return NS_ERROR_NOT_IMPLEMENTED;
 
404
}
 
405
 
 
406
/* void setFocus (); */
 
407
NS_IMETHODIMP MiroBrowserEmbed::SetFocus()
 
408
{
 
409
    return NS_OK;
 
410
}
 
411
 
 
412
/* attribute wstring title; */
 
413
NS_IMETHODIMP MiroBrowserEmbed::GetTitle(PRUnichar * *aTitle)
 
414
{
 
415
   NS_ENSURE_ARG_POINTER(aTitle);
 
416
 
 
417
   *aTitle = nsnull;
 
418
   
 
419
   return NS_ERROR_NOT_IMPLEMENTED;
 
420
}
 
421
NS_IMETHODIMP MiroBrowserEmbed::SetTitle(const PRUnichar * aTitle)
 
422
{
 
423
    return NS_ERROR_NOT_IMPLEMENTED;
 
424
}
 
425
 
 
426
/* attribute boolean visibility; */
 
427
NS_IMETHODIMP MiroBrowserEmbed::GetVisibility(PRBool * aVisibility)
 
428
{
 
429
    NS_ENSURE_ARG_POINTER(aVisibility);
 
430
    *aVisibility = PR_TRUE;
 
431
    return NS_OK;
 
432
}
 
433
NS_IMETHODIMP MiroBrowserEmbed::SetVisibility(PRBool aVisibility)
 
434
{
 
435
    return NS_OK;
 
436
}
 
437
 
 
438
/* attribute nativeSiteWindow siteWindow */
 
439
NS_IMETHODIMP MiroBrowserEmbed::GetSiteWindow(void * *aSiteWindow)
 
440
{
 
441
   NS_ENSURE_ARG_POINTER(aSiteWindow);
 
442
 
 
443
   *aSiteWindow = mWindow;
 
444
   return NS_OK;
 
445
}
 
446
 
 
447
//*****************************************************************************
 
448
// MiroBrowserEmbed::nsIURIContentListener
 
449
//*****************************************************************************   
 
450
/* boolean onStartURIOpen (in nsIURI aURI); */
 
451
NS_IMETHODIMP MiroBrowserEmbed::OnStartURIOpen(nsIURI *aURI, PRBool *_retval)
 
452
{
 
453
    nsresult rv;
 
454
    nsCAutoString specString;
 
455
    *_retval = PR_FALSE;
 
456
 
 
457
    rv = aURI->GetSpec(specString);
 
458
    NS_ENSURE_SUCCESS(rv, rv);
 
459
 
 
460
    // Hmm, the docs seem to suggest that retval should be TRUE if we want to
 
461
    // continue the load.  However, it seems like the opposite is actually the
 
462
    // case.
 
463
    if(mURICallback && is_enabled()) {
 
464
        if(mURICallback((char*)specString.get(), mURICallbackData) == 0) {
 
465
            *_retval = PR_TRUE;
 
466
        }
 
467
    }
 
468
    return NS_OK;
 
469
}
 
470
 
 
471
/* boolean doContent (in string aContentType, in boolean aIsContentPreferred, in nsIRequest aRequest, out nsIStreamListener aContentHandler); */
 
472
NS_IMETHODIMP MiroBrowserEmbed::DoContent(const char *aContentType, PRBool aIsContentPreferred, nsIRequest *aRequest, nsIStreamListener **aContentHandler, PRBool *_retval)
 
473
{
 
474
    return NS_ERROR_NOT_IMPLEMENTED;
 
475
}
 
476
 
 
477
/* boolean isPreferred (in string aContentType, out string aDesiredContentType); */
 
478
NS_IMETHODIMP MiroBrowserEmbed::IsPreferred(const char *aContentType, char **aDesiredContentType, PRBool *_retval)
 
479
{
 
480
    // This method was pretty much copied from GtkMozEmbed
 
481
    *_retval = PR_FALSE;
 
482
    *aDesiredContentType = nsnull;
 
483
 
 
484
    if (aContentType) {
 
485
        nsCOMPtr<nsIWebNavigationInfo> webNavInfo(
 
486
                do_GetService(NS_WEBNAVIGATION_INFO_CONTRACTID));
 
487
        if (webNavInfo) {
 
488
            PRUint32 canHandle;
 
489
            nsresult rv =
 
490
                webNavInfo->IsTypeSupported(nsDependentCString(aContentType),
 
491
                        mWebNavigation, &canHandle);
 
492
            NS_ENSURE_SUCCESS(rv, rv);
 
493
            *_retval = (canHandle != nsIWebNavigationInfo::UNSUPPORTED);
 
494
        }
 
495
    }
 
496
    return NS_OK;
 
497
}
 
498
 
 
499
/* boolean canHandleContent (in string aContentType, in boolean aIsContentPreferred, out string aDesiredContentType); */
 
500
NS_IMETHODIMP MiroBrowserEmbed::CanHandleContent(const char *aContentType, PRBool aIsContentPreferred, char **aDesiredContentType, PRBool *_retval)
 
501
{
 
502
    *_retval = PR_FALSE;
 
503
    return NS_OK;
 
504
}
 
505
 
 
506
/* attribute nsISupports loadCookie; */
 
507
NS_IMETHODIMP MiroBrowserEmbed::GetLoadCookie(nsISupports * *aLoadCookie)
 
508
{
 
509
    return NS_ERROR_NOT_IMPLEMENTED;
 
510
}
 
511
NS_IMETHODIMP MiroBrowserEmbed::SetLoadCookie(nsISupports * aLoadCookie)
 
512
{
 
513
    return NS_ERROR_NOT_IMPLEMENTED;
 
514
}
 
515
 
 
516
/* attribute nsIURIContentListener parentContentListener; */
 
517
NS_IMETHODIMP MiroBrowserEmbed::GetParentContentListener(nsIURIContentListener * *aParentContentListener)
 
518
{
 
519
    *aParentContentListener = mParentContentListener;
 
520
    (*aParentContentListener)->AddRef();
 
521
    return NS_OK;
 
522
}
 
523
NS_IMETHODIMP MiroBrowserEmbed::SetParentContentListener(nsIURIContentListener * aParentContentListener)
 
524
{
 
525
    mParentContentListener = aParentContentListener;
 
526
    return NS_OK;
 
527
}
 
528
 
 
529
//*****************************************************************************
 
530
// MiroBrowserEmbed::nsIWebProgressListener
 
531
//*****************************************************************************   
 
532
 
 
533
/* void onStateChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in unsigned long aStateFlags, in nsresult aStatus); */
 
534
NS_IMETHODIMP MiroBrowserEmbed::OnStateChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest, PRUint32 aStateFlags, nsresult aStatus)
 
535
{
 
536
    if((aStateFlags & nsIWebProgressListener::STATE_IS_NETWORK) &&
 
537
            mNetworkCallback && is_enabled()) {
 
538
        if(aStateFlags & nsIWebProgressListener::STATE_START) {
 
539
            mNetworkCallback(PR_TRUE, mNetworkCallbackData);
 
540
        } else if(aStateFlags & nsIWebProgressListener::STATE_STOP) {
 
541
            mNetworkCallback(PR_FALSE, mNetworkCallbackData);
 
542
        }
 
543
    }
 
544
    return NS_OK;
 
545
}
 
546
 
 
547
/* void onProgressChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in long aCurSelfProgress, in long aMaxSelfProgress, in long aCurTotalProgress, in long aMaxTotalProgress); */
 
548
NS_IMETHODIMP MiroBrowserEmbed::OnProgressChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest, PRInt32 aCurSelfProgress, PRInt32 aMaxSelfProgress, PRInt32 aCurTotalProgress, PRInt32 aMaxTotalProgress)
 
549
{
 
550
    return NS_OK;
 
551
}
 
552
 
 
553
/* void onLocationChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in nsIURI aLocation); */
 
554
NS_IMETHODIMP MiroBrowserEmbed::OnLocationChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest, nsIURI *aLocation)
 
555
{
 
556
    return NS_OK;
 
557
}
 
558
 
 
559
/* void onStatusChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in nsresult aStatus, in wstring aMessage); */
 
560
NS_IMETHODIMP MiroBrowserEmbed::OnStatusChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest, nsresult aStatus, const PRUnichar *aMessage)
 
561
{
 
562
    return NS_OK;
 
563
}
 
564
 
 
565
/* void onSecurityChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in unsigned long aState); */
 
566
NS_IMETHODIMP MiroBrowserEmbed::OnSecurityChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest, PRUint32 aState)
 
567
{
 
568
    return NS_OK;
 
569
}
 
570
 
 
571
 
 
572
//*****************************************************************************
 
573
// MiroBrowserEmbed::nsIInterfaceRequestor
 
574
//*****************************************************************************   
 
575
 
 
576
NS_IMETHODIMP MiroBrowserEmbed::GetInterface(const nsIID &aIID, void** aInstancePtr)
 
577
{
 
578
    NS_ENSURE_ARG_POINTER(aInstancePtr);
 
579
 
 
580
    *aInstancePtr = 0;
 
581
    if (aIID.Equals(NS_GET_IID(nsIDOMWindow)))
 
582
    {
 
583
        if (mWebBrowser)
 
584
        {
 
585
            return mWebBrowser->GetContentDOMWindow((nsIDOMWindow **) aInstancePtr);
 
586
        }
 
587
        return NS_ERROR_NOT_INITIALIZED;
 
588
    }
 
589
    return QueryInterface(aIID, aInstancePtr);
 
590
}
 
591
 
 
592
void addref(MiroBrowserEmbed* browser)
 
593
{
 
594
    NS_ADDREF(browser);
 
595
}
 
596
void release(MiroBrowserEmbed* browser)
 
597
{
 
598
    NS_RELEASE(browser);
 
599
}