Capítulo 25: ListSelect, selección de lista en EPLAN

Parte V: Interacción con usuario - Sección 10: Decisiones interactivas - Nivel: Principiante

Objetivos de aprendizaje

Al finalizar este capítulo serás capaz de:

• Entender qué es ListSelectDecisionContext y para qué sirve
• Crear listas de opciones para que el usuario seleccione
• Configurar selección simple vs selección múltiple
• Procesar la selección del usuario
• Aplicar ListSelectDecisionContext en flujos EPLAN

Requisitos previos

• Conocer Decider
• Entender StringCollection
• Saber usar if y switch
• Conocer bucles foreach

Introducción: Más allá de Sí/No

En el capítulo anterior usaste Decider para preguntas Sí/No:

Decider decider = new Decider();
EnumDecisionReturn respuesta = decider.Decide(
    EnumDecisionType.eYesNoDecision,
    "¿Continuar?",
    "Pregunta",
    EnumDecisionReturn.eYES,
    EnumDecisionReturn.eNO
);

Esto funciona para dos opciones, pero ¿qué pasa si necesitas que el usuario elija entre múltiples opciones?

Problema:

Opciones: PDF, DWG, DXF, XML, CSV

No puedes poner 5 botones en un Decider. Necesitas una lista.

Solución: ListSelectDecisionContext

1. ¿Qué es ListSelectDecisionContext?

1.1 Definición

ListSelectDecisionContext es una clase que crea un contexto de decisión con una lista de opciones para que el usuario seleccione.

¿Dónde se define?

using Eplan.EplApi.Base;
using System.Collections.Specialized;  // Para StringCollection

1.2 Diferencias con Decider normal

Cuándo usar cada uno:

• Decider: Preguntas simples con opciones fijas (Sí/No, OK/Cancel)
• ListSelectDecisionContext: Elegir de una lista de opciones personalizadas

2. Cómo usar ListSelectDecisionContext

2.1 Sintaxis básica

// 1. Crear la lista de opciones
StringCollection opciones = new StringCollection();
opciones.Add("Opción 1");
opciones.Add("Opción 2");
opciones.Add("Opción 3");

// 2. Crear el contexto
ListSelectDecisionContext contexto = new ListSelectDecisionContext(
    opciones,           // Lista de opciones
    "Opción 1",         // Opción seleccionada por defecto
    "Título del diálogo"  // Título
);

// 3. Configurar (opcional)
contexto.AllowMultiSelect = false;  // Selección simple

// 4. Mostrar el diálogo
Decider decider = new Decider();
EnumDecisionReturn resultado = decider.Decide(contexto);

// 5. Procesar la selección
if (resultado == EnumDecisionReturn.eOK)
{
    string seleccionado = contexto.SelectedEntry;  // Opción elegida
    MessageBox.Show("Usuario eligió: " + seleccionado);
}

2.2 Ejemplo del script oficial

Basado en EPLAN-Scripting-4.0/04_CodeFlow/09_ListSelectDecisionContext.cs:

using System.Collections.Specialized;
using System.Windows.Forms;
using Eplan.EplApi.Base;
using Eplan.EplApi.Scripting;

public class ListSelectBasico
{
    [Start]
    public void Function()
    {
        // Definir opciones
        string title = "¿Qué píldora eliges?";
        string redPill = "Píldora roja";
        string bluePill = "Píldora azul";

        // Crear lista de opciones
        StringCollection entries = new StringCollection();
        entries.Add(redPill);
        entries.Add(bluePill);

        // Crear contexto de decisión
        ListSelectDecisionContext listSelectDecision =
            new ListSelectDecisionContext(entries, redPill, title);

        // Configurar selección simple (no múltiple)
        listSelectDecision.AllowMultiSelect = false;

        // Mostrar diálogo
        var result = new Decider().Decide(listSelectDecision);

        // Procesar resultado
        if (result == EnumDecisionReturn.eOK)
        {
            MessageBox.Show("Elegiste: " + listSelectDecision.SelectedEntry);
        }
        else
        {
            MessageBox.Show("No se seleccionó nada (usuario canceló)");
        }
    }
}

¿Qué hace?

1. Crea una lista con dos opciones
2. Crea un contexto con esa lista
3. Muestra un diálogo con las opciones
4. Si el usuario elige una y presiona OK, muestra cuál eligió
5. Si cancela, no hace nada

3. Selección simple vs selección múltiple

3.1 Selección simple (por defecto)

listSelectDecision.AllowMultiSelect = false;

// Al mostrar:
// ○ Opción 1
// ○ Opción 2
// ● Opción 3  ← Solo una seleccionada

// Obtener selección:
string seleccionado = listSelectDecision.SelectedEntry;

Uso: Cuando el usuario debe elegir exactamente una opción.

3.2 Selección múltiple

listSelectDecision.AllowMultiSelect = true;

// Al mostrar:
// ☐ Opción 1
// ☑ Opción 2  ← Múltiples seleccionadas
// ☑ Opción 3

// Obtener selecciones (plural):
StringCollection seleccionados = listSelectDecision.SelectedEntries;

foreach (string item in seleccionados)
{
    MessageBox.Show("Seleccionado: " + item);
}

Uso: Cuando el usuario puede elegir cero, una o varias opciones.

4. Ejemplo: Seleccionar formato de exportación

4.1 Selección simple (un formato)

using System.Collections.Specialized;
using System.Windows.Forms;
using Eplan.EplApi.Base;
using Eplan.EplApi.ApplicationFramework;
using Eplan.EplApi.Scripting;

public class SeleccionarFormato
{
    [Start]
    public void Function()
    {
        // Crear lista de formatos disponibles
        StringCollection formatos = new StringCollection();
        formatos.Add("PDF");
        formatos.Add("DWG");
        formatos.Add("DXF");
        formatos.Add("XML");
        formatos.Add("CSV");

        // Crear contexto
        ListSelectDecisionContext contexto = new ListSelectDecisionContext(
            formatos,
            "PDF",  // Por defecto: PDF
            "Seleccione el formato de exportación"
        );

        // Selección simple
        contexto.AllowMultiSelect = false;

        // Mostrar diálogo
        Decider decider = new Decider();
        EnumDecisionReturn resultado = decider.Decide(contexto);

        if (resultado == EnumDecisionReturn.eOK)
        {
            string formatoElegido = contexto.SelectedEntry;

            new BaseException(
                "Formato seleccionado: " + formatoElegido,
                MessageLevel.Message
            ).FixMessage();

            // Ejecutar exportación según el formato
            ExportarEnFormato(formatoElegido);
        }
        else
        {
            MessageBox.Show("Exportación cancelada");
        }
    }

    private void ExportarEnFormato(string formato)
    {
        // Obtener nombre del proyecto
        string nombreProyecto = PathMap.SubstitutePath("$(PROJECTNAME)");
        string rutaSalida = @"C:\temp\" + nombreProyecto + "." + formato.ToLower();

        new BaseException(
            "Exportando a " + formato + ": " + rutaSalida,
            MessageLevel.Message
        ).FixMessage();

        // Preparar exportación
        ActionCallingContext ctx = new ActionCallingContext();
        ctx.AddParameter("EXPORTFILE", rutaSalida);
        ctx.AddParameter("TYPE", formato);

        try
        {
            CommandLineInterpreter cli = new CommandLineInterpreter();
            cli.Execute("export", ctx);

            MessageBox.Show(
                "Proyecto exportado a:\n\n" + rutaSalida,
                "Exportación completada",
                MessageBoxButtons.OK,
                MessageBoxIcon.Information
            );
        }
        catch (System.Exception ex)
        {
            new BaseException(
                "Error al exportar: " + ex.Message,
                MessageLevel.Error
            ).FixMessage();

            MessageBox.Show("Error al exportar. Ver 'Mensajes de sistema'.");
        }
    }
}

4.2 Selección múltiple (varios formatos)

using System.Collections.Specialized;
using System.Windows.Forms;
using Eplan.EplApi.Base;
using Eplan.EplApi.Scripting;

public class SeleccionarMultiplesFormatos
{
    [Start]
    public void Function()
    {
        // Crear lista de formatos disponibles
        StringCollection formatos = new StringCollection();
        formatos.Add("PDF");
        formatos.Add("DWG");
        formatos.Add("DXF");
        formatos.Add("XML");
        formatos.Add("CSV");

        // Crear contexto
        ListSelectDecisionContext contexto = new ListSelectDecisionContext(
            formatos,
            "PDF",
            "Seleccione uno o más formatos de exportación"
        );

        // Selección MÚLTIPLE
        contexto.AllowMultiSelect = true;

        // Mostrar diálogo
        Decider decider = new Decider();
        EnumDecisionReturn resultado = decider.Decide(contexto);

        if (resultado == EnumDecisionReturn.eOK)
        {
            // Obtener TODAS las selecciones (plural: SelectedEntries)
            StringCollection formatosElegidos = contexto.SelectedEntries;

            if (formatosElegidos.Count == 0)
            {
                MessageBox.Show("No se seleccionó ningún formato");
                return;
            }

            // Exportar en cada formato seleccionado
            foreach (string formato in formatosElegidos)
            {
                new BaseException(
                    "Exportando en formato: " + formato,
                    MessageLevel.Message
                ).FixMessage();

                // Aquí iría la lógica de exportación para cada formato
                System.Threading.Thread.Sleep(500);  // Simular trabajo
            }

            MessageBox.Show(
                "Exportación completada en " + formatosElegidos.Count + " formato(s)",
                "Éxito",
                MessageBoxButtons.OK,
                MessageBoxIcon.Information
            );
        }
        else
        {
            MessageBox.Show("Exportación cancelada");
        }
    }
}

5. Propiedades útiles de ListSelectDecisionContext

5.1 AllowMultiSelect

// Selección simple (default)
contexto.AllowMultiSelect = false;

// Selección múltiple
contexto.AllowMultiSelect = true;

5.2 SelectedEntry vs SelectedEntries

// Para selección SIMPLE (una opción)
string seleccionado = contexto.SelectedEntry;

// Para selección MÚLTIPLE (varias opciones)
StringCollection seleccionados = contexto.SelectedEntries;

Importante: Usa SelectedEntry (singular) si AllowMultiSelect = false, y SelectedEntries (plural) si AllowMultiSelect = true.

6. Casos de uso prácticos

6.1 Menú de opciones

StringCollection opciones = new StringCollection();
opciones.Add("Generar numeración");
opciones.Add("Validar proyecto");
opciones.Add("Exportar a PDF");
opciones.Add("Limpiar datos temporales");

ListSelectDecisionContext menu = new ListSelectDecisionContext(
    opciones,
    "Generar numeración",
    "Seleccione una acción"
);
menu.AllowMultiSelect = false;

var resultado = new Decider().Decide(menu);
if (resultado == EnumDecisionReturn.eOK)
{
    switch (menu.SelectedEntry)
    {
        case "Generar numeración":
            GenerarNumeracion();
            break;
        case "Validar proyecto":
            ValidarProyecto();
            break;
        case "Exportar a PDF":
            ExportarPDF();
            break;
        case "Limpiar datos temporales":
            LimpiarDatos();
            break;
    }
}

6.2 Seleccionar páginas del proyecto

// Obtener lista de páginas (simulado)
StringCollection paginas = new StringCollection();
paginas.Add("=001-Hoja principal");
paginas.Add("=002-Alimentación");
paginas.Add("=003-Control");
paginas.Add("=004-Bornes");

ListSelectDecisionContext seleccionPaginas = new ListSelectDecisionContext(
    paginas,
    paginas[0],
    "Seleccione las páginas a procesar"
);
seleccionPaginas.AllowMultiSelect = true;  // Permitir varias

var resultado = new Decider().Decide(seleccionPaginas);
if (resultado == EnumDecisionReturn.eOK)
{
    foreach (string pagina in seleccionPaginas.SelectedEntries)
    {
        ProcesarPagina(pagina);
    }
}

7. Buenas prácticas

7.1 Validar que hay selección (para AllowMultiSelect = true)

if (resultado == EnumDecisionReturn.eOK)
{
    if (contexto.SelectedEntries.Count == 0)
    {
        MessageBox.Show("Debe seleccionar al menos una opción");
        return;
    }

    // Procesar selecciones...
}

7.2 Usar nombres descriptivos en la lista

// ✅ Bien - Descriptivo
opciones.Add("Exportar proyecto a PDF con marcas de agua");
opciones.Add("Exportar proyecto a PDF sin marcas de agua");

// ❌ Mal - Vago
opciones.Add("Opción 1");
opciones.Add("Opción 2");

7.3 Ordenar alfabéticamente si tiene sentido

StringCollection formatos = new StringCollection();
formatos.Add("CSV");
formatos.Add("DWG");
formatos.Add("DXF");
formatos.Add("PDF");
formatos.Add("XML");
// Más fácil de encontrar si está ordenado

Resumen

ListSelectDecisionContext permite mostrar una lista de opciones personalizada para que el usuario seleccione.

Conceptos clave:

• Creas una StringCollection con las opciones
• Creas un ListSelectDecisionContext con esa lista
• Usas Decider.Decide(contexto) para mostrar el diálogo
• Si el usuario confirma (OK), obtienes su selección

Selección simple vs múltiple:

• AllowMultiSelect = false: El usuario elige UNA opción → usa SelectedEntry (singular)
• AllowMultiSelect = true: El usuario elige VARIAS opciones → usa SelectedEntries (plural)

Casos de uso típicos:

• Menús de opciones
• Seleccionar formato de exportación
• Elegir páginas/componentes a procesar
• Cualquier escenario con 3+ opciones

ListSelectDecisionContext es ideal cuando Decider con botones fijos (Sí/No/OK) no es suficiente.

Preguntas frecuentes

P: ¿Puedo agregar opciones dinámicamente (por ejemplo, desde archivos)?

R: Sí. Puedes llenar la StringCollection desde cualquier fuente:

string[] archivos = Directory.GetFiles(@"C:\temp", "*.xml");
StringCollection opciones = new StringCollection();
foreach (string archivo in archivos)
{
    opciones.Add(Path.GetFileName(archivo));
}

P: ¿Qué pasa si la lista está vacía?

R: El diálogo se mostrará vacío. Es buena práctica validar que hay al menos una opción antes de mostrar.

P: ¿Puedo usar objetos en lugar de strings?

R: No. ListSelectDecisionContext solo acepta StringCollection. Si tienes objetos, convierte a string (por ejemplo, objeto.ToString()) y luego mapea de vuelta.

P: ¿Puedo cambiar el estilo del diálogo (colores, tamaño)?

R: No directamente. El estilo lo controla EPLAN. Para mayor personalización, considera crear tu propio Form con Windows.Forms.

Conexiones

Capítulo anterior

Capítulo 24: Decider - Preguntar al usuario

Próximo capítulo

Ver capítulos siguientes

En el próximo capítulo aprenderás a crear acciones [DeclareAction] que retornan valores, lo que permite usar tus scripts desde otros scripts o desde la línea de comandos de EPLAN.

Última actualización: Enero 2025 Tiempo de lectura estimado: 20 minutos Código de ejemplo: code/cap-25/Script de referencia: EPLAN-Scripting-4.0/04_CodeFlow/09_ListSelectDecisionContext.cs