mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
571 lines
18 KiB
C++
571 lines
18 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "nsWindowDataSource.h"
|
|
#include "nsIXULWindow.h"
|
|
#include "rdf.h"
|
|
#include "nsIRDFContainerUtils.h"
|
|
#include "nsIServiceManager.h"
|
|
#include "nsReadableUtils.h"
|
|
#include "nsIObserverService.h"
|
|
#include "nsIWindowMediator.h"
|
|
#include "nsXPCOMCID.h"
|
|
#include "mozilla/ModuleUtils.h"
|
|
|
|
// just to do the reverse-lookup! sheesh.
|
|
#include "nsIInterfaceRequestorUtils.h"
|
|
#include "nsIDocShell.h"
|
|
|
|
PRUint32 nsWindowDataSource::windowCount = 0;
|
|
|
|
nsIRDFResource* nsWindowDataSource::kNC_Name = nsnull;
|
|
nsIRDFResource* nsWindowDataSource::kNC_WindowRoot = nsnull;
|
|
nsIRDFResource* nsWindowDataSource::kNC_KeyIndex = nsnull;
|
|
|
|
nsIRDFService* nsWindowDataSource::gRDFService = nsnull;
|
|
|
|
PRUint32 nsWindowDataSource::gRefCnt = 0;
|
|
|
|
static const char kURINC_WindowRoot[] = "NC:WindowMediatorRoot";
|
|
|
|
DEFINE_RDF_VOCAB(NC_NAMESPACE_URI, NC, Name);
|
|
DEFINE_RDF_VOCAB(NC_NAMESPACE_URI, NC, KeyIndex);
|
|
|
|
nsresult
|
|
nsWindowDataSource::Init()
|
|
{
|
|
nsresult rv;
|
|
|
|
if (gRefCnt++ == 0) {
|
|
rv = CallGetService("@mozilla.org/rdf/rdf-service;1", &gRDFService);
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
gRDFService->GetResource(NS_LITERAL_CSTRING(kURINC_WindowRoot), &kNC_WindowRoot);
|
|
gRDFService->GetResource(NS_LITERAL_CSTRING(kURINC_Name), &kNC_Name);
|
|
gRDFService->GetResource(NS_LITERAL_CSTRING(kURINC_KeyIndex), &kNC_KeyIndex);
|
|
}
|
|
|
|
mInner = do_CreateInstance("@mozilla.org/rdf/datasource;1?name=in-memory-datasource", &rv);
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
nsCOMPtr<nsIRDFContainerUtils> rdfc =
|
|
do_GetService("@mozilla.org/rdf/container-utils;1", &rv);
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
rv = rdfc->MakeSeq(this, kNC_WindowRoot, getter_AddRefs(mContainer));
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
nsCOMPtr<nsIWindowMediator> windowMediator =
|
|
do_GetService(NS_WINDOWMEDIATOR_CONTRACTID, &rv);
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
rv = windowMediator->AddListener(this);
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
nsCOMPtr<nsIObserverService> observerService =
|
|
do_GetService(NS_OBSERVERSERVICE_CONTRACTID, &rv);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID,
|
|
false);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
nsWindowDataSource::~nsWindowDataSource()
|
|
{
|
|
if (--gRefCnt == 0) {
|
|
NS_IF_RELEASE(kNC_Name);
|
|
NS_IF_RELEASE(kNC_KeyIndex);
|
|
NS_IF_RELEASE(kNC_WindowRoot);
|
|
NS_IF_RELEASE(gRDFService);
|
|
}
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsWindowDataSource::Observe(nsISupports *aSubject, const char* aTopic, const PRUnichar *aData)
|
|
{
|
|
if (strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) == 0) {
|
|
// release these objects so that they release their reference
|
|
// to us
|
|
mContainer = nsnull;
|
|
mInner = nsnull;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(nsWindowDataSource)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_0(nsWindowDataSource)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsWindowDataSource)
|
|
// XXX mContainer?
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mInner)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTING_ADDREF(nsWindowDataSource)
|
|
NS_IMPL_CYCLE_COLLECTING_RELEASE(nsWindowDataSource)
|
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsWindowDataSource)
|
|
NS_INTERFACE_MAP_ENTRY(nsIObserver)
|
|
NS_INTERFACE_MAP_ENTRY(nsIWindowMediatorListener)
|
|
NS_INTERFACE_MAP_ENTRY(nsIWindowDataSource)
|
|
NS_INTERFACE_MAP_ENTRY(nsIRDFDataSource)
|
|
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIObserver)
|
|
NS_INTERFACE_MAP_END
|
|
|
|
// nsIWindowMediatorListener implementation
|
|
// handle notifications from the window mediator and reflect them into
|
|
// RDF
|
|
|
|
/* void onWindowTitleChange (in nsIXULWindow window, in wstring newTitle); */
|
|
NS_IMETHODIMP
|
|
nsWindowDataSource::OnWindowTitleChange(nsIXULWindow *window,
|
|
const PRUnichar *newTitle)
|
|
{
|
|
nsresult rv;
|
|
|
|
nsVoidKey key(window);
|
|
|
|
nsCOMPtr<nsISupports> sup =
|
|
dont_AddRef(mWindowResources.Get(&key));
|
|
|
|
// oops, make sure this window is in the hashtable!
|
|
if (!sup) {
|
|
OnOpenWindow(window);
|
|
sup = dont_AddRef(mWindowResources.Get(&key));
|
|
}
|
|
|
|
NS_ENSURE_TRUE(sup, NS_ERROR_UNEXPECTED);
|
|
|
|
nsCOMPtr<nsIRDFResource> windowResource =
|
|
do_QueryInterface(sup);
|
|
|
|
nsCOMPtr<nsIRDFLiteral> newTitleLiteral;
|
|
rv = gRDFService->GetLiteral(newTitle, getter_AddRefs(newTitleLiteral));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// get the old title
|
|
nsCOMPtr<nsIRDFNode> oldTitleNode;
|
|
rv = GetTarget(windowResource, kNC_Name, true,
|
|
getter_AddRefs(oldTitleNode));
|
|
|
|
// assert the change
|
|
if (NS_SUCCEEDED(rv) && oldTitleNode)
|
|
// has an existing window title, update it
|
|
rv = Change(windowResource, kNC_Name, oldTitleNode, newTitleLiteral);
|
|
else
|
|
// removed from the tasklist
|
|
rv = Assert(windowResource, kNC_Name, newTitleLiteral, true);
|
|
|
|
if (rv != NS_RDF_ASSERTION_ACCEPTED)
|
|
{
|
|
NS_ERROR("unable to set window name");
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* void onOpenWindow (in nsIXULWindow window); */
|
|
NS_IMETHODIMP
|
|
nsWindowDataSource::OnOpenWindow(nsIXULWindow *window)
|
|
{
|
|
nsCAutoString windowId(NS_LITERAL_CSTRING("window-"));
|
|
windowId.AppendInt(windowCount++, 10);
|
|
|
|
nsCOMPtr<nsIRDFResource> windowResource;
|
|
gRDFService->GetResource(windowId, getter_AddRefs(windowResource));
|
|
|
|
nsVoidKey key(window);
|
|
mWindowResources.Put(&key, windowResource);
|
|
|
|
// assert the new window
|
|
if (mContainer)
|
|
mContainer->AppendElement(windowResource);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* void onCloseWindow (in nsIXULWindow window); */
|
|
NS_IMETHODIMP
|
|
nsWindowDataSource::OnCloseWindow(nsIXULWindow *window)
|
|
{
|
|
nsVoidKey key(window);
|
|
nsCOMPtr<nsIRDFResource> resource;
|
|
|
|
nsresult rv;
|
|
|
|
if (!mWindowResources.Remove(&key, getter_AddRefs(resource)))
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
// make sure we're not shutting down
|
|
if (!mContainer) return NS_OK;
|
|
|
|
nsCOMPtr<nsIRDFNode> oldKeyNode;
|
|
nsCOMPtr<nsIRDFInt> oldKeyInt;
|
|
|
|
// get the old keyIndex, if any
|
|
rv = GetTarget(resource, kNC_KeyIndex, true,
|
|
getter_AddRefs(oldKeyNode));
|
|
if (NS_SUCCEEDED(rv) && (rv != NS_RDF_NO_VALUE))
|
|
oldKeyInt = do_QueryInterface(oldKeyNode);
|
|
|
|
|
|
// update RDF and keyindex - from this point forward we'll ignore
|
|
// errors, because they just indicate some kind of RDF inconsistency
|
|
PRInt32 winIndex = -1;
|
|
rv = mContainer->IndexOf(resource, &winIndex);
|
|
|
|
if (NS_FAILED(rv))
|
|
return NS_OK;
|
|
|
|
// unassert the old window, ignore any error
|
|
mContainer->RemoveElement(resource, true);
|
|
|
|
nsCOMPtr<nsISimpleEnumerator> children;
|
|
rv = mContainer->GetElements(getter_AddRefs(children));
|
|
if (NS_FAILED(rv))
|
|
return NS_OK;
|
|
|
|
bool more = false;
|
|
|
|
while (NS_SUCCEEDED(rv = children->HasMoreElements(&more)) && more) {
|
|
nsCOMPtr<nsISupports> sup;
|
|
rv = children->GetNext(getter_AddRefs(sup));
|
|
if (NS_FAILED(rv))
|
|
break;
|
|
|
|
nsCOMPtr<nsIRDFResource> windowResource = do_QueryInterface(sup, &rv);
|
|
if (NS_FAILED(rv))
|
|
continue;
|
|
|
|
PRInt32 currentIndex = -1;
|
|
mContainer->IndexOf(windowResource, ¤tIndex);
|
|
|
|
// can skip updating windows with lower indexes
|
|
// than the window that was removed
|
|
if (currentIndex < winIndex)
|
|
continue;
|
|
|
|
nsCOMPtr<nsIRDFNode> newKeyNode;
|
|
nsCOMPtr<nsIRDFInt> newKeyInt;
|
|
|
|
rv = GetTarget(windowResource, kNC_KeyIndex, true,
|
|
getter_AddRefs(newKeyNode));
|
|
if (NS_SUCCEEDED(rv) && (rv != NS_RDF_NO_VALUE))
|
|
newKeyInt = do_QueryInterface(newKeyNode);
|
|
|
|
// changing from one key index to another
|
|
if (oldKeyInt && newKeyInt)
|
|
Change(windowResource, kNC_KeyIndex, oldKeyInt, newKeyInt);
|
|
// creating a new keyindex - probably window going
|
|
// from (none) to "9"
|
|
else if (newKeyInt)
|
|
Assert(windowResource, kNC_KeyIndex, newKeyInt, true);
|
|
|
|
// somehow inserting a window above this one,
|
|
// "9" to (none)
|
|
else if (oldKeyInt)
|
|
Unassert(windowResource, kNC_KeyIndex, oldKeyInt);
|
|
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
struct findWindowClosure {
|
|
nsIRDFResource* targetResource;
|
|
nsIXULWindow *resultWindow;
|
|
};
|
|
|
|
static bool
|
|
findWindow(nsHashKey* aKey, void *aData, void* aClosure)
|
|
{
|
|
nsVoidKey *thisKey = static_cast<nsVoidKey*>(aKey);
|
|
|
|
nsIRDFResource *resource =
|
|
static_cast<nsIRDFResource*>(aData);
|
|
|
|
findWindowClosure* closure =
|
|
static_cast<findWindowClosure*>(aClosure);
|
|
|
|
if (resource == closure->targetResource) {
|
|
closure->resultWindow =
|
|
static_cast<nsIXULWindow*>
|
|
(thisKey->GetValue());
|
|
return false; // stop enumerating
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// nsIWindowDataSource implementation
|
|
|
|
NS_IMETHODIMP
|
|
nsWindowDataSource::GetWindowForResource(const char *aResourceString,
|
|
nsIDOMWindow** aResult)
|
|
{
|
|
nsCOMPtr<nsIRDFResource> windowResource;
|
|
gRDFService->GetResource(nsDependentCString(aResourceString),
|
|
getter_AddRefs(windowResource));
|
|
|
|
// now reverse-lookup in the hashtable
|
|
findWindowClosure closure = { windowResource.get(), nsnull };
|
|
mWindowResources.Enumerate(findWindow, (void*)&closure);
|
|
if (closure.resultWindow) {
|
|
|
|
// this sucks, we have to jump through docshell to go from
|
|
// nsIXULWindow -> nsIDOMWindow
|
|
nsCOMPtr<nsIDocShell> docShell;
|
|
closure.resultWindow->GetDocShell(getter_AddRefs(docShell));
|
|
|
|
if (docShell) {
|
|
nsCOMPtr<nsIDOMWindow> result = do_GetInterface(docShell);
|
|
|
|
*aResult = result;
|
|
NS_IF_ADDREF(*aResult);
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
// nsIRDFDataSource implementation
|
|
// mostly, we just forward to mInner, except:
|
|
// GetURI() - need to return "rdf:window-mediator"
|
|
// GetTarget() - need to handle kNC_KeyIndex
|
|
|
|
|
|
/* readonly attribute string URI; */
|
|
NS_IMETHODIMP nsWindowDataSource::GetURI(char * *aURI)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aURI);
|
|
|
|
*aURI = ToNewCString(NS_LITERAL_CSTRING("rdf:window-mediator"));
|
|
|
|
if (!*aURI)
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* nsIRDFNode GetTarget (in nsIRDFResource aSource, in nsIRDFResource aProperty, in boolean aTruthValue); */
|
|
NS_IMETHODIMP nsWindowDataSource::GetTarget(nsIRDFResource *aSource, nsIRDFResource *aProperty, bool aTruthValue, nsIRDFNode **_retval)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(_retval);
|
|
|
|
// add extra NULL checking for top-crash bug # 146466
|
|
if (!gRDFService) return NS_RDF_NO_VALUE;
|
|
if (!mInner) return NS_RDF_NO_VALUE;
|
|
if (!mContainer) return NS_RDF_NO_VALUE;
|
|
// special case kNC_KeyIndex before we forward to mInner
|
|
if (aProperty == kNC_KeyIndex) {
|
|
|
|
PRInt32 theIndex = 0;
|
|
nsresult rv = mContainer->IndexOf(aSource, &theIndex);
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
// only allow the range of 1 to 9 for single key access
|
|
if (theIndex < 1 || theIndex > 9) return(NS_RDF_NO_VALUE);
|
|
|
|
nsCOMPtr<nsIRDFInt> indexInt;
|
|
rv = gRDFService->GetIntLiteral(theIndex, getter_AddRefs(indexInt));
|
|
if (NS_FAILED(rv)) return(rv);
|
|
if (!indexInt) return(NS_ERROR_FAILURE);
|
|
|
|
return CallQueryInterface(indexInt, _retval);
|
|
}
|
|
|
|
|
|
return mInner->GetTarget(aSource, aProperty, aTruthValue, _retval);
|
|
}
|
|
|
|
/* nsIRDFResource GetSource (in nsIRDFResource aProperty, in nsIRDFNode aTarget, in boolean aTruthValue); */
|
|
NS_IMETHODIMP nsWindowDataSource::GetSource(nsIRDFResource *aProperty, nsIRDFNode *aTarget, bool aTruthValue, nsIRDFResource **_retval)
|
|
{
|
|
if (mInner)
|
|
return mInner->GetSource(aProperty, aTarget, aTruthValue, _retval);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* nsISimpleEnumerator GetSources (in nsIRDFResource aProperty, in nsIRDFNode aTarget, in boolean aTruthValue); */
|
|
NS_IMETHODIMP nsWindowDataSource::GetSources(nsIRDFResource *aProperty, nsIRDFNode *aTarget, bool aTruthValue, nsISimpleEnumerator **_retval)
|
|
{
|
|
if (mInner)
|
|
return mInner->GetSources(aProperty, aTarget, aTruthValue, _retval);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* nsISimpleEnumerator GetTargets (in nsIRDFResource aSource, in nsIRDFResource aProperty, in boolean aTruthValue); */
|
|
NS_IMETHODIMP nsWindowDataSource::GetTargets(nsIRDFResource *aSource, nsIRDFResource *aProperty, bool aTruthValue, nsISimpleEnumerator **_retval)
|
|
{
|
|
if (mInner)
|
|
return mInner->GetTargets(aSource, aProperty, aTruthValue, _retval);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* void Assert (in nsIRDFResource aSource, in nsIRDFResource aProperty, in nsIRDFNode aTarget, in boolean aTruthValue); */
|
|
NS_IMETHODIMP nsWindowDataSource::Assert(nsIRDFResource *aSource, nsIRDFResource *aProperty, nsIRDFNode *aTarget, bool aTruthValue)
|
|
{
|
|
if (mInner)
|
|
return mInner->Assert(aSource, aProperty, aTarget, aTruthValue);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* void Unassert (in nsIRDFResource aSource, in nsIRDFResource aProperty, in nsIRDFNode aTarget); */
|
|
NS_IMETHODIMP nsWindowDataSource::Unassert(nsIRDFResource *aSource, nsIRDFResource *aProperty, nsIRDFNode *aTarget)
|
|
{
|
|
if (mInner)
|
|
return mInner->Unassert(aSource, aProperty, aTarget);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* void Change (in nsIRDFResource aSource, in nsIRDFResource aProperty, in nsIRDFNode aOldTarget, in nsIRDFNode aNewTarget); */
|
|
NS_IMETHODIMP nsWindowDataSource::Change(nsIRDFResource *aSource, nsIRDFResource *aProperty, nsIRDFNode *aOldTarget, nsIRDFNode *aNewTarget)
|
|
{
|
|
if (mInner)
|
|
return mInner->Change(aSource, aProperty, aOldTarget, aNewTarget);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* void Move (in nsIRDFResource aOldSource, in nsIRDFResource aNewSource, in nsIRDFResource aProperty, in nsIRDFNode aTarget); */
|
|
NS_IMETHODIMP nsWindowDataSource::Move(nsIRDFResource *aOldSource, nsIRDFResource *aNewSource, nsIRDFResource *aProperty, nsIRDFNode *aTarget)
|
|
{
|
|
if (mInner)
|
|
return mInner->Move(aOldSource, aNewSource, aProperty, aTarget);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* boolean HasAssertion (in nsIRDFResource aSource, in nsIRDFResource aProperty, in nsIRDFNode aTarget, in boolean aTruthValue); */
|
|
NS_IMETHODIMP nsWindowDataSource::HasAssertion(nsIRDFResource *aSource, nsIRDFResource *aProperty, nsIRDFNode *aTarget, bool aTruthValue, bool *_retval)
|
|
{
|
|
if (mInner)
|
|
return mInner->HasAssertion(aSource, aProperty, aTarget, aTruthValue, _retval);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* void AddObserver (in nsIRDFObserver aObserver); */
|
|
NS_IMETHODIMP nsWindowDataSource::AddObserver(nsIRDFObserver *aObserver)
|
|
{
|
|
if (mInner)
|
|
return mInner->AddObserver(aObserver);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* void RemoveObserver (in nsIRDFObserver aObserver); */
|
|
NS_IMETHODIMP nsWindowDataSource::RemoveObserver(nsIRDFObserver *aObserver)
|
|
{
|
|
if (mInner)
|
|
return mInner->RemoveObserver(aObserver);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* nsISimpleEnumerator ArcLabelsIn (in nsIRDFNode aNode); */
|
|
NS_IMETHODIMP nsWindowDataSource::ArcLabelsIn(nsIRDFNode *aNode, nsISimpleEnumerator **_retval)
|
|
{
|
|
if (mInner)
|
|
return mInner->ArcLabelsIn(aNode, _retval);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* nsISimpleEnumerator ArcLabelsOut (in nsIRDFResource aSource); */
|
|
NS_IMETHODIMP nsWindowDataSource::ArcLabelsOut(nsIRDFResource *aSource, nsISimpleEnumerator **_retval)
|
|
{
|
|
if (mInner)
|
|
return mInner->ArcLabelsOut(aSource, _retval);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* nsISimpleEnumerator GetAllResources (); */
|
|
NS_IMETHODIMP nsWindowDataSource::GetAllResources(nsISimpleEnumerator **_retval)
|
|
{
|
|
if (mInner)
|
|
return mInner->GetAllResources(_retval);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* boolean IsCommandEnabled (in nsISupportsArray aSources, in nsIRDFResource aCommand, in nsISupportsArray aArguments); */
|
|
NS_IMETHODIMP nsWindowDataSource::IsCommandEnabled(nsISupportsArray *aSources, nsIRDFResource *aCommand, nsISupportsArray *aArguments, bool *_retval)
|
|
{
|
|
if (mInner)
|
|
return mInner->IsCommandEnabled(aSources, aCommand, aArguments, _retval);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* void DoCommand (in nsISupportsArray aSources, in nsIRDFResource aCommand, in nsISupportsArray aArguments); */
|
|
NS_IMETHODIMP nsWindowDataSource::DoCommand(nsISupportsArray *aSources, nsIRDFResource *aCommand, nsISupportsArray *aArguments)
|
|
{
|
|
if (mInner)
|
|
return mInner->DoCommand(aSources, aCommand, aArguments);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* nsISimpleEnumerator GetAllCmds (in nsIRDFResource aSource); */
|
|
NS_IMETHODIMP nsWindowDataSource::GetAllCmds(nsIRDFResource *aSource, nsISimpleEnumerator **_retval)
|
|
{
|
|
if (mInner)
|
|
return mInner->GetAllCmds(aSource, _retval);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* boolean hasArcIn (in nsIRDFNode aNode, in nsIRDFResource aArc); */
|
|
NS_IMETHODIMP nsWindowDataSource::HasArcIn(nsIRDFNode *aNode, nsIRDFResource *aArc, bool *_retval)
|
|
{
|
|
if (mInner)
|
|
return mInner->HasArcIn(aNode, aArc, _retval);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* boolean hasArcOut (in nsIRDFResource aSource, in nsIRDFResource aArc); */
|
|
NS_IMETHODIMP nsWindowDataSource::HasArcOut(nsIRDFResource *aSource, nsIRDFResource *aArc, bool *_retval)
|
|
{
|
|
if (mInner)
|
|
return mInner->HasArcOut(aSource, aArc, _retval);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* void beginUpdateBatch (); */
|
|
NS_IMETHODIMP nsWindowDataSource::BeginUpdateBatch()
|
|
{
|
|
if (mInner)
|
|
return mInner->BeginUpdateBatch();
|
|
return NS_OK;
|
|
}
|
|
|
|
/* void endUpdateBatch (); */
|
|
NS_IMETHODIMP nsWindowDataSource::EndUpdateBatch()
|
|
{
|
|
if (mInner)
|
|
return mInner->EndUpdateBatch();
|
|
return NS_OK;
|
|
}
|
|
|
|
// The module goop
|
|
|
|
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsWindowDataSource, Init)
|
|
|
|
NS_DEFINE_NAMED_CID(NS_WINDOWDATASOURCE_CID);
|
|
|
|
static const mozilla::Module::CIDEntry kWindowDSCIDs[] = {
|
|
{ &kNS_WINDOWDATASOURCE_CID, false, NULL, nsWindowDataSourceConstructor },
|
|
{ NULL }
|
|
};
|
|
|
|
static const mozilla::Module::ContractIDEntry kWindowDSContracts[] = {
|
|
{ NS_RDF_DATASOURCE_CONTRACTID_PREFIX "window-mediator", &kNS_WINDOWDATASOURCE_CID },
|
|
{ NULL }
|
|
};
|
|
|
|
static const mozilla::Module::CategoryEntry kWindowDSCategories[] = {
|
|
{ "app-startup", "Window Data Source", "service," NS_RDF_DATASOURCE_CONTRACTID_PREFIX "window-mediator" },
|
|
{ NULL }
|
|
};
|
|
|
|
static const mozilla::Module kWindowDSModule = {
|
|
mozilla::Module::kVersion,
|
|
kWindowDSCIDs,
|
|
kWindowDSContracts,
|
|
kWindowDSCategories
|
|
};
|
|
|
|
NSMODULE_DEFN(nsWindowDataSourceModule) = &kWindowDSModule;
|