Anatomía de un módulo de función: POPUP_TO_CONFIRM – Parte 3
By s4pcademy
Sé que conté historias muy simples en el anterior capítulo. Ahora entremos en algunos detalles. Creo que este capítulo es el más emocionante, al menos para mí.
En este capítulo:
Antes de comenzar, hay algo importante que debo decirte.
Diferentes versiones de código
Las versiones del código fuente pueden diferir entre sistemas. Mientras escribía las historias 3 y 4, probé mis códigos de muestra en 2 sistemas diferentes. Durante mis pruebas, noté que el espacio entre líneas de las oraciones era diferente.
Sistema 1: El espacio entre líneas parece normal. |
Sistema 2: El espacio entre líneas es demasiado. |
Primero, comparé las versiones de los programas que tienen la BUILD_HTML subrutina Dado que las fechas de la última actualización son diferentes, escaneé los códigos para ver cómo se generaron los códigos HTML. En el modo de depuración, agarré los códigos HTML generados. Como puede ver, los valores de «altura de línea» son diferentes.
<html><head></head>
<body bgcolor="#FFFFFF" scroll="auto">
<span style="line-height:1.75em;
font-size:11pt;
font-family:Tahoma, ARIAL">
lorem ipsum
lorem ipsum
</span></body>
</html>
Sistema 1 (última modificación: 26.11.2018) |
<html><head></head>
<body bgcolor="#FFFFFF" scroll="auto">
<span style="line-height:34px;
font-size:11pt;
font-family:'Tahoma', 'ARIAL'">
<font color="#000000">
lorem ipsum
lorem ipsum
</span></body>
</html>
Sistema 1 (última modificación: 19.11.2020) |
Es importante saber que el espacio entre líneas puede diferir entre sistemas porque las historias aquí tratan de dividir el texto en oraciones y comenzar en nuevas líneas. Y el espacio entre líneas afecta la cantidad de líneas que podemos mostrar en una ventana emergente.
💡 Obtenemos un mejor resultado si tenemos más control sobre el módulo de funciones.
Historia 3: Dividir texto largo en oraciones de 48 caracteres de ancho y comenzarlas en nuevas líneas
Me gustaría mostrar el siguiente texto largo en una ventana emergente, pero cada oración debe comenzar en una nueva línea:
Hola módulo de función POPUP_TO_CONFIRM. ¿Podría mostrar este mensaje? ¡Pero cada oración debe comenzar en una nueva línea! Hay algunas limitaciones, ¡pero sé que puedes! Incluso puede mostrar una oración más.
Si le pasamos este texto a la función, la salida será:
Sistema 1: altura de línea: 1,75 em |
Sistema 2: altura de línea: 34px |
Como sabemos el ancho máximo del texto solo puede ser de 48 o 57 caracteres (el primero parte de esta serie de blogs explica esto)sigamos con eso e intentemos mostrar el mensaje de la siguiente manera:
Hola módulo de función POPUP_TO_CONFIRM.
¿Podría mostrar este mensaje?
¡Pero cada oración debe comenzar en una nueva línea!
Hay algunas limitaciones, ¡pero sé que puedes!
Incluso puede mostrar una oración más.
Está bien, pero ¿cómo podemos hacer esto?
Mi plan es dividir el texto en segmentos, agregar los espacios necesarios al final de cada uno y luego concatenarlos nuevamente. El módulo de función se encarga del resto (Ojalá).
Pero tenemos un problema.
⚠️ Problema del Sr. y la Sra. BrownDado que los signos finales (puntuación) que determinan el final de una oración no se usan solo al final (como en el ejemplo del Sr. y la Sra. Brown), crearé un texto de oraciones separadas por un carácter de «nueva línea» en este historia. |
OK, identificar una oración completa es otra historia. Ejecutemos el plan. Aquí está la receta:
| Paso | Descripción |
| Paso 1 | Construye un texto combinando 5 oraciones con un carácter de nueva línea entre ellas. Dado que no usamos un botón definido por el usuario, cada oración puede tener hasta 48 caracteres. |
| Paso 2 | Divida el texto en segmentos por caracteres de «nueva línea». |
| Paso 3 |
Agregue el número requerido de espacios al final de cada segmento para completar hasta 48 caracteres. Luego agregue el segmento al final del texto. (i) Debe haber al menos un espacio entre oraciones. De lo contrario, la última palabra de la oración actual y la primera palabra de la oración siguiente se pueden considerar como una sola palabra. |
| Paso 4 |
Agregue un carácter invisible para conservar los espacios finales al final del texto. Si no agregamos ningún carácter que no sea un espacio, se ignorarán/eliminarán. (Aquí nuevamente, opto por usar el carácter de nueva línea). Cuando fusionamos todos los segmentos (oraciones), habrá un número diferente de espacios entre ellos en el texto final. |
| Paso 5 | Llame al módulo de función con el texto manipulado. |
La siguiente tabla muestra el número de espacios que necesitamos agregar para las oraciones en nuestro ejemplo.
| Frase | Longitud de la oración | Longitud máxima por línea |
Número de espacios para agregar |
| Hola módulo de función POPUP_TO_CONFIRM. | 39 | 48 | 9 |
| ¿Podría mostrar este mensaje? | 38 | 48 | 10 |
| ¡Pero cada oración debe comenzar en una nueva línea! | 44 | 48 | 4 |
| Hay algunas limitaciones, ¡pero sé que puedes! | 48 | 48 | 0 → See paso 3(i) |
| Incluso puede mostrar una oración más. | 39 | 48 | 9 |
Historia 3: Diagrama de flujo
Tengo la intención de mostrar «programa de llamada» y «programa llamado» en el mismo código fuente. Por lo tanto, considere el paso 1 como el «programa de llamada» que prepara el texto de la pregunta, y los siguientes pasos como el «programa de llamada» que toma el texto y lo envía al módulo de funciones después de manipularlo.
📄 Código:
*--------------------------------------------------------------------*
* Anatomy of a Function Module: POPUP_TO_CONFIRM - Part 3
*
* Story 3: Splitting Long Text into 48-Character-Wide Sentences and
* Starting Them on New Lines
*--------------------------------------------------------------------*
REPORT sy-repid.
CONSTANTS: newline VALUE cl_abap_char_utilities=>newline,
maxlen TYPE i VALUE 48.
DATA: question TYPE string,
answer(1).
*--------------------------------------------------------------------*
* Step 1:
* Build a text by combining 5 sentences with a newline character
* between them. Since we do not use a user-defined button, each
* sentence can be up to 48 characters long.
*--------------------------------------------------------------------*
question &&=:
|Hello POPUP_TO_CONFIRM function module.| , newline,
|Could you please display this message?| , newline,
|But every sentence must start on a new line!| , newline,
|There are a few limitations, but I know you can!| , newline,
|You can even display one more sentence.| , newline.
*--------------------------------------------------------------------*
* Step 2:
* Split the text into segments by newline characters.
*--------------------------------------------------------------------*
SPLIT question AT newline INTO TABLE DATA(segments).
CLEAR question.
*--------------------------------------------------------------------*
* Step 3:
* Add the required number of spaces at the end of each segment to
* complete up to 48 characters. Then append the segment to the end
* of the text.
* (i) There must be at least one space between sentences. Otherwise,
* the last word of the current sentence and the first word of the next
* sentence can be considered as a single word.
*--------------------------------------------------------------------*
LOOP AT segments ASSIGNING FIELD-SYMBOL(<segment>).
DO COND #( WHEN strlen( <segment> ) EQ maxlen THEN 1 ELSE ( maxlen - strlen( <segment> ) ) ) TIMES.
<segment> &&= | |.
ENDDO.
question &&= <segment>.
ENDLOOP.
*--------------------------------------------------------------------*
* Step 4:
* Add an invisible character to preserve the trailing spaces at the
* very end of the text. If we do not add any character other than
* space, they will be ignored/removed. (Here again, I opt to use the
* newline character).
*--------------------------------------------------------------------*
question &&= newline.
*--------------------------------------------------------------------*
* Step 5:
* Call the function module with the manipulated text.
*--------------------------------------------------------------------*
CALL FUNCTION 'POPUP_TO_CONFIRM'
EXPORTING
text_question = question
IMPORTING
answer = answer
EXCEPTIONS
OTHERS = 2.
Sistema 1: altura de línea: 1,75 em |
Sistema 2: altura de línea: 34px |
Después de todo, el objetivo aquí era convencer el módulo de funciones. 🙂
Con el
QUESTION_TEXTy la lógica de «comenzar cada oración en una nueva línea», ¿cuántas oraciones podemos mostrar como máximo si todas las oraciones tienen 48 caracteres de ancho?
🧮 Desde que uso CL_ABAP_CHAR_UTILITIES=>NEWLINE como separador y su longitud es 1, aquí está la fórmula:
Longitud máxima del texto de la pregunta / (Longitud máxima del texto de salida + Longitud del separador)
400 / ( 48 + 1 ) = 8.163265306122449
Dado que usamos un carácter separador al construir el texto, podemos mostrar un máximo de 8 oraciones con una longitud de 48 caracteres. Si se escribe una mejor lógica que determina las terminaciones de las oraciones, el cálculo será diferente.
📄 Echa un vistazo a este código:
*--------------------------------------------------------------------*
* Anatomy of a Function Module: POPUP_TO_CONFIRM - Part 3
*
* Story 3: Splitting Long Text into 48-Character-Wide Sentences and
* Starting Them on New Lines
*--------------------------------------------------------------------*
REPORT sy-repid.
CONSTANTS: newline VALUE cl_abap_char_utilities=>newline,
maxlen TYPE i VALUE 48.
DATA: question TYPE string,
answer(1).
*--------------------------------------------------------------------*
* SELECTION-SCREEN
*--------------------------------------------------------------------*
PARAMETERS p_line01 TYPE c LENGTH 48 LOWER CASE DEFAULT 'This is the first sentence.'.
PARAMETERS p_line02 TYPE c LENGTH 48 LOWER CASE DEFAULT 'This is the second sentence.'.
PARAMETERS p_line03 TYPE c LENGTH 48 LOWER CASE DEFAULT 'This is the third sentence.'.
PARAMETERS p_line04 TYPE c LENGTH 48 LOWER CASE DEFAULT 'This is the fourth sentence.'.
PARAMETERS p_line05 TYPE c LENGTH 48 LOWER CASE DEFAULT 'This is the fifth sentence.'.
PARAMETERS p_line06 TYPE c LENGTH 48 LOWER CASE DEFAULT 'This is the sixth sentence.'.
PARAMETERS p_line07 TYPE c LENGTH 48 LOWER CASE DEFAULT 'This is the seventh sentence.'.
PARAMETERS p_line08 TYPE c LENGTH 48 LOWER CASE DEFAULT 'This is the eigth sentence.'.
PARAMETERS p_line09 TYPE c LENGTH 48 LOWER CASE DEFAULT 'This is the nineth sentence.'.
"Start each sentence on a new line
PARAMETERS p_newlin TYPE xfeld.
*--------------------------------------------------------------------*
* START-OF-SELECTION
*--------------------------------------------------------------------*
START-OF-SELECTION.
DO 9 TIMES.
DATA(line) = 'P_LINE0' && sy-index.
ASSIGN (line) TO FIELD-SYMBOL(<line>).
IF <line> IS NOT INITIAL.
question &&=: <line>, COND #( WHEN p_newlin EQ abap_false THEN | | ELSE newline ).
ENDIF.
ENDDO.
SPLIT question AT newline INTO TABLE DATA(segments).
CLEAR question.
LOOP AT segments ASSIGNING FIELD-SYMBOL(<segment>).
DO COND #( WHEN strlen( <segment> ) EQ maxlen THEN 1 ELSE ( maxlen - strlen( <segment> ) ) ) TIMES.
<segment> &&= | |.
ENDDO.
question &&= <segment>.
ENDLOOP.
question &&= newline.
CALL FUNCTION 'POPUP_TO_CONFIRM'
EXPORTING
text_question = question
IMPORTING
answer = answer
EXCEPTIONS
OTHERS = 2.🖥️ Salida:
Sistema 1: altura de línea: 1,75 em Imagen superior: la nueva línea está desactivada |
Sistema 2: altura de línea: 34px Imagen superior: la nueva línea está desactivada |
Como puede ver, no hay suficiente espacio para la novena oración. Simplemente ingrese diferentes oraciones y ejecute el programa con modos de activación / desactivación de nueva línea para ver los resultados.
Historia 4: Dividir texto largo en oraciones de 57 caracteres de ancho y comenzarlas en nuevas líneas
Esta vez intentaré mostrar oraciones con una longitud máxima de 57 caracteres que comiencen en líneas nuevas. Por ejemplo:
La longitud de esta oración es exactamente cincuenta y siete caracteres.
Pero para que esto suceda, la ventana emergente debe ser un poco más ancha. Esto solo es posible si podemos habilitar el USER_DEFINED_F1_HELP botón para aparecer. La buena noticia es que no necesitamos proporcionar un valor que realmente exista. (Él primero parte de esta serie de blogs explica esto).
🧮 Primero, calculemos cuántas oraciones podemos mostrar:
Longitud máxima del texto de la pregunta / (Longitud máxima del texto de salida + Longitud del separador)
400 / ( 57 + 1 ) = 6,896551724137931
Dado que usamos un carácter separador al construir el texto, podemos mostrar un máximo de 6 oraciones con una longitud de 57 caracteres. Si se escribe una mejor lógica que determina las terminaciones de las oraciones, el cálculo será diferente.
📄 Aquí está el código:
*--------------------------------------------------------------------*
* Anatomy of a Function Module: POPUP_TO_CONFIRM - Part 3
*
* Story 4: Splitting Long Text into 57-Character-Wide Sentences and
* Starting Them on New Lines
*--------------------------------------------------------------------*
REPORT sy-repid.
CONSTANTS: newline VALUE cl_abap_char_utilities=>newline,
maxlen TYPE i VALUE 57.
DATA: question TYPE string,
answer(1).
DO 7 TIMES.
question &&=: 'The length of this sentence is exactly fifty-seven chars.', newline.
ENDDO.
SPLIT question AT newline INTO TABLE DATA(segments).
CLEAR question.
LOOP AT segments ASSIGNING FIELD-SYMBOL(<segment>).
DO COND #( WHEN strlen( <segment> ) EQ maxlen THEN 1 ELSE ( maxlen - strlen( <segment> ) ) ) TIMES.
<segment> &&= | |.
ENDDO.
question &&= <segment>.
ENDLOOP.
question &&= newline.
CALL FUNCTION 'POPUP_TO_CONFIRM'
EXPORTING
text_question = question
userdefined_f1_help = '_' "Displaying this button increases the width of the popup window.
IMPORTING
answer = answer
EXCEPTIONS
OTHERS = 2.🖥️ Salida:
|
Sistema 1: altura de línea: 1,75 em |
Sistema 2: altura de línea: 34px |
Como puede ver, la ventana es más ancha, se pueden mostrar 11 caracteres adicionales. El único efecto secundario de mostrar el USER_DEFINED_F1_HELP botón con un valor que en realidad no existe es que se muestra el siguiente mensaje cuando el usuario hace clic en ese botón.
No hay documentación definida por el usuario disponible |
Conclusión
En esta publicación de blog, aprendió cómo dividir un texto largo en oraciones de 48 o 57 caracteres de ancho y mostrar esas oraciones en una ventana emergente, comenzando en nuevas líneas. También aprendió que hay una limitación de longitud cuando se usa el QUESTION_TEXT parámetro.
Puede ser útil usar esa lógica en los casos en que la longitud de las oraciones no supere los 48 o 57 caracteres.
Los ejemplos de las historias 3 y 4 utilizan el carácter de nueva línea como separador. En los programas reales, las oraciones deben determinarse verificando las marcas finales (o la puntuación final). Para lograr esto, el «Señor. y la Sra. Brown Problema” primero debe ser resuelto.
¿Próximo paso?
Entonces, se completó la «Operación 48/57». Las siguientes historias serán contadas en el último capítulo de la serie:
- Historia 5: Mostrar una lista con viñetas en el texto
- Historia 6: Mostrar texto más largo usando un objeto de documento
Nos vemos en el último capítulo.
Para obtener más recursos sobre ABAP Development, puede visitar Página de tema de desarrollo ABAPhaga preguntas o siga una publicación de blog sobre ABAP Development aquí.
Por favor, siga mi perfil para futuras publicaciones y siéntase libre de compartir sus comentarios o pensamientos en un comentario.
Marcas registradas
• SAP®, ABAP® son marcas comerciales o marcas comerciales registradas de SAP SE o sus filiales en Alemania y en otros países.
Descargo de responsabilidad
Todo el código fuente disponible en esta publicación de blog se proporciona «tal cual» sin garantía de ningún tipo, y cualquier uso de dicho código fuente es bajo su propio riesgo.
