/// <summary>
/// El constructor de la clase toma un tipo, y creará una instancia
/// de una subclase de <c>BitmapProcess</c>.
/// </summary>
/// <param name="t">
/// El tipo del algorimto a que contiene el nodo.
/// </param>
/// <param name="description">
/// La descripcion del algoritmo que contiene el nodo.
/// </param>
public BitmapProcessNode(Type t, string description)
{
this.description = description;
process =
(BitmapProcess)(t.GetConstructor(new Type[] {}).Invoke(null));
}
private void AddPropertyWidget(BitmapProcess p, PropertyInfo info)
{
ProcessEditorWidget widget = ProcessEditorWidget.Create(p, info);
if (widget != null)
{
// Si la propiedad es una de las que configuracion del procesado
editVB.Add(widget);
editorWidgets.Add(widget);
}
}
public static ResponseType Show(Window parent,
BitmapProcess process,
string desc)
{
ProcessEditorDialog dlg = new
ProcessEditorDialog(parent, process, desc);
ResponseType res = dlg.Run();
dlg.Destroy();
return(res);
}
/// <summary>
/// Añade un algoritmo de procesado a la lista.
/// </summary>
/// <param name="p">
/// A <see cref="BitmapProcess"/>
/// </param>
private void AddProcess(BitmapProcess p)
{
BitmapProcessNode node =
new BitmapProcessNode(p, bitmapProcessesTypes[p.GetType()]);
processesView.NodeStore.AddNode(node);
processesView.NodeSelection.SelectNode(node);
TreePath path = processesView.Selection.GetSelectedRows()[0];
processesView.ScrollToCell(path, null, true, 0f, 0);
}
/// <summary>
/// Crea un control para editar una propiedad de un algoritmo de
/// procesado de imagenes.
/// </summary>
/// <param name="process">
/// El algoritmo al que pertenece la propiedad a editar.
/// </param>
/// <param name="info">
/// Informacion acerca de la propiedad a editar.
/// </param>
/// <returns>
/// El control, si la información del parametro contenia su descripcion,
/// y este pudo ser creado, <c>null</c> en otro caso.
/// </returns>
public static ProcessEditorWidget Create(BitmapProcess process,
PropertyInfo info)
{
ProcessEditorWidget widget = new ProcessEditorWidget(process, info);
if (widget.InitializeWidget())
{
return(widget);
}
else
{
return(null);
}
}
private ProcessEditorDialog(Window parent,
BitmapProcess process,
string desc)
{
Glade.XML xml =
new Glade.XML(null, "databaseAssistant.glade", "processEditorDialog", null);
xml.Autoconnect(this);
processEditorDialog.Modal = true;
processEditorDialog.TransientFor = parent;
this.process = process;
editorWidgets = new List <ProcessEditorWidget>();
InitializeWidgets(desc);
}
/// <summary>
/// El constructor de la clase toma una instancia de<c>BitmapProcess</c>.
/// para crear un nodo que la contenga.
/// </summary>
/// <param name="bp">
/// El algoritmo a contener.
/// </param>
/// <param name="description">
/// La descripcion del tipo del algoritmo.
/// </param>
public BitmapProcessNode(BitmapProcess bp, string description)
{
this.description = description;
this.process = bp;
}
public async Task <ActionResult> PictureSized(int id, int width, int height)
{
var picture = await _ps.Get(id);
return(File(BitmapProcess.Resize(picture.Picture, width, height), "image/jpeg"));
}
/// <summary>
/// Constructor de la clase <c>ProcessEditorWidget</c>, es privado
/// porque la usamos con una factoria estatica.
/// </summary>
/// <param name="process">
/// El algoritmo de proceso de imagenes al que pertenece la propiedad.
/// </param>
/// <param name="info">
/// El parametro del algoritmo que el control editará.
/// </param>
private ProcessEditorWidget(BitmapProcess process, PropertyInfo info)
: base(0f, 0.5f, 0f, 1.0f)
{
this.info = info;
this.process = process;
}
