public bool FindItem(Type type, out INavigationItem foundItem)
{
// try to find category or page by found values
INavigationItem resItem = null;
foreach (INavigationItem item in _children)
{
if (item.Type == NavigationItemType.Category)
{
item.FindItem(type, out resItem); // NOTE: ignore result
}
else if (item.Type == NavigationItemType.Page)
{
if (((PageItem)item).PageType == type)
{
resItem = item;
}
}
else
{
throw new NotSupportedException();
}
if (null != resItem)
{
break;
}
}
foundItem = resItem;
return(null != foundItem);
}
public HypothesisTestingManagerViewModel(INavigation navigation)
: base(navigation, "Проверка гипотез")
{
var tTypeDistrVm = new TTypeDistributionViewModel();
navigation.Add(() => new TTypeDistributionView(tTypeDistrVm));
_pagesViewModels = new IPageViewModel[]
{
tTypeDistrVm
};
_navigationItems = new INavigationItem[]
{
new NavigationItem(tTypeDistrVm.Title, typeof(TTypeDistributionView), MaterialDesignThemes.Wpf.PackIconKind.FormatListChecks)
};
_informationItems = new IInformationItem[]
{
new InformationItem("Статистическая гипотеза", "Это определённое предположение о свойствах случайных величин на основе наблюдаемой выборки данных."),
new InformationItem("Проверка статистической гипотезы", "Это процесс принятия решения о том, противоречит ли рассматриваемая статистическая гипотеза наблюдаемой выборке данных."),
new InformationItem("Этапы проверки статистической гипотезы", "1. Формулировка нулевой и альтернативной гипотез.\n2. Выбор соответствующего статистического теста.\n3. Выбор требуемого уровня значимости (α = 0.05, 0.01, 0.025, …).\n4. Вычисление статистики критерия по тесту.\n5. Сравнение эмпирического значения критерия с критическим значением по тесту.\n6. Принятие решения: если вычисленное значение больше, чем критическое, то нулевая гипотеза отклоняется.")
};
_informationLinks = new ILink[]
{
new Link("Википедия", "https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D0%B2%D0%B5%D1%80%D0%BA%D0%B0_%D1%81%D1%82%D0%B0%D1%82%D0%B8%D1%81%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D1%85_%D0%B3%D0%B8%D0%BF%D0%BE%D1%82%D0%B5%D0%B7", MaterialDesignThemes.Wpf.PackIconKind.Wikipedia)
};
}
private void AddNavigationItemPair(INavigationItem bigButton, INavigationItem smallButton)
{
bigButton.PairedItem = smallButton;
smallButton.PairedItem = bigButton;
bigButton.NavigationViewChanged += NavigationViewChanged;
smallButton.NavigationViewChanged += NavigationViewChanged;
}
protected virtual void InitItems(IList values)
{
if (m_navigationItemsControl != null)
{
IList <INavigationItem> navigationItems = new List <INavigationItem>();
if (values != null)
{
foreach (object item in values)
{
if (item is INavigationItem navigationItem)
{
navigationItems.Add(navigationItem);
}
}
}
m_navigationItemsControl.ItemsSource = navigationItems;
INavigationItem selectedItem = navigationItems.FirstOrDefault(item => item.IsSelected);
if (selectedItem != null)
{
if (SelectedItem != selectedItem)
{
SelectedItem = selectedItem;
}
}
else
{
SelectedItem = null;
}
}
}
private static void Navigate(
INavigationItem navigationItem,
ExistingViewBehavior existingViewBehavior,
EventHandler callBack,
params object[] parameters
)
{
if (parameters.Length > 0)
{
}
var viewModel = Container.ResolveViewModel(navigationItem.ViewModelType);
var view = Container.ResolveView(navigationItem.ViewType);
var grid = FindGrid(_shell, navigationItem.RegionName);
SetAppBar(viewModel);
if (existingViewBehavior == ExistingViewBehavior.Remove)
{
grid.Children.Clear();
}
else
{
foreach (var child in grid.Children)
{
child.Visibility = Visibility.Collapsed;
}
}
if (callBack != null)
{
callBack(null, EventArgs.Empty);
}
grid.Children.Add((UIElement)view);
viewModel.Initialize(parameters);
view.DataContext = viewModel;
}
public MainViewModel(INavigation navigation, string title)
: base(navigation, title)
{
var homeVm = new HomeViewModel();
Navigation.Add(() => new Home(homeVm));
var statsAnalysisVm = new StatsAnalysisManagerViewModel(Navigation);
Navigation.Add(() => new StatsAnalysis(statsAnalysisVm));
_pagesViewModels = new IPageViewModel[]
{
homeVm, statsAnalysisVm
};
_navigationItems = new INavigationItem[]
{
new NavigationItem(homeVm.Title, typeof(Home), PackIconKind.Home),
new NavigationItem(statsAnalysisVm.Title, typeof(StatsAnalysis), PackIconKind.ChartBar)
};
Links = new ILink[]
{
new Link("GitHub", "https://github.com/holydk/StatisticalAnalysis", PackIconKind.GithubCircle, "Исходный код")
};
}
public void RemoveChild(INavigationItem item)
{
if (!_children.Remove(item))
{
throw new KeyNotFoundException();
}
}
public void Push (INavigationItem item)
{
var load = SetParent(item.Content);
Handler.Push (item);
if (load)
item.Content.OnLoadComplete (EventArgs.Empty);
}
private void ActiveNodeChanging(object sender, ActiveNodeChangingEventArgs e)
{
_selectedItem = e.NewActiveTreeNode.Data as INavigationItem;
if (_selectedItem != null && !_selectedItem.CanNavigate)
{
e.Cancel = true;
}
}
/// <summary>
/// Creates a new <see cref="WillSelectNavigationItemEventArgs" />.
/// </summary>
/// <param name="routedEvent"></param>
/// <param name="source">The source object</param>
/// <param name="currentNavigationItem">The current item before the selection</param>
/// <param name="navigationToSelect">The item to be selected</param>
public WillSelectNavigationItemEventArgs(RoutedEvent routedEvent, object source, INavigationItem currentNavigationItem, INavigationItem navigationToSelect)
: base(routedEvent, source)
{
CurrentNavigationItem = currentNavigationItem;
NavigationItemToSelect = navigationToSelect;
Cancel = false;
}
public NavigationItem(INavigationItem navigationItem)
{
Model = navigationItem ?? throw new ArgumentNullException(nameof(navigationItem));
Model.ObservePropertyChange(x => x.IsActive).Subscribe(x => IsActive = x);
SubItems.CollectionChanged += SubItems_CollectionChanged;
}
protected override IList <INavigationItemId> GetSelectedPath(INavigationItem rootItem, INavigationItem currentItem)
{
return(new[] {
this.fakes.Root.Id,
this.fakes.SecondChildOfRoot.Id,
this.fakes.SecondChildOfSecondChildOfRoot.Id
});
}
private bool IsLocalDatasourceFolderItem(INavigationItem item)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
return(item.TemplateId.Equals(ID.Parse(Sample.Foundation.LocalDatasource.Settings.LocalDatasourceFolderTemplate)));
}
public void Push(INavigationItem item)
{
var view = item.Content.GetViewController();
view.NavigationItem.Title = item.Text;
view.View.Frame = Control.Frame;
view.View.AutoresizingMask = UIViewAutoresizing.FlexibleDimensions;
Navigation.PushViewController(view, true);
}
public static void NavigateTo(this NavigationService navService, INavigationItem navItem)
{
if (navItem == null)
{
return;
}
navService.NavigateTo(navItem.NavigationUrl);
}
public async Task HandleAsync(INavigationItem navigationItem, CancellationToken cancellationToken)
{
var screen = this.container.GetExports <IScreen>(navigationItem.ItemName).FirstOrDefault();
if (screen != null)
{
this.ActivateItem(screen.Value);
}
}
public NavigationAccordionViewModel(ObservableCollection <INavigationItem> inNavItems)
{
NavigationItems = inNavItems;
foreach (NavigationItem ni in NavigationItems)
{
ni.NAVM = this;
}
SelectedNavItem = null;
}
public void Handle(INavigationItem navigationItem)
{
var screen = this.container.GetExports <IScreen>(navigationItem.ItemName).FirstOrDefault();
if (screen != null)
{
this.ActivateItem(screen.Value);
}
}
public void Push(INavigationItem item)
{
var view = item.Content.GetViewController();
if (item.Text != null)
{
view.NavigationItem.Title = item.Text;
}
Navigation.PushViewController(view, true);
}
/// <inheritdoc />
public void AddNavigationItem(INavigationItem navigationItem)
{
NavigationItems.Add(navigationItem);
if (!navigationItem.DestinationResolved)
{
navigationItem.SetDestination((IPresentable)_vmManager.CreateViewModel(navigationItem.DestinationType, null));
}
navigationItem.NavigationRequested += NavigationItem_NavigationRequested;
navigationItem.Initialize();
}
public void Push(INavigationItem item)
{
var load = SetParent(item.Content);
Handler.Push(item);
if (load)
{
item.Content.OnLoadComplete(EventArgs.Empty);
}
}
protected override void OnCreate(ao.Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
var key = Intent.GetStringExtra("item");
content = NavigationHandler.GetItem(key);
if (content != null && content.Content != null)
{
SetContentView(content.Content.GetContainerView());
}
}
private void SelectNavigationItem(INavigationItem navigationItem)
{
if (navigationItem != null)
{
contentControl.Content = navigationItem.NavigationItemSelectedCallback(navigationItem);
}
else
{
contentControl.Content = null;
}
}
public virtual void Push (INavigationItem item)
{
var loaded = item.Content.Loaded;
SetParent(item.Content);
if (!loaded) {
item.Content.OnPreLoad (EventArgs.Empty);
item.Content.OnLoad (EventArgs.Empty);
}
Handler.Push (item);
if (!loaded)
item.Content.OnLoadComplete (EventArgs.Empty);
}
public void Execute(object parameter)
{
try
{
DataObject obj = DataObjectHelper.GetPrescribedObject(_type, _id);
if (null != obj)
{
INavigationItem item = null;
if (App.Current.MainWindow.NavigationTree.FindItem(_navigateLink, out item))
{
if ((item as PageItem).Page != App.Current.MainWindow.CurrentPage)
{
App.Current.MainWindow.Navigate(_navigateLink);
}
Page pageBase = App.Current.MainWindow.CurrentPage;
ISupportDataObjectEditing objectEditing = _GetDataObjectEditing(obj, pageBase);
ISupportSelection selection = _GetSelection(obj, pageBase);
bool isEditingInProgress = false;
if (null != objectEditing)
{
isEditingInProgress = objectEditing.IsEditingInProgress;
}
if (null != selection)
{
// if any object is editing - try to save changed
if (isEditingInProgress)
{
isEditingInProgress = !selection.SaveEditedItem();
}
// if grid isn't editing or changes saved successfully - select items
if (!isEditingInProgress)
{
selection.Select(new Collection <DataObject>()
{
obj
});
}
}
}
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
public void Push(INavigationItem item)
{
items.Add(item);
var view = item.Content.GetViewController();
view.NavigationItem.Title = item.Text ?? string.Empty;
if (!(view.View is UIScrollView) && view.EdgesForExtendedLayoutIsSupported())
{
view.EdgesForExtendedLayout = UIRectEdge.None;
}
view.View.Frame = new System.Drawing.RectangleF(0, 0, 0, 0);
view.View.AutoresizingMask = UIViewAutoresizing.FlexibleDimensions;
Navigation.PushViewController(view, true);
}
public void Push(INavigationItem item)
{
items.Add(item);
var view = item.Content.GetViewController();
view.NavigationItem.Title = item.Text;
view.View.SetFrameOrigin(new System.Drawing.PointF(0, 100));
//view.AutomaticallyAdjustsScrollViewInsets = true;
//if (view.RespondsToSelector(new Selector("setEdgesForExtendedLayout:")))
// view.EdgesForExtendedLayout = UIRectEdge.None;
view.View.Frame = new System.Drawing.RectangleF(0, 0, 0, 0);
view.View.AutoresizingMask = UIViewAutoresizing.All;
Navigation.PushViewController(view, true);
}
public static MvcHtmlString ActionLink(this HtmlHelper htmlHelper, INavigationItem navigationItem)
{
var cssClasses = navigationItem.CssClasses.ToList();
if(navigationItem.IsActive) cssClasses.Add("active");
return htmlHelper.ActionLink(
navigationItem.Name,
navigationItem.Target.Action,
navigationItem.Target.Controller,
null,
new
{
@class = string.Join(" ", cssClasses.Distinct())
});
}
public virtual IList <INavigationItem> GetItems(INavigationItem root, INavigationItem current, INavigationConfig config)
{
this.rootItem = root;
this.currentItem = current;
this.configuration = config ?? new DefaultConfiguration();
var items = new List <INavigationItem>();
if (root != null)
{
items.Add(root);
items = GetItems(items, 0);
}
return(items);
}
public IEnumerable <INavigationItem> GetNavigationItems(INavigationItem startItem, int depthLevel, int maxDepthLevel)
{
if (startItem == null || depthLevel > maxDepthLevel || startItem.Children.Count() == 0)
{
return(null);
}
var childItems = startItem.Children.Where(x => !IsLocalDatasourceFolderItem(x)).Select(x => x);
if (childItems != null)
{
return(childItems);
}
return(null);
}
private void SelectNavigationItem(INavigationItem navigationItem)
{
if (navigationItem != null)
{
contentControl.Content = navigationItem.NavigationItemSelectedCallback(navigationItem);
}
else
{
contentControl.Content = null;
}
if (appBar != null)
{
appBar.IsNavigationDrawerOpen = false;
}
}
private void NavigationItem_NavigationRequested(object sender, IPresentable e)
{
var nav = sender as INavigationItem;
foreach (var navigationItem in NavigationItems)
{
navigationItem.IsSelected = false;
}
Navigated?.Invoke(this, new NavigationEventArgs {
OldLocation = _currentNavligationItem, NewLocation = nav
});
_navigationRegion.View(e);
_currentNavligationItem = nav;
ShowTitles = false;
nav.IsSelected = true;
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
private void _AddExtensionWidgets()
{
if (_isExtensionWidgetsLoaded)
{
return; // only once
}
Debug.Assert(_app != null); // Initialize first
try
{
// add extension widgets
NavigationTree navigationTree = _app.MainWindow.NavigationTree;
ICollection <ExtensionWidget> extWidgets = _app.ExtensionWidgets;
if ((null != extWidgets) && (0 < extWidgets.Count))
{
// find page
INavigationItem item = null;
if (navigationTree.FindItem(((object)this).GetType(), out item))
{
// build page path
var pagePath = string.Format(@"{0}\{1}", item.Parent.Name, this.Name);
foreach (ExtensionWidget widget in extWidgets)
{
if (pagePath.Equals(widget.PagePath,
StringComparison.OrdinalIgnoreCase))
{
// create widget
Assembly widgetAssembly =
Assembly.LoadFrom(widget.AssemblyPath);
var pageWidget =
(PageWidget)Activator.CreateInstance(widget.ClassType);
pageWidget.Initialize(this);
_widgets.Add(pageWidget);
}
}
}
}
_isExtensionWidgetsLoaded = true;
}
catch (Exception ex)
{
Logger.Error(ex);
}
}
public bool IsAccessibleToUser(RequestContext requestContext, INavigationItem navigationItem)
{
Guard.IsNotNull(requestContext, "requestContext");
Guard.IsNotNull(navigationItem, "navigationItem");
bool isAllowed = true;
if (!string.IsNullOrEmpty(navigationItem.RouteName))
{
isAllowed = controllerAuthorization.IsAccessibleToUser(requestContext, navigationItem.RouteName);
}
else if (!string.IsNullOrEmpty(navigationItem.ControllerName) && !string.IsNullOrEmpty(navigationItem.ActionName))
{
isAllowed = controllerAuthorization.IsAccessibleToUser(requestContext, navigationItem.ControllerName, navigationItem.RouteName);
}
else if (!string.IsNullOrEmpty(navigationItem.Url))
{
isAllowed = urlAuthorization.IsAccessibleToUser(requestContext, navigationItem.Url);
}
return isAllowed;
}
public string Generate(RequestContext requestContext, INavigationItem navigationItem)
{
Guard.IsNotNull(requestContext, "requestContext");
Guard.IsNotNull(navigationItem, "navigationItem");
UrlHelper urlHelper = new UrlHelper(requestContext);
Func<RouteValueDictionary> getRouteValues = () =>
{
RouteValueDictionary routeValues = new RouteValueDictionary();
if (!navigationItem.RouteValues.IsNullOrEmpty())
{
routeValues.Merge(navigationItem.RouteValues);
}
return routeValues;
};
string generatedUrl = null;
if (!string.IsNullOrEmpty(navigationItem.RouteName))
{
generatedUrl = urlHelper.RouteUrl(navigationItem.RouteName, getRouteValues());
}
else if (!string.IsNullOrEmpty(navigationItem.ControllerName) && !string.IsNullOrEmpty(navigationItem.ActionName))
{
generatedUrl = urlHelper.Action(navigationItem.ActionName, navigationItem.ControllerName, getRouteValues());
}
else if (!string.IsNullOrEmpty(navigationItem.Url))
{
generatedUrl = navigationItem.Url.StartsWith("~/", StringComparison.Ordinal) ?
urlHelper.Content(navigationItem.Url) :
navigationItem.Url;
}
return generatedUrl;
}
public void RemoveChild(INavigationItem item)
{
if (!_children.Remove(item))
throw new KeyNotFoundException();
}
public bool FindItem(Type type, out INavigationItem foundItem)
{
throw new NotSupportedException();
}
public bool FindItem(string path, out INavigationItem foundItem)
{
if (path == string.Empty)
{
foundItem = null;
return false;
}
// split path to the first category and remaining path
int delimPos = path.IndexOf(ITEM_DELIMITER);
string categoryName = string.Empty;
string remainPath = string.Empty;
if (delimPos != -1)
{
categoryName = path.Substring(0, delimPos);
remainPath = path.Substring(delimPos + 1);
}
else
remainPath = path;
bool isNeedPage = (categoryName == string.Empty);
// try to find category or page by found values
bool isFound = false;
INavigationItem resItem = null;
foreach (INavigationItem item in _children)
{
if (item.Type == NavigationItemType.Category)
{
if (isNeedPage)
continue; // skip categories: we searching page
if (item.Name.Equals(categoryName, StringComparison.OrdinalIgnoreCase))
{
isFound = item.FindItem(remainPath, out resItem);
break;
}
}
else if (item.Type == NavigationItemType.Page)
{
if (isNeedPage && item.Name.Equals(remainPath, StringComparison.OrdinalIgnoreCase))
{
isFound = true;
resItem = item;
break;
}
}
else
throw new NotSupportedException();
}
foundItem = resItem;
return isFound;
}
public bool FindItem(Type type, out INavigationItem foundItem)
{
// try to find category or page by found values
INavigationItem resItem = null;
foreach (INavigationItem item in _children)
{
if (item.Type == NavigationItemType.Category)
item.FindItem(type, out resItem); // NOTE: ignore result
else if (item.Type == NavigationItemType.Page)
{
if (((PageItem)item).PageType == type)
resItem = item;
}
else
throw new NotSupportedException();
if (null != resItem)
break;
}
foundItem = resItem;
return (null != foundItem);
}
/// <summary>
/// Finds item by type.
/// </summary>
/// <param name="type">See INavigationItem.FindItem method description.</param>
/// <param name="foundItem">See INavigationItem.FindItem method description.</param>
/// <returns></returns>
public bool FindItem(Type type, out INavigationItem foundItem)
{
return _navigationTree.FindItem(type, out foundItem);
}
public void AddChild(INavigationItem item)
{
_children.Add(item);
item.Parent = this;
}
/// <summary>
/// Pushes a new navigation item onto the stack.
/// </summary>
/// <param name="item">Item to push onto the navigation stack.</param>
public void Push(INavigationItem item)
{
SetParent(item.Content, () => Handler.Push(item), null);
}
/// <summary>
/// Initializes a new instance of the <see cref="Eto.Forms.Navigation"/> class with the initial navigation item.
/// </summary>
/// <param name="item">Item for the intial content of the navigation control.</param>
public Navigation(INavigationItem item)
: this()
{
Push(item);
}
/// <summary>
/// Selects stated category (tab)
/// </summary>
/// <param name="navigationItem"></param>
private void _NavigateToCategory(INavigationItem navigationItem)
{
Debug.Assert(navigationItem.Type == NavigationItemType.Category);
int index = _navigationTree.NaviationTreeRoot.Children.IndexOf(navigationItem);
if (_selectedPagesRepository[index] != null && _selectedPagesRepository[index].Page.IsAllowed)
_Navigate(_selectedPagesRepository[index]);
else
{
foreach (PageItem page in _navigationTree.NaviationTreeRoot.Children[index].Children)
{
if (page.Page.IsAllowed)
{
_Navigate(page);
break;
}
}
}
}
/// <summary>
/// Add custom page to category
/// </summary>
private void _AddCustomPage(Assembly pluginAssembly, Type pluginType, INavigationItem category)
{
try
{
PageItem newPage = new PageItem();
newPage.PageType = pluginAssembly.GetType(pluginType.ToString());
newPage.Page = (AppPages.Page)Activator.CreateInstance(newPage.PageType);
newPage.Page.Initialize(App.Current);
INavigationItem foundItem = null;
if (category.FindItem(newPage.Page.Name, out foundItem))
{ // not unique page - add warning
string messageFormat = (string)App.Current.FindResource("UnableLoadNotUniqueCustomPage");
string path = string.Format(FULL_PAGE_NAME_FORMAT, category.Name, newPage.Page.Name);
string message = string.Format(messageFormat, path, Path.GetFileName(pluginAssembly.Location));
App.Current.Messenger.AddWarning(message);
}
else
{ // add new page to the parent
newPage.Parent = category;
category.AddChild(newPage);
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
/// <summary>
/// Loads main window layout.
/// </summary>
private void _LoadLayout()
{
// create navigation tree
_navigationTree = new NavigationTree();
// add categories buttons
foreach (INavigationItem item in _navigationTree.NaviationTreeRoot.Children)
{
if (item.Type == NavigationItemType.Page)
continue; // NOTE: skip simple pages
if (!item.IsVisible)
{
// NOTE: support only "Preferences"
Debug.Assert(item.Name.Equals("Preferences", StringComparison.OrdinalIgnoreCase));
_preferencesCategory = item;
continue; // NOTE: skip items if it not visible
}
// create new button that will be entry point to the category pages
ToggleButton button = new ToggleButton();
button.Tag = item;
button.Content = item.Caption;
button.AddHandler(ToggleButton.ClickEvent, new RoutedEventHandler(OnCategoryButtonClick));
button.Style = Application.Current.Resources["CategoriesToggleButtonStyle"] as Style;
CategoryItem category = (CategoryItem)item;
if (category.PageCategory == null)
category.PageCategory = (PageCategoryItem)Activator.CreateInstance(category.CategoryType);
// set binding to "IsEnabled" property
_SetBinding(PageCategoryItem.IS_ENABLED_PROPERTY_NAME, button, category.PageCategory, ToggleButton.IsEnabledProperty);
// set binding to "ToooltipText"
_SetBinding(PageCategoryItem.TOOLTIP_PROPERTY_NAME, button, category.PageCategory, ToggleButton.ToolTipProperty);
CategoriesButtons.AddContentItem(button);
}
_InitSavedPagesRepository();
}
private void AddNavigationItemPair(INavigationItem bigButton, INavigationItem smallButton)
{
bigButton.PairedItem = smallButton;
smallButton.PairedItem = bigButton;
bigButton.NavigationViewChanged += NavigationViewChanged;
smallButton.NavigationViewChanged += NavigationViewChanged;
}
public bool HasAccess(INavigationItem navigationItem)
{
return _htmlHelper.HasActionPermission(navigationItem.Target.Action, navigationItem.Target.Controller);
}
public virtual void Push (INavigationItem item)
{
inner.Push (item);
}
public bool FindItem(string path, out INavigationItem foundItem)
{
throw new NotSupportedException();
}
public IRootNavigationItemActions AddNavigationItem(string name, string controller, string action)
{
_lastAddedNavigationItem = _navigation.AddNavigationItem(name, new Target(controller, action));
return this;
}
public void RemoveChild(INavigationItem item)
{
throw new NotSupportedException();
}
/// <summary>
/// Changes current category.
/// </summary>
private void _ChangeCurrentCategory(INavigationItem newCategory)
{
if (_currentCategory != null)
_SaveSelectedPageName();
if (newCategory.Name != "Root")
{
if (newCategory != _currentCategory)
{
_currentCategory = newCategory;
_UpdateNavigationPaneButtonsStack();
}
}
else
{
_currentCategory = null;
_UpdateNavigationPaneButtonsStack();
}
}
/// <summary>
/// Loads application structure from resource xml file.
/// </summary>
private void _LoadApplicationStructure()
{
// load navigation tree from resources
Assembly assembly = Assembly.GetExecutingAssembly();
using (Stream xmlStream = assembly.GetManifestResourceStream("ESRI.ArcLogistics.App.NavigationTree.xml"))
{
XmlDocument navTreeDoc = new XmlDocument();
navTreeDoc.Load(xmlStream);
// create top level navigation category
_navigationTree = new CategoryItem(false); // NOTE: root not have GUI
_navigationTree.Name = TREE_ITEM_NAME;
// create navigation tree in memory
XmlElement rootElement = navTreeDoc.DocumentElement;
foreach(XmlNode node in rootElement.ChildNodes)
{
if (node.NodeType != XmlNodeType.Element)
continue; // skip comments and other non element nodes
if (node.Name.Equals(XML_CATEGORY_ELEMENT_NAME, StringComparison.OrdinalIgnoreCase))
_AddCategoryItem(_navigationTree as CategoryItem, node as XmlElement);
else if (node.Name.Equals(XML_PAGE_ELEMENT_NAME, StringComparison.OrdinalIgnoreCase))
_AddPageItem(_navigationTree as CategoryItem, node as XmlElement);
else
throw new NotSupportedException();
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Eto.Forms.NavigationItemEventArgs"/> class.
/// </summary>
/// <param name="item">Item that triggered the event</param>
public NavigationItemEventArgs(INavigationItem item)
{
Item = item;
}
/// <summary>
/// Init navigation item
/// </summary>
/// <param name="navigationItem">Navigation item to init.</param>
private void _InitNavigationItem(INavigationItem navigationItem)
{
if (navigationItem.Type == NavigationItemType.Category)
{
CategoryItem category = (CategoryItem)navigationItem;
foreach (PageItem pageItem in navigationItem.Children)
{
if (pageItem.Page == null)
{
AppPages.Page newPage = (AppPages.Page)Activator.CreateInstance(pageItem.PageType);
pageItem.Page = newPage;
}
pageItem.Page.Initialize(App.Current);
}
}
else
{
AppPages.Page newPage = (AppPages.Page)Activator.CreateInstance(((PageItem)navigationItem).PageType);
newPage.Initialize(App.Current);
((PageItem)navigationItem).Page = newPage;
}
}
private string GetUrl(INavigationItem node, HttpContextBase httpContext, string applicationRoot)
{
string url = urlGenerator.Generate(httpContext.RequestContext(), node);
if (!string.IsNullOrEmpty(url))
{
if (!url.StartsWith("/", StringComparison.Ordinal))
{
url = "/" + url;
}
url = applicationRoot + url;
}
return url;
}
/// <summary>
/// Finds item by path.
/// </summary>
/// <param name="path">See INavigationItem.FindItem method description.</param>
/// <param name="foundItem">See INavigationItem.FindItem method description.</param>
/// <returns></returns>
public bool FindItem(string path, out INavigationItem foundItem)
{
return _navigationTree.FindItem(path, out foundItem);
}
