//タック選択中
void SelectedTack()
{
//あとまわし
//タックの種類によって持ってくるデータが違う
var activeTack = parent_.GetActiveScore().GetActiveTackPoint();
//違うタックが選ばれた
if ((focusObject_ != enFocusObject.focusTack) ||
((activeTack.tackId_ != lastTackId_) ||
(activeTack.parentTimelineId_ != lastParentTimelineId_)))
{
//Undoクリア
ARIMotionMainWindow.tackCmd_.Clear();
timelineType_ = (TimelineType)activeTack.timelineType_;
//Debug.Log(timelineType_.ToString());
lastParentTimelineId_ = activeTack.parentTimelineId_;
lastTackId_ = activeTack.tackId_;
focusObject_ = enFocusObject.focusTack;
selectedFrame_ = (activeTack.start_ + activeTack.span_ - 1); //タック末端
SetupPartsData(false);
}
}
public PluginLoader(PluginContext pluginContext,
ITimelineTypeRegistry timelineTypeRegistry, ISourceTypeRegistry sourceTypeRegistry,
IObjectBuilder objectBuilder, IServiceLocator serviceLocator)
{
var timelineType = new TimelineType(pluginContext.Spec, TimelineTypeName, () => DefaultDisplayName)
.WithAllowMultipleInstances(true);
timelineTypeRegistry.RegisterTimeline(timelineType);
timelineTypeRegistry.RegisterTimelineFactory(TimelineTypeName,
() => new PluginTimeline(timelineType, TimelineTypeName, TimelineTypeNames.GenericGroup,
t => t.TimelineType.GetDefaultDisplayName()));
timelineTypeRegistry
.RegisterTimelineEntityFactory(TimelineTypeName, () => new GenericSingleGroupActivity());
timelineTypeRegistry.RegisterTimelineEntityFactory(TimelineTypeName, () => new Group(null));
//register function for loading day view data
sourceTypeRegistry.RegisterDayViewLoader(SourceTypeName, objectBuilder.Build <PluginDayViewLoader>());
//register user inferface view
sourceTypeRegistry.RegisterAddTimelineViewModelFactory(SourceTypeName, serviceLocator.GetInstance <AddPluginTimelineViewModel>);
sourceTypeRegistry.RegisterSourceType(
new SourceType(SourceTypeName, () => DefaultDisplayName, 6)
.WithIcon32Path("pack://application:,,,/TimelinePlugins.Example;component/Images/SourceImage.png")
.WithGetDescription(() => "This is ManicTime timeline plugin example"));
}
private TimelineStreaming StreamTimeline(MastodonClient client, TimelineType type)
{
TimelineStreaming streaming = null;
switch (type)
{
case TimelineType.Home:
streaming = client.GetUserStreaming();
break;
default:
streaming = client.GetPublicStreaming();
break;
}
Console.WriteLine("\n\nStart fetching " + ((int)type == 0 ? "Local" : (int)type == 1 ? "Home" : "Federation") + " Timeline.");
Console.WriteLine("================================================\n\n");
streaming.OnUpdate += (sender, e) =>
{
StreamUpdateEventArgs s = type == TimelineType.Local ? !Regex.IsMatch(e.Status.Account.AccountName, ".+@.*") ? e : null : e;
if (s != null)
{
Console.WriteLine(s.Status.Account.DisplayName);
Console.WriteLine("@" + s.Status.Account.AccountName);
if (s.Status.SpoilerText != "")
{
Console.WriteLine("Note: " + s.Status.SpoilerText);
}
Console.WriteLine(HTML_Perser(s.Status.Content));
Console.WriteLine();
}
};
return(streaming);
}
public DragPoint(float start, Rectangle rect, TimelineType dragpoint, CustomSkill skill)
{
this.start = start;
this.rect = rect;
this.dragpoint = dragpoint;
this.skill = skill;
this.attackresult = null;
}
public TimelineProperty(TimelineType type, string text, params long[] accountIds)
{
Type = type;
Text = text;
if (accountIds.Length > 0)
{
AccountIds.AddRange(accountIds);
}
}
public static void Update <T>(this IEnumerable <Timeline> timelines, TimelineType type, IEnumerable <T> appendItems) where T : ITwitterItem
{
if (appendItems == null)
{
return;
}
foreach (var timeline in timelines.Where(p => p.Type == type))
{
Application.Current.Invoke(timeline.Update, appendItems);
}
}
public List <TackPoint> TimelinesByType(TimelineType timelineType)
{
foreach (var timelineTrack in timelineTracks_)
{
if (timelineTrack.timelineType_ == (int)timelineType)
{
return(timelineTrack.tackPoints_);
}
}
return(null);
}
public void OnUpdate()
{
PlayableDirector current = Type2Director(PlayingTimeline);
if (current != null)
{
if (current.state == PlayState.Paused)
{
TimelineType last_timeline = PlayingTimeline;
PlayingTimeline = TimelineType.None;
OnStopTimeline(last_timeline);
}
}
}
public void PlayTimeline(TimelineType type)
{
PlayableDirector current = Type2Director(PlayingTimeline);
if (current != null)
{
current.Stop();
}
PlayingTimeline = type;
PlayableDirector next = Type2Director(PlayingTimeline);
next.Play();
}
/**
* @private
*/
private TimelineData _ParseBinaryTimeline(TimelineType type, uint offset, TimelineData timelineData = null)
{
var timeline = timelineData != null ? timelineData : BaseObject.BorrowObject <TimelineData>();
timeline.type = type;
timeline.offset = offset;
this._timeline = timeline;
var keyFrameCount = this._timelineArrayBuffer[timeline.offset + (int)BinaryOffset.TimelineKeyFrameCount];
if (keyFrameCount == 1)
{
timeline.frameIndicesOffset = -1;
}
else
{
// One more frame than animation.
var totalFrameCount = this._animation.frameCount + 1;
var frameIndices = this._data.frameIndices;
timeline.frameIndicesOffset = frameIndices.Count;
frameIndices.ResizeList(frameIndices.Count + (int)totalFrameCount);
for (int i = 0, iK = 0, frameStart = 0, frameCount = 0; i < totalFrameCount; ++i)
{
if (frameStart + frameCount <= i && iK < keyFrameCount)
{
frameStart = this._frameArrayBuffer[this._animation.frameOffset + this._timelineArrayBuffer[timeline.offset + (int)BinaryOffset.TimelineFrameOffset + iK]];
if (iK == keyFrameCount - 1)
{
frameCount = (int)this._animation.frameCount - frameStart;
}
else
{
frameCount = this._frameArrayBuffer[this._animation.frameOffset + this._timelineArrayBuffer[timeline.offset + (int)BinaryOffset.TimelineFrameOffset + iK + 1]] - frameStart;
}
iK++;
}
frameIndices[timeline.frameIndicesOffset + i] = (uint)(iK - 1);
}
}
this._timeline = null; //
return(timeline);
}
//選択フレームのタック（投げ座標）
public TackPoint GetSelectedFrame(int selectedFrame, TimelineType timelineType)
{
//Posのタイムライン
var timeline = timelineTracks_
.Where(t => t.IsExistTimeline_)
.Where(t => t.timelineType_ == (int)timelineType)
.FirstOrDefault();
if (timeline == null)
{
return(null);
}
return(timeline.GetSelectedFrame(selectedFrame));
}
private static List <uint[][]?> BuildTimeline(TimelineType type, IReadOnlyList <IInputDevice> devices)
{
var timeline = new List <List <uint[]>?>();
for (var deviceIdx = 0; deviceIdx < devices.Count; deviceIdx++)
{
var device = devices[deviceIdx];
if (device.Purpose != EDevicePurpose.Target || (!device.SupportAborting && type == TimelineType.Abort))
{
continue;
}
var deviceUpdates = type switch
{
TimelineType.Abort => device.BuildPostAbortRawUpdates(),
TimelineType.Main => device.BuildRawUpdates(),
_ => throw new NotSupportedException($"Time line type \"{type}\" is not supported")
};
if (timeline.Count < deviceUpdates.Count)
{
timeline.AddRange(new List <uint[]>?[deviceUpdates.Count - timeline.Count]);
}
for (var updateIdx = 0; updateIdx < deviceUpdates.Count; updateIdx++)
{
var deviceUpdate = deviceUpdates[updateIdx];
if (deviceUpdate == null)
{
continue;
}
if (timeline[updateIdx] == null)
{
timeline[updateIdx] = new List <uint[]>();
}
var update = timeline[updateIdx];
#pragma warning disable CS8602 // list increased to required size
update.AddRange(deviceUpdate.Select(deviceEvent => deviceEvent.ToUintArray((uint)deviceIdx)));
#pragma warning restore CS8602
}
}
return(timeline.Select(x => x?.ToArray()).ToList());
}
/*--- Method: private -----------------------------------------------------------------------------------------------------------------------------------------*/
/// <summary> パラメータ指定されたTimelineTypeのアイテムを非表示にします。
/// </summary>
/// <param name="e"></param>
/// <param name="pTimelineType"></param>
private void setTypeFilter(FilterEventArgs e, TimelineType pTimelineType)
{
if (e.Accepted == false)
{
return;
}
var data = e.Item as TimelineActivityData;
if (data == null || data.TimelineType != pTimelineType)
{
return;
}
e.Accepted = false;
return;
}
private static bool IgnoreType(TimelineType timelineType)
{
switch (timelineType)
{
case TimelineType.You:
return(!Settings.Default.ParseYou);
case TimelineType.Party:
return(!Settings.Default.ParseParty);
case TimelineType.Alliance:
return(!Settings.Default.ParseAlliance);
case TimelineType.Other:
return(!Settings.Default.ParseOther);
}
return(false);
}
/// <summary>
/// </summary>
/// <param name="name"></param>
/// <param name="exp"></param>
/// <param name="type"></param>
/// <returns></returns>
public static string GetTaggedName(string name, Expressions exp, TimelineType type)
{
if (type == TimelineType.Unknown)
{
return(name);
}
var tag = "???";
name = name.Trim();
if (string.IsNullOrWhiteSpace(name))
{
return(string.Empty);
}
name = Regex.Replace(name, @"\[[\w]+\]", string.Empty).Trim();
var petFound = false;
foreach (var pet in _pets.Where(pet => string.Equals(pet, name, Constants.InvariantComparer)))
{
petFound = true;
}
switch (type)
{
case TimelineType.You:
tag = exp.YouString;
break;
case TimelineType.Party:
tag = "P";
break;
case TimelineType.Alliance:
tag = "A";
break;
case TimelineType.Other:
tag = "O";
break;
}
return($"[{tag}] {name}");
}
/// <summary> タイムラインタイプのフィルタを設定します。
/// </summary>
/// <param name="pOverlayDataModel"> フィルタ設定するデータモデル </param>
/// <param name="pType"> 設定するタイムラインタイプ </param>
/// <param name="pAccepted"> フィルタ追加する場合は False, フィルタ解除する場合は True </param>
public void SetTimelineTypeFilter(OverlayDataModel pOverlayDataModel, TimelineType pType)
{
switch (pType)
{
case TimelineType.UNKNOWN:
this.setFilterProcess.SetTimelineTypeFilter(
pOverlayDataModel.OverlayViewData.TimelineViewSource, pType, pOverlayDataModel.OverlayFilterSettingsData.TypeUNKNOWN);
break;
case TimelineType.ENEMY:
this.setFilterProcess.SetTimelineTypeFilter(
pOverlayDataModel.OverlayViewData.TimelineViewSource, pType, pOverlayDataModel.OverlayFilterSettingsData.TypeENEMY);
break;
case TimelineType.TANK:
this.setFilterProcess.SetTimelineTypeFilter(
pOverlayDataModel.OverlayViewData.TimelineViewSource, pType, pOverlayDataModel.OverlayFilterSettingsData.TypeTANK);
break;
case TimelineType.DPS:
this.setFilterProcess.SetTimelineTypeFilter(
pOverlayDataModel.OverlayViewData.TimelineViewSource, pType, pOverlayDataModel.OverlayFilterSettingsData.TypeDPS);
break;
case TimelineType.HEALER:
this.setFilterProcess.SetTimelineTypeFilter(
pOverlayDataModel.OverlayViewData.TimelineViewSource, pType, pOverlayDataModel.OverlayFilterSettingsData.TypeHEALER);
break;
case TimelineType.PET:
this.setFilterProcess.SetTimelineTypeFilter(
pOverlayDataModel.OverlayViewData.TimelineViewSource, pType, pOverlayDataModel.OverlayFilterSettingsData.TypePET);
break;
case TimelineType.GIMMICK:
this.setFilterProcess.SetTimelineTypeFilter(
pOverlayDataModel.OverlayViewData.TimelineViewSource, pType, pOverlayDataModel.OverlayFilterSettingsData.TypeGIMMICK);
break;
default:
return;
}
}
public static void ResetProjectParameters()
{
SelectedClientProxy = DefaultClientProxy;
SelectedPMProxy = DefaultPMProxy;
SelectedStatusFilter = DefaultStatusFilter;
SelectedProjectProxy = DefaultProjectProxy;
SelectedProjectRole = DefaultProjectRole;
SelectedClientRole = DefaultClientRole;
ProjectSourcePage = TilesPageName;
ProjectSourceMode = PageFunctions.None;
SelectedTeamTimeFilter = DefaultTeamTimeFilter;
SelectedStage = DefaultStage;
SelectedTimelineType = DefaultTimelineType;
SelectedFromDate = DefaultFromDate;
SelectedToDate = DefaultToDate;
SelectedHistory = null;
}
private void OnStopTimeline(TimelineType type)
{
switch (type)
{
case TimelineType.Idle: OnstopIdle(); break;
case TimelineType.ChargeArm: OnstopChargeArm(); break;
case TimelineType.ChargeCannon: OnstopChargeCannon(); break;
case TimelineType.ShotArm: OnstopShotArm(); break;
case TimelineType.ShotCannon: OnstopShotCannon(); break;
case TimelineType.WaitArm: OnstopWaitArm(); break;
case TimelineType.WaitCannon: OnstopWaitCannon(); break;
}
}
void UpdateTimelineTrackTitle(TimelineTrack timelineTrack)
{
//var newTitle = EditorGUILayout.TextField("title", timelineTrack.title_);
//var charManager = EditorGUILayout.ObjectField("charManager", timelineTrack.charManager, typeof(JMCharManager),true);
TimelineType timelineType = (TimelineType)timelineTrack.timelineType_;
EditorGUILayout.LabelField("type : " + timelineType.ToString());
//if (newTitle != timelineTrack.title_)
//{
// timelineTrack.BeforeSave();
// timelineTrack.title_ = newTitle;
// timelineTrack.Save();
//}
//if (charManager != timelineTrack.charManager)
//{
// timelineTrack.charManager = charManager as JMCharManager;
//}
}
private PlayableDirector Type2Director(TimelineType type)
{
switch (type)
{
case TimelineType.Idle: return(AnimationIdle);
case TimelineType.ChargeArm: return(ChargeArm);
case TimelineType.ChargeCannon: return(ChargeCannon);
case TimelineType.ShotArm: return(ShotArm);
case TimelineType.ShotCannon: return(ShotCannon);
case TimelineType.WaitArm: return(WaitArm);
case TimelineType.WaitCannon: return(WaitCannon);
}
return(null);
}
public TimelineBase(TwitterAccount account, string listTitle, string tabName, TimelineType type, SettingData setting, Action<TimelineAction> timelineActionCallback, Action<RowAction> rowActionCallback)
{
this.ListTitle = listTitle;
timeLine = new ObservableCollection<RowBase>();
IsTimelineFiltering = false;
IsNewNotification = false;
this.TimelineType = type;
this.TabName = tabName;
ExtractionAccountScreenNameStr = string.Empty;
ExcludeAccountScreenNameStr = string.Empty;
ExtractionWordStr = string.Empty;
ExcludeWordStr = string.Empty;
this.Setting = setting;
IsNowLoading = false;
liveTileCounter = 0;
}
public static T[] Normalize <T>(this IEnumerable <Timeline> timelines, TimelineType type, IEnumerable <T> items) where T : ITwitterItem
{
return(timelines.Single(p => p.Type == type).Normalize(items));
}
/// <summary> TimelineTypeによるフィルタを設定します。
/// <para> ＊ pAccepted のboolに注意すること。意味が逆になってる。 </para>
/// </summary>
/// <param name="pCollectionViewSource"> フィルタ設定するCollectionViewSource </param>
/// <param name="pTimelineType"> 設定対象のTimelineType </param>
/// <param name="pAccepted"> フィルタ追加する場合は False, フィルタ解除する場合は True </param>
public void SetTimelineTypeFilter(CollectionViewSource pCollectionViewSource, TimelineType pTimelineType, bool pAccepted)
{
FilterEventHandler filter = null;
switch (pTimelineType)
{
case TimelineType.UNKNOWN:
filter = new FilterEventHandler(this.typeFilter.Filter_TypeUNKNOWN);
break;
case TimelineType.ENEMY:
filter = new FilterEventHandler(this.typeFilter.Filter_TypeENEMY);
break;
case TimelineType.TANK:
filter = new FilterEventHandler(this.typeFilter.Filter_TypeTANK);
break;
case TimelineType.DPS:
filter = new FilterEventHandler(this.typeFilter.Filter_TypeDPS);
break;
case TimelineType.HEALER:
filter = new FilterEventHandler(this.typeFilter.Filter_TypeHEALER);
break;
case TimelineType.PET:
filter = new FilterEventHandler(this.typeFilter.Filter_TypePET);
break;
case TimelineType.GIMMICK:
filter = new FilterEventHandler(this.typeFilter.Filter_TypeGIMMICK);
break;
default:
return;
}
if (filter == null)
{
return;
}
this.ascceptedFilter(pCollectionViewSource, filter, pAccepted);
return;
}
private TwitterTweet[] RetrieveTimeline(
TimelineType timelineType,
string userId = null,
string screenName = null,
int count = 20,
string sinceId = null,
string maxId = null,
int page = 1,
bool trimUser = true,
bool includeRetweets = true,
bool includeEntities = true,
bool excludeReplies = true,
bool contributorDetails = true)
{
var queryBuilder = new StringBuilder();
queryBuilder.AppendFormat(
"?count={0}&page={1}&trim_user={2}&include_rts={3}&include_entities={4}&" +
"exclude_replies={5}&",
count <= 200 ? count : 200,
page > 1 ? page : 1,
trimUser ? "true" : "false",
includeRetweets ? "true" : "false",
includeEntities ? "true" : "false",
excludeReplies ? "true" : "false");
if (timelineType == TimelineType.HomeTimeline ||
timelineType == TimelineType.Mentions ||
timelineType == TimelineType.UserTimeline)
{
queryBuilder.AppendFormat("contributor_details={0}&", contributorDetails ? "true" : "false");
}
if (!String.IsNullOrEmpty(userId))
{
switch (timelineType)
{
case TimelineType.UserTimeline:
queryBuilder.AppendFormat("user_id={0}&", userId);
break;
case TimelineType.RetweetedToUser:
case TimelineType.RetweetedByUser:
queryBuilder.AppendFormat("id={0}&", userId);
break;
}
}
if (!String.IsNullOrEmpty(screenName) &&
(timelineType == TimelineType.UserTimeline ||
timelineType == TimelineType.RetweetedByUser ||
timelineType == TimelineType.RetweetedToUser))
{
queryBuilder.AppendFormat("screen_name={0}&", screenName);
}
if (!String.IsNullOrEmpty(sinceId))
queryBuilder.AppendFormat("sincd_id={0}&", sinceId);
if (!String.IsNullOrEmpty(maxId))
queryBuilder.AppendFormat("max_id={0}", maxId);
var twitterMethod = String.Empty;
switch (timelineType)
{
case TimelineType.HomeTimeline:
twitterMethod = "/home_timeline.json";
break;
case TimelineType.Mentions:
twitterMethod = "/mentions.json";
break;
case TimelineType.RetweetedByMe:
twitterMethod = "/retweeted_by_me.json";
break;
case TimelineType.RetweetedToMe:
twitterMethod = "/retweeted_to_me.json";
break;
case TimelineType.RetweetsOfMe:
twitterMethod = "/retweets_of_me.json";
break;
case TimelineType.UserTimeline:
twitterMethod = "/user_timeline.json";
break;
case TimelineType.RetweetedToUser:
twitterMethod = "/retweeted_to_user.json";
break;
case TimelineType.RetweetedByUser:
twitterMethod = "/retweeted_by_user.json";
break;
}
var uri = new Uri(this.CommandBaseUri + twitterMethod + queryBuilder.ToString().TrimEnd('&'));
var response = this.TwitterApi.Authenticated
? this.TwitterApi.ExecuteAuthenticatedRequest(uri, HttpMethod.Get, null)
: this.TwitterApi.ExecuteUnauthenticatedRequest(uri);
var tweets = JsonConvert.DeserializeObject<TwitterTweet[]>(response);
return tweets;
}
public int frameIndicesOffset; // FrameIndices.
protected override void _OnClear()
{
this.type = TimelineType.BoneAll;
this.offset = 0;
this.frameIndicesOffset = -1;
}
internal static void SetPropertyToSetupPose(this Skeleton skeleton, int propertyID)
{
Bone bone;
PathConstraint constraint2;
int num = propertyID >> 0x18;
TimelineType type = (TimelineType)num;
int index = propertyID - (num << 0x18);
switch (type)
{
case TimelineType.Rotate:
bone = skeleton.bones.Items[index];
bone.rotation = bone.data.rotation;
break;
case TimelineType.Translate:
bone = skeleton.bones.Items[index];
bone.x = bone.data.x;
bone.y = bone.data.y;
break;
case TimelineType.Scale:
bone = skeleton.bones.Items[index];
bone.scaleX = bone.data.scaleX;
bone.scaleY = bone.data.scaleY;
break;
case TimelineType.Shear:
bone = skeleton.bones.Items[index];
bone.shearX = bone.data.shearX;
bone.shearY = bone.data.shearY;
break;
case TimelineType.Attachment:
skeleton.SetSlotAttachmentToSetupPose(index);
break;
case TimelineType.Color:
skeleton.slots.Items[index].SetColorToSetupPose();
break;
case TimelineType.Deform:
skeleton.slots.Items[index].attachmentVertices.Clear(true);
break;
case TimelineType.DrawOrder:
skeleton.SetDrawOrderToSetupPose();
break;
case TimelineType.IkConstraint:
{
IkConstraint constraint = skeleton.ikConstraints.Items[index];
constraint.mix = constraint.data.mix;
constraint.bendDirection = constraint.data.bendDirection;
break;
}
case TimelineType.TransformConstraint:
{
TransformConstraint constraint3 = skeleton.transformConstraints.Items[index];
TransformConstraintData data = constraint3.data;
constraint3.rotateMix = data.rotateMix;
constraint3.translateMix = data.translateMix;
constraint3.scaleMix = data.scaleMix;
constraint3.shearMix = data.shearMix;
break;
}
case TimelineType.PathConstraintPosition:
constraint2 = skeleton.pathConstraints.Items[index];
constraint2.position = constraint2.data.position;
break;
case TimelineType.PathConstraintSpacing:
constraint2 = skeleton.pathConstraints.Items[index];
constraint2.spacing = constraint2.data.spacing;
break;
case TimelineType.PathConstraintMix:
constraint2 = skeleton.pathConstraints.Items[index];
constraint2.rotateMix = constraint2.data.rotateMix;
constraint2.translateMix = constraint2.data.translateMix;
break;
case TimelineType.TwoColor:
skeleton.slots.Items[index].SetColorToSetupPose();
break;
}
}
public UserTimelineModel(long userId, TimelineType type)
{
this._userId = userId;
this._type = type;
}
public static ITimelineMarkingStrategy Strategy(this TimelineType type, TuneDuration tuneDuration, TimeSpan firstMark, ZeroToOne end)
{
return(type == TimelineType.EndRevealing
? (ITimelineMarkingStrategy) new EndRevealingTimeline(tuneDuration, firstMark, end)
: new ConstantTimeline(tuneDuration, firstMark));
}
public UserTimelineModel(long userId, TimelineType type)
{
this._userId = userId;
this._type = type;
}
public PlayerTimelineManage()
{
PlayingTimeline = TimelineType.None;
}
public static Timeline TypeAt(this IEnumerable <Timeline> timelines, TimelineType type)
{
return(timelines.SingleOrDefault(p => p.Type == type));
}
private string GetTimelineUrl(TimelineType timelineType)
{
switch (timelineType)
{
case TimelineType.Public:
return PUBLIC_TIMELINE_URL;
case TimelineType.AllFriends:
return FRIENDS_TIMELINE_URL;
case TimelineType.SingleFriend:
return ANOTHER_FRIENDS_TIMELINE_URL;
default:
return string.Empty;
}
}
/// <summary>
/// </summary>
/// <param name="name"></param>
/// <param name="exp"></param>
/// <param name="type"></param>
/// <returns></returns>
public static string GetTaggedName(string name, Expressions exp, TimelineType type)
{
if (type == TimelineType.Unknown)
{
return name;
}
var tag = "???";
name = name.Trim();
if (String.IsNullOrWhiteSpace(name))
{
return "";
}
name = Regex.Replace(name, @"\[[\w]+\]", "")
.Trim();
var petFound = false;
foreach (var pet in _pets.Where(pet => String.Equals(pet, name, Constants.InvariantComparer)))
{
petFound = true;
}
switch (type)
{
case TimelineType.You:
tag = exp.YouString;
break;
case TimelineType.Party:
tag = "P";
break;
case TimelineType.Alliance:
tag = "A";
break;
case TimelineType.Other:
tag = "O";
break;
}
return String.Format("[{0}] {1}", tag, name);
}
internal void LoadTimeline(WUser user, TimelineType timelineType)
{
_owner = user;
_timelineType = timelineType;
}
public TimelineBase(TwitterAccount account, string listTitle, string tabName, TimelineType type, SettingData setting, Action <TimelineAction> timelineActionCallback, Action <RowAction> rowActionCallback)
{
this.ListTitle = listTitle;
timeLine = new ObservableCollection <RowBase>();
IsTimelineFiltering = false;
IsNewNotification = false;
this.TimelineType = type;
this.TabName = tabName;
ExtractionAccountScreenNameStr = string.Empty;
ExcludeAccountScreenNameStr = string.Empty;
ExtractionWordStr = string.Empty;
ExcludeWordStr = string.Empty;
this.Setting = setting;
IsNowLoading = false;
liveTileCounter = 0;
}
public UserTimelineModel(long userId, TimelineType type)
{
_userId = userId;
_type = type;
}
private static bool IgnoreType(TimelineType timelineType)
{
switch (timelineType)
{
case TimelineType.You:
return !Settings.Default.ParseYou;
case TimelineType.Party:
return !Settings.Default.ParseParty;
case TimelineType.Alliance:
return !Settings.Default.ParseAlliance;
case TimelineType.Other:
return !Settings.Default.ParseOther;
}
return false;
}