public override bool SetupMenu(IMenu menu)
{
menu?.Clear();
MenuInflater.Inflate(Resource.Menu.Settings_ActionBar, menu);
menu?.FindItem(Resource.Id.Menu_Settings_Logout)?.SetVisible(Settings.IsUserAuthenticated);
return(true);
}
public override bool SetupMenu(IMenu menu)
{
menu?.Clear();
MenuInflater.Inflate(Resource.Menu.Browse_ActionBar, menu);
return(true);
}
public override void SetupMenu(IMenu menu)
{
menu?.Clear();
var inflater = new MenuInflater(Context);
inflater.Inflate(Resource.Menu.BrowseFragment_ActionBar, menu);
}
public override bool OnPrepareOptionsMenu(IMenu menu)
{
menu.Clear ();
var menuCounter = 0;
var item = menu.Add (1, MENU_ID_HISTORY_CLEAR, menuCounter++, Resource.String.urllauncher_menu_clear_history);
item.SetIcon(Android.Resource.Drawable.IcDelete);
return true;
}
public override bool OnMenuOpened(int featureId, IMenu menu)
{
menu.Clear();
MenuInflater.Inflate(Resource.Menu.ActionMenu, menu);
if (run)
menu.FindItem(Resource.Id.startstop).SetTitle("Stop");
else
menu.FindItem(Resource.Id.startstop).SetTitle("Start");
return base.OnMenuOpened(featureId, menu);
}
public override bool SetupMenu(IMenu menu)
{
menu?.Clear();
MenuInflater.Inflate(Resource.Menu.User_ActionBar, _menu = menu);
menu?.FindItem(Resource.Id.Menu_User_Message)?.SetVisible(_canMessage);
menu?.FindItem(Resource.Id.Menu_User_Follow)?.SetIcon(_isFollowing
? Resource.Drawable.svg_star
: Resource.Drawable.svg_star_outline);
menu?.FindItem(Resource.Id.Menu_User_Follow)?.SetVisible(_canFollow);
return(true);
}
public override bool SetupMenu(IMenu menu)
{
menu?.Clear();
MenuInflater.Inflate(Resource.Menu.AniListObject_ActionBar, _menu = menu);
menu?.FindItem(Resource.Id.Menu_AniListObject_Share)?.SetVisible(_showMenu);
menu?.FindItem(Resource.Id.Menu_AniListObject_Favorite)?.SetVisible(_showMenu && _canFavorite);
menu?.FindItem(Resource.Id.Menu_AniListObject_Favorite)?.SetIcon(_isFavorite
? Resource.Drawable.ic_favorite_white_24px
: Resource.Drawable.ic_favorite_border_white_24px);
return(true);
}
public override bool OnPrepareOptionsMenu(IMenu menu)
{
if(ActionBar == null)
return base.OnPrepareOptionsMenu(menu);
menu.Clear();
MenuInflater.Inflate(MenuId, menu);
for (int i = 0; i < menu.Size(); i++)
{
var menuItem = menu.GetItem(i);
menuItem.SetVisible(!ActionBar.MenuItemsToHide.Contains(menuItem.ItemId));
}
return base.OnPrepareOptionsMenu(menu);
}
public override void OnCreateOptionsMenu(IMenu menu, MenuInflater inflater)
{
menu?.Clear();
if (MenuLayout > 0 && menu != null)
{
inflater.Inflate(MenuLayout, menu);
OnMenuInflated(menu);
foreach (var item in menu.Items())
{
item.SetOnMenuItemClickListener(this);
}
}
base.OnCreateOptionsMenu(menu, inflater);
}
public override bool OnPrepareOptionsMenu(IMenu menu)
{
menu.Clear ();
// Check if the toolbar is initialized, and if so, inflate the menu onto it
if (_toolbar != null)
{
MenuInflater.Inflate (Resource.Menu.menu, menu);
// Locate MenuItem with ShareActionProvider
var item = menu.FindItem (Resource.Id.menu_item_share);
// Fetch and store ShareActionProvider
if (item != null)
{
item.SetIntent (CreateShareIntent ());
}
var searchItem = menu.FindItem (Resource.Id.action_search);
_searchView = (SearchView)MenuItemCompat.GetActionView (searchItem);
_searchView.QueryTextChange += (sender, e) =>
{
if (!string.IsNullOrEmpty (e.NewText))
{
// User has inputted some search text
SupportFragmentManager.BeginTransaction ()
.Replace (Resource.Id.content_frame, new SearchResultsFragment (e.NewText))
.Commit ();
}
else
{
// No search string, so display the previous fragment
SupportFragmentManager.BeginTransaction ()
.Replace (Resource.Id.content_frame, _prevFragment)
.Commit ();
}
};
}
return base.OnPrepareOptionsMenu (menu);
}
internal void PrepareMenu(IMenu menu)
{
foreach (ToolbarItem item in _toolbarTracker.ToolbarItems)
{
item.PropertyChanged -= HandleToolbarItemPropertyChanged;
}
menu.Clear();
if (!ShouldShowActionBarTitleArea())
{
return;
}
foreach (ToolbarItem item in _toolbarTracker.ToolbarItems)
{
IMenuItemController controller = item;
item.PropertyChanged += HandleToolbarItemPropertyChanged;
if (item.Order == ToolbarItemOrder.Secondary)
{
IMenuItem menuItem = menu.Add(item.Text);
menuItem.SetEnabled(controller.IsEnabled);
menuItem.SetOnMenuItemClickListener(new GenericMenuClickListener(controller.Activate));
}
else
{
IMenuItem menuItem = menu.Add(item.Text);
if (!string.IsNullOrEmpty(item.Icon))
{
Drawable iconBitmap = _context.Resources.GetDrawable(item.Icon);
if (iconBitmap != null)
{
menuItem.SetIcon(iconBitmap);
}
}
menuItem.SetEnabled(controller.IsEnabled);
menuItem.SetShowAsAction(ShowAsAction.Always);
menuItem.SetOnMenuItemClickListener(new GenericMenuClickListener(controller.Activate));
}
}
}
void UpdateMenu()
{
AToolbar bar = _toolbar;
Context context = Context;
IMenu menu = bar.Menu;
foreach (ToolbarItem item in _toolbarTracker.ToolbarItems)
{
item.PropertyChanged -= HandleToolbarItemPropertyChanged;
}
menu.Clear();
foreach (ToolbarItem item in _toolbarTracker.ToolbarItems)
{
IMenuItemController controller = item;
item.PropertyChanged += HandleToolbarItemPropertyChanged;
if (item.Order == ToolbarItemOrder.Secondary)
{
IMenuItem menuItem = menu.Add(item.Text);
menuItem.SetEnabled(controller.IsEnabled);
menuItem.SetOnMenuItemClickListener(new GenericMenuClickListener(controller.Activate));
}
else
{
IMenuItem menuItem = menu.Add(item.Text);
FileImageSource icon = item.Icon;
if (!string.IsNullOrEmpty(icon))
{
Drawable iconBitmap = context.Resources.GetDrawable(icon);
if (iconBitmap != null)
{
menuItem.SetIcon(iconBitmap);
}
}
menuItem.SetEnabled(controller.IsEnabled);
menuItem.SetShowAsAction(ShowAsAction.Always);
menuItem.SetOnMenuItemClickListener(new GenericMenuClickListener(controller.Activate));
}
}
}
public static void ChangeMenu(Menu.Menus menu)
{
Session ses = Session.session;
if (ses.activeMenu != null)
{
IMenu menuInstance = ses.activeMenu as IMenu;
if (menuInstance != null)
{
menuInstance.Clear();
}
else
{
ses.activeMenu.QueueFree();
}
ses.activeMenu = null;
}
ses.activeMenu = Menu.MenuFactory(menu);
}
void UpdateMenu()
{
if (_disposed)
{
return;
}
AToolbar bar = _toolbar;
Context context = Context;
IMenu menu = bar.Menu;
foreach (ToolbarItem item in _toolbarTracker.ToolbarItems)
{
item.PropertyChanged -= OnToolbarItemPropertyChanged;
}
menu.Clear();
foreach (ToolbarItem item in _toolbarTracker.ToolbarItems)
{
IMenuItemController controller = item;
item.PropertyChanged += OnToolbarItemPropertyChanged;
if (item.Order == ToolbarItemOrder.Secondary)
{
IMenuItem menuItem = menu.Add(item.Text);
menuItem.SetEnabled(controller.IsEnabled);
menuItem.SetOnMenuItemClickListener(new GenericMenuClickListener(controller.Activate));
menuItem.SetTitleOrContentDescription(item);
}
else
{
IMenuItem menuItem = menu.Add(item.Text);
menuItem.SetEnabled(controller.IsEnabled);
UpdateMenuItemIcon(context, menuItem, item);
menuItem.SetShowAsAction(ShowAsAction.Always);
menuItem.SetOnMenuItemClickListener(new GenericMenuClickListener(controller.Activate));
menuItem.SetTitleOrContentDescription(item);
}
}
}
protected override void Refresh()
{
for (int i = 0; i < _menu.Size(); i++)
{
MenuItemTemplate.Clear(_menu.GetItem(i));
}
_menu.Clear();
IEnumerable itemsSource = ItemsSource;
if (itemsSource == null)
{
return;
}
int count = 0;
foreach (object item in itemsSource)
{
_itemTemplate.Apply(_menu, _context, item, count, count);
count++;
}
}
public override bool OnPrepareOptionsMenu(IMenu menu)
{
menu.Clear ();
MenuInflater.Inflate(Resource.Menu.chat, menu);
if (visibleMessages <= 15) {
var item = menu.FindItem (Resource.Id.action_lessMessages);
item.SetVisible (false);
item = menu.FindItem (Resource.Id.action_defaultMessages);
item.SetVisible (false);
}
return base.OnPrepareOptionsMenu(menu);
}
private async Task OpenEpub()
{
textViewTitle.Text = book.Title;
textViewAuthor.Text = book.Author;
var coverImage = await book.GetCoverAsync();
if (coverImage != null)
{
imageViewCover.SetImageBitmap(coverImage);
}
chapterList = book.GetChapterList();
bookmarkList = book.Bookmarks.Select(b => new BookmarkNavigationItem
{
Text = b.Description,
OnClickCallback = new Action(() => LoadBookmark(b))
}).ToList();
tableMenuLeft.Clear();
tableMenuRight.Clear();
var navigationItemIndex = 0;
foreach (var chapter in chapterList)
{
if (chapter.SubChapters.Count > 0)
{
var subMenu = tableMenuLeft.AddSubMenu(0, navigationItemIndex, Menu.None, chapter.Text);
chapter.MenuItemId = navigationItemIndex++;
chapter.OnClickCallback = new Action(async() => await LoadChapterAsync(chapter));
foreach (var subChapter in chapter.SubChapters)
{
subMenu.Add(0, navigationItemIndex, Menu.None, subChapter.Text);
subChapter.MenuItemId = navigationItemIndex++;
subChapter.OnClickCallback = new Action(async() => await LoadChapterAsync(subChapter));
}
}
else
{
tableMenuLeft.Add(0, navigationItemIndex, Menu.None, chapter.Text);
chapter.MenuItemId = navigationItemIndex++;
chapter.OnClickCallback = new Action(async() => await LoadChapterAsync(chapter));
}
}
foreach (var bookmark in bookmarkList)
{
tableMenuRight.Add(0, navigationItemIndex, Menu.None, bookmark.Text);
bookmark.MenuItemId = navigationItemIndex++;
}
try
{
LoadBookmark(book.LastPosition);
}
catch
{
chapterList?.FirstOrDefault()?.OnClickCallback?.Invoke();
}
}
public override void OnCreateOptionsMenu(IMenu menu, MenuInflater inflater)
{
menu.Clear();
inflater.Inflate(Resource.Menu.recipe_display_menu, menu);
base.OnCreateOptionsMenu(menu, inflater);
}
public override void OnCreateOptionsMenu(IMenu menu, MenuInflater inflater)
{
menu.Clear();
Activity.MenuInflater.Inflate(Resource.Menu.booking_new_options, menu);
}
public bool OnCreateActionMode(ActionMode mode, IMenu menu)
{
menu.Clear();
menu.Add(new Java.Lang.String("Copy")).SetShowAsAction(ShowAsAction.IfRoom);
return(true);
}
public override bool OnPrepareOptionsMenu(IMenu menu)
{
menu.Clear();
MenuInflater.Inflate(Resource.Menu.main, menu);
return(base.OnPrepareOptionsMenu(menu));
}
private static void CreateMenu(IMenu menu)
{
menu.Clear();
if (BitBrowserApp.Current.Settings != null)
menu.Add(Menu.First, 1, 1, D.PREFERENCES);
menu.Add(Menu.First, 2, 2, D.EXIT);
#if DEBUG
menu.Add(Menu.First, 3, 3, "Throw exception");
#endif
}
public override bool OnCreateOptionsMenu(IMenu menus)
{
menus.Clear();
MenuInflater.Inflate(Resource.Menu.JMenu, menus);
return(true);
}
public override void OnCreateOptionsMenu(IMenu menu, MenuInflater inflater)
{
menu.Clear();
Activity.MenuInflater.Inflate(Resource.Menu.default_no_toolbar_options, menu);
}
public override void OnPrepareOptionsMenu(IMenu menu)
{
menu.Clear();
base.OnPrepareOptionsMenu(menu);
}
internal static void ClearInternal(IMenu menu)
{
if (menu == null)
return;
int size = menu.Size();
for (int i = 0; i < size; i++)
MenuItemTemplate.ClearInternal(menu.GetItem(i));
menu.Clear();
menu.ClearBindings(true, true);
}
public override void OnCreateOptionsMenu(IMenu menu, MenuInflater inflater)
{
menu.Clear();
inflater.Inflate(Resource.Menu.menu_editshare, menu);
}
public override bool OnPrepareOptionsMenu(IMenu menu)
{
menu.Clear();
if (BitBrowserApp.Current.Settings != null)
menu.Add(Menu.First, 1, 1, D.PREFERENCES);
menu.Add(Menu.First, 2, 2, D.EXIT);
#if DEBUG
menu.Add(Menu.First, 3, 3, "Throw exception");
#endif
return base.OnPrepareOptionsMenu(menu);
}
public override bool OnCreateOptionsMenu(IMenu menu)
{
menu.Clear();
ChangeToolbar();
return(base.OnCreateOptionsMenu(menu));
}
//Prepare the Screen's standard options menu to be displayed.
public override bool OnPrepareOptionsMenu(IMenu menu)
{
//Prevent menu items from being duplicated.
menu.Clear();
MenuInflater.Inflate(Resource.Menu.menu, menu);
return base.OnPrepareOptionsMenu(menu);
}
public override void OnCreateOptionsMenu(IMenu menu, MenuInflater inflater)
{
menu.Clear();
}
public override bool OnPrepareOptionsMenu(IMenu menu)
{
menu.Clear ();
MenuInflater.Inflate(Resource.Menu.main, menu);
return base.OnPrepareOptionsMenu(menu);
}
public override void OnCreateOptionsMenu(IMenu menu, MenuInflater inflater)
{
menu.Clear ();
inflater.Inflate (Resource.Menu.menu_search, menu);
base.OnCreateOptionsMenu (menu, inflater);
}
static void n_Clear(IntPtr jnienv, IntPtr native__this)
{
IMenu __this = Java.Lang.Object.GetObject <IMenu> (native__this, JniHandleOwnership.DoNotTransfer);
__this.Clear();
}
public override void OnCreateOptionsMenu(IMenu menu, MenuInflater inflater)
{
//we hide the main options
menu.Clear();
inflater.Inflate(Resource.Menu.menu_new_task, menu);
}
public override void OnCreateOptionsMenu(IMenu menu, MenuInflater inflater)
{
menu.Clear();
inflater.Inflate(Resource.Menu.confirm_menu, menu);
}
/// <summary>
/// Prepare the Screen's standard options menu to be displayed.
/// </summary>
/// <param name="menu">The options menu as last shown or first initialized by
/// onCreateOptionsMenu().</param>
/// <returns>
/// To be added.
/// </returns>
/// <since version="Added in API level 1" />
/// <altmember cref="M:Android.App.Activity.OnCreateOptionsMenu(Android.Views.IMenu)" />
/// <remarks>
/// <para tool="javadoc-to-mdoc">Prepare the Screen's standard options menu to be displayed. This is
/// called right before the menu is shown, every time it is shown. You can
/// use this method to efficiently enable/disable items or otherwise
/// dynamically modify the contents.
/// </para>
/// <para tool="javadoc-to-mdoc">The default implementation updates the system menu items based on the
/// activity's state. Deriving classes should always call through to the
/// base class implementation.</para>
/// <para tool="javadoc-to-mdoc">
/// <format type="text/html">
/// <a href="http://developer.android.com/reference/android/app/Activity.html#onPrepareOptionsMenu(android.view.Menu)" target="_blank">[Android Documentation]</a>
/// </format>
/// </para>
/// </remarks>
public override bool OnPrepareOptionsMenu(IMenu menu)
{
menu.Clear();
MenuInflater.Inflate(Resource.Menu.ApplicationMenu, menu);
IMenuItem item = menu.FindItem(Resource.Id.actionusername);
if (ApplicationData.User.Username != null)
{
item.SetTitle(ApplicationData.User.Username);
}
return base.OnPrepareOptionsMenu(menu);
}
