static void Handler()
{
int StackPointer = Stack.Add("UI.Settings.Handler()");
Button(Controls.LastClickedButton);
Stack.Exit(StackPointer);
}
static void Button(string LastClickedButton)
{
int StackPointer = Stack.Add($"UI.Settings.Button({LastClickedButton})");
if (LastClickedButton == _Buttons["Settings Save"])
{
GlobalStatic.Settings["Listview"] = string.Format("Width={0};Height={1};", Controls.GetTextBoxText(_TextBox["Settings_Width"]), Controls.GetTextBoxText(_TextBox["Settings_Height"]));
GlobalStatic.Settings["Extensions"] = Controls.GetTextBoxText(_TextBox["Settings_Extensions"]);
GlobalStatic.Settings["Deliminator"] = Controls.GetTextBoxText(_TextBox["Settings_Deliminator"]);
GlobalStatic.Settings["Language"] = Language.ISO_LangCode[LDControls.ComboBoxGetSelected(GlobalStatic.ComboBox["Language"]) - 1];
GlobalStatic.LanguageCode = GlobalStatic.Settings["Language"];
DBM.Settings.Save();
DBM.Settings.Load(GlobalStatic.RestoreSettings, GlobalStatic.SettingsPath);
Language.Load(
Path.Combine(GlobalStatic.LocalizationFolder, GlobalStatic.LanguageCode + ".xml"),
Path.Combine(GlobalStatic.Localization_LanguageCodes_Path, GlobalStatic.LanguageCode + ".txt")
);
Button(_Buttons["Settings Close"]);
Stack.Exit(StackPointer);
return;
}
else if (LastClickedButton == _Buttons["Settings Close"])
{
Clear();
Stack.Exit(StackPointer);
return;
}
}
static void CSVHeaders(int Standard_Size, string TableName, ref StreamWriter SW)
{
int StackPointer = Stack.Add("Import.CSVHeaders");
HeaderSQL = $"CREATE TABLE IF NOT EXISTS \"{TableName}\" (";
HeaderWOType = "(";
for (int i = 1; i <= Standard_Size; i++)
{
HeaderSQL += "\"" + LDFastArray.Get2D(Data, 1, i) + "\" ";
HeaderWOType += "\"" + LDFastArray.Get2D(Data, 1, i) + "\"";
switch (CSV_IsString[(i - 1)])
{
case true:
HeaderSQL += "TEXT";
break;
case false:
HeaderSQL += "INTEGER";
break;
}
if (i < Standard_Size)
{
HeaderSQL += ",";
HeaderWOType += ",";
}
}
HeaderSQL += ");\n";
HeaderWOType += ")";
SW.WriteLine(HeaderSQL);
SW.Flush();
Stack.Exit(StackPointer);
}
/// <summary>
/// This method should only run when the correct global Paramters are set.
/// //Current Storage only supports SQLite db file.
/// </summary>
public static void TransactionRecord(string UserName, string DataBase, string SQL, Type Type, string Reason)
{
int StackPointer = Stack.Add("Engines.TransactionRecord(" + DataBase + ")");
//Escapes function when conditions are correct
if (DataBase == GlobalStatic.TransactionDB) //This is done to prevent a stackoverflow.
{
Stack.Exit(StackPointer);
return;
}
if (GlobalStatic.Transaction_Commands == true && Type == Type.Command)
{
string _Type = "Command";
_TransactionRecord(UserName, DataBase, SQL, _Type, Reason);
}
if (GlobalStatic.Transaction_Query == true && Type == Type.Query)
{
string _Type = "Query";
_TransactionRecord(UserName, DataBase, SQL, _Type, Reason);
}
Stack.Exit(StackPointer);
}
/// <summary>
/// Automatically adds a list of custom functions to be binded on database creation :)
/// </summary>
public static void CreateBindList()
{
int StackPointer = Stack.Add("Engines.CreateBindList()");
//Math Functions
AddToBindList(new CustomFunctions.Power());
AddToBindList(new CustomFunctions.Sqrt());
AddToBindList(new CustomFunctions.e());
AddToBindList(new CustomFunctions.PI());
AddToBindList(new CustomFunctions.Log());
AddToBindList(new CustomFunctions.Sin());
AddToBindList(new CustomFunctions.Sinh());
AddToBindList(new CustomFunctions.Cos());
AddToBindList(new CustomFunctions.Cosh());
AddToBindList(new CustomFunctions.Tan());
AddToBindList(new CustomFunctions.Tanh());
//Crypthological Functions
AddToBindList(new CustomFunctions.Encrypt());
AddToBindList(new CustomFunctions.Decrypt());
AddToBindList(new CustomFunctions.Hash());
//Misc Functions
AddToBindList(new CustomFunctions.Translate());
AddToBindList(new CustomFunctions.RegEx());
Stack.Exit(StackPointer);
}
public static string GenerateQuery(GenerateQuerySettings GQS, string CurrentTable)
{
int StackReference = Stack.Add("Engines.GenerateQuery()");
if (string.IsNullOrEmpty(CurrentTable))
{
throw new ArgumentNullException();
}
GQ_CMD = string.Format("SELECT * FROM \"{0}\" ", CurrentTable.SanitizeFieldName());
if (GQS.Search)
{
GQ_CMD += GenerateSearch(GQS.SearchBy, GQS.SearchText, GQS.InvertSearch, GQS.StrictSearch);
}
if (GQS.RunFunction)
{
GQ_CMD = GenerateFunction(GQS.FunctionSelected, GQS.FunctionColumn, CurrentTable);
}
if (GQS.Sort)
{
GQ_CMD += GenerateSort(GQS.OrderBy, GQS.Order);
}
Console.WriteLine("Generated Query :{0}", GQ_CMD);
Stack.Exit(StackReference);
return(GQ_CMD);
}
/// <summary>
/// StringBuilder based XML document creator.
/// </summary>
/// <param name="Data"></param>
/// <param name="Schema"></param>
/// <param name="Title"></param>
/// <param name="FilePath"></param>
public static void XML(Primitive Data, Primitive Schema, string Title, string FilePath)
{
int StackPointer = Stack.Add("Export.XML");
const string XML_Creation_Statement = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n";
Title = Title.Replace(" ", "_").Replace("\"", "").Replace("&", "").Replace("<", "").Replace(">", "").Replace("'", "");
StringBuilder _XML = new StringBuilder();
_XML.Append(XML_Creation_Statement);
_XML.Append("<root>\n");
_XML.AppendFormat("\t<{0}>\n", Title);
string[] SchemArray = ConvertSchema(Schema);
string[,] DataArray = ConvertData(Schema, Data);
int DataCount = Data.GetItemCount();
int SchemaCount = Schema.GetItemCount();
for (int i = 0; i < DataCount; i++)
{
_XML.Append("\t\t<row>\n");
for (int ii = 0; ii < SchemaCount; ii++)
{
string Node = SchemArray[ii].Replace(" ", "_").Replace("\"", "").Replace("&", "").Replace("<", "").Replace(">", "").Replace("'", "");
string Item = DataArray[i, ii].Replace("&", "&").Replace("<", "<");
_XML.AppendFormat("\t\t\t<{0}>{1}</{0}>\n", Node, Item);
}
_XML.Append("\t\t</row>\n");
}
_XML.AppendFormat("\t</{0}>\n", Title);
_XML.Append("</root>");
System.IO.File.WriteAllText(FilePath, _XML.ToString());
Stack.Exit(StackPointer);
}
public static void CreateStatisticsTable(string Database, string Table, string StatTableName, Primitive Schema)
{
int StackPointer = Stack.Add($"Engines.Transform.CreateStatisticsPage({Database},{Table},{StatTableName})");
StringBuilder SQL = new StringBuilder();
switch (DB_Info[Database].Engine)
{
case EnginesMode.SQLITE:
SQL.AppendFormat("DROP TABLE IF EXISTS {0};", StatTableName);
SQL.AppendFormat("CREATE TEMP TABLE {0} (Row Text,SUM INT,AVG INT,COUNT INT,\"COUNT DISTINCT\" INT,MAX INT,MIN INT,TYPE Text,Length TEXT,\"UTC DATE\" TEXT,\"UTC TIME\" TEXT);", StatTableName);
for (int i = 1; i <= Schema.GetItemCount(); i++)
{
string Row = "\"" + Schema[i] + "\"";
SQL.AppendFormat("INSERT INTO {0} Select '{1}',SUM({1}),AVG({1}),COUNT({1}),COUNT(DISTINCT {1}),MAX({1}),MIN({1}),typeOf({1}),Length({1}),DATE(),TIME() FROM {2};;", StatTableName, Row, Table);
}
var CS = new CommandSettings()
{
Database = Database,
SQL = SQL.ToString(),
User = GlobalStatic.UserName,
Explanation = Language.Localization["Application"] + ":" + Language.Localization["User Requested"] + ":" + Language.Localization["Statistics Page"]
};
Command(CS);
break;
}
Stack.Exit(StackPointer);
}
/// <summary>
/// Loads Application Settings from text/xml file
/// </summary>
/// <param name="RestoreSettings"></param>
/// <param name="SettingsPath"></param>
public static void Load(bool RestoreSettings, string SettingsPath)
{
int StackReference = Stack.Add($"Settings.LoadSettings({RestoreSettings},{SettingsPath})");
if (string.IsNullOrWhiteSpace(SettingsPath))
{
throw new ArgumentNullException("The Settings Path was null or whitespace");
}
string XMLPath = SettingsPath?.Replace(".txt", ".xml");
if (RestoreSettings == false && (System.IO.File.Exists(SettingsPath) || System.IO.File.Exists(XMLPath)))
{
if (Path.GetExtension(SettingsPath) == ".txt") //Auto Converts Text file to an XML Settings file
{
if (System.IO.File.Exists(XMLPath) == false)
{
ConverttoXML(System.IO.File.ReadAllText(SettingsPath), XMLPath);
}
}
}
//Reads Setttings from XML
GlobalStatic.Settings = XML(XMLPath);
SettingsToFields(); //Bind Settings.
Defaults();
SettingsToFields(); //Binds Settings in the event a default has been set.
Save(); //Save Settings in the event a value has been changed.
Stack.Exit(StackReference);
}
public static void CB(string ComboBox, int Index)
{
int StackPointer = Stack.Add($"Handlers.ComboBox({ComboBox},{Index})");
try
{
if (ComboBox == GlobalStatic.ComboBox["Table"])
{
Table(Index);
Stack.Exit(StackPointer);
return;
}
else if (ComboBox == GlobalStatic.ComboBox["Sorts"])
{
Sorts(Index);
Stack.Exit(StackPointer);
return;
}
else if (ComboBox == GlobalStatic.ComboBox["Database"])
{
Database(Index);
Stack.Exit(StackPointer);
return;
}
}
catch (KeyNotFoundException)
{
string Message = string.Format("{0} at {1} does not exist in context or has not yet implemented.", ComboBox, Index);
Events.LogMessage(Message, "System");
}
Stack.Exit(StackPointer);
}
/// <summary>
/// StringBuilder based JSON writer.
/// </summary>
/// <param name="Data"></param>
/// <param name="Schema"></param>
/// <param name="Title"></param>
/// <returns></returns>
public static string JSON(Primitive Data, Primitive Schema, string Title)
{
int StackPointer = Stack.Add("Export.JSON");
StringBuilder _JSON = new StringBuilder();
_JSON.Append("{\"" + Title + "\": {");
_JSON.Append("\"Record\": [");
string[] SchemaArray = ConvertSchema(Schema);
string[,] DataArray = ConvertData(Schema, Data);
int SchemaCount = Schema.GetItemCount();
int DataCount = Data.GetItemCount();
for (int i = 0; i < DataCount; i++)
{
_JSON.Append("{");
for (int ii = 0; ii < SchemaCount; ii++)
{
_JSON.Append("\"" + SchemaArray[ii] + "\" : \"" + DataArray[i, ii].Replace(Environment.NewLine, string.Empty) + "\"");
if (ii < (SchemaCount - 1))
{
_JSON.Append(",");
}
}
_JSON.AppendLine("}");
if (i < (DataCount - 1))
{
_JSON.Append(",");
}
}
_JSON.Append("]}}");
Stack.Exit(StackPointer);
return(_JSON.ToString());
}
public static void CreateTableUI()
{
int StackPointer = Stack.Add("UI.CreateTableUI()");
Controls.HideControl(GlobalStatic.Dataview);
Controls.HideControl(GlobalStatic.ListView);
GlobalStatic.ListView = null;
HideDisplayResults();
ClearWindow();
LDGraphicsWindow.CancelClose = true;
LDGraphicsWindow.ExitOnClose = false;
GlobalStatic.Dataview = LDControls.AddDataView((Desktop.Width - 10), (Desktop.Height - 100), "1=Field;2=Type;3=PK;4=AI;5=Unique;6=Not_Null;");
GraphicsWindow.DrawText(1, 4, "Name: ");
Controls.Move(GlobalStatic.Dataview, 1, 30);
_TextBox["Table_Name"] = Controls.AddTextBox(50, 1);
Controls.SetTextBoxText(_TextBox["Table_Name"], "Table1");
_Buttons.AddOrReplace("Commit", Controls.AddButton("Commit", 250, 1));
_Buttons.AddOrReplace("Exit", Controls.AddButton("Exit", 350, 1));
LDControls.DataViewSetColumnComboBox(GlobalStatic.Dataview, 2, "1=Integer;2=Text;3=Blob;4=Real;5=Numeric;");
for (int i = 3; i <= 6; i++)
{
LDControls.DataViewSetColumnCheckBox(GlobalStatic.Dataview, i);
}
Controls.ButtonClicked -= Events.BC;
Controls.ButtonClicked += CreateTableHandler;
Stack.Exit(StackPointer);
}
public static void JSON(Primitive Data, Primitive Schema, string Title, string Path)
{
int StackPointer = Stack.Add($"Export.JSON({Path})");
System.IO.File.WriteAllText(Path, JSON(Data, Schema, Title));
Stack.Exit(StackPointer);
}
public static void Title()
{
int StackPointer = Stack.Add("UI.Title()");
string SetTitle;
SetTitle = GlobalStatic.Title + " " + Engines.DatabaseShortname + "(" + Engines.CurrentDatabase + ") : " + Handlers.TypeofSorts[(GlobalStatic.SortBy)] + " : " + Engines.CurrentTable;
if (string.IsNullOrEmpty(Engines.CurrentDatabase))
{
SetTitle = GlobalStatic.Title;
}
else
{
switch (Engines.Types.Last())
{
case Engines.Type.Command:
SetTitle += "( Command TIME : " + Engines.Timer.Last() + ")";
break;
case Engines.Type.Query:
SetTitle += "( Query Time : " + Engines.Timer.Last() + ")";
break;
}
}
GraphicsWindow.Title = SetTitle;
Stack.Exit(StackPointer);
}
// Reads File and Parses it
public static string[] ReadFile(string URI) //Reads a file and ignores certain types of data
{
int StackReference = Stack.Add("Utilities.ReadFile()");
List <string> File_Read = new List <string>();
if (System.IO.File.Exists(URI) == true)
{
string[] CNTS = System.IO.File.ReadAllLines(URI);
int itemCount = CNTS.Length;
for (int i = 0; i < itemCount; i++)
{
if (Text.StartsWith(CNTS[i], "#") == false && !string.IsNullOrWhiteSpace(CNTS[i]))
{
File_Read.Add(CNTS[i]);
}
CNTS[i] = null;
}
string[] CNTS2 = new string[File_Read.Count];
for (int i = 1; i < File_Read.Count; i++)
{
CNTS2[i] = File_Read[i];
}
Stack.Exit(StackReference);
return(CNTS2);
}
else
{
Events.LogMessage("URI isn't accessable or incorrect Parameters given.", "Exception");
}
Stack.Exit(StackReference);
return(null);
}
static bool Download(string URL)
{
int StackPointer = Stack.Add("Utilities.DownloadUpdate(" + URL + ")");
string DownloadFolder = string.Empty;
while (string.IsNullOrWhiteSpace(DownloadFolder) || string.IsNullOrWhiteSpace(LDFile.GetExtension(DownloadFolder)))
{
GraphicsWindow.ShowMessage("You will be prompted to select the download location.", "Download Location");
DownloadFolder = LDDialogs.SaveFile("1=zip;", Program.Directory);
}
int UpdaterSize = LDNetwork.DownloadFile(DownloadFolder, URL);
switch (UpdaterSize)
{
case -1:
GraphicsWindow.ShowMessage(
Language.Localization["Check Log"],
Language.Localization["Error"]);
Stack.Exit(StackPointer);
return(false);
default:
GraphicsWindow.ShowMessage("SUCCESS", "Update Downloaded");
Stack.Exit(StackPointer);
return(true);
}
}
public static void Handler()
{
int StackPointer = Stack.Add("EULA.Handler()");
string lastButton = Controls.LastClickedButton;
GlobalStatic.Settings["VersionID"] = GlobalStatic.VersionID;
Controls.ButtonClicked -= Handler; //Unsubcribes the event Handler from the event
//Forced to use Else If due to non-constant values
if (lastButton == Accept)
{
GlobalStatic.Settings["EULA"] = string.Format("Signed=true;Signer={0};", GlobalStatic.UserName);
Settings.Save();
DBM.UI.StartupGUI();
Stack.Exit(StackPointer);
}
else if (lastButton == Decline)
{
GlobalStatic.Settings["EULA"] = false;
Settings.Save();
Events.LogMessage("EULA Declined", Language.Localization["UI"]); //Localize
Stack.Exit(StackPointer);
System.Environment.Exit(5);
}
}
static Primitive XML(string URI)
{
int StackPointer = Stack.Add("Settings.XML");
LDxml.Open(URI);
Primitive Data = LDxml.ToArray();
Data = Data["root"]["children"];
Primitive RData = null;
for (int i = 1; i <= Data.GetItemCount(); i++)
{
Primitive indicies = Data[i].GetAllIndices();
if (Data[i][indicies[1]]["Data"] != string.Empty)
{
RData[indicies[1]] = Data[i][indicies[1]]["Data"];
}
else if (Data[i][indicies[1]]["Children"] != string.Empty)
{
Primitive Temp = null;
for (int ii = 1; ii <= Data[i][indicies[1]]["Children"].GetItemCount(); ii++)
{
Primitive Index = Data[i][indicies[1]]["Children"][ii].GetAllIndices();
Temp[Index[1]] += Data[i][indicies[1]]["Children"][ii][Index[1]]["Data"];
}
RData[indicies[1]] = Temp;
}
else
{
//GraphicsWindow.ShowMessage(Data[i], "XML");
}
}
Stack.Exit(StackPointer);
return(RData);
}
/// <summary>
/// For Wikipedia Tables
/// </summary>
public static void MarkUp(Primitive Data, Primitive Schema, string FilePath)
{
int StackPointer = Stack.Add($"Export.MarkUp({FilePath})");
System.IO.File.WriteAllText(FilePath, MarkUp(Data, Schema));
Stack.Exit(StackPointer);
}
/*
* public static IReadOnlyDictionary<string, string> CheckBox
* { get { return _CheckBox; } }
*
* public static IReadOnlyDictionary<string, string> ComboBox
* { get { return _ComboBox; }}
*/
public static void Main()
{
try
{
int StackPointer = Stack.Add("UI.Main()");
LDUtilities.ShowErrors = false;
LDUtilities.ShowFileErrors = false;
LDUtilities.ShowNoShapeErrors = false;
LDGraphicsWindow.ExitOnClose = false;
LDGraphicsWindow.CancelClose = true;
LDGraphicsWindow.Closing += Events.Closing;
LDEvents.Error += Events.LogEvents;
Engines.OnGetColumnsofTable += ColumnsChanged;
Engines.OnSchemaChange += SchemaChanged;
Startup();
Stack.Exit(StackPointer);
}
catch (Exception ex)
{
Language.Localization.Print();
Stack.Print();
Events.LogMessage(ex.Message, Language.Localization["System"]);
Program.Delay(1000);
Environment.Exit(31);
}
}
/// <summary>
/// Fetches the Primary Key Information on everything
/// </summary>
public static Dictionary <string, bool> SQL_Fetch_PK(Primitive SchemaQuery, Primitive Schema, Engines.EnginesMode CurrentEngine)
{
int StackPointer = Stack.Add("Export.SQL_Fetch_PK");
Dictionary <string, bool> _Dictionary = new Dictionary <string, bool>();
switch (CurrentEngine)
{
case Engines.EnginesMode.SQLITE:
for (int i = 1; i <= SchemaQuery.GetItemCount(); i++)
{
for (int ii = 1; ii <= Schema.GetItemCount(); ii++)
{
if (Schema[ii] == SchemaQuery[i]["name"])
{
if (SchemaQuery[i]["pk"] == 1)
{
_Dictionary.Add(SchemaQuery[i]["name"], true);
}
else
{
_Dictionary.Add(SchemaQuery[i]["name"], false);
}
}
}
}
Stack.Exit(StackPointer);
return(_Dictionary);
default:
throw new NotImplementedException("Current Engine is not supported");
}
}
public static void HTML(Primitive Data, Primitive Schema, string Title, string FilePath, string Generator)
{
int StackPointer = Stack.Add($"Export.HTML({FilePath})");
string Output = HTML(Data, Schema, Title, Generator);
System.IO.File.WriteAllText(FilePath, Output);
Stack.Exit(StackPointer);
}
/// <summary>
/// Support for Github and Reddit Markdown
/// </summary>
public static void MarkDown(Primitive Data, Primitive Schema, string FilePath)
{
int StackPointer = Stack.Add("Export.MarkDown");
string Output = MarkDown(Data, Schema);
System.IO.File.WriteAllText(FilePath, Output);
Stack.Exit(StackPointer);
}
public static void CSV(string InputFilePath, string OutPutFilePath)
{
int StackPointer = Stack.Add($"Import.CSV({InputFilePath},{OutPutFilePath})");
StreamWriter SW = new StreamWriter(OutPutFilePath, false);
CSV(InputFilePath, ref SW);
Stack.Exit(StackPointer);
}
public static void SQL(Primitive Data, Primitive Schema, Dictionary <string, bool> PK, Dictionary <string, string> Types, string TableName, string FilePath)
{
int StackReference = Stack.Add("Export.SQL");
string _SQL = SQL(Data, Schema, PK, Types, Engines.CurrentTable);
System.IO.File.WriteAllText(FilePath, _SQL);
Stack.Exit(StackReference);
}
public static void Print <T>(this IDictionary <T, T> Dictionary)
{
int StackPointer = Stack.Add("Transform.PrintDictionary");
foreach (KeyValuePair <T, T> entry in Dictionary)
{
Console.WriteLine("{0} : {1}", entry.Key, entry.Value);
}
Stack.Exit(StackPointer);
}
public static void Print <T>(this IReadOnlyList <T> List)
{
int StackPointer = Stack.Add("Transform.PrintIReadOnlyList");
for (int i = 0; i < List.Count; i++)
{
Console.WriteLine("{0} : {1}", i, List[i]);
}
Stack.Exit(StackPointer);
}
/// <summary>
/// Clears the current window and associated UI dictionaries
/// </summary>
static void ClearWindow()
{
int StackPointer = Stack.Add("UI.ClearWindow()");
GraphicsWindow.Clear();
_Buttons.Clear();
_TextBox.Clear();
Stack.Exit(StackPointer);
}
public static void MainMenu()
{
int StackReference = Stack.Add("UI.MainMenu()");
LDGraphicsWindow.ExitButtonMode(GraphicsWindow.Title, "Enabled");
GraphicsWindow.CanResize = true;
LDGraphicsWindow.State = 2;
GraphicsWindow.Title = GlobalStatic.Title + " ";
Primitive Sorts = $"1={Language.Localization["Table"]};2={Language.Localization["View"]};3={Language.Localization["Index"]};4={Language.Localization["Master Table"]};";
if (Engines.CurrentDatabase != null && Engines.CurrentDatabase != null)
{
Engines.GetSchema(Engines.CurrentDatabase);
}
GraphicsWindow.FontSize = GlobalStatic.DefaultFontSize + 8;
int UIx = GlobalStatic.Listview_Width - 380;
string Menu = LDControls.AddMenu(Desktop.Width * 1.5, 30, MenuList, IconList, null);
Shapes.Move(Shapes.AddText(Language.Localization["Sort"] + ":"), UIx, 1);
int TextWidth = LDText.GetHeight(Language.Localization["Sort"] + ":");
GraphicsWindow.FontSize = GlobalStatic.DefaultFontSize;
try
{
GlobalStatic.ComboBox["Table"] = LDControls.AddComboBox(Engines.Tables.ToPrimitiveArray(), 100, 100);
}
catch (Exception ex)
{
Events.LogMessage(ex.ToString(), "System");
}
GlobalStatic.ComboBox["Sorts"] = LDControls.AddComboBox(Sorts, 100, 100);
GlobalStatic.ComboBox["Database"] = LDControls.AddComboBox(Engines.DB_ShortName.ToPrimitiveArray(), 100, 100);
Controls.Move(GlobalStatic.ComboBox["Database"], UIx + TextWidth + 35, 5);
Controls.Move(GlobalStatic.ComboBox["Sorts"], UIx + TextWidth + 150, 5);
Controls.Move(GlobalStatic.ComboBox["Table"], UIx + TextWidth + 260, 5);
//Virtual Call to Handler
Events.MC(Language.Localization["View"]);
Title();
Controls.ButtonClicked += Events.BC;
LDControls.MenuClicked += Events.MC;
LDControls.ComboBoxItemChanged += Events.CB;
LDControls.ContextMenuClicked += Events.MI;
Stack.Exit(StackReference);
}
/// <summary>
/// Old Method. Kept in for backwards compatability.
/// </summary>
/// <param name="compatability"></param>
/// <returns></returns>
public static string DB(EnginesMode Mode, Primitive Data)
{
int StackIndex = Stack.Add($"Engines.Load.DB({Mode})");
Dictionary <string, string> _Data = new Dictionary <string, string>
{
["URI"] = Data
};
Stack.Exit(StackIndex);
return(DB(Mode, _Data));
}
