public ClassAttributes GetDTOClassAttributes(string workSheet)
{
var classAttributes = new ClassAttributes(workSheet.GetClassName());
classAttributes.Properties.AddRange(_dataProvider.GetColumns(workSheet));
return(classAttributes);
}
public static bool SaveCharacterDetailsAtCreate(String characterID, String userID, int classID)
{
ClassAttributes.GetClassAttributes(Convert.ToByte(classID), out int level, out int leben, out int exp, out int atk,
out int mana, out int def, out int spd);
String query = Queries.CreateCharacterDetail(Convert.ToInt32(characterID), level, leben, exp, atk, mana, def, spd);
using (SQLiteConnection connection = new SQLiteConnection(GetConnectionString()))
{
SQLiteCommand command = CreateCommandMeta(connection);
SQLiteTransaction transaction;
transaction = connection.BeginTransaction();
command.Transaction = transaction;
try
{
command.CommandText = query;
transaction.Commit();
return(command.ExecuteNonQuery() == 1);
}
catch (Exception)
{
try
{
transaction.Rollback();
}
catch (Exception ex2)
{
throw new Exception(ex2.Message);
}
return(false);
}
}
}
protected OutputFile()
{
var executingAssembly = Assembly.GetExecutingAssembly().GetName();
Namespaces.Add("System");
Namespaces.Add("System.CodeDom.Compiler");
ClassAttributes.Add($"[GeneratedCode(\"{executingAssembly.Name}\", \"{executingAssembly.Version}\")]");
}
public XamlParserContext(IDocumentContext documentContext, ClassAttributes rootAttributes)
{
if (documentContext == null)
{
throw new ArgumentNullException("documentContext");
}
this.documentContext = documentContext;
this.namespaces = new ClrNamespaceUriParseCache(this.TypeResolver);
this.rootAttributes = rootAttributes;
this.errors = (IList <XamlParseError>) new List <XamlParseError>();
}
private void WalkType(INamedTypeSymbol typeSymbol)
{
var classAttribute = typeSymbol.GetPythonClassAttribute();
if (classAttribute != null)
{
ClassAttributes.Add(typeSymbol, classAttribute);
}
foreach (var memberSymbol in typeSymbol.GetMembers())
{
switch (memberSymbol)
{
case IFieldSymbol fieldSymbol:
var fieldAttribute = fieldSymbol.GetPythonFieldAttribute();
if (fieldAttribute != null)
{
FieldAttributes.Add(fieldSymbol, fieldAttribute);
}
break;
case IMethodSymbol methodSymbol:
var methodAttribute = methodSymbol.GetPythonMethodAttribute();
if (methodAttribute != null)
{
MethodAttributes.Add(methodSymbol, methodAttribute);
}
var operatorAttribute = methodSymbol.GetPythonOperatorAttribute();
if (operatorAttribute != null)
{
OperatorAttributes.Add(methodSymbol, operatorAttribute);
}
break;
case IPropertySymbol propertySymbol:
var propertyAttribute = propertySymbol.GetPythonPropertyAttribute();
if (propertyAttribute != null)
{
PropertyAttributes.Add(propertySymbol, propertyAttribute);
}
break;
}
}
}
private static int CalcSelectedRowsHashcode()
{
var r = 0;
if (CoreUserPreferences.Instance.InspectEasing)
{
r ^= FindMarkerBehind()?.GetHashCode() ?? 0;
}
if (Document.Current.Animation.IsCompound)
{
foreach (var track in GetSelectedAnimationTracksAndClips())
{
r ^= track.GetHashCode();
}
}
else if (Document.Current.InspectRootNode)
{
var rootNode = Document.Current.RootNode;
r ^= rootNode.GetHashCode();
foreach (var component in rootNode.Components)
{
r ^= component.GetHashCode();
}
}
else
{
foreach (var row in Document.Current.Rows)
{
if (row.Selected)
{
r ^= row.GetHashCode();
var node = row.Components.Get <NodeRow>()?.Node;
if (node != null)
{
foreach (var component in node.Components)
{
if (ClassAttributes <NodeComponentDontSerializeAttribute> .Get(component.GetType()) != null)
{
continue;
}
r ^= component.GetHashCode();
}
}
}
}
}
return(r);
}
public void SetUp()
{
_excelRepository = MockRepository.GenerateMock<IRepository>();
_classGenerator = MockRepository.GenerateMock<IClassGenerator>();
_assemblyGenerator = MockRepository.GenerateMock<IAssemblyGenerator>();
_fileConfiguration = MockRepository.GenerateMock<IFileConfiguration>();
_excelToDtoMapper = new ExcelToDTOMapper(_excelRepository, _classGenerator, _assemblyGenerator,
_fileConfiguration);
_excelFiles = new List<string>
{
"TestExcel.xls"
};
_workSheetNames = new List<string>
{
"Test1$",
"Test2$"
};
_classAttributes1 = new ClassAttributes("Test1");
_classAttributes2 = new ClassAttributes("Test2");
}
public void SetUp()
{
_excelRepository = MockRepository.GenerateMock <IRepository>();
_classGenerator = MockRepository.GenerateMock <IClassGenerator>();
_assemblyGenerator = MockRepository.GenerateMock <IAssemblyGenerator>();
_fileConfiguration = MockRepository.GenerateMock <IFileConfiguration>();
_excelToDtoMapper = new ExcelToDTOMapper(_excelRepository, _classGenerator, _assemblyGenerator,
_fileConfiguration);
_excelFiles = new List <string>
{
"TestExcel.xls"
};
_workSheetNames = new List <string>
{
"Test1$",
"Test2$"
};
_classAttributes1 = new ClassAttributes("Test1");
_classAttributes2 = new ClassAttributes("Test2");
}
public static Node Perform(Node container, FolderItemLocation location, Type nodeType)
{
if (!nodeType.IsSubclassOf(typeof(Node)))
{
throw new InvalidOperationException();
}
var ctr = nodeType.GetConstructor(Type.EmptyTypes);
var node = (Node)ctr.Invoke(new object[] { });
var attrs = ClassAttributes <TangerineNodeBuilderAttribute> .Get(nodeType);
if (attrs?.MethodName != null)
{
var builder = nodeType.GetMethod(attrs.MethodName, BindingFlags.NonPublic | BindingFlags.Instance);
builder.Invoke(node, new object[] { });
}
node.Id = GenerateNodeId(container, nodeType);
InsertFolderItem.Perform(container, location, node);
ClearRowSelection.Perform();
SelectNode.Perform(node);
Document.Current.Decorate(node);
return(node);
}
public bool Run(string assemblyName, List <string> files)
{
List <ClassAttributes> classAttributesList = new List <ClassAttributes>();
foreach (string file in files)
{
_fileConfiguration.FileName = file;
foreach (string workSheet in _excelRepository.GetWorkSheetNames())
{
ClassAttributes classAttributes = _excelRepository.GetDTOClassAttributes(workSheet);
classAttributes.Namespace = String.Format("{0}.{1}", assemblyName, Path.GetFileNameWithoutExtension(file));
if (classAttributes.Properties.Count == 0)
{
continue;
}
_classGenerator.Create(classAttributes);
classAttributesList.Add(classAttributes);
}
}
return((classAttributesList.Count > 0) &&
_assemblyGenerator.Compile(classAttributesList.Select(x => x.FullName).ToArray(), new AssemblyAttributes(assemblyName)));
}
public ClassRepresentationBuilder WithClassAttributes(params string[] classAttributes)
{
ClassAttributes.AddRange(classAttributes);
return(this);
}
private void CancelAllEdits()
{
ClassAttributes.CancelEdit();
txtClassName.myEditable = false;
txtElementNameLabel.myEditable = false;
}
private void ImportProcedure(string library, ProcedureNode proc)
{
string procName = proc.name;
if (proc.isAutoGeneratedThisProc ||
CoreUtils.IsSetter(procName) ||
CoreUtils.IsDisposeMethod(procName) ||
CoreUtils.StartsWithDoubleUnderscores(procName))
{
return;
}
int classScope = proc.classScope;
string className = string.Empty;
MethodAttributes methodAttribute = proc.MethodAttribute;
ClassAttributes classAttribute = null;
if (classScope != ProtoCore.DSASM.Constants.kGlobalScope)
{
var classNode = GraphUtilities.GetCore().ClassTable.ClassNodes[classScope];
classAttribute = classNode.ClassAttributes;
className = classNode.name;
}
// MethodAttribute's HiddenInLibrary has higher priority than
// ClassAttribute's HiddenInLibrary
bool isVisible = true;
if (methodAttribute != null)
{
isVisible = !methodAttribute.HiddenInLibrary;
}
else
{
if (classAttribute != null)
{
isVisible = !classAttribute.HiddenInLibrary;
}
}
FunctionType type;
if (classScope == ProtoCore.DSASM.Constants.kGlobalScope)
{
type = FunctionType.GenericFunction;
}
else
{
if (CoreUtils.IsGetter(procName))
{
type = proc.isStatic
? FunctionType.StaticProperty
: FunctionType.InstanceProperty;
string property;
if (CoreUtils.TryGetPropertyName(procName, out property))
{
procName = property;
}
}
else
{
if (proc.isConstructor)
{
type = FunctionType.Constructor;
}
else if (proc.isStatic)
{
type = FunctionType.StaticMethod;
}
else
{
type = FunctionType.InstanceMethod;
}
}
}
IEnumerable <TypedParameter> arguments = proc.argInfoList.Zip(
proc.argTypeList,
(arg, argType) =>
{
object defaultValue = null;
if (arg.IsDefault)
{
var binaryExpr = arg.DefaultExpression as BinaryExpressionNode;
if (binaryExpr != null)
{
AssociativeNode vnode = binaryExpr.RightNode;
if (vnode is IntNode)
{
defaultValue = (vnode as IntNode).Value;
}
else if (vnode is DoubleNode)
{
defaultValue = (vnode as DoubleNode).Value;
}
else if (vnode is BooleanNode)
{
defaultValue = (vnode as BooleanNode).Value;
}
else if (vnode is StringNode)
{
defaultValue = (vnode as StringNode).value;
}
}
}
return(new TypedParameter(arg.Name, argType.ToString(), defaultValue));
});
IEnumerable <string> returnKeys = null;
if (proc.MethodAttribute != null && proc.MethodAttribute.ReturnKeys != null)
{
returnKeys = proc.MethodAttribute.ReturnKeys;
}
var function = new FunctionDescriptor(
library,
className,
procName,
arguments,
proc.returntype.ToString(),
type,
isVisible,
returnKeys,
proc.isVarArg);
AddImportedFunctions(library, new[] { function });
}
private void CancelAllEdits()
{
ClassAttributes.CancelEdit();
ClassOperations.CancelEdit();
txtClassName.myEditable = false;
}
public override void Execute()
{
string fileName = "test";
IProject activeProject = this.DesignerContext.ActiveProject;
TemplateItemHelper templateItemHelper = new TemplateItemHelper(activeProject, (IList <string>)null, (IServiceProvider)this.DesignerContext.Services);
IProjectItemTemplate templateItem = templateItemHelper.FindTemplateItem("UserControl");
if (templateItem == null)
{
this.DesignerContext.MessageDisplayService.ShowError(StringTable.MakeUserControlTemplateNotFound);
}
else
{
SceneViewModel activeSceneViewModel = this.DesignerContext.ActiveSceneViewModel;
List <SceneElement> elements = new List <SceneElement>();
elements.AddRange((IEnumerable <SceneElement>)activeSceneViewModel.ElementSelectionSet.Selection);
elements.Sort((IComparer <SceneElement>) new ZOrderComparer <SceneElement>(activeSceneViewModel.RootNode));
if (this.ShowUI)
{
string recommendedName = this.GetRecommendedName((IEnumerable <SceneElement>)elements);
MakeUserControlDialog userControlDialog = new MakeUserControlDialog(this.DesignerContext, this.DialogTitle, templateItemHelper, recommendedName);
bool?nullable = userControlDialog.ShowDialog();
if ((!nullable.GetValueOrDefault() ? 1 : (!nullable.HasValue ? true : false)) != 0)
{
return;
}
fileName = userControlDialog.ControlName;
}
List <IProjectItem> itemsToOpen = (List <IProjectItem>)null;
IProjectItem projectItem1 = (IProjectItem)null;
IEnumerable <IProjectItem> source = (IEnumerable <IProjectItem>)null;
try
{
source = templateItemHelper.AddProjectItemsForTemplateItem(templateItem, fileName, this.DesignerContext.ProjectManager.TargetFolderForProject(activeProject), CreationOptions.DoNotAllowOverwrites | CreationOptions.DoNotSelectCreatedItems | CreationOptions.DoNotSetDefaultImportPath, out itemsToOpen);
}
catch (Exception ex)
{
if (ex is NotSupportedException || ErrorHandling.ShouldHandleExceptions(ex))
{
this.DesignerContext.MessageDisplayService.ShowError(string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.ProjectNewFileErrorDialogMessage, new object[2]
{
(object)fileName,
(object)ex.Message
}));
}
else
{
throw;
}
}
if (source == null || EnumerableExtensions.CountIsLessThan <IProjectItem>(source, 1))
{
return;
}
if (itemsToOpen != null && itemsToOpen.Count > 0)
{
projectItem1 = Enumerable.FirstOrDefault <IProjectItem>((IEnumerable <IProjectItem>)itemsToOpen);
projectItem1.OpenDocument(false, true);
}
if (projectItem1 != null && projectItem1.IsOpen && projectItem1.DocumentType.CanView)
{
Rect empty = Rect.Empty;
for (int index = 0; index < elements.Count; ++index)
{
BaseFrameworkElement child = elements[index] as BaseFrameworkElement;
if (child != null)
{
Rect childRect = child.ViewModel.GetLayoutDesignerForChild((SceneElement)child, true).GetChildRect(child);
empty.Union(childRect);
}
}
Rect rect = RoundingHelper.RoundRect(empty);
SceneElement parentElement = elements[0].ParentElement;
bool useLayoutRounding = LayoutRoundingHelper.GetUseLayoutRounding(parentElement);
DataObject dataObject = (DataObject)null;
using (activeSceneViewModel.ForceBaseValue())
{
PastePackage pastePackage = new PastePackage(activeSceneViewModel);
pastePackage.CopyStoryboardsReferencingElements = true;
pastePackage.AddElements(elements);
dataObject = pastePackage.GetPasteDataObject();
}
SceneView sceneView = projectItem1.OpenView(true) as SceneView;
if (sceneView != null)
{
SceneViewModel viewModel = sceneView.ViewModel;
ProjectXamlContext projectXamlContext = ProjectXamlContext.FromProjectContext(viewModel.ViewRoot.ProjectContext);
ClassAttributes rootClassAttributes = viewModel.DocumentRoot.RootClassAttributes;
ITypeId typeId = (ITypeId)null;
if (projectXamlContext != null && rootClassAttributes != null)
{
projectXamlContext.RefreshUnbuiltTypeDescriptions();
if (rootClassAttributes != null)
{
typeId = (ITypeId)projectXamlContext.GetType(projectXamlContext.ProjectAssembly.Name, rootClassAttributes.QualifiedClassName);
}
}
if (typeId != null && this.CheckForCircularReference((IEnumerable <SceneElement>)elements, typeId))
{
this.DesignerContext.MessageDisplayService.ShowError(StringTable.MakeUserControlCircularReferenceFound);
this.CleanupAfterCancel(projectItem1);
return;
}
using (SceneEditTransaction editTransaction = viewModel.CreateEditTransaction(StringTable.UndoUnitMakeUserControl))
{
if (!rect.IsEmpty)
{
viewModel.RootNode.SetValue(DesignTimeProperties.DesignWidthProperty, (object)rect.Width);
viewModel.RootNode.SetValue(DesignTimeProperties.DesignHeightProperty, (object)rect.Height);
if (this.AddToApplicationFlow)
{
viewModel.RootNode.SetValue(BaseFrameworkElement.WidthProperty, (object)rect.Width);
viewModel.RootNode.SetValue(BaseFrameworkElement.HeightProperty, (object)rect.Height);
}
}
IProperty property = LayoutRoundingHelper.ResolveUseLayoutRoundingProperty(viewModel.RootNode);
if (property != null)
{
viewModel.RootNode.SetValue((IPropertyId)property, (object)(bool)(useLayoutRounding ? true : false));
}
ILayoutDesigner designerForParent = viewModel.GetLayoutDesignerForParent(viewModel.ActiveSceneInsertionPoint.SceneElement, true);
bool canceledPasteOperation;
ICollection <SceneNode> nodes = PasteCommand.PasteData(viewModel, new SafeDataObject((IDataObject)dataObject), viewModel.ActiveSceneInsertionPoint, out canceledPasteOperation);
if (canceledPasteOperation)
{
editTransaction.Cancel();
this.CleanupAfterCancel(projectItem1);
return;
}
editTransaction.Update();
if (nodes.Count > 0)
{
viewModel.DefaultView.UpdateLayout();
viewModel.SelectNodes(nodes);
if (designerForParent != null)
{
foreach (SceneNode sceneNode in (IEnumerable <SceneNode>)nodes)
{
BaseFrameworkElement child = sceneNode as BaseFrameworkElement;
if (child != null && child.IsViewObjectValid)
{
Rect childRect = child.ViewModel.GetLayoutDesignerForChild((SceneElement)child, true).GetChildRect(child);
childRect.Location = (Point)(childRect.Location - rect.Location);
designerForParent.SetChildRect(child, childRect);
}
}
}
}
editTransaction.Commit();
}
if (this.AddToApplicationFlow && this.DesignerContext.PrototypingService != null)
{
this.DesignerContext.PrototypingService.PromoteToCompositionScreen(projectItem1);
}
if (typeId != null)
{
using (activeSceneViewModel.ForceBaseValue())
{
using (activeSceneViewModel.DisableDrawIntoState())
{
using (SceneEditTransaction editTransaction = activeSceneViewModel.CreateEditTransaction(StringTable.UndoUnitMakeUserControl))
{
using (activeSceneViewModel.DisableUpdateChildrenOnAddAndRemove())
{
SceneElement primarySelection = activeSceneViewModel.ElementSelectionSet.PrimarySelection;
IProperty propertyForChild = parentElement.GetPropertyForChild((SceneNode)primarySelection);
PropertySceneInsertionPoint sceneInsertionPoint = new PropertySceneInsertionPoint(parentElement, propertyForChild);
SceneNode sceneNode = (SceneNode)null;
if (sceneInsertionPoint.CanInsert(typeId))
{
foreach (SceneElement element in elements)
{
if (element != primarySelection)
{
activeSceneViewModel.AnimationEditor.DeleteAllAnimationsInSubtree(element);
element.Remove();
}
}
ISceneNodeCollection <SceneNode> collectionForProperty = parentElement.GetCollectionForProperty((IPropertyId)propertyForChild);
int index = collectionForProperty.IndexOf((SceneNode)primarySelection);
activeSceneViewModel.AnimationEditor.DeleteAllAnimationsInSubtree(primarySelection);
primarySelection.Remove();
sceneNode = activeSceneViewModel.CreateSceneNode(typeId);
collectionForProperty.Insert(index, sceneNode);
this.DesignerContext.ViewService.ActiveView = (IView)activeSceneViewModel.DefaultView;
editTransaction.Update();
activeSceneViewModel.DefaultView.UpdateLayout();
BaseFrameworkElement child = sceneNode as BaseFrameworkElement;
if (child != null && child.IsViewObjectValid)
{
activeSceneViewModel.GetLayoutDesignerForParent(parentElement, true).SetChildRect(child, rect);
}
}
if (this.AddToApplicationFlow)
{
if (sceneNode != null)
{
sceneNode.SetValue(DesignTimeProperties.IsPrototypingCompositionProperty, (object)true);
}
}
}
editTransaction.Commit();
}
}
}
this.DesignerContext.ViewService.ActiveView = (IView)viewModel.DefaultView;
}
}
}
if (itemsToOpen == null || itemsToOpen.Count <= 1)
{
return;
}
foreach (IProjectItem projectItem2 in itemsToOpen)
{
if (projectItem1 != projectItem2)
{
projectItem2.OpenView(true);
}
}
}
}
public ReactElement <HTMLAttributes <HTMLDivElement> > Render()
{
// Create label:
Intersection <ClassAttributes <HTMLLabelElement>, HTMLAttributes <HTMLLabelElement> > labelConfig =
new ClassAttributes <HTMLLabelElement>
{
key = "label1"
};
var labelNode = DOM.label.Self(labelConfig, props.Label).AsNode();
// Create input:
Intersection <ClassAttributes <HTMLInputElement>, ChangeTargetHTMLAttributes <HTMLInputElement> > inputConfig =
new ChangeTargetHTMLAttributes <HTMLInputElement>
{
style = new CSSProperties
{
marginLeft = 20,
},
value = state.Value,
onChange = Handler.ChangeEvent <HTMLInputElement>(e =>
{
setState(new State {
Value = e.currentTarget.Type2.value
});
})
};
inputConfig.Type1.key = "input1";
var inputNode = DOM.input.Self(inputConfig).AsNode();
// Create button:
Intersection <ClassAttributes <HTMLButtonElement>, HTMLAttributes <HTMLButtonElement> > buttonConfig =
new HTMLAttributes <HTMLButtonElement>
{
style = new CSSProperties
{
height = 28,
width = 150,
marginLeft = 20,
},
dangerouslySetInnerHTML = new DOMAttributes <HTMLButtonElement> .dangerouslySetInnerHTMLConfig()
{
__html = string.IsNullOrWhiteSpace(state.Value) ? "Enter text" : "Print to Console",
},
disabled = string.IsNullOrWhiteSpace(state.Value),
onClick = Handler.MouseEvent <HTMLButtonElement>(e => props.OnSave(state.Value))
};
buttonConfig.Type1.key = "button1";
var buttonNode = DOM.button.Self(buttonConfig).AsNode();
// Create div:
var div = DOM.div.Self(new HTMLAttributes <HTMLDivElement> {
className = "wrapper"
}, new [] {
labelNode,
inputNode,
buttonNode
});
return(div);
}
private void ImportProcedure(string library, ProcedureNode proc)
{
string procName = proc.Name;
if (proc.IsAutoGeneratedThisProc ||
// There could be DS functions that have private access
// that shouldn't be imported into the Library
proc.AccessModifier == AccessModifier.Private ||
CoreUtils.IsSetter(procName) ||
CoreUtils.IsDisposeMethod(procName) ||
CoreUtils.StartsWithDoubleUnderscores(procName))
{
return;
}
string obsoleteMessage = "";
int classScope = proc.ClassID;
string className = string.Empty;
MethodAttributes methodAttribute = proc.MethodAttribute;
ClassAttributes classAttribute = null;
if (classScope != Constants.kGlobalScope)
{
var classNode = LibraryManagementCore.ClassTable.ClassNodes[classScope];
classAttribute = classNode.ClassAttributes;
className = classNode.Name;
}
// MethodAttribute's HiddenInLibrary has higher priority than
// ClassAttribute's HiddenInLibrary
var isVisible = true;
var canUpdatePeriodically = false;
if (methodAttribute != null)
{
isVisible = !methodAttribute.HiddenInLibrary;
canUpdatePeriodically = methodAttribute.CanUpdatePeriodically;
}
else
{
if (classAttribute != null)
{
isVisible = !classAttribute.HiddenInLibrary;
}
}
FunctionType type;
if (classScope == Constants.kGlobalScope)
{
type = FunctionType.GenericFunction;
}
else
{
if (CoreUtils.IsGetter(procName))
{
type = proc.IsStatic
? FunctionType.StaticProperty
: FunctionType.InstanceProperty;
string property;
if (CoreUtils.TryGetPropertyName(procName, out property))
{
procName = property;
}
}
else
{
if (proc.IsConstructor)
{
type = FunctionType.Constructor;
}
else if (proc.IsStatic)
{
type = FunctionType.StaticMethod;
}
else
{
type = FunctionType.InstanceMethod;
}
}
}
List <TypedParameter> arguments = proc.ArgumentInfos.Zip(
proc.ArgumentTypes,
(arg, argType) =>
{
AssociativeNode defaultArgumentNode;
// Default argument specified by DefaultArgumentAttribute
// takes higher priority
if (!TryGetDefaultArgumentFromAttribute(arg, out defaultArgumentNode) &&
arg.IsDefault)
{
var binaryExpr = arg.DefaultExpression as BinaryExpressionNode;
if (binaryExpr != null)
{
defaultArgumentNode = binaryExpr.RightNode;
}
}
string shortName = null;
if (defaultArgumentNode != null)
{
shortName = defaultArgumentNode.ToString();
var rewriter = new ElementRewriter(LibraryManagementCore.ClassTable, LibraryManagementCore.BuildStatus.LogSymbolConflictWarning);
defaultArgumentNode = defaultArgumentNode.Accept(rewriter);
}
return(new TypedParameter(arg.Name, argType, defaultArgumentNode, shortName));
}).ToList();
bool isLacingDisabled = false;
IEnumerable <string> returnKeys = null;
if (proc.MethodAttribute != null)
{
if (proc.MethodAttribute.ReturnKeys != null)
{
returnKeys = proc.MethodAttribute.ReturnKeys;
}
if (proc.MethodAttribute.IsObsolete)
{
obsoleteMessage = proc.MethodAttribute.ObsoleteMessage;
}
isLacingDisabled = proc.MethodAttribute.IsLacingDisabled;
}
var function = new FunctionDescriptor(new FunctionDescriptorParams
{
Assembly = library,
ClassName = className,
FunctionName = procName,
Parameters = arguments,
ReturnType = proc.ReturnType,
FunctionType = type,
IsVisibleInLibrary = isVisible,
ReturnKeys = returnKeys,
PathManager = pathManager,
IsVarArg = proc.IsVarArg,
ObsoleteMsg = obsoleteMessage,
CanUpdatePeriodically = canUpdatePeriodically,
IsBuiltIn = pathManager.PreloadedLibraries.Contains(library),
IsPackageMember = packagedLibraries.Contains(library),
IsLacingDisabled = isLacingDisabled
});
AddImportedFunctions(library, new[] { function });
}
public override StringBuilder Generate()
{
StringBuilder builder = new();
var currentIndent = 0;
if (!string.IsNullOrWhiteSpace(Namespace))
{
builder.Append($"package {Namespace};{NewLine}{NewLine}");
}
if (Imports.Count > 0)
{
builder.Append("import " + string.Join($";{NewLine}import ", Imports.Where(i => !i.Equals(Namespace))) + $";{NewLine}{NewLine}");
}
ClassAttributes.ForEach(attr =>
{
IndentStringBuilder(builder, currentIndent);
builder.Append($"{attr}{NewLine}");
});
IndentStringBuilder(builder, currentIndent);
builder.Append($"{ClassAccess} class {FileName}");
if (Relations.Any(r => r.RelationType == ClassRelationType.Inheritance && r.Target.Type == FileType.Class))
{
builder.Append(
$" extends {Relations.First(r => r.RelationType == ClassRelationType.Inheritance && r.Target.Type == FileType.Class).Target.Name}");
}
if (Relations.Any(r => r.RelationType == ClassRelationType.Inheritance && r.Target.Type == FileType.Interface))
{
builder.Append(" implements " + string.Join(", ", Relations.Where(r => r.RelationType == ClassRelationType.Inheritance && r.Target.Type == FileType.Interface).Select(x => x.Target.Name)));
}
IndentStringBuilder(builder.Append(NewLine), currentIndent++);
builder.Append($"{{{NewLine}");
FieldsAndProperties.ForEach(d =>
{
});
Constructors.ForEach(ctr =>
{
IndentStringBuilder(builder, currentIndent);
builder.Append($"{Helper.ToString(ctr.Access)} {ctr.NameType.Name}({string.Join(", ", ctr.Params.Select(p => $"{p.Type} {p.Name}"))}){{{NewLine}");
IndentStringBuilder(builder, ++currentIndent);
builder.Append($"{NewLine}");
IndentStringBuilder(builder, --currentIndent);
builder.Append($"}}{NewLine}");
});
Methods.ForEach(m =>
{
IndentStringBuilder(builder, currentIndent);
builder.Append($"{Helper.ToString(m.Access)} {m.NameType.Type} {m.NameType.Name}({string.Join(", ", m.Params.Select(p => $"{p.Type} {p.Name}"))}){NewLine}");
IndentStringBuilder(builder, currentIndent);
builder.Append($"{{{NewLine}");
IndentStringBuilder(builder, ++currentIndent);
builder.Append($"{NewLine}");
IndentStringBuilder(builder, --currentIndent);
builder.Append($"}}{NewLine}");
});
//builder.Append(NewLine);
IndentStringBuilder(builder, currentIndent);
builder.Append(NewLine);
IndentStringBuilder(builder, --currentIndent);
return(builder.Append('}'));
}
public string GetClassAttributesAsString()
{
return(ClassAttributes.Aggregate("", (current, classAttribute) => current + ("[" + classAttribute + "]" + Environment.NewLine)));
}
private void ImportProcedure(string library, ProcedureNode proc)
{
string procName = proc.name;
if (proc.isAutoGeneratedThisProc ||
CoreUtils.IsSetter(procName) ||
CoreUtils.IsDisposeMethod(procName) ||
CoreUtils.StartsWithDoubleUnderscores(procName))
{
return;
}
string obsoleteMessage = "";
int classScope = proc.classScope;
string className = string.Empty;
MethodAttributes methodAttribute = proc.MethodAttribute;
ClassAttributes classAttribute = null;
if (classScope != Constants.kGlobalScope)
{
var classNode = LibraryManagementCore.ClassTable.ClassNodes[classScope];
classAttribute = classNode.ClassAttributes;
className = classNode.name;
}
// MethodAttribute's HiddenInLibrary has higher priority than
// ClassAttribute's HiddenInLibrary
var isVisible = true;
var canUpdatePeriodically = false;
if (methodAttribute != null)
{
isVisible = !methodAttribute.HiddenInLibrary;
canUpdatePeriodically = methodAttribute.CanUpdatePeriodically;
}
else
{
if (classAttribute != null)
{
isVisible = !classAttribute.HiddenInLibrary;
}
}
FunctionType type;
if (classScope == Constants.kGlobalScope)
{
type = FunctionType.GenericFunction;
}
else
{
if (CoreUtils.IsGetter(procName))
{
type = proc.isStatic
? FunctionType.StaticProperty
: FunctionType.InstanceProperty;
string property;
if (CoreUtils.TryGetPropertyName(procName, out property))
{
procName = property;
}
}
else
{
if (proc.isConstructor)
{
type = FunctionType.Constructor;
}
else if (proc.isStatic)
{
type = FunctionType.StaticMethod;
}
else
{
type = FunctionType.InstanceMethod;
}
}
}
List <TypedParameter> arguments = proc.argInfoList.Zip(
proc.argTypeList,
(arg, argType) =>
{
AssociativeNode defaultArgumentNode;
// Default argument specified by DefaultArgumentAttribute
// takes higher priority
if (!TryGetDefaultArgumentFromAttribute(arg, out defaultArgumentNode) &&
arg.IsDefault)
{
var binaryExpr = arg.DefaultExpression as BinaryExpressionNode;
if (binaryExpr != null)
{
defaultArgumentNode = binaryExpr.RightNode;
}
}
return(new TypedParameter(arg.Name, argType, defaultArgumentNode));
}).ToList();
IEnumerable <string> returnKeys = null;
if (proc.MethodAttribute != null)
{
if (proc.MethodAttribute.ReturnKeys != null)
{
returnKeys = proc.MethodAttribute.ReturnKeys;
}
if (proc.MethodAttribute.IsObsolete)
{
obsoleteMessage = proc.MethodAttribute.ObsoleteMessage;
}
}
var function = new FunctionDescriptor(new FunctionDescriptorParams
{
Assembly = library,
ClassName = className,
FunctionName = procName,
Parameters = arguments,
ReturnType = proc.returntype,
FunctionType = type,
IsVisibleInLibrary = isVisible,
ReturnKeys = returnKeys,
PathManager = pathManager,
IsVarArg = proc.isVarArg,
ObsoleteMsg = obsoleteMessage,
CanUpdatePeriodically = canUpdatePeriodically,
IsBuiltIn = pathManager.PreloadedLibraries.Contains(library)
});
AddImportedFunctions(library, new[] { function });
}
public ReactElement <HTMLAttributes <HTMLDivElement> > Render()
{
// Create label:
Intersection <ClassAttributes <HTMLLabelElement>, HTMLAttributes <HTMLLabelElement> > labelConfig =
new ClassAttributes <HTMLLabelElement>
{
key = "label1"
};
var labelNode = createElement("label", labelConfig).AsNode();
// Create input:
Intersection <ClassAttributes <HTMLInputElement>, InputHTMLAttributes <HTMLInputElement> > inputConfig =
new InputHTMLAttributes <HTMLInputElement>
{
style = new CSSProperties
{
marginLeft = (Union <string, double>) 20
},
value = state.Value,
onChange = Handler.ChangeEvent <HTMLInputElement>(e =>
{
state = new State {
Value = e.target.Type2.value
};
setState <KeyOf <State> >(state);
//System.Console.WriteLine(e.target.Type2.value);
//System.Console.WriteLine(state.Value);
})
};
inputConfig.Type1.key = "input1";
var inputNode = createElement("input", inputConfig).AsNode();
// Create button:
Intersection <ClassAttributes <HTMLButtonElement>, ButtonHTMLAttributes <HTMLButtonElement> > buttonConfig =
new ButtonHTMLAttributes <HTMLButtonElement>
{
style = new CSSProperties
{
height = (Union <string, double>) 28,
width = (Union <string, double>) 150,
marginLeft = (Union <string, double>) 20
},
dangerouslySetInnerHTML = new DOMAttributes <HTMLButtonElement> .dangerouslySetInnerHTMLConfig()
{
__html = string.IsNullOrWhiteSpace(state.Value) ? "Enter text" : "Print to Console",
},
disabled = string.IsNullOrWhiteSpace(state.Value),
onClick = Handler.MouseEvent <HTMLButtonElement>(e =>
{
props.OnSave(state.Value);
})
};
buttonConfig.Type1.key = "button1";
var buttonNode = createElement("button", buttonConfig).AsNode();
// Create div:
Intersection <ClassAttributes <HTMLDivElement>, HTMLAttributes <HTMLDivElement> > divConfig =
new HTMLAttributes <HTMLDivElement>
{
className = "wrapper"
};
var div = createElement("div", divConfig, new[]
{
labelNode,
inputNode,
buttonNode
});
return(div);
}
