/// <summary>
/// If the design mode is chosen then the driver will use NeoLoad as Proxy.
/// </summary>
/// <param name="capabilities">capabilities to modify</param>
/// <returns>modified capabilities</returns>
public static DesiredCapabilities AddProxyCapabilitiesIfNecessary(DesiredCapabilities capabilities)
{
if (!Mode.DESIGN.Equals(ModeHelper.getMode()))
{
return(capabilities);
}
DesignConfiguration conf = ConfigurationHelper.newDesignConfiguration(null, null);
string host = getDomainName(conf.DesignAPIUrl);
int port;
try
{
port = DesignManager.newDesignAPIClientFromConfig(conf).GetRecorderSettings().ProxySettings.Port;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
throw e;
}
string proxyString = host + ":" + port;
Proxy proxy = new Proxy();
proxy.HttpProxy = proxyString;
proxy.SslProxy = proxyString;
capabilities.SetCapability(CapabilityType.Proxy, proxy);
capabilities.SetCapability(CapabilityType.AcceptSslCertificates, true);
return(capabilities);
}
void TargetControl_PointerPressed(object sender, Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
{
IsActive = !IsActive;
//IsActive = true;
DesignActive.CurrentSelectedControl = TargetControl;
if (TargetControl == null || TargetControl.Parent == null || !(TargetControl.Parent is Canvas))
{
return;
}
TargetCanvas = TargetControl.Parent as Canvas;
Canvas.SetZIndex(TargetControl, getTopIndex() + 1);
if (DesignManager.SetCurrent != null)
{
if (TargetControl.DataContext != null && TargetControl.DataContext as DesignItem != null)
{
var ditem = TargetControl.DataContext as DesignItem;
DesignManager.SetCurrent(ditem.TargetObject);
}
else
{
DesignManager.SetCurrent(TargetControl.DataContext);
}
}
//e.Handled = true;
}
public Allergies(string personalCode)
{
InitializeComponent();
DesignManager.ConfigurateForm(this);
PersonalCode = personalCode;
}
public DiseaseHistory(string personalCode)
{
InitializeComponent();
DesignManager.ConfigurateForm(this);
PersonalCode = personalCode;
}
public MedicamentAssignment(AppData.PatientRow patient, AppData.TreatmentRow treatment)
{
InitializeComponent();
DesignManager.ConfigurateForm(this);
Patient = patient;
Treatment = treatment;
}
public Stayings(string personalCode, AppData.DiseaseHistoryRow diseaseHistory)
{
InitializeComponent();
DesignManager.ConfigurateForm(this);
PersonalCode = personalCode;
DiseaseHistory = diseaseHistory;
}
public void getColourDesignOfSpaceTest()
{
DesignManager spaceCtrl = new DesignManager();
var colourExpected = "#123456";
var config = new { Configuration = new { componentColor = colourExpected } };
var colourReal = spaceCtrl.getColourDesignOfSpace(JsonConvert.SerializeObject(config));
Assert.AreEqual(colourExpected, colourReal);
}
void TargetDesignCanvas_PointerPressed(object sender, PointerRoutedEventArgs e)
{
if (createControlFunc == null)
{
foreach (var v in TargetDesignCanvas.Children)
{
if (v is ArrowCurveSegment)
{
(v as ArrowCurveSegment).ChangeActive(false);
}
if (v is DesignControl)
{
(v as DesignControl).ChangeActive(false);
}
}
if (DesignManager.SetCurrent != null && Parent != null)
{
var p = Parent as FrameworkElement;
DesignManager.SetCurrent(p.DataContext);
}
return;
}
if (DataContext == null)
{
return;
}
var dc = DataContext as DesignCanvasViewModel;
if (dc == null)
{
return;
}
var control = createControlFunc();
if (control == null)
{
throw new Exception("Can not create control");
}
var item = new DesignItem()
{
TargetControl = control,
Left = e.GetCurrentPoint(TargetDesignCanvas).Position.X,
Top = e.GetCurrentPoint(TargetDesignCanvas).Position.Y,
Width = double.IsNaN(control.Width) ? 200 : control.Width,
Height = double.IsNaN(control.Height) ? 150 : control.Height
};
dc.ItemList.Add(item);
var dcontrol = new DesignControl();
dcontrol.DataContext = item;
TargetDesignCanvas.Children.Add(dcontrol);
//RefreshDataContext(DataContext);
createControlFunc = null;
//e.Handled = true;
}
public void Initialize()
{
if (instance == null)
{
instance = this;
}
else
{
Debug.LogError("You've put another Player Manager somewhere");
}
}
void ProcessEntity(object data, Point point)
{
var control = DesignManager.CreateDesignControl(data);
Canvas.SetLeft(control, point.X);
Canvas.SetTop(control, point.Y);
Draw(control);
if (DesignManager.IsAutoConnectNode != null && DesignManager.IsAutoConnectNode())
{
AutoAddConnection(control);
}
}
private void ArrowLine_PointerPressed(object sender, Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
{
ChangeActive(true);
if (DesignManager.SetCurrent != null)
{
if (DataContext is DesignLink)
{
DesignManager.SetCurrent((DataContext as DesignLink).TargetObject);
}
else
{
DesignManager.SetCurrent(DataContext);
}
}
e.Handled = true;
}
public void CreateUpdateCssFileForSpaceTest()
{
DesignManager designManager = new DesignManager();
var oldColour = "#123456";
var oldConfig = new { Configuration = new { componentColor = oldColour } };
var oldConfigString = JsonConvert.SerializeObject(oldConfig);
var newColour = "#aaaaaa";
var newConfig = new { Configuration = new { componentColor = newColour } };
var newConfigString = JsonConvert.SerializeObject(newConfig);
var spaceid = "testunit";
designManager.CreateUpdateCssFileForSpace(spaceid, designManager.getColourDesignOfSpace(newConfigString));
Assert.IsTrue(System.IO.File.Exists("D:/Travail/Reta/RetaTrunk/Reta/Reta" + "/Files/CssSpecific/" + spaceid + ".css"));
}
void ProcessLink(object data, Point point)
{
if (data == null)
{
return;
}
var l = DesignManager.GetDesignLink(data);
if (l == null)
{
return;
}
var s = GetItemByID(l.Item1);
var t = GetItemByID(l.Item2);
if (s == null && t == null)
{
CommonProc.ShowMessage("Error", "Link source item and target item does not exist in diagram");
return;
}
if (s == null)
{
var control = DesignManager.CreateDesignControl(s);
Canvas.SetLeft(control, point.X);
Canvas.SetTop(control, point.Y);
Draw(control);
if (DesignManager.IsAutoConnectNode != null && DesignManager.IsAutoConnectNode())
{
AutoAddConnection(control);
}
}
if (t == null)
{
var control = DesignManager.CreateDesignControl(t);
Canvas.SetLeft(control, point.X);
Canvas.SetTop(control, point.Y);
Draw(control);
if (DesignManager.IsAutoConnectNode != null && DesignManager.IsAutoConnectNode())
{
AutoAddConnection(control);
}
}
Connect(l);
}
void Connect(Tuple <Guid, Guid, object> link)
{
var s = GetItemByID(link.Item1);
if (s == null)
{
return;
}
var t = GetItemByID(link.Item2);
if (t == null)
{
return;
}
var si = s.DataContext as DesignItem;
var ti = t.DataContext as DesignItem;
var p = DesignManager.GetLinkConnection(s.DataContext as DesignItem, t.DataContext as DesignItem);
var sp = DesignManager.GetPoint(si, p.Item1);
var tp = DesignManager.GetPoint(ti, p.Item2);
var sc = getConnectionControl(s, p.Item1);
var tc = getConnectionControl(t, p.Item2);
var CurrentLink = new DesignLink()
{
SourceX = sp.X,
SourceY = sp.Y,
TargetX = tp.X,
TargetY = tp.Y,
TargetObject = link.Item3
};
CurrentLink.SourcePoint = sc.TargetControl;
CurrentLink.TargetPoint = tc.TargetControl;
si.OutLinkList.Add(CurrentLink);
ti.InLinkList.Add(CurrentLink);
Draw(CurrentLink.LinkLine);
}
public MainMenu()
{
InitializeComponent();
DesignManager.ConfigurateForm(this);
}
public Procedures()
{
InitializeComponent();
DesignManager.ConfigurateForm(this);
}
public Wards()
{
InitializeComponent();
DesignManager.ConfigurateForm(this);
}
private void InControl_PointerReleased(object sender, PointerRoutedEventArgs e)
{
if (CurrentLink == null)
{
return;
}
if (CurrentConnection != null && CurrentConnection != this)
{
CurrentConnection.Silent();
}
if (DesignManager.CreateConnection != null)
{
var sid = (CurrentLink.SourcePoint.DataContext as DesignItem).TargetObjectID;
var tid = (TargetControl.DataContext as DesignItem).TargetObjectID;
CurrentLink.TargetObject = DesignManager.CreateConnection(sid.Value, tid.Value);
}
if (TargetControl.DataContext is DesignItem)
{
var targetItem = (TargetControl.DataContext as DesignItem);
CurrentLink.TargetID = targetItem.TargetObjectID;
CurrentLink.TargetDesignItemID = targetItem.DesignItemID;
CurrentLink.TargetPoint = sender as FrameworkElement;
targetItem.InLinkList.Add(CurrentLink);
var sourceItem = CurrentLink.SourcePoint.DataContext as DesignItem;
CurrentLink.SourceID = sourceItem.TargetObjectID;
CurrentLink.SourceDesignItemID = sourceItem.DesignItemID;
sourceItem.OutLinkList.Add(CurrentLink);
if (IsBottom)
{
CurrentLink.TargetPosition = RelativePosition.Bottom;
}
if (IsLeft)
{
CurrentLink.TargetPosition = RelativePosition.Left;
}
if (IsTop)
{
CurrentLink.TargetPosition = RelativePosition.Top;
}
if (IsRight)
{
CurrentLink.TargetPosition = RelativePosition.Right;
}
CurrentLink.TargetX = GetCenter().X;
CurrentLink.TargetY = GetCenter().Y;
var model = TargetCanvas.DataContext as DesignCanvasViewModel;
if (model != null)
{
model.LinkList.Add(CurrentLink);
}
CurrentLink.SetCurveRadius(sourceItem, targetItem);
}
IsConnecting = false;
CurrentLink.LinkLine.PointerPressed += LinkLine_PointerPressed;;
CurrentLink = null;
Silent();
e.Handled = true;
}
public Medicaments()
{
InitializeComponent();
DesignManager.ConfigurateForm(this);
}
List <Tuple <Guid, Guid, object> > GetConnectionList(FrameworkElement currentControl)
{
if (DesignManager.GetConnection == null)
{
return(null);
}
List <Tuple <Guid, Guid, object> > ol = new List <Tuple <Guid, Guid, object> >();
List <Guid> idl = new List <Guid>();
List <Guid> linkidl = new List <Guid>();
if (currentControl == null || (currentControl as DesignControl) == null ||
((currentControl as DesignControl).DataContext) == null)
{
return(ol);
}
var sitem = (currentControl as DesignControl).DataContext as DesignItem;
if (sitem == null)
{
return(ol);
}
var id = sitem.TargetObjectID;
if (id == null)
{
return(ol);
}
foreach (var c in TargetDesignCanvas.Children)
{
if (c is ArrowCurveSegment)
{
var linkVM = (c as ArrowCurveSegment).DataContext as DesignLink;
linkidl.Add(linkVM.DesignLinkID);
}
}
foreach (var c in TargetDesignCanvas.Children)
{
if (c is DesignControl)
{
var controlVM = (c as DesignControl).DataContext as DesignItem;
if (controlVM != null && controlVM.TargetObjectID != null)
{
var l = DesignManager.GetConnection(id.Value, controlVM.TargetObjectID.Value);
if (l != null)
{
l.ForEach(v =>
{
var tid = CommonProc.GetID(v);
if (tid != null && !idl.Contains(tid.Value) && !linkidl.Contains(tid.Value))
{
ol.Add(new Tuple <Guid, Guid, object>(id.Value, controlVM.TargetObjectID.Value, v));
idl.Add(tid.Value);
}
});
}
l = DesignManager.GetConnection(controlVM.TargetObjectID.Value, id.Value);
if (l != null)
{
l.ForEach(v =>
{
var tid = CommonProc.GetID(v);
if (tid != null && !idl.Contains(tid.Value) && !linkidl.Contains(tid.Value))
{
ol.Add(new Tuple <Guid, Guid, object>(controlVM.TargetObjectID.Value, id.Value, v));
idl.Add(tid.Value);
}
});
}
}
}
}
return(FilterExistLink(ol));
}
public void InitContextMemu(Dictionary <string, Func <FrameworkElement> > createCommandList)
{
contextFlyout = new MenuFlyout();
MenuFlyoutItem pasteItem = new MenuFlyoutItem {
Text = "Paste"
};
pasteItem.Click += (s, e) =>
{
object data;
if (Clipboard.GetContent().Properties.TryGetValue("entity", out data))
{
ProcessEntity(data, contextMenuPoint);
}
if (Clipboard.GetContent().Properties.TryGetValue("link", out data))
{
ProcessLink(data, contextMenuPoint);
}
};
contextFlyout.Items.Add(pasteItem);
contextFlyout.Items.Add(new MenuFlyoutSeparator());
MenuFlyoutItem saveItem = new MenuFlyoutItem {
Text = "Save"
};
saveItem.Click += SaveMenu_OnClick;
contextFlyout.Items.Add(saveItem);
MenuFlyoutItem loadItem = new MenuFlyoutItem {
Text = "Load"
};
loadItem.Click += LoadMenu_OnClick;
contextFlyout.Items.Add(loadItem);
contextFlyout.Items.Add(new MenuFlyoutSeparator());
if (createCommandList != null)
{
foreach (var ccommand in createCommandList)
{
MenuFlyoutItem addItem = new MenuFlyoutItem
{
Text = "Add " + ccommand.Key,
};
addItem.Click += (s, e) =>
{
var control = ccommand.Value();
var dcontrol = DesignManager.CreateDesignControl(control);
Canvas.SetLeft(dcontrol, contextMenuPoint.X);
Canvas.SetTop(dcontrol, contextMenuPoint.Y);
Draw(dcontrol);
};
contextFlyout.Items.Add(addItem);
}
}
contextFlyout.Items.Add(new MenuFlyoutSeparator());
MenuFlyoutItem fitItem = new MenuFlyoutItem {
Text = "Auto fit"
};
loadItem.Click += (s, e) =>
{
ActoSize();
};
contextFlyout.Items.Add(fitItem);
}
void Awake() {
instance = this;
}
