Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

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
}
}