public static void TestMarkElement()
{
var root = HtmlHelper.FixtureElement;
var markElement1 = new MarkElement();
Assert.NotNull(markElement1, "MarkElement created");
Assert.AreEqual(markElement1.TagName, "MARK");
var p = new HTMLParagraphElement();
root.AppendChild(p);
markElement1.Id = "markElement1";
p.AppendChild(markElement1);
markElement1.InnerHTML = "I'm highlighted";
var m1 = Document.GetElementById("markElement1");
Assert.AreEqual("I'm highlighted", m1.InnerHTML, "m1.InnerHTML");
var markElement2 = new MarkElement();
markElement2.Id = "markElement2";
p.AppendChild(markElement2);
markElement2.InnerHTML = "Me too";
var m2 = Document.GetElementById("markElement2");
Assert.AreEqual("Me too", m2.InnerHTML, "m2.InnerHTML");
}
private HTMLParagraphElement GetParagraphElement(HTMLDocument htmlDocument, string content)
{
HTMLParagraphElement paragraphElement = (HTMLParagraphElement)htmlDocument.CreateElement("p");
paragraphElement.SetAttribute("class", "title");
Text text = htmlDocument.CreateTextNode(content);
paragraphElement.AppendChild(text);
return(paragraphElement);
}
private static Node InsideParagraph(List <Node> elementList, string paragraphID = null)
{
var currentParagraphElement = new HTMLParagraphElement();
if (!String.IsNullOrWhiteSpace(paragraphID))
{
currentParagraphElement.Id = paragraphID;
}
foreach (var element in elementList)
{
currentParagraphElement.AppendChild(element);
}
return(currentParagraphElement);
}
public static void Main()
{
string myGrammar;
myGrammar = @"{periodo}:{pre_inizio}{frase}; {pre_durante}{frase}; {pre_fine}{frase}
{periodo}:{pre_inizio}{frase}; {pre_durante}{frase}
{periodo}:{pre_inizio}{frase}; {pre_durante}{frase}
{periodo}:{pre_inizio}{frase}; {pre_fine}{frase}
{periodo}:{pre_inizio}{frase}; {pre_fine}{frase}
{periodo}:per {frase_semplice}:<br/> 1. {frase}<br/> 2. {frase}<br/> 3. {frase}
{periodo}:{frase_semplice}: come {frase_semplice} senza {frase_semplice}
{pre_durante}:{contesto_periodo_durante}, il sistema dovrà consentire di
{pre_durante}:{contesto_periodo_durante}, l'obiettivo sarà
{pre_durante}:dovremo, {contesto_periodo_durante}, valutare se
{pre_durante}:forniremo supporto operativo nel
{pre_durante}:decideremo {contesto_periodo_durante}, assieme al Cliente, come
{pre_durante}:sarà fondamentale, {contesto_periodo_durante},
{pre_durante}:sarà prioritario, {contesto_periodo_durante},
{pre_durante}:creeremo, {contesto_periodo_durante}, {soggetto} per
{pre_durante}:svilupperemo {contesto_periodo_durante} {soggetto} per
{pre_durante}:dovremo, {contesto_periodo_durante},
{pre_durante}:e' stato richiesto {contesto_periodo_durante} di
{pre_durante}:il Cliente ha richiesto {contesto_periodo_durante} di
{pre_durante}:ci si aspetta {contesto_periodo_durante} di poter
{pre_durante}:il sistema {contesto_periodo_durante} dovrà
{pre_durante}:il software {contesto_periodo_durante} permetterà di
{pre_durante}:bisognerà {contesto_periodo_durante} valutare, in funzione del budget disponibile, se
{pre_durante}:in vista di future richieste, predisporremo {contesto_periodo_durante} {soggetto} per
{pre_durante}:{contesto_periodo_durante}, un nostro partner si occuperà di {verbo} {soggetto} per
{pre_durante}:{contesto_periodo_durante}, invieremo un nostro tecnico per
{pre_durante}:il reparto R&D si occuperà, {contesto_periodo_durante}, di {verbo} {soggetto} per
{pre_durante}:il tuning di {soggetto} consentirà {contesto_periodo_durante} di
{pre_durante}:si metteranno a calendario {contesto_periodo_durante} le attività per
{pre_durante}:per la messa in produzione, sarà necessario
{pre_durante}:per non bloccare l'operatività del Cliente, sarà necessario
{pre_durante}:sarà {contesto_periodo_durante} necessario
{pre_durante}:compatibilmente con le tempistiche, il team si occuperà di
{pre_durante}:se non si troverà un modo per {frase_semplice}, dovremo
{pre_durante}:il nostro responsabile tecnico dovrà, {contesto_periodo_durante}, stimare le giornate uomo necessarie per
{pre_durante}:definiremo {contesto_periodo_durante} un workflow per
{pre_durante}:si dovrà, {contesto_periodo_durante}, studiare una soluzione integrata per
{pre_durante}:{contesto_periodo_durante}, si dovrà implementare un algoritmo per
{pre_durante}:bisognerà {contesto_periodo_durante}
{pre_durante}:valutaremo {contesto_periodo_durante} l'uso di {soggetto} per
{pre_durante}:si valuterà, {contesto_periodo_durante}, se sia possibile
{pre_durante}:si ritiene opportuno, {contesto_periodo_durante},
{pre_durante}:la soluzione sarà progettata per
{pre_durante}:sarà aggiunto {contesto_periodo_durante} un campo per
{pre_durante}:le modifiche coinvolgeranno {soggetto} così da
{pre_durante}:gli interventi {contesto_periodo_durante} saranno funzionali a
{verbo}:aggiornare
{verbo}:automatizzare la creazione di
{verbo}:censire
{verbo}:configurare
{verbo}:compattare
{verbo}:compilare
{verbo}:connettere in https {soggetto} con
{verbo}:controllare da remoto
{verbo}:convertire in Unicode
{verbo}:creare un modello per
{verbo}:creare
{verbo}:duplicare
{verbo}:deduplicare
{verbo}:ridefinire
{verbo}:dimensionare
{verbo}:decentralizzare
{verbo}:elaborare
{verbo}:estrarre
{verbo}:fare il refactoring di
{verbo}:fare l'upgrade di
{verbo}:fornire l'accesso a
{verbo}:generare ex novo
{verbo}:gestire
{verbo}:identificare
{verbo}:importare
{verbo}:incapsulare
{verbo}:interconnettere {soggetto} con
{verbo}:monitorare
{verbo}:mettere in cluster
{verbo}:ottimizzare
{verbo}:prototipare
{verbo}:rappresentare
{verbo}:redirezionare
{verbo}:remotizzare
{verbo}:rendere multilingua
{verbo}:rendere Service Oriented
{verbo}:gestire in modo proattivo
{verbo}:simulare
{verbo}:standardizzare
{verbo}:taggare
{verbo}:testare
{verbo}:validare
{verbo}:migliorare l'uptime di
{verbo}:virtualizzare
{verbo}:verticalizzare
{verbo}:verificare la compatibilità di
{verbo}:normalizzare
{complemento_complesso}: (anche {complemento})
{complemento_complesso}: (meglio {complemento})
{complemento_complesso}: (preferibilmente {complemento})
{complemento_complesso}: (possibilmente {complemento})
{complemento_complesso}: (opzionalmente {complemento})
{complemento_complesso}: (il tutto {complemento})
{complemento_complesso}: (in corso d'opera si valuterà se operare {complemento} o meno)
{contesto_periodo_durante}:poi
{contesto_periodo_durante}:in seguito
{contesto_periodo_durante}:quindi
{contesto_periodo_durante}:perciò
{contesto_periodo_durante}:contestualmente
{contesto_periodo_durante}:inoltre
{contesto_periodo_durante}:successivamente
{pre_inizio}:{contesto_periodo_inizio}, il sistema dovrà consentire di
{pre_inizio}:{contesto_periodo_inizio}, l'obiettivo sarà
{pre_inizio}:dovremo, {contesto_periodo_inizio}, valutare se
{pre_inizio}:forniremo supporto operativo nel
{pre_inizio}:decideremo {contesto_periodo_inizio}, assieme al Cliente, come
{pre_inizio}:sarà fondamentale, {contesto_periodo_inizio},
{pre_inizio}:sarà prioritario, {contesto_periodo_inizio},
{pre_inizio}:creeremo, {contesto_periodo_inizio}, {soggetto} per
{pre_inizio}:svilupperemo {contesto_periodo_inizio} {soggetto} per
{pre_inizio}:dovremo, {contesto_periodo_inizio},
{pre_inizio}:e' stato richiesto {contesto_periodo_inizio} di
{pre_inizio}:il Cliente ha richiesto {contesto_periodo_inizio} di
{pre_inizio}:ci si aspetta {contesto_periodo_inizio} di poter
{pre_inizio}:il sistema {contesto_periodo_inizio} dovrà
{pre_inizio}:il software {contesto_periodo_inizio} permetterà di
{pre_inizio}:bisognerà {contesto_periodo_inizio} valutare, in funzione del budget disponibile, se
{pre_inizio}:in vista di future richieste, predisporremo {contesto_periodo_inizio} {soggetto} per
{pre_inizio}:{contesto_periodo_inizio}, un nostro partner si occuperà di {verbo} {soggetto} per
{pre_inizio}:{contesto_periodo_inizio}, invieremo un nostro tecnico per
{pre_inizio}:il reparto R&D si occuperà, {contesto_periodo_inizio}, di {verbo} {soggetto} per
{pre_inizio}:il tuning di {soggetto} consentirà {contesto_periodo_inizio} di
{pre_inizio}:si metteranno a calendario {contesto_periodo_inizio} le attività per
{pre_inizio}:per la messa in produzione, sarà necessario
{pre_inizio}:per non bloccare l'operatività del Cliente, sarà necessario
{pre_inizio}:sarà {contesto_periodo_inizio} necessario
{pre_inizio}:compatibilmente con le tempistiche, il team si occuperà di
{pre_inizio}:se non si troverà un modo per {frase_semplice}, dovremo
{pre_inizio}:il nostro responsabile tecnico dovrà, {contesto_periodo_inizio}, stimare le giornate uomo necessarie per
{pre_inizio}:definiremo {contesto_periodo_inizio} un workflow per
{pre_inizio}:si dovrà, {contesto_periodo_inizio}, studiare una soluzione integrata per
{pre_inizio}:{contesto_periodo_inizio}, si dovrà implementare un algoritmo per
{pre_inizio}:bisognerà {contesto_periodo_inizio}
{pre_inizio}:valutaremo {contesto_periodo_inizio} l'uso di {soggetto} per
{pre_inizio}:si valuterà, {contesto_periodo_inizio}, se sia possibile
{pre_inizio}:si ritiene opportuno, {contesto_periodo_inizio},
{pre_inizio}:la soluzione sarà progettata per
{pre_inizio}:sarà aggiunto {contesto_periodo_inizio} un campo per
{pre_inizio}:le modifiche coinvolgeranno {soggetto} così da
{pre_inizio}:gli interventi {contesto_periodo_inizio} saranno funzionali a
{pre}:{contesto_periodo}, il sistema dovrà consentire di
{pre}:{contesto_periodo}, l'obiettivo sarà
{pre}:dovremo, {contesto_periodo}, valutare se
{pre}:forniremo supporto operativo nel
{pre}:decideremo {contesto_periodo}, assieme al Cliente, come
{pre}:sarà fondamentale, {contesto_periodo},
{pre}:sarà prioritario, {contesto_periodo},
{pre}:creeremo, {contesto_periodo}, {soggetto} per
{pre}:svilupperemo {contesto_periodo} {soggetto} per
{pre}:dovremo, {contesto_periodo},
{pre}:e' stato richiesto {contesto_periodo} di
{pre}:il Cliente ha richiesto {contesto_periodo} di
{pre}:ci si aspetta {contesto_periodo} di poter
{pre}:il sistema {contesto_periodo} dovrà
{pre}:il software {contesto_periodo} permetterà di
{pre}:bisognerà {contesto_periodo} valutare, in funzione del budget disponibile, se
{pre}:in vista di future richieste, predisporremo {contesto_periodo} {soggetto} per
{pre}:{contesto_periodo}, un nostro partner si occuperà di {verbo} {soggetto} per
{pre}:{contesto_periodo}, invieremo un nostro tecnico per
{pre}:il reparto R&D si occuperà, {contesto_periodo}, di {verbo} {soggetto} per
{pre}:il tuning di {soggetto} consentirà {contesto_periodo} di
{pre}:si metteranno a calendario {contesto_periodo} le attività per
{pre}:per la messa in produzione, sarà necessario
{pre}:per non bloccare l'operatività del Cliente, sarà necessario
{pre}:sarà {contesto_periodo} necessario
{pre}:compatibilmente con le tempistiche, il team si occuperà di
{pre}:se non si troverà un modo per {frase_semplice}, dovremo
{pre}:il nostro responsabile tecnico dovrà, {contesto_periodo}, stimare le giornate uomo necessarie per
{pre}:definiremo {contesto_periodo} un workflow per
{pre}:si dovrà, {contesto_periodo}, studiare una soluzione integrata per
{pre}:{contesto_periodo}, si dovrà implementare un algoritmo per
{pre}:bisognerà {contesto_periodo}
{pre}:valutaremo {contesto_periodo} l'uso di {soggetto} per
{pre}:si valuterà, {contesto_periodo}, se sia possibile
{pre}:si ritiene opportuno, {contesto_periodo},
{pre}:la soluzione sarà progettata per
{pre}:sarà aggiunto {contesto_periodo} un campo per
{pre}:le modifiche coinvolgeranno {soggetto} così da
{pre}:gli interventi {contesto_periodo} saranno funzionali a
{contesto_periodo_fine}:infine
{contesto_periodo_fine}:contestualmente
{contesto_periodo_fine}:al momento della consegna
{contesto_periodo_fine}:al termine dell'attività
{contesto_periodo_fine}:prima del collaudo finale
{contesto_periodo_fine}:in conclusione
{contesto_periodo_fine}:al termine dei lavori
{contesto_periodo_fine}:a completamento del progetto
{contesto_periodo_fine}:terminata la realizzazione
{contesto_periodo}:
{titolo}:{frase_semplice}
{titolo}:{frase_semplice} e {frase_semplice}
{titolo}:{frase_semplice}: come {frase_semplice}
{titolo}:{frase_semplice}: analisi tecnica
{titolo}:{frase_semplice}: studio di fattibilità
{titolo}:come {frase_semplice}
{titolo}:{soggetto}: implementazione
{titolo}:{soggetto}: valutazione
{titolo}:{soggetto}
{titolo}:{soggetto} {complemento}
{titolo}:come {verbo} {soggetto}
{titolo}:connettere {soggetto} con {soggetto}
{titolo}:integrazione per {verbo} {soggetto}
{frase}:{frase_semplice}{complemento_opzionale}
{frase_semplice}:{verbo} {soggetto}
{complemento}:ad alta coesione
{complemento}:ad alta usabilità
{complemento}:ad alta scalabilità
{complemento}:ad alte performance
{complemento}:ad hoc
{complemento}:a plug-in
{complemento}:da un Iphone
{complemento}:embedded
{complemento}:riassegnando le priorità
{complemento}:automaticamente
{complemento}:client-server
{complemento}:con aspect oriented programming
{complemento}:con cache
{complemento}:con codifica Json
{complemento}:con metodologie agili
{complemento}:con filtro dinamico
{complemento}:con Scrum
{complemento}:con un plugin di wordpress
{complemento}:notificando il tutto con twitter
{complemento}:con notifica asincrona
{complemento}:con parametri
{complemento}:con ridondanza
{complemento}:con un'interfaccia astratta
{complemento}:da palmare
{complemento}:da Android o IPhone
{complemento}:domain driven
{complemento}:event-driven
{complemento}:high-integrity
{complemento}:in Ajax
{complemento}:condividendo le informazioni
{complemento}:in base a un file di configurazione
{complemento}:in bytecode
{complemento}:in funzione dell'utente
{complemento}:in logica combinatoria
{complemento}:in multithreading
{complemento}:ricorsivamente
{complemento}:in modalità concorrente
{complemento}:in modo sincrono
{complemento}:in modalità contestuale
{complemento}:in Ruby
{complemento}:in Python
{complemento}:in html5
{complemento}:in una logica distribuita
{complemento}:just in time
{complemento}:lato server
{complemento}:lato client
{complemento}:offline
{complemento}:on demand
{complemento}:one-to-one
{complemento}:seo oriented
{complemento}:rimanendo cross platform
{complemento}:secondo una logica Web 2.0
{complemento}:state-less
{complemento}:uno a molti
{complemento}:utilizzando attributi
{complemento}:via Sms
{complemento}:ottimizzando per i motori di ricerca
{complemento}:W3C compliant
{complemento}:multicore
{complemento}:nei tempi previsti
{complemento}:autonomamente
{complemento}:aggiornando {soggetto} in automatico
{complemento}:mediante {soggetto} Open Source
{complemento}:attraverso un algoritmo basato su {soggetto}
{complemento}:con accesso diretto a {soggetto}
{complemento}:con {soggetto} per il load balancing
{complemento}:con {soggetto} su Linux
{complemento}:con {soggetto} su Solaris
{complemento}:proattivamente
{complemento}:tramite aggiornamento di {soggetto}
{complemento}:comunicando con {soggetto}
{complemento}:delegando a {soggetto} la security
{complemento}:con un token fornito da {soggetto}
{complemento}:mediante l'aggiunta di {soggetto}
{complemento}:mantenendo la compatibilità con .net 2.0
{complemento}:mantenendo la retrocompatibilità
{complemento}:secondo un protocollo concordato
{complemento}:su Excel
{complemento}:mediante un proxy COM
{complemento}:in realtime
{complemento}:dando notifica a {soggetto} in realtime
{complemento}:organizzando {soggetto} in base a {soggetto}
{complemento}:prevedendo {soggetto} di backup
{complemento}:creando {soggetto} in funzione di {soggetto}
{complemento}:ricorrendo eventualmente a {soggetto}
{complemento}:usando {soggetto} come proxy
{complemento}:usando {soggetto} come provider
{complemento}:utilizzando {soggetto} come sorgente
{complemento}:utilizzando {soggetto}
{complemento}:validando {soggetto}
{complemento}:verificando {soggetto} attraverso {soggetto}
{complemento}:di nicchia
{complemento}:con i consueti strumenti
{complemento}:{complemento_complesso}
{complemento}:{complemento_complesso}
{complemento}:{complemento_complesso}
{complemento}:{complemento_complesso}
{pre_opzionale}:
{pre_opzionale}:{pre}
{soggetto}:un db relazionale
{soggetto}:un'architettura a livelli
{soggetto}:un mockup
{soggetto}:un proxy
{soggetto}:un device esterno
{soggetto}:un server virtualizzato
{soggetto}:un applicativo Java
{soggetto}:un controller Mvc
{soggetto}:un social network verticale
{soggetto}:un cubo Olap
{soggetto}:API asincrone
{soggetto}:una coda di messaggi
{soggetto}:set di dati disconnessi
{soggetto}:un profilo Facebook
{soggetto}:librerie Enterprise Java Beans
{soggetto}:entità logiche
{soggetto}:un flusso bidirezionale
{soggetto}:flussi di informazione
{soggetto}:un firmware
{soggetto}:una Gui interattiva
{soggetto}:un header JMS
{soggetto}:un set di oggetti connessi
{soggetto}:uno o più oggetti Pojo
{soggetto}:oggetti remoti
{soggetto}:una pagina Web
{soggetto}:una o più mappe logiche
{soggetto}:matrici bidimensionali
{soggetto}:messaggi Soap
{soggetto}:record strutturati
{soggetto}:proprietà read-only
{soggetto}:dei record di dati
{soggetto}:una libreria di funzioni customizzabili
{soggetto}:un Rss feed
{soggetto}:sistemi di autenticazione Ldap
{soggetto}:sistemi Active Directory
{soggetto}:sistemi distribuiti
{soggetto}:soggetti attivi
{soggetto}:strutture eterogenee
{soggetto}:uno stream Xml
{soggetto}:un account virtuale
{soggetto}:un applicativo Silverlight
{soggetto}:messaggi Corba
{soggetto}:un grafo bilanciato
{soggetto}:un indice univoco
{soggetto}:un log di eventi
{soggetto}:un oggetto clustered
{soggetto}:un sistema Web 3.0
{soggetto}:un sistema ecommerce
{soggetto}:un sistema distribuito
{soggetto}:un accesso differenziato
{soggetto}:un Web Service
{soggetto}:un social network
{soggetto}:un campo automatico
{complemento_opzionale}: {complemento}
{complemento_opzionale}:
{complemento_opzionale}:
{complemento_opzionale}:
{negazione_opzionale}:non
{negazione_opzionale}:
{contesto_periodo_inizio}:innanzitutto
{contesto_periodo_inizio}:inizialmente
{contesto_periodo_inizio}:per prima cosa
{contesto_periodo_inizio}:per lo startup
{contesto_periodo_inizio}:nella prima fase
{contesto_periodo_inizio}:nelle fasi iniziali
{contesto_periodo_inizio}:per la prima milestone
{contesto_periodo_inizio}:per la prima demo
{contesto_periodo_inizio}:dapprima
{pre_fine}:{contesto_periodo_fine}, il sistema dovrà consentire di
{pre_fine}:{contesto_periodo_fine}, l'obiettivo sarà
{pre_fine}:dovremo, {contesto_periodo_fine}, valutare se
{pre_fine}:forniremo supporto operativo nel
{pre_fine}:decideremo {contesto_periodo_fine}, assieme al Cliente, come
{pre_fine}:sarà fondamentale, {contesto_periodo_fine},
{pre_fine}:sarà prioritario, {contesto_periodo_fine},
{pre_fine}:creeremo, {contesto_periodo_fine}, {soggetto} per
{pre_fine}:svilupperemo {contesto_periodo_fine} {soggetto} per
{pre_fine}:dovremo, {contesto_periodo_fine},
{pre_fine}:e' stato richiesto {contesto_periodo_fine} di
{pre_fine}:il Cliente ha richiesto {contesto_periodo_fine} di
{pre_fine}:ci si aspetta {contesto_periodo_fine} di poter
{pre_fine}:il sistema {contesto_periodo_fine} dovrà
{pre_fine}:il software {contesto_periodo_fine} permetterà di
{pre_fine}:bisognerà {contesto_periodo_fine} valutare, in funzione del budget disponibile, se
{pre_fine}:in vista di future richieste, predisporremo {contesto_periodo_fine} {soggetto} per
{pre_fine}:{contesto_periodo_fine}, un nostro partner si occuperà di {verbo} {soggetto} per
{pre_fine}:{contesto_periodo_fine}, invieremo un nostro tecnico per
{pre_fine}:il reparto R&D si occuperà, {contesto_periodo_fine}, di {verbo} {soggetto} per
{pre_fine}:il tuning di {soggetto} consentirà {contesto_periodo_fine} di
{pre_fine}:si metteranno a calendario {contesto_periodo_fine} le attività per
{pre_fine}:per la messa in produzione, sarà necessario
{pre_fine}:per non bloccare l'operatività del Cliente, sarà necessario
{pre_fine}:sarà {contesto_periodo_fine} necessario
{pre_fine}:compatibilmente con le tempistiche, il team si occuperà di
{pre_fine}:se non si troverà un modo per {frase_semplice}, dovremo
{pre_fine}:il nostro responsabile tecnico dovrà, {contesto_periodo_fine}, stimare le giornate uomo necessarie per
{pre_fine}:definiremo {contesto_periodo_fine} un workflow per
{pre_fine}:si dovrà, {contesto_periodo_fine}, studiare una soluzione integrata per
{pre_fine}:{contesto_periodo_fine}, si dovrà implementare un algoritmo per
{pre_fine}:bisognerà {contesto_periodo_fine}
{pre_fine}:valutaremo {contesto_periodo_fine} l'uso di {soggetto} per
{pre_fine}:si valuterà, {contesto_periodo_fine}, se sia possibile
{pre_fine}:si ritiene opportuno, {contesto_periodo_fine},
{pre_fine}:la soluzione sarà progettata per
{pre_fine}:sarà aggiunto {contesto_periodo_fine} un campo per
{pre_fine}:le modifiche coinvolgeranno {soggetto} così da
{pre_fine}:gli interventi {contesto_periodo_fine} saranno funzionali a";
// Create a new HTML Button
var button = new HTMLButtonElement();
var paragraph = new HTMLParagraphElement();
var div = new HTMLTextAreaElement();
div.Rows = 5;
div.Cols = 80;
paragraph.AppendChild(div);
button.InnerHTML = "Get some fuffa";
button.OnClick = (ev) =>
{
var parser = new TextParser();
Grammar g;
try
{
g = parser.GrammarFromText(myGrammar);
Sentence result;
result = g.ApplyAllSubstitutions();
div.TextContent = result.FinalOutput;
//Console.WriteLine(result.FinalOutput);
}
catch (Exception ex)
{
Console.WriteLine("Grammar parsing error");
}
};
Document.Body.AppendChild(button);
Document.Body.AppendChild(paragraph);
}
//show the default jquery ui demo
private static void ShowDemo()
{
HTMLDivElement contendElement = new HTMLDivElement();
#region accordion
{
contendElement.AppendChild(new HTMLHeadingElement(HeadingType.H2)
{
TextContent = "Accordion"
});
var accordion = new HTMLDivElement();
accordion.AppendChild(new HTMLHeadingElement(HeadingType.H3)
{
TextContent = "Section 1"
});
var accSec1 = new HTMLDivElement();
accSec1.AppendChild(new HTMLParagraphElement()
{
TextContent = "Mauris mauris ante, blandit et, ultrices a, suscipit eget, quam. Integer ut neque.Vivamus nisi metus, molestie vel, gravida in, condimentum sit amet, nunc.Nam a nibh.Donec suscipit eros.Nam mi.Proin viverra leo ut odio.Curabitur malesuada.Vestibulum a velit eu ante scelerisque vulputate."
});
accordion.AppendChild(accSec1);
accordion.AppendChild(new HTMLHeadingElement(HeadingType.H3)
{
TextContent = "Section 2"
});
var accSec2 = new HTMLDivElement();
accSec2.AppendChild(
new HTMLParagraphElement()
{
TextContent = "Sed non urna. Donec et ante. Phasellus eu ligula. Vestibulum sit amet purus. Vivamus hendrerit, dolor at aliquet laoreet, mauris turpis porttitor velit, faucibus interdum tellus libero ac justo. Vivamus non quam. In suscipit faucibus urna."
});
accordion.AppendChild(accSec2);
accordion.AppendChild(new HTMLHeadingElement(HeadingType.H3)
{
TextContent = "Section 3"
});
var accSec3 = new HTMLDivElement();
accSec3.AppendChild(
new HTMLParagraphElement()
{
TextContent = "Nam enim risus, molestie et, porta ac, aliquam ac, risus. Quisque lobortis. Phasellus pellentesque purus in massa. Aenean in pede. Phasellus ac libero ac tellus pellentesque semper. Sed ac felis. Sed commodo, magna quis lacinia ornare, quam ante aliquam nisi, eu iaculis leo purus venenatis dui."
});
var accSec3Li = new HTMLUListElement();
accSec3Li.AppendChild(new HTMLLIElement()
{
TextContent = "List item one"
});
accSec3Li.AppendChild(new HTMLLIElement()
{
TextContent = "List item two"
});
accSec3Li.AppendChild(new HTMLLIElement()
{
TextContent = "List item three"
});
accSec3.AppendChild(accSec3Li);
accordion.AppendChild(accSec3);
accordion.AppendChild(new HTMLHeadingElement(HeadingType.H3)
{
TextContent = "Section 4"
});
var accSec4 = new HTMLDivElement();
accSec4.AppendChild(
new HTMLParagraphElement()
{
TextContent = "Cras dictum. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Aenean lacinia mauris vel est."
});
accSec4.AppendChild(
new HTMLParagraphElement()
{
TextContent = "Suspendisse eu nisl. Nullam ut libero. Integer dignissim consequat lectus. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos."
});
accordion.AppendChild(accSec4);
accordion.Accordion(new AccordionParameter()
{
HeightStyle = Bridge.jQueryUI.HeightStyles.Content
});
contendElement.AppendChild(accordion);
}
#endregion
#region autocomplete
{
contendElement.AppendChild(new HTMLHeadingElement(HeadingType.H2)
{
TextContent = "Autocomplete"
});
var autocmpl = new HTMLInputElement();
autocmpl.Autocomplete(new AutocompleteParameter()
{
Source = new AutocompleteSource[]
{
new AutocompleteSource("ActionScript"),
new AutocompleteSource("AppleScript"),
new AutocompleteSource("Asp"),
new AutocompleteSource("BASIC"),
new AutocompleteSource("C"),
new AutocompleteSource("C#"),
new AutocompleteSource("C++"),
new AutocompleteSource("Clojure"),
new AutocompleteSource("COBOL"),
new AutocompleteSource("ColdFusion"),
new AutocompleteSource("Erlang"),
new AutocompleteSource("Fortran"),
new AutocompleteSource("Groovy"),
new AutocompleteSource("Haskell"),
new AutocompleteSource("Java"),
new AutocompleteSource("JavaScript"),
new AutocompleteSource("Lisp"),
new AutocompleteSource("Perl"),
new AutocompleteSource("PHP"),
new AutocompleteSource("Python"),
new AutocompleteSource("Ruby"),
new AutocompleteSource("Scala"),
new AutocompleteSource("Scheme"),
},
AppendTo = contendElement
});
contendElement.AppendChild(autocmpl);
}
#endregion
#region buttons
{
contendElement.AppendChild(new HTMLHeadingElement(HeadingType.H2)
{
TextContent = "Buttons"
});
var btn = new HTMLButtonElement()
{
TextContent = "Button"
};
btn.Button();
contendElement.AppendChild(btn);
var icnBtn = new HTMLButtonElement()
{
TextContent = "button with icon"
};
icnBtn.Button(new ButtonParameter()
{
Icon = "ui-icon-gear", ShowLabel = false
});
contendElement.AppendChild(icnBtn);
}
#endregion
#region checkboxradio
{
contendElement.AppendChild(new HTMLHeadingElement(HeadingType.H2)
{
TextContent = "Checkboxes"
});
var outerFieldset = new HTMLFieldSetElement();
outerFieldset.AppendChild(new HTMLLabelElement()
{
TextContent = "Hotel Ratings: "
});
HTMLLabelElement lbl1 = new HTMLLabelElement()
{
HtmlFor = "checkbox-1", TextContent = "2 Star"
};
HTMLInputElement cb1 = new HTMLInputElement()
{
Type = InputType.Checkbox, Name = "checkbox-1", Id = "checkbox-1"
};
HTMLLabelElement lbl2 = new HTMLLabelElement()
{
HtmlFor = "checkbox-2", TextContent = "3 Star"
};
HTMLInputElement cb2 = new HTMLInputElement()
{
Type = InputType.Checkbox, Name = "checkbox-2", Id = "checkbox-2"
};
HTMLLabelElement lbl3 = new HTMLLabelElement()
{
HtmlFor = "checkbox-3", TextContent = "4 Star"
};
HTMLInputElement cb3 = new HTMLInputElement()
{
Type = InputType.Checkbox, Name = "checkbox-3", Id = "checkbox-3"
};
HTMLLabelElement lbl4 = new HTMLLabelElement()
{
HtmlFor = "checkbox-4", TextContent = "5 Star"
};
HTMLInputElement cb4 = new HTMLInputElement()
{
Type = InputType.Checkbox, Name = "checkbox-4", Id = "checkbox-4"
};
outerFieldset.AppendChild(lbl1);
outerFieldset.AppendChild(cb1);
outerFieldset.AppendChild(lbl2);
outerFieldset.AppendChild(cb2);
outerFieldset.AppendChild(lbl3);
outerFieldset.AppendChild(cb3);
outerFieldset.AppendChild(lbl4);
outerFieldset.AppendChild(cb4);
cb1.Checkboxradio();
cb2.Checkboxradio();
cb3.Checkboxradio();
cb4.Checkboxradio();
contendElement.AppendChild(outerFieldset);
contendElement.AppendChild(new HTMLHeadingElement(HeadingType.H2)
{
TextContent = "Radio"
});
var outerFieldset2 = new HTMLFieldSetElement();
outerFieldset2.AppendChild(new HTMLLabelElement()
{
TextContent = "Select a Location: "
});
HTMLLabelElement rlbl1 = new HTMLLabelElement()
{
HtmlFor = "radio-1", TextContent = "New York"
};
HTMLInputElement rd1 = new HTMLInputElement()
{
Type = InputType.Radio, Name = "radio-1", Id = "radio-1"
};
HTMLLabelElement rlbl2 = new HTMLLabelElement()
{
HtmlFor = "radio-2", TextContent = "Paris"
};
HTMLInputElement rd2 = new HTMLInputElement()
{
Type = InputType.Radio, Name = "radio-1", Id = "radio-2"
};
HTMLLabelElement rlbl3 = new HTMLLabelElement()
{
HtmlFor = "radio-3", TextContent = "London"
};
HTMLInputElement rd3 = new HTMLInputElement()
{
Type = InputType.Radio, Name = "radio-1", Id = "radio-3"
};
outerFieldset2.AppendChild(rlbl1);
outerFieldset2.AppendChild(rd1);
outerFieldset2.AppendChild(rlbl2);
outerFieldset2.AppendChild(rd2);
outerFieldset2.AppendChild(rlbl3);
outerFieldset2.AppendChild(rd3);
rd1.Checkboxradio();
rd2.Checkboxradio();
rd3.Checkboxradio();
contendElement.AppendChild(outerFieldset2);
}
#endregion
#region tabs
{
contendElement.AppendChild(new HTMLHeadingElement(HeadingType.H2)
{
TextContent = "Tabs"
});
var tabsdiv = new HTMLDivElement()
{
Id = "tabs"
};
var tabList = new HTMLUListElement();
tabList.AppendChild(new HTMLLIElement().AppendChild(new HTMLAnchorElement()
{
Href = "#tabs-1", TextContent = "Nunc tincidunt"
}).ParentElement);
tabList.AppendChild(new HTMLLIElement().AppendChild(new HTMLAnchorElement()
{
Href = "#tabs-2", TextContent = "Proin dolor"
}).ParentElement);
tabList.AppendChild(new HTMLLIElement().AppendChild(new HTMLAnchorElement()
{
Href = "#tabs-3", TextContent = "Aenean lacinia"
}).ParentElement);
tabsdiv.AppendChild(tabList);
tabsdiv.AppendChild(new HTMLDivElement()
{
Id = "tabs-1"
}.AppendChild(new HTMLParagraphElement()
{
TextContent = "Proin elit arcu, rutrum commodo, vehicula tempus, commodo a, risus. Curabitur nec arcu. Donec sollicitudin mi sit amet mauris. Nam elementum quam ullamcorper ante. Etiam aliquet massa et lorem. Mauris dapibus lacus auctor risus. Aenean tempor ullamcorper leo. Vivamus sed magna quis ligula eleifend adipiscing. Duis orci. Aliquam sodales tortor vitae ipsum. Aliquam nulla. Duis aliquam molestie erat. Ut et mauris vel pede varius sollicitudin. Sed ut dolor nec orci tincidunt interdum. Phasellus ipsum. Nunc tristique tempus lectus."
}).ParentElement);
tabsdiv.AppendChild(new HTMLDivElement()
{
Id = "tabs-2"
}.AppendChild(new HTMLParagraphElement()
{
TextContent = "Morbi tincidunt, dui sit amet facilisis feugiat, odio metus gravida ante, ut pharetra massa metus id nunc. Duis scelerisque molestie turpis. Sed fringilla, massa eget luctus malesuada, metus eros molestie lectus, ut tempus eros massa ut dolor. Aenean aliquet fringilla sem. Suspendisse sed ligula in ligula suscipit aliquam. Praesent in eros vestibulum mi adipiscing adipiscing. Morbi facilisis. Curabitur ornare consequat nunc. Aenean vel metus. Ut posuere viverra nulla. Aliquam erat volutpat. Pellentesque convallis. Maecenas feugiat, tellus pellentesque pretium posuere, felis lorem euismod felis, eu ornare leo nisi vel felis. Mauris consectetur tortor et purus."
}).ParentElement);
tabsdiv.AppendChild(new HTMLDivElement()
{
Id = "tabs-3"
}.AppendChild(new HTMLParagraphElement()
{
TextContent = "Mauris eleifend est et turpis. Duis id erat. Suspendisse potenti. Aliquam vulputate, pede vel vehicula accumsan, mi neque rutrum erat, eu congue orci lorem eget lorem. Vestibulum non ante. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Fusce sodales. Quisque eu urna vel enim commodo pellentesque. Praesent eu risus hendrerit ligula tempus pretium. Curabitur lorem enim, pretium nec, feugiat nec, luctus a, lacus."
}).ParentElement.AppendChild(new HTMLParagraphElement()
{
TextContent = "Duis cursus. Maecenas ligula eros, blandit nec, pharetra at, semper at, magna. Nullam ac lacus. Nulla facilisi. Praesent viverra justo vitae neque. Praesent blandit adipiscing velit. Suspendisse potenti. Donec mattis, pede vel pharetra blandit, magna ligula faucibus eros, id euismod lacus dolor eget odio. Nam scelerisque. Donec non libero sed nulla mattis commodo. Ut sagittis. Donec nisi lectus, feugiat porttitor, tempor ac, tempor vitae, pede. Aenean vehicula velit eu tellus interdum rutrum. Maecenas commodo. Pellentesque nec elit. Fusce in lacus. Vivamus a libero vitae lectus hendrerit hendrerit."
}).ParentElement);
tabsdiv.Tabs();
contendElement.AppendChild(tabsdiv);
}
#endregion
#region dialog
{
contendElement.AppendChild(new HTMLHeadingElement(HeadingType.H2)
{
TextContent = "Dialog"
});
var btnNrm = new HTMLButtonElement()
{
TextContent = "Dialog"
};
var btnMdl = new HTMLButtonElement()
{
TextContent = "Modal Dialog"
};
btnNrm.Button(new ButtonParameter()
{
Icon = "ui-icon-newwin"
});
btnMdl.Button(new ButtonParameter()
{
Icon = "ui-icon-newwin"
});
btnNrm.OnClick += (ev) =>
{
(new HTMLDivElement()
{
TextContent = "Hello I am an dialog"
}).Dialog(new DialogParameter()
{
Title = "Dialog"
});
};
btnMdl.OnClick += (ev) =>
{
var dialogDiv = new HTMLDivElement()
{
TextContent = "I am a modal dialog"
};
dialogDiv.Dialog(new DialogParameter()
{
Title = "Modal Dialog",
Modal = true,
Buttons = new DialogButton[]
{
new DialogButton()
{
Click = () =>
{
dialogDiv.DialogClose();
},
Text = "OK"
},
new DialogButton()
{
Click = () =>
{
dialogDiv.DialogClose();
},
Text = "Cancel"
}
}
});
};
contendElement.AppendChild(btnNrm);
contendElement.AppendChild(btnMdl);
}
#endregion
#region slider
{
contendElement.AppendChild(new HTMLHeadingElement(HeadingType.H2)
{
TextContent = "Slider"
});
var slider = new HTMLDivElement();
slider.Slider();
contendElement.AppendChild(slider);
var val = new HTMLParagraphElement()
{
TextContent = "Value"
};
contendElement.AppendChild(val);
slider.SliderSlide(new System.Action <Bridge.jQueryUI.JqueryEvents, SliderEvent>((ev, ui) =>
{
val.TextContent = "Value: " + ui.Value;
}));
}
#endregion
#region datepicker
{
contendElement.AppendChild(new HTMLHeadingElement(HeadingType.H2)
{
TextContent = "Datepicker"
});
var inp = new HTMLInputElement();
inp.Datepicker();
contendElement.AppendChild(inp);
}
#endregion
#region progressbar
{
contendElement.AppendChild(new HTMLHeadingElement(HeadingType.H2)
{
TextContent = "Progressbar"
});
var div = new HTMLDivElement();
div.Progressbar(new ProgressbarParamter()
{
Max = 100
});
contendElement.AppendChild(div);
var btn = new HTMLButtonElement()
{
TextContent = "Start",
OnClick = (ev) =>
{
div.ProgressbarValue(0);
System.Threading.Tasks.Task.Run(async() =>
{
while (true)
{
int val = div.ProgressbarValue();
val++;
if (val > 100)
{
return;
}
div.ProgressbarValue(val);
await System.Threading.Tasks.Task.Delay(100);
}
});
}
};
btn.Button();
contendElement.AppendChild(btn);
}
#endregion
#region selectmenu
{
contendElement.AppendChild(new HTMLHeadingElement(HeadingType.H2)
{
TextContent = "Selectmenu"
});
var sel = new HTMLSelectElement();
sel.AppendChild(new HTMLOptionElement()
{
TextContent = "Slower"
});
sel.AppendChild(new HTMLOptionElement()
{
TextContent = "Slow"
});
sel.AppendChild(new HTMLOptionElement()
{
TextContent = "Medium"
});
sel.AppendChild(new HTMLOptionElement()
{
TextContent = "Fast"
});
sel.AppendChild(new HTMLOptionElement()
{
TextContent = "Faster"
});
contendElement.AppendChild(sel);
sel.Selectmenu(new SelectmenuParameter()
{
AppendTo = contendElement
});
}
#endregion
#region menu
{
contendElement.AppendChild(new HTMLHeadingElement(HeadingType.H2)
{
TextContent = "Menu"
});
var menu = new HTMLUListElement();
menu.Style.Width = "150px";
menu.AppendChild(new HTMLLIElement()
{
ClassName = "ui-state-disabled"
}.AppendChild(new HTMLDivElement()
{
TextContent = "Toys (n/a)"
}).ParentNode);
menu.AppendChild(new HTMLLIElement().AppendChild(new HTMLDivElement()
{
TextContent = "Books"
}).ParentNode);
menu.AppendChild(new HTMLLIElement().AppendChild(new HTMLDivElement()
{
TextContent = "Clothing"
}).ParentNode);
menu.AppendChild(new HTMLLIElement().AppendChild(new HTMLDivElement()
{
TextContent = "Electronics"
}).ParentNode
.AppendChild(new HTMLUListElement()
.AppendChild(new HTMLLIElement()
{
ClassName = "ui-state-disabled"
}.AppendChild(new HTMLDivElement()
{
TextContent = "Home Entertainment"
}).ParentNode).ParentNode
.AppendChild(new HTMLLIElement().AppendChild(new HTMLDivElement()
{
TextContent = "Car Hifi"
}).ParentNode).ParentNode
.AppendChild(new HTMLLIElement().AppendChild(new HTMLDivElement()
{
TextContent = "Utilities"
}).ParentNode).ParentNode
).ParentNode);
menu.AppendChild(new HTMLLIElement().AppendChild(new HTMLDivElement()
{
TextContent = "Movies"
}).ParentNode);
menu.AppendChild(new HTMLLIElement().AppendChild(new HTMLDivElement()
{
TextContent = "Music"
}).ParentNode
.AppendChild(new HTMLUListElement()
.AppendChild(new HTMLLIElement().AppendChild(new HTMLDivElement()
{
TextContent = "Rock"
}).ParentNode
.AppendChild(new HTMLUListElement()
.AppendChild(new HTMLLIElement().AppendChild(new HTMLDivElement()
{
TextContent = "Alternative"
}).ParentNode).ParentNode
.AppendChild(new HTMLLIElement().AppendChild(new HTMLDivElement()
{
TextContent = "Classics"
}).ParentNode).ParentNode
).ParentNode
).ParentNode
.AppendChild(new HTMLLIElement().AppendChild(new HTMLDivElement()
{
TextContent = "Jazz"
}).ParentNode
.AppendChild(new HTMLUListElement()
.AppendChild(new HTMLLIElement().AppendChild(new HTMLDivElement()
{
TextContent = "Freejazz"
}).ParentNode).ParentNode
.AppendChild(new HTMLLIElement().AppendChild(new HTMLDivElement()
{
TextContent = "Big Band"
}).ParentNode).ParentNode
.AppendChild(new HTMLLIElement().AppendChild(new HTMLDivElement()
{
TextContent = "Modern"
}).ParentNode).ParentNode
).ParentNode
).ParentNode
.AppendChild(new HTMLLIElement().AppendChild(new HTMLDivElement()
{
TextContent = "Pop"
}).ParentNode).ParentNode
).ParentNode);
menu.AppendChild(new HTMLLIElement()
{
ClassName = "ui-state-disabled"
}.AppendChild(new HTMLDivElement()
{
TextContent = "Specials (n/a)"
}).ParentNode);
menu.Menu();
contendElement.AppendChild(menu);
}
#endregion
#region tooltip
{
contendElement.AppendChild(new HTMLHeadingElement(HeadingType.H2)
{
TextContent = "Tooltip"
});
var para = new HTMLParagraphElement();
var ttlink = new HTMLAnchorElement()
{
Href = "#", TextContent = "Tooltips", Title = "That's what this widget is"
};
ttlink.Tooltip();
para.AppendChild(ttlink);
para.AppendChild(new Text(" can be attached to any element. When you hover the element with your mouse, the title attribute is displayed in a little box next to the element, just like a native tooltip."));
contendElement.AppendChild(para);
}
#endregion
#region errorhigh
{
contendElement.AppendChild(new HTMLHeadingElement(HeadingType.H2)
{
TextContent = "Highlight / Error"
});
var highlight = new HTMLDivElement();
highlight.Highlight("Hey!", " Sample ui-state-highlight style.");
contendElement.AppendChild(highlight);
contendElement.AppendChild(new HTMLBRElement());
var error = new HTMLDivElement();
error.Error("Hey!", "Sample ui-state-error style.");
contendElement.AppendChild(error);
}
#endregion
contendElement.Dialog(new DialogParameter()
{
Buttons = new DialogButton[] {
new DialogButton()
{
Click = () => { contendElement.DialogClose(); },
Text = "Close"
}
},
Height = 600,
Width = 900,
Title = "jQueryUi Demo Elements"
});
}