public static void AddBottomAppBar(Page myPage)
        {
            var commandBar = new CommandBar();
            var searchButton = new AppBarButton
            {
                Label = "Поиск",
                Icon = new SymbolIcon(Symbol.Find),
            };

            var aboutButton = new AppBarButton
            {
                Label = "О прилож.",
                Icon = new SymbolIcon(Symbol.Help),
            };

            if (RootFrame != null)
            {
                searchButton.Click += SearchButtonClick;
                aboutButton.Click += AboutButtonClick;
            }

            commandBar.PrimaryCommands.Add(searchButton);
            commandBar.PrimaryCommands.Add(aboutButton);
            myPage.BottomAppBar = commandBar;
        }

		public void CreateUIForChoiceGroupCollection(ChoiceGroupCollection groupCollection)
		{
			bool weCreatedTheBarManager = GetCommandBarManager();

			foreach(ChoiceGroup group in groupCollection)
			{
				CommandBar toolbar = new CommandBar(CommandBarStyle.ToolBar);
				toolbar.Tag = group;
				group.ReferenceWidget = toolbar;

				//whereas the system was designed to only populate groups when
				//the OnDisplay method is called on a group,
				//this particular widget really really wants to have all of the buttons
				//populated before it gets added to the window.
				//therefore, we don't hope this up but instead call a bogus OnDisplay() now.
				//toolbar.VisibleChanged  += new System.EventHandler(group.OnDisplay);

				group.OnDisplay(null,null);

				this.m_commandBarManager.CommandBars.Add(toolbar);
			}

			if(weCreatedTheBarManager)
				m_window.Controls.Add(m_commandBarManager);
		}

        public static CommandBar ToAppCommandBar(this IContextMenu source, CommandBar menu, bool isSecondary)
        {
            var commandsVector = isSecondary ? menu.SecondaryCommands : menu.PrimaryCommands;
            commandsVector.Clear();

            foreach(var item in source.Items)
            {
                AppBarButton button = new AppBarButton();
                commandsVector.Add(button);
                button.Label = item.Header;
                button.Command = item.Command;
                button.CommandParameter = item.CommandParameter;

                if (!string.IsNullOrEmpty(item.Icon))
                {
                    var icon = new SymbolIcon();
                    icon.Symbol = (Symbol)System.Enum.Parse(typeof(Symbol), item.Icon);
                    button.Icon = icon;
                }
                else
                    button.Icon = new SymbolIcon(Symbol.Emoji);
            }

            return menu;
        }

        private void initiateCommandBar()
        {
            CommandBar bar = new CommandBar();
            AppBarButton logou = new AppBarButton() { Icon = new SymbolIcon(Symbol.Cancel), Label = "Log out" };
            logou.Click += logout;
            AppBarButton refr = new AppBarButton() { Icon = new BitmapIcon() { UriSource = new Uri("ms-appx:Assets/Buttons/appbar.refresh.png") }, Label = "Refresh" };
            refr.Click += refresh;
            AppBarButton search = new AppBarButton() { Icon = new SymbolIcon(Symbol.Find), Label = "Search" };
            search.Click += search_Click;

            AppBarButton ideas = new AppBarButton() { Label = "Suggest a feature" };
            ideas.Click += openForum;
            AppBarButton bugs = new AppBarButton() { Label = "Report a bug" };
            ideas.Click += openForum;
            AppBarButton contact = new AppBarButton() { Label = "Contact Developer" };
            contact.Click += sendEmail;

            bar.PrimaryCommands.Add(refr);
            bar.PrimaryCommands.Add(search);
            bar.PrimaryCommands.Add(logou);

            bar.SecondaryCommands.Add(ideas);
            bar.SecondaryCommands.Add(bugs);
            bar.SecondaryCommands.Add(contact);

            bar.ClosedDisplayMode = AppBarClosedDisplayMode.Minimal;

            BottomAppBar = bar;
        }

        public ApplicationWindow()
        {
            this.Icon = new Icon(this.GetType().Assembly.GetManifestResourceStream("Resourcer.Application.ico"));
            this.Font = new Font("Tahoma", 8.25f);
            this.Text = (this.GetType().Assembly.GetCustomAttributes(typeof(System.Reflection.AssemblyTitleAttribute), false)[0] as System.Reflection.AssemblyTitleAttribute).Title;
            this.Size = new Size(480, 600);
            this.MinimumSize = new Size (240, 300);

            this.resourceBrowser = new ResourceBrowser();
            this.resourceBrowser.Dock = DockStyle.Fill;
            this.Controls.Add(this.resourceBrowser);

            this.verticalSplitter = new Splitter ();
            this.verticalSplitter.Dock = DockStyle.Bottom;
            this.verticalSplitter.BorderStyle = BorderStyle.None;
            this.Controls.Add(this.verticalSplitter);

            this.resourceViewer = new ResourcerViewer();
            this.resourceViewer.Dock = DockStyle.Bottom;
            this.resourceViewer.Height = 100;
            this.Controls.Add(this.resourceViewer);

            this.statusBar = new StatusBar();
            this.Controls.Add(this.statusBar);

            this.commandBarManager = new CommandBarManager();
            this.menuBar = new CommandBar(this.commandBarManager, CommandBarStyle.Menu);
            this.commandBarManager.CommandBars.Add(this.menuBar);
            this.toolBar = new CommandBar(this.commandBarManager, CommandBarStyle.ToolBar);
            this.commandBarManager.CommandBars.Add(this.toolBar);
            this.Controls.Add(this.commandBarManager);
        }

 public static void SetCommandBar(DependencyObject obj, CommandBar value)
 {
     if (obj == null)
     {
         throw new ArgumentNullException("obj");
     }
     obj.SetValue(CommandBarProperty, value);
 }

			public override bool RegisterGUI(Command vsCommand, CommandBar vsCommandbar, bool toolBarOnly)
			{
				if(!toolBarOnly)
				{
					_RegisterGuiContext(vsCommand, "Solution");
				}
				return true;
			}

 public static CommandBar GetSolutionCommandBar(this DTE2 application)
 {
     if (_solutionCommandBar == null)
     {
         _solutionCommandBar = ((CommandBars)application.CommandBars)["Solution"];
     }
     return _solutionCommandBar;
 }

 public static CommandBar GetProjectCommandBar(this DTE2 application)
 {
     if (_projectCommandBar == null)
     {
         _projectCommandBar = ((CommandBars)application.CommandBars)["Project"];
     }
     return _projectCommandBar;
 }

 public static CommandBar GetCodeWindowCommandBar(this DTE2 application)
 {
     if (_codeWindowCommandBar == null)
     {
         _codeWindowCommandBar = ((CommandBars)application.CommandBars)["Code Window"];
     }
     return _codeWindowCommandBar;
 }

		public virtual bool RegisterGUI(Command vsCommand, CommandBar vsCommandbar, bool toolBarOnly)
		{
			// The default command is registered in the toolbar.
			if(IconIndex >= 0 && toolBarOnly)
				vsCommand.AddControl(vsCommandbar, vsCommandbar.Controls.Count + 1);

			return true;
		}

		public System.Windows.Forms.Control Init (System.Windows.Forms.Form window,  IImageCollection smallImages, IImageCollection largeImages, Mediator mediator)
		{
			m_window = window;
			m_smallImages = smallImages;
			m_largeImages = largeImages;
			m_menuBar = new CommandBar(CommandBarStyle.Menu);

			return null; //this is not available yet. caller should call GetCommandBarManager() after CreateUIForChoiceGroupCollection() is called
		}

 public CommandRegistry(Plugin plugin, CommandBar commandBar, Guid packageGuid, Guid cmdGroupGuid)
 {
     mCommands = new Dictionary<string, CommandBase>();
     mCommandsById = new Dictionary<uint, CommandBase>();
     mPlugin = plugin;
     mCommandBar = commandBar;
     mPackageGuid = packageGuid;
     mCmdGroupGuid = cmdGroupGuid;
 }

        public CommandBarButton AddButtonToCmdBar(CommandBar cmdBar, int beforeIndex, string caption, string tooltip)
        {
            CommandBarButton button = cmdBar.Controls.Add(MsoControlType.msoControlButton,
                        Type.Missing, Type.Missing, beforeIndex, true) as CommandBarButton;
            button.Caption = caption;
            button.TooltipText = tooltip;

            return button;
        }

        public NewAlarmView()
        {
            this.InitializeComponent();

            this.navigationHelper = new NavigationHelper(this);
            this.navigationHelper.LoadState += this.NavigationHelper_LoadState;
            this.navigationHelper.SaveState += this.NavigationHelper_SaveState;
            //defaultViewModel.Add("newAlarm", new NewAlarmViewModel());
            alarmViewCommandBar = BottomAppBar as CommandBar;
        }

        public int Add(CommandBar commandBar)
        {
            if (!this.Contains(commandBar))
            {
                int index = this.bands.Add(commandBar);
                this.commandBarManager.UpdateBands();
                return index;
            }

            return -1;
        }

        private CommandBarPopup CreateFmgPopupMenu( CommandBar mainMenuBar, int menuPositionOnBar )
        {
            CommandBarPopup fmgPluginsPopupMenu = mainMenuBar.Controls.Add( MsoControlType.msoControlPopup, Type.Missing, Type.Missing, menuPositionOnBar, true ) as CommandBarPopup;

            if ( fmgPluginsPopupMenu != null )
            {
                fmgPluginsPopupMenu.Caption = "FMG Plug-ins";
            }

            return fmgPluginsPopupMenu;
        }

 public static void RefreshUIOnDataLoaded(ProgressBar pb, CommandBar cb)
 {
     if (cb != null)
     {
         cb.Visibility = Windows.UI.Xaml.Visibility.Visible;
     }
     if (pb != null)
     {
         pb.IsIndeterminate = false;
         pb.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
     }
 }

            public CommandsListMonitor(CommandBar bar,
                IObservableCollection<AppBarCommandViewModel> source)
            {
                if (bar == null) throw new ArgumentNullException("bar");
                if (source == null) throw new ArgumentNullException("source");

                _bar = bar;
                _source = source;

                _bar.Unloaded += OnUnloaded;
                _source.CollectionChanged += OnCollectionChanged;
            }

 /// <summary>
 /// Returns an instance of the selected command bar by name
 /// </summary>
 /// <param name="commandBars">A vector of command bars</param>
 /// <param name="commandBarName">Command bar name</param>
 /// <param name="commandBar">Handle of the selected command bar</param>
 private void getCommandBarInstanceByName(CommandBars commandBars, string commandBarName, out CommandBar commandBar)
 {
     try
     {
         commandBar = null;
         commandBar = Globals.ThisAddIn.Application.CommandBars[commandBarName];
     }
     catch (Exception)
     {
         commandBar = null;
     }
 }