A continuación tienes el vídeo de la conferencia donde se hace una demostración práctica de desarrollo de una aplicación de pedidos en una hora. (Sube el volumen al máximo para escucharla bien)

Para conseguir sólo tenemos que realizar la siguiente configuración:

En la sección

En el control de texto

Multilíneas: Si es verdadero el control imprimirá más de una línea, lo necesario para imprimir todo el texto.

Altura variable: Si es verdadero el control de texto crecerá en altura lo que sea necesario para imprimir todo el texto.

Puede partirse: Si es verdadero el control de texto seguirá creciendo en las páginas siguiente partiéndose en cada página para continuar en la siguiente página en la línea donde había quedado anteriormente la impresión.

El resultado

Al visualizar el informe o imprimirlo en PDF obtendremos informes que incluirán las páginas necesarias para imprimir todo el contenido de los campos objeto texto.

¿Qué es vJavaScript?

 
vJavaScript es la implementación realizada en Velneo sobre el lenguaje de programación JavaScript al que se le han añadido un conjunto de clases que aportan objetos y funciones adicionales para obtener una integración completa en la plataforma de desarrollo de aplicaciones empresariales Velneo V7.

VApp

 
Este objeto representa a la aplicacion. Dispone de funciones para ver información de sus proyectos, acceso a variables globales y utilidades de base de datos. En el blog del vArquitecto encontrarás la información detallada sobre este objetos y sus funciones “Objeto VApp para vJavaScript“.

Funciones

 
Están combinadas parejas de funciones por equivalencia de uso de datos para almacenamiento y lectura de las variables globales.

Variable global alfabética

 
void setVarGlobal( String szIdRefVar, String szValue ); Almacena un valor cadena en una variable global alfabética. String varGlobalToString( String szIdRefVar );Devuelve el valor de una variable global alfabética.

VApp.setVarGlobal("VEST_DAT/VJAVASCRIPT_STRING", "String") var resultado = VApp.varGlobalToString("VEST_DAT/VJAVASCRIPT_STRING");

VJAVASCRIPT_STRING es una variable global alfabética declarada en el proyecto de datos VEST_DAT.

Variable global numérica (con decimales y signo)

 
void setVarGlobal( String szIdRefVar, Number nValue ); Almacena un valor numérico en una variable global numérica. double varGlobalToDouble( String szIdRefVar );Devuelve el valor de una variable global numérica con formato Double.

VApp.setVarGlobal("VEST_DAT/VJAVASCRIPT_NUMBER", -9876543.21) var resultado = VApp.varGlobalToDouble("VEST_DAT/VJAVASCRIPT_NUMBER");

VJAVASCRIPT_NUMBER es una variable global numérica declarada en el proyecto de datos VEST_DAT. En el ejemplo se puede observar como se pasan valores con decimales y signo.

Variable global numérica (entero)

 
void setVarGlobal( String szIdRefVar, Number nValue ); Almacena un valor numérico en una variable global numérica. int varGlobalToInt( String szIdRefVar );Devuelve el valor de una variable global numérica con formato Int.

VApp.setVarGlobal("VEST_DAT/VJAVASCRIPT_NUMBER", 987654321) var resultado = VApp.varGlobalToInt("VEST_DAT/VJAVASCRIPT_NUMBER");

VJAVASCRIPT_NUMBER es una variable global numérica declarada en el proyecto de datos VEST_DAT. La función para almacenar valores numéricos es la misma tanto si es double, int o boolean.

Variable global booleana

 
void setVarGlobal( String szIdRefVar, Boolean bValue ); Almacena un valor 1 ó 0 en una variable global booleana. int varGlobalToInt( String szIdRefVar );Devuelve el valor de una variable global booleana.

VApp.setVarGlobal("VEST_DAT/VJAVASCRIPT_BOOLEAN", 1) var resultado = VApp.varGlobalToInt("VEST_DAT/VJAVASCRIPT_BOOLEAN");

VJAVASCRIPT_BOOLEAN es una variable global booleana declarada en el proyecto de datos VEST_DAT. La función para almacenar valores numéricos es la misma tanto si es double, int o boolean.

Variable global de tiempo

 
void setVarGlobal( String szIdRefVar, QDateTime dtValue ); Almacena un valor fecha y hora en una variable global de tiempo. QDateTime varGlobalToDateTime( String szIdRefVar );Devuelve el valor de una variable global de tiempo.

var fecha_hora_original = new Date(2012, 11, 31, 12, 34, 56, 123); VApp.setVarGlobal("VEST_DAT/VJAVASCRIPT_DATETIME", fecha_hora_original); var fecha_hora_devuelta = VApp.varGlobalToDateTime("VEST_DAT/VJAVASCRIPT_DATETIME");

VJAVASCRIPT_DATETIME es una variable global de tiempo declarada en el proyecto de datos VEST_DAT. Nota:En la función Date() de JavaScript el parámetro mes admite valores de (0=enero a 11=diciembre)

Variable global de fecha

 
void setVarGlobal( String szIdRefVar, QDate dValue ); Almacena un valor fecha en una variable global de fecha. QDate varGlobalToDate( String szIdRefVar );Devuelve el valor de una variable global de fecha.

var fecha_original = new Date(2012, 11, 31); VApp.setVarGlobal("VEST_DAT/VJAVASCRIPT_DATE", fecha_original); var fecha_devuelta = VApp.varGlobalToDate("VEST_DAT/VJAVASCRIPT_DATE");

VJAVASCRIPT_DATE es una variable global de fecha declarada en el proyecto de datos VEST_DAT. Nota:En la función Date() de JavaScript el parámetro mes admite valores de (0=enero a 11=diciembre)

Variable global de hora

 
void setVarGlobal( String szIdRefVar, QTime tValue ); Almacena un valor hora en una variable global de hora. QTime varGlobalToTime( String szIdRefVar );Devuelve el valor de una variable global de hora.

var hora_original = new Date(2012, 11, 31, 12, 34, 56, 000); VApp.setVarGlobal("VEST_DAT/VJAVASCRIPT_TIME", hora_original); var fecha_devuelta = VApp.varGlobalToTime("VEST_DAT/VJAVASCRIPT_TIME");

VJAVASCRIPT_TIME es una variable global de hora declarada en el proyecto de datos VEST_DAT.

Verificar si una variable global está vacía

 
Boolean varGlobalIsEmpty( String szIdRefVar );Devuelve el valor 1 sí la variable global está vacía y el valor 0 si tiene contenido.

var resultado = VApp.varGlobalIsEmpty("VEST_DAT/VJAVASCRIPT_STRING");

VJAVASCRIPT_STRING es una variable global alfabética declarada en el proyecto de datos VEST_DAT.

¿Qué es una prueba funcional?

 
Definición de Wikipedia: “Una prueba funcional es una prueba basada en la ejecución, revisión y retroalimentación de las funcionalidades previamente diseñadas para el software. Las pruebas funcionales se hacen mediante el diseño de modelos de prueba que buscan evaluar cada una de las opciones con las que cuenta el paquete informático.”

¿Qué es vEST?

 
vEST es el conjunto de aplicaciones y scripts que permiten realizar pruebas funcionales de Velneo V7 en distintos sistemas operativos y relacionado con el sistema de integración continua. Se distinguen pruebas funcionales de pruebas de interfaz debido a su distinto tratamiento. vEST sólo realiza comprobaciones de tareas sin interfaz.

¿Qué es vJavaScript?

 
vJavaScript es la implementación realizada en Velneo sobre el lenguaje de programación JavaScript al que se le han añadido un conjunto de clases que aportan objetos y funciones adicionales para obtener una integración completa en la plataforma de desarrollo de aplicaciones empresariales Velneo V7.

VTableInfo

 
Los objetos de esta clase contienen la información de la estructura de una tabla. Tiene funciones generales de la tabla, como ver su id o su tipo, y funciones para obtener información de sus subobjetos: campos, indices e históricos. También nos permite obtener otros VTablaInfo de las tablas enlazadas como maestros o históricos. En el blog del vArquitecto encontrarás la información detallada sobre esta clase y sus funciones “Class VTableInfo para vJavaScript“.

Testeo de las funciones

 
En vEST se ha incluido el testeo de un grupo de funciones de la clase VTableInfo. A continuación se muestran las capturas de los códigos de las pruebas que espero te puedan ayudar como material de consulta sobre la codificación de estas funciones.

vEST graba en la tabla LOG los resultados de las pruebas. Por ese motivo el script comienza abriendo la transacción en la que se incluirán las altas de los registros con los resultados de las pruebas. La tabla de entrada del proceso que ejecuta el script es precisamente la tabla LOG, es precisamente contra esta tabla contra la que se lanzarán las funciones.

Antes de ejecutar el script se crea un registro en blanco que utilizaremos para grabar los registros del LOG, por el momento y mientras no tengamos activas las funciones de crear registro en memoria lo que hace el script tras abrir la transacción es leer el registro (0), es decir, el primero de la tabla LOG con la función readLockingAt(0) por lo tanto el registro se lee en modo lectura/escritura, es decir con bloqueo lo que nos permite lanzar operaciones de base de datos contra dicho registro.

// ----------------------------------------------------------------------------------------------------
// TEST DE FUNCIONES VJAVASCRIPT
// CLASE VTableInfo
// ----------------------------------------------------------------------------------------------------
VRoot.openTrans("Alta en el log");
var registro = VRegisterListIn.readLockingAt(0);


Todos los testeos se realizan de la misma forma:

• 1º Se guarda en una variable el resultado de la ejecución de la función.
• 2º Se modifica el campo NAME de la tabla LOG con la descripción de la función testada.
• 3º Se modifica el campo RESULTADO de la tabla LOG con el resultado de la comparación del valor retornado por la función y la constante que contiene el resultado esperado.
• 4º Se añade el nuevo registro en la tabla LOG.

VTableInfo.id(): Devuelve el valor de la propiedad identificador de la tabla.

// ----------------------------------------------------------------------------------------------------
// VJS_TBI_001 - Tabla VTableInfo.id()
// ----------------------------------------------------------------------------------------------------
var resultado = VRegisterListIn.tableInfo().id();
registro.setField("NAME", "VJS_TBI_001 - Tabla VTableInfo.id()");
registro.setField("RESULTADO", String(resultado == "LOGS"));
registro.addRegister();


VTableInfo.name(): Devuelve el valor de la propiedad nombre plural de la tabla.

// ----------------------------------------------------------------------------------------------------
// VJS_TBI_002 - Tabla VTableInfo.name()
// ----------------------------------------------------------------------------------------------------
var resultado = VRegisterListIn.tableInfo().name();
registro.setField("NAME", "VJS_TBI_002 - Tabla VTableInfo.name()");
registro.setField("RESULTADO", String(resultado == "Logs"));
registro.addRegister();


VTableInfo.singleName(): Devuelve el valor de la propiedad nombre singular de la tabla.

// ----------------------------------------------------------------------------------------------------
// VJS_TBI_003 - Tabla VTableInfo.singleName()
// ----------------------------------------------------------------------------------------------------
var resultado = VRegisterListIn.tableInfo().singleName();
registro.setField("NAME", "VJS_TBI_003 - Tabla VTableInfo.singleName()");
registro.setField("RESULTADO", String(resultado == "Log"));
registro.addRegister();


VTableInfo.type(): Devuelve el valor de la propiedad tipo de tabla.

// ----------------------------------------------------------------------------------------------------
// VJS_TBI_004 - Tabla VTableInfo.type()
// ----------------------------------------------------------------------------------------------------
var resultado = VRegisterListIn.tableInfo().type();
registro.setField("NAME", "VJS_TBI_004 - Tabla VTableInfo.type()");
registro.setField("RESULTADO", String(resultado == 0));
registro.addRegister();


VTableInfo.isInMemory(): Devuelve un 1 Si la tabla está definida con persistencia en memoria y un 0 si la tabla está definida con persistencia en disco.

// ----------------------------------------------------------------------------------------------------
// VJS_TBI_005 - Tabla VTableInfo.isInMemory()
// ----------------------------------------------------------------------------------------------------
var resultado = VRegisterListIn.tableInfo().isInMemory();
registro.setField("NAME", "VJS_TBI_005 - Tabla VTableInfo.isInMemory()");
registro.setField("RESULTADO", String(resultado == 0));
registro.addRegister();


VTableInfo.registerLength(): Devuelve el tamaño del registro de la tabla en bytes.

// ----------------------------------------------------------------------------------------------------
// VJS_TBI_006 - Tabla VTableInfo.registerLength()
// ----------------------------------------------------------------------------------------------------
var resultado = VRegisterListIn.tableInfo().registerLength();
registro.setField("NAME", "VJS_TBI_006 - Tabla VTableInfo.registerLength()");
registro.setField("RESULTADO", String(resultado == 142));
registro.addRegister();


VTableInfo.fieldCount(): Devuelve el número de campos de la tabla.

// ----------------------------------------------------------------------------------------------------
// VJS_TBI_007 - Campos VTableInfo.fieldCount()
// ----------------------------------------------------------------------------------------------------
var resultado = VRegisterListIn.tableInfo().fieldCount();
registro.setField("NAME", "VJS_TBI_007 - Campos VTableInfo.fieldCount()");
registro.setField("RESULTADO", String(resultado == 6));
registro.addRegister();


VTableInfo.fieldId(): Devuelve el valor de la propiedad identificador de un número de campo. Para evaluar esta función se hace un bucle concatenando el valor de la propiedad identificador de todos los campos de la tabla.

// ----------------------------------------------------------------------------------------------------
// VJS_TBI_008 - Campos VTableInfo.fieldId()
// ----------------------------------------------------------------------------------------------------
var resultado = ""
for (var x=0; x < VRegisterListIn.tableInfo().fieldCount(); x++)
{
var resultado = resultado + VRegisterListIn.tableInfo().fieldId(x) + " ";
}
registro.setField("NAME", "VJS_TBI_008 - Campos VTableInfo.fieldId()");
registro.setField("RESULTADO", String(resultado == "ID NAME RESULTADO EQUIPO TIEMPO VALOR "));
registro.addRegister();


VTableInfo.fieldName(): Devuelve el valor de la propiedad descripción de un número de campo. Para evaluar esta función se hace un bucle concatenando el valor de la propiedad descripción de todos los campos de la tabla.

// ----------------------------------------------------------------------------------------------------
// VJS_TBI_009 - Campos VTableInfo.fieldName()
// ----------------------------------------------------------------------------------------------------
var resultado = ""
for (var x=0; x < VRegisterListIn.tableInfo().fieldCount(); x++)
{
var resultado = resultado + VRegisterListIn.tableInfo().fieldName(x) + " ";
}
registro.setField("NAME", "VJS_TBI_009 - Campos VTableInfo.fieldName()");
registro.setField("RESULTADO", String(resultado == "Codigo Nombre Resultado Equipo TIEMPO Valor "));
registro.addRegister();


VTableInfo.fieldType(): Devuelve el tipo de campo de un número de campo. Para evaluar esta función se hace un bucle concatenando el valor del tipo de campo de todos los campos de la tabla.

// ----------------------------------------------------------------------------------------------------
// VJS_TBI_010 - Campos VTableInfo.fieldType()
// ----------------------------------------------------------------------------------------------------
var resultado = ""
for (var x=0; x < VRegisterListIn.tableInfo().fieldCount(); x++)
{
var resultado = resultado + VRegisterListIn.tableInfo().fieldType(x) + " ";
}
registro.setField("NAME", "VJS_TBI_010 - Campos VTableInfo.fieldType()");
registro.setField("RESULTADO", String(resultado == "6 1 10 3 9 6 "));
registro.addRegister();


Velneo vClient para Android
Este nuevo componente te permitirá ejecutar tus aplicaciones en el sistema operativo de mayor difusión para dispositivos móviles, Android de Google. Debes tener en cuenta que vClient para Android requiere la versión 2.2 ó superior de este sistema. Esta primera versión se encuentra en fase beta.

Interfaz

¡Nueva propiedad vista de datos en los controles de edición!
Esta propiedad se usa con campos puntero a tabla maestra denominada “Vista de datos de lista”. En esta propiedad se puede seleccionar cualquier objeto del grupo de “Vista de datos” con origen de la tabla maestra, incluido el alternador de lista. En ejecución cuando este campo gana foco si el usuario comienza a escribir un valor, además de realizarse el autocompletado, se abre el objeto de lista posicionándose en el registro seleccionado, de forma similar a como actúa el localizador. El objeto de lista es totalmente funcional permitiendo la selección de un registro, usar toolbars y las opciones del menú contextual. Cuando el campo tiene el foco, aunque no escriba el usuario siempre podrá desplegar la vista de datos con la tecla de función F4. Visualmente mejora al objeto localizador ya que evita abrir un cuadro de diálogo y ofrece un gran abanico de posibilidades tanto para la selección de registros como para la visualización de datos adicionales, ejecución de acciones, etc. (2562)

¡Nuevos comandos de Interfaz para la ventana principal!
Estos nuevos comando actúan sobre docks del objetos marco AUTOEXEC que contengan objetos de tipo formulario o cesta, para las toolbars se pueden usar los comandos (Interfaz: Ocultar e Interfaz: Mostrar). Con este grupo de comandos se puede interrogar si un dock está visible (Interfaz: ¿Es visible el dock?), saber si el dock está flotante (Interfaz: ¿Está el dock flotando?), actuar haciendo visible un dock (Interfaz: Mostrar el dock) u ocultando un dock (Interfaz: Ocultar el dock), también es posible poner un dock flotante (Interfaz: Set dock flotante) o configurar las características de un dock (Interfaz: set dock features) que permite hacer un dock cerrable, movible, flotable o hacer que la barra de título salga vertical. Gracias a estos nuevos comandos el programador tiene el control sobre los docks para que independientemente de como los gestione el usuario pueda forzar a que estén ocultos, visibles o con unas características concretas. (2679)

Alta de registros en rejilla con doble clic
Ahora haciendo doble clic en una zona del cuerpo de la rejilla que no tenga registros se lanza el formulario de alta que tenga asociado. (2313)

Recalcular vistas de datos en subformularios
Se han realizado mejoras en la ejecución del comando de instrucción “Interfaz: Recalcular” sobre controles “Vista de datos” de subformularios. (1077)

Controles de edición fecha y fecha/hora mejorados
Se han realizado mejoras en los controles de tipo “Edición Fecha” y “Edición Fecha/Hora”. Entre ellas ahora si se selecciona su contenido y se elimina, el campo, variable o variable local quedan vacíos y no con el valor “14/09/1752” que era el valor mínimo que asumía antes por defecto. (2780)

Orden alfabético en objeto árbol visor de tablas
Se ha mejorado el objeto árbol visor de tablas en el que ya es operativa la propiedad “Orden alfabético”. Tanto en la carga inicial como al ejecutar el comando “Interfaz: Recalcular”. (2789)

Refresco de control objeto dibujo de maestros
Se ha mejorado el refresco del control objeto dibujo que fallaba al mostrar una imagen de una tabla con una relación de segundo nivel, por ejemplo una imagen de un maestro de otro maestro del registro del formulario. (2037)

Icono de tabla estática en control objeto dibujo
Se ha mejorado el control “Objeto dibujo” de formulario que ahora permite mostrar el icono de una tabla estática, evitando que en ejecución sea editable la imagen con doble clic o el menú contextual que en este caso ni siquiera estará disponible. (2810)

Señal inicializado en objeto marco
Se ha mejorado la gestión de la señal de inicializado en el objeto marco para que se ejecute después de que se haga efectiva la configuración de ventana guardada de la anterior ejecución. De esta forma al usar los nuevos comandos de interfaz los docks quedarán como el programador lo haya configurado en el evento. (2726)

Formularios en modo vista
Se ha corregido que si en un formulario en modo “Vista” no tiene definido un tipo de layout, no mostraba los controles. En cuadro de diálogo o incrustado en un dock funcionaban correctamente aunque no tuviesen definido un tipo de layout. (2835)

Comando de instrucción disparar objeto sobre rejillas
Ahora al ejecutar el comando disparar objeto sobre una rejilla funciona de la siguiente forma: Si la rejilla no tiene declarado un formulario funciona de forma similar a un localizador, al hacer doble clic o pulsar intro se cierra y devuelve el registro seleccionado. Si tiene declarado un formulario de modificación, al hacer doble clic o pulsar intro abre el formulario de modificación, se cierra la rejilla y en el subproceso obtenemos el registro que ha sido mostrado en el formulario. (2807)

Recálculo automático de totales en pie de rejilla
Los cálculos por fórmula absoluta en el pie de las rejillas ahora se refrescan automáticamente al realizar operaciones que afectan a la lista como “Partir lista”, “Filtrar” y “Quitar el elemento seleccionado de la lista”. (1966 y 2821)

Varias rejillas editables en un formulario
Se han realizado mejoras para evitar problemas de operativa si en un mismo formulario se incrusta más de una rejilla editable. (2322)

Campos booleanos en rejilla
En una columna de rejilla ahora se muestra bien el valor de un campo de tipo “Booleano” de una tabla enlazada, antes mostraba siempre un 0 (cero). Se ha mejorado la visualización de los campos “booleanos” en rejilla para que se visualicen con texto y no como datos numéricos cuando se asigna el valor “Verdadero” a la propiedad “Formato numérico local”. (2047 y 2758)

Intro en rejilla
Se ha corregido la incidencia que se producía cuando en un formulario que incluye una rejilla en la que abrimos uno de sus registros pulsando la tecla Intro, al aceptar el formulario se cerraba a la vez el primer formulario, ahora sólo se cierra el formulario abierto desde la rejilla permaneciendo abierto el primer formulario. (2694)

Refresco de cestas en docks
Se ha mejorado el refresco automático de las cestas usadas en dock. (1986)

Ordenación y posicionamiento de docks tipo toolbar
Se ha mejorado la ordenación y posicionamiento de los docks tipo “Toolbar” que fallaba en algunos casos con el modo de aparecer “Añadir”. (1258)

Botón maximizar en cuadros de diálogo
Los cuadros de diálogo ahora tienen botón maximizar en Windows y Mac. En Windows también maximizan con doble clic en la barra de título. En modo tab sólo aparecerá el botón maximizar, en modo MDI el cuadro de diálogo tendrá los botones maximizar, minimizar y restaurar. (859)

Tecla Tab en casilleros
Del objeto casillero se ha quitado la navegación interna con la tecla “Tab”. (2805)

Cambio de contraseña
Se ha mejorado el diseño del cuadro de diálogo de cambio de contraseña en vDevelop y vClient. (2333)

Funcionalidad

Detener la ejecución de una cadena objetos en una acción
En una acción es posible encadenar múltiples objetos, al final siempre se devuelve el objeto u objetos de interfaz que se encadenan. Ahora es posible utilizar el comando de instrucción “Set retorno = NO” en cualquier proceso de la cadena objetos a ejecutar para detener la ejecución y evitar que sigan mostrando más objetos. Por ejemplo, ahora se puede lanzar una búsqueda que si no encuentra registros no visualice una rejilla vacía y sí que muestre un mensaje avisando de que la búsqueda no ha obtenido registros a mostrar. (2774)

Drag&Drop en Combo-View y List-View
Se ha añadido la posibilidad de realizar Drag&Drop en los objetos Combo-View y List-View. (2684)

Teclas aceleradoras “Return” y “Enter”
En la lista que aparece en la propiedad tecla aceleradora ahora aparecen las teclas “Return” que se refiere al teclado alfanumérico y también la tecla “Enter” que se refiere al teclado numérico. (2652)

Nuevo proceso ON_CLOSE_SERVER
Este proceso es análogo a ON_INIT_SERVER, se lanza siempre que sea detenida la ejecución de la instancia en el servidor bien porque se reinicie la instancia o porque se detenga el servidor. Hay que tener en cuenta que no se ejecutarán comandos que tengan interacción con la interfaz ya que se ejecuta en el servidor. Puede ser muy útil para guardar información o finalizar protocolos, por ejemplo. (2683)

Cargar lista en procesos en tercer plano
Se ha corregido una incidencia que se producía en la ejecución de procesos en tercer plano, en la que en algunas circunstancias la ejecución de el comando de instrucción “Cargar lista” no devolvía registros. (2762)

Cerrar ventana en cuadro de diálogo
El comando en stock “Ventana: cerrar” está pensado para usarlo con vista en modo MDI o Tab, es decir para vistas centrales, no está pensado para cuadros de diálogo. Aún así, se ha mejorado para que se pueda cerrar también una ventana en cuadro de diálogo. (2393)

Campo ID alfanumérico en tablas submaestras
Si en una tabla submaestra tenemos definido el campo ID de tipo alfanumérico ahora realizará la numeración automática como valor alfanumérico formateando el ID con ceros a la izquierda hasta completa el tamaño del campo. (2572)

Valor numérico en botón de radio (¡ATENCIÓN, MUY IMPORTANTE!)
En los controles de tipo “Botón de radio” ahora si la propiedad valor tiene un contenido numérico y el contenido del control es una variable declarada como numérica se puede utilizar como primer campo de una expresión obteniendo la suma, antes la variable recibía el valor como un dato alfanumérico y al sumarle cualquier valor lo concatenaba. ¡ATENCIÓN, MUY IMPORTANTE! Al final de este documento encontrará un texto explicando los efectos que la corrección de esta incidencia puede producir en sus aplicaciones si en ellas existe algún error en la definición del tipo de las variables globales o locales. (2760)

Funciones de conversión de códigos y caracteres ASCII
Se han corregido ya que no devolvían los valores correctos las funciones getAsciiChar, getAsciiCharCode y getLatin1CharCode. (2006 y 2856)

Ejecutar acciones desde formularios en Dock
Ahora ya están operativas las acciones disparadas desde controles de tipo “Botón” incrustados en un formulario que es usado desde un dock. (2775)

Comando de lista multipartir desde toolbar
Se ha mejorado la ejecución del comando “Lista: Multipartir” para que funcione correctamente y evite que rompa vClient cuando es ejecutado desde una toolbar asociada a una vista de datos en el momento de aceptar la ventana de selección de campo. (2128)

Opciones del menú de estilo
Al usar la opción de menú de selección de estilo, ahora muestra siempre las opciones, antes la primera vez que se lanzaba esa opción del menú no se mostraban. (2397)

Propiedades de las imágenes tras cortar
En el editor de imágenes, tras cortar una imagen si accedemos a la opción de propiedades ahora ya no se produce ningún error. (2497)

Los protocolos ya están operativos en 2º y 3º plano
Ya es posible poner a la escucha protocolos TCP en 2º y 3º plano. Esto permite arrancar un servicio TCP sin afectar al interfaz de la aplicación. Cuando se inicia en 2º plano, si no se programa su cierre lo hará automáticamente al finalizar el vClient como ocurre también en 1º plano, . En 3º plano el puerto seguirá a la escucha hasta que se termine el servicio con el comando de instrucción en un proceso en 3º plano o en el ON_CLOSE_SERVER, y también cuando se pare o reinicie el servicio vServer. (2816)

Valor de variables y altas de registros desde procesos en 3º plano
Se ha corregido la falta de visibilidad que ocurría con las variables globales y las altas de registros en la ejecución de procesos en tercer plano cuando se daban unas circunstancias particulares de herencias de proyectos, origen del proceso y la existencia de múltiples instancias sobre el proyecto heredado. Ahora el valor de las variables es accesible en todos los casos y las altas de registros se realizan correctamente en la instancia que corresponde. (2866)

Base de datos

¡Optimizaciones en la base de datos!
Se han mejorado las funciones internas de manejo de registros en la base de datos. Con estas mejoras se ha conseguido más velocidad al realizar ciertas operaciones. Esta mejora afecta a todas las operaciones de la base de datos que hagan uso de campos. (2783)

¡Optimizaciones en la regeneración de tablas!
Se han realizado mejoras en los procesos de regeneración de tablas que reducen notablemente el tiempo de procesamiento de las tablas durante la regeneración. Estas optimizaciones mejoran el rendimiento en todos los casos: tablas grandes, tablas pequeñas, registros con muchos campos, registros con pocos campos, etc. (2784)

Actualizaciones en tablas en memoria
Ya están disponibles las actualizaciones en las tablas en memoria, tanto de tabla en memoria a tabla en memoria como de tabla en memoria a tabla en disco. Esta funcionalidad facilita la programación de importaciones, cálculos estadísticos, cálculos para informes, etc. (661)

Refresco de plurales
Se ha mejorado el refresco de plurales para que se actualicen inmediatamente cuando se renombra una tabla o un índice. Esto evita tener que guardar el proyecto, salir y volver a entrar en vDevelop para ver los plurales actualizados. (2141)

Contenido inicial en campos fecha
En vDataClient se ha mejorado el cálculo del contenido inicial de campos tipo “Fecha” basados en una variable global. Al iniciar la edición del registro la fecha permanecerá vacía hasta que gane foco, si la variable global no tiene ningún valor la fecha asumirá como valor la del sistema. (1259)

Código de submaestras en memoria
En las tablas submaestras en memoria se ha corregido el cálculo del código, ID, siguiente al último que, en algunos casos, limitaba el número de registros que se podían dar de alta para cada registro de la tabla maestra. (2606)

Cambio de maestro en submaestras
Si tenemos una tabla histórica de una submaestra y en el formulario tenemos controles de edición de los campos punteros a la maestra y a la submaestra, si cambiamos el valor del campo de la maestra ahora se limpia el valor de la submaestra, salvo que tengo un contenido inicial, en cuyo caso se recalcula. Hasta ahora al cambiar la maestra no se alteraba el valor del campo puntero al ID de la submaestra. (2080)

Modificaciones de campos en evento
Se ha corregido que si en un formulario ejecutábamos un evento de interfaz que modificaba campos y usa el comando “Interfaz: Aceptar”, los campos editados en controles de edición de tipo: fecha, hora, fecha/hora y checkbox no se modificaban. (2116)

Reindexación por cambio de condición
Se ha mejorado la reindexación en operaciones de modificación de registros para que no permita la generación de claves duplicadas que sí podían producirse en el caso particular de que la modificación afectase a la condición de indexación y no al campo a indexar. (2654)

Regeneración de tablas al cambiar partes de un índice
Si modificabas las partes de un índice y, en lugar de ejecutar con F5 desde vDevelop, reiniciabas la instancia para ejecutar directamente con vClient la tabla no se regeneraba. Ahora la tabla se regenera en todos los casos. (594)

Administración

Mensaje de aviso si hay problemas de activación
En Windows Vista y en versiones posteriores de Windows, vActivator, si no se ejecuta como administrador, no graba las claves en el registro. Antes no se daba ningún aviso, ahora se muestra un mensaje notificando que no ha sido posible grabar las claves del registro por problemas de permisos, para que el usuario sea consciente de  la causa del problema de activación. (2528)

Permisos al renombrar carpeta compartida
Los permisos asignados a un grupo sobre una carpeta compartida, ahora ya no se pierden al renombrar la carpeta. (1149)

Seguridad en el borrado de carpetas compartidas
En vAdmin se ha añadido la verificación para que no permita borrar una carpeta compartida que esté siendo utilizada en una instancia. (1164)

Mejora de seguridad en la creación de directorios
En vAdmin, se ha eliminado el botón crear directorio de la ventana de creación o modificación de carpeta compartida para evitar que el usuario pueda crear cualquier directorio en el sistema operativo sin tener permisos. (2590)

Asignación de instancias a un grupo
En vAdmin se ha mejorado la asignación de instancias a un grupo de usuarios para que sea cómodo aunque existan un número elevado de instancias declaradas en el servidor. (2759)

Orden de los mensajes de sistema
Se ha mejorado en vAdmin el orden de presentación de los mensajes en el panel de mensajes del sistema para que se visualicen en el orden en que se generan ya que antes salían desordenados en algún caso. (1464)

Reducción de mensajes de sistema
En el visor de mensajes del sistema de vAdmin se han dejado de mostrar como mensaje de error, ya que no tienen la consideración de error, los siguientes mensajes: Run:KeyBusca -> errorFichaInexistente, Sys:MultiON -> errorTestigoEnganche, Run:FichaAlta -> errorKeyYaExiste. (2797)

Refresco de los datos de disco al instalar soluciones
En vAdmin al instalar una aplicación, cuando finaliza la instalación se refrescan automáticamente los datos en el menú “Disco”. (2776)

Instalaciones con ficheros adjuntos de tamaño 0 bytes
Se ha añadido la posibilidad de crear instalaciones de proyectos que contengan objetos del tipo “Fichero adjunto” con tamaño de 0 (cero) bytes, antes provocaban un error en la creación del instalable “.vin” con vInstallBuilder. (2119)

Tamaños recomendados de imágenes en la instalación
En el formulario de grabación de datos de la instalación de vInstallBuilder se han incluido en los textos de las imágenes el tamaño recomendado para el Logo (120×80 píxeles) y el Banner (145×315 píxeles). (2820)

Mejoras en la ejecución de opciones de menú
Ya no se produce ningún error en vDataClient si usamos las opciones “Regenerar datos” y “Regenerar índices” sin tener abierta ninguna solución. (2524)

Edición

Nuevos iconos de tamaño reducido para organizar los objetos del proyecto
En el árbol de carpetas y objetos de la pestaña proyecto se han mejorado los iconos reduciendo su tamaño a 16×16 ya que antes eran demasiado grandes. Además, se han incorporado 34 nuevos iconos para permitir una mayor combinación de tipos de carpetas a la hora de organizar los objetos.  Si modificas una carpeta con doble clic y accedes al cuadro de diálogo de propiedades, debes tener en cuenta que si borras el nombre de la carpeta, al seleccionar un nuevo icono de carpeta, por defecto, la carpeta asumirá el nombre que tenga la carpeta en la lista de iconos. Estas mejoras aportan una mayor usabilidad al árbol de carpetas y objetos del proyecto. (2819 y 2858)

Refresco de cambio de identificador en pestañas
Si cambias el identificador de un objeto que está siendo editado, al aceptar el cambio se actualiza la pestaña del editor con el nuevo identificador. (861)

Refresco en el árbol de propiedades
Se ha mejorado el refresco del árbol de propiedades para que cambie en todos los casos en función del objeto seleccionado en el inspector o de que el foco esté en un editor abierto en el área central. (862)

Copiar/pegar líneas de procesos
Cuando se copian líneas de instrucciones de un proceso a otro ahora las pega en el orden en que están en el proceso de origen y no en el orden en que se hizo la selección. (1309)

Selección de tablas por orden alfabético
En las propiedades que requieren la selección de una tabla ahora el combo muestra las tablas en orden alfabético lo que facilita la selección aunque haya tablas de múltiples proyectos ya que el combo se posiciona automáticamente al escribir caracteres del identificador de la tabla. (2756)

Pestañas móviles y ocultables
Las pestañas del explorador de proyectos (Solución y proyectos cargados) y las del Inspectores (Objetos, Qué usa, Dónde se usa, Campos y Errores) ahora son móviles lo que permite cambiarlas de posición. Además, las pestañas de los inspectores se pueden ocultar y mostrar utilizando el menú contextual que aparece al pulsar botón derecho de ratón sobre ellas. (2757)

Ayuda en galería de objetos
Al mostrar la galería de objetos, tecla de función F6, ahora por defecto se mostrará la vista de objetos agrupados por funcionalidad con la ayuda abierta a la derecha. (2587)

Ayuda actualizada
Se han actualizado las ayudas de la Galería de objetos. (2854)

Limpieza de propiedades de menú
En los objetos de lista si se modifica la propiedad “Tipo de menú de contexto” a los valores “Ninguno” o “Por defecto” se limpia la propiedad “Menú de contexto” que se activa cuando el tipo es “Personalizado”. De esta forma se evitan problemas en ejecución y con los inspectores. (2832)

Estabilidad en el cierre de vDevelop
Se ha mejorado la estabilidad de vDevelop cuando se cierra teniendo en edición alguna propiedad del árbol. Esto sólo se producía con algunos tipos de propiedades y en esos casos antes se producía un cierre no controlado del editor. (2815)

• Las dos primeras jornadas estarán repletas de interesantes seminarios cuyo contenido seguro que te puede interesar.
• En la tarde del jueves se celebrará el examen del que saldrá la primera remesa de desarrolladores certificados Velneo V7.
• El viernes podremos asistir al gran evento de software empresarial donde contaremos con magníficas ponencias que nos aportaran información interesante y motivadora sobre el negocio del software empresarial.

Contenido de los seminarios

Velneo ha recopilado a los mejores ponentes y ha organizado unos seminarios que esperamos sean de gran interés por la diversidad y alto nivel técnico de sus contenidos. Un numeroso grupos de ponentes nos ayudarán a conocer a fondo técnicas de programación y tecnologías relacionadas con el desarrollo de aplicaciones con Velneo V7  que con seguridad nos resultarán de interés y que podremos usar en 2012.

• ¿Te gustaría conocer en primicia las novedades en las que Velneo lleva trabajando mucho tiempo y que verán la luz en 2012 de la mano del vArquitecto, Juan Muñoz-Cobos?
• ¿Quieres conocer directamente del equipo de desarrollo de Velneo V7 las novedades presentadas en la versión 7.8.
• ¿Estás interesado en desplegar tus aplicaciones en Tablets Android?
• ¿Te interesa conocer como integrar tus bases de datos con aplicaciones que corren en iOS?
• ¿Te interesa la presentación de las Open Apps oficiales vConta y vERP?
• ¿Quieres aprender a integrar gráficos dinámicos en tus aplicaciones mediante jquery?
• ¿Quieres conocer como integrar una solución de mensajería en tus aplicaciones?
• ¿Te gustaría conocerlo todo sobre como  aplicar CSS para cambiar la interfaz de tus aplicaciones sin reprogramar?
• ¿Has oído hablar de QML? En Velneo creemos que es algo que debes conocer ¿Quieres recibir un primer curso sobre QML y conocer su potencia y posibilidades?
• ¿Estás buscando una solución web de integración con un CMS como Drupal? ¿Sabes lo que te puede aportar?
• ¿Te interesa poder dar salida web a tus aplicaciones de forma sencilla o integrar una cesta de la compra integrada con tu base de datos en soluciones web?

Las respuestas a estas preguntas las encontrarás en los seminarios que se celebrarán los días 9 y 10 en el evento Life is soft. Las plazas son limitadas. Si estás interesado, regístrate ahora.

• El miércoles 9 y en la mañana del jueves 10 se celebrarán unos interesantísimos seminarios donde podrás obtener la mejor y más actualizada información sobre tecnologías y software Velneo, directamente de personal de Velneo y de los mejores ponentes en cada área.

• El jueves por la tarde tendrá lugar el primer examen del que saldrá la primera remesa de desarrolladores certificados. Sin duda, una gran oportunidad para pertenecer al que será un grupo de referencia para toda la comunidad y las empresas que buscan software desarrollado con Velneo.

• La tercera jornada del viernes será el colofón final de estas jornadas  y tendremos un gran evento en un marco incomparable como es el teatro de la Universidad Laboral de Gijón. En este evento contaremos con unos magníficos ponentes que nos darán una visión actual y motivadora de diferentes áreas relacionadas con el sector empresarial del software.

¿Me puede interesar certificarme?

Si tu negocio está basado en la tecnología Velneo V7, estar certificado supondrá formar parte de un grupo reconocido de desarrolladores que se convertirán en referencia dentro de la comunidad y, que podrán aprovechar las nuevas oportunidades de negocio que se podrán presentar.

¿Tengo que estudiar? ¿Qué requisitos debo cumplir?

El objetivo del examen es que demuestres tu experiencia en el desarrollo de aplicaciones empresariales con Velneo V7, pero no tendrás que aprender nada de memoria. No se trata de eso, sino de todo lo contrario, el examen está basado en preguntas que cualquier desarrollador que programa habitualmente con Velneo V7 sabrá responder, por su experiencia o sabrá encontrar la respuesta apoyándose en el uso de la plataforma o de obtener la información en la ayuda de la web. Es decir, realizarás el examen usando la  aplicación vExamen con tu portátil, por lo que podrás abrir los componentes de la plataforma o consultar la ayuda de la web para ayudarte a obtener respuestas. Para programar bien no necesitas saber las cosas de memoria, sino saber donde las puedes encontrar.  Además, las preguntas están orientadas hacia el desarrollo de aplicaciones y tienen una clara orientación práctica.

¿Si no me certifico ahora cuándo podré hacerlo?

Actualmente se contempla un examen de certificación al año coincidiendo con el evento Life is soft. Si hubiese una demanda suficiente durante el año se podría plantear otro examen de certificación, en caso contrario tendrías que esperar hasta finales de 2012 para poder convertirte en un desarrollador certificado en Velneo V7.

¿Qué obtengo si consigo certificarme?

En primer lugar obtendrás un reconocimiento que podrás hacer público en forma de sello, tanto en tus tarjetas personales, como en tu web, blog, etc. En segundo lugar formarás parte de la lista de desarrolladores certificados que estarán publicados en la web de Velneo.

¿Vivo fuera de España me puedo certificar?

A finales de noviembre Velneo ha organizado un evento de 3 días en Colombia. En este enlace podrás consultar más información sobre las vJornadas en Bogotá entre las que se celebrará el examen de certificación para los desarrolladores de LatAm que puedan acudir.

¿Estoy a tiempo de registrarme?

Sí, todavía quedan plazas libres, sin embargo en los últimos días se ha notado un importante incremento en el número de desarrolladores que se han registrado para la certificación. Si tienes previsto certificarte este año, no esperes más y regístrate ahora.

Si tienes dudas sobre el proceso de certificación ponte en contacto con Velneo o consulta la página oficial sobre la certificación de desarrollador Velneo V7.