public void Run()
{
Engine.Initialize("Selector_Basic", 640, 480, new EngineOption());
var selector = new SimpleSelector<int>(); // Selectorクラスを作成する。
selector.ItemSpan = new Vector2DF(0, 40); // 選択肢オブジェクトの位置同士の間のベクトル
selector.Cursor.Texture = Engine.Graphics.CreateTexture2D("Data/Selector/ListCursor.png"); // カーソルのテクスチャを設定
selector.BindKey(Keys.Down, Keys.Up, Keys.Z, Keys.X); // 操作方法を設定
Engine.AddObject2D(selector); // Altseedのシステムに追加
// 選択肢オブジェクトを作成する
var font = Engine.Graphics.CreateDynamicFont("", 28, new Color(255, 0, 0), 0, new Color(255, 255, 255));
for (int i = 0; i < 9; i++)
{
var obj = new TextObject2D
{
Font = font,
Text = $"選択肢{i}"
};
selector.AddChoice(i, obj);
}
// メインループ
while(Engine.DoEvents())
{
Engine.Update();
Recorder.TakeScreenShot("Selector_Basic", 20);
}
Engine.Terminate();
}
public override ISelector Produce()
{
var sel = _nested.ToPool();
if (sel == null)
{
return(null);
}
return(SimpleSelector.PseudoClass(el => sel.Match(el), String.Concat(PseudoClassNames.Matches, "(", sel.Text, ")")));
}
public override ISelector Produce()
{
var sel = _nested.ToPool();
if (sel == null)
{
return(null);
}
return(SimpleSelector.PseudoClass(el => el.ChildNodes.QuerySelector(sel) != null, String.Concat(PseudoClassNames.Has, "(", sel.Text, ")")));
}
public override ISelector Produce()
{
if (!valid || value == null)
{
return(null);
}
var code = String.Concat(PseudoClassNames.Dir, "(", value, ")");
return(SimpleSelector.PseudoClass(el => el is IHtmlElement && ((IHtmlElement)el).Direction.Equals(value, StringComparison.OrdinalIgnoreCase), code));
}
public override ISelector Produce()
{
if (!valid || value == null)
{
return(null);
}
var code = String.Concat(PseudoClassNames.Contains, "(", value, ")");
return(SimpleSelector.PseudoClass(el => el.TextContent.Contains(value), code));
}
/// <summary>
/// Picks a simple selector from the stream of tokens.
/// </summary>
/// <param name="tokens">The stream of tokens to consider.</param>
/// <returns>The created selector.</returns>
public SimpleSelector GetSimpleSelector(IEnumerator <CssToken> tokens)
{
while (tokens.MoveNext())
{
switch (tokens.Current.Type)
{
//Begin of attribute [A]
case CssTokenType.SquareBracketOpen:
{
var sel = GetAttributeSelector(tokens);
if (sel != null)
{
return(sel);
}
}
break;
//Begin of Pseudo :P
case CssTokenType.Colon:
{
var sel = GetPseudoSelector(tokens);
if (sel != null)
{
return(sel);
}
}
break;
//Begin of ID #I
case CssTokenType.Hash:
return(SimpleSelector.Id(((CssKeywordToken)tokens.Current).Data));
//Begin of Type E
case CssTokenType.Ident:
return(SimpleSelector.Type(((CssKeywordToken)tokens.Current).Data));
//Various
case CssTokenType.Delim:
if (((CssDelimToken)tokens.Current).Data == Specification.DOT && tokens.MoveNext() && tokens.Current.Type == CssTokenType.Ident)
{
return(SimpleSelector.Class(((CssKeywordToken)tokens.Current).Data));
}
break;
//All others are being ignored
case CssTokenType.Whitespace:
case CssTokenType.Comma:
default:
break;
}
}
return(null);
}
public override ISelector Produce()
{
if (!valid || value == null)
{
return(null);
}
var code = PseudoClassNames.Contains.CssFunction(value);
return(SimpleSelector.PseudoClass(el => el.TextContent.Contains(value), code));
}
public override ISelector Produce()
{
if (!valid || value == null)
{
return(null);
}
var code = String.Concat(PseudoClassNames.Dir, "(", value, ")");
return(SimpleSelector.PseudoClass(el => el is IHtmlElement && value.Isi(((IHtmlElement)el).Direction), code));
}
public override ISelector Produce()
{
if (!valid || value == null)
{
return(null);
}
var code = PseudoClassNames.Lang.CssFunction(value);
return(SimpleSelector.PseudoClass(el => el is IHtmlElement && ((IHtmlElement)el).Language.StartsWith(value, StringComparison.OrdinalIgnoreCase), code));
}
/// <summary>
/// Creates or gets the associated CSS pseudo class selector.
/// </summary>
/// <param name="name">The name of the CSS pseudo class.</param>
/// <returns>The associated selector.</returns>
public ISelector Create(String name)
{
var selector = default(ISelector);
if (selectors.TryGetValue(name, out selector))
{
return(selector);
}
return(SimpleSelector.PseudoClass(el => false, name));
}
/// <summary>
/// Invoked once a colon has been found in the token enumerator.
/// </summary>
/// <param name="token">The token.</param>
/// <returns>True if no error occurred, otherwise false.</returns>
Boolean OnClass(CssToken token)
{
state = State.Data;
if (token.Type == CssTokenType.Ident)
{
Insert(SimpleSelector.Class(token.Data));
return(true);
}
return(false);
}
public override ISelector Produce()
{
var valid = _nested.IsValid;
var sel = _nested.ToPool();
if (!valid)
{
return(null);
}
return(SimpleSelector.PseudoClass(el => !sel.Match(el), String.Concat(PseudoClassNames.Not, "(", sel.Text, ")")));
}
public override ISelector Produce()
{
if (!valid || value == null)
{
return(null);
}
var code = PseudoClassNames.Dir.CssFunction(value);
return(SimpleSelector.PseudoClass(el => el is IHtmlElement && value.Isi(((IHtmlElement)el).Direction), code));
}
/// <summary>
/// General state.
/// </summary>
/// <param name="token">The token to examine.</param>
/// <returns>True if no error occurred, otherwise false.</returns>
void OnData(CssToken token)
{
switch (token.Type)
{
//Begin of attribute [A]
case CssTokenType.SquareBracketOpen:
attrName = null;
attrValue = null;
attrOp = String.Empty;
attrNs = null;
state = State.Attribute;
ready = false;
break;
//Begin of Pseudo :P
case CssTokenType.Colon:
state = State.PseudoClass;
ready = false;
break;
//Begin of ID #I
case CssTokenType.Hash:
Insert(SimpleSelector.Id(token.Data));
ready = true;
break;
//Begin of Type E
case CssTokenType.Ident:
Insert(SimpleSelector.Type(token.Data));
ready = true;
break;
//Whitespace could be significant
case CssTokenType.Whitespace:
Insert(CssCombinator.Descendent);
break;
//Various
case CssTokenType.Delim:
OnDelim(token);
break;
case CssTokenType.Comma:
InsertOr();
ready = false;
break;
default:
valid = false;
break;
}
}
public override ISelector Produce()
{
var valid = _selector.IsValid;
var sel = _selector.GetResult();
if (valid)
{
var code = PseudoClassNames.Matches.CssFunction(sel.Text);
return(SimpleSelector.PseudoClass(el => sel.Match(el), code));
}
return(null);
}
public override ISelector Produce()
{
var valid = _nested.IsValid;
var sel = _nested.GetResult();
if (valid)
{
var code = PseudoClassNames.Has.CssFunction(sel.Text);
return(SimpleSelector.PseudoClass(el => el.ChildNodes.QuerySelector(sel) != null, code));
}
return(null);
}
/// <summary>
/// Invoked once a square bracket has been found in the token enumerator.
/// </summary>
/// <param name="token">The token.</param>
/// <returns>True if no error occurred, otherwise false.</returns>
Boolean OnAttributeEnd(CssToken token)
{
if (token.Type == CssTokenType.Whitespace)
{
return(true);
}
state = State.Data;
if (token.Type == CssTokenType.SquareBracketClose)
{
switch (attrOp)
{
case "=":
Insert(SimpleSelector.AttrMatch(attrName, attrValue));
break;
case "~=":
Insert(SimpleSelector.AttrList(attrName, attrValue));
break;
case "|=":
Insert(SimpleSelector.AttrHyphen(attrName, attrValue));
break;
case "^=":
Insert(SimpleSelector.AttrBegins(attrName, attrValue));
break;
case "$=":
Insert(SimpleSelector.AttrEnds(attrName, attrValue));
break;
case "*=":
Insert(SimpleSelector.AttrContains(attrName, attrValue));
break;
case "!=":
Insert(SimpleSelector.AttrNotMatch(attrName, attrValue));
break;
default:
Insert(SimpleSelector.AttrAvailable(attrName));
break;
}
return(true);
}
return(false);
}
public static void ShowDialog <T>(List <T> list, Action <T> onSelected = null)
{
var selector = new SimpleSelector <T>(list, onSelected);
if (selector.SelectionTree.EnumerateTree().Count() == 1)
{
selector.SelectionTree.EnumerateTree().First().Select();
selector.SelectionTree.Selection.ConfirmSelection();
}
else
{
selector.ShowInPopup(200);
}
}
/// <summary>
/// Invoked once a colon has been found in the token enumerator.
/// </summary>
/// <param name="token">The token.</param>
void OnClass(CssToken token)
{
state = State.Data;
ready = true;
if (token.Type == CssTokenType.Ident)
{
Insert(SimpleSelector.Class(token.Data));
}
else
{
valid = false;
}
}
public override ISelector Produce()
{
var valid = _nested.IsValid;
var sel = _nested.ToPool();
if (!valid)
{
return(null);
}
var code = PseudoClassNames.Matches.CssFunction(sel.Text);
return(SimpleSelector.PseudoClass(el => sel.Match(el), code));
}
/// <summary>
/// Invoked once a delimiter has been found in the token enumerator.
/// </summary>
/// <param name="token">The token.</param>
/// <returns>True if no error occurred, otherwise false.</returns>
void OnDelim(CssToken token)
{
switch (token.Data[0])
{
case Symbols.Comma:
InsertOr();
ready = false;
break;
case Symbols.GreaterThan:
Insert(CssCombinator.Child);
ready = false;
break;
case Symbols.Plus:
Insert(CssCombinator.AdjacentSibling);
ready = false;
break;
case Symbols.Tilde:
Insert(CssCombinator.Sibling);
ready = false;
break;
case Symbols.Asterisk:
Insert(SimpleSelector.All);
ready = true;
break;
case Symbols.Dot:
state = State.Class;
ready = false;
break;
case Symbols.Pipe:
if (combinators.Count > 0 && combinators.Peek() == CssCombinator.Descendent)
{
Insert(SimpleSelector.Type(String.Empty));
}
Insert(CssCombinator.Namespace);
ready = false;
break;
default:
valid = false;
break;
}
}
public void SimpleSelector_ParseFailure()
{
string[] tests = new string[]
{
" { color: blue }",
};
foreach (string test in tests)
{
ITextProvider tp = new StringTextProvider(test);
TokenStream ts = Helpers.MakeTokenStream(tp);
SimpleSelector s = new SimpleSelector();
Assert.IsFalse(s.Parse(new ItemFactory(tp, null), tp, ts));
}
}
private void BtnResore_Click(object sender, RoutedEventArgs e)
{
var delApp = DeletedAppList.SelectedItems;
AppType appType = null;
bool hasNoType = false;
foreach (DeletedApp da in delApp)
{
if (da.DeletedFrom == null)
{
hasNoType = true;
break;
}
}
if (hasNoType)
{
var ss = new SimpleSelector(
_AppTypes,
AppTypes.SelectedItem,
"AppTypeName",
Strings.SELECT_APP_GROUP,
false);
ss.Owner = this;
if (ss.ShowDialog() ?? false)
{
_Controller.RestoreApp(
_AppGroup,
new DeletedAppCollection(delApp),
_DeletedApps,
appType,
ss.NewName
);
}
return;
}
_Controller.RestoreApp(
_AppGroup,
new DeletedAppCollection(delApp),
_DeletedApps,
null,
null
);
}
/// <summary>
/// Picks a simple selector from the stream of tokens.
/// </summary>
/// <param name="tokens">The stream of tokens to consider.</param>
public void PickSelector(IEnumerator <CssToken> tokens)
{
switch (tokens.Current.Type)
{
//Begin of attribute [A]
case CssTokenType.SquareBracketOpen:
OnAttribute(tokens);
break;
//Begin of Pseudo :P
case CssTokenType.Colon:
OnColon(tokens);
break;
//Begin of ID #I
case CssTokenType.Hash:
Insert(SimpleSelector.Id(((CssKeywordToken)tokens.Current).Data));
break;
//Begin of Type E
case CssTokenType.Ident:
Insert(SimpleSelector.Type(((CssKeywordToken)tokens.Current).Data));
break;
//Whitespace could be significant
case CssTokenType.Whitespace:
Insert(CssCombinator.Descendent);
break;
//Various
case CssTokenType.Delim:
OnDelim(tokens);
break;
case CssTokenType.Comma:
InsertOr();
break;
default:
if (!ignoreErrors)
{
throw new DOMException(ErrorCode.SyntaxError);
}
break;
}
}
/// <summary>
/// Invoked once a delimiter has been found in the token enumerator.
/// </summary>
/// <param name="tokens">The token source.</param>
public void OnDelim(IEnumerator <CssToken> tokens)
{
var chr = ((CssDelimToken)tokens.Current).Data;
switch (chr)
{
case Specification.COMMA:
InsertOr();
break;
case Specification.GT:
Insert(CssCombinator.Child);
break;
case Specification.PLUS:
Insert(CssCombinator.AdjacentSibling);
break;
case Specification.TILDE:
Insert(CssCombinator.Sibling);
break;
case Specification.ASTERISK:
Insert(SimpleSelector.All);
break;
case Specification.DOT:
if (tokens.MoveNext() && tokens.Current.Type == CssTokenType.Ident)
{
var cls = (CssKeywordToken)tokens.Current;
Insert(SimpleSelector.Class(cls.Data));
}
else if (!ignoreErrors)
{
throw new DOMException(ErrorCode.SyntaxError);
}
else
{
return;
}
break;
}
}
/// <summary>
/// General state.
/// </summary>
/// <param name="token">The token to examine.</param>
/// <returns>True if no error occurred, otherwise false.</returns>
Boolean OnData(CssToken token)
{
switch (token.Type)
{
//Begin of attribute [A]
case CssTokenType.SquareBracketOpen:
attrName = null;
attrValue = null;
attrOp = String.Empty;
state = State.Attribute;
return(true);
//Begin of Pseudo :P
case CssTokenType.Colon:
state = State.PseudoClass;
return(true);
//Begin of ID #I
case CssTokenType.Hash:
Insert(SimpleSelector.Id(token.Data));
return(true);
//Begin of Type E
case CssTokenType.Ident:
Insert(SimpleSelector.Type(token.Data));
return(true);
//Whitespace could be significant
case CssTokenType.Whitespace:
Insert(CssCombinator.Descendent);
return(true);
//Various
case CssTokenType.Delim:
return(OnDelim(token));
case CssTokenType.Comma:
InsertOr();
return(true);
}
return(false);
}
string ExtractSimpleSelector(BaseSelector selector)
{
SimpleSelector simpleSelector = selector as SimpleSelector;
if (simpleSelector != null)
{
return(selector.ToString());
}
AggregateSelectorList selectorList = selector as AggregateSelectorList;
// Work around a strange parser issue where sometimes simple selectors
// are wrapped inside SelectorList with no delimiter
if (selectorList != null && selectorList.Delimiter == string.Empty)
{
return(selectorList.ToString());
}
return(string.Empty);
}
public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
{
SimpleSelector sel = (SimpleSelector)item;
if (!WESettings.GetBoolean(WESettings.Keys.ValidateStarSelector) || !sel.IsValid || context == null)
{
return(ItemCheckResult.Continue);
}
if (sel.Text == "*")
{
string errorMessage = string.Format(CultureInfo.InvariantCulture, Resources.PerformanceDontUseStarSelector);
SimpleErrorTag tag = new SimpleErrorTag(sel, errorMessage);
context.AddError(tag);
}
return(ItemCheckResult.Continue);
}
/// <summary>
/// Invoked once a colon has been found in the token enumerator.
/// </summary>
/// <param name="token">The token.</param>
/// <returns>True if no error occurred, otherwise false.</returns>
Boolean OnPseudoElement(CssToken token)
{
state = State.Data;
if (token.Type == CssTokenType.Ident)
{
var data = token.Data;
switch (data)
{
case pseudoElementBefore:
Insert(SimpleSelector.PseudoElement(MatchBefore, pseudoElementBefore));
return(true);
case pseudoElementAfter:
Insert(SimpleSelector.PseudoElement(MatchAfter, pseudoElementAfter));
return(true);
case pseudoElementSelection:
Insert(SimpleSelector.PseudoElement(el => true, pseudoElementSelection));
return(true);
case pseudoElementFirstLine:
Insert(SimpleSelector.PseudoElement(MatchFirstLine, pseudoElementFirstLine));
return(true);
case pseudoElementFirstLetter:
Insert(SimpleSelector.PseudoElement(MatchFirstLetter, pseudoElementFirstLetter));
return(true);
default:
Insert(SimpleSelector.PseudoElement(el => false, data));
return(false);
}
}
return(false);
}
public SimpleSelector ParseSimpleSelector()
{
var selector = new SimpleSelector()
{
TagName = null, Id = null, Classes = new List <string>()
};
while (!EOF())
{
var c = NextChar();
if (c == '#')
{
ConsumeChar();
selector.Id = ParseIdentifier();
}
else if (c == '.')
{
ConsumeChar();
selector.Classes.Add(ParseIdentifier());
}
else if (c == '*')
{
selector.Id = "*";
selector.Classes.Add("*");
selector.TagName = "*";
ConsumeChar();
}
else if (ValidIdentifierChar(c))
{
selector.TagName = ParseIdentifier();
}
else
{
break;
}
}
return(selector);
}
private string ExtractSimpleSelector(BaseSelector selector)
{
SimpleSelector simpleSelector = selector as SimpleSelector;
string result;
if (simpleSelector != null)
{
result = selector.ToString();
}
else
{
AggregateSelectorList aggregateSelectorList = selector as AggregateSelectorList;
if (aggregateSelectorList != null && aggregateSelectorList.Delimiter == string.Empty)
{
result = aggregateSelectorList.ToString();
}
else
{
result = string.Empty;
}
}
return(result);
}
public NotExpression(SimpleSelector inner)
{
Inner = inner;
}
void simpleselector(out SimpleSelector ss)
{
ss = ss = new SimpleSelector {ElementName = ""}; // Build a C# Simple Selector
string psd;
Model.Attribute attribute;
var parent = ss;
string ident;
if (StartOf(13)) {
if (la.kind == 24) {
Get();
ss.ElementName += "-";
}
identity(out ident);
ss.ElementName += ident;
} else if (la.kind == 32) {
Get();
ss.ElementName = "*";
} else if (la.kind == 33) {
Get();
ss.Combinator = Combinator.Namespace; ss.ElementName = "|";
} else if (StartOf(14)) {
if (la.kind == 34) {
Get();
if (la.kind == 24) {
Get();
ss.ID = "-";
}
identity(out ident);
if (ss.ID == null) { ss.ID = ident; } else { ss.ID += ident; }
} else if (la.kind == 35) {
Get();
ss.Class = "";
if (la.kind == 24) {
Get();
ss.Class += "-";
}
identity(out ident);
ss.Class += ident;
} else if (la.kind == 36) {
attrib(out attribute);
ss.Attribute = attribute;
} else {
pseudo(out psd);
ss.Pseudo = psd;
}
} else SynErr(57);
while (StartOf(14)) {
var child = new SimpleSelector(); // Now find optional child selectors
if(t.col + t.val.Length < la.col){
child.ElementName = "";
}
if (la.kind == 34) {
Get();
if (la.kind == 24) {
Get();
child.ID = "-";
}
identity(out ident);
if (child.ID == null) { child.ID = ident; }
else { child.ID += "-"; }
} else if (la.kind == 35) {
Get();
child.Class = "";
if (la.kind == 24) {
Get();
child.Class += "-";
}
identity(out ident);
child.Class += ident;
} else if (la.kind == 36) {
attrib(out attribute);
child.Attribute = attribute;
} else {
pseudo(out psd);
child.Pseudo = psd;
}
parent.Child = child; parent = child;
}
}
