protected override WithImageStorableComicSourceInfo <TResource, TImage> CreateSourceInfo(ComicSnapshot snapshot, ComicSource source, ComicEngine engine)
{
var store = AppEngine.GetRequiredService <WithImageComicStoreService <TResource, TImage> >();
var box = store.GetStoreBox(source.TargetUrl);
return(new WithImageStorableComicSourceInfo <TResource, TImage>(snapshot, source, engine.GetComicSourceProviderType(source.TargetUrl), box));
}
public void AddSomeServices_CallGet_MustReturnService()
{
AppEngine.Reset();
AppEngine.Services.AddSingleton <A>();
AppEngine.Services.AddScoped <B>();
AppEngine.Services.AddTransient <C>();
_ = AppEngine.Provider;
Check <A>();
Check <B>();
Check <C>();
void Check <T>()
{
var a = AppEngine.GetService(typeof(T));
Assert.IsNotNull(a);
Assert.IsInstanceOfType(a, typeof(T));
a = AppEngine.GetService <T>();
Assert.IsNotNull(a);
a = AppEngine.GetRequiredService <T>();
Assert.IsNotNull(a);
a = AppEngine.GetRequiredService(typeof(T));
Assert.IsNotNull(a);
Assert.IsInstanceOfType(a, typeof(T));
}
}
private async void LoadVm(string address)
{
vm = new DesktopVisitingViewModel();
DataContext = vm;
vc = new VisitingControlView {
DataContext = vm
};
titleService = AppEngine.GetRequiredService <TitleService>();
titleService.LeftControls.Add(vc);
try
{
await vm.Visiting.LoadAsync(address);
if (vm.HasStoreBox)
{
await vm.GoChapterIndexAsync(vm.StoreBox.AttackModel.CurrentChapter);
}
else
{
await vm.NextChapterAsync();
}
_ = LoadPageAsync(0);
vm.TransverseChanged += Vm_TransverseChanged;
rep = this.Get <ItemsRepeater>("Rep");
car = this.Get <Carousel>("Car");
var sv = this.Get <ScrollViewer>("RepSv");
sv.ScrollChanged += Sv_ScrollChanged;
this.KeyDown += OnCarKeyDown;
Vm_TransverseChanged(vm, vm.Transverse);
}
catch (Exception ex)
{
vm.ExceptionService.Exception = ex;
}
}
public StoreComicVisiting(IServiceProvider host, IResourceFactoryCreator <T> resourceFactoryCreator)
: base(host, resourceFactoryCreator)
{
storeService = AppEngine.GetRequiredService <IStoreService>();
recyclableMemoryStreamManager = AppEngine.GetRequiredService <RecyclableMemoryStreamManager>();
DelayTime = DefaultDelayTime;
}
private static void TaskScheduler_UnobservedTaskException(object sender, UnobservedTaskExceptionEventArgs e)
{
var exSer = AppEngine.GetRequiredService <ExceptionService>();
exSer.Exception = e.Exception;
e.SetObserved();
}
public HomeViewModel()
{
ComicEngine = AppEngine.GetRequiredService <ComicEngine>();
SearchEngine = AppEngine.GetRequiredService <SearchEngine>();
ProposalEngine = AppEngine.GetRequiredService <ProposalEngine>();
SearchCommand = new AsyncRelayCommand(SearchAsync);
GoSourceCommand = new RelayCommand(GoSource);
SetAndSearchCommand = new AsyncRelayCommand <string>(SetAndSearchAsync);
ResetCommand = new RelayCommand(Reset);
SetCurrentCommand = new RelayCommand <ComicSnapshotInfo <TSourceInfo> >(SetCurrent);
CopyCommand = new RelayCommand <string>(Copy);
scope = AppEngine.CreateScope();
observableCollectionFactory = AppEngine.GetRequiredService <IObservableCollectionFactory>();
SearchProviders = observableCollectionFactory.Create <ISearchProvider>();
foreach (var item in SearchEngine)
{
var sp = (ISearchProvider)scope.ServiceProvider.GetRequiredService(item);
SearchProviders.Add(sp);
}
CurrentSearchProvider = SearchProviders.FirstOrDefault();
Snapshots = observableCollectionFactory.Create <ComicSnapshotInfo <TSourceInfo> >();
ProposalSnapshots = observableCollectionFactory.Create <ComicSnapshotInfo <TSourceInfo> >();
EngineIcons = observableCollectionFactory.Create <EngineInfo <TImage> >();
}
public async Task <ComicDetail> StoreAsync()
{
KeepingAction?.Invoke(null, null, null, null, KeepingActionTypes.BeginGetEntity);
OnBeginGetEntity();
var entity = await Provider.GetChaptersAsync(Address);
try
{
if (entity is null)
{
return(null);
}
var detail = new ComicDetail {
Entity = entity
};
var cwps = new List <ChapterWithPage>(entity.Chapters.Length);
foreach (var item in entity.Chapters)
{
if (tokenSource.IsCancellationRequested)
{
break;
}
KeepingAction?.Invoke(entity, item, null, null, KeepingActionTypes.BeginStoreChapter);
OnBeginStoreChapter(entity, item);
try
{
var cwp = await StoreChapterAsync(entity, item);
cwps.Add(cwp);
}
catch (Exception ex)
{
KeepingAction?.Invoke(entity, item, null, ex, KeepingActionTypes.StoreChapterException);
OnStoreChapterException(entity, item, ex);
}
KeepingAction?.Invoke(entity, item, null, null, KeepingActionTypes.EndStoreChapter);
OnEndStoreChapter(entity, item);
}
if (!tokenSource.IsCancellationRequested)
{
var streamManager = AppEngine.GetRequiredService <RecyclableMemoryStreamManager>();
var str = JsonHelper.Serialize(detail);
var buffer = Encoding.UTF8.GetBytes(str);
var path = ComicIndexName;
using (var stream = streamManager.GetStream())
{
stream.Write(buffer, 0, buffer.Length);
stream.Seek(0, SeekOrigin.Begin);
await storeService.SaveAsync(path, stream);
}
}
return(detail);
}
finally
{
KeepingAction?.Invoke(entity, null, null, null, KeepingActionTypes.EndGetEntity);
OnEndGetEntity(entity);
}
}
public void Watch()
{
if (!(Condition is null))
{
var navSer = AppEngine.GetRequiredService <IComicTurnPageService>();
navSer.GoSource(this);
}
}
public HomePage()
{
var setting = AppEngine.GetRequiredService <AnfSettings>();
vm = new DesktopHomeViewModel(setting);
InitializeComponent();
DataContext = vm;
AppEngine.GetRequiredService <MainWindow>().BindDecorationMargin(this);
}
public SettingsControlView()
{
DataContext = this;
AnfSettings = AppEngine.GetRequiredService <AnfSettings>();
ThemeSettings = AnfSettings.Theme;
ReadingSettings = AnfSettings.Reading;
PerformaceSettings = AnfSettings.Performace;
InitializeComponent();
}
protected override void OnCurrentComicSnapshotChanged(ComicSnapshotInfo <WithImageStorableComicSourceInfo <ImageBox, ImageBox> > info)
{
if (info is WithImageComicSnapshotInfo <ImageBox, ImageBox> sn)
{
var navSer = AppEngine.GetRequiredService <UnoNavigationService>();
navSer.Navigate(typeof(ComicView), sn);
//var vm = new UnoComicViewModel(info.Snapshot, sn.LogoImage.Image);
//navSer.Navigate(new ComicView { DataContext = vm });
}
}
public BookshelfViewModel()
{
StoreService = AppEngine.GetRequiredService <ComicStoreService <TStoreBox> >();
observableCollectionFactory = AppEngine.GetRequiredService <IObservableCollectionFactory>();
NextCommand = new RelayCommand(Next);
FlushCommand = new RelayCommand(Load);
RemoveCommand = new RelayCommand(Remove);
UpdateCommand = new AsyncRelayCommand(UpdateAsync);
StoreBoxs = observableCollectionFactory.Create <TStoreBox>();
Load();
}
protected override void OnCurrentComicSnapshotChanged(ComicSnapshotInfo <WithImageStorableComicSourceInfo <Bitmap, Bitmap> > info)
{
if (info is WithImageComicSnapshotInfo <Bitmap, Bitmap> sn)
{
var vm = new DesktopComicViewModel(info.Snapshot, sn.LogoImage);
var navSer = AppEngine.GetRequiredService <MainNavigationService>();
var c = navSer.Navigate <ComicView>();
c.DataContext = vm;
}
}
public VisitingControlView()
{
this.InitializeComponent();
titleService = AppEngine.GetRequiredService <UnoTtileService>();
//foreach (var item in Children)
//{
// if (item is Button btn)
// {
// btn.Bind(TemplatedControl.FontSizeProperty, new Binding(nameof(TitleService.AdviseFontSize)) { Source = titleService });
// }
//}
}
public StorableComicSourceInfo(ComicSnapshot snapshot,
ComicSource source,
IComicSourceCondition condition,
TStoreBox storeBox)
: base(snapshot, source, condition)
{
StoreBox = storeBox;
HasBox = storeBox != null;
CanStore = condition != null;
ToggleSuperFavoriteCommand = new RelayCommand(ToggleSuperFavorite);
AddCommand = new AsyncRelayCommand(AddAsync);
RemoveCommand = new RelayCommand(Remove);
ToggleCommand = new AsyncRelayCommand(ToggleAsync);
StoreService = AppEngine.GetRequiredService <ComicStoreService <TStoreBox> >();
}
public async Task <Stream> StoreStreamAsync(string address)
{
var stream = StreamManager.GetStream();
var zip = new ZipArchive(stream, ZipArchiveMode.Update, true);
using (var zipSave = new ZipStoreService(zip))
{
var defaultStore = AppEngine.GetRequiredService <IStoreService>();
var keeper = ComicKeeper.FromDefault(address, zipSave, defaultStore);
await keeper.StoreAsync();
}
await stream.FlushAsync();
stream.Seek(0, SeekOrigin.Begin);
return(stream);
}
public async Task <TImage> GetAsync(string address)
{
if (EnableCache)
{
var bitmap = await StoreFetchHelper.GetOrFromCacheAsync <TResource, TImage>(address, () => provider.GetImageStreamAsync(address));
return(bitmap);
}
else
{
var convert = AppEngine.GetRequiredService <IStreamImageConverter <TImage> >();
using (var mem = await provider.GetImageStreamAsync(address))
{
return(await convert.ToImageAsync(mem));
}
}
}
private async void LoadVm(string address)
{
vm = new UnoVisitingViewModel();
DataContext = vm;
var titleBar = new VisitingControlView {
DataContext = vm
};
var appBar = AppEngine.GetRequiredService <AppBarService>();
appBar.GetAsDefault()
.Lefts.Add(titleBar);
try
{
await vm.InitAsync(address);
}
catch (Exception ex)
{
vm.ExceptionService.Exception = ex;
}
}
internal void RunInitAll()
{
navSer = AppEngine.GetRequiredService <MainNavigationService>();
var titleSer = AppEngine.GetRequiredService <TitleService>();
exSer = AppEngine.GetRequiredService <ExceptionService>();
var settings = AppEngine.GetRequiredService <AnfSettings>();
mainPlan = this.Get <Panel>("MainPlan");
var titleBar = this.Get <Border>("TitleBar");
var exBorder = this.Get <Border>("ExcetionBorder");
mainPlan.Children.Add(navSer.border);
titleBar.DataContext = titleSer;
titleBar.Bind(HeightProperty, new Binding(nameof(TitleService.OffsceneHeight))
{
Source = titleSer
});
exBorder.DataContext = exSer;
exBorder.KeyDown += ExBorder_KeyDown;
this.Bind(MinWidthProperty, new Binding(nameof(WindowSettings.MinWidth))
{
Source = settings.Window
});
this.Bind(MinHeightProperty, new Binding(nameof(WindowSettings.MinHeight))
{
Source = settings.Window
});
this.Bind(TopmostProperty, new Binding(nameof(WindowSettings.Topmost))
{
Source = settings.Window
});
this.Get <Border>("WraperExcetionBorder")
.DataContext = settings;
}
public override void OnFrameworkInitializationCompleted()
{
if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
{
AppEngine.Services.AddSingleton(desktop);
AppEngine.Services.AddSingleton <MainWindow>();
AppEngine.Provider.UseKnowEngines();
var nav = AppEngine.GetRequiredService <MainNavigationService>();
var mainWin = AppEngine.GetRequiredService <MainWindow>();
var titleSer = AppEngine.GetRequiredService <TitleService>();
_ = AppEngine.GetRequiredService <AnfSettings>();
mainWin.Icon = new WindowIcon("Anf.ico");
desktop.MainWindow = mainWin;
titleSer.Bind(mainWin);
titleSer.CreateControls();
mainWin.KeyDown += OnMainWinKeyDown;
//nav.Navigate(new VisitingView());
nav.Navigate <HomePage>();
AppEngine.GetRequiredService <ThemeService>();
mainWin.RunInitAll();
}
base.OnFrameworkInitializationCompleted();
}
public static async Task <string> PickSaveAsync(this Bitmap bitmap, string name)
{
var win = AppEngine.GetRequiredService <MainWindow>();
var mgr = AppEngine.GetRequiredService <RecyclableMemoryStreamManager>();
var dig = new SaveFileDialog();
dig.InitialFileName = name;
var res = await dig.ShowAsync(win);
if (res != null)
{
using (var stream = mgr.GetStream())
{
bitmap.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
using (var fs = File.Open(res, FileMode.Create))
{
await stream.CopyToAsync(fs);
}
}
}
return(res);
}
public ComicView()
{
InitializeComponent();
binder = AppEngine.GetRequiredService <MainWindow>().BindDecorationMargin(this);
}
private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
{
var exSer = AppEngine.GetRequiredService <ExceptionService>();
exSer.Exception = e.ExceptionObject as Exception;
}
public void Copy()
{
AppEngine.GetRequiredService <IPlatformService>()
.Copy(Condition.Address.AbsoluteUri);
}
public async void Open()
{
await AppEngine.GetRequiredService <IPlatformService>()
.OpenAddressAsync(Condition.Address.AbsoluteUri);
}
protected override ComicSnapshotInfo <WithImageStorableComicSourceInfo <Bitmap, Bitmap> > CreateSnapshotInfo(ComicSnapshot info)
{
var httpClient = AppEngine.GetRequiredService <INetworkAdapter>();
return(new WithImageComicSnapshotInfo <Bitmap, Bitmap>(info, httpClient));
}
public MAUIHomeViewModel()
{
AnfSettings = AppEngine.GetRequiredService <AnfSettings>();
this.networkAdapter = AppEngine.GetRequiredService <INetworkAdapter>();
}
private void BackButton_Click(object sender, RoutedEventArgs e)
{
var navSer = AppEngine.GetRequiredService <UnoNavigationService>();
navSer.GoBack();
}
private void OnFavoriteButtonClick(object sender, RoutedEventArgs e)
{
var navSer = AppEngine.GetRequiredService <UnoNavigationService>();
//navSer.Navigate<BookshelfView>();
}
public BookshelfView()
{
InitializeComponent();
DataContext = vm = new DesktopBookshelfViewModel();
AppEngine.GetRequiredService <MainWindow>().BindDecorationMargin(this);
}
