private CacheRule GetCacheRuleForTopic(string topic)
 {
     AbsoluteTopicName tn = new AbsoluteTopicName(topic);
     CompositeCacheRule rule = new CompositeCacheRule();
     Formatter.FormattedTopic(tn, OutputFormat.Testing, null, Federation, _lm, rule);
     return rule;
 }

		string IEditServiceProxy.GetTextForTopic(LocalTopic topic)
		{
			AbsoluteTopicName atn = new AbsoluteTopicName(); 
			atn.Namespace = topic.Namespace.Name; 
			atn.Name = topic.Name; 
			return base.GetTextForTopic(atn); 
		}

		[Test] public void TestFederationPropagationOfContentBaseFederationUpdates()
		{
			AbsoluteTopicName tn = new AbsoluteTopicName("EventTest", _base.Namespace);
			_base.WriteTopic(tn.LocalName, @"Stay1: hello
Stay2: foo
Go1: foo
Go2: foo
Change1: blag
Change2: blag
");

			FederationUpdate expected = new FederationUpdate();
			expected.RecordPropertyChange(tn, "_ModificationTime", FederationUpdate.PropertyChangeType.PropertyUpdate);
			expected.RecordPropertyChange(tn, "_Body", FederationUpdate.PropertyChangeType.PropertyUpdate);
			expected.RecordPropertyChange(tn, "Go1", FederationUpdate.PropertyChangeType.PropertyRemove);
			expected.RecordPropertyChange(tn, "Go2", FederationUpdate.PropertyChangeType.PropertyRemove);
			expected.RecordPropertyChange(tn, "Change1", FederationUpdate.PropertyChangeType.PropertyUpdate);
			expected.RecordPropertyChange(tn, "Change2", FederationUpdate.PropertyChangeType.PropertyUpdate);
			
			StartMonitoringFederationEvents();
			_base.WriteTopic(tn.LocalName, @"Stay1: hello
Stay2: foo
Change1: new value
Change2: new value
");
			StopMonitoringFederationEvents();
			ContentBaseTests.CompareFederationUpdates(expected, _Events, false, true);
		}

		/// <summary>
		/// Adds the elements of an array to the end of this AbsoluteTopicNameCollection.
		/// </summary>
		/// <param name="items">
		/// The array whose elements are to be added to the end of this AbsoluteTopicNameCollection.
		/// </param>
		public virtual void AddRange(AbsoluteTopicName[] items)
		{
			foreach (AbsoluteTopicName item in items)
			{
				this.List.Add(item);
			}
		}

		protected void DoPage()
		{
			LinkMaker lm = TheLinkMaker;

			string body = Request.Form["body"];
			string ns = Request.Form["defaultNamespace"];
			string tn = Request.Form["topic"];

			AbsoluteTopicName topicName = new AbsoluteTopicName(tn, ns);

			Response.Write("<div class='PreviewMain'>");
			Response.Write(Formatter.FormattedString(topicName, body, OutputFormat.HTML, TheFederation.ContentBaseForNamespace(ns), TheLinkMaker, null));
			Response.Write("</div>");
			Response.Write(@"<div id='TopicTip' class='TopicTip' ></div>");
		}

		public AbsoluteTopicName[] GetAllTopics(ContentBase cb)
		{
			Hashtable ns = (Hashtable) namespaces[cb.Namespace]; 
		
			ArrayList atns = new ArrayList(); 

			foreach (string topic in ns.Keys)
			{
				AbsoluteTopicName atn = new AbsoluteTopicName(); 
				atn.Namespace = cb.Namespace; 
				atn.Name = topic; 
				atn.Version = GetLatestVersion((Hashtable) ns[topic]); 
				atns.Add(atn); 
			}

			return (AbsoluteTopicName[]) atns.ToArray(typeof(AbsoluteTopicName)); 
		}

		protected void ShowPage()
		{
			string topicString = Request.QueryString["topic"];
			AbsoluteTopicName topic = new AbsoluteTopicName(topicString);
			Response.Write("<h1>All Versions for " + topic.Fullname + "</h1>");
			
			IEnumerable changeList = TheFederation.GetTopicChanges(topic);

			// Now generate the page!

			bool first = true;
			string mostRecentVersion = null;
			foreach (TopicChange change in changeList)
			{
				if (first)
					mostRecentVersion = change.Version;
				string s = "";
				if (change.Version == topic.Version || (first &&  topic.Version == null))
				{
					s += "&rarr;&nbsp;";
				}
				else
					s += "&nbsp;&nbsp;&nbsp;&nbsp;";
				if (change.Timestamp.Date == DateTime.Now.Date)
					s += change.Timestamp.ToString("HH:mm");
				else
				{
					if (change.Timestamp.Date.Year == DateTime.Now.Date.Year)
						s += change.Timestamp.ToString("MMM d  H:mm");
					else
						s += change.Timestamp.ToString("MMM d yyyy  H:mm");
				}	
				s += "&nbsp;&nbsp;(" + change.Author + ")";	
				AbsoluteTopicName linkTo = change.Topic;
				if (first)
					linkTo.Version = null;	// don't include the version for the latest one
				Response.Write("<li><a href='" + TheLinkMaker.LinkToTopic(linkTo)  + "'>" + s + "</a>");
				first = false;
			}

		}

		/// <summary>
		/// Initializes a new instance of the AbsoluteTopicNameCollection class, containing elements
		/// copied from an array.
		/// </summary>
		/// <param name="items">
		/// The array whose elements are to be added to the new AbsoluteTopicNameCollection.
		/// </param>
		public AbsoluteTopicNameCollection(AbsoluteTopicName[] items)
		{
			this.AddRange(items);
		}

        private void GetVersionsForTopic(AbsoluteTopicName topicName)
        {
            flatComboBoxVersion.Items.Clear();
            buttonItemRestore.Enabled = false;

            string[] versions = editService.GetVersionsForTopic(topicName);

            if (versions.Length > 0)
            {
                foreach (string s in versions)
                {
                    flatComboBoxVersion.Items.Add(s);
                }

                flatComboBoxVersion.SelectedIndex = 0;
            }
        }

 public void RestoreTopic(AbsoluteTopicName topicName, string visitorIdentityString, string version)
 {
     this.Invoke("RestoreTopic", new object[] {
                                          topicName,
                                          visitorIdentityString,
                                          version});
 }

        public void TestTopicUpdateEvent()
        {
            AbsoluteTopicName tn = new AbsoluteTopicName("EventTest", _base.Namespace);

            FederationUpdate expected = new FederationUpdate();
            expected.RecordUpdatedTopic(tn);

            _base.WriteTopic(tn.LocalName, "hello");

            StartMonitoringEvents(_base);
            _base.WriteTopic(tn.LocalName, "second should be an update");
            StopMonitoringEvents(_base);

            CompareFederationUpdates(expected, _Events, true, false);
        }

 public string GetHtmlForTopicVersion(AbsoluteTopicName topicName, string version)
 {
     object[] results = this.Invoke("GetHtmlForTopicVersion", new object[] {
                                                                       topicName,
                                                                       version});
       return ((string)(results[0]));
 }

 public string GetTextForTopic(AbsoluteTopicName topicName)
 {
     object[] results = this.Invoke("GetTextForTopic", new object[] {
                                                                topicName});
       return ((string)(results[0]));
 }

 /// <remarks/>
 public System.IAsyncResult BeginRestoreTopic(AbsoluteTopicName topicName, string visitorIdentityString, string version, System.AsyncCallback callback, object asyncState)
 {
     return this.BeginInvoke("RestoreTopic", new object[] {
                                                      topicName,
                                                      visitorIdentityString,
                                                      version}, callback, asyncState);
 }

 /// <remarks/>
 public System.IAsyncResult BeginGetPreviewForTopic(AbsoluteTopicName topicName, string textToFormat, System.AsyncCallback callback, object asyncState)
 {
     return this.BeginInvoke("GetPreviewForTopic", new object[] {
                                                            topicName,
                                                            textToFormat}, callback, asyncState);
 }

		/// <summary>
		/// Adds an instance of type AbsoluteTopicName to the end of this AbsoluteTopicNameCollection.
		/// </summary>
		/// <param name="value">
		/// The AbsoluteTopicName to be added to the end of this AbsoluteTopicNameCollection.
		/// </param>
		public virtual void Add(AbsoluteTopicName value)
		{
			this.List.Add(value);
		}

 static void ComparePropertyUpdatesForVerb(AbsoluteTopicName t, IList expectedProperties, IList gotProperties, string verb)
 {
     foreach (string propertyName in expectedProperties)
     {
         bool found = gotProperties.Contains(propertyName);
         if (!found)
             System.Diagnostics.Debug.WriteLine("ACK!");
         Assert.IsTrue(found, "Missing " + verb + " property (" + propertyName + " in " + t.FullnameWithVersion + ") from fired event(s)");
         gotProperties.Remove(propertyName);
     }
     if (gotProperties.Count == 0)
         return;	// good -- there should be none left
     string s = "";
     foreach (string p in gotProperties)
     {
         if (s != "")
             s += ", ";
         s += p;
     }
     Assert.Fail("Unexpected " + verb + " property notifications for: " + s);
 }

        public void TestTopicUpdateWhenAuthorChanges()
        {
            AbsoluteTopicName tn = new AbsoluteTopicName("AuthorEventTest", _base.Namespace);

            FederationUpdate expected = new FederationUpdate();
            expected.RecordPropertyChange(tn, "_LastModifiedBy", FederationUpdate.PropertyChangeType.PropertyUpdate);
            expected.RecordPropertyChange(tn, "_Body", FederationUpdate.PropertyChangeType.PropertyUpdate);
            expected.RecordPropertyChange(tn, "_ModificationTime", FederationUpdate.PropertyChangeType.PropertyUpdate);

            WriteTestTopicAndNewVersion(_base, tn.Name, "this is the original text", "pre modern man");

            StartMonitoringEvents(_base);
            AbsoluteTopicName versioned = WriteTestTopicAndNewVersion(_base, tn.Name, "this is a change", "post modern man");
            StopMonitoringEvents(_base);

            expected.RecordPropertyChange(versioned, "_LastModifiedBy", FederationUpdate.PropertyChangeType.PropertyAdd);
            expected.RecordPropertyChange(versioned, "_Body", FederationUpdate.PropertyChangeType.PropertyAdd);
            expected.RecordPropertyChange(versioned, "_ModificationTime", FederationUpdate.PropertyChangeType.PropertyAdd);
            expected.RecordPropertyChange(versioned, "_TopicName", FederationUpdate.PropertyChangeType.PropertyAdd);
            expected.RecordPropertyChange(versioned, "_TopicFullName", FederationUpdate.PropertyChangeType.PropertyAdd);
            expected.RecordPropertyChange(versioned, "_CreationTime", FederationUpdate.PropertyChangeType.PropertyAdd);

            CompareFederationUpdates(expected, _Events, false, true);
        }

 /// <remarks/>
 public System.IAsyncResult BeginGetHtmlForTopicVersion(AbsoluteTopicName topicName, string version, System.AsyncCallback callback, object asyncState)
 {
     return this.BeginInvoke("GetHtmlForTopicVersion", new object[] {
                                                                topicName,
                                                                version}, callback, asyncState);
 }

        private void htmlEditor1_BeforeNavigate(object s, onlyconnect.BeforeNavigateEventArgs e)
        {
            Console.WriteLine(e.NewTarget);

            string[] splitUrl = e.Target.Split('/');
            string fullName = splitUrl[splitUrl.Length-1];
            string[] split = fullName.Split('.');

            if (split.Length == 2)
            {
                AbsoluteTopicName currentTopicName = new AbsoluteTopicName();
                currentTopicName.Fullname = fullName;

                currentTopicName.Namespace = split[0];
                currentTopicName.Name = split[1];

                if (currentTopicName.Namespace == currentContentBase.Namespace)
                {
                    foreach (ListViewItem lvi in listViewTopicNames.Items)
                    {
                        AbsoluteTopicName topicName = (AbsoluteTopicName)lvi.Tag;
                        if (currentTopicName.Name  == topicName.Name)
                        {
                            lvi.Selected = true;
                            e.Cancel = true;
                            break;
                        }
                    }
                }
                else
                {
                    foreach(ContentBase cb in contentBases)
                    {
                        if (cb.Namespace == currentTopicName.Namespace )
                        {
                            comboBoxContentBase.SelectedValue = currentTopicName.Namespace;

                            foreach (ListViewItem lvi in listViewTopicNames.Items)
                            {
                                AbsoluteTopicName topicName = (AbsoluteTopicName)lvi.Tag;
                                if (currentTopicName.Name  == topicName.Name)
                                {
                                    lvi.Selected = true;
                                    e.Cancel = true;
                                    break;
                                }
                            }
                        }
                    }
                }
            }
        }