/**
* Convert from HEX using illumination and observer angles
* @param hex
* @param observer1
* @param observer2
* @return {object[]}
*/
public object[] ConvertHEX(string hex, string observer1, string observer2)
{
global::maglev.MagLevCs mybus = global::maglev.MagLevCs.getInstance("default");
global::Array <object> args = new global::Array <object>();
args.push(hex);
args.push(observer1);
args.push(observer2);
object[] ret = {};
MyCallbackDelegate async_delegate = delegate(object async_ret) { ret = (object[])async_ret; };
global::haxe.lang.Function async_callback = global::maglev.MagLevCs.callbackDelegateToHaxeFunction(async_delegate);
mybus.call("ColorConverter.ConvertHEX", args, async_callback);
return(ret);
}
/**
* Calcualte three phase power based on measured voltage and current
* @param voltage Measured voltage in Volts
* @param lineTo Which voltage was measured. Must be "line" or "netural"
* @param current Measured current in Amps
* @return {double} Apparent Power in VA
*/
public double CalculateThreePhasePower(double voltage, string lineTo, double current)
{
global::maglev.MagLevCs mybus = global::maglev.MagLevCs.getInstance("default");
global::Array <object> args = new global::Array <object>();
args.push(voltage);
args.push(lineTo);
args.push(current);
double ret = 0;
MyCallbackDelegate async_delegate = delegate(object async_ret) { ret = (double)async_ret; };
global::haxe.lang.Function async_callback = global::maglev.MagLevCs.callbackDelegateToHaxeFunction(async_delegate);
mybus.call("ElectriCalc.CalculateThreePhasePower", args, async_callback);
return(ret);
}
/**
* Calculate present value of future money
* @param futureValue Future Value
* @param numPeriods Number of Periods
* @param interestRate Interest Rate
* @return {object} object containing Present Value and Total Interest
*/
public object PresentValueOfFutureMoney(double futureValue, double numPeriods, double interestRate)
{
global::maglev.MagLevCs mybus = global::maglev.MagLevCs.getInstance("default");
global::Array <object> args = new global::Array <object>();
args.push(futureValue);
args.push(numPeriods);
args.push(interestRate);
object ret = null;
MyCallbackDelegate async_delegate = delegate(object async_ret) { ret = (object)async_ret; };
global::haxe.lang.Function async_callback = global::maglev.MagLevCs.callbackDelegateToHaxeFunction(async_delegate);
mybus.call("FinanceCalculator.PresentValueOfFutureMoney", args, async_callback);
return(ret);
}
/**
* Convert from RGB
* @param r
* @param g
* @param b
* @return {object[]}
*/
public object[] FromRGB(double r, double g, double b)
{
global::maglev.MagLevCs mybus = global::maglev.MagLevCs.getInstance("default");
global::Array <object> args = new global::Array <object>();
args.push(r);
args.push(g);
args.push(b);
object[] ret = {};
MyCallbackDelegate async_delegate = delegate(object async_ret) { ret = (object[])async_ret; };
global::haxe.lang.Function async_callback = global::maglev.MagLevCs.callbackDelegateToHaxeFunction(async_delegate);
mybus.call("ColorConverter.FromRGB", args, async_callback);
return(ret);
}
/**
*
* @param invoiceId
* @param clientId
* @param invoiceNumber
* @param date
* @param dueDate
* @param notes
*/
public void ChangeInvoice(string invoiceId, string clientId, string invoiceNumber, string date, string dueDate, string notes)
{
global::maglev.MagLevCs mybus = global::maglev.MagLevCs.getInstance("default");
global::Array <object> args = new global::Array <object>();
args.push(invoiceId);
args.push(clientId);
args.push(invoiceNumber);
args.push(date);
args.push(dueDate);
args.push(notes);
MyCallbackDelegate async_delegate = delegate(object async_ret) {};
global::haxe.lang.Function async_callback = global::maglev.MagLevCs.callbackDelegateToHaxeFunction(async_delegate);
mybus.call("Invoices.ChangeInvoice", args, async_callback);
}
/**
* Add a reference color
* @param system
* @param name
* @param description
* @param x
* @param y
* @param z
*/
public void AddReferenceColorByXYZ(string system, string name, string description, double x, double y, double z)
{
global::maglev.MagLevCs mybus = global::maglev.MagLevCs.getInstance("default");
global::Array <object> args = new global::Array <object>();
args.push(system);
args.push(name);
args.push(description);
args.push(x);
args.push(y);
args.push(z);
MyCallbackDelegate async_delegate = delegate(object async_ret) {};
global::haxe.lang.Function async_callback = global::maglev.MagLevCs.callbackDelegateToHaxeFunction(async_delegate);
mybus.call("ColorConverter.AddReferenceColorByXYZ", args, async_callback);
}
/**
* Get a list of currently running auctions
* @param page
* @param perpage number of auctions per page
* @param sort field to sort by
* @param asc ascending (true) or descending (false)
* @return {object[]} List of open auctions
*/
public object[] GetOpenAuctions(double page, double perpage, string sort, bool asc)
{
global::maglev.MagLevCs mybus = global::maglev.MagLevCs.getInstance("default");
global::Array <object> args = new global::Array <object>();
args.push(page);
args.push(perpage);
args.push(sort);
args.push(asc);
object[] ret = {};
MyCallbackDelegate async_delegate = delegate(object async_ret) { ret = (object[])async_ret; };
global::haxe.lang.Function async_callback = global::maglev.MagLevCs.callbackDelegateToHaxeFunction(async_delegate);
mybus.call("EnglishAuction.GetOpenAuctions", args, async_callback);
return(ret);
}
/**
*
* @param c
* @param m
* @param y
* @param k
* @return {object[]}
*/
public object[] FindReferenceColorByCMYK(double c, double m, double y, double k)
{
global::maglev.MagLevCs mybus = global::maglev.MagLevCs.getInstance("default");
global::Array <object> args = new global::Array <object>();
args.push(c);
args.push(m);
args.push(y);
args.push(k);
object[] ret = {};
MyCallbackDelegate async_delegate = delegate(object async_ret) { ret = (object[])async_ret; };
global::haxe.lang.Function async_callback = global::maglev.MagLevCs.callbackDelegateToHaxeFunction(async_delegate);
mybus.call("ColorConverter.FindReferenceColorByCMYK", args, async_callback);
return(ret);
}
/**
* Add an item to a cart
* @param cartId
* @param itemId
* @param qty quantity
* @param price price
* @return {double} cart item index
*/
public double AddItem(string cartId, string itemId, double qty, double price)
{
global::maglev.MagLevCs mybus = global::maglev.MagLevCs.getInstance("default");
global::Array <object> args = new global::Array <object>();
args.push(cartId);
args.push(itemId);
args.push(qty);
args.push(price);
double ret = 0;
MyCallbackDelegate async_delegate = delegate(object async_ret) { ret = (double)async_ret; };
global::haxe.lang.Function async_callback = global::maglev.MagLevCs.callbackDelegateToHaxeFunction(async_delegate);
mybus.call("ShoppingCart.AddItem", args, async_callback);
return(ret);
}
/**
* Create a new auction
* @param start start time of auction
* @param end end time of auction
* @param startingPrice starting price of auction
* @param reservePrice reserve price for the auction (0 = none)
* @param priceIncrement price increments for bids in the auction
* @return {string} auctionId
*/
public string Create(double start, double end, double startingPrice, double reservePrice, double priceIncrement)
{
global::maglev.MagLevCs mybus = global::maglev.MagLevCs.getInstance("default");
global::Array <object> args = new global::Array <object>();
args.push(start);
args.push(end);
args.push(startingPrice);
args.push(reservePrice);
args.push(priceIncrement);
string ret = "";
MyCallbackDelegate async_delegate = delegate(object async_ret) { ret = (string)async_ret; };
global::haxe.lang.Function async_callback = global::maglev.MagLevCs.callbackDelegateToHaxeFunction(async_delegate);
mybus.call("EnglishAuction.Create", args, async_callback);
return(ret);
}
public void InitParam(string path, MyCallbackDelegate c)
{
callback = c;
var files = from file in Directory.GetFiles(path)
orderby file where file.EndsWith(".geo")
select file;
foreach (var file in files)
{
FileList.Items.Add(Path.GetFileNameWithoutExtension(file));
}
XTrack.Value = 100;
instrument.zoom = true;
instrument.zoomx = XTrack.Value;
instrument.changeinstrument = true;
SetParams(true);
}
/**
*
* @param invoiceId
* @param lineNumber
* @param accountId
* @param description
* @param taxes
* @param quantity
* @param price
*/
public void ChangeLineItem(string invoiceId, double lineNumber, string accountId, string description, object taxes, double quantity, double price)
{
global::maglev.MagLevCs mybus = global::maglev.MagLevCs.getInstance("default");
global::Array <object> args = new global::Array <object>();
args.push(invoiceId);
args.push(lineNumber);
args.push(accountId);
args.push(description);
args.push(taxes);
args.push(quantity);
args.push(price);
MyCallbackDelegate async_delegate = delegate(object async_ret) {};
global::haxe.lang.Function async_callback = global::maglev.MagLevCs.callbackDelegateToHaxeFunction(async_delegate);
mybus.call("Invoices.ChangeLineItem", args, async_callback);
}
/**
* Calculate net present value
* @param initialInvestment Initial Investment
* @param discountRate Discount Rate (eg. Interest Rate)
* @param timesCompoundedPerPeriod Times discount/interest is compounded per period
* @param cashFlowsAtBeginning
* @param cashFlow List of cash flows per period
* @return {double} Net Present Value
*/
public double NetPresentValue(double initialInvestment, double discountRate, double timesCompoundedPerPeriod, double cashFlowsAtBeginning, object[] cashFlow)
{
global::maglev.MagLevCs mybus = global::maglev.MagLevCs.getInstance("default");
global::Array <object> args = new global::Array <object>();
args.push(initialInvestment);
args.push(discountRate);
args.push(timesCompoundedPerPeriod);
args.push(cashFlowsAtBeginning);
args.push(cashFlow);
double ret = 0;
MyCallbackDelegate async_delegate = delegate(object async_ret) { ret = (double)async_ret; };
global::haxe.lang.Function async_callback = global::maglev.MagLevCs.callbackDelegateToHaxeFunction(async_delegate);
mybus.call("FinanceCalculator.NetPresentValue", args, async_callback);
return(ret);
}
public void InitParam(string path,MyCallbackDelegate c)
{
callback = c;
var files = from file in Directory.GetFiles(path)
orderby file where file.EndsWith(".geo")
select file;
foreach (var file in files)
{
FileList.Items.Add(Path.GetFileNameWithoutExtension(file));
}
XTrack.Value = 1;
instrument.zoom = true;
instrument.zoomx = XTrack.Value;
instrument.changeinstrument = true;
SetParams(true);
}
/**
* Calculate the future value of money and/or deposits
* @param presentValue Present Value
* @param numPeriods Number of Periods
* @param interestRate Interest rate as a percentage
* @param timesCompoundedPerPeriod Times interest is compounded per period
* @param depositAmount Periodic Deposit Amount
* @param depositAtBeginning Periodic Deposits made at beginning of period
* @return {object} object containing Future Value and Total Interest
*/
public object FutureValue(double presentValue, double numPeriods, double interestRate, double timesCompoundedPerPeriod, double depositAmount, bool depositAtBeginning)
{
global::maglev.MagLevCs mybus = global::maglev.MagLevCs.getInstance("default");
global::Array <object> args = new global::Array <object>();
args.push(presentValue);
args.push(numPeriods);
args.push(interestRate);
args.push(timesCompoundedPerPeriod);
args.push(depositAmount);
args.push(depositAtBeginning);
object ret = null;
MyCallbackDelegate async_delegate = delegate(object async_ret) { ret = (object)async_ret; };
global::haxe.lang.Function async_callback = global::maglev.MagLevCs.callbackDelegateToHaxeFunction(async_delegate);
mybus.call("FinanceCalculator.FutureValue", args, async_callback);
return(ret);
}
static void Main(string[] args)
{
// create a worker
Worker worker1 = new Worker();
// ask worker1 to start the process
// pass a reference to the method where to receive call (callback)
// by creating a Delegate object of type MyCallbackDelegate
MyCallbackDelegate callback = CallbackHandler; // assign the method to the callback delegate
// pass the callback delegate to the worker1
worker1.Process(callback); // this actually tells the recipient what to call via the delegate99
Console.Write("Press <Enter> to exit. . .");
Console.ReadLine();
}
/**
* Calculate the price of the car from the monthly loan payment information
* @param monthlyPayment monthly payment amount
* @param tradeInAllowance trade-in value
* @param tradeInLoanBalance loan balance after trade-in
* @param downPaymentAndRebates total amount of rebates plus downpayment
* @param loanDuration loan duration in months
* @param salesTaxRate sales tax rate as percentage
* @param interestRate interest rate as percentage
* @return {double} target price with tax and fees
*/
public double CalcAffordability(double monthlyPayment, double tradeInAllowance, double tradeInLoanBalance, double downPaymentAndRebates, double loanDuration, double salesTaxRate, double interestRate)
{
global::maglev.MagLevCs mybus = global::maglev.MagLevCs.getInstance("default");
global::Array <object> args = new global::Array <object>();
args.push(monthlyPayment);
args.push(tradeInAllowance);
args.push(tradeInLoanBalance);
args.push(downPaymentAndRebates);
args.push(loanDuration);
args.push(salesTaxRate);
args.push(interestRate);
double ret = 0;
MyCallbackDelegate async_delegate = delegate(object async_ret) { ret = (double)async_ret; };
global::haxe.lang.Function async_callback = global::maglev.MagLevCs.callbackDelegateToHaxeFunction(async_delegate);
mybus.call("CarLoanCalculator.CalcAffordability", args, async_callback);
return(ret);
}
private void Form1_Shown(object sender, EventArgs e)
{
bm = new Bitmap(Width, Height);
//param.file = "test1";
param.file = "cunami2";
param.gx = -0.01;
param.reinit = true;
reinitcallback = new MyCallbackDelegate(ReInit);
formparam = new FormParam();
formparam.Show();
formparam.InitParam("Demos", reinitcallback);
//formparam.Left = 500;
gform = Graphics.FromHwnd(this.Handle);
g = Graphics.FromImage(bm);
// instrument.zoom = true;
// instrument.zoomx = formparam.sc instrument.zoomx;
timer1.Enabled = false;
ReceiveWorkerThread.WorkerReportsProgress = true;
ReceiveWorkerThread.RunWorkerAsync();
}
private void Form1_Shown(object sender, EventArgs e)
{
bm = new Bitmap(Width, Height);
//param.file = "test1";
param.file = "cunami2";
param.gx = -0.01;
param.reinit = true;
reinitcallback = new MyCallbackDelegate(ReInit);
formparam = new FormParam();
formparam.Show();
formparam.InitParam("Demos", reinitcallback);
//formparam.Left = 500;
gform = Graphics.FromHwnd(this.Handle);
g = Graphics.FromImage(bm);
// instrument.zoom = true;
// instrument.zoomx = formparam.sc instrument.zoomx;
timer1.Enabled = false;
ReceiveWorkerThread.WorkerReportsProgress = true;
ReceiveWorkerThread.RunWorkerAsync();
}
// this worker will process all the work given to it and will call you back if it encounters a problem
public void Process(MyCallbackDelegate callback) // the argument here is the phone number by which the worker can call the App
{
// processing
// simulate processing by making the worker spin for a few seconds
// display just to observe -- usually DON'T do this
Console.WriteLine("worker is about to start processing...");
System.Threading.Thread.SpinWait(100000000);
// create a random value
int r = new Random().Next();
if (r % 2 != 0)
{
// call back the client
// but WHERE and HOW? The Library does not know
// Define a delegate type for the callback ^^^^^^^^
callback("r is not even!", r);
}
else
{
callback("r is even!", r);
}
}
