428 lines
14 KiB
C#
428 lines
14 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="SiteMapDataSource.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Web.UI.WebControls {
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Drawing.Design;
|
|
using System.Web;
|
|
using System.Web.UI;
|
|
using System.Web.Util;
|
|
|
|
[
|
|
Designer("System.Web.UI.Design.WebControls.SiteMapDataSourceDesigner, " + AssemblyRef.SystemDesign),
|
|
ParseChildren(true),
|
|
PersistChildren(false),
|
|
ToolboxBitmap(typeof(SiteMapDataSource)),
|
|
WebSysDescription(SR.SiteMapDataSource_Description),
|
|
WebSysDisplayName(SR.SiteMapDataSource_DisplayName)
|
|
]
|
|
|
|
public class SiteMapDataSource : HierarchicalDataSourceControl, IDataSource, IListSource {
|
|
private const string DefaultViewName = "DefaultView";
|
|
private ICollection _viewNames;
|
|
private SiteMapDataSourceView _dataSourceView;
|
|
private SiteMapProvider _provider;
|
|
|
|
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
WebSysDescription(SR.SiteMapDataSource_ContainsListCollection)
|
|
]
|
|
public virtual bool ContainsListCollection {
|
|
get {
|
|
return ListSourceHelper.ContainsListCollection(this);
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para></para>
|
|
/// </devdoc>
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
WebSysDescription(SR.SiteMapDataSource_Provider)
|
|
]
|
|
public SiteMapProvider Provider {
|
|
get {
|
|
if (_provider != null)
|
|
return _provider;
|
|
|
|
// If not specified, use the default provider.
|
|
if (String.IsNullOrEmpty(SiteMapProvider)) {
|
|
_provider = SiteMap.Provider;
|
|
|
|
if (_provider == null) {
|
|
throw new HttpException(SR.GetString(SR.SiteMapDataSource_DefaultProviderNotFound));
|
|
}
|
|
}
|
|
else {
|
|
_provider = SiteMap.Providers[SiteMapProvider];
|
|
|
|
if (_provider == null) {
|
|
throw new HttpException(SR.GetString(SR.SiteMapDataSource_ProviderNotFound, SiteMapProvider));
|
|
}
|
|
}
|
|
|
|
return _provider;
|
|
}
|
|
set {
|
|
if (_provider != value) {
|
|
_provider = value;
|
|
OnDataSourceChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Indicates whether the starting node should be displayed.</para>
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(true),
|
|
WebCategory("Behavior"),
|
|
WebSysDescription(SR.SiteMapDataSource_ShowStartingNode)
|
|
]
|
|
public virtual bool ShowStartingNode {
|
|
get {
|
|
object o = ViewState["ShowStartingNode"];
|
|
return (o == null) ? true : (bool)o;
|
|
}
|
|
set {
|
|
if (value != ShowStartingNode) {
|
|
ViewState["ShowStartingNode"] = value;
|
|
OnDataSourceChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Indicates the name of the SiteMapProvider used to populate the datasource control.</para>
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(""),
|
|
WebCategory("Behavior"),
|
|
WebSysDescription(SR.SiteMapDataSource_SiteMapProvider)
|
|
]
|
|
public virtual string SiteMapProvider {
|
|
get {
|
|
string provider = ViewState["SiteMapProvider"] as string;
|
|
return (provider == null) ? String.Empty : provider;
|
|
}
|
|
set {
|
|
if (value != SiteMapProvider) {
|
|
_provider = null;
|
|
ViewState["SiteMapProvider"] = value;
|
|
OnDataSourceChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Indicates the starting node offset used to populate the datasource control.</para>
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(0),
|
|
WebCategory("Behavior"),
|
|
WebSysDescription(SR.SiteMapDataSource_StartingNodeOffset)
|
|
]
|
|
public virtual int StartingNodeOffset {
|
|
get{
|
|
object o = ViewState["StartingNodeOffset"];
|
|
if (o == null) {
|
|
return 0;
|
|
}
|
|
return (int)o;
|
|
}
|
|
set {
|
|
if (value != StartingNodeOffset) {
|
|
ViewState["StartingNodeOffset"] = value;
|
|
OnDataSourceChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para></para>
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(false),
|
|
WebCategory("Behavior"),
|
|
WebSysDescription(SR.SiteMapDataSource_StartFromCurrentNode)
|
|
]
|
|
public virtual bool StartFromCurrentNode {
|
|
get {
|
|
object o = ViewState["StartFromCurrentNode "];
|
|
return (o == null) ? false : (bool)o;
|
|
}
|
|
set {
|
|
if (value != StartFromCurrentNode) {
|
|
ViewState["StartFromCurrentNode "] = value;
|
|
OnDataSourceChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Indicates the starting node url used to populate the datasource control.</para>
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(""),
|
|
Editor("System.Web.UI.Design.UrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
|
|
UrlProperty(),
|
|
WebCategory("Behavior"),
|
|
WebSysDescription(SR.SiteMapDataSource_StartingNodeUrl)
|
|
]
|
|
public virtual string StartingNodeUrl {
|
|
get {
|
|
string startingNodeUrl = ViewState["StartingNodeUrl"] as string;
|
|
return (startingNodeUrl == null) ? String.Empty : startingNodeUrl;
|
|
}
|
|
set {
|
|
if (value != StartingNodeUrl) {
|
|
ViewState["StartingNodeUrl"] = value;
|
|
OnDataSourceChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Helper method to return the nodes.
|
|
private SiteMapNodeCollection GetNodes() {
|
|
SiteMapNode node = null;
|
|
int startingNodeOffset = StartingNodeOffset;
|
|
|
|
if (!String.IsNullOrEmpty(StartingNodeUrl) && StartFromCurrentNode) {
|
|
throw new InvalidOperationException(SR.GetString(SR.SiteMapDataSource_StartingNodeUrlAndStartFromcurrentNode_Defined));
|
|
}
|
|
|
|
if (StartFromCurrentNode) {
|
|
node = Provider.CurrentNode;
|
|
}
|
|
else if (!String.IsNullOrEmpty(StartingNodeUrl)) {
|
|
node = Provider.FindSiteMapNode(MakeUrlAbsolute(StartingNodeUrl));
|
|
if (node == null) {
|
|
throw new ArgumentException(SR.GetString(SR.SiteMapPath_CannotFindUrl, StartingNodeUrl));
|
|
}
|
|
}
|
|
else {
|
|
node = Provider.RootNode;
|
|
}
|
|
|
|
if (node == null) {
|
|
return null;
|
|
}
|
|
|
|
if (startingNodeOffset <= 0) {
|
|
if (startingNodeOffset != 0) {
|
|
// Hind neighborhood nodes based on startingNodeOffset
|
|
Provider.HintNeighborhoodNodes(node, Math.Abs(startingNodeOffset), 0);
|
|
|
|
SiteMapNode parentNode = node.ParentNode;
|
|
while (startingNodeOffset < 0 && parentNode != null) {
|
|
node = node.ParentNode;
|
|
parentNode = node.ParentNode;
|
|
startingNodeOffset++;
|
|
}
|
|
}
|
|
|
|
return GetNodes(node);
|
|
}
|
|
|
|
// else if (startingNodeOffset > 0)
|
|
SiteMapNode currentNode = Provider.GetCurrentNodeAndHintAncestorNodes(-1);
|
|
|
|
// If the current node is not in StartingNode's subtree, return null.
|
|
if (currentNode == null || !currentNode.IsDescendantOf(node) || currentNode.Equals(node)) {
|
|
return null;
|
|
}
|
|
|
|
SiteMapNode leadingNode = currentNode;
|
|
|
|
// Create a gap of n levels between the following and the leading nodes.
|
|
for (int i = 0; i < startingNodeOffset; i++) {
|
|
leadingNode = leadingNode.ParentNode;
|
|
|
|
// If the current node is within n levels below the starting node,
|
|
// use the current node.
|
|
if (leadingNode == null || leadingNode.Equals(node)) {
|
|
return GetNodes(currentNode);
|
|
}
|
|
}
|
|
|
|
SiteMapNode followingNode = currentNode;
|
|
while (leadingNode != null && !leadingNode.Equals(node)) {
|
|
followingNode = followingNode.ParentNode;
|
|
leadingNode = leadingNode.ParentNode;
|
|
}
|
|
|
|
return GetNodes(followingNode);
|
|
}
|
|
|
|
private SiteMapNodeCollection GetNodes(SiteMapNode node) {
|
|
if (ShowStartingNode) {
|
|
return new SiteMapNodeCollection(node);
|
|
}
|
|
|
|
return node.ChildNodes;
|
|
}
|
|
|
|
|
|
protected override HierarchicalDataSourceView GetHierarchicalView(string viewPath) {
|
|
|
|
if (Provider == null)
|
|
throw new HttpException(SR.GetString(SR.SiteMapDataSource_ProviderNotFound, SiteMapProvider));
|
|
|
|
return GetTreeView(viewPath);
|
|
}
|
|
|
|
|
|
public virtual IList GetList() {
|
|
return ListSourceHelper.GetList(this);
|
|
}
|
|
|
|
// Helper method to get the non-hierarhical path view. ie. from BaseNode to currentNode.
|
|
// if currentNode is not in the subtree rooted at basenode, returns empty collection.
|
|
internal SiteMapNodeCollection GetPathNodeCollection(string viewPath) {
|
|
|
|
SiteMapNodeCollection collection = null;
|
|
|
|
if (String.IsNullOrEmpty(viewPath)) {
|
|
collection = GetNodes();
|
|
}
|
|
else {
|
|
// Otherwise, return the child nodes specified by the key (viewPath)
|
|
SiteMapNode node = Provider.FindSiteMapNodeFromKey(viewPath);
|
|
if (node != null) {
|
|
collection = node.ChildNodes;
|
|
}
|
|
}
|
|
|
|
if (collection == null) {
|
|
collection = SiteMapNodeCollection.Empty;
|
|
}
|
|
|
|
return collection;
|
|
}
|
|
|
|
private HierarchicalDataSourceView GetTreeView(string viewPath) {
|
|
|
|
SiteMapNode node = null;
|
|
|
|
// When querying for the whole view, returns the view starting from the designated node.
|
|
if (String.IsNullOrEmpty(viewPath)) {
|
|
SiteMapNodeCollection nodes = GetNodes();
|
|
if (nodes != null) {
|
|
return nodes.GetHierarchicalDataSourceView();
|
|
}
|
|
}
|
|
// Otherwise, return the child nodes specified by the key (viewPath)
|
|
else {
|
|
node = Provider.FindSiteMapNodeFromKey(viewPath);
|
|
if (node != null)
|
|
return node.ChildNodes.GetHierarchicalDataSourceView();
|
|
}
|
|
|
|
// return the view of an empty readonly collection
|
|
return SiteMapNodeCollection.Empty.GetHierarchicalDataSourceView();
|
|
}
|
|
|
|
|
|
public virtual DataSourceView GetView(string viewName) {
|
|
if (Provider == null)
|
|
throw new HttpException(SR.GetString(SR.SiteMapDataSource_ProviderNotFound, SiteMapProvider));
|
|
|
|
if (_dataSourceView == null) {
|
|
_dataSourceView = SiteMapNodeCollection.ReadOnly(GetPathNodeCollection(viewName)).GetDataSourceView(this, String.Empty);
|
|
|
|
}
|
|
|
|
return _dataSourceView;
|
|
}
|
|
|
|
|
|
public virtual ICollection GetViewNames() {
|
|
if (_viewNames == null) {
|
|
_viewNames = new string[1] { DefaultViewName };
|
|
}
|
|
return _viewNames;
|
|
}
|
|
|
|
private string MakeUrlAbsolute(string url) {
|
|
// check if its empty or already absolute
|
|
if (url.Length == 0 || !UrlPath.IsRelativeUrl(url)) {
|
|
return url;
|
|
}
|
|
|
|
string baseUrl = AppRelativeTemplateSourceDirectory;
|
|
if (baseUrl.Length == 0) {
|
|
return url;
|
|
}
|
|
|
|
// Make it absolute
|
|
return UrlPath.Combine(baseUrl, url);
|
|
}
|
|
|
|
#region IDataSource implementations
|
|
/// <summary>
|
|
/// Raised when the underlying data source has changed. The
|
|
/// change may be due to a change in the control's properties,
|
|
/// or a change in the data due to an edit action performed by
|
|
/// the DataSourceControl.
|
|
/// </summary>
|
|
event EventHandler IDataSource.DataSourceChanged {
|
|
add {
|
|
((IHierarchicalDataSource)this).DataSourceChanged += value;
|
|
}
|
|
remove {
|
|
((IHierarchicalDataSource)this).DataSourceChanged -= value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <internalonly/>
|
|
DataSourceView IDataSource.GetView(string viewName) {
|
|
return GetView(viewName);
|
|
}
|
|
|
|
|
|
/// <internalonly/>
|
|
ICollection IDataSource.GetViewNames() {
|
|
return GetViewNames();
|
|
}
|
|
#endregion
|
|
|
|
#region Implementation of IListSource
|
|
|
|
/// <internalonly/>
|
|
bool IListSource.ContainsListCollection {
|
|
get {
|
|
if (DesignMode) {
|
|
return false;
|
|
}
|
|
return ContainsListCollection;
|
|
}
|
|
}
|
|
|
|
|
|
/// <internalonly/>
|
|
IList IListSource.GetList() {
|
|
if (DesignMode) {
|
|
return null;
|
|
}
|
|
return GetList();
|
|
}
|
|
#endregion
|
|
}
|
|
}
|