Land Guha's history stuff, including some fixes for references in the file system data source, and modifications for literals: there's now nsIntLiteral and nsDateLiteral.

1999-03-09 04:01:56 +00:00 · 1999-03-09 04:01:56 +00:00 · 3d2b42cfd9
--- a/content/xul/templates/src/nsXULTemplateBuilder.cpp
+++ b/content/xul/templates/src/nsXULTemplateBuilder.cpp
@ -756,7 +756,9 @@ RDFGenericBuilderImpl::OnSetAttribute(nsIDOMElement* aElement, const nsString& a
        }

        if ((rv == NS_CONTENT_ATTR_NO_VALUE) || (rv == NS_CONTENT_ATTR_NOT_THERE) ||
-            ((rv == NS_CONTENT_ATTR_HAS_VALUE) && (! attrValue.EqualsIgnoreCase(aValue)))) {
+            ((rv == NS_CONTENT_ATTR_HAS_VALUE) && (! attrValue.EqualsIgnoreCase(aValue))) ||
+            PR_TRUE // XXX just always allow this to fire.
+            ) {
            // Okay, it's really changing.

            // This is a "transient" property, so we _don't_ go to the
--- a/rdf/base/public/nsIRDFNode.h
+++ b/rdf/base/public/nsIRDFNode.h
@ -29,7 +29,7 @@
 #include "nscore.h"
 #include "rdf.h"
 #include "nsISupports.h"
-
+#include "prtime.h"
 // {0F78DA50-8321-11d2-8EAC-00805F29F370}
 #define NS_IRDFNODE_IID \
 { 0xf78da50, 0x8321, 0x11d2, { 0x8e, 0xac, 0x0, 0x80, 0x5f, 0x29, 0xf3, 0x70 } }
@ -57,12 +57,6 @@ class NS_RDF nsIRDFNode : public nsISupports {
 public:
    static const nsIID& GetIID() { static nsIID iid = NS_IRDFNODE_IID; return iid; }

-    /**
-     * Called by nsIRDFService after constructing a resource object to
-     * initialize it's URI.
-     */
-    NS_IMETHOD Init(const char* uri) = 0;
-
    /**
     * Determine if two nodes are identical
     */
@ -82,6 +76,12 @@ class NS_RDF nsIRDFResource : public nsIRDFNode {
 public:
    static const nsIID& GetIID() { static nsIID iid = NS_IRDFRESOURCE_IID; return iid; }

+    /**
+     * Called by nsIRDFService after constructing a resource object to
+     * initialize it's URI.
+     */
+    NS_IMETHOD Init(const char* uri) = 0;
+
    /**
     * Get the 8-bit string value of the node.
     */
@ -118,6 +118,44 @@ public:
    NS_IMETHOD EqualsLiteral(const nsIRDFLiteral* literal, PRBool* result) const = 0;
 };

+// {E13A24E1-C77A-11d2-80BE-006097B76B8E}
+#define NS_IRDFDATE_IID \
+{ 0xe13a24e1, 0xc77a, 0x11d2, { 0x80, 0xbe, 0x0, 0x60, 0x97, 0xb7, 0x6b, 0x8e } };
+
+
+class nsIRDFDate : public nsIRDFNode {
+public:
+    static const nsIID& IID() { static nsIID iid = NS_IRDFDATE_IID; return iid; }
+
+    /**
+     * Get the PRTime value of the node.
+     */
+    NS_IMETHOD GetValue(PRTime *value) const = 0;
+
+    /**
+     * Determine if two ints are identical.
+     */
+    NS_IMETHOD EqualsDate(const nsIRDFDate* literal, PRBool* result) const = 0;
+};
+
+// {E13A24E3-C77A-11d2-80BE-006097B76B8E}
+#define NS_IRDFINT_IID \
+{ 0xe13a24e3, 0xc77a, 0x11d2, { 0x80, 0xbe, 0x0, 0x60, 0x97, 0xb7, 0x6b, 0x8e } };
+
+class nsIRDFInt : public nsIRDFNode {
+public:
+    static const nsIID& IID() { static nsIID iid = NS_IRDFINT_IID; return iid; }
+
+    /**
+     * Get the int32 value of the node.
+     */
+    NS_IMETHOD GetValue(int32 *value) const = 0;
+
+    /**
+     * Determine if two ints are identical.
+     */
+    NS_IMETHOD EqualsInt(const nsIRDFInt* literal, PRBool* result) const = 0;
+};


 #endif // nsIRDFNode_h__
--- a/rdf/base/public/nsIRDFService.h
+++ b/rdf/base/public/nsIRDFService.h
@ -37,10 +37,14 @@

 #include "nscore.h"
 #include "nsISupports.h"
+#include "prtime.h"
 class nsIRDFDataBase;
 class nsIRDFDataSource;
 class nsIRDFLiteral;
 class nsIRDFResource;
+class nsIRDFResourceFactory;
+class nsIRDFDate;
+class nsIRDFInt;

 // {BFD05261-834C-11d2-8EAC-00805F29F370}
 #define NS_IRDFSERVICE_IID \
@ -56,9 +60,11 @@ public:
    /**
     * Construct an RDF resource from a single-byte URI. <tt>nsIRDFSerivce</tt>
     * caches resources that are in-use, so multiple calls to <tt>GetResource()</tt>
-     * for the same <tt>uri</tt> will return identical pointers.
+     * for the same <tt>uri</tt> will return identical pointers. FindResource
+     * is used to find out whether there already exists a resource corresponding to that url.
     */
    NS_IMETHOD GetResource(const char* uri, nsIRDFResource** resource) = 0;
+    NS_IMETHOD FindResource(const char* uri, nsIRDFResource** resource, PRBool* found) = 0;

    /**
     * Construct an RDF resource from a Unicode URI. This is provided
@ -74,6 +80,18 @@ public:
    NS_IMETHOD GetLiteral(const PRUnichar* value, nsIRDFLiteral** literal) = 0;

    /**
+
+     * Construct an RDF literal from a PRTime.
+     */
+    NS_IMETHOD GetDateLiteral(const PRTime value, nsIRDFDate** date) = 0;
+
+    /**
+     * Construct an RDF literal from an int.
+     */
+    NS_IMETHOD GetIntLiteral(const int32 value, nsIRDFInt** intLiteral) = 0;
+
+    /**
+
     * Registers a resource with the RDF system, making it unique w.r.t.
     * GetResource.
     *
@ -100,6 +118,7 @@ public:
    NS_IMETHOD RegisterResource(nsIRDFResource* aResource, PRBool replace = PR_FALSE) = 0;

    /**
+
     * Called to notify the resource manager that a resource is no
     * longer in use. This method should only be called from the
     * destructor of a "custom" resource implementation to notify the
--- a/rdf/base/public/rdf.h
+++ b/rdf/base/public/rdf.h
@ -66,6 +66,9 @@ static const char* kTag##prefix##_##name = #name
 #define NS_ERROR_RDF_CURSOR_EMPTY       NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_RDF, 1)
 #define NS_ERROR_RDF_NO_VALUE           NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_RDF, 2)

+
+
+
 /* ProgID prefixes for RDF DLL registration. */
 #define NS_RDF_PROGID                           "component:||netscape|rdf"
 #define NS_RDF_DATASOURCE_PROGID                NS_RDF_PROGID "|datasource"
@ -73,6 +76,7 @@ static const char* kTag##prefix##_##name = #name
 #define NS_RDF_RESOURCE_FACTORY_PROGID          "component:||netscape|rdf|resource-factory"
 #define NS_RDF_RESOURCE_FACTORY_PROGID_PREFIX   NS_RDF_RESOURCE_FACTORY_PROGID "?name#"

+
 /*@}*/

 #ifdef _IMPL_NS_RDF
--- a/rdf/base/src/nsRDFService.cpp
+++ b/rdf/base/src/nsRDFService.cpp
@ -25,6 +25,8 @@

  1) Implement the CreateDataBase() methods.

+  2) Cache date and int literals.
+
 */

 #include "nsIAtom.h"
@ -69,6 +71,8 @@ static NS_DEFINE_CID(kRDFDefaultResourceCID,     NS_RDFDEFAULTRESOURCE_CID);

 static NS_DEFINE_IID(kIRDFServiceIID,         NS_IRDFSERVICE_IID);
 static NS_DEFINE_IID(kIRDFLiteralIID,         NS_IRDFLITERAL_IID);
+static NS_DEFINE_IID(kIRDFDateIID,         NS_IRDFDATE_IID);
+static NS_DEFINE_IID(kIRDFIntIID,         NS_IRDFINT_IID);
 static NS_DEFINE_IID(kIRDFResourceIID,        NS_IRDFRESOURCE_IID);
 static NS_DEFINE_IID(kIRDFNodeIID,            NS_IRDFNODE_IID);
 static NS_DEFINE_IID(kISupportsIID,           NS_ISUPPORTS_IID);
@ -97,8 +101,11 @@ public:

    // nsIRDFService
    NS_IMETHOD GetResource(const char* uri, nsIRDFResource** resource);
+    NS_IMETHOD FindResource(const char* uri, nsIRDFResource** resource, PRBool *found);
    NS_IMETHOD GetUnicodeResource(const PRUnichar* uri, nsIRDFResource** resource);
    NS_IMETHOD GetLiteral(const PRUnichar* value, nsIRDFLiteral** literal);
+    NS_IMETHOD GetDateLiteral(const PRTime value, nsIRDFDate** date) ;
+    NS_IMETHOD GetIntLiteral(const int32 value, nsIRDFInt** intLiteral);
    NS_IMETHOD RegisterResource(nsIRDFResource* aResource, PRBool replace = PR_FALSE);
    NS_IMETHOD UnregisterResource(nsIRDFResource* aResource);
    NS_IMETHOD RegisterDataSource(nsIRDFDataSource* dataSource, PRBool replace = PR_FALSE);
@ -131,7 +138,6 @@ public:
    NS_DECL_ISUPPORTS

    // nsIRDFNode
-    NS_IMETHOD Init(const char* uri);
    NS_IMETHOD EqualsNode(nsIRDFNode* node, PRBool* result) const;

    // nsIRDFLiteral
@ -175,15 +181,6 @@ LiteralImpl::QueryInterface(REFNSIID iid, void** result)
    return NS_NOINTERFACE;
 }

-NS_IMETHODIMP
-LiteralImpl::Init(const char* uri)
-{
-    // Literals should always be constructed by calling nsIRDFService::GetLiteral,
-    // so this method should never get called.
-    NS_NOTREACHED("RDF LiteralImpl::Init");
-    return NS_ERROR_FAILURE;
-}
-
 NS_IMETHODIMP
 LiteralImpl::EqualsNode(nsIRDFNode* node, PRBool* result) const
 {
@ -230,6 +227,203 @@ LiteralImpl::EqualsLiteral(const nsIRDFLiteral* literal, PRBool* result) const
    return NS_OK;
 }

+
+////////////////////////////////////////////////////////////////////////
+// DateImpl
+//
+
+class DateImpl : public nsIRDFDate {
+public:
+    DateImpl(const PRTime s);
+    virtual ~DateImpl(void);
+
+    // nsISupports
+    NS_DECL_ISUPPORTS
+
+    // nsIRDFNode
+    NS_IMETHOD EqualsNode(nsIRDFNode* node, PRBool* result) const;
+
+    // nsIRDFDate
+    NS_IMETHOD GetValue(PRTime *value) const;
+    NS_IMETHOD EqualsDate(const nsIRDFDate* date, PRBool* result) const;
+
+private:
+    PRTime mValue;
+};
+
+
+DateImpl::DateImpl(const PRTime s)
+    : mValue(s)
+{
+    NS_INIT_REFCNT();
+}
+
+DateImpl::~DateImpl(void)
+{
+}
+
+NS_IMPL_ADDREF(DateImpl);
+NS_IMPL_RELEASE(DateImpl);
+
+nsresult
+DateImpl::QueryInterface(REFNSIID iid, void** result)
+{
+    if (! result)
+        return NS_ERROR_NULL_POINTER;
+
+    *result = nsnull;
+    if (iid.Equals(kIRDFDateIID) ||
+        iid.Equals(kIRDFNodeIID) ||
+        iid.Equals(kISupportsIID)) {
+        *result = NS_STATIC_CAST(nsIRDFDate*, this);
+        AddRef();
+        return NS_OK;
+    }
+    return NS_NOINTERFACE;
+}
+
+NS_IMETHODIMP
+DateImpl::EqualsNode(nsIRDFNode* node, PRBool* result) const
+{
+    nsresult rv;
+    nsIRDFDate* date;
+    if (NS_SUCCEEDED(node->QueryInterface(kIRDFDateIID, (void**) &date))) {
+        rv = EqualsDate(date, result);
+        NS_RELEASE(date);
+    }
+    else {
+        *result = PR_FALSE;
+        rv = NS_OK;
+    }
+    return rv;
+}
+
+NS_IMETHODIMP
+DateImpl::GetValue(PRTime *value) const
+{
+    NS_ASSERTION(value, "null ptr");
+    if (! value)
+        return NS_ERROR_NULL_POINTER;
+
+    *value = mValue;
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+DateImpl::EqualsDate(const nsIRDFDate* date, PRBool* result) const
+{
+    NS_ASSERTION(date && result, "null ptr");
+    if (!date || !result)
+        return NS_ERROR_NULL_POINTER;
+
+    nsresult rv;
+    PRTime p;
+    if (NS_FAILED(rv = date->GetValue(&p)))
+        return rv;
+
+    *result = LL_EQ(p, mValue);
+    return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////
+// IntImpl
+//
+
+class IntImpl : public nsIRDFInt {
+public:
+    IntImpl(const int32 s);
+    virtual ~IntImpl(void);
+
+    // nsISupports
+    NS_DECL_ISUPPORTS
+
+    // nsIRDFNode
+    NS_IMETHOD EqualsNode(nsIRDFNode* node, PRBool* result) const;
+
+    // nsIRDFInt
+    NS_IMETHOD GetValue(int32 *value) const;
+    NS_IMETHOD EqualsInt(const nsIRDFInt* value, PRBool* result) const;
+
+private:
+    int32 mValue;
+};
+
+
+IntImpl::IntImpl(const int32 s)
+    : mValue(s)
+{
+    NS_INIT_REFCNT();
+}
+
+IntImpl::~IntImpl(void)
+{
+}
+
+NS_IMPL_ADDREF(IntImpl);
+NS_IMPL_RELEASE(IntImpl);
+
+nsresult
+IntImpl::QueryInterface(REFNSIID iid, void** result)
+{
+    if (! result)
+        return NS_ERROR_NULL_POINTER;
+
+    *result = nsnull;
+    if (iid.Equals(kIRDFIntIID) ||
+        iid.Equals(kIRDFNodeIID) ||
+        iid.Equals(kISupportsIID)) {
+        *result = NS_STATIC_CAST(nsIRDFInt*, this);
+        AddRef();
+        return NS_OK;
+    }
+    return NS_NOINTERFACE;
+}
+
+NS_IMETHODIMP
+IntImpl::EqualsNode(nsIRDFNode* node, PRBool* result) const
+{
+    nsresult rv;
+    nsIRDFInt* intValue;
+    if (NS_SUCCEEDED(node->QueryInterface(kIRDFIntIID, (void**) &intValue))) {
+        rv = EqualsInt(intValue, result);
+        NS_RELEASE(intValue);
+    }
+    else {
+        *result = PR_FALSE;
+        rv = NS_OK;
+    }
+    return rv;
+}
+
+NS_IMETHODIMP
+IntImpl::GetValue(int32 *value) const
+{
+    NS_ASSERTION(value, "null ptr");
+    if (! value)
+        return NS_ERROR_NULL_POINTER;
+
+    *value = mValue;
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+IntImpl::EqualsInt(const nsIRDFInt* intValue, PRBool* result) const
+{
+    NS_ASSERTION(intValue && result, "null ptr");
+    if (!intValue || !result)
+        return NS_ERROR_NULL_POINTER;
+
+    nsresult rv;
+    int32 p;
+    if (NS_FAILED(rv = intValue->GetValue(&p)))
+        return rv;
+
+    *result = (p == mValue);
+    return NS_OK;
+}
+
 ////////////////////////////////////////////////////////////////////////
 // ServiceImpl

@ -443,6 +637,21 @@ ServiceImpl::GetResource(const char* aURI, nsIRDFResource** aResource)
    return rv;
 }

+NS_IMETHODIMP
+ServiceImpl::FindResource(const char* uri, nsIRDFResource** resource, PRBool *found)
+{
+    nsIRDFResource* result =
+        NS_STATIC_CAST(nsIRDFResource*, PL_HashTableLookup(mResources, uri));
+
+    if (result) {
+        *resource = result;
+        *found = 1;
+    } else {
+        *found = 0;
+    }
+    return NS_OK;
+}
+
 NS_IMETHODIMP
 ServiceImpl::GetUnicodeResource(const PRUnichar* aURI, nsIRDFResource** aResource)
 {
@ -495,6 +704,32 @@ ServiceImpl::GetLiteral(const PRUnichar* aValue, nsIRDFLiteral** aLiteral)
    return NS_OK;
 }

+NS_IMETHODIMP
+ServiceImpl::GetDateLiteral(const PRTime time, nsIRDFDate** literal)
+{
+    // XXX how do we cache these? should they live in their own hashtable?
+    DateImpl* result = new DateImpl(time);
+    if (! result)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    *literal = result;
+    NS_ADDREF(result);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+ServiceImpl::GetIntLiteral(const int32 value, nsIRDFInt** literal)
+{
+    // XXX how do we cache these? should they live in their own hashtable?
+    IntImpl* result = new IntImpl(value);
+    if (! result)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    *literal = result;
+    NS_ADDREF(result);
+    return NS_OK;
+}
+
 NS_IMETHODIMP
 ServiceImpl::RegisterResource(nsIRDFResource* aResource, PRBool replace)
 {
--- a/rdf/base/src/rdfutil.h
+++ b/rdf/base/src/rdfutil.h
@ -36,6 +36,7 @@ class nsIRDFArcsOutCursor;
 class nsIRDFAssertionCursor;
 class nsIRDFCursor;
 class nsIRDFDataSource;
+class nsIRDFResource;
 class nsIRDFNode;
 class nsIRDFResource;
 class nsString;
@ -235,7 +236,7 @@ NS_NewEmptyRDFArcsInCursor(nsIRDFArcsInCursor** result);
 PR_EXTERN(nsresult)
 NS_NewEmptyRDFArcsOutCursor(nsIRDFArcsOutCursor** result);

-
+PR_EXTERN(void) SHTtest ();
 // XXX need to move nsEmptyCursor stuff here.
                       
 #endif // rdfutil_h__
--- a/rdf/build/Makefile.in
+++ b/rdf/build/Makefile.in
@ -73,3 +73,4 @@ install:: $(TARGETS)
 	$(INSTALL) $(srcdir)/../resources/bookmarks.xul $(DIST)/bin/res/rdf
 	$(INSTALL) $(srcdir)/../resources/bookmarks.css $(DIST)/bin/res/rdf
 	$(INSTALL) $(srcdir)/../resources/bookmarks.html $(DIST)/bin/res/rdf
+	$(INSTALL) $(srcdir)/../resources/History/h1.hst $(DIST)/bin/res/rdf/History
--- a/rdf/build/makefile.win
+++ b/rdf/build/makefile.win
@ -74,6 +74,8 @@ install:: $(DLL)
 	$(MAKE_INSTALL) ..\resources\bookmarks.xul $(DIST)\bin\res\rdf
 	$(MAKE_INSTALL) ..\resources\bookmarks.css $(DIST)\bin\res\rdf
 	$(MAKE_INSTALL) ..\resources\bookmarks.html $(DIST)\bin\res\rdf
+	$(MAKE_INSTALL) ..\resources\History\h1.hst $(DIST)\bin\res\rdf\History
+



--- a/rdf/build/nsRDFCID.h
+++ b/rdf/build/nsRDFCID.h
@ -94,4 +94,8 @@
 #define NS_XULDOCUMENT_CID \
 { 0x541afcb2, 0xa9a3, 0x11d2, { 0x8e, 0xc5, 0x0, 0x80, 0x5f, 0x29, 0xf3, 0x70 } }

+// {1EAAFD60-D596-11d2-80BE-006097B76B8E}
+#define NS_RDFHISTORYDATASOURCE_CID \
+{ 0x1eaafd60, 0xd596, 0x11d2, { 0x80, 0xbe, 0x0, 0x60, 0x97, 0xb7, 0x6b, 0x8e } }
+
 #endif // nsRDFCID_h__
--- a/rdf/build/nsRDFFactory.cpp
+++ b/rdf/build/nsRDFFactory.cpp
@ -43,13 +43,15 @@ static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
 static NS_DEFINE_IID(kIFactoryIID,  NS_IFACTORY_IID);

 static NS_DEFINE_CID(kRDFBookmarkDataSourceCID,  NS_RDFBOOKMARKDATASOURCE_CID);
-static NS_DEFINE_CID(kRDFFileSystemDataSourceCID,NS_RDFFILESYSTEMDATASOURCE_CID);
 static NS_DEFINE_CID(kRDFCompositeDataSourceCID, NS_RDFCOMPOSITEDATASOURCE_CID);
 static NS_DEFINE_CID(kRDFContentSinkCID,         NS_RDFCONTENTSINK_CID);
+static NS_DEFINE_CID(kRDFDefaultResourceCID,     NS_RDFDEFAULTRESOURCE_CID);
+static NS_DEFINE_CID(kRDFFileSystemDataSourceCID,NS_RDFFILESYSTEMDATASOURCE_CID);
 static NS_DEFINE_CID(kRDFHTMLBuilderCID,         NS_RDFHTMLBUILDER_CID);
+static NS_DEFINE_CID(kRDFHistoryDataSourceCID,   NS_RDFHISTORYDATASOURCE_CID);
 static NS_DEFINE_CID(kRDFInMemoryDataSourceCID,  NS_RDFINMEMORYDATASOURCE_CID);
-static NS_DEFINE_CID(kRDFServiceCID,             NS_RDFSERVICE_CID);
 static NS_DEFINE_CID(kRDFMenuBuilderCID,         NS_RDFMENUBUILDER_CID);
+static NS_DEFINE_CID(kRDFServiceCID,             NS_RDFSERVICE_CID);
 static NS_DEFINE_CID(kRDFToolbarBuilderCID,      NS_RDFTOOLBARBUILDER_CID);
 static NS_DEFINE_CID(kRDFTreeBuilderCID,         NS_RDFTREEBUILDER_CID);
 static NS_DEFINE_CID(kRDFXMLDataSourceCID,       NS_RDFXMLDATASOURCE_CID);
@ -57,7 +59,6 @@ static NS_DEFINE_CID(kRDFXULBuilderCID,          NS_RDFXULBUILDER_CID);
 static NS_DEFINE_CID(kXULContentSinkCID,         NS_XULCONTENTSINK_CID);
 static NS_DEFINE_CID(kXULDataSourceCID,	         NS_XULDATASOURCE_CID);
 static NS_DEFINE_CID(kXULDocumentCID,            NS_XULDOCUMENT_CID);
-static NS_DEFINE_CID(kRDFDefaultResourceCID,     NS_RDFDEFAULTRESOURCE_CID);
 static NS_DEFINE_CID(kXULSortServiceCID,         NS_XULSORTSERVICE_CID);

 class RDFFactoryImpl : public nsIFactory
@ -140,7 +141,7 @@ RDFFactoryImpl::CreateInstance(nsISupports *aOuter,
    *aResult = nsnull;

    nsresult rv;
-    PRBool wasRefCounted = PR_TRUE;
+
    nsISupports *inst = nsnull;
    if (mClassID.Equals(kRDFServiceCID)) {
        if (NS_FAILED(rv = NS_NewRDFService((nsIRDFService**) &inst)))
@ -171,6 +172,10 @@ RDFFactoryImpl::CreateInstance(nsISupports *aOuter,
        if (NS_FAILED(rv = NS_NewRDFCompositeDataSource((nsIRDFCompositeDataSource**) &inst)))
            return rv;
    }
+    else if (mClassID.Equals(kRDFHistoryDataSourceCID)) {
+        if (NS_FAILED(rv = NS_NewRDFHistoryDataSource((nsIRDFDataSource**) &inst)))
+            return rv;
+    }
    else if (mClassID.Equals(kXULDocumentCID)) {
        if (NS_FAILED(rv = NS_NewXULDocument((nsIRDFDocument**) &inst)))
            return rv;
@ -218,13 +223,12 @@ RDFFactoryImpl::CreateInstance(nsISupports *aOuter,
    if (! inst)
        return NS_ERROR_OUT_OF_MEMORY;

-    if (NS_FAILED(rv = inst->QueryInterface(aIID, aResult)))
-        // We didn't get the right interface, so clean up
-        delete inst;
+    if (NS_FAILED(rv = inst->QueryInterface(aIID, aResult))) {
+        // We didn't get the right interface.
+        NS_ERROR("didn't support the interface you wanted");
+    }

-    if (wasRefCounted)
    NS_IF_RELEASE(inst);
-
    return rv;
 }

@ -276,6 +280,10 @@ NSRegisterSelf(nsISupports* serviceMgr, const char* aPath)
                                         "RDF File System Data Source",
                                         NS_RDF_DATASOURCE_PROGID_PREFIX "files",
                                         aPath, PR_TRUE, PR_TRUE);
+    rv = nsRepository::RegisterComponent(kRDFHistoryDataSourceCID,  
+                                         "RDF History Data Source",
+                                         NS_RDF_DATASOURCE_PROGID_PREFIX "history",
+                                         aPath, PR_TRUE, PR_TRUE);
    rv = nsRepository::RegisterComponent(kRDFCompositeDataSourceCID, 
                                         "RDF Composite Data Source",
                                         NS_RDF_DATASOURCE_PROGID_PREFIX "composite-datasource",
@ -352,6 +360,7 @@ NSUnregisterSelf(nsISupports* serviceMgr, const char* aPath)

    rv = nsRepository::UnregisterComponent(kRDFBookmarkDataSourceCID,  aPath);
    rv = nsRepository::UnregisterComponent(kRDFFileSystemDataSourceCID,aPath);
+    rv = nsRepository::UnregisterComponent(kRDFHistoryDataSourceCID,   aPath);
    rv = nsRepository::UnregisterComponent(kRDFCompositeDataSourceCID, aPath);
    rv = nsRepository::UnregisterComponent(kRDFInMemoryDataSourceCID,  aPath);
    rv = nsRepository::UnregisterComponent(kRDFXMLDataSourceCID,       aPath);
--- a/rdf/content/src/nsRDFGenericBuilder.cpp
+++ b/rdf/content/src/nsRDFGenericBuilder.cpp
@ -756,7 +756,9 @@ RDFGenericBuilderImpl::OnSetAttribute(nsIDOMElement* aElement, const nsString& a
        }

        if ((rv == NS_CONTENT_ATTR_NO_VALUE) || (rv == NS_CONTENT_ATTR_NOT_THERE) ||
-            ((rv == NS_CONTENT_ATTR_HAS_VALUE) && (! attrValue.EqualsIgnoreCase(aValue)))) {
+            ((rv == NS_CONTENT_ATTR_HAS_VALUE) && (! attrValue.EqualsIgnoreCase(aValue))) ||
+            PR_TRUE // XXX just always allow this to fire.
+            ) {
            // Okay, it's really changing.

            // This is a "transient" property, so we _don't_ go to the
--- a/rdf/content/src/nsRDFTreeBuilder.cpp
+++ b/rdf/content/src/nsRDFTreeBuilder.cpp
@ -360,8 +360,8 @@ RDFTreeBuilderImpl::AddWidgetItem(nsIContent* aElement,
            return rv;
        }

-        // Ignore ordinal properties
-        if (rdf_IsOrdinalProperty(property))
+        // Ignore properties that are used to indicate "tree-ness"
+        if (IsWidgetProperty(aElement, property))
            continue;

        PRInt32 nameSpaceID;
--- a/rdf/content/src/nsXULTemplateBuilder.cpp
+++ b/rdf/content/src/nsXULTemplateBuilder.cpp
@ -756,7 +756,9 @@ RDFGenericBuilderImpl::OnSetAttribute(nsIDOMElement* aElement, const nsString& a
        }

        if ((rv == NS_CONTENT_ATTR_NO_VALUE) || (rv == NS_CONTENT_ATTR_NOT_THERE) ||
-            ((rv == NS_CONTENT_ATTR_HAS_VALUE) && (! attrValue.EqualsIgnoreCase(aValue)))) {
+            ((rv == NS_CONTENT_ATTR_HAS_VALUE) && (! attrValue.EqualsIgnoreCase(aValue))) ||
+            PR_TRUE // XXX just always allow this to fire.
+            ) {
            // Okay, it's really changing.

            // This is a "transient" property, so we _don't_ go to the
--- a/rdf/datasource/public/MANIFEST
+++ b/rdf/datasource/public/MANIFEST
@ -1,2 +1,3 @@
+nsIRDFHistory.h
 nsIRDFFileSystem.h
 nsIXULContentSink.h
--- a/rdf/datasource/public/Makefile.in
+++ b/rdf/datasource/public/Makefile.in
@ -25,8 +25,9 @@ include $(DEPTH)/config/autoconf.mk
 MODULE = rdf

 EXPORTS =				\
-	nsIXULContentSink.h		\
 	nsIRDFFileSystem.h		\
+	nsIRDFHistory.h			\
+	nsIXULContentSink.h		\
        $(NULL)

 EXPORTS := $(addprefix $(srcdir)/, $(EXPORTS))
--- a/rdf/datasource/public/makefile.win
+++ b/rdf/datasource/public/makefile.win
@ -21,8 +21,9 @@ MODULE=rdf
 DEPTH=..\..\..

 EXPORTS	= \
-        nsIXULContentSink.h \
 	nsIRDFFileSystem.h      \
+	nsIRDFHistory.h         \
+        nsIXULContentSink.h     \
 	$(NULL)

 include <$(DEPTH)/config/rules.mak>
--- a/rdf/datasource/public/nsIRDFHistory.h
+++ b/rdf/datasource/public/nsIRDFHistory.h
@ -24,20 +24,21 @@

 // {115CE051-A59D-11d2-80B6-006097B76B8E}
 #define NS_IRDFWEBPAGE_IID \
-{ 0x115ce051, 0xa59d, 0x11d2, { 0x80, 0xb6, 0x0, 0x60, 0x97, 0xb7, 0x6b, 0x8e } };
+{ 0x115ce051, 0xa59d, 0x11d2, { 0x80, 0xb6, 0x0, 0x60, 0x97, 0xb7, 0x6b, 0x8e } }

 // {1A880051-A59D-11d2-80B6-006097B76B8E}
 #define NS_IRDFHISTORYDATASOURCE_IID \
-{ 0x1a880051, 0xa59d, 0x11d2, { 0x80, 0xb6, 0x0, 0x60, 0x97, 0xb7, 0x6b, 0x8e } };
+{ 0x1a880051, 0xa59d, 0x11d2, { 0x80, 0xb6, 0x0, 0x60, 0x97, 0xb7, 0x6b, 0x8e } }


 class nsIRDFHistoryDataSource : public nsIRDFDataSource {
 public:
+    static const nsIID& GetIID() { static nsIID iid = NS_IRDFHISTORYDATASOURCE_IID; return iid; }

    /**
     * Add the specified item to history
     */
-    NS_IMETHOD AddPage (const char* uri) = 0;
+    NS_IMETHOD AddPage (const char* uri, const char* referer, PRTime date) = 0;

    /**
     * Set the title of the page
@ -52,5 +53,19 @@ public:
    /**
     * Get the uri's last visit date
     */
-    NS_IMETHOD LastVisitDate (const char* uri, unit32 *date) = 0;
+    NS_IMETHOD LastVisitDate (const char* uri, uint32 *date) = 0;
+
+    /** 
+     * Get the preferred completion 
+     */
+    NS_IMETHOD CompleteURL (const char* prefix, char** preferredCompletion) = 0;
 };
+
+#endif nsIRDFHistory_h
+
+
+
+
+
+
+
--- a/rdf/datasource/src/Makefile.in
+++ b/rdf/datasource/src/Makefile.in
@ -29,6 +29,7 @@ LIBRARY_NAME = rdfdatasource_s
 CPPSRCS =				\
        nsBookmarkDataSource.cpp	\
        nsFileSystemDataSource.cpp	\
+	nsHistoryDataSource.cpp		\
 	nsXULContentSink.cpp		\
 	nsXULDataSource.cpp		\
 	$(NULL)
--- a/rdf/datasource/src/makefile.win
+++ b/rdf/datasource/src/makefile.win
@ -21,6 +21,7 @@ LIBRARY_NAME=rdfdatasource_s

 CPP_OBJS=\
        .\$(OBJDIR)\nsBookmarkDataSource.obj    \
+        .\$(OBJDIR)\nsHistoryDataSource.obj    \
        .\$(OBJDIR)\nsFileSystemDataSource.obj  \
        .\$(OBJDIR)\nsXULContentSink.obj        \
        .\$(OBJDIR)\nsXULDataSource.obj         \
--- a/rdf/datasource/src/nsFileSystemDataSource.cpp
+++ b/rdf/datasource/src/nsFileSystemDataSource.cpp
@ -82,6 +82,19 @@ DEFINE_RDF_VOCAB(RDF_NAMESPACE_URI, RDF, Seq);
 static	nsIRDFService		*gRDFService = nsnull;
 static	FileSystemDataSource	*gFileSystemDataSource = nsnull;

+PRInt32 FileSystemDataSource::gRefCnt;
+
+nsIRDFResource		*FileSystemDataSource::kNC_FileSystemRoot;
+nsIRDFResource		*FileSystemDataSource::kNC_Child;
+nsIRDFResource		*FileSystemDataSource::kNC_Name;
+nsIRDFResource		*FileSystemDataSource::kNC_URL;
+nsIRDFResource		*FileSystemDataSource::kNC_Columns;
+nsIRDFResource		*FileSystemDataSource::kNC_Folder;
+
+nsIRDFResource		*FileSystemDataSource::kRDF_InstanceOf;
+nsIRDFResource		*FileSystemDataSource::kRDF_type;
+nsIRDFResource		*FileSystemDataSource::kRDF_Seq;
+


 static PRBool
@ -125,10 +138,26 @@ FileSystemDataSource::FileSystemDataSource(void)
 	  mObservers(nsnull)
 {
    NS_INIT_REFCNT();
+
+    if (gRefCnt++ == 0) {
        nsresult rv = nsServiceManager::GetService(kRDFServiceCID,
-		kIRDFServiceIID, (nsISupports**) &gRDFService);
+                                                   kIRDFServiceIID,
+                                                   (nsISupports**) &gRDFService);
+
        PR_ASSERT(NS_SUCCEEDED(rv));
+
+	gRDFService->GetResource(kURINC_FileSystemRoot, &kNC_FileSystemRoot);
+	gRDFService->GetResource(kURINC_child, &kNC_Child);
+	gRDFService->GetResource(kURINC_Name, &kNC_Name);
+	gRDFService->GetResource(kURINC_URL, &kNC_URL);
+	gRDFService->GetResource(kURINC_Folder, &kNC_Folder);
+
+	gRDFService->GetResource(kURIRDF_instanceOf, &kRDF_InstanceOf);
+	gRDFService->GetResource(kURIRDF_type, &kRDF_type);
+	gRDFService->GetResource(kURIRDF_Seq, &kRDF_Seq);
+
        gFileSystemDataSource = this;
+    }
 }


@ -149,21 +178,21 @@ FileSystemDataSource::~FileSystemDataSource (void)
            mObservers = nsnull;
 	}

-	nsrefcnt	refcnt;
-	NS_RELEASE2(kNC_FileSystemRoot, refcnt);
-	NS_RELEASE2(kNC_Child, refcnt);
-	NS_RELEASE2(kNC_Name, refcnt);
-	NS_RELEASE2(kNC_URL, refcnt);
-//	NS_RELEASE2(kNC_Columns, refcnt);
-	NS_RELEASE2(kNC_Folder, refcnt);
+    if (--gRefCnt == 0) {
+        NS_RELEASE(kNC_FileSystemRoot);
+        NS_RELEASE(kNC_Child);
+        NS_RELEASE(kNC_Name);
+        NS_RELEASE(kNC_URL);
+        NS_RELEASE(kNC_Folder);

-	NS_RELEASE2(kRDF_InstanceOf, refcnt);
-	NS_RELEASE2(kRDF_type, refcnt);
-	NS_RELEASE2(kRDF_Seq, refcnt);
+        NS_RELEASE(kRDF_InstanceOf);
+        NS_RELEASE(kRDF_type);
+        NS_RELEASE(kRDF_Seq);

        gFileSystemDataSource = nsnull;
        nsServiceManager::ReleaseService(kRDFServiceCID, gRDFService);
        gRDFService = nsnull;
+    }
 }


@ -181,18 +210,6 @@ FileSystemDataSource::Init(const char *uri)
 	if ((mURI = PL_strdup(uri)) == nsnull)
 		return rv;

-	gRDFService->GetResource(kURINC_FileSystemRoot, &kNC_FileSystemRoot);
-	gRDFService->GetResource(kURINC_child, &kNC_Child);
-	gRDFService->GetResource(kURINC_Name, &kNC_Name);
-	gRDFService->GetResource(kURINC_URL, &kNC_URL);
-//	gRDFService->GetResource(kURINC_Columns, &kNC_Columns);
-	gRDFService->GetResource(kURINC_Folder, &kNC_Folder);
-
-	gRDFService->GetResource(kURIRDF_instanceOf, &kRDF_InstanceOf);
-	gRDFService->GetResource(kURIRDF_type, &kRDF_type);
-	gRDFService->GetResource(kURIRDF_Seq, &kRDF_Seq);
-
-
 	//   if (NS_FAILED(rv = AddColumns()))
 	//       return rv;

@ -623,7 +640,7 @@ FileSystemCursor::FileSystemCursor(nsIRDFResource *source,
 	  mTarget(nsnull),
 	  mValue(nsnull)
 {
-//	NS_INIT_REFCNT();
+	NS_INIT_REFCNT();
 	NS_ADDREF(mSource);
 	NS_ADDREF(mProperty);
 }
@ -654,6 +671,7 @@ FileSystemCursor::Advance(void)
 	NS_IF_RELEASE(mValue);
 	mTarget = mValue = (nsIRDFNode *)mArray->ElementAt(mCount++);
 	NS_ADDREF(mValue);
+    NS_ADDREF(mTarget);
 	return NS_OK;
 }

--- a/rdf/datasource/src/nsFileSystemDataSource.h
+++ b/rdf/datasource/src/nsFileSystemDataSource.h
@ -77,16 +77,19 @@ private:
 	char			*mURI;
 	nsVoidArray		*mObservers;

-	nsIRDFResource		*kNC_FileSystemRoot;
-	nsIRDFResource		*kNC_Child;
-	nsIRDFResource		*kNC_Name;
-	nsIRDFResource		*kNC_URL;
-	nsIRDFResource		*kNC_Columns;
-	nsIRDFResource		*kNC_Folder;
+    static PRInt32 gRefCnt;

-	nsIRDFResource		*kRDF_InstanceOf;
-	nsIRDFResource		*kRDF_type;
-	nsIRDFResource		*kRDF_Seq;
+    // pseudo-constants
+	static nsIRDFResource		*kNC_FileSystemRoot;
+	static nsIRDFResource		*kNC_Child;
+	static nsIRDFResource		*kNC_Name;
+	static nsIRDFResource		*kNC_URL;
+	static nsIRDFResource		*kNC_Columns;
+	static nsIRDFResource		*kNC_Folder;
+
+	static nsIRDFResource		*kRDF_InstanceOf;
+	static nsIRDFResource		*kRDF_type;
+	static nsIRDFResource		*kRDF_Seq;

 public:

--- a/rdf/datasource/src/nsHistoryDataSource.cpp
+++ b/rdf/datasource/src/nsHistoryDataSource.cpp
@ -29,15 +29,15 @@
 #include "nsVoidArray.h"  // XXX introduces dependency on raptorbase
 #include "nsRDFCID.h"
 #include "rdfutil.h"
-#include "nsIRDFMail.h"
+#include "nsIRDFHistory.h"
 #include "nsIRDFService.h"
 #include "plhash.h"
 #include "plstr.h"
 #include "prmem.h"
 #include "prprf.h"
 #include "prio.h"
+#include "prtime.h"

-#include "nsMailDataSource.h"

 ////////////////////////////////////////////////////////////////////////
 // Interface IDs
@ -48,10 +48,9 @@ static NS_DEFINE_IID(kIRDFAssertionCursorIID,      NS_IRDFASSERTIONCURSOR_IID);
 static NS_DEFINE_IID(kIRDFCursorIID,               NS_IRDFCURSOR_IID);
 static NS_DEFINE_IID(kIRDFDataSourceIID,           NS_IRDFDATASOURCE_IID);
 static NS_DEFINE_IID(kIRDFLiteralIID,              NS_IRDFLITERAL_IID);
-static NS_DEFINE_IID(kIRDFHistoryDataSourceIID,    NS_IRDFHISTORYDATAOURCE_IID);
+static NS_DEFINE_IID(kIRDFHistoryDataSourceIID,    NS_IRDFHISTORYDATASOURCE_IID);
 static NS_DEFINE_IID(kIRDFNodeIID,                 NS_IRDFNODE_IID);
 static NS_DEFINE_IID(kIRDFResourceIID,             NS_IRDFRESOURCE_IID);
-static NS_DEFINE_IID(kIRDFResourceFactoryIID,      NS_IRDFRESOURCEFACTORY_IID);
 static NS_DEFINE_IID(kIRDFServiceIID,              NS_IRDFSERVICE_IID);
 static NS_DEFINE_IID(kISupportsIID,                NS_ISUPPORTS_IID);
 static NS_DEFINE_CID(kRDFServiceCID,               NS_RDFSERVICE_CID);
@ -61,25 +60,74 @@ static NS_DEFINE_CID(kRDFInMemoryDataSourceCID,    NS_RDFINMEMORYDATASOURCE_CID)
 // RDF property & resource declarations

 static const char kURIHistoryRoot[]  = "HistoryRoot";
+static nsIRDFService* gRDFService = nsnull;
+
+
+DEFINE_RDF_VOCAB(RDF_NAMESPACE_URI, RDF, instanceOf);

 DEFINE_RDF_VOCAB(NC_NAMESPACE_URI, NC, child);
 DEFINE_RDF_VOCAB(NC_NAMESPACE_URI, NC, Name);
 DEFINE_RDF_VOCAB(NC_NAMESPACE_URI, NC, Folder);
-DEFINE_RDF_VOCAB(NC_NAMESPACE_URI, NC, Column);
-DEFINE_RDF_VOCAB(NC_NAMESPACE_URI, NC, Columns);
 DEFINE_RDF_VOCAB(NC_NAMESPACE_URI, NC, Title);
+DEFINE_RDF_VOCAB(NC_NAMESPACE_URI, NC, Page);
+DEFINE_RDF_VOCAB(NC_NAMESPACE_URI, NC, Date);
+DEFINE_RDF_VOCAB(NC_NAMESPACE_URI, NC, Referer);

 DEFINE_RDF_VOCAB(WEB_NAMESPACE_URI, WEB, LastVisitDate);
 DEFINE_RDF_VOCAB(WEB_NAMESPACE_URI, WEB, LastModifiedDate);

+typedef struct _HistoryEntry {
+    PRTime date;
+    char* url;
+    char* referer;
+} HistoryEntry;

+typedef HistoryEntry* HE;

-class nsHistoryDataSource : public nsIHistoryDataSource {
-    nsIRDFDataSource** mInner;
+static PLHashNumber
+rdf_HashPointer(const void* key)
+{
+    return (PLHashNumber) key;
+}
+
+class nsHistoryDataSource : public nsIRDFHistoryDataSource {
+protected:
+    nsIRDFDataSource*  mInner;
    nsVoidArray        mFiles;
+    char*              mCurrentFilePath;
+    FILE*              mCurrentFile;
+    nsVoidArray        mPendingWrites; 
+    PLHashTable*       mLastVisitDateHash; 
+    PRExplodedTime     mSessionTime;
+
+    nsIRDFResource*    mResourcePage;
+    nsIRDFResource*    mResourceDate;    
+    nsIRDFResource*    mResourceTitle;
+    nsIRDFResource*    mResourceReferer;
+    nsIRDFResource*    mResourceChild;
+    nsIRDFResource*    mResourceHistoryBySite;
+
+    nsresult ReadHistory(void);
+    nsresult ReadOneHistoryFile(const char* uri);
+    nsresult AddPageToGraph(char* url, char* title, char* referer,  PRTime date);
+    nsresult AddToDateHierarchy (PRTime date, nsIRDFResource* resource) ;
+    nsresult getSiteOfURL(char* url, nsIRDFResource** resource) ;

 public:
+    // nsISupports
+    NS_DECL_ISUPPORTS
+
+    nsHistoryDataSource(void) {
+        NS_INIT_REFCNT();
+    }
+
+    virtual ~nsHistoryDataSource(void) {
+        NS_RELEASE(mInner);
+        nsServiceManager::ReleaseService(kRDFServiceCID, gRDFService);
+    }
+
    NS_IMETHOD Init(const char* uri) ;
+
    NS_IMETHOD GetURI(const char* *uri) {
        return mInner->GetURI(uri);
    }
@ -159,4 +207,298 @@ public:
        return mInner->DoCommand(aCommand, aCommandTarget);
    }

+    NS_IMETHOD GetURI(const char* *uri) const {
+        return mInner->GetURI(uri);
+    }
+
+    NS_IMETHOD GetAllResources(nsIRDFResourceCursor** aCursor) {
+        return mInner->GetAllResources(aCursor);
+    }
+
+    NS_IMETHOD AddPage (const char* uri, const char* referer, PRTime time);
+
+    NS_IMETHOD SetPageTitle (const char* uri, PRUnichar* title) ;
+
+    NS_IMETHOD RemovePage (nsIRDFResource* page) {
+        return NS_OK;
+    }
+
+    NS_IMETHOD LastVisitDate (const char* uri, uint32 *date) {
+        nsIRDFResource* res;
+        PRBool found = 0;
+        *date = 0;
+        gRDFService->FindResource(uri, &res, &found);
+        if (found) *date = (uint32)PL_HashTableLookup(mLastVisitDateHash, res);    
+        return NS_OK;
+    }
+
+    nsresult UpdateLastVisitDate (nsIRDFResource* res, uint32 date) {
+        uint32 edate = (uint32) PL_HashTableLookup(mLastVisitDateHash, res);    
+        if (edate && (edate > date)) return NS_OK;
+        PL_HashTableAdd(mLastVisitDateHash, res, (void*)date);
+        return NS_OK;
+    }
+
+    NS_IMETHOD CompleteURL (const char* prefix, char** preferredCompletion) {
+        return NS_OK;
+    }
+
 };
+
+NS_IMPL_ADDREF(nsHistoryDataSource);
+NS_IMPL_RELEASE(nsHistoryDataSource);
+
+NS_IMETHODIMP
+nsHistoryDataSource::QueryInterface(REFNSIID aIID, void** aResult)
+{
+    NS_PRECONDITION(aResult != nsnull, "null ptr");
+    if (! aResult)
+        return NS_ERROR_NULL_POINTER;
+
+    if (aIID.Equals(nsIRDFHistoryDataSource::GetIID()) ||
+        aIID.Equals(nsIRDFDataSource::GetIID()) ||
+        aIID.Equals(nsISupports::GetIID())) {
+        *aResult = NS_STATIC_CAST(nsIRDFHistoryDataSource*, this);
+        NS_ADDREF(this);
+        return NS_OK;
+    }
+    else {
+        *aResult = nsnull;
+        return NS_NOINTERFACE;
+    }
+}
+
+NS_IMETHODIMP
+nsHistoryDataSource::Init(const char* uri)
+{
+    nsresult rv;
+    if (NS_FAILED(rv = nsRepository::CreateInstance(kRDFInMemoryDataSourceCID,
+                                                    nsnull, kIRDFDataSourceIID,
+                                                    (void**) &mInner)))
+        return rv;
+
+    if (NS_FAILED(rv = mInner->Init(uri)))
+        return rv;
+
+
+    rv = nsServiceManager::GetService(kRDFServiceCID,
+                                               kIRDFServiceIID,
+                                               (nsISupports**) &gRDFService);
+
+    PR_ASSERT(NS_SUCCEEDED(rv));
+
+    // register this as a named data source with the RDF service
+    gRDFService->RegisterDataSource(this);
+    
+    gRDFService->GetResource(kURINC_Page,    &mResourcePage);
+    gRDFService->GetResource(kURINC_Date,    &mResourceDate);
+    gRDFService->GetResource(kURINC_Name,   &mResourceTitle);
+    gRDFService->GetResource(kURINC_Referer, &mResourceReferer);
+    gRDFService->GetResource(kURINC_child,   &mResourceChild);
+    gRDFService->GetResource("NC:HistoryBySite",   &mResourceHistoryBySite);
+
+    mLastVisitDateHash = PL_NewHashTable(400, rdf_HashPointer,
+                                         PL_CompareValues,
+                                         PL_CompareValues,
+                                         nsnull, nsnull);
+ 
+    PR_ExplodeTime(PR_Now(), PR_LocalTimeParameters, &mSessionTime);
+    
+    if (NS_FAILED(rv = ReadHistory()))
+        return rv;
+
+    if (!mCurrentFile) {
+        char fileurl[256];
+        PR_snprintf(fileurl, sizeof(fileurl), "res\\rdf\\History\\%i.hst",  PR_Now());
+    }
+    return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsHistoryDataSource::AddPage (const char* uri, const char* referer, PRTime time) {
+    HE he = (HE) PR_Malloc(sizeof(HistoryEntry));
+    he->date = time;
+    he->url = (char*) uri;
+    he->referer = (char*) referer;
+    mPendingWrites.AppendElement(he);
+    return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsHistoryDataSource::SetPageTitle (const char* uri, PRUnichar* title) {
+    for (PRInt32 i = mPendingWrites.Count() - 1; i >= 0; --i) {
+        HE wr = (HE) mPendingWrites.ElementAt(i);
+        if (strcmp(wr->url, uri) == 0) {
+            char timeBuffer[256];
+            PRExplodedTime etime;
+            PR_ExplodeTime(wr->date, PR_LocalTimeParameters, &etime);
+            PR_FormatTimeUSEnglish(timeBuffer, 256, "%a %b %d %H:%M:%S %Y", &etime);
+            fprintf(mCurrentFile, "%s\t%s\t%s\t%s\n", wr->url, title, wr->referer, timeBuffer);
+            mPendingWrites.RemoveElement(wr);
+            AddPageToGraph(wr->url,  (char*) title, wr->referer,  PR_Now()) ;
+            PR_Free(wr);
+            return NS_OK;
+        }    
+    }
+    return NS_OK;
+}
+
+
+
+PRBool
+endsWith (const char* pattern, const char* uuid)
+{
+  short l1 = strlen(pattern);
+  short l2 = strlen(uuid);
+  short index;
+  if (l2 < l1) return false;  
+  for (index = 1; index <= l1; index++) {
+    if (pattern[l1-index] != uuid[l2-index]) return false;
+  }  
+  return true;
+}
+
+nsresult
+nsHistoryDataSource::ReadHistory(void)
+{
+    nsresult rv = NS_ERROR_FAILURE;
+    char fileurl[256];
+    PRInt32 n = PR_SKIP_BOTH;
+    PRDirEntry	*de;
+    PRDir* dir;
+    PR_snprintf(fileurl, sizeof(fileurl), "res\\rdf\\History");
+    dir =  PR_OpenDir(fileurl);
+    while ((dir != NULL) && ((de = PR_ReadDir(dir, (PRDirFlags)(n++))) != NULL)) {
+        if (endsWith(".hst", de->name)) ReadOneHistoryFile(de->name);
+    }
+    if (dir) PR_CloseDir(dir);
+    return NS_OK;
+}
+
+
+nsresult
+nsHistoryDataSource::ReadOneHistoryFile(const char* fileName)
+{
+    nsresult rv = NS_ERROR_FAILURE;
+    char fileurl[256];
+    FILE* f;
+    PR_snprintf(fileurl, sizeof(fileurl), "res\\rdf\\History\\%s", fileName);
+    if ((f = fopen(fileurl, "rw")) != nsnull) {
+        char* buffer = (char*) PR_Malloc(1024 * 4);
+        int n = 0;
+        char *title, *url, *referer, *date;
+        PRTime time;
+        PRTime fileTime = LL_ZERO;
+        while (fgets(buffer, 1024 * 4, f) != 0) {
+            // url<tab>title<tab>referer<tab>date
+            url = buffer;
+			buffer[strlen(buffer)-1] = '\0';
+            title = strchr(buffer, '\t') + 1;
+            *(title - 1) = '\0';
+            referer = strchr(title, '\t') + 1;
+            *(referer - 1) = '\0';
+            date = strchr(referer, '\t') + 1;         
+			*(date -1 ) = '\0';
+            PR_ParseTimeString (date, 0, &time);
+            if (LL_IS_ZERO(fileTime)) { 
+                PRExplodedTime etime;
+                fileTime = time;
+                PR_ExplodeTime(time, PR_LocalTimeParameters, &etime);
+                if (etime.tm_yday == mSessionTime.tm_yday) mCurrentFile = f;
+            }
+            AddPageToGraph(url, title, referer,  time);
+        }        
+        PR_Free(buffer);  
+		if (f != mCurrentFile) fclose(f);
+    }
+    return rv;
+}
+
+nsresult 
+nsHistoryDataSource::getSiteOfURL(char* url, nsIRDFResource** resource) {
+    char* str = strstr(url, "://");
+    char buff[256];
+	 nsIRDFLiteral  *titleLiteral;
+    PRBool foundp;
+    if (!str) return NS_ERROR_FAILURE;
+    str = str + 3;
+    if (str[0] == '/') str++;
+    char* estr = strchr(str, '/');
+    if (!estr) estr = str + strlen(str);
+    if ((estr - str) > 256) return NS_ERROR_FAILURE;
+	memset(buff, '\0', 256);
+    static const char kHistoryURLPrefix[] = "hst:site?";
+    strcpy(buff, kHistoryURLPrefix);
+    strncat(buff, str, (estr-str));
+    if (NS_OK != gRDFService->FindResource(buff, resource, &foundp)) return NS_ERROR_FAILURE;
+    if (foundp) return NS_OK;
+    if (NS_OK != gRDFService->GetResource(buff, resource)) return NS_ERROR_FAILURE;
+    mInner->Assert(mResourceHistoryBySite,  mResourceChild, *resource, 1);
+    nsAutoString ptitle(buff + sizeof(kHistoryURLPrefix) - 1);	
+    gRDFService->GetLiteral(ptitle, &titleLiteral);
+	mInner->Assert(*resource, mResourceTitle, titleLiteral, 1);
+    return NS_OK;
+}
+
+nsresult 
+nsHistoryDataSource::AddPageToGraph(char* url, char* title, 
+                                    char* referer,  PRTime date) {
+    char* histURL = (char*) PR_Malloc(strlen(url) + 7);    
+    nsIRDFResource *pageResource, *refererResource, *histResource, *siteResource;    
+    nsIRDFLiteral  *titleLiteral;
+    nsIRDFDate     *dateLiteral;
+    PR_snprintf(histURL, strlen(histURL), "hst://%s", url);
+    nsresult rv = getSiteOfURL(url, &siteResource);
+    if (rv != NS_OK) return rv;
+    gRDFService->GetResource(url, &pageResource);
+    gRDFService->GetResource(histURL, &histResource);
+    gRDFService->GetResource(referer, &refererResource);
+    gRDFService->GetDateLiteral(date, &dateLiteral);
+    nsAutoString ptitle(title);
+    gRDFService->GetLiteral(ptitle, &titleLiteral);
+    mInner->Assert(histResource,  mResourcePage, pageResource, 1);
+    mInner->Assert(histResource,  mResourceDate, dateLiteral, 1);
+    mInner->Assert(pageResource,  mResourceTitle, titleLiteral, 1);
+    mInner->Assert(histResource,  mResourceReferer, refererResource, 1);
+    mInner->Assert(siteResource,  mResourceChild, pageResource, 1);
+    AddToDateHierarchy(date, histResource);
+    UpdateLastVisitDate (pageResource, 1/* date */) ;
+    NS_RELEASE(histResource);
+    NS_RELEASE(siteResource);
+    NS_RELEASE(pageResource);
+    NS_RELEASE(refererResource);
+    NS_RELEASE(dateLiteral);
+    NS_RELEASE(titleLiteral);
+    PR_Free(histURL);
+    return NS_OK;
+}
+
+nsresult
+nsHistoryDataSource::AddToDateHierarchy (PRTime date, nsIRDFResource* resource) {
+    return NS_OK;
+}
+
+nsresult
+NS_NewRDFHistoryDataSource(nsIRDFDataSource** result)
+{
+    nsHistoryDataSource* ds = new nsHistoryDataSource();
+
+    if (! ds)
+        return NS_ERROR_NULL_POINTER;
+
+    *result = ds;
+    NS_ADDREF(*result);
+    return NS_OK;
+}
+    
+    
+
+
+
+
+
+
+
+
+
+
--- a/rdf/datasource/src/nsRDFBuiltInDataSources.h
+++ b/rdf/datasource/src/nsRDFBuiltInDataSources.h
@ -46,6 +46,9 @@ nsresult NS_NewRDFInMemoryDataSource(nsIRDFDataSource** result);
 // in nsStreamDataSource.cpp
 nsresult NS_NewRDFStreamDataSource(nsIRDFDataSource** result);

+// in nsHistoryDataSource.cpp
+nsresult NS_NewRDFHistoryDataSource(nsIRDFDataSource** result);
+
 #endif // nsBuiltinDataSources_h__


--- a/rdf/macbuild/rdf.mcp
+++ b/rdf/macbuild/rdf.mcp
--- a/rdf/resources/History/h1.hst
+++ b/rdf/resources/History/h1.hst
@ -0,0 +1,3 @@
+http://www.netscape.com/	Netscape Home	http://www.mozilla.org	22-AUG-1993 12:59am
+http://www.microsoft.com/	Microsoft Home	http://www.mozilla.org	Friday, August 04, 1995 3:54 PM
+http://www.whatever.com/baz.html	Baz	http://www.netscape.com	20/06/95 21:07
--- a/rdf/resources/sidebar.xul
+++ b/rdf/resources/sidebar.xul
@ -57,7 +57,7 @@ function doSort(sortColName)

 </html:script>

-<xul:tree datasources="rdf:files rdf:bookmarks rdf:mail">
+<xul:tree datasources="rdf:files rdf:bookmarks rdf:mail rdf:history">
  <xul:treecol id="NameColumn" rdf:resource="http://home.netscape.com/NC-rdf#Name"/>
  <xul:treecol id="URLColumn" rdf:resource="http://home.netscape.com/NC-rdf#URL"/>
  <xul:treecol id="LastModColumn" rdf:resource="http://home.netscape.com/WEB-rdf#LastModifiedDate"/>
@ -98,6 +98,12 @@ function doSort(sortColName)
      <xul:treecell></xul:treecell>
    </xul:treeitem>

+    <xul:treeitem id="NC:HistoryBySite">
+      <xul:treecell>History By Site</xul:treecell>
+      <xul:treecell></xul:treecell>
+      <xul:treecell></xul:treecell>
+    </xul:treeitem>
+
  </xul:treebody>
 </xul:tree>

--- a/rdf/util/public/nsRDFResource.h
+++ b/rdf/util/public/nsRDFResource.h
@ -33,10 +33,10 @@ public:
    NS_DECL_ISUPPORTS

    // nsIRDFNode methods:
-    NS_IMETHOD Init(const char* uri);
    NS_IMETHOD EqualsNode(nsIRDFNode* node, PRBool* result) const;

    // nsIRDFResource methods:
+    NS_IMETHOD Init(const char* uri);
    NS_IMETHOD GetValue(const char* *uri) const;
    NS_IMETHOD EqualsResource(const nsIRDFResource* resource, PRBool* result) const;
    NS_IMETHOD EqualsString(const char* uri, PRBool* result) const;