private void ParseScorePart(IXmlNode element)
{
string id = element.GetAttribute("id");
var track = new Track(1);
_trackById[id] = track;
_score.AddTrack(track);
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "part-name":
track.Name = Std.GetNodeValue(c.FirstChild);
break;
case "part-abbreviation":
track.ShortName = Std.GetNodeValue(c.FirstChild);
break;
case "midi-instrument":
ParseMidiInstrument(c, track);
break;
}
}
});
if (IsEmptyTuning(track.Tuning))
{
track.Tuning = new int[0];
}
}
public override void RegisterMaxSizes(BarSizeInfo sizes)
{
var preSize = BeatGlyphsStart;
if (sizes.GetSize(KeySizePre) < preSize)
{
sizes.SetSize(KeySizePre, preSize);
}
Std.Foreach(_voiceContainers.Values, c => c.RegisterMaxSizes(sizes));
float postSize;
if (_postBeatGlyphs.Count == 0)
{
postSize = 0;
}
else
{
postSize = _postBeatGlyphs[_postBeatGlyphs.Count - 1].X + _postBeatGlyphs[_postBeatGlyphs.Count - 1].Width;
}
if (sizes.GetSize(KeySizePost) < postSize)
{
sizes.SetSize(KeySizePost, postSize);
}
if (sizes.FullWidth < Width)
{
sizes.FullWidth = Width;
}
}
public override void DoLayout()
{
var w = 0f;
for (int i = 0, j = _notes.Count; i < j; i++)
{
var g = _notes[i];
g.Renderer = Renderer;
g.DoLayout();
if (g.Width > w)
{
w = g.Width;
}
}
var tabHeight = Renderer.Resources.TablatureFont.Size;
var effectY = GetNoteY(_minNote) + tabHeight / 2;
// TODO: take care of actual glyph height
var effectSpacing = 7 * Scale;
Std.Foreach(BeatEffects.Values, g =>
{
g.Y = effectY;
g.X += Width / 2;
g.Renderer = Renderer;
effectY += effectSpacing;
g.DoLayout();
});
_centerX = 0;
Width = w;
}
private void ParseStaffTuning(IXmlNode element, Track track)
{
var line = Std.ParseInt(element.GetAttribute("line"));
string tuningStep = "C";
string tuningOctave = "";
int tuningAlter = 0;
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "tuning-step":
tuningStep = Std.GetNodeValue(c);
break;
case "tuning-alter":
tuningAlter = Std.ParseInt(Std.GetNodeValue(c));
break;
case "tuning-octave":
tuningOctave = Std.GetNodeValue(c);
break;
}
}
});
track.Tuning[track.Tuning.Length - line] = TuningParser.GetTuningForText(tuningStep + tuningOctave) + tuningAlter;
}
public override void BuildBoundingsLookup(BoundingsLookup lookup,
float visualTop, float visualHeight,
float realTop, float realHeight, float x)
{
base.BuildBoundingsLookup(lookup, visualTop, visualHeight, realTop, realHeight, x);
var barLookup = lookup.Bars[lookup.Bars.Count - 1];
var beatStart = BeatGlyphsStart;
Std.Foreach(_voiceContainers.Values, c =>
{
for (int i = 0, j = c.BeatGlyphs.Count; i < j; i++)
{
var bc = c.BeatGlyphs[i];
var beatLookup = new BeatBoundings();
beatLookup.Beat = bc.Beat;
// on beat bounding rectangle
beatLookup.VisualBounds = new Bounds(
x + Stave.X + X + beatStart + c.X + bc.X + bc.OnNotes.X, visualTop,
bc.OnNotes.Width, visualHeight);
// real beat boundings
beatLookup.Bounds = new Bounds(
x + Stave.X + X + beatStart + c.X + bc.X, realTop,
bc.Width, realHeight);
barLookup.Beats.Add(beatLookup);
}
});
}
/// <summary>
/// Deletes a Standard instance and raises the appropriate StandardChanged Event
/// </summary>
/// <param name="standardInstance">The Instance to delete</param>
public void DeleteStandard(Std standardInstance)
{
standardInstance.Delete();
_eventAggregator.GetEvent <StandardChanged>()
.Publish(new EntityChangedToken(standardInstance,
EntityChangedToken.EntityChangedAction.Deleted));
}
/// <summary>
/// Consolidates a list of Std entries into a single one, redirecting all references
/// All the entries that are left unused are deleted
/// </summary>
/// <param name="standardList">The list of standards to consolidate</param>
/// <param name="mainEntry">The entry that will incorporate all the others</param>
public void ConsolidateStandard(IEnumerable <Std> standardList,
Std mainEntry)
{
foreach (Std currentStd in standardList)
{
// if currentStd is mainentry, skip
if (currentStd.ID == mainEntry.ID)
{
continue;
}
// Retrieve method list, set new reference and update
foreach (Method mtd in currentStd.GetMethods())
{
mtd.StandardID = mainEntry.ID;
mtd.Update();
}
// Retrieve specification list, set new reference and update
foreach (Specification spc in currentStd.GetSpecifications())
{
spc.StandardID = mainEntry.ID;
spc.Update();
}
// Call method to delete currentStd
DeleteStandard(currentStd);
}
}
public void UseCase_SystemAsCompoundArchitecture()
{
_p.KeepTrack = false;
MathSystem s = _p.CurrentSystem;
s.RemoveUnusedObjects();
Signal x = Binder.CreateSignal();
Std.ConstrainAlwaysReal(x);
Signal x2 = StdBuilder.Square(x);
Signal sinx2 = StdBuilder.Sine(x2);
s.AddSignalTree(sinx2, true, true);
s.RemoveUnusedObjects();
s.PublishToLibrary("SineOfSquaredX", "sinx2");
Signal y = Binder.CreateSignal();
y.PostNewValue(RealValue.E);
Signal z = Service <IBuilder> .Instance.Function("sinx2", y);
_p.SimulateInstant(); //.SimulateFor(new TimeSpan(1));
IValueStructure res = z.Value;
RealValue resReal = RealValue.ConvertFrom(res);
Assert.AreEqual(0.8939, Math.Round(resReal.Value, 4));
}
public void UseCase_SimpleSystemAsFunction()
{
// TODO: Replace with new (easier to use) MathFunction class instead of MathSystem
_p.KeepTrack = true;
MathSystem s = _p.CurrentSystem;
s.RemoveUnusedObjects();
Signal x = Binder.CreateSignal();
Std.ConstrainAlwaysReal(x);
Signal x2 = StdBuilder.Square(x);
Signal sinx2 = StdBuilder.Sine(x2);
Assert.AreEqual(0, s.InputCount, "Input Signal Count A");
Assert.AreEqual(0, s.OutputCount, "Output Signal Count A");
Assert.AreEqual(0, s.BusCount, "Bus Count A");
Assert.AreEqual(3, s.SignalCount, "Signal Count A");
Assert.AreEqual(2, s.PortCount, "Port Count A");
s.PromoteAsInput(x);
s.PromoteAsOutput(sinx2);
s.RemoveUnusedObjects();
Assert.AreEqual(1, s.InputCount, "Input Signal Count B");
Assert.AreEqual(1, s.OutputCount, "Output Signal Count B");
Assert.AreEqual(0, s.BusCount, "Bus Count B");
Assert.AreEqual(3, s.SignalCount, "Signal Count B");
Assert.AreEqual(2, s.PortCount, "Port Count B");
double ret = Math.Round(s.Evaluate(Math.PI)[0], 4);
Assert.AreEqual(-0.4303, ret, "Result");
}
public dynamic ToJson()
{
dynamic json = Std.NewObject();
json.scale = Scale;
json.width = Width;
json.height = Height;
json.engine = Engine;
json.stretchForce = StretchForce;
json.forcePianoFingering = ForcePianoFingering;
json.scriptFile = ScriptFile;
json.fontDirectory = FontDirectory;
json.layout = Std.NewObject();
json.layout.mode = Layout.Mode;
json.layout.additionalSettings = Std.NewObject();
foreach (string setting in Layout.AdditionalSettings)
{
json.layout.additionalSettings[setting] = Layout.AdditionalSettings[setting];
}
json.staves = Std.NewObject();
json.staves.id = Staves.Id;
json.staves.additionalSettings = Std.NewObject();
foreach (var additionalSetting in Staves.AdditionalSettings)
{
json.staves.additionalSettings[additionalSetting] = Staves.AdditionalSettings[additionalSetting];
}
return(json);
}
private void ParseIdentification(IXmlNode element)
{
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "creator":
if (c.GetAttribute("type") == "composer")
{
_score.Words = Std.GetNodeValue(c.FirstChild);
}
break;
case "rights":
if (!string.IsNullOrEmpty(_score.Copyright))
{
_score.Copyright += "\n";
}
_score.Copyright += Std.GetNodeValue(c.FirstChild);
break;
}
}
});
}
public override Score ReadScore()
{
try
{
CreateDefaultScore();
_curChPos = 0;
_currentDuration = Duration.Quarter;
_lyrics = new FastList <Lyrics>();
NextChar();
NewSy();
Score();
_score.Finish();
_track.ApplyLyrics(_lyrics);
return(_score);
}
catch (Exception e)
{
if (Std.IsException <AlphaTexException>(e))
{
throw new UnsupportedFormatException(e.Message);
}
throw e;
}
}
private void ParseDirection(IXmlNode element, MasterBar masterBar)
{
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "sound":
var tempo = c.GetAttribute("tempo");
if (!string.IsNullOrEmpty(tempo))
{
var tempoAutomation = new Automation();
tempoAutomation.IsLinear = true;
tempoAutomation.Type = AutomationType.Tempo;
tempoAutomation.Value = Std.ParseInt(tempo);
masterBar.TempoAutomation = tempoAutomation;
}
break;
case "direction-type":
var directionType = c.FirstChild;
switch (directionType.LocalName)
{
case "words":
masterBar.Section = new Section();
masterBar.Section.Text = Std.GetNodeValue(directionType);
break;
}
break;
}
}
});
}
private void ParsePartwise(IXmlNode element)
{
var version = element.GetAttribute("version");
if (!string.IsNullOrEmpty(version) && version != "2.0")
{
throw new UnsupportedFormatException();
}
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "movement-title":
_score.Title = Std.GetNodeValue(c.FirstChild);
break;
case "identification":
ParseIdentification(c);
break;
case "part-list":
ParsePartList(c);
break;
case "part":
ParsePart(c);
break;
}
}
});
}
public void Write(byte[] buffer, int offset, int count)
{
int i = _position + count;
if (i > _length)
{
if (i > _capacity)
{
EnsureCapacity(i);
}
_length = i;
}
if ((count <= 8) && (buffer != _buffer))
{
int byteCount = count;
while (--byteCount >= 0)
{
_buffer[_position + byteCount] = buffer[offset + byteCount];
}
}
else
{
Std.BlockCopy(buffer, offset, _buffer, _position, Math.Min(count, buffer.Length - offset));
}
_position = i;
}
public int Read(byte[] buffer, int offset, int count)
{
int n = _length - _position;
if (n > count)
{
n = count;
}
if (n <= 0)
{
return(0);
}
if (n <= 8)
{
int byteCount = n;
while (--byteCount >= 0)
{
buffer[offset + byteCount] = _buffer[_position + byteCount];
}
}
else
{
Std.BlockCopy(_buffer, _position, buffer, offset, n);
}
_position += n;
return(n);
}
public static LayoutSettings LayoutFromJson(dynamic json)
{
var layout = new LayoutSettings();
if (JsContext.@typeof(json) == "string")
{
layout.Mode = json;
}
else
{
if (json.mode)
{
layout.Mode = json.mode;
}
if (json.additionalSettings)
{
string[] keys = Std.JsonKeys(json.additionalSettings);
foreach (var key in keys)
{
layout.AdditionalSettings[key.ToLower()] = json.additionalSettings[key];
}
}
}
return(layout);
}
protected override bool FilterStatus(Std.Tweak.TwitterStatusBase status)
{
var a = AccountModel.GetAccountElement(accountScreenName);
if (a == null)
return false;
return a.ContainsFollowers(status.User.ScreenName);
}
public void Pattern_TreePattern()
{
Project p = new Project();
MathSystem s = p.CurrentSystem;
// sin(x^2)
Signal x = Binder.CreateSignal(); x.Label = "x";
Std.ConstrainAlwaysReal(x);
Signal x2 = StdBuilder.Square(x); x2.Label = "x2";
Signal sinx2 = StdBuilder.Sine(x2); sinx2.Label = "sinx2";
Pattern psimp = new Pattern(new EntityCondition(new MathIdentifier("Sine", "Std")));
Assert.AreEqual(true, psimp.Match(sinx2, sinx2.DrivenByPort), "B01");
Assert.AreEqual(false, psimp.Match(x2, x2.DrivenByPort), "B02");
TreePattern psinsqr = new TreePattern(new EntityCondition(new MathIdentifier("Sine", "Std")));
psinsqr.Add(new Pattern(new EntityCondition(new MathIdentifier("Square", "Std"))));
Assert.AreEqual(true, psinsqr.Match(sinx2, sinx2.DrivenByPort), "B03");
Assert.AreEqual(false, psinsqr.Match(x2, x2.DrivenByPort), "B04");
TreePattern psinadd = new TreePattern(new EntityCondition(new MathIdentifier("Sine", "Std")));
psinadd.Add(new Pattern(new EntityCondition(new MathIdentifier("Add", "Std"))));
Assert.AreEqual(false, psinadd.Match(sinx2, sinx2.DrivenByPort), "B03");
Assert.AreEqual(false, psinadd.Match(x2, x2.DrivenByPort), "B04");
}
private void ParseAccidental(IXmlNode element, Note note)
{
switch (Std.GetNodeValue(element))
{
case "sharp":
note.AccidentalMode = NoteAccidentalMode.ForceSharp;
break;
case "natural":
note.AccidentalMode = NoteAccidentalMode.ForceNatural;
break;
case "flat":
note.AccidentalMode = NoteAccidentalMode.ForceFlat;
break;
//case "double-sharp":
// break;
//case "sharp-sharp":
// break;
//case "flat-flat":
// break;
//case "natural-sharp":
// break;
//case "natural-flat":
// break;
//case "quarter-flat":
// break;
//case "quarter-sharp":
// break;
//case "three-quarters-flat":
// break;
//case "three-quarters-sharp":
// break;
}
}
private void ParseTechnical(IXmlNode element, Note note)
{
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "string":
note.String = Std.ParseInt(Std.GetNodeValue(c));
if (note.String != int.MinValue)
{
note.String = note.Beat.Voice.Bar.Staff.Track.Tuning.Length - note.String + 1;
}
break;
case "fret":
note.Fret = Std.ParseInt(Std.GetNodeValue(c));
break;
}
}
});
if (note.String == int.MinValue || note.Fret == int.MinValue)
{
note.String = -1;
note.Fret = -1;
}
}
private void ParseTimeModification(IXmlNode element, Beat beat)
{
var actualNodes = 0;
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "actual-notes":
beat.TupletNumerator = Std.ParseInt(Std.GetNodeValue(c));
break;
case "normal-notes":
beat.TupletDenominator = Std.ParseInt(Std.GetNodeValue(c));
break;
//case "normal-type":
// break;
//case "normal-dot":
// break;
}
}
});
}
private void ParseOrnaments(IXmlNode element, Note note)
{
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "tremolo":
var tremoloSpeed = Std.ParseInt(Std.GetNodeValue(c));
switch (tremoloSpeed)
{
case 1:
note.Beat.TremoloSpeed = Duration.Eighth;
break;
case 2:
note.Beat.TremoloSpeed = Duration.Sixteenth;
break;
case 3:
note.Beat.TremoloSpeed = Duration.ThirtySecond;
break;
}
break;
}
}
});
}
public void SystemToExpressionTest()
{
Project p = new Project();
MathSystem s1 = p.CurrentSystem;
// BUILD SYSTEM 1: sin(x^2)*2
Signal x = Binder.CreateSignal(); x.Label = "x";
Std.ConstrainAlwaysReal(x);
Signal x2 = StdBuilder.Square(x); x2.Label = "x2";
Signal sinx2 = StdBuilder.Sine(x2); sinx2.Label = "sinx2";
Signal sinx2t2 = sinx2 * IntegerValue.ConstantTwo;
s1.AddSignalTree(sinx2t2, true, true);
// EVALUATE SYSTEM 1 FOR x=1.5
x.PostNewValue(new RealValue(1.5));
p.SimulateInstant();
Assert.AreEqual(0, s1.BusCount, "A0");
Assert.AreEqual(5, s1.SignalCount, "A1");
Assert.AreEqual(3, s1.PortCount, "A2");
Assert.AreEqual("Std.Real(1.55614639377584)", sinx2t2.Value.ToString(), "A3");
// SERIALIZE SYSTEM 1 TO EXPRESSION
ExpressionWriter writer = new ExpressionWriter();
SystemReader reader = new SystemReader(writer);
reader.ReadSystem(s1);
string expr = writer.WrittenExpressions.Dequeue();
Console.WriteLine(expr);
// ....
}
private void ParsePartwise(IXmlNode element)
{
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "movement-title":
_score.Title = Std.GetNodeValue(c.FirstChild);
break;
case "identification":
ParseIdentification(c);
break;
case "part-list":
ParsePartList(c);
break;
case "part":
ParsePart(c);
break;
}
}
});
}
private void ParsePitch(IXmlNode element, Track track, Beat beat, Note note)
{
string step = null;
int semitones = 0;
int octave = 0;
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "step":
step = Std.GetNodeValue(c);
break;
case "alter":
semitones = Std.ParseInt(Std.GetNodeValue(c));
break;
case "octave":
// 0-9, 4 for middle C
octave = Std.ParseInt(Std.GetNodeValue(c));
break;
}
}
});
var fullNoteName = step + octave;
var fullNoteValue = TuningParser.GetTuningForText(fullNoteName) + semitones;
ApplyNoteStringFrets(track, beat, note, fullNoteValue);
}
public bool PEGI_inList(IList list, int ind, ref int edited)
{
bool changed = false;
pegi.edit(ref dataExplorer.tag, 100);
if (Std != null)
{
if (icon.Load.ClickUnfocus("Decode Data into " + Std.ToPEGIstring()))
{
Std.Decode(dataExplorer.data);
}
if (icon.Save.ClickUnfocus("Save data from " + Std.ToPEGIstring()))
{
dataExplorer = new Exploring_STD(dataExplorer.tag, Std.Encode().ToString());
}
}
if (icon.Enter.Click(comment))
{
edited = ind;
}
return(changed);
}
private void ParseScorePart(IXmlNode element)
{
string id = element.GetAttribute("id");
var track = new Track();
_trackById[id] = track;
_score.AddTrack(track);
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "part-name":
track.Name = Std.GetNodeValue(c.FirstChild);
break;
case "part-abbreviation":
track.ShortName = Std.GetNodeValue(c.FirstChild);
break;
case "midi-instrument":
ParseMidiInstrument(c, track);
break;
}
}
});
if (track.Tuning == null || track.Tuning.Length == 0)
{
track.Tuning = Tuning.GetDefaultTuningFor(6).Tunings;
}
}
private void ParseUnpitched(IXmlNode element, Note note)
{
string step = null;
int semitones = 0;
int octave = 0;
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "display-step":
step = Std.GetNodeValue(c);
break;
case "display-alter":
semitones = Std.ParseInt(Std.GetNodeValue(c));
break;
case "display-octave":
// 0-9, 4 for middle C
octave = Std.ParseInt(Std.GetNodeValue(c));
break;
}
}
});
var value = octave * 12 + TuningParser.GetToneForText(step) + semitones;
note.Octave = (value / 12);
note.Tone = value - (note.Octave * 12);
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[2];
theorems[0] = new Analysis.DerivativeTransformation(context.Library.LookupEntity(_entityId),
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
Signal[] outputs = new Signal[manipulatedInputs.Count];
ReadOnlySignalSet squares = b.Square(port.OutputSignals);
Signal one = IntegerValue.ConstantOne(context);
for (int i = 0; i < outputs.Length; i++)
{
outputs[i] = (one + squares[i]) * manipulatedInputs[i];
}
return(b.Negate(outputs));
});
theorems[1] = new BasicTransformation("CotangentTrigonometricSusbtitute", "Std", "TrigonometricSubstitute", "Std",
delegate(Port port) { return(port.Entity.EntityId.Equals("Cotangent", "Std")); },
delegate(Port port) { return(ManipulationPlan.DoAlter); },
delegate(Port port, SignalSet transformedInputs, bool hasTransformedInputs)
{
Signal[] ret = new Signal[transformedInputs.Count];
for (int i = 0; i < ret.Length; i++)
{
ret[i] = Std.Cosine(port.Context, transformedInputs[i]) / Std.Sine(port.Context, transformedInputs[i]);
}
return(ret);
});
return(theorems);
}
public void Write(byte[] buffer, int offset, int count)
{
int i = Position + count;
if (i > Length)
{
if (i > _capacity)
{
EnsureCapacity(i);
}
Length = i;
}
if ((count <= 8) && (buffer != _buffer))
{
int byteCount = count;
while (--byteCount >= 0)
{
_buffer[Position + byteCount] = buffer[offset + byteCount];
}
}
else
{
Std.BlockCopy(buffer, offset, _buffer, Position, count);
}
Position = i;
}
static void TweetModel_ReceivedStatus(Std.Tweak.TwitterStatusBase obj)
{
Task.Factory.StartNew(() =>
{
var matches = Regexs.HashRegex.Matches(obj.Text);
matches.OfType<Match>().Select(m => m.Value).ToList().ForEach(s => AddHashtag(s));
});
}
protected override bool FilterStatus(Std.Tweak.TwitterStatusBase status)
{
foreach (var u in AccountModel.GetAccountElements())
{
if (u.ContainsFollowing(status.User.ScreenName))
return true;
}
return false;
}
protected override bool FilterStatus(Std.Tweak.TwitterStatusBase status)
{
var list = ListModel.Lookup(UserId, ListName);
if (list == null || list.Members == null)
{
return false;
}
else
{
return list.Members.Contains(status.User);
}
}
protected override bool FilterStatus(Std.Tweak.TwitterStatusBase status)
{
switch (this.CurrentStarKind)
{
case StarKind.Red:
return Setting.Instance.TimelineFilteringProperty.RedStarUsers.Contains(status.User.ScreenName);
case StarKind.Blue:
return Setting.Instance.TimelineFilteringProperty.BlueStarUsers.Contains(status.User.ScreenName);
case StarKind.Green:
return Setting.Instance.TimelineFilteringProperty.GreenStarUsers.Contains(status.User.ScreenName);
default:
return false;
}
}
protected override bool FilterStatus(Std.Tweak.TwitterStatusBase status)
{
var s = status as TwitterStatus;
return s != null && s.PublishedByRetweet;
}
protected override bool FilterStatus(Std.Tweak.TwitterStatusBase status)
{
return status is Std.Tweak.TwitterStatus;
}
protected override bool FilterStatus(Std.Tweak.TwitterStatusBase status)
{
if (!IsAccountExists()) return false;
return GetElement().FavoritedStatusIds.Contains(status.Id);
}
void _timelineBlockViewModel_SelectedTwitterStatusChanged(Std.Tweak.TwitterStatusBase obj)
{
Helper.CommonEventServer.RaiseSelectedStatusChanged(obj);
}
protected override bool FilterStatus(Std.Tweak.TwitterStatusBase status)
{
var s = status as TwitterStatus;
return s != null && CheckMatch(s.Source);
}
internal static extern global::System.IntPtr FindOrCreateModule_0(global::System.IntPtr instance, Std.String File);
protected override bool FilterStatus(Std.Tweak.TwitterStatusBase status)
{
if (!IsAccountExists()) return false;
return GetElement().Following.Contains(status.User);
}
protected override bool FilterStatus(Std.Tweak.TwitterStatusBase status)
{
return status.User.Verified;
}
public static AprFile Open(Std stream, AprPool pool)
{
IntPtr ptr = IntPtr.Zero;
int res = 0;
switch(stream)
{
case Std.In:
Debug.Write(String.Format("apr_file_open_stdin({0})...",pool));
res = Apr.apr_file_open_stdin(out ptr, pool);
break;
case Std.Out:
Debug.Write(String.Format("apr_file_open_stdout({0})...",pool));
res = Apr.apr_file_open_stdout(out ptr, pool);
break;
case Std.Err:
Debug.Write(String.Format("apr_file_open_stderr({0})...",pool));
res = Apr.apr_file_open_stderr(out ptr, pool);
break;
}
if(res != 0 )
throw new AprException(res);
Debug.WriteLine(String.Format("Done({0:X})",((Int32)ptr)));
return(ptr);
}
public CppSharp.Parser.AST.TranslationUnit FindOrCreateModule(Std.String File)
{
var arg0 = new Std.String();
var __ret = Internal.FindOrCreateModule_0(__Instance, arg0);
if (__ret == global::System.IntPtr.Zero) return null;
return new CppSharp.Parser.AST.TranslationUnit(__ret);
}
public CppSharp.Parser.AST.TypedefDecl FindTypedef(Std.String Name, bool Create)
{
var arg0 = new Std.String();
var __ret = Internal.FindTypedef_0(__Instance, arg0, Create);
if (__ret == global::System.IntPtr.Zero) return null;
return new CppSharp.Parser.AST.TypedefDecl(__ret);
}
public CppSharp.Parser.AST.Class FindClass(Std.String Name, bool IsComplete, bool Create)
{
var arg0 = new Std.String();
var __ret = Internal.FindClass_1(__Instance, arg0, IsComplete, Create);
if (__ret == global::System.IntPtr.Zero) return null;
return new CppSharp.Parser.AST.Class(__ret);
}
protected override bool FilterStatus(Std.Tweak.TwitterStatusBase status)
{
return CheckMatch(status.Text);
}
public CppSharp.Parser.AST.Namespace FindNamespace(Std.Vector<Std.String> _0)
{
var arg0 = _0.Internal;
var __ret = Internal.FindNamespace_1(__Instance, arg0);
if (__ret == global::System.IntPtr.Zero) return null;
return new CppSharp.Parser.AST.Namespace(__ret);
}
public CppSharp.Parser.AST.Enumeration FindEnum(Std.String Name, bool Create)
{
var arg0 = new Std.String();
var __ret = Internal.FindEnum_0(__Instance, arg0, Create);
if (__ret == global::System.IntPtr.Zero) return null;
return new CppSharp.Parser.AST.Enumeration(__ret);
}
internal static extern global::System.IntPtr FindClass_1(global::System.IntPtr instance, Std.String Name, bool IsComplete, bool Create);
public CppSharp.Parser.AST.Class FindClass(Std.String Name)
{
var arg0 = new Std.String();
var __ret = Internal.FindClass_0(__Instance, arg0);
if (__ret == global::System.IntPtr.Zero) return null;
return new CppSharp.Parser.AST.Class(__ret);
}
internal static extern global::System.IntPtr FindCreateNamespace_0(global::System.IntPtr instance, Std.String Name);
internal static extern global::System.IntPtr FindTypedef_0(global::System.IntPtr instance, Std.String Name, bool Create);
internal static extern global::System.IntPtr FindNamespace_1(global::System.IntPtr instance, Std.Vector _0);
internal static extern global::System.IntPtr FindClass_0(global::System.IntPtr instance, Std.String Name);
