public static Annotation GetAnnotationDetail(Guid annotationId, SqlDataAccess sda)
{
Annotation returnValue = new Annotation();
try
{
#region | SQL QUERY |
string query = @"SELECT
A.AnnotationId
,A.MimeType
,A.FileName
,A.DocumentBody
FROM
Annotation A
WHERE
A.AnnotationId = '{0}'";
#endregion
DataTable dt = sda.getDataTable(string.Format(query, annotationId));
if (dt != null && dt.Rows.Count > 0)
{
returnValue.AnnotationId = (Guid)dt.Rows[0]["AnnotationId"];
returnValue.MimeType = dt.Rows[0]["MimeType"] != DBNull.Value ? dt.Rows[0]["MimeType"].ToString() : string.Empty;
returnValue.FileName = dt.Rows[0]["FileName"] != DBNull.Value ? dt.Rows[0]["FileName"].ToString() : string.Empty;
returnValue.File = dt.Rows[0]["DocumentBody"] != DBNull.Value ? dt.Rows[0]["DocumentBody"].ToString() : string.Empty;
}
}
catch (Exception)
{
}
return returnValue;
}
internal WidgetActions(
Annotation parent,
PdfDirectObject baseObject
)
: base(parent, baseObject)
{
}
/// <summary>
/// Executes Sentiment and EntitiesMentioned analysis.
/// </summary>
public IOutcome<AnalysisResult> Analyze(StanfordCoreNLP pipeline, string text)
{
//Create annotated document
Annotation doc = new Annotation(text);
pipeline.annotate(doc);
//Validate
var sentences = doc.get(typeof(CoreAnnotations.SentencesAnnotation));
if (sentences == null)
return Outcomes.Outcomes
.Failure<AnalysisResult>()
.WithMessage("No sentences detected.");
//Analyze
var result = new AnalysisResult()
{
Sentiment = GetSentiment((ArrayList)sentences),
MentionedEntities = GetMentions(doc)
};
return Outcomes.Outcomes
.Success<AnalysisResult>()
.WithValue(result);
}
/// <summary>
/// Prompts the user to edit an annotation.
/// </summary>
public Annotation ShowDialog(Session session, Annotation annotation, string caption)
{
if (caption != null)
{
this.Text = caption;
}
m_session = session;
if (annotation == null)
{
annotation = new Annotation();
annotation.AnnotationTime = DateTime.UtcNow;
annotation.UserName = Environment.GetEnvironmentVariable("USERNAME");
annotation.Message = "<insert your message here>";
}
AnnotationTimeDP.Value = annotation.AnnotationTime;
UserNameTB.Text = annotation.UserName;
CommentTB.Text = annotation.Message;
if (ShowDialog() != DialogResult.OK)
{
return null;
}
annotation = new Annotation();
annotation.AnnotationTime = AnnotationTimeDP.Value;
annotation.UserName = UserNameTB.Text;
annotation.Message = CommentTB.Text;
return annotation;
}
private void AddToAnnotationCache(Annotation key)
{
if (_annotCache.ContainsKey(key))
RemoveFromAnnotationCache(key);
_annotCache.Add(key, AnnotationRendererFactory.Default.Create(key));
}
/// <summary>
/// Create an android InnerClass annotation and attach it to the given provider.
/// </summary>
public static void AddInnerClassAnnotation(this IAnnotationProvider provider, string simpleName, AccessFlags accessFlags)
{
var annotation = new Annotation { Type = new ClassReference("dalvik/annotation/InnerClass"), Visibility = AnnotationVisibility.System };
annotation.Arguments.Add(new AnnotationArgument("name", simpleName));
annotation.Arguments.Add(new AnnotationArgument("accessFlags", (int)accessFlags));
provider.Annotations.Add(annotation);
}
static void Main()
{
// Path to the folder with models extracted from `stanford-corenlp-3.7.0-models.jar`
var jarRoot = @"..\..\..\..\paket-files\nlp.stanford.edu\stanford-corenlp-full-2016-10-31\models";
// Text for processing
var text = "Kosgi Santosh sent an email to Stanford University. He didn't get a reply.";
// Annotation pipeline configuration
var props = new Properties();
props.setProperty("annotators", "tokenize, ssplit, pos, lemma, parse, ner,dcoref");
props.setProperty("ner.useSUTime", "0");
// We should change current directory, so StanfordCoreNLP could find all the model files automatically
var curDir = Environment.CurrentDirectory;
Directory.SetCurrentDirectory(jarRoot);
var pipeline = new StanfordCoreNLP(props);
Directory.SetCurrentDirectory(curDir);
// Annotation
var annotation = new Annotation(text);
pipeline.annotate(annotation);
// Result - Pretty Print
using (var stream = new ByteArrayOutputStream())
{
pipeline.prettyPrint(annotation, new PrintWriter(stream));
Console.WriteLine(stream.toString());
stream.close();
}
}
/// <summary>
/// Creates a <c>Parameter</c> using the provided constructor
/// and the XML annotation. The parameter produced contains all
/// information related to the constructor parameter. It knows the
/// name of the XML entity, as well as the type.
/// </summary>
/// <param name="method">
/// this is the constructor the parameter exists in
/// </param>
/// <param name="label">
/// represents the XML annotation for the contact
/// </param>
/// <returns>
/// returns the parameter instantiated for the field
/// </returns>
public Parameter GetInstance(Constructor method, Annotation label, int index) {
Constructor factory = GetConstructor(label);
if(!factory.isAccessible()) {
factory.setAccessible(true);
}
return (Parameter)factory.newInstance(method, label, index);
}
/// <summary>
/// Create annotations for all included attributes
/// </summary>
public static void Create(AssemblyCompiler compiler, ICustomAttributeProvider attributeProvider,
IAnnotationProvider annotationProvider, DexTargetPackage targetPackage, bool customAttributesOnly = false)
{
if (!attributeProvider.HasCustomAttributes)
return;
var annotations = new List<Annotation>();
foreach (var attr in attributeProvider.CustomAttributes)
{
var attributeType = attr.AttributeType.Resolve();
if (!attributeType.HasIgnoreAttribute())
{
Create(compiler, attr, attributeType, annotations, targetPackage);
}
}
if (annotations.Count > 0)
{
// Create 1 IAttributes annotation
var attrsAnnotation = new Annotation { Visibility = AnnotationVisibility.Runtime };
attrsAnnotation.Type = compiler.GetDot42InternalType("IAttributes").GetClassReference(targetPackage);
attrsAnnotation.Arguments.Add(new AnnotationArgument("Attributes", annotations.ToArray()));
annotationProvider.Annotations.Add(attrsAnnotation);
}
if (!customAttributesOnly)
{
// Add annotations specified using AnnotationAttribute
foreach (var attr in attributeProvider.CustomAttributes.Where(IsAnnotationAttribute))
{
var annotationType = (TypeReference) attr.ConstructorArguments[0].Value;
var annotationClass = annotationType.GetClassReference(targetPackage, compiler.Module);
annotationProvider.Annotations.Add(new Annotation(annotationClass, AnnotationVisibility.Runtime));
}
}
}
public void StanfordCoreNlpDemoThatChangeCurrentDirectory()
{
const string Text = "Kosgi Santosh sent an email to Stanford University. He didn't get a reply.";
// Annotation pipeline configuration
var props = new Properties();
props.setProperty("annotators", "tokenize, ssplit, pos, lemma, ner, parse, dcoref");
props.setProperty("sutime.binders", "0");
// we should change current directory so StanfordCoreNLP could find all the model files
var curDir = Environment.CurrentDirectory;
Directory.SetCurrentDirectory(Config.JarRoot);
var pipeline = new edu.stanford.nlp.pipeline.StanfordCoreNLP(props);
Directory.SetCurrentDirectory(curDir);
// Annotation
var annotation = new Annotation(Text);
pipeline.annotate(annotation);
// Result - Pretty Print
using (var stream = new ByteArrayOutputStream())
{
pipeline.prettyPrint(annotation, new PrintWriter(stream));
Console.WriteLine(stream.toString());
}
this.CustomAnnotationPrint(annotation);
}
/// <summary>
/// Gets depeendencies from sentence.
/// </summary>
/// <param name="annotation"></param>
/// <returns></returns>
private NotenizerDependencies GetDepencencies(Annotation annotation)
{
Tree tree;
NotenizerDependency dep;
GrammaticalStructure gramStruct;
NotenizerDependencies dependencies;
NotenizerDependency nsubjComplement;
TreebankLanguagePack treeBankLangPack;
java.util.Collection typedDependencies;
GrammaticalStructureFactory gramStructFact;
tree = annotation.get(typeof(TreeCoreAnnotations.TreeAnnotation)) as Tree;
treeBankLangPack = new PennTreebankLanguagePack();
gramStructFact = treeBankLangPack.grammaticalStructureFactory();
gramStruct = gramStructFact.newGrammaticalStructure(tree);
typedDependencies = gramStruct.typedDependenciesCollapsed();
dependencies = new NotenizerDependencies();
foreach (TypedDependency typedDependencyLoop in (typedDependencies as java.util.ArrayList))
{
dep = new NotenizerDependency(typedDependencyLoop);
dependencies.Add(dep);
if (dep.Relation.IsNominalSubject())
{
nsubjComplement = new NotenizerDependency(typedDependencyLoop);
nsubjComplement.TokenType = dep.TokenType == TokenType.Dependent ? TokenType.Governor : TokenType.Dependent;
dependencies.Add(nsubjComplement);
}
}
return dependencies;
}
protected internal virtual Annotation VisitAnnotation(Annotation annotation)
{
if (annotation == null) return null;
annotation.Declaration = Visit(annotation.Declaration);
annotation.Argument = VisitValue(annotation.Argument);
return annotation;
}
//------------------------------------------------------
//
// Constructors
//
//------------------------------------------------------
#region Constructors
/// <summary>
/// Creates an instance of AnnotationUpdatedEventArgs with the
/// specified action and annotation.
/// </summary>
/// <param name="action">the action that was performed on an annotation</param>
/// <param name="annotation">the annotation that was updated</param>
public StoreContentChangedEventArgs(StoreContentAction action, Annotation annotation)
{
if (annotation == null)
throw new ArgumentNullException("annotation");
_action = action;
_annotation = annotation;
}
internal TextBlock(int spanStart, int spanEnd, string type, string text, Annotation annotation)
{
mSpanStart = spanStart;
mSpanEnd = spanEnd;
mType = type;
mText = text;
mAnnotation = annotation;
}
public void AddAnnotation(Annotation annotation)
{
if (annotation != null)
{
Annotations.Add(annotation);
if (this.AnnotationAdded != null)
this.AnnotationAdded(annotation);
}
}
public void TestAnnotateAddsToAnnotations()
{
var support = new AnnotationSupport();
var annotation = new Annotation();
support.Annotate(annotation);
Assert.AreSame(annotation, support.Annotation<Annotation>());
}
public override void CreateAnnotations(DexTargetPackage targetPackage)
{
base.CreateAnnotations(targetPackage);
if (Class == null)
return;
bool isBaseTypeGeneric = XType.BaseType != null && (XType.BaseType.IsGenericInstance || XType.BaseType.IsGenericParameter);
bool containsGenericInterfaces = XType.Interfaces.Any(i => i.IsGenericInstance || i.IsGenericParameter);
bool needsFieldAnnotation = !Class.IsSynthetic && Class.Fields.Count(p => !p.IsSynthetic && !p.IsStatic) > 1;
bool needsAnnotation = Class.GenericInstanceFields.Count > 0
|| XType.GenericParameters.Count > 0
|| isBaseTypeGeneric
|| containsGenericInterfaces
|| needsFieldAnnotation;
if (!needsAnnotation) return;
var annType = Compiler.GetDot42InternalType(InternalConstants.TypeReflectionInfoAnnotation).GetClassReference(targetPackage);
var annotation = new Annotation(annType, AnnotationVisibility.Runtime);
if (Class.GenericInstanceFields.Count > 0)
{
annotation.Arguments.Add(new AnnotationArgument(InternalConstants.TypeReflectionInfoGenericArgumentsFields,
Class.GenericInstanceFields.Select(f=>f.Name).ToArray()));
}
if (XType.GenericParameters.Count > 0)
annotation.Arguments.Add(new AnnotationArgument(InternalConstants.TypeReflectionInfoGenericArgumentCountField, XType.GenericParameters.Count));
List<Annotation> definitions= new List<Annotation>();
if (isBaseTypeGeneric)
definitions.Add(AssemblyCompilerExtensions.GetGenericDefinitionAnnotationForType(
XType.BaseType, true, Compiler, targetPackage));
foreach (var intf in XType.Interfaces)
{
if(!intf.IsGenericInstance && !intf.IsGenericParameter)
continue;
definitions.Add(AssemblyCompilerExtensions.GetGenericDefinitionAnnotationForType(
intf, true, Compiler, targetPackage));
}
if(definitions.Count > 0)
annotation.Arguments.Add(new AnnotationArgument(InternalConstants.TypeReflectionInfoGenericDefinitionsField, definitions.ToArray()));
if (needsFieldAnnotation)
{
annotation.Arguments.Add(new AnnotationArgument(InternalConstants.TypeReflectionInfoFieldsField,
Class.Fields.Where(p=>!p.IsSynthetic && !p.IsStatic).Select(p=>p.Name).ToArray()));
}
Class.Annotations.Add(annotation);
}
public static JObject ProcessText(string text)
{
var annotation = new Annotation(text);
using (java.io.StringWriter writer = new java.io.StringWriter())
{
pipeline.annotate(annotation);
pipeline.jsonPrint(annotation, writer);
return JObject.Parse(writer.toString());
}
}
private AnnotationBuilder(AnnotationType type, AnnotationSurfaceSize size, Guid toolId, int currentPage)
{
this.surfaceSize = size;
this.type = type;
this.annotation = new Annotation()
{
Type = type,
Points = new List<AnnotationPoint>(),
PageNumber = currentPage,
ToolId = toolId
};
}
/// <summary>
/// This is used to determine if two annotations are equals based
/// on the attributes of the annotation. The comparison done can
/// ignore specific attributes, for instance the name attribute.
/// </summary>
/// <param name="left">
/// this is the left side of the comparison done
/// </param>
/// <param name="right">
/// this is the right side of the comparison done
/// </param>
/// <returns>
/// this returns true if the annotations are equal
/// </returns>
public bool Equals(Annotation left, Annotation right) {
Class type = left.annotationType();
Method[] list = type.getDeclaredMethods();
for(Method method : list) {
if(!IsIgnore(method)) {
Object value = method.invoke(left);
Object other = method.invoke(right);
if(!value.Equals(other)) {
return false;
}
}
}
return true;
}
public virtual void SendServerSpan(Span span, int duration)
{
var annotation = new Annotation()
{
Host = zipkinEndpoint.GetEndpoint(serviceName),
Duration = duration, //duration is currently not supported by zipkin UI
Timestamp = GetTimeStamp(),
Value = zipkinCoreConstants.SERVER_SEND
};
span.Annotations.Add(annotation);
spanCollector.Collect(span);
}
private string getAnnotation(string input)
{
Annotation annotation = new Annotation(input);
pipeline.annotate(annotation);
string result = "";
using (var stream = new ByteArrayOutputStream())
{
pipeline.conllPrint(annotation, new PrintWriter(stream));
result += stream.toString();
stream.close();
}
return result;
}
// As the declaration may have been a reference, we can now resolve the argument because we know
// the type from the declaration.
protected internal override Annotation VisitAnnotation(Annotation annotation)
{
if (annotation == null) return null;
Debug.Assert(!(annotation.Declaration is CapnpReference));
var decl = annotation.Declaration as CapnpAnnotation;
var genericDeclaration = annotation.Declaration as CapnpBoundGenericType;
if (genericDeclaration != null)
{
decl = (CapnpAnnotation)genericDeclaration.OpenType;
//// The annotation is declared within a generic type, so close that type.
//argType = new CapnpClosedGenericType
//{
// OpenType = genericDeclaration.OpenType,
// TypeParameters = genericDeclaration.ParentScope.TypeParameters,
// ParentScope = genericDeclaration.ParentScope.ParentScope
//};
}
if (decl != null && annotation.Argument == null)
{
// todo: what abotu generics? is this even valid?
Debug.Assert(decl.ArgumentType == CapnpPrimitive.Void);
return annotation;
}
var v = annotation.Argument as UnresolvedValue;
if (v == null) return annotation;
var argType = decl.ArgumentType;
if (genericDeclaration != null && argType is CapnpGenericParameter)
argType = genericDeclaration.ResolveGenericParameter((CapnpGenericParameter)argType);
// Now that we know the argument type, resolve the value.
var resolvedValue = VisitValue(new UnresolvedValue(argType)
{
Position = -1, // todo
RawData = v == null ? null : v.RawData
});
return new Annotation
{
Declaration = genericDeclaration == null ? (CapnpType)decl : genericDeclaration,
Argument = resolvedValue
};
}
/// <summary>
/// Create an annotation for the given attribute
/// </summary>
private static void Create(AssemblyCompiler compiler, CustomAttribute attribute, TypeDefinition attributeType,
List<Annotation> annotationList, DexTargetPackage targetPackage)
{
// Gets the mapping for the type of attribute
var mapping = compiler.GetAttributeAnnotationType(attributeType);
var ctorMap = mapping.CtorMap[attribute.Constructor.Resolve()];
// Create annotation
var annotation = new Annotation {Visibility = AnnotationVisibility.Runtime};
annotation.Type = mapping.AnnotationInterfaceClass;
// Add ctor arguments
var argIndex = 0;
foreach (var arg in attribute.ConstructorArguments)
{
var name = ctorMap.ArgumentGetters[argIndex].Name;
annotation.Arguments.Add(CreateAnnotationArgument(name, arg.Type, arg.Value, targetPackage, compiler.Module));
argIndex++;
}
// Add field values
foreach (var arg in attribute.Fields)
{
var entry = mapping.FieldToGetMethodMap.First(x => x.Key.Name == arg.Name);
var name = entry.Value.Name;
annotation.Arguments.Add(CreateAnnotationArgument(name, arg.Argument.Type, arg.Argument.Value, targetPackage, compiler.Module));
}
// Add property values
foreach (var arg in attribute.Properties)
{
if (mapping.PropertyToGetMethodMap.Keys.Any(x => x.Name == arg.Name))
{
var entry = mapping.PropertyToGetMethodMap.First(x => x.Key.Name == arg.Name);
var name = entry.Value.Name;
annotation.Arguments.Add(CreateAnnotationArgument(name, arg.Argument.Type, arg.Argument.Value, targetPackage, compiler.Module));
}
}
// Create attribute annotation
var attrAnnotation = new Annotation { Visibility = AnnotationVisibility.Runtime };
attrAnnotation.Type = compiler.GetDot42InternalType("IAttribute").GetClassReference(targetPackage);
attrAnnotation.Arguments.Add(new AnnotationArgument("AttributeBuilder", ctorMap.Builder));
attrAnnotation.Arguments.Add(new AnnotationArgument("AttributeType", attributeType.GetReference(targetPackage, compiler.Module)));
attrAnnotation.Arguments.Add(new AnnotationArgument("Annotation", annotation));
// Add annotation
annotationList.Add(attrAnnotation);
}
protected override void ProcessDocument(Document document)
{
TextBlock[] textBlocks = document.GetAnnotatedBlocks(SRC_ANNOT_TYPE);
foreach (TextBlock textBlock in textBlocks)
{
// do tokenization, add annotations to document
mTokenizer.Text = textBlock.Text;
for (RegexTokenizer.Enumerator e = (RegexTokenizer.Enumerator)mTokenizer.GetEnumerator(); e.MoveNext(); )
{
//Console.WriteLine("{0} {1} {2}", textBlock.SpanStart + e.CurrentTokenIdx, textBlock.SpanStart + e.CurrentTokenIdx + e.Current.Length - 1, e.Current);
Annotation annot = new Annotation(textBlock.SpanStart + e.CurrentTokenIdx, textBlock.SpanStart + e.CurrentTokenIdx + e.Current.Length - 1, DEST_ANNOT_TYPE);
document.AddAnnotation(annot);
}
}
}
public static MsCrmResult CreateAnnotation(Annotation note, IOrganizationService service)
{
MsCrmResult returnValue = new MsCrmResult();
try
{
Entity ent = new Entity("annotation");
if (note.AttachmentFile != null)
{
ent["objectid"] = note.AttachmentFile;
}
if (!string.IsNullOrEmpty(note.Subject))
{
ent["subject"] = note.Subject;
}
if (!string.IsNullOrEmpty(note.File))
{
ent["documentbody"] = note.File;
}
if (!string.IsNullOrEmpty(note.FileName))
{
ent["filename"] = note.FileName;
}
if (!string.IsNullOrEmpty(note.MimeType))
{
ent["mimetype"] = note.MimeType;
}
if (!string.IsNullOrEmpty(note.Text))
{
ent["notetext"] = note.Text;
}
returnValue.CrmId = service.Create(ent);
returnValue.Success = true;
returnValue.Result = "Dosya Ekleme başarıyla gerçekleşti.";
}
catch (Exception ex)
{
returnValue.Success = false;
returnValue.Result = ex.Message;
}
return returnValue;
}
public static void CreateAssemblyTypes(AssemblyCompiler compiler, DexTargetPackage targetPackage,
IEnumerable<TypeDefinition> reachableTypes)
{
var xAssemblyTypes = compiler.GetDot42InternalType("AssemblyTypes");
var assemblyTypes = (ClassDefinition)xAssemblyTypes.GetClassReference(targetPackage);
var entryAssembly = assemblyTypes.Fields.First(f => f.Name == "EntryAssembly");
var iAssemblyTypes = compiler.GetDot42InternalType("IAssemblyTypes").GetClassReference(targetPackage);
entryAssembly.Value = compiler.Assemblies.First().Name.Name;
List<object> values = new List<object>();
string prevAssemblyName = null;
foreach (var type in reachableTypes.OrderBy(t => t.Module.Assembly.Name.Name)
.ThenBy(t => t.Namespace)
.ThenBy(t => t.Name))
{
var assemblyName = type.module.Assembly.Name.Name;
if (assemblyName == "dot42")
{
// group all android types into virtual "android" assembly,
// so that MvvmCross can find all view-types.
// -- is this a hack?
if (type.Namespace.StartsWith("Android"))
assemblyName = "android";
else // ignore other types, these will get the "default" assembly.
continue;
}
if (prevAssemblyName != assemblyName)
{
values.Add("!" + assemblyName); // we need some identification of assemblies.
prevAssemblyName = assemblyName;
}
// TODO: With compilationmode=all reachable types contains <Module>
// this should be excluded earlier.
if (type.FullName == "<Module>")
continue;
var tRef = type.GetReference(targetPackage, compiler.Module) as ClassReference;
if(tRef != null) values.Add(tRef.Fullname);
}
var anno = new Annotation(iAssemblyTypes, AnnotationVisibility.Runtime,
new AnnotationArgument("AssemblyTypeList", values.ToArray()));
((IAnnotationProvider)assemblyTypes).Annotations.Add(anno);
}
protected override void SyllabifyUnmarkedAnnotation(Word word, Annotation<ShapeNode> ann, Shape newShape)
{
ShapeNode[] annNodes = word.Shape.GetNodes(ann.Span).ToArray();
ShapeNode syllableStart = null;
int prevSonority = -1, curSonority = -1;
FeatureSymbol prevType = null;
bool useMaximalOnset = false;
foreach (ShapeNode node in annNodes)
{
FeatureSymbol curType = node.Type();
ShapeNode nextNode = node.Next;
int nextSonority = ann.Span.Contains(nextNode) ? GetSonority(nextNode) : -1;
// stress markers indicate a syllable break
if (syllableStart != null && node.StrRep().IsOneOf("ˈ", "ˌ"))
{
if (useMaximalOnset)
ProcessSyllableWithMaximalOnset(syllableStart, node.Prev, newShape);
else
ProcessSyllable(syllableStart, node.Prev, newShape);
useMaximalOnset = false;
curSonority = -1;
syllableStart = null;
}
else if (curSonority == -1)
{
curSonority = GetSonority(node);
}
else if ((curSonority < prevSonority && curSonority < nextSonority)
|| ((!_vowelsSameSonorityTautosyllabic || curType != CogFeatureSystem.VowelType || prevType != CogFeatureSystem.VowelType) && curSonority == prevSonority))
{
if (useMaximalOnset)
ProcessSyllableWithMaximalOnset(syllableStart, node.Prev, newShape);
else
ProcessSyllable(syllableStart, node.Prev, newShape);
useMaximalOnset = true;
syllableStart = null;
}
if (syllableStart == null)
syllableStart = node;
prevType = curType;
prevSonority = curSonority;
curSonority = nextSonority;
}
if (useMaximalOnset)
ProcessSyllableWithMaximalOnset(syllableStart, ann.Span.End, newShape);
else
ProcessSyllable(syllableStart, ann.Span.End, newShape);
}
private Annotation PrepareAnnotation()
{
var props = new Properties();
props.put("pos.model", modelsDir + "pos-tagger/english-left3words/english-left3words-distsim.tagger");
props.put("ner.model", modelsDir + "ner/english.conll.4class.distsim.crf.ser.gz");
props.put("parse.model", modelsDir + "lexparser/englishPCFG.ser.gz");
props.put("sutime.rules", modelsDir + "sutime/defs.sutime.txt, " + modelsDir + "sutime/english.sutime.txt");
props.setProperty("annotators", "tokenize, ssplit, pos, lemma, ner, parse");
props.setProperty("sutime.binders", "0");
props.setProperty("ner.useSUTime", "0");
var pipeline = new StanfordCoreNLP(props);
var annotatedText = new Annotation(text);
pipeline.annotate(annotatedText);
return annotatedText;
}
public void InsertTestAndGetByPostAndUserTest()
{
initializeTest();
Random rnd = new Random();
int userid = rnd.Next(10000);
int postid = rnd.Next(10000);
Annotation annotation = new Annotation
{
UserId = userid,
PostId = postid,
Date = DateTime.Parse("2015-11-25 13:58:23"),
Body = "annotation unit test with userid = " + userid + " and postid =" + postid,
};
_annotationRepository.Insert(annotation);
Annotation annotation_Actual = _annotationRepository.GetByPostAndUser(postid, userid);
Assert.AreEqual(annotation.UserId, annotation_Actual.UserId);
}
protected override void AddAnnotation(Annotation annotation)
{
_conceptScheme.Annotations.Add(annotation);
}
public static MsCrmResult SendMailSecondHandToApproval(Product secondHandProduct, Entity _secondHand, UserTypes type, SqlDataAccess sda, IOrganizationService service)
{
MsCrmResult returnValue = new MsCrmResult();
try
{
#region | SEND INFORMATIONS |
string projectName = secondHandProduct.Project != null ? secondHandProduct.Project.Name : string.Empty;
string blockName = secondHandProduct.Block != null ? secondHandProduct.Block.Name : string.Empty;
string floorNumber = secondHandProduct.FloorNumber != null?secondHandProduct.FloorNumber.ToString() : string.Empty;
string generalhomeType = secondHandProduct.GeneralHomeType != null ? secondHandProduct.GeneralHomeType.Name : string.Empty;
string homeType = secondHandProduct.HomeType != null ? secondHandProduct.HomeType.Name : string.Empty;
string net = secondHandProduct.Net != null ? ((decimal)secondHandProduct.Net).ToString("N0", CultureInfo.CurrentCulture) : string.Empty;
string brut = secondHandProduct.Brut != null ? ((decimal)secondHandProduct.Brut).ToString("N0", CultureInfo.CurrentCulture) : string.Empty;
string productAmount = secondHandProduct.PaymentOfHire.HasValue ? secondHandProduct.PaymentOfHire.Value.ToString("N2") : string.Empty;
string rentalAmount = _secondHand.GetAttributeValue <Money>("new_salesfee") != null?_secondHand.GetAttributeValue <Money>("new_salesfee").Value.ToString("N2") : string.Empty;
string currencyName = _secondHand.GetAttributeValue <EntityReference>("transactioncurrencyid") != null ? (_secondHand.GetAttributeValue <EntityReference>("transactioncurrencyid")).Name : string.Empty;
#endregion
#region | GET CURRENCY |
string exchangeRate = string.Empty;
Guid currencyId = (_secondHand.GetAttributeValue <EntityReference>("transactioncurrencyid")).Id;
MsCrmResultObject currencyResult = CurrencyHelper.GetExchangeRateByCurrency(DateTime.Now, currencyId, sda);
if (currencyResult.Success)
{
ExchangeRate rate = (ExchangeRate)currencyResult.ReturnObject;
exchangeRate = ((decimal)rate.SaleRate).ToString("N0", CultureInfo.CurrentCulture);
}
#endregion
string body = "<table>";
body += "<tr><td>Proje : </td><td>" + projectName + "</td></tr>";
body += "<tr><td>Blok : </td><td>" + blockName + "</td></tr>";
body += "<tr><td>Kat : </td><td>" + floorNumber + "</td></tr>";
body += "<tr><td>Daire No : </td><td>" + secondHandProduct.HomeNumber + "</td></tr>";
body += "<tr><td>Tip : </td><td>" + generalhomeType + "</td></tr>";
body += "<tr><td>Daire Tipi : </td><td>" + homeType + "</td></tr>";
body += "<tr><td>Konut Satış Fiyatı Fiyatı : </td><td>" + productAmount + "</td></tr>";
body += "<tr><td>Satılmak İstenen Fiyat : </td><td>" + rentalAmount + "</td></tr>";
body += "<tr><td>Net m2 : </td><td>" + net + "</td></tr>";
body += "<tr><td>Brüt m2 : </td><td>" + brut + "</td></tr>";
body += "<tr><td>Para Birimi : </td><td>" + currencyName + "</td></tr>";
body += "<tr><td>Güncel Kur : </td><td>" + exchangeRate + "</td></tr>";
body += "</table>";
body += "<br/>";
body += "<br/>";
body += "<a href='{0}' target='_blank'>Kiralamayı onaylamak/reddetmek için lütfen tıklayınız.</a>";
string url = "http://fenix.centralproperty.com.tr/index.aspx?page=secondhandconfirm&name=secondhandid&pageid=" + _secondHand.Id;
body = string.Format(body, url);
//MsCrmResultObject managerResult = SystemUserHelper.GetSalesManager(sda);
MsCrmResultObject managerResult = SystemUserHelper.GetUsersByUserTypes(type, sda);
if (managerResult != null && managerResult.Success)
{
Entity fromParty = new Entity("activityparty");
fromParty["partyid"] = _secondHand.GetAttributeValue <EntityReference>("ownerid");
Entity[] fromPartyColl = new Entity[] { fromParty };
#region | SET TO |
List <SystemUser> returnList = (List <SystemUser>)managerResult.ReturnObject;
Entity[] toPartyColl = new Entity[returnList.Count];
for (int i = 0; i < returnList.Count; i++)
{
Entity toParty = new Entity("activityparty");
toParty["partyid"] = new EntityReference("systemuser", returnList[i].SystemUserId);
toPartyColl[i] = toParty;
}
#endregion
Annotation anno = null;
MsCrmResult mailResult = GeneralHelper.SendMail(_secondHand.Id, "new_resalerecord", fromPartyColl, toPartyColl, "2.El Satış Onayı", body, anno, service);
returnValue = mailResult;
}
else
{
returnValue.Success = false;
returnValue.Result = managerResult.Result;
}
}
catch (Exception ex)
{
returnValue.Success = false;
returnValue.Result = ex.Message;
}
return(returnValue);
}
void ITestModelBuilder.AddAnnotation(Annotation annotation)
{
throw new NotSupportedException();
}
protected override bool OnLeaveNotifyEvent(EventCrossing evnt)
{
highlightAnnotation = null;
widget.QueueDraw();
return(base.OnLeaveNotifyEvent(evnt));
}
public void setCurrentAnnotation(Annotation pAnnotation)
{
annotationCurrent = pAnnotation;
}
protected override bool OnExposeEvent(Gdk.EventExpose e)
{
using (Cairo.Context cr = Gdk.CairoHelper.Create(e.Window)) {
cr.LineWidth = Math.Max(1.0, widget.Editor.Options.Zoom);
cr.Rectangle(leftSpacer, 0, Allocation.Width, Allocation.Height);
cr.SetSourceColor(Styles.BlameView.AnnotationBackgroundColor.ToCairoColor());
cr.Fill();
int startLine = widget.Editor.YToLine((int)widget.Editor.VAdjustment.Value);
double startY = widget.Editor.LineToY(startLine);
while (startLine > 1 && startLine < annotations.Count && annotations[startLine - 1] != null && annotations[startLine] != null && annotations[startLine - 1].Revision == annotations[startLine].Revision)
{
startLine--;
startY -= widget.Editor.GetLineHeight(widget.Editor.Document.GetLine(startLine));
}
double curY = startY - widget.Editor.VAdjustment.Value;
int line = startLine;
while (curY < Allocation.Bottom && line <= widget.Editor.LineCount)
{
double curStart = curY;
// widget.JumpOverFoldings (ref line);
int lineStart = line;
int authorWidth = 0, revisionWidth = 0, dateWidth = 0, h = 16;
Annotation ann = line <= annotations.Count ? annotations[line - 1] : null;
if (ann != null)
{
do
{
widget.JumpOverFoldings(ref line);
line++;
} while (line <= annotations.Count && annotations[line - 1] != null && annotations[line - 1].Revision == ann.Revision);
double nextY = widget.editor.LineToY(line) - widget.editor.VAdjustment.Value;
if (highlightAnnotation != null && highlightAnnotation.Revision == ann.Revision && curStart <= highlightPositon && highlightPositon < nextY)
{
cr.Rectangle(leftSpacer, curStart + cr.LineWidth, Allocation.Width - leftSpacer, nextY - curStart - cr.LineWidth);
cr.SetSourceColor(Styles.BlameView.AnnotationHighlightColor.ToCairoColor());
cr.Fill();
}
// use a fixed size revision to get a approx. revision width
layout.SetText("88888888");
layout.GetPixelSize(out revisionWidth, out h);
layout.SetText(TruncRevision(ann.Text));
const int dateRevisionSpacing = 16;
using (var gc = new Gdk.GC(e.Window)) {
gc.RgbFgColor = Styles.BlameView.AnnotationTextColor.ToGdkColor();
e.Window.DrawLayout(gc, Allocation.Width - revisionWidth - margin, (int)(curY + (widget.Editor.LineHeight - h) / 2), layout);
if (ann.HasDate)
{
string dateTime = ann.Date.ToShortDateString();
// use a fixed size date to get a approx. date width
layout.SetText(new DateTime(1999, 10, 10).ToShortDateString());
layout.GetPixelSize(out dateWidth, out h);
layout.SetText(dateTime);
e.Window.DrawLayout(gc, Allocation.Width - revisionWidth - margin - revisionWidth - dateRevisionSpacing, (int)(curY + (widget.Editor.LineHeight - h) / 2), layout);
}
}
using (var authorLayout = MonoDevelop.Components.PangoUtil.CreateLayout(this)) {
authorLayout.FontDescription = FontService.SansFont.CopyModified(Ide.Gui.Styles.FontScale11);
authorLayout.SetText(ann.Author);
authorLayout.GetPixelSize(out authorWidth, out h);
var maxWidth = Allocation.Width - revisionWidth - margin - revisionWidth - dateRevisionSpacing;
/* if (authorWidth > maxWidth) {
* int idx = ann.Author.IndexOf ('<');
* if (idx > 0)
* authorLayout.SetText (ann.Author.Substring (0, idx) + Environment.NewLine + ann.Author.Substring (idx));
* authorLayout.GetPixelSize (out authorWidth, out h);
* }*/
cr.Save();
cr.Rectangle(0, 0, maxWidth, Allocation.Height);
cr.Clip();
cr.Translate(leftSpacer + margin, (int)(curY + (widget.Editor.LineHeight - h) / 2));
cr.SetSourceColor(Styles.BlameView.AnnotationTextColor.ToCairoColor());
cr.ShowLayout(authorLayout);
cr.ResetClip();
cr.Restore();
}
curY = nextY;
}
else
{
curY += widget.Editor.GetLineHeight(line);
line++;
widget.JumpOverFoldings(ref line);
}
if (ann != null && line - lineStart > 1)
{
string msg = GetCommitMessage(lineStart, false);
if (!string.IsNullOrEmpty(msg))
{
msg = RevisionHelpers.FormatMessage(msg);
layout.SetText(msg);
layout.Width = (int)(Allocation.Width * Pango.Scale.PangoScale);
using (var gc = new Gdk.GC(e.Window)) {
gc.RgbFgColor = Styles.BlameView.AnnotationSummaryTextColor.ToGdkColor();
gc.ClipRectangle = new Rectangle(0, (int)curStart, Allocation.Width, (int)(curY - curStart));
e.Window.DrawLayout(gc, (int)(leftSpacer + margin), (int)(curStart + h), layout);
}
}
}
cr.Rectangle(0, curStart, leftSpacer, curY - curStart);
if (ann != null && !string.IsNullOrEmpty(ann.Author))
{
double a;
if (ann != null && (maxDate - minDate).TotalHours > 0)
{
a = 1 - (ann.Date - minDate).TotalHours / (maxDate - minDate).TotalHours;
}
else
{
a = 1;
}
var color = Styles.BlameView.AnnotationMarkColor;
color.Light = 0.4 + a / 2;
color.Saturation = 1 - a / 2;
cr.SetSourceColor(color.ToCairoColor());
}
else
{
cr.SetSourceColor((ann != null ? Styles.BlameView.AnnotationMarkModifiedColor : Styles.BlameView.AnnotationBackgroundColor).ToCairoColor());
}
cr.Fill();
if (ann != null)
{
cr.MoveTo(0, curY + 0.5);
cr.LineTo(Allocation.Width, curY + 0.5);
cr.SetSourceColor(Styles.BlameView.AnnotationSplitterColor.ToCairoColor());
cr.Stroke();
}
}
}
return(true);
}
public Annotation Apply(InternalEntityTypeBuilder entityTypeBuilder, string name, Annotation annotation, Annotation oldAnnotation)
{
if (name == CosmosAnnotationNames.ContainerName)
{
Apply(entityTypeBuilder);
}
return(annotation);
}
/// <summary>
/// Note that the icon used is independent of whether the annotation is resolved/closed or not.
/// AnnotationEditorView._annotationLogo_Paint paints the check mark over the top if needed.
/// (This is different from the 16x16 strategy, where we have fine-tuned distinct icons.)
/// </summary>
/// <returns></returns>
public Image GetAnnotationLogoImage()
{
return(Annotation.GetImage(32));
}
protected override void TranslateFunctionDefinition(List <string> output, FunctionDefinition functionDef)
{
output.Add(this.CurrentTabIndention);
output.Add("\nfunction ");
Annotation returnTypeAnnotation = functionDef.GetAnnotation("type");
if (returnTypeAnnotation == null)
{
throw new ParserException(functionDef.FirstToken, "Need return type.");
}
string type = returnTypeAnnotation.GetSingleArgAsString(null);
if (type == null)
{
throw new ParserException(functionDef.FirstToken, "Need return type.");
}
output.Add("v_");
output.Add(functionDef.NameToken.Value);
output.Add("(");
for (int i = 0; i < functionDef.ArgNames.Length; ++i)
{
if (i > 0)
{
output.Add(", ");
}
Annotation annotation = functionDef.ArgAnnotations[i];
if (annotation == null)
{
throw new ParserException(functionDef.FirstToken, "Arg needs a type.");
}
output.Add("$v_" + functionDef.ArgNames[i].Value);
}
output.Add(") {\n");
this.CurrentIndention++;
HashSet <Variable> variablesUsed = new HashSet <Variable>();
foreach (Executable line in functionDef.Code)
{
line.GetAllVariablesReferenced(variablesUsed);
}
foreach (string variable in variablesUsed
.Select <Variable, string>(v => v.Name)
.Where <string>(s => s.ToUpper() == s)
.Distinct <string>()
.OrderBy <string, string>(s => s))
{
output.Add(this.CurrentTabIndention);
output.Add("global $v_");
output.Add(variable);
output.Add(";\n");
}
foreach (Executable line in functionDef.Code)
{
this.Translate(output, line);
}
this.CurrentIndention--;
output.Add(this.CurrentTabIndention);
output.Add("}\n");
}
//gets range of tokens that are in the same sentence as the beginning of the quote that precede it, if they exist,
//or the previous sentence, if it is in the same paragraph.
//also, ensure that the difference is at least two tokens
public static Pair <int, int> GetTokenRangePrecedingQuote(Annotation doc, ICoreMap quote)
{
IList <ICoreMap> docSentences = doc.Get(typeof(CoreAnnotations.SentencesAnnotation));
int quoteBeginTokenIndex = quote.Get(typeof(CoreAnnotations.TokenBeginAnnotation));
if (quoteBeginTokenIndex <= 2)
{
return(null);
}
int quoteBeginSentenceIndex = quote.Get(typeof(CoreAnnotations.SentenceBeginAnnotation));
ICoreMap beginSentence = docSentences[quoteBeginSentenceIndex];
if (beginSentence.Get(typeof(QuoteAttributionUtils.EnhancedSentenceAnnotation)) != null)
{
beginSentence = beginSentence.Get(typeof(QuoteAttributionUtils.EnhancedSentenceAnnotation));
}
int quoteIndex = quote.Get(typeof(CoreAnnotations.QuotationIndexAnnotation));
if (beginSentence.Get(typeof(CoreAnnotations.TokenBeginAnnotation)) < quoteBeginTokenIndex - 1)
{
//check previous quote to make sure boundary is okay- modify if necessary.
if (quoteIndex > 0)
{
ICoreMap prevQuote = doc.Get(typeof(CoreAnnotations.QuotationsAnnotation))[quoteIndex - 1];
int prevQuoteTokenEnd = prevQuote.Get(typeof(CoreAnnotations.TokenEndAnnotation));
if (prevQuoteTokenEnd > beginSentence.Get(typeof(CoreAnnotations.TokenBeginAnnotation)))
{
if (prevQuoteTokenEnd + 1 == quoteBeginTokenIndex)
{
return(null);
}
return(new Pair <int, int>(prevQuoteTokenEnd + 1, quoteBeginTokenIndex - 1));
}
}
return(new Pair <int, int>(beginSentence.Get(typeof(CoreAnnotations.TokenBeginAnnotation)), quoteBeginTokenIndex - 1));
}
else
{
if (quoteBeginSentenceIndex > 0)
{
//try previous sentence- if it is in the same paragraph.
int currParagraph = beginSentence.Get(typeof(CoreAnnotations.ParagraphIndexAnnotation));
ICoreMap prevSentence = docSentences[quoteBeginSentenceIndex - 1];
//check if prevSentence is in same paragraph
if (prevSentence.Get(typeof(CoreAnnotations.ParagraphIndexAnnotation)) == currParagraph)
{
//check previous quote boundary
if (quoteIndex > 0)
{
ICoreMap prevQuote = doc.Get(typeof(CoreAnnotations.QuotationsAnnotation))[quoteIndex - 1];
int prevQuoteTokenEnd = prevQuote.Get(typeof(CoreAnnotations.TokenEndAnnotation));
if (prevQuoteTokenEnd > prevSentence.Get(typeof(CoreAnnotations.TokenBeginAnnotation)))
{
if (prevQuoteTokenEnd + 1 == quoteBeginTokenIndex)
{
return(null);
}
return(new Pair <int, int>(prevQuoteTokenEnd + 1, quoteBeginTokenIndex - 1));
}
return(new Pair <int, int>(prevSentence.Get(typeof(CoreAnnotations.TokenBeginAnnotation)), quoteBeginTokenIndex - 1));
}
}
}
}
return(null);
}
public override object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data)
{
if (objectCreateExpression.Arguments.Count() == 2)
{
Expression obj = objectCreateExpression.Arguments.First();
Expression func = objectCreateExpression.Arguments.Last();
Annotation annotation = func.Annotation <Annotation>();
if (annotation != null)
{
IdentifierExpression methodIdent = (IdentifierExpression)((InvocationExpression)func).Arguments.Single();
MethodReference method = methodIdent.Annotation <MethodReference>();
if (method != null)
{
if (HandleAnonymousMethod(objectCreateExpression, obj, method))
{
return(null);
}
// Perform the transformation to "new Action(obj.func)".
obj.Remove();
methodIdent.Remove();
if (!annotation.IsVirtual && obj is ThisReferenceExpression)
{
// maybe it's getting the pointer of a base method?
if (method.DeclaringType.GetElementType() != context.CurrentType)
{
obj = new BaseReferenceExpression();
}
}
if (!annotation.IsVirtual && obj is NullReferenceExpression && !method.HasThis)
{
// We're loading a static method.
// However it is possible to load extension methods with an instance, so we compare the number of arguments:
bool isExtensionMethod = false;
TypeReference delegateType = objectCreateExpression.Type.Annotation <TypeReference>();
if (delegateType != null)
{
TypeDefinition delegateTypeDef = delegateType.Resolve();
if (delegateTypeDef != null)
{
MethodDefinition invokeMethod = delegateTypeDef.Methods.FirstOrDefault(m => m.Name == "Invoke");
if (invokeMethod != null)
{
isExtensionMethod = (invokeMethod.Parameters.Count + 1 == method.Parameters.Count);
}
}
}
if (!isExtensionMethod)
{
obj = new TypeReferenceExpression {
Type = AstBuilder.ConvertType(method.DeclaringType)
};
}
}
// now transform the identifier into a member reference
MemberReferenceExpression mre = new MemberReferenceExpression();
mre.Target = obj;
mre.MemberName = methodIdent.Identifier;
methodIdent.TypeArguments.MoveTo(mre.TypeArguments);
mre.AddAnnotation(method);
objectCreateExpression.Arguments.Clear();
objectCreateExpression.Arguments.Add(mre);
return(null);
}
}
}
return(base.VisitObjectCreateExpression(objectCreateExpression, data));
}
public string GetLongLabel()
{
return(Annotation.GetLongLabel());
}
public void AddMessage(string newMessageText)
{
Annotation.AddMessage(_user.Name, null, newMessageText);
UpdateContentNow();
}
public virtual void OneSpeakerSentence(Annotation doc)
{
IList <CoreLabel> toks = doc.Get(typeof(CoreAnnotations.TokensAnnotation));
IList <ICoreMap> quotes = doc.Get(typeof(CoreAnnotations.QuotationsAnnotation));
IDictionary <int, IList <ICoreMap> > quotesBySentence = new Dictionary <int, IList <ICoreMap> >();
for (int quoteIndex = 0; quoteIndex < quotes.Count; quoteIndex++)
{
ICoreMap quote = quotes[quoteIndex];
// iterate through each quote in the chapter
// group quotes by sentence
int quoteBeginTok = quote.Get(typeof(CoreAnnotations.TokenBeginAnnotation));
int sentenceBeginId = toks[quoteBeginTok].SentIndex();
int quoteEndTok = quote.Get(typeof(CoreAnnotations.TokenEndAnnotation));
int sentenceEndId = toks[quoteEndTok].SentIndex();
quotesBySentence.PutIfAbsent(sentenceBeginId, new List <ICoreMap>());
quotesBySentence.PutIfAbsent(sentenceEndId, new List <ICoreMap>());
quotesBySentence[sentenceBeginId].Add(quote);
quotesBySentence[sentenceEndId].Add(quote);
}
//
foreach (int k in quotesBySentence.Keys)
{
IList <ICoreMap> quotesInSent = quotesBySentence[k];
IList <Sieve.Mention> existantMentions = new List <Sieve.Mention>();
foreach (ICoreMap quote in quotesInSent)
{
if (quote.Get(typeof(QuoteAttributionAnnotator.MentionAnnotation)) != null)
{
Sieve.Mention m = new Sieve.Mention(this, quote.Get(typeof(QuoteAttributionAnnotator.MentionBeginAnnotation)), quote.Get(typeof(QuoteAttributionAnnotator.MentionEndAnnotation)), quote.Get(typeof(QuoteAttributionAnnotator.MentionAnnotation)),
quote.Get(typeof(QuoteAttributionAnnotator.MentionTypeAnnotation)));
existantMentions.Add(m);
}
}
//remove cases in which there is more than one mention in a sentence.
bool same = true;
string text = null;
foreach (Sieve.Mention m_1 in existantMentions)
{
if (text == null)
{
text = m_1.text;
}
if (!Sharpen.Runtime.EqualsIgnoreCase(m_1.text, text))
{
same = false;
}
}
if (same && text != null && existantMentions.Count > 0)
{
foreach (ICoreMap quote_1 in quotesInSent)
{
if (quote_1.Get(typeof(QuoteAttributionAnnotator.MentionAnnotation)) == null)
{
Sieve.Mention firstM = existantMentions[0];
quote_1.Set(typeof(QuoteAttributionAnnotator.MentionAnnotation), firstM.text);
quote_1.Set(typeof(QuoteAttributionAnnotator.MentionBeginAnnotation), firstM.begin);
quote_1.Set(typeof(QuoteAttributionAnnotator.MentionEndAnnotation), firstM.end);
quote_1.Set(typeof(QuoteAttributionAnnotator.MentionSieveAnnotation), "Deterministic one speaker sentence");
quote_1.Set(typeof(QuoteAttributionAnnotator.MentionTypeAnnotation), firstM.type);
}
}
}
}
}
protected override void AddAnnotation(Annotation annotation)
{
_series.Annotations.Add(annotation);
}
/// <summary>
/// Constructs a RtfAnnotation based on an Annotation.
/// </summary>
/// <param name="doc">The RtfDocument this RtfAnnotation belongs to</param>
/// <param name="annotation">The Annotation this RtfAnnotation is based off</param>
public RtfAnnotation(RtfDocument doc, Annotation annotation) : base(doc)
{
_title = annotation.Title;
_content = annotation.Content;
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public virtual Annotation Apply(
InternalPropertyBuilder propertyBuilder, string name, Annotation annotation, Annotation oldAnnotation)
{
var property = propertyBuilder.Metadata;
switch (name)
{
case RelationalAnnotationNames.DefaultValue:
case RelationalAnnotationNames.DefaultValueSql:
case RelationalAnnotationNames.ComputedColumnSql:
propertyBuilder.ValueGenerated(GetValueGenerated(property), ConfigurationSource.Convention);
break;
}
return(annotation);
}
protected override void ConsumeData(IDataProducer sender, object data)
{
DocumentCorpus c = (DocumentCorpus)data;
foreach (Document doc in c.Documents)
{
short sentenceNum = 0, blockNum = 0;
int tokensPerDocument = 0;
//string documentId = doc.Features.GetFeatureValue("guid");
//documentId = documentId.Replace("-", "");
//doc.Features.SetFeatureValue("fullId", corpusId + "_" + documentId); //add feature fullId for Achim
string responseUrl = doc.Features.GetFeatureValue("responseUrl") ?? "";
string urlKey = doc.Features.GetFeatureValue("urlKey") ?? "";
string title = doc.Features.GetFeatureValue("title") ?? "";
string domainName = doc.Features.GetFeatureValue("domainName") ?? "";
//********************* date = pubdate if |pubDate-timeGet|<3 days
string pubDate = doc.Features.GetFeatureValue("pubDate") ?? "";
DateTime timeGet = DateTime.Parse(doc.Features.GetFeatureValue("time"));
string date = timeGet.ToString("yyyy-MM-dd");
try
{
DateTime mPubDate = DateTime.Parse(pubDate);
if (DateTime.Compare(mPubDate, timeGet) < 0 && timeGet.Subtract(mPubDate).CompareTo(TimeSpan.FromDays(3)) < 0)
{
date = mPubDate.ToString("yyyy-MM-dd");
}
}
catch { } // supress errors
//******************* Document to database
double pumpDumpIndex = Convert.ToDouble(doc.Features.GetFeatureValue("pumpIndex"));
bool isFinancial = doc.Features.GetFeatureValue("isFinancial") == "True";
// compute new ID
Guid cGuid = new Guid(c.Features.GetFeatureValue("guid"));
Guid dGuid = new Guid(doc.Features.GetFeatureValue("guid"));
ArrayList <byte> buffer = new ArrayList <byte>();
buffer.AddRange(cGuid.ToByteArray());
buffer.AddRange(dGuid.ToByteArray());
Guid documentId = new Guid(MD5.Create().ComputeHash(buffer.ToArray()));
long docId = ToDb.DocumentToDb(mConnection, title, date, pubDate, timeGet.ToString("yyyy-MM-dd HH:mm"), responseUrl, urlKey, domainName, isFinancial, pumpDumpIndex, documentId);
//******************* occurrences
string blockSelector = "TextBlock/Content";
string rev = doc.Features.GetFeatureValue("rev");
if (rev != "1")
{
blockSelector = "TextBlock/Content/Unseen";
}
//******************** occurrence to database
int documentNeg = 0, documentPoz = 0;
doc.CreateAnnotationIndex();
foreach (TextBlock tb in doc.GetAnnotatedBlocks(blockSelector)) //"TextBlock/Content" if rev = "1", else "TextBlock/Content/Unseen"
{
int tokensPerBlock = doc.GetAnnotatedBlocks("Token", tb.SpanStart, tb.SpanEnd).Length;
tokensPerDocument += tokensPerBlock;
int blockNeg = 0, blockPoz = 0;
blockNum++;
foreach (TextBlock s in doc.GetAnnotatedBlocks("Sentence", tb.SpanStart, tb.SpanEnd)) // *** sentence selector within TextBlock tb
{
int sentenceNeg = 0;
int sentencePoz = 0;
sentenceNum++;
int tokensPerSentence = doc.GetAnnotatedBlocks("Token", s.SpanStart, s.SpanEnd).Length;
// sentiment object
foreach (TextBlock so in doc.GetAnnotatedBlocks("SentimentObject", s.SpanStart, s.SpanEnd)) // *** SentimentObject selector within sentence s
{
Annotation annot = so.Annotation;
// string gazUri = annot.Features.GetFeatureValue("gazetteerUri");
string instUri = annot.Features.GetFeatureValue("instanceUri");
// string instClassUri = annot.Features.GetFeatureValue("instanceClassUri");
string term = so.Text; // takole pa dobis dejanski tekst...
// Console.WriteLine("\n" + gazUri + " \t" + instUri + " \t" + instClassUri + " \t" + term);
long occId = ToDb.OccurrenceToDb(mConnection, date, annot.SpanStart, annot.SpanEnd, sentenceNum, blockNum, docId, instUri);
ToDb.TermToDb(mConnection, occId, term);
}
// sentiment word
foreach (TextBlock so in doc.GetAnnotatedBlocks("SentimentWord", s.SpanStart, s.SpanEnd)) // *** SentimentWord selector within sentence s
{
Annotation annot = so.Annotation;
string gazUri = annot.Features.GetFeatureValue("gazetteerUri");
string instUri = annot.Features.GetFeatureValue("instanceUri");
string instClassUri = annot.Features.GetFeatureValue("instanceClassUri");
string term = so.Text; // takole pa dobis dejanski tekst...
// Console.WriteLine("\n" + gazUri + " \t" + instUri + " \t" + instClassUri + " \t" + term);
if (instClassUri.EndsWith("PositiveWord"))
{
sentencePoz++;
blockPoz++;
documentPoz++;
}
else if (instClassUri.EndsWith("NegativeWord"))
{
sentenceNeg++;
blockNeg++;
documentNeg++;
}
// Insert into SQL table SentimentWordOccurrence
ToDb.SentimentWordOccurrenceToDb(mConnection, date, annot.SpanStart, annot.SpanEnd, sentenceNum, blockNum, docId, instUri);
}
}
// Insert into SQL table BlockSentiment
if (blockNeg != 0 || blockPoz != 0)
{
ToDb.BlockSentimentToDb(mConnection, docId, blockNum, blockPoz, blockNeg, tokensPerBlock);
}
}
}
}
public void Read(TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Trace_id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I64)
{
Parent_id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
Annotations = new List <Annotation>();
TList _list0 = iprot.ReadListBegin();
for (int _i1 = 0; _i1 < _list0.Count; ++_i1)
{
Annotation _elem2;
_elem2 = new Annotation();
_elem2.Read(iprot);
Annotations.Add(_elem2);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
Binary_annotations = new List <BinaryAnnotation>();
TList _list3 = iprot.ReadListBegin();
for (int _i4 = 0; _i4 < _list3.Count; ++_i4)
{
BinaryAnnotation _elem5;
_elem5 = new BinaryAnnotation();
_elem5.Read(iprot);
Binary_annotations.Add(_elem5);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Bool)
{
Debug = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public string GetAllInfoForMessageBox()
{
return(Annotation.GetDiagnosticDump());
}
/// <summary>
/// Handles selecting the nearest peptide to edit the annotation for, and showing the editAnnotation form
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void msPlot_DoubleClick(object sender, EventArgs e)
{
bool usingCustomAnnotation = false;
MouseEventArgs mouseArgs = (MouseEventArgs)e;
Graphics g = msPlot.CreateGraphics();
GraphPane closestPane;
PointPair closestPoint;
PointF mousePt = new PointF(mouseArgs.X, mouseArgs.Y);
TextObj selectedTextObj = null;
//retrieve the text object that the user may have selected
if (msPlot.FindClosestPoint(mousePt, out closestPoint, out closestPane))
{
foreach (GraphObj textObject in closestPane.GraphObjList)
{
if (textObject.Tag == closestPoint)
{
//zed graph found the annotation object, use that text object
selectedTextObj = textObject as TextObj;
break;
}
}
}
else
{
//couldn't find the annotation from where the user clicked
return;
}
if (selectedTextObj == null)
{
return; //no obj, so don't do anything
}
//see if we have a custom annotation for this annotation we selected
LadderInstance currentInstance = m_manager.GetCurrentInstance();
Annotation selectedAnnotation = new Annotation();
foreach (Annotation annotation in currentInstance.annotations)
{
if (annotation.m_point == (PointPair)selectedTextObj.Tag)
{
usingCustomAnnotation = true;
selectedAnnotation = annotation;
currentInstance.annotations.Remove(annotation);
break;
}
}
if (selectedAnnotation.m_point == null && selectedAnnotation.m_text == null)
{
selectedAnnotation.m_showHideAuto = 0;
selectedAnnotation.m_text = selectedTextObj.Text;
selectedAnnotation.m_point = (PointPair)selectedTextObj.Tag;
}
// Open the AnnotationEdit form
PlotView.AnnotationEdit editForm = new PlotView.AnnotationEdit(selectedAnnotation);
if (editForm.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
if (editForm.m_annotation.m_showHideAuto < 0)
{
selectedTextObj.IsVisible = false;
}
else if (editForm.m_annotation.m_showHideAuto > 0)
{
selectedTextObj.IsVisible = true;
}
selectedTextObj.Text = editForm.m_annotation.m_text;
currentInstance.annotations.Add(editForm.m_annotation);
}
else if (usingCustomAnnotation)
{
//recreate the annotation we thought we were replacing
currentInstance.annotations.Add(selectedAnnotation);
}
msPlot.ReevaluateAnnotations();
msPlot.Invalidate();
return;
}
public static IDictionary <int, string> SetupCoref(string bammanFile, IDictionary <string, IList <Person> > characterMap, Annotation doc)
{
if (bammanFile != null)
{
//TODO: integrate coref
IDictionary <int, IList <CoreLabel> > bammanTokens = BammanCorefReader.ReadTokenFile(bammanFile, doc);
IDictionary <int, string> pronounCorefMap = MapBammanToCharacterMap(bammanTokens, characterMap);
return(pronounCorefMap);
}
else
{
IDictionary <int, string> pronounCorefMap = new Dictionary <int, string>();
foreach (CorefChain cc in doc.Get(typeof(CorefCoreAnnotations.CorefChainAnnotation)).Values)
{
string representativeMention = cc.GetRepresentativeMention().mentionSpan;
foreach (CorefChain.CorefMention cm in cc.GetMentionsInTextualOrder())
{
if (IsPronominal(cm.mentionSpan))
{
ICoreMap cmSentence = doc.Get(typeof(CoreAnnotations.SentencesAnnotation))[cm.sentNum - 1];
IList <CoreLabel> cmTokens = cmSentence.Get(typeof(CoreAnnotations.TokensAnnotation));
int charBegin = cmTokens[0].Get(typeof(CoreAnnotations.CharacterOffsetBeginAnnotation));
pronounCorefMap[charBegin] = representativeMention;
}
}
}
return(pronounCorefMap);
}
}
public static int GetQuoteParagraphIndex(Annotation doc, ICoreMap quote)
{
IList <ICoreMap> sentences = doc.Get(typeof(CoreAnnotations.SentencesAnnotation));
return(sentences[quote.Get(typeof(CoreAnnotations.SentenceBeginAnnotation))].Get(typeof(CoreAnnotations.ParagraphIndexAnnotation)));
}
public static Pair <int, int> GetTokenRangeFollowingQuote(Annotation doc, ICoreMap quote)
{
IList <ICoreMap> sentences = doc.Get(typeof(CoreAnnotations.SentencesAnnotation));
IList <ICoreMap> quotes = doc.Get(typeof(CoreAnnotations.QuotationsAnnotation));
int quoteEndTokenIndex = quote.Get(typeof(CoreAnnotations.TokenEndAnnotation));
if (quoteEndTokenIndex >= doc.Get(typeof(CoreAnnotations.TokensAnnotation)).Count - 2)
{
return(null);
}
int quoteEndSentenceIndex = quote.Get(typeof(CoreAnnotations.SentenceEndAnnotation));
ICoreMap endSentence = sentences[quoteEndSentenceIndex];
int quoteIndex = quote.Get(typeof(CoreAnnotations.QuotationIndexAnnotation));
if (quoteEndTokenIndex < endSentence.Get(typeof(CoreAnnotations.TokenEndAnnotation)) - 2)
{
//quote TokenEndAnnotation is inclusive; sentence TokenEndAnnotation is exclusive
//check next quote to ensure boundary
if (quoteIndex < quotes.Count - 1)
{
ICoreMap nextQuote = quotes[quoteIndex + 1];
int nextQuoteTokenBegin = nextQuote.Get(typeof(CoreAnnotations.TokenBeginAnnotation));
if (nextQuoteTokenBegin < endSentence.Get(typeof(CoreAnnotations.TokenEndAnnotation)) - 1)
{
if (quoteEndTokenIndex + 1 == nextQuoteTokenBegin)
{
return(null);
}
return(new Pair <int, int>(quoteEndTokenIndex + 1, nextQuoteTokenBegin - 1));
}
}
return(new Pair <int, int>(quoteEndTokenIndex + 1, endSentence.Get(typeof(CoreAnnotations.TokenEndAnnotation)) - 1));
}
else
{
if (quoteEndSentenceIndex < sentences.Count - 1)
{
//check next sentence
ICoreMap nextSentence = sentences[quoteEndSentenceIndex + 1];
int currParagraph = endSentence.Get(typeof(CoreAnnotations.ParagraphIndexAnnotation));
if (nextSentence.Get(typeof(CoreAnnotations.ParagraphIndexAnnotation)) == currParagraph)
{
//check next quote boundary
if (quoteIndex < quotes.Count - 1)
{
ICoreMap nextQuote = quotes[quoteIndex + 1];
int nextQuoteTokenBegin = nextQuote.Get(typeof(CoreAnnotations.TokenBeginAnnotation));
if (nextQuoteTokenBegin < nextSentence.Get(typeof(CoreAnnotations.TokenEndAnnotation)) - 1)
{
if (quoteEndTokenIndex + 1 == nextQuoteTokenBegin)
{
return(null);
}
return(new Pair <int, int>(quoteEndTokenIndex + 1, nextQuoteTokenBegin - 1));
}
return(new Pair <int, int>(quoteEndTokenIndex + 1, nextSentence.Get(typeof(CoreAnnotations.TokenEndAnnotation)) - 1));
}
}
}
}
return(null);
}
protected virtual void SyllabifyUnmarkedAnnotation(Word word, Annotation <ShapeNode> ann, Shape newShape)
{
ProcessSyllable(ann.Range.Start, ann.Range.End, newShape);
}
public static void AssignPageRangeManuallyAfterShowingAnnotation()
{
KnowledgeItem quotation = Program.ActiveProjectShell.PrimaryMainForm.GetSelectedQuotations().FirstOrDefault();
if (quotation.EntityLinks.FirstOrDefault() == null)
{
return;
}
Control quotationSmartRepeater = Program.ActiveProjectShell.PrimaryMainForm.Controls.Find("quotationSmartRepeater", true).FirstOrDefault();
SwissAcademic.Citavi.Shell.Controls.SmartRepeaters.QuotationSmartRepeater quotationSmartRepeaterAsQuotationSmartRepeater = quotationSmartRepeater as SwissAcademic.Citavi.Shell.Controls.SmartRepeaters.QuotationSmartRepeater;
Reference reference = quotation.Reference;
if (reference == null)
{
return;
}
List <KnowledgeItem> quotations = reference.Quotations.ToList();
int index = quotations.FindIndex(q => q == quotation);
Annotation annotation = quotation.EntityLinks.FirstOrDefault().Target as Annotation;
if (annotation == null)
{
return;
}
PreviewControl previewControl = Program.ActiveProjectShell.PrimaryMainForm.PreviewControl;
PdfViewControl pdfViewControl = previewControl.GetPdfViewControl();
if (pdfViewControl == null)
{
return;
}
pdfViewControl.GoToAnnotation(annotation);
KnowledgeItemsForms.NewPageRangeForm("Please enter the new page range:", out string data);
if (!String.IsNullOrEmpty(data))
{
quotation.PageRange = quotation.PageRange.Update(data);
}
if (quotations[index - 1] == null)
{
return;
}
Program.ActiveProjectShell.PrimaryMainForm.ActiveControl = quotationSmartRepeater;
quotationSmartRepeaterAsQuotationSmartRepeater.SelectAndActivate(quotations[index - 1]);
annotation = quotations[index - 1].EntityLinks.FirstOrDefault().Target as Annotation;
if (annotation == null)
{
return;
}
pdfViewControl.GoToAnnotation(annotation);
}
public override Dictionary <string, FileOutput> Package(
BuildContext buildContext,
string projectId,
Dictionary <string, ParseTree.Executable[]> finalCode,
ICollection <ParseTree.StructDefinition> structDefinitions,
string fileCopySourceRoot,
ResourceDatabase resourceDatabase,
SystemLibraryManager libraryManager)
{
Dictionary <string, FileOutput> output = new Dictionary <string, FileOutput>();
string package = projectId.ToLowerInvariant();
Dictionary <string, string> replacements = new Dictionary <string, string>()
{
{ "PROJECT_TITLE", projectId },
{ "PROJECT_ID", projectId },
{ "PACKAGE", package },
{ "CURRENT_YEAR", DateTime.Now.Year.ToString() },
{ "COPYRIGHT", "©" },
};
bool hasIcon = buildContext.IconFilePath != null;
if (hasIcon)
{
output["resources/icon.png"] = new FileOutput()
{
Type = FileOutputType.Copy,
AbsoluteInputPath = buildContext.IconFilePath,
};
}
foreach (string awtFile in new string[] {
"AwtTranslationHelper",
})
{
output["src/" + package + "/" + awtFile + ".java"] = new FileOutput()
{
Type = FileOutputType.Text,
TextContent = Constants.DoReplacements(
Util.ReadResourceFileInternally("game-java-awt/" + awtFile + ".txt"),
replacements)
};
}
foreach (string basicFile in new string[] {
"TranslationHelper",
})
{
output["src/" + package + "/" + basicFile + ".java"] = new FileOutput()
{
Type = FileOutputType.Text,
TextContent = Constants.DoReplacements(
Util.ReadResourceFileInternally("java-common/" + basicFile + ".txt"),
replacements)
};
}
foreach (string basicFile in new string[] {
"AwtTranslationHelper",
"Start",
"GameWindow",
"Image",
"RenderEngine",
})
{
output["src/" + package + "/" + basicFile + ".java"] = new FileOutput()
{
Type = FileOutputType.Text,
TextContent = Constants.DoReplacements(
Util.ReadResourceFileInternally("game-java-awt/" + basicFile + ".txt"),
replacements)
};
}
string[] items = finalCode.Keys.OrderBy <string, string>(s => s.ToLowerInvariant()).ToArray();
List <string> crayonWrapper = new List <string>();
crayonWrapper.Add(string.Join("\n",
"package %%%PACKAGE%%%;",
"",
"import java.util.ArrayList;",
"import java.util.HashMap;",
"import java.util.Stack;",
"",
"public final class CrayonWrapper {",
" private CrayonWrapper() {}",
""));
this.Translator.CurrentIndention++;
foreach (string finalCodeKey in items)
{
this.Translator.Translate(crayonWrapper, finalCode[finalCodeKey]);
}
this.Translator.CurrentIndention--;
crayonWrapper.Add(string.Join("\n",
"}",
""));
output["src/" + package + "/CrayonWrapper.java"] = new FileOutput()
{
Type = FileOutputType.Text,
TextContent = Constants.DoReplacements(string.Join("", crayonWrapper), replacements)
};
string nl = this.Translator.NL;
foreach (StructDefinition structDefinition in structDefinitions)
{
string structName = structDefinition.Name.Value;
string filename = structName + ".java";
List <string> codeContents = new List <string>();
codeContents.Add("public final class " + structName + " {" + nl);
codeContents.Add(" public " + structName + "(");
List <string> types = new List <string>();
for (int i = 0; i < structDefinition.FieldsByIndex.Length; ++i)
{
string type;
Annotation typeAnnotation = structDefinition.Types[i];
if (typeAnnotation == null)
{
throw new Exception("Are there any of these left?");
}
else
{
type = this.GetTypeStringFromAnnotation(typeAnnotation.FirstToken, typeAnnotation.GetSingleArgAsString(null), false, false);
}
types.Add(type);
if (i > 0)
{
codeContents.Add(", ");
}
codeContents.Add(type);
codeContents.Add(" v_" + structDefinition.FieldsByIndex[i]);
}
codeContents.Add(") {" + nl);
for (int i = 0; i < structDefinition.FieldsByIndex.Length; ++i)
{
codeContents.Add(" this." + structDefinition.FieldsByIndex[i] + " = v_" + structDefinition.FieldsByIndex[i] + ";" + nl);
}
codeContents.Add(" }" + nl + nl);
for (int i = 0; i < structDefinition.FieldsByIndex.Length; ++i)
{
codeContents.Add(" public ");
codeContents.Add(types[i]);
codeContents.Add(" " + structDefinition.FieldsByIndex[i] + ";" + nl);
}
codeContents.Add("}" + nl);
string fileContents = string.Join("", codeContents);
string header = "package " + package + ";" + nl + nl;
bool useList = fileContents.Contains("ArrayList<");
bool useHashMap = fileContents.Contains("HashMap<");
bool useStack = fileContents.Contains("Stack<");
if (useList || useHashMap || useStack)
{
if (useList)
{
header += "import java.util.ArrayList;" + nl;
}
if (useHashMap)
{
header += "import java.util.HashMap;" + nl;
}
if (useStack)
{
header += "import java.util.Stack;" + nl;
}
header += nl;
}
fileContents = header + fileContents;
output["src/" + package + "/" + filename] = new FileOutput()
{
Type = FileOutputType.Text,
TextContent = fileContents
};
}
foreach (string tileFile in resourceDatabase.ImageSheetFiles.Keys)
{
output["resources/images/" + tileFile] = resourceDatabase.ImageSheetFiles[tileFile];
}
foreach (FileOutput image in resourceDatabase.ImageResources)
{
if (image.Type != FileOutputType.Ghost)
{
output["resources/images/" + image.CanonicalFileName] = image;
}
}
foreach (FileOutput textFile in resourceDatabase.TextResources)
{
output["resources/text/" + textFile.CanonicalFileName] = textFile;
}
Dictionary <string, string> libraryResourceFiles = this.LibraryManager.CopiedFiles;
foreach (string file in libraryResourceFiles.Keys)
{
string content = libraryResourceFiles[file];
output[file.Replace("%PROJECT_ID%", projectId.ToLower())] = new FileOutput()
{
Type = FileOutputType.Text,
TextContent = Constants.DoReplacements(content, replacements)
};
}
output["resources/bytecode.txt"] = resourceDatabase.ByteCodeFile;
output["resources/manifest.txt"] = resourceDatabase.ResourceManifestFile;
if (resourceDatabase.ImageSheetManifestFile != null)
{
output["resources/imagesheetmanifest.txt"] = resourceDatabase.ImageSheetManifestFile;
}
output["build.xml"] = new FileOutput()
{
Type = FileOutputType.Text,
TextContent = Constants.DoReplacements(
Util.ReadResourceFileInternally("game-java-awt/BuildXml.txt"),
replacements)
};
return(output);
}
protected override DependencyObject CloneAnnotation(Annotation annotation)
{
return(base.CloneAnnotation(new RectangleAnnotation()));
}
private void SetAnnotationAndFocussedMessage(Annotation annotation, Message message)
{
Annotation = annotation;
_currentFocusedMessage = message;
UpdateContentNow();
}
/// <summary>Convert a CoreNLP Annotation object to a Document.</summary>
/// <param name="ann">The CoreNLP Annotation object.</param>
public GermanDocument(Annotation ann)
: base(Edu.Stanford.Nlp.Simple.GermanDocument.EmptyProps, ann)
{
}
