//--------------------------------------------------------------------------------------------------
#endregion
#region Export
public bool Export(string fileName, IExchanger exchanger)
{
if (!IsValid)
{
Messages.Error("The etching mask data could not be generated.");
return(false);
}
var exporter = exchanger as IDrawingExporter;
if (exporter == null)
{
return(false);
}
Drawing.Drawing drawing = new()
{
Name = "Masks"
};
for (var layer = 0; layer < _Layers.Length; layer++)
{
BRepDrawing drawingLayer = new()
{
Name = $"Layer{layer}",
Source = new TopoDSBrepSource(_Layers[layer].BRep),
Stroke = new StrokeStyle(Color.Black, 0.1f, LineStyle.Solid),
Fill = new FillStyle(Color.Black)
};
drawing.Add(drawingLayer);
}
return(exporter.DoExport(fileName, drawing));
}
public ODataTypedRepository(
ILogger logger,
IExchanger exchanger,
IActions actions,
ITimeOutPolicy <T> policy)
: base(logger, exchanger, actions, policy)
{
}
//--------------------------------------------------------------------------------------------------
public static void Register(IExchanger exchanger)
{
var interfaces = exchanger.GetType().GetInterfaces();
foreach (var interfaceType in interfaces)
{
_AddExchanger(exchanger, interfaceType);
}
}
//--------------------------------------------------------------------------------------------------
public ExchangerSettings(IExchanger exchanger, object panel)
{
SettingsPanel = panel;
DoItCommand = new RelayCommand(DoIt);
InitializeComponent();
Title = exchanger.Description + " Settings";
}
//--------------------------------------------------------------------------------------------------
public static IExchangerSettingsPanelCreator FindExchangerSettingsPanel(IExchanger exchanger)
{
if (_ExchangerSettingPanels.TryGetValue(exchanger.GetType(), out var panelCreator))
{
return(panelCreator);
}
return(null);
}
//--------------------------------------------------------------------------------------------------
public object CreatePanel <T>(IExchanger exchanger)
{
if (typeof(T) == typeof(IBodyImporter))
{
return(new StepSettingsPanel((exchanger as StepExchanger)?.Settings));
}
return(null);
}
public TypedRepository(
ILogger logger,
IExchanger exchanger,
IActions actions,
ITimeOutPolicy <T> policy)
: base(logger, exchanger, actions)
{
Policy = policy;
}
//--------------------------------------------------------------------------------------------------
public object CreatePanel <T>(IExchanger exchanger)
{
if (typeof(T) == typeof(IBodyExporter))
{
return(new OpenCascadeExchangerSettingsPanel((exchanger as OpenCascadeExchanger)?.Settings));
}
return(null);
}
void OnDestroy()
{
f1 = null;
f2 = null;
f3 = null;
f4 = null;
f5 = null;
farr = null;
flua = null;
ie = null;
add = null;
luaenv.Dispose();
}
//--------------------------------------------------------------------------------------------------
public object CreatePanel <T>(IExchanger exchanger)
{
if (typeof(T) == typeof(ISketchExporter) || typeof(T) == typeof(IDrawingExporter))
{
return(new DxfExportSettingsPanel((exchanger as DxfExchanger)?.Settings));
}
if (typeof(T) == typeof(ISketchImporter))
{
return(new DxfImportSettingsPanel((exchanger as DxfExchanger)?.Settings));
}
return(null);
}
//--------------------------------------------------------------------------------------------------
public object CreatePanel <T>(IExchanger exchanger)
{
if (typeof(T) == typeof(IBodyImporter))
{
return(new ObjSettingsPanel((exchanger as ObjExchanger)?.Settings, true));
}
if (typeof(T) == typeof(IBodyExporter))
{
return(new ObjSettingsPanel((exchanger as ObjExchanger)?.Settings, false));
}
return(null);
}
//--------------------------------------------------------------------------------------------------
#endregion
#region Registration
static void _AddExchanger(IExchanger exchanger, Type interfaceType)
{
if (!_Exchangers.TryGetValue(interfaceType, out var list))
{
list = new List <IExchanger>();
_Exchangers.Add(interfaceType, list);
}
if (list.Exists(ex => ex.GetType() == exchanger.GetType()))
{
Messages.Warning($"Exchanger {exchanger.GetType().FullName} already registered for type {interfaceType.Name}");
return;
}
list.Add(exchanger);
}
public static bool Execute <T>(IExchanger exchanger) where T : IExchanger
{
ExchangeRegistry.LoadSettings();
var panel = ExchangeRegistry.FindExchangerSettingsPanel(exchanger)?.CreatePanel <T>(exchanger);
if (panel == null)
{
return(true); // No settings available
}
var exchangerSettings = new ExchangerSettings(exchanger, panel);
if (!exchangerSettings.ShowDialog())
{
return(false);
}
ExchangeRegistry.SaveSettings();
return(true);
}
//--------------------------------------------------------------------------------------------------
#endregion
#region Export
public bool Export(string fileName, IExchanger exchanger)
{
if (!IsValid)
{
Messages.Error("The etching mask data could not be generated.");
return(false);
}
var exporter = exchanger as IVectorExporter;
if (exporter == null)
{
return(false);
}
VectorExportLayer[] exportLayers = new VectorExportLayer[_Layers.Length];
for (var layer = 0; layer < _Layers.Length; layer++)
{
exportLayers[layer] = new VectorExportLayer(VectorExportLayerType.FilledOutline, $"Layer{layer}", _Layers[layer].BRep);
}
return(exporter.DoExport(fileName, VectorExportTemplate.Contours, exportLayers));
}
//--------------------------------------------------------------------------------------------------
public object CreatePanel <T>(IExchanger exchanger)
{
return(new SvgSettingsPanel((exchanger as SvgExchanger)?.Settings, typeof(T)));
}
// Use this for initialization
void Start()
{
XLuaEnv.onDispose += () =>
{
f1 = null;
f2 = null;
f3 = null;
f4 = null;
f5 = null;
farr = null;
flua = null;
ie = null;
add = null;
};
XLuaEnv.DoString(@"
function id(...)
return ...
end
function add(a, b) return a + b end
function array_exchange(arr)
arr[0], arr[1] = arr[1], arr[0]
end
local v3 = CS.UnityEngine.Vector3(7, 8, 9)
local vt = CS.IFramework.Hotfix.Lua.MyStruct(5, 6)
function lua_access_csharp()
monoBehaviour:FloatParamMethod(123) --primitive
monoBehaviour:Vector3ParamMethod(v3) --vector3
local rnd = math.random(1, 100)
local r = monoBehaviour:Vector3ParamMethod({x = 1, y = 2, z = rnd}) --vector3
assert(r.x == 1 and r.y == 2 and r.z == rnd)
monoBehaviour:StructParamMethod(vt) --custom struct
r = monoBehaviour:StructParamMethod({a = 1, b = rnd, e = {c = rnd}})
assert(r.b == rnd and r.e.c == rnd)
monoBehaviour:EnumParamMethod(CS.IFramework.Hotfix.Lua.MyEnum.E2) --enum
monoBehaviour:DecimalParamMethod(monoBehaviour.a5[0])
monoBehaviour.a1[0], monoBehaviour.a1[1] = monoBehaviour.a1[1], monoBehaviour.a1[0] -- field
end
exchanger = {
exchange = function(self, arr)
array_exchange(arr)
end
}
A = { B = { C = 789}}
GDATA = 1234;
");
XLuaEnv.gtable.Set("monoBehaviour", this);
XLuaEnv.gtable.Get("id", out f1);
XLuaEnv.gtable.Get("id", out f2);
XLuaEnv.gtable.Get("id", out f3);
XLuaEnv.gtable.Get("id", out f4);
XLuaEnv.gtable.Get("id", out f5);
XLuaEnv.gtable.Get("array_exchange", out farr);
XLuaEnv.gtable.Get("lua_access_csharp", out flua);
XLuaEnv.gtable.Get("exchanger", out ie);
XLuaEnv.gtable.Get("add", out add);
XLuaEnv.gtable.Set("g_int", 123);
XLuaEnv.gtable.Set(123, 456);
int i;
XLuaEnv.gtable.Get("g_int", out i);
Debug.Log("g_int:" + i);
XLuaEnv.gtable.Get(123, out i);
Debug.Log("123:" + i);
}
public ExchangeService(IExchanger exchanger)
{
_exchanger = exchanger;
}
public Repository(ILogger logger, IExchanger exchanger, IActions actions)
: base(logger, exchanger, actions)
{
}
protected BaseRepository(ILogger logger, IExchanger exchanger, IActions actions)
{
Logger = logger;
Exchanger = exchanger;
Actions = actions;
}
