public static void ClassInit(TestContext context)
{
serviceProvider = TestStartup.ConfigureServices();
pageProvider = serviceProvider.GetRequiredService <IPageProvider>();
forumAdapterFactory = serviceProvider.GetRequiredService <ForumAdapterFactory>();
}
public PageController(ITemplateTypeProvider templateProvider, IWidgetTypeProvider widgetProvider, IPageTemplateProvider pageTemplateProvider, IPageProvider pageProvider)
{
this.templateProvider = templateProvider;
this.widgetProvider = widgetProvider;
this.pageTemplateProvider = pageTemplateProvider;
this.pageProvider = pageProvider;
}
/// <summary>
/// Public function to check for identifiable forums from a provided web page.
/// </summary>
/// <param name="uri">The URI being checked. Cache the host so we don't have to verify again.</param>
/// <param name="token">Cancellation token for loading page.</param>
/// <returns>Returns the forum type that was identified, if any.</returns>
public static async Task <ForumType> IdentifyForumTypeAsync(Uri?uri, IPageProvider pageProvider, CancellationToken token)
{
if (uri == null)
{
return(ForumType.Unknown);
}
if (!forumTypes.TryGetValue(uri.Host, out ForumType forumType))
{
var doc = await GetDocumentAsync(uri, pageProvider, token).ConfigureAwait(false);
if (doc == null)
{
ArgumentException e = new ArgumentException($"Unable to load forum URL: {uri.AbsoluteUri}");
e.Data["Notify"] = true;
throw e;
}
forumType = IdentifyForumTypeFromHtmlDocument(doc);
forumTypes[uri.Host] = forumType;
}
return(forumType);
}
public static void Create <T, TColl>(int pageSize
, IPageProvider <T, TColl> pageProvider
, ICountProvider countProvider
, Action <TColl> created
) where T : new() where TColl : IList <T>, new()
{
if (null == countProvider)
{
throw new ArgumentNullException("countProvider");
}
if (null == pageProvider)
{
throw new ArgumentNullException("pageProvider");
}
countProvider.CountAvailable += (s, e)
=>
{
var collection = new TColl();
HashSet <int> fetchingPages = new HashSet <int>();
var data = new { Count = 0 };
for (int i = 0; i < e.Count; i += pageSize)
{
var t = ProxyFactory.CreateProxy <T>(new PageInterceptor <T, TColl>(pageProvider, pageSize, collection));
(t as IPageableElement).PageIndex = i / pageSize;
for (int j = i; j < i + pageSize && j < e.Count; ++j)
{
collection.Add(t);
}
}
created(collection);
};
countProvider.GetCount();
}
/// <summary>
/// Get the HTML document for the specified URI.
/// </summary>
/// <param name="uri">The URI to load.</param>
/// <param name="token">The cancellation token.</param>
/// <returns>Returns the requested page, if found. Otherwise, null.</returns>
private async static Task <HtmlDocument?> GetDocumentAsync(Uri uri, IPageProvider pageProvider, CancellationToken token)
{
HtmlDocument?page = null;
try
{
page = await pageProvider.GetHtmlDocumentAsync(uri.AbsoluteUri, uri.Host,
CachingMode.UseCache, ShouldCache.Yes, SuppressNotifications.Yes, token)
.ConfigureAwait(false);
if (token.IsCancellationRequested)
{
page = null;
}
}
catch (OperationCanceledException)
{
}
catch (Exception e)
{
Logger2.LogError(e, "Attempt to query site to determine forum adapter failed.");
}
return(page);
}
public CheckingPageVersionRequestMiddleware(
ISiteRequestAccessor siteRequest,
IPageProvider pageProvider)
{
_siteRequest = siteRequest;
_pageProvider = pageProvider;
}
/// <summary>
/// Gets the range of post numbers to tally, for the given quest.
/// This may require loading information from the site.
/// </summary>
/// <param name="quest">The quest being tallied.</param>
/// <param name="pageProvider">The page provider to use to load any needed pages.</param>
/// <param name="token">The cancellation token to check for cancellation requests.</param>
/// <returns>Returns a ThreadRangeInfo describing which pages to load for the tally.</returns>
public async Task <ThreadRangeInfo> GetQuestRangeInfoAsync(IQuest quest, IPageProvider pageProvider, CancellationToken token)
{
if (quest == null)
{
throw new ArgumentNullException(nameof(quest));
}
if (pageProvider == null)
{
throw new ArgumentNullException(nameof(pageProvider));
}
// Use the provided start post if we aren't trying to find the threadmarks.
if (!quest.CheckForLastThreadmark)
{
return(new ThreadRangeInfo(true, quest.StartPost));
}
var(foundThreadmark, rangeInfo) = await TryGetRSSThreadmarksRange(quest, pageProvider, token);
if (foundThreadmark)
{
return(rangeInfo);
}
(foundThreadmark, rangeInfo) = await TryGetThreadmarksRange(quest, pageProvider, token);
if (foundThreadmark)
{
return(rangeInfo);
}
// If we get here, just fall back on default start post.
return(new ThreadRangeInfo(true, quest.StartPost));
}
public static IObservable<ScrollRequest> ToScrollRequest(this IObservable<KeyboardNavigationType> source, IPageProvider pageProvider )
{
return source.Select(keys =>
{
var size = pageProvider.PageSize;
var firstIndex = pageProvider.FirstIndex;
switch (keys)
{
case KeyboardNavigationType.Up:
return new ScrollRequest(ScrollReason.User, size, firstIndex - 1);
case KeyboardNavigationType.Down:
return new ScrollRequest(ScrollReason.User, size, firstIndex + 1);
case KeyboardNavigationType.PageUp:
return new ScrollRequest(ScrollReason.User, size, firstIndex - size);
case KeyboardNavigationType.PageDown:
return new ScrollRequest(ScrollReason.User, size, firstIndex + size);
case KeyboardNavigationType.Home:
return new ScrollRequest(ScrollReason.User, size, 0);
case KeyboardNavigationType.End:
return new ScrollRequest(size);
default:
throw new ArgumentOutOfRangeException(nameof(keys), keys, null);
}
});
}
/// <summary>
/// Collects the posts out of a quest based on the quest's configuration.
/// </summary>
/// <param name="quest">The quest to read.</param>
/// <param name="pageProvider">The page provider to use to read this quest.</param>
/// <param name="token">The cancellation token.</param>
/// <returns>Returns a list of posts extracted from the quest.</returns>
private async Task <(string threadTitle, List <Post> posts)> ReadQuestAsyncImpl(
IQuest quest, IPageProvider pageProvider, CancellationToken token)
{
logger.LogDebug($"Reading quest {quest.DisplayName} with ForumReader.");
IForumAdapter2 adapter = await forumAdapterFactory.CreateForumAdapterAsync(quest, pageProvider, token).ConfigureAwait(false);
logger.LogDebug($"Forum adapter created for {quest.DisplayName}.");
SyncQuestWithForumAdapter(quest, adapter);
logger.LogDebug($"Quest {quest.DisplayName} synced with forum adapter.");
ThreadRangeInfo rangeInfo = await GetStartInfoAsync(quest, adapter, pageProvider, token).ConfigureAwait(false);
logger.LogDebug($"Range info acquired for {quest.DisplayName}. ({rangeInfo})");
List <Task <HtmlDocument?> > loadingPages = await LoadQuestPagesAsync(quest, adapter, rangeInfo, pageProvider, token).ConfigureAwait(false);
logger.LogDebug($"Got {loadingPages.Count} pages loading {quest.DisplayName}.");
var(threadInfo, posts2) = await GetPostsFromPagesAsync(loadingPages, quest, adapter, rangeInfo).ConfigureAwait(false);
logger.LogDebug($"Got {posts2.Count} posts for quest {quest.DisplayName}.");
List <Post> filteredPosts = FilterPosts(posts2, quest, threadInfo, rangeInfo);
logger.LogDebug($"Filtered to {filteredPosts.Count} posts for quest {quest.DisplayName}.");
return(threadInfo.Title, filteredPosts);
}
/// <summary>
/// Acquire a list of page loading tasks for the pages that are intended
/// to be tallied.
/// </summary>
/// <param name="quest">The quest for which the tally is being run.</param>
/// <param name="adapter">The forum adapter that handles the quest's thread.</param>
/// <param name="threadRangeInfo">The range of posts that are wanted in the tally.</param>
/// <param name="token">A cancellation token.</param>
/// <returns>Returns a list of page loading tasks.</returns>
private async Task <List <Task <HtmlDocument?> > > LoadQuestPagesAsync(
IQuest quest, IForumAdapter2 adapter, ThreadRangeInfo threadRangeInfo, IPageProvider pageProvider, CancellationToken token)
{
int firstPageNumber = threadRangeInfo.GetStartPage(quest);
// Get the first page in order to find out how many pages are in the thread
// Keep it as a task.
Task <HtmlDocument?> firstPage = GetFirstPage(firstPageNumber, quest, adapter, pageProvider, token);
// Get the last page number.
int lastPageNumber = await GetLastPageNumber(quest, adapter, threadRangeInfo, firstPage).ConfigureAwait(false);
// Initiate tasks for any remaining pages
IEnumerable <Task <HtmlDocument?> > remainingPages =
GetRemainingPages(firstPageNumber, lastPageNumber, quest, adapter, pageProvider, token);
// Collect all the page load tasks (including the finished first page) to return to caller.
List <Task <HtmlDocument?> > pagesToLoad = new List <Task <HtmlDocument?> >()
{
firstPage
};
pagesToLoad.AddRange(remainingPages);
return(pagesToLoad);
}
/// <summary>
/// Get the HTML document for the specified URI.
/// </summary>
/// <param name="uri">The URI to load.</param>
/// <param name="token">The cancellation token.</param>
/// <returns>Returns the requested page, if found. Otherwise, null.</returns>
private async static Task <HtmlDocument> GetDocumentAsync(Uri uri, CancellationToken token)
{
IPageProvider pageProvider = ViewModels.ViewModelService.MainViewModel.PageProvider;
try
{
HtmlDocument page = await pageProvider.GetPage(uri.AbsoluteUri, uri.Host,
CachingMode.UseCache, ShouldCache.Yes, SuppressNotifications.No, token)
.ConfigureAwait(false);
if (token.IsCancellationRequested)
{
return(null);
}
return(page);
}
catch (OperationCanceledException)
{
return(null);
}
catch (Exception e)
{
ErrorLog.Log(e);
return(null);
}
}
public PageController(ITemplateTypeProvider templateProvider, IWidgetTypeProvider widgetProvider, IPageTemplateProvider pageTemplateProvider, IPageProvider pageProvider)
{
this.templateProvider = templateProvider;
this.widgetProvider = widgetProvider;
this.pageTemplateProvider = pageTemplateProvider;
this.pageProvider = pageProvider;
}
/// <summary>
/// Loads the HTML pages that are relevant to a quest's tally.
/// </summary>
/// <param name="quest">The quest being loaded.</param>
/// <param name="adapter">The quest's forum adapter, used to forum the URLs to load.</param>
/// <param name="threadRangeInfo">The range info that determines which pages to load.</param>
/// <param name="token">The cancellation token.</param>
/// <returns>Returns a list of tasks that are handling the async loading of the requested pages.</returns>
private async Task <List <Task <HtmlDocument> > > LoadQuestPagesAsync(
IQuest quest, IForumAdapter adapter, ThreadRangeInfo threadRangeInfo, CancellationToken token)
{
var scanInfo = await GetPagesToScanAsync(quest, adapter, threadRangeInfo, token).ConfigureAwait(false);
int firstPageNumber = scanInfo.Item1;
int lastPageNumber = scanInfo.Item2;
int pagesToScan = scanInfo.Item3;
// We will store the loaded pages in a new List.
List <Task <HtmlDocument> > pages = new List <Task <HtmlDocument> >();
IPageProvider pageProvider = ViewModels.ViewModelService.MainViewModel.PageProvider;
// Initiate the async tasks to load the pages
if (pagesToScan > 0)
{
// Initiate tasks for all pages other than the first page (which we already loaded)
var results = from pageNum in Enumerable.Range(firstPageNumber, pagesToScan)
let pageUrl = adapter.GetUrlForPage(pageNum, quest.PostsPerPage)
let shouldCache = (pageNum == lastPageNumber) ? ShouldCache.No : ShouldCache.Yes
select pageProvider.GetPage(pageUrl, $"Page {pageNum}", CachingMode.UseCache, shouldCache, SuppressNotifications.No, token);
pages.AddRange(results.ToList());
}
return(pages);
}
public FrontUserPageSectionController(IContentTypeProvider contentTypeProvider
, IPageSectionTypeProvider pageSectionTypeProvider
, IPageSectionDataTypeProvider pageSectionDataTypeProvider
, IFrontUserPageSectionProvider frontUserPageSectionProvider
, IPageSectionProvider pageSectionProvider
, IFrontUserPageProvider frontUserPageProvider
, IMasterListProvider masterListProvider
, IMasterProvider masterProvider
, ICheckProvider checkProvider
, IClaimCheck claimCheck
, IPageProvider pageProvider
, Microsoft.AspNetCore.Identity.UserManager <SIPx.API.Models.SipUser> userManager)
{
_masterProvider = masterProvider;
_contentTypeProvider = contentTypeProvider;
_pageSectionTypeProvider = pageSectionTypeProvider;
_pageSectionDataTypeProvider = pageSectionDataTypeProvider;
_frontUserPageSectionProvider = frontUserPageSectionProvider;
_pageSectionProvider = pageSectionProvider;
_frontUserPageProvider = frontUserPageProvider;
_masterListProvider = masterListProvider;
_checkProvider = checkProvider;
_claimCheck = claimCheck;
_pageProvider = pageProvider;
_userManager = userManager;
}
public MainViewModel(QuestCollectionWrapper config, HttpClientHandler handler,
IPageProvider pageProvider, ITextResultsProvider textResults,
IErrorLogger errorLogger, Func <string, CompareInfo, CompareOptions, int> hashFunction)
{
ErrorLog.LogUsing(errorLogger);
Agnostic.HashStringsUsing(hashFunction);
if (config != null)
{
QuestList = config.QuestCollection;
QuestList.Sort();
SelectQuest(config.CurrentQuest);
}
else
{
QuestList = new QuestCollection();
SelectQuest(null);
}
SetupNetwork(pageProvider, handler);
SetupTextResults(textResults);
AllVotesCollection = new ObservableCollectionExt <string>();
AllVotersCollection = new ObservableCollectionExt <string>();
BuildCheckForNewRelease();
BuildTally();
BindVoteCounter();
SetupCommands();
}
void Start()
{
pageProvider = GetComponent <IPageProvider>();
if (pageProvider == null)
{
throw new System.NullReferenceException(
"PagedScrollRect is missing an IPageProvider. " +
"Please look at IPageProvider.cs for details.");
}
scrollEffects = GetComponents <BaseScrollEffect>();
if (scrollEffects.Length == 0)
{
Debug.LogWarning(
"PagedScrollRect does not have any BaseScrollEffects. " +
"Adding defaults.");
gameObject.AddComponent <TranslateScrollEffect>();
gameObject.AddComponent <FadeScrollEffect>();
scrollEffects = GetComponents <BaseScrollEffect>();
}
if (!onlyScrollWhenPointing)
{
CanScroll = true;
}
// Immediately snap to the starting page.
SnapToPage(StartPage, true, true);
}
public static object Resource(string language, string resourceName)
{
//Todo: Clean
// Get the cache
Cache cache = HttpContext.Current.Cache;
if (cache["Resources"] == null)
{
cache.Insert("Resources", new Dictionary <string, Dictionary <string, string> >());
}
var resources = (Dictionary <string, Dictionary <string, string> >)cache.Get("Resources");
Dictionary <string, string> languageSpecificResources;
if (!resources.ContainsKey(language))
{
// create the whole resources dictionary for the specified language
string resourceFile = ConfigurationManager.AppSettings["ResourcePath"];
string resourcePagePath = String.Format("/{0}/{1}", language, resourceFile);
IPageProvider provider = DependencyResolver.Current.GetService <IPageProvider>();
IPageFactory factory = DependencyResolver.Current.GetService <IPageFactory>();
factory.PageProvider = provider;
var resourcesPage = factory.FindPage(resourcePagePath);
languageSpecificResources = new Dictionary <string, string>();
foreach (IComponentPresentation componentPresentation in resourcesPage.ComponentPresentations)
{
foreach (IFieldSet fieldSet in componentPresentation.Component.Fields["Resource"].EmbeddedValues)
{
if (languageSpecificResources.ContainsKey(fieldSet["Key"].Value))
{
throw new DuplicateNameException(String.Format("Duplicate key found for key name: {0}", fieldSet["Key"].Value));
}
languageSpecificResources.Add(fieldSet["Key"].Value, fieldSet["Value"].Value);
}
}
// add the dictionary to the main resources dictionary in the cache
resources.Add(language, languageSpecificResources);
}
else
{
languageSpecificResources = resources[language];
}
if (languageSpecificResources.ContainsKey(resourceName))
{
return(languageSpecificResources[resourceName]);
}
return(String.Format("[{0}]", resourceName));
}
private void InitializePageCascading(IPageProvider filePageProvider, Page page)
{
this.Add(filePageProvider.Get(page));
foreach (var item in filePageProvider.ChildPages(page))
{
InitializePageCascading(filePageProvider, item);
}
}
public Tally(IPageProvider pageProvider, IVoteCounter voteCounter)
{
VoteCounter = voteCounter ?? throw new ArgumentNullException(nameof(voteCounter));
// Hook up to event notifications
pageProvider.StatusChanged += PageProvider_StatusChanged;
AdvancedOptions.Instance.PropertyChanged += Options_PropertyChanged;
}
private void ExportPageCascading(IPageProvider filePageProvider, Page page)
{
filePageProvider.Add(page);
foreach (var item in this.ChildPages(page))
{
ExportPageCascading(filePageProvider, item);
}
}
/// <summary>
/// Gets the thread range info (page and post numbers) based on the quest configuration.
/// May load pages (such as for checking threadmarks), so will use the ViewModel's page provider.
/// </summary>
/// <param name="quest">The quest we're getting thread info for.</param>
/// <param name="adapter">The quest's forum adapter.</param>
/// <param name="token">The cancellation token.</param>
/// <returns>Returns the quest's thread range info.</returns>
private async Task <ThreadRangeInfo> GetStartInfoAsync(IQuest quest, IForumAdapter adapter, CancellationToken token)
{
IPageProvider pageProvider = ViewModels.ViewModelService.MainViewModel.PageProvider;
ThreadRangeInfo rangeInfo = await adapter.GetStartingPostNumberAsync(quest, pageProvider, token).ConfigureAwait(false);
return(rangeInfo);
}
public PagesController(
IPageService service,
IPageProvider provider,
ILogger <PagesController> logger)
: base(logger)
{
_service = service;
_provider = provider;
}
public PageMap(IPageProvider <TData> source, IRange <int> range)
{
_source = source;
if (ReferenceEquals(null, _source))
{
throw new ArgumentException();
}
SetBounds(range);
}
public PageMap(IPageProvider <TData> source, int first, int last)
{
_source = source;
if (ReferenceEquals(null, _source))
{
throw new ArgumentException();
}
SetBounds(first, last);
}
public static T Create <T>(IPageProvider <TData> source, IRange <int> range) where T : PageMap <TData>
{
if (ReferenceEquals(typeof(T), typeof(PageMap <TData>)))
{
return(new PageMap <TData>(source, range) as T);
}
throw new NotSupportedException("type not supported");
}
private void ExportAsFileCascading(IPageProvider filePageProvider, Page page)
{
page = Get(page);
filePageProvider.Add(page);
foreach (var item in ChildPages(page))
{
ExportAsFileCascading(filePageProvider, item);
}
}
public void Bind(IPageProvider <TData> pageProvider)
{
_chain = new Chain <PageMap <TData>, TData>(
pageProvider,
new []
{
new PageMap <TData>(pageProvider, new Range <int>()),
new PageMap <TData>(pageProvider, new Range <int>()),
});
}
public PublishingManager(IPageProvider provider, TextContentManager textContentManager,
LocalPublishingQueueManager localPublishingQueueManager, RemotePublishingQueueManager remotePublishingQueueManager, PageManager pageManager, IPublishingLogProvider publishingLogProvider)
{
this._provider = provider;
this._textContentManager = textContentManager;
this._localPublishingQueueManager = localPublishingQueueManager;
this._remotePublishingQueueManager = remotePublishingQueueManager;
this._pageManager = pageManager;
this._publishingLogProvider = publishingLogProvider;
}
public PublishingManager(IPageProvider provider, TextContentManager textContentManager,
LocalPublishingQueueManager localPublishingQueueManager, RemotePublishingQueueManager remotePublishingQueueManager, PageManager pageManager, IPublishingLogProvider publishingLogProvider)
{
this._provider = provider;
this._textContentManager = textContentManager;
this._localPublishingQueueManager = localPublishingQueueManager;
this._remotePublishingQueueManager = remotePublishingQueueManager;
this._pageManager = pageManager;
this._publishingLogProvider = publishingLogProvider;
}
public PageInterceptor(IPageProvider <T, TColl> pageFiller
, int pageSize
, TColl collection
)
{
this.pageFiller = pageFiller;
this.pageSize = pageSize;
this.collection = collection;
}
public PageController(IPageProvider pageProvider, ILogger logger)
{
if (pageProvider == null)
throw new ArgumentNullException("pageProvider");
if (logger == null)
throw new ArgumentNullException("logger");
PageProvider = pageProvider;
Logger = logger;
}
/// <summary>
/// Initializes a new instance of the <see cref="NavigationManager{TPageIdentifier}"/> class.
/// To gather page definitions it searches for classes marked with <see cref="NavigationPageAttribute"/> from <see cref="Assembly.GetCallingAssembly"/>
/// </summary>
/// <param name="fragmentManager">Fragment manager of main activity.</param>
/// <param name="rootFrame">The view which will be used as the one being replaced with new Views</param>
/// <param name="viewModelResolver">Class used to resolve ViewModels for pages derived from <see cref="FragmentBase{TViewModel}"/></param>
/// <param name="stackResolver">Class allowing to differentiate to which stack given indentigier belongs.</param>
/// <param name="interceptTransaction">Delegate allowing to modify <see cref="FragmentTransaction"/> before commiting.</param>
public NavigationManager(
FragmentManager fragmentManager,
ViewGroup rootFrame,
IViewModelResolver viewModelResolver = null,
IStackResolver <NavigationFragmentBase, TPageIdentifier> stackResolver = null,
Action <FragmentTransaction> interceptTransaction = null)
: base(stackResolver)
{
_fragmentManager = fragmentManager;
_rootFrame = rootFrame;
_interceptTransaction = interceptTransaction;
NavigationFragmentBase.ViewModelResolver = viewModelResolver;
var types = Assembly.GetCallingAssembly().GetTypes();
foreach (var type in types)
{
var attr = type.GetTypeInfo().GetCustomAttribute <NavigationPageAttribute>();
if (attr != null)
{
IPageProvider <NavigationFragmentBase> provider = null;
switch (attr.PageProviderType)
{
case NavigationPageAttribute.PageProvider.Cached:
provider = ObtainProviderFromType(typeof(CachedPageProvider <>));
break;
case NavigationPageAttribute.PageProvider.Oneshot:
provider = ObtainProviderFromType(typeof(OneshotPageProvider <>));
break;
default:
throw new ArgumentOutOfRangeException();
}
PageDefinitions.Add((TPageIdentifier)(object)attr.Page, provider);
}
IPageProvider <NavigationFragmentBase> ObtainProviderFromType(Type providerType)
{
return((IPageProvider <NavigationFragmentBase>)providerType.MakeGenericType(type)
.GetConstructor(new Type[] { })
.Invoke(null));
}
}
foreach (var pageDefinition in PageDefinitions)
{
pageDefinition.Value.PageIdentifier = pageDefinition.Key;
}
}
public CheckingPageRequestMiddleware(
ISiteRequestAccessor siteRequestAccessor,
ISiteRouteProvider siteRouteProvider,
IThemeProvider themeProvider,
IPageProvider pageProvider)
{
_siteRequestAccessor = siteRequestAccessor;
_siteRouteProvider = siteRouteProvider;
_pageProvider = pageProvider;
_themeProvider = themeProvider;
}
public RemotePublishingQueueManager(IRemotePublishingQueueProvider remotePublishingQueueProvider, ICmisSession cmisSession,
PageManager pageManager, TextContentManager textContentManager, IPublishingLogProvider publishingLogProvider, IPageProvider pageProvider)
: base(remotePublishingQueueProvider)
{
this._remotePublishingQueueProvider = remotePublishingQueueProvider;
this._cmisSession = cmisSession;
this._textContentManager = textContentManager;
this._pageManager = pageManager;
this._publishingLogProvider = publishingLogProvider;
this._pageProvider = pageProvider;
}
public PageFactory(IPageProvider pageProvider, IComponentPresentationFactory componentPresentationFactory,
IFactoriesFacade facade)
: base(facade)
{
if (pageProvider == null)
throw new ArgumentNullException("pageProvider");
if (componentPresentationFactory == null)
throw new ArgumentNullException("componentPresentationFactory");
ComponentPresentationFactory = componentPresentationFactory;
PageProvider = pageProvider;
}
public InlineEditingController(IPageProvider pageProvider, ITextContentBinder binder)
{
this.PageProvider = pageProvider;
Binder = binder;
}
private void InitializePageCascading(IPageProvider filePageProvider, Page page)
{
this.Add(filePageProvider.Get(page));
foreach (var item in filePageProvider.ChildPages(page))
{
InitializePageCascading(filePageProvider, item);
}
}
private void ExportPageCascading(IPageProvider filePageProvider, Page page)
{
filePageProvider.Add(page);
foreach (var item in this.ChildPages(page))
{
ExportPageCascading(filePageProvider, item);
}
}
private void ExportAsFileCascading(IPageProvider filePageProvider, Page page)
{
page = Get(page);
filePageProvider.Add(page);
foreach (var item in ChildPages(page))
{
ExportAsFileCascading(filePageProvider, item);
}
}
public ZenitBetParser(IPageProvider provider, List<IGameParser> gameParsers)
{
this.provider = provider;
this.gameParsers = gameParsers;
}
public static void Register(IPageProvider provider)
{
providers.Add(provider);
}
void Start() {
pageProvider = GetComponent<IPageProvider>();
if (pageProvider == null) {
throw new System.NullReferenceException(
"PagedScrollRect is missing an IPageProvider. " +
"Please look at IPageProvider.cs for details.");
}
scrollEffects = GetComponents<BaseScrollEffect>();
if (scrollEffects.Length == 0) {
Debug.LogWarning(
"PagedScrollRect does not have any BaseScrollEffects. " +
"Adding defaults.");
gameObject.AddComponent<TranslateScrollEffect>();
gameObject.AddComponent<FadeScrollEffect>();
scrollEffects = GetComponents<BaseScrollEffect>();
}
if (!onlyScrollWhenPointing) {
CanScroll = true;
}
// Immediately snap to the starting page.
SnapToPage(StartPage, true);
}
public EtfSecurities(IPageProvider provider)
{
this.pageProvider = provider;
}
