summaryrefslogtreecommitdiffstats
path: root/xpfe/components/windowds
diff options
context:
space:
mode:
Diffstat (limited to 'xpfe/components/windowds')
-rw-r--r--xpfe/components/windowds/moz.build17
-rw-r--r--xpfe/components/windowds/nsIWindowDataSource.idl17
-rw-r--r--xpfe/components/windowds/nsWindowDataSource.cpp519
-rw-r--r--xpfe/components/windowds/nsWindowDataSource.h59
4 files changed, 612 insertions, 0 deletions
diff --git a/xpfe/components/windowds/moz.build b/xpfe/components/windowds/moz.build
new file mode 100644
index 000000000..0e7536b16
--- /dev/null
+++ b/xpfe/components/windowds/moz.build
@@ -0,0 +1,17 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+XPIDL_SOURCES += [
+ 'nsIWindowDataSource.idl',
+]
+
+XPIDL_MODULE = 'windowds'
+
+SOURCES += [
+ 'nsWindowDataSource.cpp',
+]
+
+FINAL_LIBRARY = 'xul'
diff --git a/xpfe/components/windowds/nsIWindowDataSource.idl b/xpfe/components/windowds/nsIWindowDataSource.idl
new file mode 100644
index 000000000..6143a4317
--- /dev/null
+++ b/xpfe/components/windowds/nsIWindowDataSource.idl
@@ -0,0 +1,17 @@
+/* -*- 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 "nsISupports.idl"
+#include "nsIDOMWindow.idl"
+
+// interface for accessing RDF-specific data from the window datasource
+[scriptable, uuid(3722A5B9-5323-4ed0-BB1A-8299F27A4E89)]
+interface nsIWindowDataSource : nsISupports
+{
+ /**
+ * for the given resource name, return the window
+ */
+ nsIDOMWindow getWindowForResource(in string inResource);
+};
diff --git a/xpfe/components/windowds/nsWindowDataSource.cpp b/xpfe/components/windowds/nsWindowDataSource.cpp
new file mode 100644
index 000000000..3e7a42060
--- /dev/null
+++ b/xpfe/components/windowds/nsWindowDataSource.cpp
@@ -0,0 +1,519 @@
+/* -*- 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"
+#include "nsString.h"
+
+// just to do the reverse-lookup! sheesh.
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsIDocShell.h"
+
+uint32_t nsWindowDataSource::windowCount = 0;
+
+nsIRDFResource* nsWindowDataSource::kNC_Name = nullptr;
+nsIRDFResource* nsWindowDataSource::kNC_WindowRoot = nullptr;
+nsIRDFResource* nsWindowDataSource::kNC_KeyIndex = nullptr;
+
+nsIRDFService* nsWindowDataSource::gRDFService = nullptr;
+
+uint32_t nsWindowDataSource::gRefCnt = 0;
+
+#define URINC_WINDOWROOT "NC:WindowMediatorRoot"
+#define URINC_NAME NC_NAMESPACE_URI "Name"
+#define URINC_KEYINDEX NC_NAMESPACE_URI "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(URINC_WINDOWROOT), &kNC_WindowRoot);
+ gRDFService->GetResource(NS_LITERAL_CSTRING(URINC_NAME), &kNC_Name);
+ gRDFService->GetResource(NS_LITERAL_CSTRING(URINC_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 char16_t *aData)
+{
+ if (strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) == 0) {
+ // release these objects so that they release their reference
+ // to us
+ mContainer = nullptr;
+ mInner = nullptr;
+ }
+
+ 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(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
+
+NS_IMETHODIMP
+nsWindowDataSource::OnWindowTitleChange(nsIXULWindow *window,
+ const char16_t *newTitle)
+{
+ nsresult rv;
+
+ nsCOMPtr<nsIRDFResource> windowResource;
+ mWindowResources.Get(window, getter_AddRefs(windowResource));
+
+ // oops, make sure this window is in the hashtable!
+ if (!windowResource) {
+ OnOpenWindow(window);
+ mWindowResources.Get(window, getter_AddRefs(windowResource));
+ }
+
+ NS_ENSURE_TRUE(windowResource, NS_ERROR_UNEXPECTED);
+
+ 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;
+}
+
+NS_IMETHODIMP
+nsWindowDataSource::OnOpenWindow(nsIXULWindow *window)
+{
+ nsAutoCString windowId(NS_LITERAL_CSTRING("window-"));
+ windowId.AppendInt(windowCount++, 10);
+
+ nsCOMPtr<nsIRDFResource> windowResource;
+ gRDFService->GetResource(windowId, getter_AddRefs(windowResource));
+
+ mWindowResources.Put(window, windowResource);
+
+ // assert the new window
+ if (mContainer)
+ mContainer->AppendElement(windowResource);
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsWindowDataSource::OnCloseWindow(nsIXULWindow *window)
+{
+ nsresult rv;
+ nsCOMPtr<nsIRDFResource> resource;
+ mWindowResources.Get(window, getter_AddRefs(resource));
+ if (!resource) {
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ mWindowResources.Remove(window);
+
+ // 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
+ int32_t 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;
+
+ int32_t currentIndex = -1;
+ mContainer->IndexOf(windowResource, &currentIndex);
+
+ // 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;
+}
+
+// nsIWindowDataSource implementation
+
+NS_IMETHODIMP
+nsWindowDataSource::GetWindowForResource(const char *aResourceString,
+ nsIDOMWindow** aResult)
+{
+ if (NS_WARN_IF(!aResourceString)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ nsCOMPtr<nsIRDFResource> windowResource;
+ gRDFService->GetResource(nsDependentCString(aResourceString),
+ getter_AddRefs(windowResource));
+
+ // now reverse-lookup in the hashtable
+ for (auto iter = mWindowResources.Iter(); !iter.Done(); iter.Next()) {
+ nsIXULWindow* window = iter.Key();
+ nsIRDFResource* resource = iter.UserData();
+
+ if (resource == windowResource) {
+ // This sucks, we have to jump through docshell to go from
+ // nsIXULWindow -> nsIDOMWindow.
+ nsCOMPtr<nsIDocShell> docShell;
+ window->GetDocShell(getter_AddRefs(docShell));
+
+ if (docShell) {
+ nsCOMPtr<nsIDOMWindow> result = do_GetInterface(docShell);
+
+ *aResult = result;
+ NS_IF_ADDREF(*aResult);
+ }
+ break;
+ }
+ }
+
+ 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
+
+
+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;
+}
+
+NS_IMETHODIMP nsWindowDataSource::GetTarget(nsIRDFResource *aSource, nsIRDFResource *aProperty, bool aTruthValue, nsIRDFNode **_retval)
+{
+ NS_ENSURE_ARG_POINTER(_retval);
+
+ // add extra nullptr 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) {
+
+ int32_t 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);
+
+ indexInt.forget(_retval);
+ return NS_OK;
+ }
+
+ return mInner->GetTarget(aSource, aProperty, aTruthValue, _retval);
+}
+
+NS_IMETHODIMP nsWindowDataSource::GetSource(nsIRDFResource *aProperty, nsIRDFNode *aTarget, bool aTruthValue, nsIRDFResource **_retval)
+{
+ if (mInner)
+ return mInner->GetSource(aProperty, aTarget, aTruthValue, _retval);
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsWindowDataSource::GetSources(nsIRDFResource *aProperty, nsIRDFNode *aTarget, bool aTruthValue, nsISimpleEnumerator **_retval)
+{
+ if (mInner)
+ return mInner->GetSources(aProperty, aTarget, aTruthValue, _retval);
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsWindowDataSource::GetTargets(nsIRDFResource *aSource, nsIRDFResource *aProperty, bool aTruthValue, nsISimpleEnumerator **_retval)
+{
+ if (mInner)
+ return mInner->GetTargets(aSource, aProperty, aTruthValue, _retval);
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsWindowDataSource::Assert(nsIRDFResource *aSource, nsIRDFResource *aProperty, nsIRDFNode *aTarget, bool aTruthValue)
+{
+ if (mInner)
+ return mInner->Assert(aSource, aProperty, aTarget, aTruthValue);
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsWindowDataSource::Unassert(nsIRDFResource *aSource, nsIRDFResource *aProperty, nsIRDFNode *aTarget)
+{
+ if (mInner)
+ return mInner->Unassert(aSource, aProperty, aTarget);
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsWindowDataSource::Change(nsIRDFResource *aSource, nsIRDFResource *aProperty, nsIRDFNode *aOldTarget, nsIRDFNode *aNewTarget)
+{
+ if (mInner)
+ return mInner->Change(aSource, aProperty, aOldTarget, aNewTarget);
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsWindowDataSource::Move(nsIRDFResource *aOldSource, nsIRDFResource *aNewSource, nsIRDFResource *aProperty, nsIRDFNode *aTarget)
+{
+ if (mInner)
+ return mInner->Move(aOldSource, aNewSource, aProperty, aTarget);
+ return NS_OK;
+}
+
+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;
+}
+
+NS_IMETHODIMP nsWindowDataSource::AddObserver(nsIRDFObserver *aObserver)
+{
+ if (mInner)
+ return mInner->AddObserver(aObserver);
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsWindowDataSource::RemoveObserver(nsIRDFObserver *aObserver)
+{
+ if (mInner)
+ return mInner->RemoveObserver(aObserver);
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsWindowDataSource::ArcLabelsIn(nsIRDFNode *aNode, nsISimpleEnumerator **_retval)
+{
+ if (mInner)
+ return mInner->ArcLabelsIn(aNode, _retval);
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsWindowDataSource::ArcLabelsOut(nsIRDFResource *aSource, nsISimpleEnumerator **_retval)
+{
+ if (mInner)
+ return mInner->ArcLabelsOut(aSource, _retval);
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsWindowDataSource::GetAllResources(nsISimpleEnumerator **_retval)
+{
+ if (mInner)
+ return mInner->GetAllResources(_retval);
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsWindowDataSource::IsCommandEnabled(nsISupports *aSources, nsIRDFResource *aCommand, nsISupports *aArguments, bool *_retval)
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsWindowDataSource::DoCommand(nsISupports *aSources, nsIRDFResource *aCommand, nsISupports *aArguments)
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsWindowDataSource::GetAllCmds(nsIRDFResource *aSource, nsISimpleEnumerator **_retval)
+{
+ if (mInner)
+ return mInner->GetAllCmds(aSource, _retval);
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsWindowDataSource::HasArcIn(nsIRDFNode *aNode, nsIRDFResource *aArc, bool *_retval)
+{
+ if (mInner)
+ return mInner->HasArcIn(aNode, aArc, _retval);
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsWindowDataSource::HasArcOut(nsIRDFResource *aSource, nsIRDFResource *aArc, bool *_retval)
+{
+ if (mInner)
+ return mInner->HasArcOut(aSource, aArc, _retval);
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsWindowDataSource::BeginUpdateBatch()
+{
+ if (mInner)
+ return mInner->BeginUpdateBatch();
+ return NS_OK;
+}
+
+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, nullptr, nsWindowDataSourceConstructor },
+ { nullptr }
+};
+
+static const mozilla::Module::ContractIDEntry kWindowDSContracts[] = {
+ { NS_RDF_DATASOURCE_CONTRACTID_PREFIX "window-mediator", &kNS_WINDOWDATASOURCE_CID },
+ { nullptr }
+};
+
+static const mozilla::Module::CategoryEntry kWindowDSCategories[] = {
+ { "app-startup", "Window Data Source", "service," NS_RDF_DATASOURCE_CONTRACTID_PREFIX "window-mediator" },
+ { nullptr }
+};
+
+static const mozilla::Module kWindowDSModule = {
+ mozilla::Module::kVersion,
+ kWindowDSCIDs,
+ kWindowDSContracts,
+ kWindowDSCategories
+};
+
+NSMODULE_DEFN(nsWindowDataSourceModule) = &kWindowDSModule;
diff --git a/xpfe/components/windowds/nsWindowDataSource.h b/xpfe/components/windowds/nsWindowDataSource.h
new file mode 100644
index 000000000..351ff951b
--- /dev/null
+++ b/xpfe/components/windowds/nsWindowDataSource.h
@@ -0,0 +1,59 @@
+/* -*- 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 "nsIRDFDataSource.h"
+#include "nsIWindowMediatorListener.h"
+#include "nsIWindowDataSource.h"
+#include "nsIObserver.h"
+
+#include "nsHashKeys.h"
+#include "nsIRDFService.h"
+#include "nsIRDFContainer.h"
+#include "nsInterfaceHashtable.h"
+#include "nsCycleCollectionParticipant.h"
+
+// {C744CA3D-840B-460a-8D70-7CE63C51C958}
+#define NS_WINDOWDATASOURCE_CID \
+{ 0xc744ca3d, 0x840b, 0x460a, \
+ { 0x8d, 0x70, 0x7c, 0xe6, 0x3c, 0x51, 0xc9, 0x58 } }
+
+
+class nsWindowDataSource final : public nsIRDFDataSource,
+ public nsIObserver,
+ public nsIWindowMediatorListener,
+ public nsIWindowDataSource
+{
+ public:
+ nsWindowDataSource() { }
+
+ nsresult Init();
+
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsWindowDataSource,
+ nsIRDFDataSource)
+ NS_DECL_NSIOBSERVER
+ NS_DECL_NSIWINDOWMEDIATORLISTENER
+ NS_DECL_NSIWINDOWDATASOURCE
+ NS_DECL_NSIRDFDATASOURCE
+
+ protected:
+ virtual ~nsWindowDataSource();
+
+ private:
+
+ // mapping of window -> RDF resource
+ nsInterfaceHashtable<nsPtrHashKey<nsIXULWindow>, nsIRDFResource> mWindowResources;
+
+ static uint32_t windowCount;
+ static uint32_t gRefCnt;
+
+ nsCOMPtr<nsIRDFDataSource> mInner;
+ nsCOMPtr<nsIRDFContainer> mContainer;
+
+ static nsIRDFResource* kNC_Name;
+ static nsIRDFResource* kNC_KeyIndex;
+ static nsIRDFResource* kNC_WindowRoot;
+ static nsIRDFService* gRDFService;
+};
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-26 17:55:22 +0000