} // proc OnDeactivated
public async Task <IPpsWindowPane> LoadAsync(IPpsWindowPaneManager paneManager, Type paneType, LuaTable arguments)
{
this.PaneManager = paneManager;
var newPane = paneManager.CreateEmptyPane(this, paneType);
try
{
using (var progress = this.DisableUI("Lade..."))
await newPane.LoadAsync(arguments);
return(SetWindowPane(newPane));
}
catch
{
// clear new pane
try { newPane.Dispose(); }
catch { }
throw;
}
finally
{
CommandManager.InvalidateRequerySuggested();
}
} // func LoadAsync
public static IPpsWindowPane CreateEmptyPane(this IPpsWindowPaneManager paneManager, IPpsWindowPaneHost paneHost, Type paneType)
{
var ti = paneType.GetTypeInfo();
var ctorBest = (ConstructorInfo)null;
var ctoreBestParamLength = -1;
if (!typeof(IPpsWindowPane).IsAssignableFrom(paneType))
{
throw new ArgumentException($"{paneType.Name} does not implement {nameof(IPpsWindowPane)}.");
}
// search for the longest constructor
foreach (var ci in ti.GetConstructors())
{
var pi = ci.GetParameters();
if (ctoreBestParamLength < pi.Length)
{
ctorBest = ci;
ctoreBestParamLength = pi.Length;
}
}
if (ctorBest == null)
{
throw new ArgumentException($"'{ti.Name}' has no constructor.");
}
// create the argument set
var parameterInfo = ctorBest.GetParameters();
var paneArguments = new object[parameterInfo.Length];
for (var i = 0; i < paneArguments.Length; i++)
{
var pi = parameterInfo[i];
var tiParam = pi.ParameterType.GetTypeInfo();
if (tiParam.IsAssignableFrom(paneManager.Shell.GetType()))
{
paneArguments[i] = paneManager.Shell;
}
else if (tiParam.IsAssignableFrom(typeof(IPpsWindowPaneManager)))
{
paneArguments[i] = paneManager;
}
else if (tiParam.IsAssignableFrom(typeof(IPpsWindowPaneHost)))
{
paneArguments[i] = paneHost;
}
else if (pi.HasDefaultValue)
{
paneArguments[i] = pi.DefaultValue;
}
else
{
throw new ArgumentException($"Unsupported argument '{pi.Name}' for type '{ti.Name}'.");
}
}
// activate the pane
return((IPpsWindowPane)Activator.CreateInstance(paneType, paneArguments));
} // func CreateEmptyPane
} // func GetPaneType
/// <summary>Get default open pane mode</summary>
/// <param name="paneManager">Pane manager to use.</param>
/// <param name="arguments"></param>
/// <returns></returns>
public static PpsOpenPaneMode GetDefaultPaneMode(this IPpsWindowPaneManager paneManager, dynamic arguments)
{
if (arguments != null && arguments.Mode != null)
{
return(Procs.ChangeType <PpsOpenPaneMode>(arguments.Mode));
}
return(paneManager.Shell.GetOptionalValue("NewPaneMode", true) ? PpsOpenPaneMode.NewPane : PpsOpenPaneMode.ReplacePane);
} // func GetDefaultPaneMode
/// <summary>Loads a pane of specific type with the givven arguments.</summary>
/// <param name="paneManager">Pane manager to use.</param>
/// <param name="arguments">Argument for the pane load function. This is pane specific.</param>
/// <returns>A full inialized pane.</returns>
/// <remarks>This function uses <c>AwaitTask</c>
///
/// - <c>arguments.mode</c>: is the <see cref="PpsOpenPaneMode"/> (optional)
/// - <c>arguments.paneType</c>: is the type as string or type, of the pane. (required)
/// Well known Pane types are:
/// - mask
/// - generic
/// - picture
/// - pdf
/// </remarks>
public static IPpsWindowPane LoadPane(this IPpsWindowPaneManager paneManager, LuaTable arguments = null)
{
var paneType = GetPaneType(paneManager, arguments);
if (paneType == null)
{
throw new ArgumentException("Pane type is missing.");
}
return(paneManager.OpenPaneAsync(paneType, GetDefaultPaneMode(paneManager, arguments), arguments).AwaitTask());
} // func OpenPane
} // proc ClearWindowPane
public void MoveWindowPane(IPpsWindowPaneManager targetPaneManager, PpsWindowPaneHost targetPaneHost)
{
var pane = CurrentPane;
if (pane == null)
{
return;
}
// remove window from current host
ClearWindowPane(pane);
// copy window pane to new host
targetPaneHost.PaneManager = targetPaneManager;
targetPaneHost.SetWindowPane(pane);
} // proc MoveWindowPane
} // func CreateEmptyPane
private static Type GetPaneType(IPpsWindowPaneManager paneManager, dynamic arguments)
{
var paneTypeValue = (object)arguments?.PaneType;
switch (paneTypeValue)
{
case Type type:
return(type);
case LuaType luaType:
return(luaType.Type);
case string typeString:
return(paneManager.Shell.GetPaneTypeFromString(typeString));
case null:
throw new ArgumentNullException("paneType");
default:
throw new ArgumentException("Could not parse pane type.", "paneType");
}
} // func GetPaneType
} // func GetDefaultPaneMode
/// <summary>Loads a generic wpf window pane <see cref="PpsGenericWpfWindowPane"/>.</summary>
/// <param name="paneManager">Pane manager to use.</param>
/// <param name="arguments">Argument for the pane load function. This is pane specific.</param>
/// <returns>A full inialized pane.</returns>
/// <remarks>This function uses <c>AwaitTask</c>
///
/// - <c>arguments.mode</c>: is the <see cref="PpsOpenPaneMode"/> (optional)
/// </remarks>
public static IPpsWindowPane LoadGenericPane(this IPpsWindowPaneManager paneManager, LuaTable arguments = null)
=> paneManager.OpenPaneAsync(typeof(PpsGenericWpfWindowPane), PpsOpenPaneMode.Default, arguments).AwaitTask();
