public async Task OnClickAsync()
{
if (ParentMenu != null && TopMenu.Mode == MenuMode.Horizontal)
{
await ParentMenu.CloseAsync();
}
TopMenu.ActivateItem(this);
if (!string.IsNullOrEmpty(Route))
{
if (OnRouteChanging.HasDelegate)
{
var arg = new BChangeEventArgs <string>();
arg.NewValue = Route;
arg.OldValue = currentRoute;
await OnRouteChanging.InvokeAsync(arg);
if (arg.DisallowChange)
{
return;
}
}
NavigationManager.NavigateTo(Route);
NavigationManager.LocationChanged += NavigationManager_LocationChanged;
}
}
public async Task SetActivateTabAsync(ITab tab)
{
if (OnActiveTabChangingAsync != null)
{
var allowSwitching = await OnActiveTabChangingAsync(tab);
if (!allowSwitching)
{
return;
}
}
if (ActiveTab != null && ActiveTab.Name == tab.Name)
{
return;
}
ActiveTabName = tab.Name;
var eventArgs = new BChangeEventArgs <ITab>();
eventArgs.OldValue = ActiveTab;
eventArgs.NewValue = tab;
ActiveTab = tab;
StateHasChanged();
if (OnActiveTabChanged.HasDelegate)
{
await OnActiveTabChanged.InvokeAsync(eventArgs);
}
}
internal async Task <bool> TrySetValueAsync(TValue value, bool requireRefresh)
{
var arg = new BChangeEventArgs <TValue>()
{
NewValue = value,
OldValue = SelectedValue
};
if (SelectedValueChanging.HasDelegate)
{
await SelectedValueChanging.InvokeAsync(arg);
if (arg.DisallowChange)
{
return(false);
}
}
SelectedValue = value;
SetFieldValue(SelectedValue, true);
RequireRender = true;
if (SelectedValueChanged.HasDelegate)
{
await SelectedValueChanged.InvokeAsync(value);
}
if (requireRefresh)
{
StateHasChanged();
}
return(true);
}
protected void OnActiveTabChanged(BChangeEventArgs <BTabPanel> eventArgs)
{
if (eventArgs.NewValue != null && NavigationManager.Uri != eventArgs.NewValue.Name)
{
NavigationManager.NavigateTo(eventArgs.NewValue.Name);
}
}
internal async Task OnInternalSelectAsync(BSelectOptionBase <TValue> item)
{
var args = new BChangeEventArgs <BSelectOptionBase <TValue> >();
args.NewValue = item;
args.OldValue = SelectedOption;
if (OnChanging.HasDelegate)
{
await OnChanging.InvokeAsync(args);
if (args.DisallowChange)
{
return;
}
}
await dropDownOption.Instance.CloseDropDownAsync(dropDownOption);
SelectedOption = item;
SetFieldValue(item.Value, true);
Value = item.Value;
if (dict != null)
{
dict.TryGetValue(Value, out var label);
Label = label;
}
if (OnChange.HasDelegate)
{
await OnChange.InvokeAsync(args);
}
EnableClearButton = false;
StateHasChanged();
}
internal async Task OnInternalSelectAsync(BSimpleOptionBase <TValue> item)
{
var args = new BChangeEventArgs <BSimpleOptionBase <TValue> >();
args.NewValue = item;
args.OldValue = SelectedOption;
if (OnSelecting.HasDelegate)
{
await OnSelecting.InvokeAsync(args);
if (args.DisallowChange)
{
return;
}
}
await DropDownOption.Instance.CloseDropDownAsync(DropDownOption);
SelectedOption = item;
SetFieldValue(item.Value);
if (OnSelect.HasDelegate)
{
await OnSelect.InvokeAsync(args);
}
IsClearButtonClick = false;
StateHasChanged();
}
protected void ActiveTabChanged(BChangeEventArgs <BTabPanel> e)
{
blayout?.Refresh();
btab?.Refresh();
RequireRender = true;
this.MarkAsRequireRender();
StateHasChanged();
}
protected void ChangeStatus(ChangeEventArgs uIMouseEvent)
{
if (IsDisabled)
{
return;
}
var oldValue = new CheckBoxValue()
{
Status = Status
};
var newValue = new CheckBoxValue();
switch (Status)
{
case Status.UnChecked:
newValue.Status = Status.Checked;
break;
case Status.Checked:
newValue.Status = Status.UnChecked;
break;
case Status.Indeterminate:
newValue.Status = Status.Checked;
break;
}
if (newValue.Status == Status.Checked)
{
CheckBoxGroup?.SelectedItems?.Add(Value);
Value = originValue;
}
else
{
CheckBoxGroup?.SelectedItems?.Remove(Value);
Value = default;
}
Status = newValue.Status;
//有 CheckBoxGroup 时，视整个CheckBoxGroup为一个字段
if (CheckBoxGroup == null)
{
SetFieldValue(Value);
}
if (ValueChanged.HasDelegate)
{
_ = ValueChanged.InvokeAsync(Value);
}
if (StatusChanged.HasDelegate)
{
var args = new BChangeEventArgs <CheckBoxValue>();
args.OldValue = oldValue;
args.NewValue = newValue;
_ = StatusChanged.InvokeAsync(newValue.Status);
}
}
internal async Task <bool> SetActivateTabAsync(BTabPanelBase tab)
{
if (OnActiveTabChanging.HasDelegate)
{
var arg = new BChangeEventArgs <BTabPanelBase>();
arg.NewValue = tab;
arg.OldValue = ActiveTab;
await OnActiveTabChanging.InvokeAsync(arg);
if (arg.DisallowChange)
{
return(false);
}
}
if (DataSource == null)
{
foreach (var tabPanel in tabPanels)
{
if (tabPanel == tab)
{
tabPanel.Activate();
continue;
}
tabPanel.DeActivate();
}
}
else
{
foreach (var item in DataSource)
{
item.IsActive = item.Name == tab.Name;
}
}
ActiveTab = tab;
var eventArgs = new BChangeEventArgs <BTabPanelBase>();
eventArgs.OldValue = ActiveTab;
eventArgs.NewValue = tab;
RequireRender = true;
if (OnActiveTabChanged.HasDelegate)
{
await OnActiveTabChanged.InvokeAsync(eventArgs);
}
else
{
StateHasChanged();
}
return(true);
}
protected void OnRadioChanged(MouseEventArgs e)
{
if (IsDisabled)
{
return;
}
if (RadioGroup != null)
{
_ = RadioGroup.TrySetValueAsync(Value, !SelectedValueChanged.HasDelegate);
return;
}
var newStatus = Status == RadioStatus.Selected ? RadioStatus.UnSelected : RadioStatus.Selected;
if (StatusChanging.HasDelegate)
{
var arg = new BChangeEventArgs <RadioStatus>();
arg.OldValue = Status;
arg.NewValue = newStatus;
StatusChanging.InvokeAsync(arg).Wait();
if (arg.DisallowChange)
{
return;
}
}
if (newStatus == RadioStatus.Selected && !TypeHelper.Equal(SelectedValue, Value))
{
SelectedValue = Value;
}
if (RadioGroup == null)
{
SetFieldValue(SelectedValue, true);
if (FormItem != null)
{
FormItem.MarkAsRequireRender();
FormItem.Refresh();
}
}
if (StatusChanged.HasDelegate)
{
_ = StatusChanged.InvokeAsync(newStatus);
}
if (SelectedValueChanged.HasDelegate)
{
_ = SelectedValueChanged.InvokeAsync(SelectedValue);
}
}
protected void ProductSelected(BChangeEventArgs <BSelectOptionBase <int?> > arg)
{
Steps.Clear();
table.MarkAsRequireRender();
RequireRender = true;
if (arg.NewValue.Value.HasValue)
{
productId = arg.NewValue.Value.Value;
productVersions = ProductService.GetProductVersions(arg.NewValue.Value.Value);
Versions = productVersions.ToDictionary(x => x.Id, x => x.Version);
}
else
{
productId = 0;
productVersions.Clear();
Versions.Clear();
}
}
protected void ActiveTabChanged(BChangeEventArgs <BTabPanel> e)
{
var title = e.NewValue.Title;
switch (title)
{
case "综合":
tabPanel_Comprehensive?.Refresh();
break;
case "人气":
tabPanel_Hot?.Refresh();
break;
case "精华":
tabPanel_Best?.Refresh();
break;
case "已结":
tabPanel_End?.Refresh();
break;
}
UpdateUI();
}
protected void OnStatusChanging(BChangeEventArgs <RadioStatus> e)
{
e.DisallowChange = true;
}
protected void OnTabPanelChanging(BChangeEventArgs <BTabPanelBase> args)
{
args.DisallowChange = true;
NavigationManager.NavigateTo(args.NewValue.Name);
}
protected void OnRouteChanging(BChangeEventArgs <string> arg)
{
arg.DisallowChange = true;
AddTab(arg.NewValue);
}
