public override async void Reload()
{
ILoader <BookItem> Loader = ZS.CreateLoader();
IsLoading = true;
MessageBus.Subscribe(this, MessageBus_OnDelivery);
IList <GRRow <BookDisplay> > FirstPage = (await Loader.NextPage(30)).Remap(ToGRRow);
MessageBus.Unsubscribe(this, MessageBus_OnDelivery);
Observables <BookItem, GRRow <BookDisplay> > ItemsObservable = new Observables <BookItem, GRRow <BookDisplay> >(FirstPage);
ItemsObservable.LoadEnd += (s, e) =>
{
MessageBus.Unsubscribe(this, MessageBus_OnDelivery);
IsLoading = false;
};
ItemsObservable.LoadStart += (s, e) =>
{
IsLoading = true;
MessageBus.Subscribe(this, MessageBus_OnDelivery);
};
ItemsObservable.ConnectLoader(Loader, b => b.Remap(ToGRRow));
BkTable.Items = ItemsObservable;
IsLoading = false;
}
public async void OpenCommentStack(string CommId)
{
CommInit = true;
DisplayControls(CommentControls);
CommentSection.Visibility = Visibility.Visible;
bool LoadFirst = true;
Func <SHTarget, int, uint, string[], PostData> StackRequest = (a, b, c, Ids) =>
{
if (LoadFirst)
{
LoadFirst = false;
return(Shared.ShRequest.GetCommentStack(Ids[0]));
}
return(Shared.ShRequest.GetComments(a, b, c, Ids));
};
HSLoader <HSComment> CLoader = new HSLoader <HSComment>(CommId, SHTarget.COMMENT, StackRequest)
{
ConvertResult = (x) => x.Flattern(y => y.Replies)
};
IEnumerable <HSComment> FirstPage = await CLoader.NextPage();
CommentsSource = new Observables <HSComment, HSComment>(FirstPage.ToArray());
CommentsSource.LoadStart += (x, y) => MarkLoading();
CommentsSource.LoadEnd += (x, y) => MarkNotLoading();
CommentsSource.ConnectLoader(CLoader);
CommentList.ItemsSource = CommentsSource;
}
private async void ViewFile( StorageFile file )
{
StorageFileStreamer SFS = new StorageFileStreamer( file );
IList<string> FirstRead = await SFS.NextPage( 50 );
Observables<string, string> OSF = new Observables<string, string>( FirstRead );
OSF.ConnectLoader( SFS );
TextContent.ItemsSource = OSF;
}
private async void ViewFile(StorageFile file)
{
StorageFileStreamer SFS = new StorageFileStreamer(file);
IList <string> FirstRead = await SFS.NextPage(50);
Observables <string, string> OSF = new Observables <string, string>(FirstRead);
OSF.ConnectLoader(SFS);
TextContent.ItemsSource = OSF;
}
public async Task OpenReview(Review R)
{
CommentLoader CL = new CommentLoader(
R.Id
, X.Call <XKey[]>(XProto.WRequest, "GetReplies", R.Id)
, new CommentLoader.CommentXMLParser(GetReplies)
);
IList <Comment> FirstLoad = await CL.NextPage();
Replies.ConnectLoader(CL);
Replies.UpdateSource(FirstLoad);
}
public void Reload(Func <IQueryable <Book>, IQueryable <Book> > Filter)
{
lock (this)
{
if (IsLoading)
{
return;
}
IsLoading = true;
}
StringResources stx = StringResources.Load("AppResources");
Message = stx.Text("Loading");
IQueryable <Book> Books = QuerySet(Shared.BooksDb.Books.AsQueryable());
if (Filter != null)
{
Books = Filter(Books);
}
if (!string.IsNullOrEmpty(Search))
{
Books = Books.Where(x => x.Title.Contains(Search));
}
Books = Books.Include(x => x.Info);
QueryLoader <Book> BLoader = new QueryLoader <Book>(Books, Shared.BooksDb);
Observables <Book, GRRow <BookDisplay> > ItemsObservable = new Observables <Book, GRRow <BookDisplay> >();
ItemsObservable.ConnectLoader(BLoader, x => x.Remap(ToGRRow));
ItemsObservable.LoadEnd += (s, e) => IsLoading = false;
ItemsObservable.LoadStart += (s, e) =>
{
Message = string.Format("{0} {1} / {2}", stx.Text("Loading"), BLoader.CurrentPage, BLoader.NTotal);
IsLoading = true;
};
BkTable.Items = ItemsObservable;
IsLoading = false;
}
private async void SetTwitter()
{
TwitterService.Instance.Initialize(AuthData.Token);
TwitterLoader Loader = new TwitterLoader();
Loader.Tags = new List <NameValue <bool> >();
Loader.Tags.Add(new NameValue <bool>("wenku10", true));
LoadingRing.IsActive = true;
Observables <Tweet, Tweet> Tweets = new Observables <Tweet, Tweet>(await Loader.NextPage(20));
LoadingRing.IsActive = false;
Tweets.LoadStart += (s, e) => LoadingRing.IsActive = true;
Tweets.LoadEnd += (s, e) => LoadingRing.IsActive = false;
Tweets.ConnectLoader(Loader);
TweetsView.ItemsSource = Tweets;
}
private async void ReloadComments()
{
if (0 < LoadLevel)
{
return;
}
MarkLoading();
HSLoader <HSComment> CLoader = new HSLoader <HSComment>(BindItem.Id, SHTarget.SCRIPT, Shared.ShRequest.GetComments)
{
ConvertResult = (x) => x.Flattern(y => y.Replies)
};
IList <HSComment> FirstPage = await CLoader.NextPage();
MarkNotLoading();
if (BindItem.Encrypted)
{
if (Crypt == null)
{
CommentsSource = new Observables <HSComment, HSComment>(CrippledComments(FirstPage));
CommentsSource.ConnectLoader(CLoader, CrippledComments);
}
else
{
CommentsSource = new Observables <HSComment, HSComment>(DecryptComments(FirstPage));
CommentsSource.ConnectLoader(CLoader, DecryptComments);
}
}
else
{
CommentsSource = new Observables <HSComment, HSComment>(FirstPage);
CommentsSource.ConnectLoader(CLoader);
}
CommentsSource.LoadStart += (x, y) => MarkLoading();
CommentsSource.LoadEnd += (x, y) => MarkNotLoading();
CommentList.ItemsSource = CommentsSource;
}
public override void Reload()
{
IsLoading = true;
StringResources stx = StringResources.Load("LoadingMessage");
Message = stx.Str("ProgressIndicator_Message");
IEnumerable <string> AccessTokens = new TokenManager().AuthList.Remap(x => ( string )x.Value);
SHSearchLoader SHLoader = new SHSearchLoader(Search, AccessTokens);
Observables <HubScriptItem, GRRow <HSDisplay> > OHS = new Observables <HubScriptItem, GRRow <HSDisplay> >();
OHS.ConnectLoader(SHLoader, x => x.Remap(ToGRRow));
OHS.LoadEnd += (s, e) => IsLoading = false;
OHS.LoadStart += (s, e) => IsLoading = true;
HSTable.Items = OHS;
IsLoading = false;
}
private async void ReloadRequests(SHTarget Target)
{
if (0 < LoadLevel)
{
return;
}
ReqTarget = Target;
MarkLoading();
HSLoader <SHRequest> CLoader = new HSLoader <SHRequest>(
BindItem.Id
, Target
, (_Target, _Skip, _Limit, _Ids) => Shared.ShRequest.GetRequests(_Target, _Ids[0], _Skip, _Limit)
);
CLoader.ConvertResult = xs =>
{
XParameter XParam = XGrant.Parameter(BindItem.Id);
if (XParam != null)
{
foreach (SHRequest x in xs)
{
x.Granted = XParam.FindParameter(x.Id) != null;
}
}
return(xs.ToArray());
};
IList <SHRequest> FirstPage = await CLoader.NextPage();
MarkNotLoading();
RequestsSource = new Observables <SHRequest, SHRequest>(FirstPage);
RequestsSource.ConnectLoader(CLoader);
RequestsSource.LoadStart += (x, y) => MarkLoading();
RequestsSource.LoadEnd += (x, y) => MarkNotLoading();
RequestList.ItemsSource = RequestsSource;
}
private async void ReloadTweets()
{
await AuthData.Authenticate();
TwitterLoader Loader = new TwitterLoader();
Loader.Keyword = ThisBook.Title.TrimForSearch();
Loader.Tags = TagsAvailable;
LoadingRing.IsActive = true;
Observables <Tweet, Tweet> Tweets = new Observables <Tweet, Tweet>(await Loader.NextPage(20));
Tweets.ConnectLoader(Loader);
Tweets.LoadStart += (s, e) => { LoadingRing.IsActive = true; };
Tweets.LoadEnd += (s, e) => { LoadingRing.IsActive = false; };
LoadingRing.IsActive = false;
TweetsView.ItemsSource = Tweets;
}
private async void ReloadComments()
{
if ( LoadingRing.IsActive ) return;
MarkLoading();
HSLoader<HSComment> CLoader = new HSLoader<HSComment>( BindItem.Id, SHTarget.SCRIPT, Shared.ShRequest.GetComments )
{
ConvertResult = ( x ) => x.Flattern( y => y.Replies )
};
IList<HSComment> FirstPage = await CLoader.NextPage();
MarkNotLoading();
if ( BindItem.Encrypted )
{
if ( Crypt == null )
{
CommentsSource = new Observables<HSComment, HSComment>( CrippledComments( FirstPage ) );
CommentsSource.ConnectLoader( CLoader, CrippledComments );
}
else
{
CommentsSource = new Observables<HSComment, HSComment>( DecryptComments( FirstPage ) );
CommentsSource.ConnectLoader( CLoader, DecryptComments );
}
}
else
{
CommentsSource = new Observables<HSComment, HSComment>( FirstPage );
CommentsSource.ConnectLoader( CLoader );
}
CommentsSource.LoadStart += ( x, y ) => MarkLoading();
CommentsSource.LoadEnd += ( x, y ) => MarkNotLoading();
CommentList.ItemsSource = CommentsSource;
}
public async void OpenCommentStack( string CommId )
{
CommInit = true;
DisplayControls( CommentControls );
SimpleStory.DoubleAnimation(
CommentStory, CommentSection
, "(UIElement.RenderTransform).(TranslateTransform.Y)"
, 0.25 * LayoutSettings.ScreenHeight, 0
);
SimpleStory.DoubleAnimation( CommentStory, CommentSection, "Opacity", 0, 1 );
CommentSection.Visibility = Visibility.Visible;
bool LoadFirst = true;
Func<SHTarget, int, uint, string[], PostData> StackRequest = ( a, b, c, Ids ) =>
{
if ( LoadFirst )
{
LoadFirst = false;
return Shared.ShRequest.GetCommentStack( Ids[ 0 ] );
}
return Shared.ShRequest.GetComments( a, b, c, Ids );
};
HSLoader<HSComment> CLoader = new HSLoader<HSComment>( CommId, SHTarget.COMMENT, StackRequest )
{
ConvertResult = ( x ) => x.Flattern( y => y.Replies )
};
IEnumerable<HSComment> FirstPage = await CLoader.NextPage();
CommentsSource = new Observables<HSComment, HSComment>( FirstPage.ToArray() );
CommentsSource.LoadStart += ( x, y ) => MarkLoading();
CommentsSource.LoadEnd += ( x, y ) => MarkNotLoading();
CommentsSource.ConnectLoader( CLoader );
CommentList.ItemsSource = CommentsSource;
CommentStory.Begin();
}
private async void ReloadRequests( SHTarget Target )
{
if ( LoadingRing.IsActive ) return;
ReqTarget = Target;
MarkLoading();
HSLoader<SHRequest> CLoader = new HSLoader<SHRequest>(
BindItem.Id
, Target
, ( _Target, _Skip, _Limit, _Ids ) => Shared.ShRequest.GetRequests( _Target, _Ids[0], _Skip, _Limit )
);
CLoader.ConvertResult = xs =>
{
XParameter XParam = XGrant.Parameter( BindItem.Id );
if ( XParam != null )
{
foreach ( SHRequest x in xs )
{
x.Granted = XParam.FindParameter( x.Id ) != null;
}
}
return xs.ToArray();
};
IList<SHRequest> FirstPage = await CLoader.NextPage();
MarkNotLoading();
RequestsSource = new Observables<SHRequest, SHRequest>( FirstPage );
RequestsSource.ConnectLoader( CLoader );
RequestsSource.LoadStart += ( x, y ) => MarkLoading();
RequestsSource.LoadEnd += ( x, y ) => MarkNotLoading();
RequestList.ItemsSource = RequestsSource;
}
public override void Reload()
{
if (SourceData == null)
{
string[] Lines = new string[0];
if (Shared.Storage.FileExists(Local))
{
Lines = Shared.Storage.GetString(Local).Split(new char[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
}
else if (PhaseTable != null)
{
if (PhaseTable.Table == null)
{
SourceData = new List <NameValue <string> >();
}
else
{
Lines = Encoding.UTF8.GetString(PhaseTable.Table).Split(new char[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
}
}
if (Lines.Any())
{
SourceData = Lines
.Where(x => x.Contains(','))
.Select(x =>
{
string[] s = x.Split(new char[] { ',' }, 2, StringSplitOptions.RemoveEmptyEntries);
return(new NameValue <string>(s[0], s[1]));
}).ToList();
}
if (SourceData == null)
{
return;
}
}
LargeList <NameValue <string> > Results = null;
if (!string.IsNullOrEmpty(Search))
{
if (Search[0] == '^')
{
string HSearch = Search.Substring(1);
if (!string.IsNullOrEmpty(HSearch))
{
Results = new LargeList <NameValue <string> >(SourceData.Where(x => x.Name.IndexOf(HSearch) == 0 || x.Value.IndexOf(HSearch) == 0));
}
}
else if (Search[Search.Length - 1] == '$')
{
string RSearch = Search.Substring(0, Search.Length - 1);
if (!string.IsNullOrEmpty(RSearch))
{
int RLen = RSearch.Length;
Results = new LargeList <NameValue <string> >(SourceData.Where(x =>
{
int RIndex = x.Name.Length - RLen;
if (0 < RIndex && x.Name.IndexOf(RSearch) == RIndex)
{
return(true);
}
RIndex = x.Value.Length - RLen;
if (0 < RIndex && x.Value.IndexOf(RSearch) == RIndex)
{
return(true);
}
return(false);
}));
}
}
else
{
Results = new LargeList <NameValue <string> >(SourceData.Where(x => x.Name.Contains(Search) || x.Value.Contains(Search)));
}
}
else
{
Results = new LargeList <NameValue <string> >(SourceData);
}
Observables <NameValue <string>, GRRow <NameValue <string> > > ItemsObservable = new Observables <NameValue <string>, GRRow <NameValue <string> > >();
if (Results != null)
{
ItemsObservable.ConnectLoader(Results, x => x.Remap(ToGRRow));
}
ConvTable.Items = ItemsObservable;
}
public async Task Load()
{
IsLoading = true;
CommentLoader CL = new CommentLoader(
ThisBook.Id
, X.Call<XKey[]>( "wenku8.Settings.WRequest, wenku8-protocol", "GetComments", ThisBook.Id )
, new CommentLoader.CommentXMLParser( GetReviews )
);
IList<Comment> FirstLoad = await CL.NextPage();
IsLoading = false;
Comments = new Observables<Comment, Comment>( FirstLoad );
Comments.LoadStart += ( s, e ) => IsLoading = true;
Comments.LoadEnd += ( se, e ) => IsLoading = false;
Comments.ConnectLoader( CL );
NotifyChanged( "Comments" );
SetControls( "NewComment", "Reload" );
}
public async Task Init()
{
if ( DataReady ) return;
IsLoading = true;
try
{
ZSFeedbackLoader<BookItem> ZSF = new ZSFeedbackLoader<BookItem>( PM.CreateSpider() );
Data = new Observables<BookItem, BookItem>( await ZSF.NextPage() );
Data.ConnectLoader( ZSF );
Data.LoadStart += ( s, e ) => IsLoading = true;
Data.LoadEnd += ( s, e ) => IsLoading = false;
DataReady = true;
NotifyChanged( "Data", "DataReady" );
}
finally
{
IsLoading = false;
}
}
private void BookLoaded( IList<BookItem> aList )
{
IsLoading.IsActive = false;
SCondition.Visibility
= SearchTerm.Visibility
= Visibility.Collapsed
;
Status.Visibility = Visibility.Visible;
SearchTerm.IsEnabled = false;
Status.Text = stx.Text( "Search_ResultStamp_A" )
+ " " + LL.TotalCount + " "
+ stx.Text( "Search_ResultStamp_B" );
Observables<BookItem, BookItem> ItemsObservable = new Observables<BookItem, BookItem>( aList );
ItemsObservable.LoadEnd += ( a, b ) =>
{
IsLoading.IsActive = false;
};
ItemsObservable.LoadStart += ( a, b ) =>
{
IsLoading.IsActive = true;
};
ItemsObservable.ConnectLoader( LL );
VGrid.ItemsSource = ItemsObservable;
}
