private static IFunctionCatalogGroup CreateViewGroup(ISettings settings, LrApi api)
{
var functions = new List <IFunctionFactory>();
functions.AddRange(CreateSwitchToModule(settings, api));
functions.AddRange(CreateShowView(settings, api));
functions.AddRange(CreateShowSecondaryView(settings, api));
functions.AddRange(new IFunctionFactory[]
{
new MethodFunctionFactory(settings, api, "Toggle secondary display", "ToggleSecondaryDisplay", a => a.LrApplicationView.ToggleSecondaryDisplay()),
new MethodFunctionFactory(settings, api, "Toggle secondary display fullscreen", "ToggleSecondaryDisplayFullscreen", a => a.LrApplicationView.ToggleSecondaryDisplayFullscreen()),
new MethodFunctionFactory(settings, api, "Toggle zoom", "ToggleZoom", a => a.LrApplicationView.ToggleZoom()),
new MethodFunctionFactory(settings, api, "Zoom in", "ZoomIn", a => a.LrApplicationView.ZoomIn()),
new MethodFunctionFactory(settings, api, "Zoom in some", "ZoomInSome", a => a.LrApplicationView.ZoomInSome()),
new MethodFunctionFactory(settings, api, "Zoom out", "ZoomOut", a => a.LrApplicationView.ZoomOut()),
new MethodFunctionFactory(settings, api, "Zoom out some", "ZoomOutSome", a => a.LrApplicationView.ZoomOutSome()),
new ToggleDevelopBeforeAfterFunctionFactory(settings, api),
});
return(new FunctionCatalogGroup
{
DisplayName = "View",
Key = "LrApplicationView",
Functions = new ObservableCollection <IFunctionFactory>(functions),
});
}
private static IFunctionCatalogGroup CreateUndoGroup(ISettings settings, LrApi api)
{
return(new FunctionCatalogGroup
{
DisplayName = "Undo",
Key = "LrUndo",
Functions = new ObservableCollection <IFunctionFactory>(new[]
protected Function(ISettings settings, LrApi api, string displayName, string key)
{
Settings = settings;
Api = api;
DisplayName = displayName;
Key = key;
}
public MethodFunctionFactory(ISettings settings, LrApi api, string displayName, string key,
Action <LrApi> method) : base(settings, api)
{
_method = method;
DisplayName = displayName;
Key = $"MethodFunction:{key}";
}
public ParameterFunction(ISettings settings, LrApi api, string displayName, IParameter <T> parameter, string key)
: base(settings, api, displayName, key)
{
Parameter = parameter;
api.LrDevelopController.AddParameterChangedListener(parameter, RequestUpdateControllerValue);
}
private static IFunctionCatalogGroup CreateDevelopGroup(ISettings settings, LrApi api)
{
var functions = new List <IFunctionFactory>();
functions.AddRange(new []
{
new MethodFunctionFactory(settings, api, "Reset all develop adjustments", "ResetAllDevelopAdjustments", a => a.LrDevelopController.ResetAllDevelopAdjustments()),
new MethodFunctionFactory(settings, api, "Reset Adjustment Brush", "ResetBrushing", a => a.LrDevelopController.ResetBrushing()),
new MethodFunctionFactory(settings, api, "Reset Radial Filter", "ResetCircularGradient", a => a.LrDevelopController.ResetCircularGradient()),
new MethodFunctionFactory(settings, api, "Reset Crop", "ResetCrop", a => a.LrDevelopController.ResetCrop()),
new MethodFunctionFactory(settings, api, "Reset Graduated Filter", "ResetGradient", a => a.LrDevelopController.ResetGradient()),
new MethodFunctionFactory(settings, api, "Reset Red Eye Correction", "ResetRedEye", a => a.LrDevelopController.ResetRedEye()),
new MethodFunctionFactory(settings, api, "Reset Spot Removal", "ResetSpotRemoval", a => a.LrDevelopController.ResetSpotRemoval()),
});
foreach (var tool in Tool.AllEnums)
{
functions.Add(new MethodFunctionFactory(settings, api, $"Select Tool {tool.Name}", $"SelectTool{tool.Value}",
a => a.LrDevelopController.SelectTool(tool)));
}
return(new FunctionCatalogGroup
{
DisplayName = "Develop",
Key = "LrDevelop",
Functions = new ObservableCollection <IFunctionFactory>(functions)
});
}
private static ModuleGroup CreateModuleWithGlobal(LrApi api, Module module)
{
return(new ModuleGroup(module, new List <FunctionGroup>
{
new FunctionGroup(api)
{
Key = $"{module.Value}:Global"
}
}));
}
public FunctionGroup(LrApi api, Panel panel = null)
{
_api = api;
IsGlobal = panel == null;
Panel = panel;
_controllerFunctions = new List <ControllerFunction>();
OnPropertyChanged(nameof(ControllerFunctions));
AllFunctionGroups.Add(this);
}
public static FunctionGroupManager DefaultGroups(LrApi api, IFunctionCatalog functionCatalog, Device device)
{
return(new FunctionGroupManager(functionCatalog, device, new List <ModuleGroup>
{
CreateModuleWithGlobal(api, Module.Library),
CreateDevelopModule(api),
CreateModuleWithGlobal(api, Module.Map),
CreateModuleWithGlobal(api, Module.Book),
CreateModuleWithGlobal(api, Module.Slideshow),
CreateModuleWithGlobal(api, Module.Print),
CreateModuleWithGlobal(api, Module.Web)
}));
}
private static ModuleGroup CreateDevelopModule(LrApi api)
{
var group = new ModuleGroup(Module.Develop, new List <FunctionGroup>
{
new FunctionGroup(api)
{
Key = $"{Module.Develop.Value}:Global"
}
});
foreach (var panel in Panel.AllEnums)
{
group.AddFunctionGroup(new FunctionGroup(api, panel)
{
Key = $"{Module.Develop.Value}:{panel.Value}"
});
}
return(group);
}
private LrControlApplication()
{
// Configure logging
var template = "{Timestamp:yyyy-MM-dd HH:mm:ss.sss} [{SourceContext:l}] [{Level}] {Message}{NewLine}{Exception}";
Serilog.Log.Logger = new LoggerConfiguration()
.MinimumLevel.Information()
.WriteTo.ColoredConsole(outputTemplate: template)
.WriteTo.RollingFile("LrControl.exe.{Date}.log",
outputTemplate: template,
fileSizeLimitBytes: 10 * 1024 * 1024,
flushToDiskInterval: TimeSpan.FromSeconds(1),
retainedFileCountLimit: 5,
shared: true)
.CreateLogger();
_settings = Configurations.Settings.LoadOrDefault();
_lrApi = new LrApi();
_functionCatalog = Functions.Catalog.FunctionCatalog.DefaultCatalog(_settings, _lrApi);
_device = new Device();
_functionGroupManager = FunctionGroupManager.DefaultGroups(_lrApi, _functionCatalog, _device);
// Hookup module listener
_lrApi.LrApplicationView.ModuleChanged += _functionGroupManager.EnableModule;
_lrApi.ConnectionStatus += (connected, version) => ConnectionStatus?.Invoke(connected, version);
// Listen for Setting changes
_settings.PropertyChanged += SettingsOnPropertyChanged;
// Restore previously selected input/output devices
RefreshAvailableDevices(false);
SetInputDevice(_inputDevices.FirstOrDefault(x => x.Name == _settings.LastUsedInputDevice));
SetOutputDevice(_outputDevices.FirstOrDefault(x => x.Name == _settings.LastUsedOutputDevice));
// Load configuration
LoadConfiguration();
Log.Information("LrControl application started, running {Version}", Environment.Version);
}
protected override IFunction CreateFunction(ISettings settings, LrApi api)
{
switch (_parameter)
{
case IParameter <double> temperatureParameter when ReferenceEquals(temperatureParameter, Parameters.AdjustPanelParameters.Temperature):
return(new TemperatureParameterFunction(settings, api, DisplayName, temperatureParameter, Key));
case IParameter <int> intParameter:
return(new ParameterFunction <int>(settings, api, DisplayName, intParameter, Key));
case IParameter <double> doubleParameter:
return(new ParameterFunction <double>(settings, api, DisplayName, doubleParameter, Key));
case IParameter <bool> boolParameter:
return(new ParameterFunction <bool>(settings, api, DisplayName, boolParameter, Key));
default:
{
Log.Error("Unsupported Parameter {Parameter}", _parameter);
throw new ArgumentException("Unsupported parameter type");
}
}
}
protected override IFunction CreateFunction(ISettings settings, LrApi api)
{
return(new MethodFunction(settings, api, DisplayName, _method, DisplayName, Key));
}
private static IEnumerable <IFunctionFactory> CreateFunctionsForEnumParameter(ISettings settings, LrApi api, IList <IParameter> parameters)
{
var enumFunctions = new List <IFunctionFactory>();
foreach (var param in parameters)
{
var valueType = param.GetType().GetGenericArguments()[0];
if (valueType.BaseType == null || !valueType.BaseType.IsGenericType || typeof(ClassEnum <,>) != valueType.BaseType.GetGenericTypeDefinition())
{
continue;
}
var allEnumsProperty = valueType.BaseType.GetProperty("AllEnums");
var nameProperty = valueType.BaseType.GetProperty("Name");
var valueProperty = valueType.BaseType.GetProperty("Value");
var callSetValueMethod = valueType.BaseType.GetMethod("CallSetValue");
var allEnums = (IEnumerable)allEnumsProperty.GetMethod.Invoke(null, null);
foreach (var enumValue in allEnums)
{
var name = nameProperty.GetMethod.Invoke(enumValue, null);
var value = valueProperty.GetMethod.Invoke(enumValue, null);
enumFunctions.Add(
new MethodFunctionFactory(settings, api, $"Set {param.DisplayName} to {name}", $"Set{param.Name}To{value}",
a => callSetValueMethod.Invoke(null, new[] { a, param, enumValue })));
}
}
return(enumFunctions);
}
public EnablePanelFunction(ISettings settings, LrApi api, string displayName, Panel panel, IParameter <bool> enablePanelParameter, string key) : base(settings, api, displayName, key)
{
_panel = panel;
_enablePanelParamter = enablePanelParameter;
}
protected override IFunction CreateFunction(ISettings settings, LrApi api)
{
return(new ToggleParameterFunction(settings, api, DisplayName, _parameter, Key));
}
public ToggleParameterFunctionFactory(ISettings settings, LrApi api, IParameter <bool> parameter) : base(settings, api)
{
_parameter = parameter;
}
public VuserClass()
{
lr = new LrApi();
}
public static void CallSetValue(LrApi api, IParameter <TEnum> parameter, TEnum value)
{
api.LrDevelopController.SetValue(parameter, value);
}
private static IEnumerable <MethodFunctionFactory> CreateShowSecondaryView(ISettings settings, LrApi api)
{
return(SecondaryView.AllEnums.Select(view =>
new MethodFunctionFactory(settings, api, $"Change secondary monitor to {view.Name}", $"ShowSecondaryView{view.Value}",
a => a.LrApplicationView.ShowSecondaryView(view))));
}
private static IEnumerable <MethodFunctionFactory> CreateSwitchToModule(ISettings settings, LrApi api)
{
return(Module.AllEnums.Select(module =>
new MethodFunctionFactory(settings, api, $"Switch to {module.Name}", $"SwitchToModule{module.Value}",
a => a.LrApplicationView.SwitchToModule(module))));
}
private static IEnumerable <IFunctionCatalogGroup> CreateDevelopGroups(ISettings settings, LrApi api)
{
var groups = new List <IFunctionCatalogGroup>();
groups.Add(CreateDevelopGroup(settings, api));
groups.Add(CreateDevelopPanelGroup(settings, api, Panel.Basic, null, Parameters.AdjustPanelParameters.AllParameters));
groups.Add(CreateDevelopPanelGroup(settings, api, Panel.ToneCurve, Parameters.EnablePanelParameters.ToneCurve, Parameters.TonePanelParameters.AllParameters));
groups.Add(CreateDevelopPanelGroup(settings, api, Panel.ColorAdjustment, Parameters.EnablePanelParameters.ColorAdjustments, Parameters.MixerPanelParameters.AllParameters));
groups.Add(CreateDevelopPanelGroup(settings, api, Panel.SplitToning, Parameters.EnablePanelParameters.SplitToning, Parameters.SplitToningPanelParameters.AllParameters));
groups.Add(CreateDevelopPanelGroup(settings, api, Panel.Detail, Parameters.EnablePanelParameters.Detail, Parameters.DetailPanelParameters.AllParameters));
groups.Add(CreateDevelopPanelGroup(settings, api, Panel.LensCorrections, Parameters.EnablePanelParameters.LensCorrections, Parameters.LensCorrectionsPanelParameters.AllParameters));
groups.Add(CreateDevelopPanelGroup(settings, api, Panel.Effects, Parameters.EnablePanelParameters.Effects, Parameters.EffectsPanelParameters.AllParameters));
groups.Add(CreateDevelopPanelGroup(settings, api, Panel.CameraCalibration, Parameters.EnablePanelParameters.Calibration, Parameters.CalibratePanelParameters.AllParameters));
groups.Add(CreateDevelopCropGroup(settings, api));
groups.Add(CreateDevelopLocalizedGroup(settings, api));
return(groups);
}
private static IFunctionCatalogGroup CreateDevelopLocalizedGroup(ISettings settings, LrApi api)
{
var functions = new List <IFunctionFactory>();
// Change parameters
foreach (var param in Parameters.LocalizedAdjustmentsParameters.AllParameters)
{
functions.Add(new ParameterFunctionFactory(settings, api, param));
}
// Reset parameter
foreach (var param in Parameters.LocalizedAdjustmentsParameters.AllParameters)
{
functions.Add(new MethodFunctionFactory(settings, api, $"Reset {param.DisplayName} to default", $"ResetToDefault{param.Name}",
a =>
{
a.LrDevelopController.StopTracking();
a.LrDevelopController.ResetToDefault(param);
}));
}
return(new FunctionCatalogGroup
{
DisplayName = "Develop Localized",
Key = "LrDevelopLocalized",
Functions = new ObservableCollection <IFunctionFactory>(functions)
});
}
protected FunctionFactory(ISettings settings, LrApi api)
{
_settings = settings;
_api = api;
}
private static IEnumerable <IFunctionCatalogGroup> CreateGroups(ISettings settings, LrApi api)
{
var groups = new List <IFunctionCatalogGroup>
{
CreateViewGroup(settings, api),
CreateUndoGroup(settings, api),
CreateSelectionGroup(settings, api)
};
groups.AddRange(CreateDevelopGroups(settings, api));
return(groups);
}
public static IFunctionCatalog DefaultCatalog(ISettings settings, LrApi api)
{
return(new FunctionCatalog(CreateGroups(settings, api)));
}
public ToggleParameterFunction(ISettings settings, LrApi api, string displayName, IParameter <bool> parameter, string key) : base(settings, api, displayName, key)
{
_parameter = parameter;
}
public ParameterFunctionFactory(ISettings settings, LrApi api, IParameter parameter) : base(settings, api)
{
_parameter = parameter;
}
protected abstract IFunction CreateFunction(ISettings settings, LrApi api);
private static IFunctionCatalogGroup CreateDevelopPanelGroup(ISettings settings, LrApi api, Panel panel, IParameter <bool> enablePanelParameter, IList <IParameter> parameters)
{
var functions = new List <IFunctionFactory>();
functions.AddRange(new []
{
new EnablePanelFunctionFactory(settings, api, panel, enablePanelParameter),
});
// Change parameter
foreach (var param in parameters)
{
if (param is IParameter <int> || param is IParameter <double> )
{
functions.Add(new ParameterFunctionFactory(settings, api, param));
}
}
// Change enum parameter
functions.AddRange(CreateFunctionsForEnumParameter(settings, api, parameters));
// Reset parameter
foreach (var param in parameters)
{
functions.Add(new MethodFunctionFactory(settings, api, $"Reset {param.DisplayName} to default", $"ResetToDefault{param.Name}",
a =>
{
a.LrDevelopController.StopTracking();
a.LrDevelopController.ResetToDefault(param);
}));
}
// Toggle parameter
functions.AddRange(parameters
.OfType <IParameter <bool> >()
.Select(parameter => new ToggleParameterFunctionFactory(settings, api, parameter)));
// Increment / Decrement
foreach (var param in parameters)
{
if (param is IParameter <int> || param is IParameter <double> )
{
functions.Add(new MethodFunctionFactory(settings, api, $"Increment {param.DisplayName}", $"Increment{param.Name}",
a => a.LrDevelopController.Increment(param)));
functions.Add(new MethodFunctionFactory(settings, api, $"Decrement {param.DisplayName}", $"Decrement{param.Name}",
a => a.LrDevelopController.Decrement(param)));
}
}
return(new FunctionCatalogGroup
{
DisplayName = $"Develop {panel.Name}",
Key = $"LrDevelop{panel.Value}",
Functions = new ObservableCollection <IFunctionFactory>(functions)
});
}
