Manual de scripts

 Manual de scripts
Velneo V7 7.10
Scripts
Descripción
Velneo V7 ha integrado en el núcleo de su plataforma la ejecución de scripts. Esto supone una apertura de la plataforma a estándares como EcmaScript
y a otros lenguajes de programación como QML y JavaScript. Esta integración es completa y se puede apreciar en múltiples ámbitos de trabajo como
procesos o fórmulas. Para conseguir esta integración se ha desarrollado un completo API que incluye un conjunto de clases que aportan objetos y
funciones adicionales para facilitar el uso de objetos Velneo V7 y nuevos objetos en estos lenguajes.
Clases
Directorio de scripts
Editor de scripts
Lenguajes
Clases
Clases
Descripción
Para conseguir la integración de Velneo V7 con múltiples lenguajes se ha desarrollado un completo API que incluye un conjunto de clases que aportan
objetos y funciones adicionales para facilitar el uso de objetos V7 y de nuevos objetos en estos lenguajes.
API
El API de Velneo V7 para scripts contempla las siguientes clases:
Lista de clases
Clases de info de V7
VProjectInfo
VObjectInfo
VTableInfo
Clases de ventana
VMainWindow
VMdiView
Clases de entorno de ejecución
VApp
VRoot
Clases de datos
VRegister
VRegisterList
VQuery
Clases de disco
VDir
VFile
VFileInfo
VTextFile
VXmlWriter
Funciones
Funciones globales
Clase
VProjectInfo
VProjectInfo
Descripción
Este objeto contiene la información de un proyecto. Tiene funciones para obtener sus propiedades básicas, sus tablas, sus objetos y los proyectos de los
que hereda.
Las funciones de tablas y de objetos que empiezan por “all” nos devuelven todas sus tablas u objetos, incluyendo las de sus proyectos heredados. Las
otras solo las suyas propias.
Funciones
Funciones generales
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Devuelve el identificador del proyecto
String id()
// Devuelve el alias del proyecto
String alias()
// Devuelve el tipo de proyecto (ver enumeraciones)
Number type()
// Devuelve el nombre del proyecto
String name()
// Devuelve la versión del proyecto
String version()
// Devuelve la fecha y hora de último cambio del proyecto
Date saved()
// Devuelve el número de historia del proyecto
Number history()
Funciones de tablas
1
2
3
4
5
6
7
8
9
10
11
12
13
// Devuelve el número de tablas del proyecto de datos
Number tableCount()
// Devuelve el objeto VTableInfo de una tabla
// ‐ szIdPrimeroTabla = Identificador de una tabla
VTableInfo tableInfo( String szIdPrimarioTabla )
// Devuelve el objeto VTableInfo de una tabla
// ‐ nIndex es el nº ordinal de la tabla en el proyecto de datos
VTableInfo tableInfo( Number nIndex )
// Devuelve el número total de tablas de todos los proyectos (incluidos los heredados)
Number allTableCount()
14
15
16
17
// Devuelve el objeto VTableInfo de una tabla
// ‐ nIndex es el nº ordinal de la tabla entre todas las tablas de todos los proyectos
VTableInfo allTableInfo( Number nIndex )
Funciones de objetos
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// Devuelve el número de objetos de un tipo
// Esta función incluye sólo el proyecto en curso
// ‐ nObjectType = Tipo de objeto (ver enumeración en la clase ObjectInfo)
Number objectCount( Number nObjectType )
// Devuelve un objeto ObjectInfo de un tipo y del número de orden de la lista
// Esta función incluye sólo el proyecto en curso
// ‐ nObjectType = Tipo de objeto (ver enumeración en la clase ObjectInfo)
// ‐ nObjectIndex = Número de orden del objeto en la lista de objetos de ese tipo VObjectInfo objectInfo( Number nObjectType, Number nObjectIndex )
// Devuelve un objeto ObjectInfo del proyecto en curso de un tipo y un identificador
// Esta función incluye sólo el proyecto en curso
// ‐ nObjectType = Tipo de objeto (ver enumeración en la clase ObjectInfo)
// ‐ szIdPrimario = Identificador del objeto VObjectInfo objectInfo( Number nObjectType, String szIdPrimario )
// Devuelve el número de objetos de un determinado tipo
// Esta función incluye objetos de todos los proyectos (incluidos los heredados)
// ‐ nObjectType = Tipo de objeto (ver enumeración en la clase ObjectInfo)
Number allObjectCount( Number nObjectType )
21
22
23
24
25
26
27
Number allObjectCount( Number nObjectType )
// Devuelve un objeto ObjectInfo de un tipo y un identificador
// Esta función incluye objetos de todos los proyectos (incluidos los heredados)
// ‐ nObjectType = Tipo de objeto (ver enumeración en la clase ObjectInfo)
// ‐ nObjectIndex = Número de orden del objeto en la lista de objetos de ese tipo
VObjectInfo allObjectInfo( Number nObjectType, Number nObjectIndex )
Funciones de herencia
1
2
3
4
5
6
// Devuelve el número de proyectos heredados del proyecto en curso
Number legacyProjectCount()
// Devuelve un objeto VProjectInfo
// ‐ nIndex = Número de orden del proyecto en la lista de proyectos heredados
VProjectInfo legacyProjectInfo( Number nIndex )
Enumeraciones
Enum de tipos de proyectos
1
2
TypeDat = 0 Proyecto de datos
TypeApp = 1 Proyecto de aplicación
Ejemplos
Ejemplo de funciones generales
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
////////////////////////////////////////////////////////////
// Mostrar los datos del proyecto en curso
var proyecto = theApp.mainProjectInfo();
var info = proyecto_datos( proyecto );
alert( "El proyecto principal tiene la siguiente información: \n\n" + "Id = " + info[0] + "\n" + "Alias = " + info[1] + "\n" + "Tipo = " + info[2] + "\n" + "Nombre = " + info[3] + "\n" + "Versión = " + info[4] + "\n" + "Ultimo cambio = " + info[5] + "\n" + "Nº historia = " + info[6] );
////////////////////////////////////////////////////////////
// Almacenar datos generales de un proyecto
// proyecto = Proyecto del que se extraerá la información
function proyecto_datos( proyecto )
{ var datos = new Array();
datos[0] = proyecto.id();
datos[1] = proyecto.alias();
datos[2] = proyecto.type();
datos[3] = proyecto.name();
datos[4] = proyecto.version();
datos[5] = proyecto.saved();
datos[6] = proyecto.history();
return( datos );
}
Ejemplo de funciones de objetos y de herencia
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
////////////////////////////////////////////////////////////
// Mostrar los datos de los proyectos heredados
var proyecto = theApp.mainProjectInfo();
var msg = "";
var resultado = proyectos_info( proyecto );
alert( msg, "Información de herencia" );
////////////////////////////////////////////////////////////
// Almacenar datos generales de un proyecto
// proyecto = Proyecto del que se extraerá la información
function proyectos_info( proyecto )
{ // Se compone el mensaje final a mostrar
msg += "Proyecto heredado: " + proyecto.name() + " (" + proyecto.alias() + ")" + "\n" + "Nº tablas: " + proyecto.objectCount( VObjectInfo.TypeTable) + "; " + "\n" + 19
20
21
22
23
24
25
26
27
28
29
30
31
32
"Nº tablas estáticas: " + proyecto.objectCount( VObjectInfo.TypeStaticTable) + "; " + "\n" + "Nº esquemas: " + proyecto.objectCount( VObjectInfo.TypeScheme) + "\n\n";
alert ( proyecto.name() );
// Se analiza si el proyecto tiene otros proyectos heredados
var num_pry_heredados = proyecto.legacyProjectCount();
// Por cada proyecto heredado se ejecuta la función de forma reentrante hasta procesar todos los proyectos
for ( var x=0; x<num_pry_heredados; x++ )
{
var proyecto_heredado = proyecto.legacyProjectInfo( x );
resultado = proyectos_info( proyecto_heredado );
}
}
Clase
VObjectInfo
VObjectInfo
Descripción
Los objetos de esta clase contienen la informacion de la estructura de un objeto V7.
Se pueden ver sus propiedades, tanto los datos que contienen como información de su nombre, tipo, tabla asociada (si tiene), tipo de objeto
referenciado, etc. Para obtener el valor que contiene una propiedad primero debemos mirar el tipo de dato para usar la funcion adecuada. Por ejemplo
si el tipo de dato es Uint16 usar la funcion propertyDataToInt( nProp )
También se pueden obtener otros VObjectInfo de sus subobjetos y de los objetos referenciados por sus propiedades.
Funciones
Funciones generales
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Devuelve el identificador de un objeto. Por ejemplo, "AUTOEXEC"
String id()
// Devuelve el identificador con referencia de un objeto. Por ejemplo, "VJS_APP/AUTOEXEC"
String idRef()
// Devuelve el nombre o descripción del objeto
// Si no le pasamos parámetros devuelvo el nombre del idioma en curso
// Si le resolvemos el idioma o el idioma y país nos devuelve del nombre para ese idioma y país
// ‐ nLenguaje = Código Qt del idioma
// ‐ nPais = Código Qt del país
String name()
String name( int nLenguaje, int nPais = 0 )
// Devuelve el código de tipo de objeto. Ver enum de tipos de objejos
Number type()
// Devuelve true si el objeto es una vista de datos
Boolean isDataView()
Funciones de entrada
1
2
3
4
5
// Devuelve el tipo de entrada. Ver enum de tipos de entrada/salida
Number inputType()
// Devuelve el objeto VTableInfo correspondiente a la tabla de entrada
VTableInfo inputTable()
Funciones de salida
1
// Devuelve el tipo de salida. Ver enum de tipos de entrada/salida
2
3
4
5
Number outputType()
// Devuelve el objeto VTableInfo correspondiente a la tabla de salida
VTableInfo outputTable()
Funciones de subobjetos
1
2
3
4
5
6
7
8
9
10
11
12
13
// Devuelve el número de subobjetos de un objeto de un tipo
// ‐ nSubType = Ver enum de tipos de objetos
Number subObjectCount( Number nSubType )
// Devuelve un objeto VObjectInfo de un subobjeto de un tipo y un identificador
// nSubType = Ver enum de tipos de objetos
// ‐ szIdSubObject = Identificador del subobjeto
VObjectInfo subObjectInfo( Number nSubType, String szIdSubObject )
// Devuelve un objeto VObjectInfo de un subobjeto de un tipo y un número de orden del subobjeto
// ‐ nSubType = Ver enum de tipos de objetos
// ‐ szIdSubObject = Número de orden del subobjeto en la lista
VObjectInfo subObjectInfo( Number nSubType, Number nSubObject )
Enumeraciones
Enum de tipo de entrada/salida
1
2
3
IONone = 0 Ninguno
IORecord = 1 Ficha
IOList = 2 Lista
Enum de tipos de objeto
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
TypeTable = 00 Tabla
TypeField = 01 Campo
TypeIndex = 02 Indice
TypeIndexPart = 03 ParteIndice
TypePluralBind = 04 Enlace plural
TypeUpdate = 05 Actualización
TypeUpdateComponent = 06 Componente de actualización
TypeVariable = 09 Variable
TypeStaticTable = 10 Tabla estática
TypeStaticTableItem = 11 Ítem de tabla estática
TypeTrigger = 12 Trigger
TypePicture = 13 Dibujo
TypeGrid = 14 Rejilla
TypeGridCol = 15 Columna de rejilla
TypeTree = 16 Árbol
TypeCasillero = 17 Casillero
TypeForm = 18 Formulario
TypeControl = 19 Control de formulario
TypeSubcontrol = 20 Subcontrol de formulario
TypeMultiView = 21 MultiVista
TypeLogicPrinter = 22 Impresora lógica
TypeReport = 23 Informe
TypeReportSection = 24 Sección de informe
TypeReportControl = 25 Control de informe
TypeReportGrouping = 26 Agrupamiento de informe
TypeReportCalcution = 27 Cálculo de informe
TypeQuery = 28 Búsqueda
TypeQueryComponent = 29 Componente de búsqueda
TypeFilterGlass = 30 Lupa
TypeFinder = 31 Localizador
TypeFinderIndex = 32 Indice del localizador
TypeBasket = 33 Cesta
TypeProcess = 34 Proceso
TypeFunction = 35 Función
TypeEventConnection = 37 Conexión de evento
TypeEventSlot = 38 Manejador de evento
TypeInstruction = 39 Instrucción de proceso
TypeDll = 40 Dll
TypeAction = 41 Acción
TypeMenu = 42 Menú
TypeToolbar = 43 Toolbar
TypeActionLauncher = 44 Lanzador de acción
TypeListPipe = 45 Tubo de lista
TypeRecordPipe = 46 Tubo de ficha
TypeTcpProtocol = 47 Protocolo TCP
TypeConstant = 51 Constante
TypeFrame = 52 Marco
TypeDock = 53 Dock
TypeFormBlock = 54 Bloc de formularios
TypeDrop = 55 Drop
TypeQueue = 56 Cola de procesos
TypeScheme = 57 Esquema
TypeSchemeItem = 58 Item de esquema
TypeDllFunction = 60 Función Dll
TypeInsertion = 61 Insertar en
TypeSerialPort = 62 Dispositivo serie
TypeDllFunctionParam = 63 Parámetro de función Dll
TypeAttachedFile = 64 Fichero adjunto
TypeSvgImage = 65 SVG
TypeSvgControl = 66 Control SVG
TypeSubindexator = 67 Subindexador
TypeIntercomunicator = 68 Intercomunicador del TCP
TypeStyleCondition = 69 Condición de estilo
TypeViewFlow = 70 ViewFlow
TypeListAlternator = 71 Alternador de lista
TypeComboView = 72 ComboView
TypeListView = 73 ListView
TypeQmlList = 74 Lista QML
TypeUserRole = 75 UserRole de QML
TypeAuxModel = 76 AuxModel de lista QML
TypeAdvancedGrid = 77 Rejilla
TypeAdvancedGridCol = 78 Columna de rejilla
TypeAdvancedGridBand = 79 Banda de cabecera de rejilla
TypeQmlForm = 80 Formulario QML
TypeNone = ‐1 No definido
Ejemplos
Ejemplo de información del objeto de la vista en curso
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
////////////////////////////////////////////////////////////
// Información del objeto de la vista en curso
// Se coge el root (objeto) de la vista en curso
var root = theMainWindow.currentView().root();
// Se crea el objeto VObjectInfo de la vista en curso
obj = root.objectInfo();
// Se muestra la información del objeto
msg = "El objeto en curso tiene la siguiente información:" + "\n\n" + "Id: " + obj.id() + "\n" + "IdRef: " + obj.idRef() + "\n" + "Name: " + obj.name() + "\n" + "Tipo: " + obj.type() + "\n" + "¿Es vista de datos? " + obj.isDataView() + "\n";
// Si tiene tabla asociada se añade al mensaje
if ( obj.inputTable().name() != "" )
msg += "\n" + "Tabla asociada: " + obj.inputTable().name() + "\n";
// Si tiene tabla destino se añade al mensaje
if ( obj.outputTable().name() != "" )
msg += "\n" + "Tabla destino: " + obj.outputTable().name() + "\n";
// Si es una rejilla se muestra el número de columnas
if ( obj.type() == VObjectInfo.TypeGrid )
msg += "\n" + "Es una rejilla y tiene " + obj.subObjectCount( 15 ) + " columnas";
// Mostrar la información
alert( msg );
Clase
VTableInfo
VTableInfo
Descripción
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, índices y enlaces plurales. También nos permite obtener otros VTablaInfo de las tablas
enlazadas como maestros o enlaces plurales.
Funciones
Funciones de tabla
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// Devuelve el identificador (Id) de la tabla
String id()
// Devuelve el idRef (Alias_Aplicación/Id_Tabla) de la tabla
String idRef()
// Devuelve el nombre plural de la tabla
String name()
// Devuelve el nombre plural de la tabla en el idioma configurado
// Si no se especifican valores asume el idioma en curso
// El código de país es opcional
// ‐ nLenguage = Código del idioma (Ver tabla de idiomas en documentación de Qt)
// ‐ nPais = Código del país (Ver tabla de idiomas en documentación de Qt)
String name( Number nLenguage, Number nPais = 0 )
// Devuelve el nombre singular de la tabla
String singleName()
// Devuelve el nombre singular de la tabla en el idioma configurado
// Si no se especifican valores asume el idioma en curso
// El código de país es opcional
// ‐ nLenguage = Código del idioma (Ver tabla de idiomas en documentación de Qt)
// ‐ nPais = Código del país (Ver tabla de idiomas en documentación de Qt)
String singleName( Number nLenguage, Number nPais = 0 )
// Devuelve el código de tipo de tabla
// Ver enum de tipos de tablas
Number type()
// Devuelve true si la tabla reside en memoria
Boolean isInMemory()
// Devuelve la longitud en bytes del registro de la tabla
Number registerLength()
Funciones de campos
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// Devuelve el número de campos del registro de la tabla
Number fieldCount()
// Devuelve el identificador (Id) del campo
// ‐ nCampo = Número de campo, el primero es el 0
String fieldId( Number nCampo )
// Nombre del campo
// ‐ nCampo = Número de campo, el primero es el 0
String fieldName( Number nCampo )
// Devuelve el tipo de campo
// Ver enum de tipos de campo
// ‐ nCampo = Número de campo, el primero es el 0
Number fieldType( Number nCampo )
// Devuelve el tipo de objeto de un campo objeto
// Ver enum de tipos de campos objeto
// ‐ nCampo = Número de campo, el primero es el 0
Number fieldObjectType( Number nCampo )
// Devuelve el tamaño en bytes de los caracteres que admite el buffer del campo
// Por ejemplo un campo Alfa40 de 2 bytes tiene un buffer 3 caracteres
// ‐ nCampo = Número de campo, el primero es el 0
Number fieldBufferLen( Number nCampo )
// Devuelve el nº de decimales de un campo numérico
// ‐ nCampo = Número de campo, el primero es el 0
Number fieldDecimals( Number nCampo )
// Devuelve true si el campo numérico es con signo
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
// Devuelve true si el campo numérico es con signo
// ‐ nCampo = Número de campo, el primero es el 0
Boolean fieldIsSigned( Number nCampo )
// Devuelve el valor mínimo de un campo numérico
// ‐ nCampo = Número de campo, el primero es el 0
Number fieldMinimumValue( Number nCampo )
// Devuelve el valor máximo de un campo numérico
// ‐ nCampo = Número de campo, el primero es el 0
Number fieldMaximumValue( Number nCampo )
// Devuelve el tipo de enlace del campo
// Ver enum de tipos de enlaces de campo
// ‐ nCampo = Número de campo, el primero es el 0
Number fieldBindType( Number nCampo )
// Devuelve el identificador (Id) de la tabla enlazada
// ‐ nCampo = Número de campo, el primero es el 0
String fieldBoundedTableId( Number nCampo )
// Devuelve un objeto de la clase VTableInfo de la tabla enlazada
VTableInfo fieldBoundedTableInfo( Number nPlural )
// Devuelve el identificar (Id) del campo padre de una tala submaestra
// ‐ nCampo = Número de campo, el primero es el 0
String fieldParentFieldId( Number nCampo )
// Devuelve el número de campo del campo padre de una tala submaestra
// ‐ nCampo = Número de campo, el primero es el 0
Number fieldParentFieldNumber( Number nCampo )
Funciones de índices
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Devuelve el número de índices de la tabla
Number indexCount()
// Devuelve el identificador del índice
// ‐ nIndex = Número de orden del índice, el primer valor es el 0
String indexId( Number nIndex )
// Devuelve el nombre del índice
// ‐ nIndex = Número de orden del índice, el primer valor es el 0
String indexName( Number nIndex )
// Devuelve el identificador del índice
// ‐ nIndex = Número de orden del índice, el primer valor es el 0
Number indexType( Number nIndex )
Funciones de enlaces plurales
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Devuelve el número de enlaces plurales de la tabla
Number pluralCount()
// Devuelve el identificador (Id) del plural
// ‐ nPlural = Número de orden del plural, el primero valor es el 0
String pluralId( Number nPlural )
// Devuelve el nombre del plural
// ‐ nPlural = Número de orden del plural, el primero valor es el 0
String pluralName( Number nPlural )
// Devuelve el identificador (Id) de la tabla enlazada (maestra)
// ‐ nPlural = Número de orden del plural, el primero valor es el 0
String pluralBoundedTableId( Number nPlural )
// Devuelve un objeto de la clase VTableInfo de la tabla enlazada (maestra)
// ‐ nPlural = Número de orden del plural, el primero valor es el 0
VTableInfo pluralBoundedTableInfo( Number nPlural )
// Devuelve el identificador (Id) del índice de la tabla enlazada (maestra)
// ‐ nPlural = Número de orden del plural, el primero valor es el 0
String pluralBoundedIndexId( Number nPlural )
// Devuelve un objeto de la clase VObjectInfo del índice de la tabla enlazada (maestra)
// ‐ nPlural = Número de orden del plural, el primero valor es el 0
VObjectInfo pluralBoundedIndexInfo( Number nPlural )
Funciones de localizadores por Id
1
2
3
4
5
6
7
8
// Devuelve el número de campo de un identificador
// ‐ szIdPrimarioCampo = Identificador del campo
Number findField( String szIDPrimarioCampo )
// Devuelve el número del índice de un identificador
// ‐ szIdPrimarioIndice = Identificador del índice
Number findIndex( String szIDPrimarioIndice )
9
10
11
// Devuelve el número del enlace plural de un identificador
// ‐ szIdPrimarioIndice = Identificador del enlace plural
Number findPlural( String szIDPrimarioHist )
Enumeraciones
Enum de tipos de tablas
1
2
3
4
TypeMaster = 0 Maestra
TypeHistorical = 1 Histórica
TypeMasterSub = 2 Submaestra
TypeMasterTree = 3 Arbolada
Enum de tipos de campo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
FieldTypeAlpha256 = 00 Alfa 256
FieldTypeAlpha128 = 01 Alfa 128
FieldTypeAlpha64 = 02 Alfa 64
FieldTypeAlpha40 = 03 Alfa 40
FieldTypeAlphaLatin1 = 04 Alfa Latin1
FieldTypeAlphaUtf16 = 05 Alfa Utf16
FieldTypeNumeric = 06 Numérico
FieldTypeDate = 07 Fecha
FieldTypeTime = 08 Hora
FieldTypeDateTime = 09 Tiempo (fecha y hora)
FieldTypeBool = 10 Booleano
FieldTypeObject = 11 Objeto
FieldTypeFormulaNumeric = 12 Fórmula numérica
FieldTypeFormulaAlfa = 13 Fórmula alfabética
FieldTypeFormulaDate = 14 Fórmula fecha
FieldTypeFormulaDateTime = 15 Fórmula tiempo (fecha y hora)
FieldTypeVirtualBind = 18 Puntero virtual
Enum de tipos de campos objeto
1
2
3
4
5
ObjectTypePicture = 0 Imagen
ObjectTypeText = 1 Texto
ObjectTypeRichText = 2 RichText (texto enriquecido)
ObjectTypeBinary = 3 Binario
ObjectTypeFormula = 4 Fórmula dinámica
Enum de tipos de enlaces de campo (bindType)
1
2
3
4
5
6
7
8
BindTypeNone = 0 Ninguno
BindTypeMaster = 1 Tabla maestra
BindTypeStatic = 2 Tabla estática
BindTypeIndirectReal = 3 Indirecto real
BindTypeIndirectVirtual = 4 Indirecto virtual
BindTypeSingularPluralPos = 5 Singular de plural por posición
BindTypeSingularPluralIndex = 6 Singular de plural por índice
BindTypeAdjacentSibling = 7 Hermano contiguo
Enum de tipos de índices
1
2
3
4
5
IndexTypeSingleKey = 0 Clave unica
IndexTypeWords = 1 Palabras
IndexTypeMultiKey = 2 Multiples claves
IndexTypeAcceptRepeat = 3 Acepta repetidas
IndexTypeWordParts = 4 Trozos de palabras
Ejemplos
Ejemplo de eliminación de todos los plurales de un registro de la tabla de entidades
1
2
3
4
5
6
7
8
9
10
11
12
////////////////////////////////////////////////////////////
// Eliminar todos los plurales de la tabla entidades de vbase
// Confirmar la eliminación de los plurales de la entidades
if ( confirm( "¿Desea eliminar todos los datos históricos de " + theRegisterIn.fieldToString( "NAME" ) + "?", { // Se crea la transacción
theRoot.beginTrans( "Eliminación de los plurales de " + theRegisterIn.fieldToString( "NAME" ) );
// Se analiza la tabla de entidades para recorrer sus plurales
ti = theRegisterIn.tableInfo();
numPlurales = ti.pluralCount();
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
numTotalReg = 0;
for ( x=0; x<numPlurales; ++x )
{
// Obtenemos el Id del plural
pluralId = ti.pluralId( x );
// Cargamos la lista de registro por ese plural
listaPlurales = theRegisterIn.loadPlurals( pluralId );
numReg = listaPlurales.size()
if ( numReg > 0 )
{
// Si la lista de plurales tiene registros se eliminan numTotalReg += numReg;
for ( y=0; y<numReg; ++y )
{
// Cogemos el registro plural
regPlural = listaPlurales.readLockingAt( y );
regPlural.deleteRegister();
}
}
}
// Se finaliza la transacción
theRoot.commitTrans();
alert( "Se han eliminado " + numTotalReg + " registros en " + numPlurales + " plurales" );
}
Clase
VMainWindow
VMainWindow
Descripción
Este objeto nos da acceso a las funciones de manejo de la ventana principal de la aplicación. Está disponible en procesos de scripts ejecutados en primer
plano.
Funciones
Funciones generales
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
// Devuelve el título de la ventana
String title()
// Cambia el título de la ventana
// ‐ szTitle = Texto del nuevo título de la ventana
void setTitle( String szTitle )
// Devuelve la hoja de estilo (CSS) que se está aplicando a la ventana
String styleSheet()
// Cambia la hoja de estilo (CSS) que se aplicará a la ventana
// ‐ szCssText = Texto con el CSS a aplicar
void setStyleSheet( String szCssText )
// Devuelve true si la ventana es visible
Boolean isVisible()
// Devuelve true si la ventana está a pantalla completa
Boolean isFullScreen()
// Devuelve true si la ventana está maximizada
Boolean isMaximized()
// Devuelve true si la ventana está minimizada
Boolean isMinimized()
// Muestra la ventana
void show()
// Oculta la ventana
void hide()
// Visualiza la ventana en modo a pantalla completa
void showFullScreen()
// Visualiza la ventana en modo maximizada
void showMaximized()
// Visualiza la ventana en modo minimizada
void showMinimized()
// Visualiza la ventana en modo normal
void showNormal()
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
// Devuelve la posición x de la ventana (esquina superior izquierda)
Number x()
// Devuelve la posición y de la ventana (esquina superior izquierda)
Number y()
// Devuelve el ancho en píxels de la ventana
Number width()
// Devuelve el alto en píxels de la ventana
Number height()
// Mueve la ventana a la posición especificada
// ‐ x = Posición horizontal en píxeles
// ‐ y = Posición vertical en píxeles
void move( Number x, Number y )
// Modifica el tamaño de la ventana
// ‐ nWidth = Ancho de la ventana en píxels
// ‐ nHeight = Alto de la ventana en píxels
void resize( Number nWidth, Number nHeight )
// Personaliza los botones y la barra de título de la ventana
// ‐ nFlags = Ver enum de personalización de la ventana (flags combinables) void customizeWindowHint( Number nFlags )
Funciones de docks
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// Devuelve true si el dock está visible
// ‐ szIdPrimarioDock = Identificador del dock
Boolean isDockVisible( String szIdPrimarioDock )
// Muestra el dock
// ‐ szIdPrimarioDock = Identificador del dock
void showDock( String szIdPrimarioDock )
// Oculta el dock
// ‐ szIdPrimarioDock = Identificador del dock
void hideDock( String szIdPrimarioDock )
// Devuelve true si el dock está flotante
// ‐ szIdPrimarioDock = Identificador del dock
Boolean isDockFloating( String szIdPrimarioDock )
// Fija el dock como flotante
// ‐ szIdPrimarioDock = Identificador del dock
// ‐ bSet = True para activarlo como flotante, false para desactivarlo como flotante
void setDockFloating( String szIdPrimarioDock, Boolean bSet )
// Modifica las características del dock
// ‐ szIdPrimarioDock = Identificador del dock
// ‐ nFeatures = Ver enum de features del dock (flags combinables)
void setDockFeatures( String szIdPrimarioDock, Number nFeatures )
Funciones de barra de menú
1
2
3
4
5
6
7
8
// Devuelve true si la barra de menú está visible
Boolean isMenuBarVisible()
// Muestra la barra de menú
void showMenuBar()
// Oculta la barra de menú
void hideMenuBar()
Funciones de acciones
1
2
3
// Ejecuta una acción (de cualquier proyecto)
// ‐ szIdRefAction = IdRef de una acción (proyecto/identificado), ejemplo: "VJS_APP/VDIR"
void runAction( String szIdRefAction )
Funciones de barra de estado
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Devuelve true si la barra de estado está visible
Boolean isStatusBarVisible()
// Muestra la barra de estado
void showStatusBar()
// Oculta la barra de estado
void hideStatusBar()
// Devuelve el mensaje que se está mostrando en la barra de estado
String currentMessageStatusBar()
// Limpia el mensaje que se está mostrando en la barra de estado
void clearMessageStatusBar()
// Muestra un mensaje en la barra de estado
// ‐ szMsg = Mensaje de texto a mostrar en la barra de estado
// ‐ nMiliSegsTimeout = Tiempo en milisegundos que estará visible, por defecto 0 = no se oculta el mensaje
void showMessageStatusBar( String szMsg, Number nMiliSegsTimeout = 0 )
// Devuelve true si está visible el grip de cambio de tamaño de la ventana
Boolean isSizeGripEnabledStatusBar()
// Habilta o deshabilita el grip de cambio de tamaño de la ventana
// ‐ bSet = True para habilitar el grip de la cambio de tamaño, false para deshabilitar
void setSizeGripEnabledStatusBar( Boolean bSet )
Funciones de la vista central
1
2
3
4
5
6
7
8
9
// Devuelve el modo de interfaz de documento de la ventana
Number bootMode()
// Fijar el modo de interfaz de documento de la ventana
// ‐ nMode = Ver enum de modos de interfaz de documento de la ventana
void setBootMode( Number nMode )
// Devuelve el número de vistas abierta
Number viewsCount()
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// Devuelve el número ordinal de la vista en curso
VMdiView currentView()
// Hace visible la siguiente vista
void nextView()
// Hace visible la vista previa
void prevView()
// Cierra la vista en curso
void closeCurrentView()
// Cierra todas las vistas
void closeAllViews()
// Aplica el interfaz MDI en cascada
void mdiCascade()
// Aplica el interfaz MDI en mosaico
void mdiTile()
Enumeraciones
Enum de modos de interfaz de documento de la ventna
1
2
3
TAB = 0
MDI = 1
SDI = 2
Enum de personalización de ventana (flags combinables)
1
2
3
4
5
HintTitle = 0x01 Sin título
HintSystemMenu = 0x02 Sin menú del sistema
HintMinimizeButton = 0x04 Sin botón minimizar
HintMaximizeButton = 0x08 Sin botón maximizar
HintCloseButton = 0x10 Sin botón cerrar
Enum de features del dock (flags combinables)
1
2
3
4
Cerrable = 0×01
Movible = 0×02
Flotable = 0×04
Barra de titulo vertical = 0×08
Ejemplos
Ejemplo de cómo conseguir tener 1 opción de menú abierta una vez
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
////////////////////////////////////////////////////////////
// Busca una vista con el título y si la encuentra la habilita
// Si no la encuentra ejecuta la acción
// El proceso recibe 2 parámetros a través de las variables locales
// TITULO = Título de la pestaña
// ACCION = Acción a ejecutar
var numVistas = theMainWindow.viewsCount();
var ejecutar = true;
for ( i=0; i<numVistas + 1; i++ )
{
var vista = theMainWindow.currentView()
if ( vista.title() == theRoot.varToString( "TITULO" ) )
{
ejecutar = false;
} else {
theMainWindow.nextView();
}
}
// Si no se ha encontrado se lanza la acción para abrir la vista y se retorna true (para seguir)
if ( ejecutar == true )
{
theMainWindow.runAction( theRoot.varToString( "ACCION" ) );
}
Clase
VMdiView
VMdiView
Descripción
Un objeto de esta clase representa a una de las vistas centrales de la ventana principal. Algunas de las funciones sólo están disponibles cuando el modo
de interfaz de la VMainWindow es MDI.
Se puede coger el VRoot que contiene la vista si no es una vista genérica.
Funciones
Funciones generales
1
2
3
// Devuelve el tipo de vista
// Ver enum de tipos de vistas Number type()
Funciones de información de la ventana
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Devuelve el título de la ventana
String windowTitle()
// Devuelve el script CSS que se está aplicando a la vista
String styleSheet()
// Devuelve true si la vista no está visible
Boolean isVisible()
// Devuelve la posición x de la ventana
Number x()
// Devuelve la posición y de la ventana
Number y()
// Devuelve el ancho en pixels de la ventana
Number width()
// Devuelve el alto en pixels de la ventana
Number height()
Funciones de manipulación de la ventana
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Cambia el título de la ventana
// ‐ szTitle = Texto del título de la ventana
void setWindowTitle( String szTitle )
// Cambia el script CSS que se aplicará a la vista
// ‐ szCSS = Texto del script CSS
void setStyleSheet( String szCSS )
// Hace visible la vista
void show()
// Oculta la vista
void hide()
// Fija el foco en la ventana
void setFocus()
// Cierra la ventana
void close()
// Fuerza el repintado de la ventana salvo que esté oculta o las actualizaciones desactivadas
void repaint()
// Actualiza la ventana
// No produce un repintado inmediato para reducir el flicker
void update()
Funciones de la ventana sólo en modo MDI
1
2
3
4
5
// Mueve la ventana a la posición x, y
// ‐ x = Posición horizontal en pixeles de la esquina superior izquierda de la ventana
// ‐ y = Posición vertical en pixeles de la esquina superior izquierda de la ventana
void move( Number x, Number y )
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// Modifica el tamaño de la ventana
// ‐ nWidth = Nuevo ancho en pixeles de la ventana
// ‐ nHeight = Nuevo alto en pixeles de la ventana
void resize( Number nWidth, Number nHeight )
// Devuelve true si la ventana está maximizada
Boolean isMaximized()
// Devuelve true si la ventana está minimizada
Boolean isMinimized()
// Muestra la ventana maximizada
void showMaximized()
// Muestra la ventana minimizada
void showMinimized()
// Muestra la ventana normal
void showNormal()
// Coloca la ventana en la posición más baja de la pila de ventanas
void lower()
// Coloca la ventana en la posición más alta de la pila de ventanas
void raise()
Funciones sólo para vistas de datos
1
2
// Devuelve un objeto de la clase VRoot que representa a la vista dentro de la ventana
VRoot root()
Enumeraciones
Enum de tipos de vistas
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
TypeGeneric = 00 Genérica
TypeForm = 01 Formulario
TypeGrid = 02 Rejilla
TypeCasillero = 03 Casillero
TypeTree = 04 Arbol
TypeMultiView = 05 MultiVista
TypeMultiViewTree = 06 MultiVista en modo árbol
TypeFormBlock = 07 Bloc de formularios
TypeReportPreview = 08 Vista previa de informe
TypeViewFlow = 10 ViewFlow
TypeListAlternator = 11 Alternador de lista
TypeComboView = 12 ComboView
TypeListView = 13 ListView
TypeQmlList = 14 Lista QML
TypeAdvancedGrid = 15 Rejilla avanzada
TypeQmlForm = 16 Formulario QML
Ejemplos
Ejemplo de análisis del contenido de la vista en curso
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
////////////////////////////////////////////////////////////
// Ejemplo de análisis del contenido de la vista en curso
// Se obtiene la vista en curso
var view = theMainWindow.currentView();
if ( view )
{
// Cogemos el objeto "root" de la vista
var root = view.root();
if ( root )
{
// Cogemos el contenido del root: ficha, lista o ninguno
var rootContent = root.content();
if ( rootContent )
{
if ( root.objectInfo().inputType() == VObjectInfo.IORecord )
{
// Si el contenido es un registro
alert( "Contenido: ficha del registro " + rootContent.fieldToString( "ID" ) + " ‐ " + rootContent.field
}
else if ( root.objectInfo().inputType() == VObjectInfo.IOList )
{
// Si el contenido es una lista
alert( "Contenido: lista de " + rootContent.listSize() + " registros de la tabla " + rootContent.tableI
}
29
30
31
32
33
34
35
36
37
}
else
alert( "Contenido ninguno" );
}
else
alert( "No es vista de datos" );
}
else
alert( "No hay ninguna vista" );
Clase
VApp
VApp
Descripción de la clase
Este clase representa a la aplicacion. Dispone de funciones para ver información de sus proyectos, acceso a variables globales, constantes, utilidades de
base de datos, disco, etc.
El objeto theApp
Todos los scripts están conectados a un objeto global y único que representa a la aplicación cuyo nombre es theApp.
Herencia
Hay que tener en cuenta que la aplicación da acceso al proyecto principal con el que se ha arrancado la aplicación y todos sus objetos heredados lo que
permite el acceso y uso de cualquier objeto de la aplicación desde cualquier script.
Funciones
Funciones generales
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// Devuelve el nombre del navegador en curso (vClient, vWebClient)
String exeName()
// Emite un pitido a través del altavoz del sistema
void beep()
// Devuelve el código del idioma en curso
Number currentLanguageCode()
// Devuelve el código ISO (639) del idioma en curso
String currentLanguageIsoCode()
// Devuelve el nombre del idioma en curso (en inglés)
String currentLanguageName()
// Devuelve el código de país en curso
Number currentCountryCode()
// Devuelve el código ISO (3166) del país en curso
String currentCountryIsoCode()
// Devuelve el nombre del país en curso
String currentCountryName()
// Devuelve el caracter de separador decimal en curso (un string de un byte)
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
String currentDecimalPoint()
// Devuelve el código del idioma del sistema
Number sysLanguageCode()
// Devuelve el código ISO (639) del idioma del sistema
String sysLanguageIsoCode()
// Devuelve el nombre del idioma del sistema (en inglés)
String sysLanguageName()
// Devuelve el código de país del sistema
Number sysCountryCode()
// Devuelve el código ISO (3166) del país del sistema
String sysCountryIsoCode()
// Devuelve el nombre del país del sistema
String sysCountryName()
// Devuelve el caracter de separador decimal del sistema (un string de un byte)
String sysDecimalPoint()
// Devuelve el nombre de la máquina (host)
String sysMachineName()
Funciones de proyectos
1
2
3
4
5
6
// Devuelve el objeto VProjectInfo del proyecto principal en curso
VProjectInfo mainProjectInfo()
// Devuelve un objeto VProjectInfo del proyecto con el alias especificado
// ‐ szAlias = Alias del proyecto o nombre del fichero en disco
VProjectInfo projectInfo( String szAlias )
Funciones de variables globales
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// Devuelve el valor de una variable global de tipo:
String globalVarToString( String szIdRefVar ) // Alfabética
Number globalVarToDouble( String szIdRefVar ) // Numérica con decimales
Number globalVarToInt( String szIdRefVar ) // Numérica sin decimales
Boolean globalVarToBool( String szIdRefVar ) // Booleano
DateTime globalVarToDateTime( String szIdRefVar ) // Fecha y tiempo
Date globalVarToDate( String szIdRefVar ) // Fecha
Time globalVarToTime( String szIdRefVar ) // Tiempo (hora)
// Devuelve true si la variable global está vacía
// Las numéricas se asumen vacías con el valor 0
// ‐ szIdRefVar = IdRef de la variable ("ALIASPROYECTO/IDVARIABLE)
Boolean IsglobalVarEmpty( String szIdRefVar )
// Asigna el valor a la variable global, según el tipo:
void setGlobalVar(String szIdRefVar, String szValor) // Alfabética
void setGlobalVar(String szIdRefVar, double dValor) // Numérica con decimales
void setGlobalVar(String szIdRefVar, int nValor ) // Numérica entera
void setGlobalVar(String szIdRefVar, Boolean bValor ) // Booleana
void setGlobalVar(String szIdRefVar, DateTime dt ) // Fecha y tiempo
void setGlobalVar(String szIdRefVar, Date date ) // Fecha
void setGlobalVar(String szIdRefVar, Time time ) // Tiempo (hora)
Funciones de constantes
1
2
// Devuelva el contenido de una constante
String constant( String szIdRef )
Funciones de herramientas de base de datos
1
2
3
4
5
6
7
8
// Regenera el área de datos de la tabla indicada en el primer parámetro
// Si indicamos true en el 2º parámetro se mostrará la barra de progreso
// Esta función lanzada sobre tablas en memoria siempre devuelve false
Boolean regenDataArea( String idRefTabla, Boolean bProgressDialog )
// Regenera los índices de tabla indicada en el primer parámetro
// Si indicamos true en el 2º parámetro se mostrará la barra de progreso
Boolean regenIndexes( String idRefTabla, Boolean bProgressDialog )
Funciones de DOS (Sistema operativo de disco)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// Copia un fichero. Devuelve true si la copia finaliza correctamente
Boolean copyFile( String szFileName, String szNewName )
// Devuelve true si el fichero existe y está legible
Boolean existsFile( String szFileName )
// Elimina un fichero del disco. Devuelve true si finaliza correctamente
Boolean removeFile( String szFileName )
// Renombra un fichero del disco. Devuelve true si finaliza correctamente
Boolean renameFile( String szFileName, String szNewName )
// Crea un enlace simbólico (acceso directo o shortcut) a un fichero o directorio
Boolean linkFile( String szFileName, String szLinkName )
// Cambia el path en curso. Devuelve true si el cambio finaliza correctamente
Boolean setCurrentPath( String szPath )
// Devuelve el path de:
String currentPath() // Directorio en curso (por defecto donde se ejecuta vClient)
String homePath() // Directorio home (por defecto el del usuario)
String rootPath() // Directorio raíz (p.e. C:/)
String tempPath() // Directorio temporal
// Elimina del path los separadores "/" o "\" redundantes y los unifica a "/"
String cleanPath( String szPath )
// Carga las unidades de disco del sistema. Devuelve true si finaliza correctamente
Boolean loadDrives()
// Devuelve el número de unidades de disco del sistema
Number drivesCount()
// Devuelve un objeto VFileInfo para el unidades del índice cargado
VFileInfo driveAt( Number nIndex )
Ejemplos
Ejemplo de funciones generales
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
////////////////////////////////////////////////////////////
// Ejemplo de funciones generales
// Si el componente ejecutado es vClient se emite un pitido
if ( theApp.exeName() == "vClient" ) {
theApp.beep();
}
// Se muestra el nombre del componente en ejecución
alert( "Componente en ejecución: " + theApp.exeName() );
// Mostrar info local en curso
alert( "Información local en curso" + "\n" + "\n" +
"Código del idioma = " + theApp.currentLanguageCode() + "\n" +
"Código ISO del idioma = " + theApp.currentLanguageIsoCode() + "\n" +
"Nombre del idioma = " + theApp.currentLanguageName() + "\n" +
"Código del país = " + theApp.currentCountryCode() + "\n" +
"Código ISO del país = " + theApp.currentCountryIsoCode() + "\n" +
"Nombre del país = " + theApp.currentCountryName() + "\n" +
"Separador decimal = " + theApp.currentDecimalPoint() );
// Mostrar info local del sistema
alert( "Información local del sistema" + "\n" + "\n" +
"Código del idioma = " + theApp.sysLanguageCode() + "\n" +
"Código ISO del idioma = " + theApp.sysLanguageIsoCode() + "\n" +
"Nombre del idioma = " + theApp.sysLanguageName() + "\n" +
"Código del país = " + theApp.sysCountryCode() + "\n" +
"Código ISO del país = " + theApp.sysCountryIsoCode() + "\n" +
"Nombre del país = " + theApp.sysCountryName() + "\n" +
"Separador decimal = " + theApp.sysDecimalPoint() + "\n" +
"Nombre de la máquina = " + theApp.sysMachineName() );
Ejemplo de funciones de variables globales
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
////////////////////////////////////////////////////////////
// Ejemplo de funciones de variables globales
// Almacenamos los valores en variables globales
theApp.setGlobalVar( "VJS_DAT/VAR_GLO_ALF", "ABC" );
theApp.setGlobalVar( "VJS_DAT/VAR_GLO_NUM", 123.45 );
theApp.setGlobalVar( "VJS_DAT/VAR_GLO_TMP", "2012/05/03 08:31:18" );
theApp.setGlobalVar( "VJS_DAT/VAR_GLO_FCH", "2012/05/04" );
theApp.setGlobalVar( "VJS_DAT/VAR_GLO_HOR", "09:53:23" );
// Se comprueba si la variable global alfabética está vacía
alert( "¿Está vacía la variable global alfabética? " +
theApp.isGlobalVarEmpty( "VJS_DAT/VAR_GLO_ALF" ) );
// Recuperamos y mostramos el valor de las variables globales
alfabetica = theApp.globalVarToString( "VJS_DAT/VAR_GLO_ALF" );
numero_decimal = theApp.globalVarToDouble( "VJS_DAT/VAR_GLO_NUM" );
numero_entero = theApp.globalVarToInt( "VJS_DAT/VAR_GLO_NUM" );
tiempo = theApp.globalVarToDateTime( "VJS_DAT/VAR_GLO_TMP" );
fecha = theApp.globalVarToDate( "VJS_DAT/VAR_GLO_FCH" );
hora = theApp.globalVarToTime( "VJS_DAT/VAR_GLO_HOR" );
alert( "Valor de las variables globales: \n" + alfabetica + "\n" +
numero_decimal + "\n" + numero_entero + "\n" +
tiempo + "\n" + fecha + "\n" + hora );
Ejemplo de funciones de constantes
1
2
3
////////////////////////////////////////////////////////////
// Se muestra un mensaje con el texto de una constante
alert( theApp.constant( "VJS_DAT/MSG_ERR_ID" ) );
Ejemplo de funciones de DOS (Sistema operativo de disco)
1
2
3
4
5
6
7
8
9
10
11
12
////////////////////////////////////////////////////////////
// Ejemplos varios de las funciones de disco
// Se preparan las variables con los nombres de ficheros
fileFrom = "/fichero.txt";
fileTo = "/fichero.txt.bck";
// Si existe el fichero destino se elimina
if ( theApp.existsFile( fileTo) )
{
if ( confirm( "¿Desea eliminar el fichero " + fileTo + "?", "Confirmar" ) )
{
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
theApp.removeFile( fileTo);
}
}
// Si existe el fichero se copia
if ( theApp.existsFile( fileFrom ) )
{
if ( theApp.copyFile( fileFrom, fileTo) )
{
alert( "Se ha copiado el fichero correctamente", "Notificación" );
// Se crea un acceso directo al fichero origen
theApp.linkFile( fileFrom, fileFrom + ".lnk" );
// Se renombra el fichero copiado
theApp.renameFile( fileTo, fileTo + "1" );
} else {
alert( "No se ha copiado el fichero correctamente", "Notificación" );
}
} else {
alert( "No se ha encontrado el fichero " + fileFrom, "Aviso" );
}
// Cambiamos el directorio en curso
if ( theApp.setCurrentPath( theApp.rootPath() + "/instancias" ) )
{
alert( "Se ha cambiado el path en curso", "Notificación" );
}
// Mostrar los path de los directorios
alert( "Estos son los directorios de trabajo:" + "\n" +
"En curso: " + theApp.currentPath() + "\n" +
"Root: " + theApp.rootPath() + "\n" +
"Home: " + theApp.homePath() + "\n" +
"Temp: " + theApp.tempPath() );
// Limpieza de un path
alert( theApp.cleanPath( "//instancias\\app\datos//2012", "Senda" ) );
// Revisar las unidades de disco del sistema operativo
var drivesNumber =0;
var drivesList = "";
theApp.loadDrives();
for ( i=0; i{
drive = theApp.driveAt( i );
drivesNumber++;
drivesList += drive.path() + "\n";
}
alert( "Se han encontrado " + drivesNumber.toString() + " unidades de disco: \n\n" +
drivesList );
Ejemplo de funciones de herramientas de base de datos
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
////////////////////////////////////////////////////////////
// Ejemplo de regeneración del área de datos e índices de todas las tablas
// Confirmamos si desea regenerar área de datos, índices o todos
var regenAreaDatos = confirm( "¿Desea regenerar el área de datos de todas las tablas?", "Confirmación" );
var regenIndexes = confirm( "¿Desea regenerar los índices de todas las tablas?", "Confirmación" );
// Si hay algo que regenerar se leen todas las tablas de la aplicación incluídas las heredadas
if ( regenAreaDatos || regenIndexes )
{
var msgErrors = "";
var mainProject = theApp.mainProjectInfo();
for( var nIndex=0; nIndex < mainProject.allTableCount(); nIndex++ )
{
var tableInfo = mainProject.allTableInfo( nIndex );
var table = tableInfo.idRef();
// Sólo se regenera el área de datos de las tablas en disco
if ( tableInfo.isInMemory() == false )
{
if ( !theApp.regenDataArea( table, true ))
{
msgErrors += "Falló la regeneración del área de datos de la tabla " + table + "\n";
}
}
// Se regeneran los índices de todas las tablas sean en disco o en memoria
if ( !theApp.regenIndexes( table, true ))
{
msgErrors += "Falló la regeneración de índices de la tabla " + table + "\n";
}
}
// Mensaje final del resultado de las regeneraciones
if (msgErrors.length == 0)
{
alert( "El proceso de regeneración ha finalizado correctamente", "Notificación" );
} else {
40
41
42
alert( "Se han producido los siguientes errores: \n" + msgErrors, "¡Atención!" );
}
}
Clase
VRoot
VRoot
Descripción
La clase VRoot representa a un ejecutor de objeto y es creado automáticamente por V7. Dispone de funciones para ver o modificar las variables locales
del objeto y de sistema, obtener información del objeto (API), transacciones, etc.
Veamos algunos ejemplos:
Ejecutamos un proceso JavaScript desde una acción: el objeto theRoot representa el ejecutor del proceso en V7.
Próximas versiones: Tenemos un formulario con un manejador de evento en lenguaje JavaScript: El objeto theRoot del manejador de evento
representa al ejecutor del formulario.
Próximas versiones: Si el objeto V7 es una vista de datos (rejilla, formulario…) estará disponible el objeto dataView que sirve para coger la ventana
que representa el formulario o la vista de datos.
El objeto theRoot
Los scripts están conectados al objeto V7 que los ejecuta. Al ejecutarse el script se crea un objeto que representa al objeto V7 en ejecución, este objeto
se denomina theRoot.
El objeto theRoot representa al objeto en ejecución en curso. Representará a un objeto diferente dependiendo de donde estés, si estás en un proceso
será el proceso y si estás en un evento representa al formulario. También puedes obtener otros objetos root del interfaz.
Funciones
Funciones de API del objeto
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Devuelve un objeto de la clase VObjectInfo que representa al objeto manipulado con la clase VRoot
VObjectInfo objectInfo()
// Devuelve el tipo del objeto manipulado con la clase VRoot
// Ver enum de tipos de objeto en la clase VObjectInfo
Number objectType()
// Devuelve el nombre del objeto manipulado con la clase VRoot
String objectName()
// Devuelve el tipo de entrada (ninguno, ficha o lista) del objeto manipulado con la clase VRoot
// Ver enum de tipos de entrada/salida en la clase VObjectInfo
Number inputType()
// Devuelve el tipo de salida (ninguno, ficha o lista) del objeto manipulado con la clase VRoot
// Ver enum de tipos de entrada/salida en la clase VObjectInfo
Number outputType()
Funciones de variables locales
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Devuelve el valor de una variable local según el tipo
// ‐ szId = Identificador de la variable local
String varToString( String szId ) // Variable alfabética
double varToDouble( String szId ) // Variable numérica (con decimales)
Number varToInt( String szId ) // Variable numérica (entero)
Boolean varToBool( String szId ) // Variable booleana DateTime varToDateTime( String szId ) // Variable tiempo (fecha y hora)
Date varToDate( String szId ) // Variable fecha
Time varToTime( String szId ) // Variable hora
// Asigna el contenido a una variable local según el tipo
// ‐ szId = Identificador de la variable local
void setVar( String szId, String szValor ) // Variable alfabética
void setVar( String szId, double dValor ) // Variable numérica (con decimales)
void setVar( String szId, int nValor ) // Variable numérica (entero)
void setVar( String szId, Boolean bValor ) // Variable booleana
void setVar( String szId, QDateTime dt ) // Variable tiempo (fecha y hora)
void setVar( String szId, QDate date ) // Variable fecha
void setVar( String szId, QTime time ) // Variable hora
Funciones de variables de sistema
1
2
3
// Devuelve el número de registros de la lista del objeto
Number listSize()
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Devuelve la posición del registro actual en la lista de registros del objeto
Number listPos()
// Devuelve la página en curso (Informes)
Number currentPage()
// Devuelve el número de páginas (Informe)
Number lastPage()
// Devuelve el nombre del usuario
String userName()
// Devuelve el path del directorio de caché del cliente
String clientCachePath()
// Devuelve true si el usuario en vAdmin está configurado como supervisor
Boolean isAdministrator()
Funciones de transacciones
1
2
3
4
5
6
7
8
9
10
11
12
// Inicia una transacción
// Devuelve true si la transacción se ha iniciado satisfactoriamente
// ‐ szTitulo = Título de la transacción que se visualiza en el visor de transacción de vAdmin
Boolean beginTrans( String szTitulo )
// Devuelve true si hay una transacción en curso
Boolean existTrans()
// Finaliza una transacción
// Devuelve true si la transacción ha finalizado satisfactoriamente
// Al finalizar la transacción se dar por válidas todas las operaciones realizadas en la base de datos todas las operac
// Al finalizar un proceso si hay una transacción abierta se cierra automáticamente como si se hubiese ejecutado esta f
13
14
15
16
17
Boolean commitTrans()
// Aborta una transacción y deshace todas sus operaciones
// Devuelve true si todas las operaciones de la transacción se han deshecho satisfactoriamente
Boolean rollbackTrans()
Funciones de vista de datos
1
2
3
4
5
6
7
8
9
10
11
// Devuelve VRegister, VRegisterList o Nulo
// El objeto que devuelve depende del origen del objeto representado por la clase VRoot
Object content()
// Devuelve el widget del objeto representado por la clase VRoot.
// ‐ szIDCompuestoControl = Identificador compuesto (Alias_Proyecto/Id_control)
Widget getWidget( String szIDCompuestoControl );
// Devuelve el tipo de vista
// Ver el enum de tipos de vista de la clase VMdiView
Number viewType()
Funciones de formulario
1
2
3
4
5
6
7
8
9
10
11
// Guarda el registro y cierra el formulario
// Equivale a pulsar el botón aceptar del formulario
void accept()
// Guarda el registro y mantiene abierto el formulario
// Equivale a pulsar el botón aceptar sin cerrar del formulario
void acceptNoClose()
// Cierra el formulario sin guardar el registro
// Equivale a pulsar el botón cancelar del formulario
void cancel()
Ejemplos
Ejemplo de múltiples transacciones
1
2
3
4
5
6
7
8
9
10
11
12
13
////////////////////////////////////////////////////////////
// Ejemplo de múltiples transacciones
// Se crea un registro vacío en memoria y se le asigna la tabla
var reg = new VRegister( theRoot );
reg.setTable( "vbaseUsuariosDat/USR" );
// Se ejecuta un bucle para dar 10 altas en 10 transacciones diferentes
for ( var i=0; i < 10; ++i )
{
// Se crea una transaccióname
if ( theRoot.beginTrans( "Alta de usuario. Transacción " + i ) )
{
13
14
15
16
17
18
19
20
21
22
23
24
25
26
{
// Se modifican los datos
reg.setField( "NAME", "Usuario_" + i );
// Se crea el registro
reg.addRegister();
// Se añaden el registro a la lista de salida
theRegisterListOut.append( reg );
// Se cierra la transacción
theRoot.commitTrans();
}
}
Clase
VRegister
VRegister
Descripción
Los objetos de esta clase representan una ficha de una tabla.
Los register pueden ser creados:
Automaticamente por v7 como VRegisterIn y VRegisterOut al inicio de un script lanzado desde uno o varios objetos V7 con entrada o salida ficha.
Desde otro objeto en javascript como con la funcion readAt de la clase VRegisterList que devuelve un VRegister.
Dispone de funciones para gestionar los contenidos de los campos por identificador simple o compuesto y por número de campo. Además se pueden
ver los contenidos previos de los campos, cuando se leyó la ficha.
Tambien dispone de una funciones para obtener la subclase del tipo VTableInfo que nos da informacion api de la tabla y de sus campos, indices e
historicos para ver las propiedades de estos objetos como por ejemplo el tipo de un campo, su identificador o su numero de decimales.
Para edición tenemos funciones de alta, baja y modificación asi como de control de errores.
Y al más puro estilo v7 las funciones de navegante.
Los objetos theRegisterIn, theRegisterOut y theRegister
Si el proceso JavaScript tiene una tabla asociada de origen ficha el script tendrá conectado un objeto de la clase VRegister denominado theRegisterIn
que se crea automáticamente con el registro de entrada.
Si el proceso tiene asociada una tabla destino de destino ficha el script tendrá conectado un objeto de la clase VRegister denominado theRegisterOut
que se crea automáticamente vacío y que podrá contener el registro de salida.
En las fórmulas que son lanzadas desde un origen de ficha de tabla, como por ejemplo un contenido inicial, el script tendrá conectado un objeto de la
clase VRegister denominado theRegister que se crea automáticamente con el registro que alimenta la fórmula. Desde este objeto podemos ejecutar
funciones de lectura de información pero no de escritura ya que las fórmulas no disponen de esa característica.
Constructor
1
2
3
// Devuelve un objeto VRegister inicializado
// Debe ejecutarse la función setTable() para asignarle la tabla
VRegister( theRoot )
Funciones
Funciones de inicialización
1
2
3
4
5
6
// Asigna la tabla al objeto VRegister creado con el constructor
// Devuelve true si ha podido asignar la tabla correctamente
// Una vez ejecutada es equivalente a crear una ficha en memoria de la tabla
// ‐ szIdRefTable = IdRef de la tabla
// ‐ bInitContenidos = Por defecto asume el valor true. Si se indica false no se dispararán los contenidos iniciales
Boolean setTable( const QString& szIdRefTable, bool bInitContenidos = true )
Funciones de API del objeto
1
2
// Devuelve un objeto VTableInfo de la tabla del registro
VTableInfo tableInfo()
Funciones de contenido de campos por identificador
1
2
3
4
5
6
7
8
// Devuelve el contenido de un campo en función del tipo
// La precisión en JavaScript de los números con decimales es la de tipo "double"
// El identificador de campo compuesto permite especificar campos de la tabla y de las enlazadas
// ‐ szIDCompuestoCampo = Identificador del campo
String fieldToString( String szIDCompuestoCampo ) // Campos alfanuméricos
Number fieldToDouble( String szIDCompuestoCampo ) // Campos numéricos (con decimales)
Number fieldToInt( String szIDCompuestoCampo ) // Campos numéricos (enteros)
Boolean fieldToBool( String szIDCompuestoCampo ) // Campos booleanos 9
10
11
12
13
14
15
16
17
18
19
20
21
DateTime fieldToDateTime( String szIDCompuestoCampo ) // Campos tiempo (fecha y hora)
Date fieldToDate( String szIDCompuestoCampo ) // Campos fecha
Time fieldToTime( String szIDCompuestoCampo ) // Campos hora
// Devuelve true si el campo está vacío
// Un campo numérico está vacío si su valor es 0
// Un campo alfabético está vacío si la longitud del contenido es 0
// ‐ szIDCompuestoCampo = Identificador del campo
Boolean isFieldEmpty( String szIDCompuestoCampo )
// Devuelve true si el contenido del campo ha sido modificado
// ‐ szIDCompuestoCampo = Identificador del campo
Boolean isFieldModified( String szIDCompuestoCampo )
Funciones de contenido de campos por número de campo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Devuelve el contenido de un campo en función del tipo
// La precisión en JavaScript de los números con decimales es la de tipo "double"
// ‐ nCampo = Número de campo. El primero campo es el 0
String fieldToString( Number nCampo ) // Campos alfabéticos
double fieldToDouble( Number nCampo ) // Campos numéricos (con decimales)
Number fieldToInt( Number nCampo ) // Campos numéricos (enteros)
Boolean fieldToBool( Number nCampo ) // Campos booleanos
DateTime fieldToDateTime( Number nCampo ) // Campos tiempo (fecha y hora)
Date fieldToDate( Number nCampo ) // Campos fecha
Time fieldToTime( Number nCampo ) // Campos hora
// Devuelve true si el campo está vacío
// Un campo numérico está vacío si su valor es 0
// Un campo alfabético está vacío si la longitud del contenido es 0
// ‐ nCampo = Número de campo. El primero campo es el 0
Boolean isFieldEmpty( Number nCampo )
// Devuelve true si el contenido del campo ha sido modificado
// ‐ nCampo = Número de campo. El primero campo es el 0
Boolean isFieldModified( Number nCampo )
Funciones de contenido old de campos por identificador
1
2
3
4
5
6
7
8
9
10
11
12
// Devuelve el contenido anterior a la modificación de un campo en función del tipo
// El valor old es diferente al valor del campo si ha sido modificado pero aún se ha guardado la información en disco
// La precisión en JavaScript de los números con decimales es la de tipo "double"
// El identificador de campo compuesto permite especificar campos de la tabla y de las enlazadas
// ‐ szIDCompuestoCampo = Identificador del campo
String oldFieldToString( String szIDPrimarioCampo ) // Campos alfabéticos
double oldFieldToDouble( String szIDPrimarioCampo ) // Campos numéricos (con decimales)
Number oldFieldToInt( String szIDPrimarioCampo ) // Campos numéricos (enteros)
Boolean oldFieldToBool( String szIDCompuestoCampo ) // Campos booleanos DateTime oldFieldToDateTime( String szIDPrimarioCampo ) // Campos tiempo (fecha y hora)
Date oldFieldToDate( String szIDPrimarioCampo ) // Campos fecha
Time oldFieldToTime( String szIDPrimarioCampo ) // Campos hora
Funciones de contenido old de campos por número de campo
1
2
3
4
5
6
7
8
9
10
11
// Devuelve el contenido anterior a la modificación de un campo en función del tipo
// El valor old es diferente al valor del campo si ha sido modificado pero aún se ha guardado la información en disco
// La precisión en JavaScript de los números con decimales es la de tipo "double"
// ‐ nCampo = Número de campo. El primero campo es el 0
String oldFieldToString( Number nCampo ) // Campos alfabéticos
double oldFieldToDouble( Number nCampo ) // Campos numéricos (con decimales)
Number oldFieldToInt( Number nCampo ) // Campos numéricos (enteros)
Boolean oldFieldToBool( Number nCampo ) // Campos booleanos
DateTime oldFieldToDateTime( Number nCampo ) // Campos tiempo (fecha y hora)
Date oldFieldToDate( Number nCampo ) // Campos fecha
Time oldFieldToTime( Number nCampo ) // Campos hora
Funciones de modificación de campos por identificador
1
2
3
4
5
6
7
8
9
10
// Modifica el valor de un campo en función del tipo
// La precisión en JavaScript de los números con decimales es la de tipo "double"
// ‐ szIDPrimarioCampo = Identificador del campo
void setField( String szIDPrimarioCampo, String szText ) // Campos alfabéticos
void setField( String szIDPrimarioCampo, double dValor) // Campos numéricos (con decimales)
void setField( String szIDPrimarioCampo, int nValor ) // Campos numéricos (enteros)
void setField( String szIDPrimarioCampo, Boolean bValor ) // Campos booleanos
void setField( String szIDPrimarioCampo, DateTime dateTime ) // Campos tiempo (fecha y hora)
void setField( String szIDPrimarioCampo, Date date ) // Campos fecha
void setField( String szIDPrimarioCampo, Time time ) // Campos hora
Funciones de modificación de campos por número de campo
1
2
3
// Modifica el valor de un campo en función del tipo
// La precisión en JavaScript de los números con decimales es la de tipo "double"
// ‐ nCampo = Número de campo. El primero campo es el 0
4
5
6
7
8
9
10
void setField( Number nCampo, String szText ) // Campos alfabéticos
void setField( Number nCampo, double dValor) // Campos numéricos (con decimales)
void setField( Number nCampo, int nValor ) // Campos numéricos (enteros)
void setField( Number nCampo, Boolean bValor ) // Campos booleanos
void setField( Number nCampo, DateTime dateTime ) // Campos tiempo (fecha y hora)
void setField( Number nCampo, Date date ) // Campos fecha
void setField( Number nCampo, Time time ) // Campos hora
Funciones de estado
1
2
3
4
5
// Devuelve true si el registro existe
Boolean exist()
// Devuelve true si alguno de los campos del registros ha sido modificado
Boolean isModified()
Funciones de operaciones de disco
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Da del alta el registro en la base de datos
Boolean addRegister()
// Modifica el registro en la base de datos
Boolean modifyRegister()
// Elimina el registro en la base de datos
Boolean deleteRegister()
// Devuelve true si la operación de base de datos ha finalizado satisfactoriamente
Boolean isOK()
// Devuelve el número de error producido en la operación de base de datos
// Ver enum de errores de operaciones de base de datos
Number errorNumber()
// Devuelve el texto del mensaje de error
String errorMessage()
Funciones de navegante
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Devuelve una lista de registros del enlace plural del registro actual
// Equivale al comando cargar plurales y a navegar a histórico de uno
// ‐ szIDHistorico = Identificador del plural
VRegisterList loadPlurals( String szIDHistorico )
// Devuelve el registro de un campo enlace a maestro
// Equivale al comando cargar maestro y a navegar a maestro
// ‐ szIDPrimarioCampo = Identificador del campo con enlace a tabla maestra
VRegister readMaster( String szIDPrimarioCampo )
// Devuelve el registro de un campo enlace a maestro con bloqueo
// Al ser con bloqueo nos permite realizar operaciones de base de datos sobre el registro
// Equivale al comando cargar maestro y a navegar a maestro
// ‐ szIDPrimarioCampo = Identificador del campo con enlace a tabla maestra
VRegister readLockingMaster( String szIDPrimarioCampo )
Funciones de variables locales
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Devuelve el valor de una variable local en función del tipo
// ‐ szID = Identificador de la variable local
String varToString( String szID ) // Variables alfabéticas
double varToDouble( String szID ) // Variables numéricas (con decimales)
Number varToInt( String szID ) // Variables numéricas (enteros)
Boolean varToBool( String szID ) // Variables booleanas
DateTime varToDateTime( String szID ) // Variables tiempo (fecha y hora)
Date varToDate( String szID ) // Variables fecha
Time varToTime( String szID ) // Variables hora
// Asigna un valor a la variable local según el tipo
// ‐ szID = Identificador de la variable local
void setVar( String szID, String szValor ) // Variable alfabética
void setVar( String szID, double dValor ) // Variable numérica (con decimales)
void setVar( String szID, int nValor ) // Variable numérica (entero)
void setVar( String szID, Boolean bValor ) // Variable booleana
void setVar( String szID, DateTime dt ) // Variable tiempo (fecha y hora)
void setVar( String szID, Date date ) // Variable fecha
void setVar( String szID, Time time ) // Variable hora
Funciones de variables de sistema
1
2
3
// Devuelve el tamaño de registros de una lista
Number listSize()
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Devuelve la posición del registro en la lista de registros
Number listPos()
// Devuelve el número de la página en curso de un informe
Number currentPage()
// Devuelve el número de páginas de un informe
Number lastPage()
// Devuelve el nombre del usuario en curso
String userName()
// Devuelve el path del directorio de caché de la aplicación
String clientCachePath()
// Devuelve true si el usuario tiene marcado en vAdmin el check Supervisor
Boolean isAdministrator()
Funciones de ejecución
1
2
3
// Ejecuta un proceso V7 o JavaScript
// ‐ szIdRefProcess = IdRef del proceso "Alias_proyecto/ID_proceso"
Boolean runProcess( String szIdRefProcess )
Enumeraciones
Enum de errores de operaciones de base de datos
1
2
3
4
5
6
7
8
9
10
ErrorNone = 0 OK, sin errores
ErrorUnknown = 1 Error de registro desconocido
ErrorTransUnknown = 2 Error: No hay transacción en curso
ErrorAddReg = 3 Error en alta
ErrorDeleteReg = 4 Error en baja
ErrorModifyReg = 5 Error en modificación
ErrorRead = 6 Error de lectura
ErrorReadLocking = 7 Error lectura con bloqueo
ErrorNullDir = 8 Error dirección de ficha nula
ErrorIndexOutOfRange = 9 Error index fuera de rango
Ejemplos
Ejemplo de altas de registros con varias transacciones
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
////////////////////////////////////////////////////////////
// Ejemplo de altas de registros con varias transacciones
// Se crea una transacción
if ( theRoot.beginTrans( "Transacción 1 ‐ Crear registros desde vJavaScript" ) )
{
// Se crea un registro vacío en memoria y se le asigna una tabla
var reg = new VRegister( theRoot );
if ( reg.setTable( "vbaseUsuariosDat/USR_GRP" ) )
{
for ( var i=0; i < 10; ++i )
{
// Se modifican los datos
reg.setField( "NAME", "VJS ‐ Nuevo grupo de usuarios " + i );
// Se crea el registro
reg.addRegister();
// Se añaden los registros a la lista de salida
theRegisterListOut.append( reg );
}
}
// Se cierra la primera transacción
theRoot.commitTrans();
}
// Se crea una transacción
if ( theRoot.beginTrans( "Transacción 2 ‐ Crear registros desde vJavaScript" ) )
{
// Se crea un registro vacío en memoria y se le asigna una tabla
var reg = new VRegister( theRoot );
if ( reg.setTable( "vbaseUsuariosDat/USR_GRP" ) )
{ for ( var i=0; i < 10; ++i )
{
// Se modifican los datos
reg.setField( "NAME", "VJS ‐ Nuevo grupo de usuarios " + i );
// Se crea el registro
reg.addRegister();
42
43
44
45
46
47
48
// Se añaden los registros a la lista de salida
theRegisterListOut.append( reg );
}
}
// Se cierra la segunda transacción
theRoot.rollbackTrans();
}
Ejemplo de eliminación de registros encontrados en una búsqueda
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
////////////////////////////////////////////////////////////
// Ejemplo de eliminación de registros encontrados en una búsqueda
// Se importa la clase para usar sus funciones
importClass( "VQuery" );
// Se crea el objeto búsqueda
var bus = new VQuery( theRoot );
bus.setQuery( "VJS_APP/USR_GRP_ENT_NAM");
// Se alimentan los paŕametros de búsqueda
var des = prompt( "Desde", "VJS" );
var has = prompt( "Desde", "VJSzzzzzzzzzzzzz" );
bus.setVar( "NOM_DES", des );
bus.setVar( "NOM_HAS", has );
// Se ejecuta la búsqueda y los registros encontrados se añaden a la salida
if ( bus.exec() )
{
// Obtenemos de la búsqueda la lista de registros a eliminar
var lis = bus.result();
var numReg = lis.listSize();
// Se crea una transaccióname
if ( theRoot.beginTrans( "Eliminar registros desde vJavaScript" ) )
{
for ( var i=0; i < numReg; ++i )
{
// Obtenemos el registro de la lista a eliminar
var reg = lis.readLockingAt( i );
// Se crea el registro
reg.deleteRegister();
}
} }
alert( "Se han eliminado satisfactoriamente " + numReg + " registros" );
Ejemplo de navegación a maestros y a plurales
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
////////////////////////////////////////////////////////////
// Ejemplo de navegación a maestros y a plurales
// Se importa la clase para usar sus funciones
importClass( "VQuery" );
// Se crea el objeto búsqueda
var bus = new VQuery( theRoot );
bus.setQuery( "vbaseApp/ENT");
// Se ejecuta la búsqueda y los registros encontrados se añaden a la salida
if ( bus.exec() )
{
// Obtenemos de la búsqueda la lista de entidades
var lisEnt = bus.result();
// Navegamos a las direcciones de las entidades
lisDir = lisEnt.loadPlurals( "DIR_ENT" );
// Navegamos a maestros para obtener los países de las direcciones
lisPai = lisDir.loadMasters( "PAI" );
// Se añaden los registros a la lista de salida
theRegisterListOut.append( lisPai );
}
Clase
VRegisterList
VRegisterList
Descripción
Los objetos de esta clase representan una lista de fichas de una tabla. Dispone de funciones de manejo de la lista y sus items pudiendose obtener
objetos de la clase VRegister por index, en modos lectura y lectura con bloqueo si vamos a modificar.
Las funciones del navegante devuelven otro objeto clase VRegisterList con la lista del maestro o historico.
La funcion sort está sobrecargada pudiendo llevar varios pares de parametros campo y bDescendente.
Objetos theRegisterListIn y theRegisterListOut
Si el proceso JavaScript tiene una tabla asociada de origen lista el script tendrá conectado un objeto de la clase VRegisterList denominado
theRegisterListIn que se crea automáticamente con la lista de registros de entrada.
Si el proceso tiene asociada una tabla destino de destino lista el script tendrá conectado un objeto de la clase VRegisterList denominado
theRegisterListOut que se crea automáticamente vacío y que podrá contener la lista de registros de salida.
Constructor
1
2
3
// Devuelve un objeto VRegisterList inicializado
// Debe ejecutarse la función setTable() para asignarle la tabla
VRegisterList( theRoot )
Funciones
Funciones de inicialización
1
2
3
4
5
// Asigna la tabla al objeto VRegisterList creado con el constructor
// Devuelve true si ha podido asignar la tabla correctamente
// Una vez ejecutada es equivalente a crear una cesta de la tabla
// ‐ szIdRefTable = IdRef de la tabla
Boolean setTable( String szIdRefTable )
Funciones de API de tabla
1
2
// Devuelve un objeto VTableInfo de la tabla de la lista de registros
VTableInfo tableInfo();
Funciones de lista e ítems
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Devuelve el número de registros de la lista
Number size()
// Devuelve la posición del registro en curso de la lista
Number pos()
// Limpia la lista de registros
// Equivale al comando de instrucción "Cesta: Limpiar"
void clear()
// Invierte el orden de los registros de la lista
void invert()
// Ordena la lista de registros por los campos indicados
// Se puede ordenador por múltiples campos separados por comas
// ‐ szIdCompuestoCampo = Identificador del campo de la tabla o de sus enlazadas
// ‐ bDescendente = True para indicar orden descendente, por defecto es false
void sort( String szIdCompuestoCampo, Boolean bDescendente, ... )
// Añade un registro a la lista
// Equivale al comando de instrucción "Cesta: Añadir ficha a la cesta"
// ‐ register = Objeto de la clase VRegister
void append( VRegister register )
// Añade una lista de registros a la lista
// Equivale al comando de instrucción "Cesta: Añadir lista a la cesta" 27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
// ‐ registerList = Objeto de la clase VRegisterList
void append( VRegisterList registerList )
// Cruza la lista de registros con la lista en curso
// En la lista en curso sólo quedarán los registros coincidentes
// Equivale al comando de instrucción "Cesta: Cruzar la lista de la cesta"
// ‐ registerList = Objeto de la clase VRegisterList
void cross( VRegisterList registerList )
// Quita de la lista el registro
// Esto no eliminar el registro de la base de datos, sólo de la lista
// Equivale al comando de instrucción "Cesta: Quitar ficha de la cesta"
// ‐ register = Objeto de la clase VRegister
void remove( VRegister register )
// Quita de la lista los registros de la lista que se pasa
// En la lista en curso quedarán los registros no coincidentes
// Esto no elimina los registros de la base de datos, sólo los de la cesta
// ‐ registerList = Objeto de la clase VRegisterList
void remove( VRegisterList registerList )
// Quita de la cesta el registro de la posición indicada
// Esto no eliminar el registro de la base de datos, sólo de la lista
// ‐ nIndex = Número de posición del registro en la lista
void removeAt( Number nIndex )
// Devuelve un objeto de clase VRegister con el registro de la posición seleccionada
// ‐ nIndex = Número de posición del registro en la lista
VRegister readAt( Number nIndex )
// Devuelve un objeto de clase VRegister bloqueado con el registro de la posición seleccionada
// Al estar bloqueado se podrán realizar operaciones de base de datos contra el registro
// ‐ nIndex = Número de posición del registro en la lista
VRegister readLockingAt( Number nIndex )
Funciones de navegante
1
2
3
4
5
6
7
8
9
10
// Devuelve una lista de registros del enlace plural de la lista de registros actual
// Equivale al comando cargar plurales y a navegar a histórico de todos
// ‐ szIDHistorico = Identificador del plural
VRegisterList loadPlurals( String szIDHistorico )
// Devuelve la lista de registros maestros del campo enlace a maestro
// Devuelve los maestros sin repetición, aunque varios registros apunten al mismo maestro sólo lo devuelve una vez
// Equivale al comando cargar maestros y a navegar a maestros
// ‐ szIDPrimarioCampo = Identificador del campo con enlace a tabla maestra
VRegisterList loadMasters( String szIDPrimarioCampo )
Funciones de ejecución
1
2
3
// Ejecuta un proceso V7 o JavaScript
// ‐ szIdRefProcess = IdRef del proceso "Alias_proyecto/ID_proceso"
Boolean runProcess( String szIdRefProcess )
Funciones de variables locales
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Devuelve el valor de una variable local en función del tipo
// ‐ szID = Identificador de la variable local
String varToString( String szID ) // Variables alfabéticas
double varToDouble( String szID ) // Variables numéricas (con decimales)
Number varToInt( String szID ) // Variables numéricas (enteros)
Boolean varToBool( String szID ) // Variables booleanas
DateTime varToDateTime( String szID ) // Variables tiempo (fecha y hora)
Date varToDate( String szID ) // Variables fecha
Time varToTime( String szID ) // Variables hora
// Asigna un valor a la variable local según el tipo
// ‐ szID = Identificador de la variable local
void setVar( String szID, String szValor ) // Variable alfabética
void setVar( String szID, double dValor ) // Variable numérica (con decimales)
void setVar( String szID, int nValor ) // Variable numérica (entero)
void setVar( String szID, Boolean bValor ) // Variable booleana
void setVar( String szID, DateTime dt ) // Variable tiempo (fecha y hora)
void setVar( String szID, Date date ) // Variable fecha
void setVar( String szID, Time time ) // Variable hora
Funciones de variables de sistema
1
2
3
4
5
6
7
8
// Devuelve el tamaño de registros de una lista
Number listSize()
// Devuelve la posición del registro en la lista de registros
Number listPos()
// Devuelve el número de la página en curso de un informe
Number currentPage()
9
10
11
12
13
14
15
16
17
18
19
20
// Devuelve el número de páginas de un informe
Number lastPage()
// Devuelve el nombre del usuario en curso
String userName()
// Devuelve el path del directorio de caché de la aplicación
String clientCachePath()
// Devuelve true si el usuario tiene marcado en vAdmin el check Supervisor
Boolean isAdministrator()
Ejemplos
Ejemplo de navegación a plurales y maestros
1
2
3
4
5
6
7
8
9
10
11
12
////////////////////////////////////////////////////////////
// Ejemplo de navegación a plurales y maestros
// Recibimos una lista de países y devolvemos una lista de entidades
// Se carga el histórico de direcciones de los países
var lisDir = theRegisterListIn.loadPlurals( "DIR_PAI" );
// Se cargan las entidades de las direcciones
var lisEnt = lisDir.loadMasters( "ENT" );
// Se alimenta la lista de salida con las entidades cargadas
theRegisterListOut.append( lisEnt );
Ejemplo de recorrer lista eliminando fichas
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
////////////////////////////////////////////////////////////
// Ejemplo de recorrer lista eliminando fichas
// Abrimos la transacción
if ( theRoot.beginTrans( "Recorrer lista eliminando fichas de " + theRegisterListIn.tableInfo().name() ) )
{
// Se recorre la lista de entrada
var numReg = theRegisterListIn.size();
var numRegDel = 0;
var msgError = "";
for ( var x=0; x<numReg; ++x )
{
// Se lee el registro con bloqueo para poder modificar
var reg = theRegisterListIn.readLockingAt( x );
if ( reg.isOK() )
{
reg.deleteRegister();
if ( reg.isOK() )
numRegDel += 1;
else
msgError += " ‐ " + reg.fieldToString( "NAME" )+ "\n";
}
}
// Finalizamos la transacción
// Si no realizamos explícitamente el commitTrans() V7 lo hace automaticamente
theRoot.commitTrans();
}
// Se preparar el mensaje final con el restulado y se visualiza
var msg = "Se han eliminado " + numRegDel + " " + theRegisterListIn.tableInfo().name() + "\n\n"
if ( msgError != "" )
msg += "No se han podido eliminar los siguientes registros: " + "\n" + msgError;
alert( msg );
Clase
VQuery
VQuery
Descripción
La clase VQuery nos permite ejecutar objetos búsqueda. Construimos un objeto VQuery pasandole el objeto VRoot en curso y le indicamos la búsqueda
a ejecutar con la función setQuery. Una vez inicializado el objeto ya podemos usar el resto de funciones (salvo result): le pasamos contenido a las
variables locales de la búsqueda con setVarLocal (si lo requiere) y la ejecutamos con la función exec. Ahora ya podemos recoger los resultados con la
función result, que nos devuelve un objeto de la clase VRegisterList con el cual podemos operar.
Constructor
1
2
3
// Crea una instancia de objeto de la clase VQuery
// Debe ejecutarse la función setQuery() para asignarle la búsqueda
VQuery( theRoot )
Funciones
Funciones de inicialización
1
2
3
// Fija la búsqueda que se asocia al objeto
// ‐ szIdRefQuery = IdRef (Alias_Proyecto/Id_Búsqueda) de la búsqueda
void setQuery( String szIdRefQuery )
Funciones de API del objeto
1
2
// Devuelve el objeto VObjectInfo correspondiente a la búsqueda asignada al objeto VQuery
VObjectInfo objectInfo()
Funciones de variables locales
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Devuelve el valor de una variable local según el tipo
// ‐ szID = Identificador de la variable local
String varToString( String szID ) // Variable alfabética
Number varToDouble( String szID ) // Variable numérica (con decimales)
Number varToInt( String szID ) // Variable numérica (entero)
Boolean varToBool( String szID ) // Variable booleana DateTime varToDateTime( String szID ) // Variable tiempo (fecha y hora)
Date varToDate( String szID ) // Variable fecha
Time varToTime( String szID ) // Variable hora
// Asigna un valor a la variable local según el tipo
// ‐ szID = Identificador de la variable local
void setVar( String szID, String szValor ) // Variable alfabética
void setVar( String szID, double dValor ) // Variable numérica (con decimales)
void setVar( String szID, int nValor ) // Variable numérica (entero)
void setVar( String szID, Boolean bValor ) // Variable booleana
void setVar( String szID, DateTime dt ) // Variable tiempo (fecha y hora)
void setVar( String szID, Date date ) // Variable fecha
void setVar( String szID, Time time ) // Variable hora
Funciones de operaciones
1
2
3
4
5
// Ejecuta la búsqueda y devuelve true si finaliza correctamente
Boolean exec()
// Devuelve un objeto VRegisterList con la lista de registro encontrados en la búsqueda
VRegisterList result()
Ejemplos
Ejemplo de búsqueda sin parámetros
1
2
3
4
5
6
////////////////////////////////////////////////////////////
// Ejemplo de búsqueda sin parámetros
// Se importa la clase para usar sus funciones
importClass( "VQuery" );
7
8
9
10
11
12
13
14
15
16
// Se crea el objeto búsqueda
var bus = new VQuery( theRoot );
bus.setQuery( "vbaseUsuariosApp/USR_GRP_NOM");
// Se ejecuta la búsqueda y los registros encontrados se añaden a la salida
if ( bus.exec() )
{
// Le pasamos los resultados a la lista de salida
theRegisterListOut.append( bus.result() );
}
Ejemplo de búsqueda con parámetros
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
////////////////////////////////////////////////////////////
// Ejemplo de búsqueda con parámetros
// Se importa la clase para usar sus funciones
importClass( "VQuery" );
// Se crea el objeto búsqueda
var bus = new VQuery( theRoot );
bus.setQuery( "VJS_APP/USR_GRP_ENT_NAM");
// Se alimentan los paŕametros de búsqueda
bus.setVar( "NOM_DES", "VJS" );
bus.setVar( "NOM_HAS", "VJSzzzzzzzzzzzzzzz" );
// Se ejecuta la búsqueda y los registros encontrados se añaden a la salida
if ( bus.exec() )
{
// Le pasamos los resultados a la lista de salida
theRegisterListOut.append( bus.result() );
}
Clase
VDir
VDir
Descripción
La clase VDir proporciona acceso a las estructuras de directorios y sus contenidos.
Un VDir se utiliza para manipular los nombres de sendas, acceso a la información sobre las sendas y los ficheros y manipular el sistema de archivos
subyacente.
VDir usa “/” como un separador universal de directorios de la misma manera que “/” se utiliza como un separador de ruta en URLs. Si siempre utiliza
“/” como separador de directorio, VDir traducirá las sendas para cumplir con el sistema operativo subyacente.
Un VDir puede apuntar a un directorio utilizando una ruta absoluta o relativa. Las rutas absolutas comienzan con el separador de directorio
(opcionalmente precedido por una especificación de unidad en Windows). Los nombres relativos de archivo comienzan con un nombre de directorio o
un nombre de archivo.
Constructor
1
2
3
// Crea una instancia de objeto de la clase VDir
// ‐ szFileName = Nombre o path del fichero
VDir( String szFileName )
Funciones
Funciones generales
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// Devuelve el nombre del directorio, por ejemplo "vbase" // No se debe confundir con el path "/instancias/vbase"
// Si el directorio no tiene nombre, por ejemplo el raíz devuelve ""
String dirName()
// Devuelve true si el directorio existe y false si no existe
Boolean exists()
// Devuelve true si el path es absoluto
Boolean isAbsolute()
// Devuelve true si el path es relativo
// En Linux y Mac es relativo si el path no comienza por "/"
Boolean isRelative()
// Devuelve true si el directorio es legible
// Un valor false no garantiza que los ficheros no sean accesibles Boolean isReadable()
// Devuelve true si es el directorio raíz
// Si es un enlace simbólico del directorio raíz devolverá false
// Para enlaces simbólicos usar la función canonicalPath()
23
Boolean isRoot()
Funciones de path
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// Devuelve el path del directorio
String path()
// Devuelve el path canonica, sin enlaces simbólicos ni "." o ".." redundantes
// Si el sistema no tiene enlaces simbólicos la función equivale a absolutePath()
// Si el canonical path no existe la función no devuelve nada
String canonicalPath()
// Devuelve el path absoluto (empieza con "/" o con la letra del dispositivo)
// Puede contener enlaces simbólicos pero no "." o ".." redundates o múltiples separadores
String absolutePath()
// Convierte el path del directorio en un path absoluto
// Si ya es absoluto no hace nada
// Devuelve true si la conversión se ha realizado
Boolean makeAbsolute()
// Devuelve el path de un fichero
// ‐ szFileName = Nombre o path del fichero
String filePath( String szFileName )
// Devuelve el path de un fichero relativo al directorio
// szFileName = Nombre o path del fichero
String relativeFilePath( String szFileName )
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
// Devuelve el path absoluto de un fichero en un directo
// No se verifica si el fichero existe en el directorio
// No se elimina del path los separadores múltiples o "." o ".." redundantes
// szFileName = Nombre o path del fichero
String absoluteFilePath( String szFileName )
// Cambia el directorio del objeto VDir
// Devuelve true si el directorio existe y es legible, en caso contrario false
// El cambio de directorio no se produce si devuelve false
// Usar cd("..") es equivalente a usar la función cdUp()
// szDirName = Nombre o path del directorio
Boolean cd( String szDirName )
// Cambia el directorio del objetos VDir al directorio padre
// Devuelve true si el directorio existe y es legible, en caso contrario false
// El cambio de directorio no se produce si devuelve false
// Usar cdUp() es equivalente a usar la función cd("..") Boolean cdUp()
Funciones de operaciones con directorios
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// Crear un directorio
// Devuelve true si se ha podido crear el nuevo directorio
// szDirName = Nombre o path del directorio
Boolean mkdir( String szDirName )
// Crear los directorios inexistentes de un path
// Devuelve true si ha podido crear todo el path del directorio
// Se crean todos los subdirectorios necesario para crear el directorio
// szDirPath = Path del directorio
Boolean mkpath( String szDirPath )
// Elimina un directorio
// El directorio debe estar vacío para poder eliminarlo
// Devuelve true sin finaliza correctamente
// szDirName = Nombre o path del directorio
Boolean rmdir( String szDirName )
// Elimina un path (directorio y subdirectorios).
// Devuelve true si finaliza correctamente
// szDirPath = Path del directorio Boolean rmpath( String szDirPath )
Funciones de ficheros del directorio
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// Devuelve true si el fichero existe
// szFilename = Nombre o path del fichero
Boolean exists( String szFileName )
// Carga en el objeto la lista de ficheros y subdirectorio del directorio en curso
// szNameFilter = Nombre del filtro
// nFilters = Ver enum de tipos de filtros
// nSortFlags = Ver enum de tipos de ordenación
Boolean load( StringList& aszNameFilters, Number nFilters = QDir::NoFilter, Number nSortFlags = QDir::NoSort )
Boolean load( Number nFilters = QDir::NoFilter, Number nSortFlags = QDir::NoSort )
// Refresca en el objeto directorio la lista de ficheros y subdirectorios
void refresh()
// Devuelve del nº de ficheros y directorios cargados con load()
Number count()
// Devuelve un objeto VFileInfo correspondiente al nº de elemento de la lista
// nIndex = Número de orden del fichero en la lista cargada de ficheros del directorio
VFileInfo entryAt( Number nIndex )
// Elimina un fichero o directorio
// Devuelve true si finaliza correctamente
// szFilename = Nombre o path del fichero
Boolean remove( String szFileName )
// Renombra un fichero o directorio
// Devuelve true si finaliza correctamente
// szOldname = Nombre o path del del fichero a cambiar
// szNename = Nombre o path del nuevo para el fichero
Boolean rename( String szOldName, String szNewName )
Enumeraciones
Enum de flags de filtros
1
2
3
FilterDirs = 0x001 Sólo directorios que cumplan el filtro
FilterFiles = 0x002 Solo ficheros
FilterDrives = 0x004 Lista de dispositivos (se ignora en Linux) 3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
FilterDrives = 0x004 Lista de dispositivos (se ignora en Linux) FilterNoSymLinks = 0x008 No incluir en la lista los enlaces simbólicos (accesos directos)
FilterAllEntries = FilterDirs | FilterFiles | FilterDrives Incluye en la lista directorios, ficheros, dispositiv
FilterReadable = 0x010 Incluye los directorios o ficheros que tienen acceso de lectura
FilterWritable = 0x020 Incluye los directorios o ficheros que tienen acceso de escritura
FilterExecutable = 0x040 Incluye los ficheros que tienen acceso de ejecución
FilterModified = 0x080 Incluye sólo los ficheros que han sido modificados (ignorado en Unix)
FilterHidden = 0x100 Incluye los ficheros ocultos
FilterSystem = 0x200 Incluye los ficheros del sistema
FilterAllDirs = 0x400 Todos los directorios, sin aplicar filtros
FilterCaseSensitive = 0x800 El filtro es sensible a mayúsculas y minúsculas
FilterNoDotAndDotDot = 0x1000 No incluye en la lista las entradas "." y "..", directorios en curso y padre
FilterNoDot = 0x2000 No incluye en la lista la entrada ".", el directorio en curso
FilterNoDotDot = 0x4000 No incluye en la lista la entrada "..", el directorio padre
FilterNone = ‐1 Sin filtro
Enum de flags de ordenación
1
2
3
4
5
6
7
8
9
10
11
SortName = 0x00 Ordenado por nombre
SortTime = 0x01 Ordenado por fecha de última modificación
SortSize = 0x02 Ordenado por tamaño
SortUnsorted = 0x03 No ordenado
SortDirsFirst = 0x04 Los directorios al principio, después los ficheros
SortReversed = 0x08 Orden inverso
SortIgnoreCase = 0x10 Ignorar mayúsculas
SortDirsLast = 0x20 Los ficheros al principio, después los directorios
SortLocaleAware = 0x40 Ordenado según la configuración local
SortType = 0x80 Ordenado por extensión
SortNone = ‐1 No ordenado por defecto
Ejemplos
Ejemplo de uso de las funciones de la clase VDir
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
////////////////////////////////////////////////////////////
// Ejemplo de las funciones de la clase VDir
// Para poder usar la clase VDir y sus funciones hay que importarla primero
importClass( "VDir" );
// Lo primero que hay que hacer es crear un objeto VDir con un directorio o vacío
var dir = new VDir();
// En caso de crear el objeto VDir sin un directorio es necesario asignar un path
dir.cd( "/Instancias/001" );
alert( "Se ha cambiado la senda del objeto directorio a " + dir.path() )
// Convertir el path del direcotorio en path absoluto
if ( dir.makeAbsolute() )
alert( dir.path() + " ya era un path abosluto" );
// Cargar la lista de ficheros y directorios
dir.load();
alert( "¿Existe el directorio " + dir.path() + "? " + dir.exists() + "\n" + "¿El directorio es el raíz? " + dir.isRoot() + "\n" + "¿El directorio es legible? " + dir.isReadable() + "\n" + "¿El directorio es absoluto? " + dir.isAbsolute() + "\n" + "¿El directorio es relativo? " + dir.isRelative() + "\n" + "Este directorio tiene " + dir.count() + " ficheros y directorios.");
// Se crea un directorio
bOk = dir.mkdir( "/" + "new" );
if ( bOk )
// Se elimina el directorio
dir.rmdir( "/" + "new" );
// Se crean los directorios y subidrectorios necesarios
bOk = dir.mkpath( "/backup/files/txt" );
if ( bOk )
// Se elimina el path completo
dir.rmpath( "/backup/files/txt" );
Clase
VFile
VFile
Descripción
Esta clase representa a un fichero binario y disponemos de funciones para consultar sus características, modificarlas así como crear, leer o escribir un
fichero binario en disco.
Constructor
1
2
3
// Crea una instancia de objeto de la clase VFile
// ‐ szFileName = Nombre o path del fichero
VFile( String szFileName )
Funciones
Funciones de información del fichero
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// Devuelve true si el fin de fichero ya ha sido leído
Boolean atEnd()
// Devuelve el código de estado del fichero
// Ver enum de errores de fichero
Number error()
// Devuelve true si el fichero existe
Boolean exists()
// Devuelve el nombre del fichero
String fileName()
// Devuelve true si el fichero sólo puede ser manipulado secuencialmente
Boolean isSequential()
// Devuelve el valor de los permisos del fichero
// El valor devuelto es la suma (OR) de los valores de los permisos
// Ver enum de permisos del fichero
Number permissions()
// Devuelve la posición en curso del fichero
// Se corresponde con la posición del último dato escrito o leído
// Si el fichero está cerrado o es secuencial devuelve cero.
Number pos()
// Devuelve el tamaño del fichero
Number size()
// Devuelve el path absoluto del fichero o directorio del enlace simbólico o acceso directo
// Devuelve una cadena vacía si el fichero no es un enlace simbólico o acceso directo
String symLinkTarget()
Funciones de operaciones sobre el fichero
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// Cierra el fichero
// Antes de cerrarlo ejecuta flush
void close()
// Hace una copia del fichero en curso con otro nombre o path
// Devuelve true si la copia ha podido realizarse con éxito
// ‐ szNewName = Path donde se almacenará la copia del fichero
Boolean copy( String szNewName )
// Guarda en disco los buffers de datos del fichero
// Devuelve true si ha podido realizarse con éxito
Boolean flush()
// Crear un acceso directo (Windows) o enlace simbólico (Unix)
// Devuelve true si se creado con éxito
// ‐ szLinkName = Nombre o path completo del enlace
Boolean link( String szLinkName )
// Abre el fichero con los modos especificados
// Los modos de apertura son combinables
// Se pueden especificar varios separados por "|"
// ‐ nMode = Ver enum de modos de apertura del fichero
Boolean open( Number nMode )
// Elimina el fichero en curso
// Devuelve true si se ha eliminado correctamente
Boolean remove()
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
// Renombra el fichero en curso
// Devuelve true si ha podido renombrarse correctamente.
// Si el fichero con el nombre szNewName ya existe devuelve false
// ‐ szNewName = Nombre o path nuevo para el fichero
Boolean rename( String szNewName )
// Cambia el tamaño del fichero
// Devuelve true si ha posido realizarse correctamente
// ‐ nSize = Valor en bytes del nuevo tamaño del fichero
Boolean resize( Number nSize )
// Fija la posición en curso del fichero
// Devuelve true si se ha posicionado correctamente
// Para fichero secuenciales devuelve el valor false
// Si la posición es posterior al fin de fichero, el fichero no se extiende, si se escribe en esa posición sí se extien
// ‐ nOffset = Número en bytes que representa la nueva posición del fichero
Boolean seek( Number nOffset )
// Fija los permisos del fichero
// Se pueden especificar múltiples permisos de forma combinada, separados por "|"
// Devuelve true si la asignación de permisos ha finalizado correctamente
// ‐ nPermissions = Ver enum de permisos del fichero
Boolean setPermissions( Number nPermissions )
// Fija el estado del fichero al valor a sin errores "ErrorNone".
void unsetError()
Funciones para el buffer del fichero
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Devuelve el tamaño del buffer en bytes
Number bufferSize()
// Fija el tamaño del buffer en bytes
// ‐ nSize = Tamaño del buffer en bytes
void setBufferSize( Number nSize )
// Devuelve el número de bytes leídos que será el tamaño del buffer o menos
// Si el fichero está posicionado al final devolverá 0
Number readBuffer()
// Graba el buffer en el disco
// ‐ nBytes = Número de bytes del buffer a escribir, es opcional, si no se especifica asume el tamaño del buffer
Number writeBuffer( Number nBytes = ‐1 )
// Se usa para leer byte a byte el buffer
// Devuelve el valor del byte (entre 0 y 255) de la posición del buffer seleccionada
// ‐ nIndex = Posición del buffer
Number bufferAt( Number nIndex )
// Se usa para escribir byte a byte en el buffer
// ‐ nIndex = Posición del buffer en la que se escribirá
// ‐ nValue = Valor de 0 a 255 a escribir en la posición del buffer
void setBufferAt( Number nIndex, Number nValue )
Enumeraciones
Enum de modos de apertura del fichero
1
2
3
4
5
6
7
8
OpenModeNotOpen = 0x0000 No está abierto
OpenModeReadOnly = 0x0001 Abierto para lectura
OpenModeWriteOnly = 0x0002 Abierto para escritura
OpenModeReadWrite = OpenModeReadOnly | OpenModeWriteOnly Abierto para lectura/escritura
OpenModeAppend = 0x0004 Abierto para escribir al final del fichero, sin borrar el contenido existente
OpenModeTruncate = 0x0008 Abierto para escritura truncando. Si no existe y si existe se borra su contenido antes de
OpenModeText = 0x0010 Se abre en modo texto. Al leer el fin de línea se convierte al carácter "\n" y al escribi
OpenModeUnbuffered = 0x0020 No se utiliza buffer para el fichero
Enum de errores de fichero
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
ErrorNone = 00 Ok, no se ha producido ningún error
ErrorRead = 01 Se ha producido un error al leer del fichero
ErrorWrite = 02 Se ha producido un error al escribir en el fichero
ErrorFatal = 03 Se ha producido un error fatal
ErrorResource = 04 Se ha producido un error en el recurso
ErrorOpen = 05 No ha sido posible abrir el fichero
ErrorAbort = 06 Se ha abortado la operación sobre el fichero
ErrorTimeOut = 07 Se ha producido un error de timeout
ErrorUnspecified = 08 Se ha producido un error no especificado
ErrorRemove = 09 No ha sido posible eliminar el fichero
ErrorRename = 10 No ha sido posible renombrar el fichero
ErrorPosition = 11 La posición del fichero no puede ser modificada
ErrorResize = 12 No es posible redimensionar el fichero
ErrorPermissions = 13 No tiene permisos de acceso al fichero
ErrorCopy = 14 No se podido copiar el fichero
Enum de permisos del fichero
1
2
3
4
5
6
7
8
9
10
11
12
PermissionReadOwner = 0x4000 El propietario puede leer el fichero
PermissionWriteOwner = 0x2000 El propietario puede escribir en el fichero
PermissionExeOwner = 0x1000 El propietario puede ejecutar el fichero
PermissionReadUser = 0x0400 El usuario puede leer el fichero
PermissionWriteUser = 0x0200 El usuario puede escribir en el fichero
PermissionExeUser = 0x0100 El usuario puede ejecutar el fichero
PermissionReadGroup = 0x0040 El grupo de usuarios puede leer el fichero
PermissionWriteGroup = 0x0020 El grupo de usuarios puede escribir en el fichero
PermissionExeGroup = 0x0010 El grupo de usuarios puede ejecutar el fichero
PermissionReadOther = 0x0004 Todos pueden leer el fichero
PermissionWriteOther = 0x0002 Todos pueden escribir en el fichero
PermissionExeOther = 0x0001 Todos pueden ejecutar el fichero
Ejemplos
Ejemplo de creación de un fichero de texto
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
////////////////////////////////////////////////////////////
// Ejemplo de creación de un fichero de texto
// Para usar las funciones de la clase VFile primero hay que importarla
importClass( "VFile" );
// Se declara el objeto fichero
var fi = new VFile( "/buffer.txt" );
// Se abre el fichero de escritura (si no existe se crea y si existe se limpia)
if ( fi.open( VFile.OpenModeWriteOnly||VFile.OpenModeTruncate) )
{
// Se llena el buffer con las 26 letras del abecedario
for( var x=0; x<26; ++x )
{
fi.setBufferAt( x, 65+x );
}
// Se graba el buffer
fi.writeBuffer( 26 );
// Se cierra el fichero
fi.close();
}
else
// Si no ha sido posible abrir el fichero se muestra error
alert( "No se pudo abrir el ficher " + fi.fileName(), "Error" );
Clase
VFileInfo
VFileInfo
Descripción
Los objetos de esta clase contienen la información de un fichero de disco. Tiene funciones generales para obtener información de la senda, el fichero y
sus permisos además de permitir alterar algunas características del fichero.
Funciones
Funciones del path
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
// Devuelve el path absoluto del fichero incluyendo el nombre del fichero
String absoluteFilePath()
// Devuelve el path absoluto del fichero sin incluir el nombre del fichero
String absolutePath()
// Devuelve el nombre del fichero sin incluir la senda ni la extensión
// El nombre son todos los caracteres hasta el primero punto "."
// Por ejemplo de "/tmp/archive.tar.gz" devolvería "archive"
String baseName()
// Devuelve el nombre del enlace al fichero
// EN Mac OS X devuelve el nombre del enlace, en otras plataformas devuelve una cadena vacía String bundleName()
// Devuelve el path de la senda absoluta de un enlace simbólico del fichero incluyendo el nombre
// Si el fichero no existe devuelve una cadena vacía
String canonicalFilePath()
// Devuelve el path de la senda absoluta de un enlace simbólico del fichero sin incluir el nombre
// Si el fichero no existe devuelve una cadena vacía
String canonicalPath()
// Devuelve el nombre completo del fichero incluyendo la extensión sin la senda del path
// Por ejemplo de "/tmp/archive.tar.gz" devolvería "archive.tar"
String completeBaseName()
// Devuelve todas las extensiones del fichero
// Por ejemplo, de "/tmp/archive.tar.gz" devuelve "tar.gz"
String completeSuffix()
// Devuelve el nombre del fichero excluyendo la senda
// Por ejemplo, de "/tmp/archive.tar.gz" devuelve "archive.tar.gz"
String fileName()
// Devuelve el nombre del fichero incluyendo el path tanto si es absoluto o relativo
String filePath()
// Devuelve el nombre del grupo del fichero
// Sólo para sistemas Unix
String group()
// Devuelve el código (Id) del grupo del fichero
44
45
// Sólo para sistemas Unix
Number groupId()
Funciones de información
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Devuelve true si el path apunta a una senda absoluta
Boolean isAbsolute()
// Devuelve true si el path apunta a un enlace (simbólico o paquete)
Boolean isBundle()
// Devuelve true si el path apunta a un directorio
Boolean isDir()
// Devuelve true si el path apunta a un fichero ejecutable
Boolean isExecutable()
// Devuelve true si el path apunta a un fichero o a un enlace simbólico
Boolean isFile()
// Devuelve true si el path apunta a un fichero o directorio oculto
Boolean isHidden()
// Devuelve true si el path apunta a un fichero que puede ser leído
Boolean isReadable()
// Devuelve true si el path apunta a un senda relativa
Boolean isRelative()
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
Boolean isRelative()
// Devuelve true si el path apunta al directorio raíz o a un enlace simbólico del mismo
Boolean isRoot()
// Devuelve true si el path apunta a un enlace simbólico
Boolean isSymLink()
// Devuelve true si el path apunta a un fichero en el que se puede escribir
Boolean isWritable()
// Devuelve true si el fichero existe
Boolean exists()
// Devuelve true si el cacheado del fichero está habilitado
Boolean caching()
// Devuelve la fecha y hora de creación del fichero
// En sistemas Unix esta fecha cambia tanto en la creación como si hay modificación de permisos, por ejemplo
DateTime created()
// Devuelve la fecha y hora de la última modificación del fichero
DateTime lastModified()
// Devuelve la fecha y hora de la última vez que el fichero fue leído o tuvo un acceso
DateTime lastRead()
Funciones de asignación
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
// Convertir el path del fichero en un senda absoluta
// Devuelve true si la conversión ha finalizado correctamente
// Si el path ya era absoluto devuelve false
Boolean makeAbsolute()
// Devuelve el nombre del propietario del fichero
String owner()
// Devuelve el código (Id) del propietario del fichero
Number ownerId()
// Devuelve el path del fichero
String path()
// Chequea los permisos del fichero y devuelve true si el fichero los tiene
// ‐ permissions = Ver enum de tipos de permisos del fichero en la clase VFile
Boolean permission( Number permissions )
// Devuelve el valor de los permisos del fichero
// El valor devuelto es la suma (OR) de los valores de los permisos
// Ver enum de permisos del fichero
Number permissions()
// Refresca la información del fichero
void refresh()
// Estable si el sistema tendrá caché de la información del fichero
// ‐ bEnable = True para que el sistema haga caché de la información del fichero
void setCaching( Boolean bEnable )
// Fija el fichero o directorio al que apuntará el objeto
// ‐ szFilePath = Path del fichero o directorio
void setFile( String szFilePath )
// Devuelve el tamaño del fichero en bytes
Number size()
// Devuelve la extensión del fichero String suffix()
// Devuelve el path absoluto del fichero apuntado por el enlace simbólico o acceso directo
String symLinkTarget()
Ejemplos
Ejemplo de lectura de los ficheros del directorio raíz del sistema
1
2
3
4
5
6
7
8
9
10
11
12
13
14
////////////////////////////////////////////////////////////
// Ejemplo de lectura de los ficheros del directorio raíz del sistema
// Para poder usar la clase VDir y sus funciones hay que importarla primero
importClass( "VDir" );
// Ss crear un objeto VDir con el directorio temporal de la aplicación
var dir = new VDir( theApp.rootPath() );
// Cargar la lista de ficheros y directorios
dir.load();
// Se inicializan las variables de trabajo
var filesNumber =0;
15
16
17
18
19
var totalSize = 0;
var filesList = "";
// Se recorren todos los ficheros del directorio
for ( i=0; i<dir.count(); i++ )
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
{
// Se lee el fichero (Se obtiene un objeto VTableInfo)
file = dir.entryAt( i );
// Si es fichero se acumulan sus datos
if ( file.isFile() ) {
filesNumber++;
totalSize += file.size();
filesList += dir.entryAt( i ).filePath(file.path() ) + "\n";
}
}
// Se visualizan los datos de todos los ficheros del directorio
alert( "En el directorio raíz (" + dir.path() + ")" + "\n" + "Se han encontrado " + filesNumber.toString() + " ficheros: \n\n" + filesList + "\n" + "El tamaño total de los ficheros es " + totalSize.toString() + " bytes." );
Clase
VTextFile
VTextFile
Descripción
Esta clase representa a un fichero de texto y disponemos de funciones para consultar sus características, modificarlas así como crear, leer o escribir un
fichero de texto en disco.
Constructor
1
2
3
// Crea una instancia de objeto de la clase VTextFile
// ‐ szFileName = Nombre o path del fichero de texto
VTextFile( String szFileName )
Funciones
Funciones generales
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// Devuelve la codificación que se aplicará al fichero
void codec()
// Fijar el codec para codificar los datos que escriben
// Aplicar esta función sobre el objeto VTextFile creado antes de escribir
// Por defecto se crea con code UTF‐8
// ‐ szCodecName = Ver lista de nombres de códigos (escribir entrecomillado)
void setCodec( String szCodecName );
// Devuelve true si el fin de fichero ha sido leído
Boolean atEnd()
// Cierre el fichero
void close()
// Devuelve el código numérico del error
Number error()
// Devuelve true si el fichero existe
Boolean exists()
// Devuelve el nombre del fichero
String fileName()
// Fuerza que se guarden todos los buffers a disco
void flush()
// Abre el fichero
// ‐ nMode = Ver enum de modo de apertura
Boolean open( Number nMode )
// Devuelve el código numérico de los permisos
Number permissions()
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
// Devuelve la posición actual del fichero
Number pos()
// Devuelve el contenido completo de todo el fichero
String readAll()
// Devuelve el contenido de una línea
// ‐ nMaxLen = Longitud máxima a devolver, por defecto 0 = hasta fin de línea
String readLine( Number nMaxlen=0 )
// Fija la posición del fichero. Devuelve true si el posicionamiento finaliza correctamente
// ‐ nOffset = Valor numérico de la posición
Boolean seek( Number nOffset )
// Fija los permisos del fichero
// ‐ nPermissions = Ver enum de permisos de un fichero Boolean setPermissions( Number nPermissions )
// Devuelve el tamaño en bytes del fichero
Number size()
// Fija el error del fichero al valor del enum VFile::NoError
void unsetError()
// Grabar una cadena de texto en la posición en curso
// ‐ szTexto = Texto a grabar
void write( String szText )
Lista de nombres de códigos
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
"Apple Roman"
"Big5"
"Big5‐HKSCS"
"CP949"
"EUC‐JP"
"EUC‐KR"
"GB18030‐0"
"IBM 850"
"IBM 866"
"IBM 874"
"ISO 2022‐JP"
"ISO 8859‐1 to 10"
"ISO 8859‐13 to 16"
"Iscii‐Bng, Dev, Gjr, Knd, Mlm, Ori, Pnj, Tlg, and Tml"
"JIS X 0201"
"JIS X 0208"
"KOI8‐R"
"KOI8‐U"
"MuleLao‐1"
"ROMAN8"
"Shift‐JIS"
"TIS‐620"
"TSCII"
"UTF‐8"
"UTF‐16"
"UTF‐16BE"
"UTF‐16LE"
"UTF‐32"
"UTF‐32BE"
"UTF‐32LE"
"Windows‐1250 to 1258"
"WINSAMI2"
Ejemplos
Ejemplos de creación de un fichero de texto
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
////////////////////////////////////////////////////////////
// Ejemplo de creación de un fichero de texto
// Para usar las funciones de la clase VFile primero hay que importarla
importClass( "VTextFile" );
importClass( "VFile" );
// Se declara el objeto fichero
var fi = new VTextFile( "/TextFile.txt" );
// Se abre el fichero en modo escritura. Crea si no existe o limpia si existe
if ( fi.open( VFile.OpenModeWriteOnly | VFile.OpenModeTruncate) )
{
// Se llena el buffer con las 26 letras del abecedario
for( var x=0; x<30; ++x )
{
fi.write( "Línea " + x + " de texto a grabar" + "\n" );
}
// Se cierra el fichero
fi.close();
}
else
// Si no ha sido posible abrir el fichero se muestra error
alert( "No se pudo abrir el ficher " + fi.fileName() + ", error " + fi.error(), "Error" );
Ejemplos de lectura de un fichero de texto
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
////////////////////////////////////////////////////////////
// Ejemplo de lectura de un fichero de texto
// Para usar las funciones de la clase VFile primero hay que importarla
importClass( "VTextFile" );
importClass( "VFile" );
// Se declara el objeto fichero
var fi = new VTextFile( "/TextFile.txt" );
// Se abre el fichero en modo de sólo lectura
if ( fi.open( VFile.OpenModeReadOnly ) )
{
// Leer todo el fichero
alert( "Tamaño del fichero = " + fi.size() + " bytes" );
// Leer todo el fichero
alert( fi.readAll() );
// Como hemos leído todo el fichero estamos posicionados al final
// Para volver a leer el fichero línea a línea nos posicionamos al princicipio
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
fi.seek( 0 );
// Recorremos el fichero línea a línea guardando su contenido
var txt = "";
while ( fi.atEnd() == false )
{
txt += fi.readLine();
} // Mostramos la variable con todo el contenido del fichero
alert( txt );
// Se cierra el fichero
fi.close();
}
else {
// Si no ha sido posible abrir el fichero se muestra error
alert( "No se pudo abrir el ficher " + fi.fileName() + ", error " + fi.error(), "Error" );
}
Clase
VXmlWriter
VXmlWriter
Descripción
Esta clase representa un objeto XML y nos permite generar un fichero XML con el contenido de una lista.
¿Cómo crear un fichero XML desde una lista de registros?
Para empezar hay que contruir el objeto VXmlWriter con new pasándole como parámetro un objeto de la clase VRegisterList.
El codec por defecto es “UTF­8″. Para cambiarlo por ejemplo a UTF­16, llamar a la funcion setCodec( “UTF­16″ ). Hay una lista de los codecs
disponibles más abajo.
Si no se usa la función setDocType(“mytype”) no se incluirá la cabecera opcional .
Por defecto el texto es formateado con saltos de linea e indentación. Para cancelarlo usar la función setAutoFormatting( false ). Con la función
setAutoFormattingIndent( nSpacesOrTabs ) ajustamos el número de espacios o tabs de indentación. Si usamos valores positivos para n representan
espacios y si son negativos tabs. Por defecto la indentación son 4 espacios.
Con la función addInitialTag( “tag”) le añadimos uno o varios tags, llamando varias veces a la función, que envuelven a los registros de la lista. Lo
normal es usar una con el nombre de la tabla.
Con la función setRowTag( “tag” ) le decimos la etiqueta que ha de envolver a cada registro. Si no se usa por defecto es “row”.
A continuación con las funciones addField( “tagCol”, “IDCOMPUESTOCAMPO”) y addFormula( “tagCol”, “Formula” ) le añadimos tantas columnas
como queramos por registro.
Y ya solo nos queda llamar a la función writeFile( “file.xml” ); para que nos lo escriba en disco.
Constructor
1
2
3
// Crea una instancia de objeto de la clase VXmlWriter
// ‐ registerList = Objeto de lista de registros que alimentará el objeto
VXmlWriter( VRegisterList registerList )
Funciones
Funciones de inicialización
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// Fija el tipo de documento
// ‐ szType = Texto que identifica el tipo de documento XML
void setDocType( String szType )
// Fijar el codec para codificar los datos que escriben
// Aplicar esta función sobre el objeto VTextFile creado antes de escribir
// Por defecto se crea con code UTF‐8
// ‐ szCodecName = Ver lista de nombres de códigos (Escribir entrecomillado)
void setCodec( String szCodecName )
// Fija si se aplica o no formato automático
// Por defecto el texto es formateado con saltos de linea e indentación
// Por defecto la indentación son 4 espacios
// ‐ bSet = True para aplicar autoforma y false para cancelarlo
void setAutoFormatting( Boolean bSet )
// Ajusta el número de espacios o tabs de indentación
// Si usamos valores positivos para nSpacesOrTabs representan espacios
// Si usamos valores negativos para nSpacesOrTabs representan tabs.
void setAutoFormattingIndent( Number nSpacesOrTabs )
// Se añade uno o varios tags, llamando varias veces a la función
// Estos tags envuelven los registros de la lista
// Lo normal es usar una etiqueta con el nombre de la tabla
// ‐ szTag = Etiqueta (Normalmente el nombre de la tabla)
void addInitialTag( String szTag )
// Fijamos la etiqueta que envuelve a cada registro
// Si no se aplica esta función el valor por defecto de la etiqueta es "row"
// ‐ szTag = Etiqueta (Por defecto es row)
void setRowTag( String szTag )
// Permite añadir tantas columnas como campos definamos
// ‐ szTag = Etiqueta de la columna (Por ejemplo el ID del campo
// ‐ szIdCampoCompuesto ‐ Identificador del campo de la tabla o de las relacionadas
35
36
// ‐ szIdCampoCompuesto ‐ Identificador del campo de la tabla o de las relacionadas
void addField( String szTag, String szIdCampoCompuesto )
Funciones de operaciones
1
2
3
4
5
6
7
// Graba en disco el fichero XML
// Devuelve true si la generación ha finalizado correctamente
// ‐ szPath = Path o senda del fichero a generar
writeFile( String szPath )
// Devuelve un String con el XML generado
String writeToString()
Funciones de información
1
2
// Devuelve la codificación que se aplicará al fichero
void codec()
Lista de nombres de codecs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
"Apple Roman"
"Big5"
"Big5‐HKSCS"
"CP949"
"EUC‐JP"
"EUC‐KR"
"GB18030‐0"
"IBM 850"
"IBM 866"
"IBM 874"
"ISO 2022‐JP"
"ISO 8859‐1 to 10"
"ISO 8859‐13 to 16"
"Iscii‐Bng, Dev, Gjr, Knd, Mlm, Ori, Pnj, Tlg, and Tml"
"JIS X 0201"
"JIS X 0208"
"KOI8‐R"
"KOI8‐U"
"MuleLao‐1"
"ROMAN8"
"Shift‐JIS"
"TIS‐620"
"TSCII"
"UTF‐8"
"UTF‐16"
"UTF‐16BE"
"UTF‐16LE"
"UTF‐32"
"UTF‐32BE"
"UTF‐32LE"
"Windows‐1250 to 1258"
"WINSAMI2"
Ejemplos
Ejemplo de exportación de una lista de registros a XML
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
////////////////////////////////////////////////////////////
// Exportar una lista de registros a xml
// Se importa la clase para usar sus funciones
importClass( "VQuery" );
importClass( "VXmlWriter" );
// Se crea el objeto búsqueda
var bus = new VQuery( theRoot );
bus.setQuery( "vbaseUsuariosApp/USR_GRP_NOM" );
// Se ejecuta la búsqueda
if ( bus.exec() )
{
// Se crea el objeto XML con la lista de registros de entrada
var xml = new VXmlWriter( bus.result() );
// Se fija el tipo de documento
xml.setDocType( "vXML" );
// Se añade como etiqueta de documento, el nombre de la tabla
xml.addInitialTag( "USR_GRP" );
// Se añade la etiqueta de registro
xml.setRowTag( "row" );
// Se añaden los campos de la tabla
28
29
30
31
32
xml.addField( "Código", "ID" );
xml.addField( "Nombre", "NAME" );
xml.addField( "Usuario alta", "ALT_USR.NAME" );
// Grabar el fichero en disco
33
34
35
36
37
xml.writeFile( theApp.rootPath() + "/USR_GRP" + ".xml" );
}
// Se muestra un mensaje confirmando la exportación
alert( "Se han exportado satisfactoriamente " + bus.result().size() + " grupos de usuarios", "Información" );
Ejemplo de exportación a XML de los registros buscados de cualquier tabla
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
////////////////////////////////////////////////////////////
// Exportar a XML todos los campos de los registros buscados en una tabla //
// Este script es ejecutado desde otro proceso que le pasa la búsqueda a ejecutar (Variable local BUS)
// Una vez ejecutada la búsqueda se exportan todos los registros encontrados en la búsqueda
// Se exportan todos los campos de la tabla
// Se importa la clase para usar sus funciones
importClass( "VQuery" );
importClass( "VXmlWriter" );
// Se crea el objeto búsqueda
var bus = new VQuery( theRoot );
bus.setQuery( theRoot.varToString( "BUS" ) );
// Se ejecuta la búsqueda
if ( bus.exec() )
{
// Se obtiene el VRegisterList de la búsqueda
var lista = bus.result();
// Se crea el objeto VTableInfo para obtener la información de la tabla
var ti = lista.tableInfo();
// Se crea el objeto XML con la lista de registros de entrada
var xml = new VXmlWriter( lista );
// Se añade como etiqueta de documento, el nombre de la tabla
xml.addInitialTag( ti.id() );
// Se añade la etiqueta de registro
xml.setRowTag( "row" );
// Se recorren los campos y se añaden las columnas al XML
for ( col=0; col < ti.fieldCount(); ++col )
{
xml.addField( ti.fieldName( col ), ti.fieldId( col ) );
}
// Grabar el fichero en disco
xml.writeFile( theApp.rootPath() + "/" + ti.id() + ".xml" );
}
// Se muestra un mensaje confirmando la exportación
alert( "Se han exportado satisfactoriamente " + lista.size() + " " + ti.name(), "Información" );
Funciones
Globales
Funciones globales
Descripción
Estas funciones de interfaz ayudan a la interacción con el usuario de la aplicación.
Sintaxis
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Muestra un mensaje en un cuadro de diálogo con el botón Aceptar
// ‐ szMensaje = Mensaje a mostrar
// ‐ szTitulo = Texto opcional para mostrar en el título del cuadro de diálogo
void alert( String szMensaje, [String szTitulo] )
// Muestra un cuadro de diálogo de confirmación
// ‐ szPregunta = Texto que se mostrará al usuario
// ‐ szTitulo = Texto opcional para mostrar en el título del cuadro de diálogo
Boolean confirm( String szPregunta, [String szTitulo] )
// Muestra un cuadro de diálogo solicitando la introducción de un dato
// ‐ szLabel = Texto descriptivo del dato a introducir
// ‐ szContIni = Valor opcional que puede mostrar el dato a introducir
// ‐ szTitulo = Texto opcional para mostrar en el título del cuadro de diálogo
String prompt( String szLabel, [String szContIni], [String szTitulo] )
Ejemplo
Ejemplo de uso de las funciones globales
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
////////////////////////////////////////////////////////////
// Cálculo del factorial de un número
// Confirmación de que se quiere ejecutar el proceso
if ( confirm("¿Seguro que desea calcular el factorial de un número?", "Confirmación") )
{
// Pedir el número a calcular
var numero = parseInt( prompt("Número a calcular", 10, "Cálculo de factural") );
// Se muestra el resultado del cálculo realizado
alert( "El factorial del número " + formatNumber( numero ) + " es " + formatNumber( factorial( numero ) ), }
// Calcula el factorial de un número
// ‐ num = Número del que se desea calcular el factorial
function factorial( num )
{
var factorial = 1;
for ( x=1; x<num+1; ++x)
{
factorial = factorial * x;
}
return( factorial );
}
// Formatear un número
// ‐ num = Número a formatear (admite decimales)
// ‐ prefix = Texto de prefijo a aplicar
// ‐ postfix = Texto de sufijo a aplicar
function formatNumber( num, prefix, postfix )
{
prefix = prefix || '';
postfix = postfix || '';
num += '';
var splitStr = num.split( '.' );
var splitLeft = splitStr[0];
var splitRight = splitStr.length > 1 ? ',' + splitStr[1] : '';
var regx = /(\d+)(\d{3})/;
while ( regx.test( splitLeft ) ) {
splitLeft = splitLeft.replace( regx, '$1' + '.' + '$2' );
}
return prefix + splitLeft + splitRight + postfix;
}
// Quitar el formato a un número
// ‐ num = Número a quitar el formateo
55
56
57
58
59
function unformatNumber( num )
{
return num.replace( /([^0‐9\,\‐])/g,'' )*1;
}
Directorio de scripts
Directorio de scripts
Descripción
Cada proyecto de Velneo V7 contiene un directorio donde podemos crear una estructura de carpetas y guardar en ellas los ficheros de scripts: QML,
JavaScript, … y sus ficheros auxiliares.
Al ejecutar una aplicación con vClient, vWebClient o vDataClient, se cargan tambien los directorios de scripts de cada proyecto de la aplicación.
Scripts reutilizables
Un mismo fichero QML o JavaScript se puede usar desde distintos objetos V7. Además, hay distintos tipos de objetos V7 que los usan como procesos,
lista QML y formulario QML. Un mismo fichero QML o JavaScript puede ser usado en objetos con distintas entradas y salidas, tabla y/o ficha/lista,
controlando el programador mediante las funciones API de los objetos de entrada/salida que nos da vJavaScript. Tambien se puede asumir que un
fichero QML o JavaScript tiene una tabla de entrada y/o salida determinadas, con el nivel de abstraccion deseado en cada fichero script.
Para introducir en un objeto V7 la propiedad “Fichero script” en el edit disponemos de un botón que nos presenta un árbol con los directorios de
scripts del proyecto en curso y de sus proyectos heredados.
Velneo V7 incorpora también editores de codigo fuente para los distintos lenguajes soportados.
Se puede usar “import” en los ficheros fuente QML para importar otros ficheros QML, JavaScript o carpetas enteras contenidas en los directorios
scripts del proyecto y heredados.
Editor de scripts
Editor de scripts
Descripción
En el componente de edición vDevelop se ha integrado un editor de scripts para facilitar la edición de los ficheros de script que se almacenan en el
directorio de scripts. El editor contempla las siguientes funcionalidades:
Coloreado de código
Como podemos ver en la imagen superior el editor contempla coloreado de código en función del lenguaje.
Autocompletar para clases y objetos
Autocompletar para funciones, señales y métodos
Autocompletar para enums de parámetros de funciones
Ayuda con los parámetros de funciones
Configuración del editor
Destacar la última opción que permite dejar configurado por defecto el tamaño de zoom que se aplicará al código cuando es editado. Para guardar el
tamaño deseado, primero debemos seleccionar el zoom deseado y luego ejecutar esta opción.
Toolbar del editor
Como vemos la toolbar incluye los botones de:
Configuración
Verificación de sintaxis de script correcta. Es recomendable verificar antes de ejecutar
Botones para copiar, cortar y pegar
Botones para deshacer y rehacer
Combo de selección manual del zoom
Botones para aumentar o disminuir el zoom
Botones para imprimir el script o guardarlo en disco en formato PDF
Toolbar de búsqueda
Con esta toolbar se pueden buscar textos en el script editado y movernos hacia adelante o hacia atrás de los ocurrencias encontradas.
Lenguajes
Lenguajes
Descripción
JavaScript
QML
Lenguajes
JavaScript
JavaScript
Descripción
Es posible crear en Velneo V7 procesos y fórmulas JavaScript para ser usados en el desarrollo de aplicaciones.
¿Qué objetos de Velneo V7 permiten la ejecución de JavaScript?
Lista QML
Formulario QML
Procesos JavaScript
Fórmulas JavaScript
¿Qué funciones de JavaScript están soportadas en Velneo V7?
En los scripts de JavaScript podremos usar:
Todo el conjunto de funciones soportadas en Qt 4.7 y que dan soporte al estándar EcmaScript­262
Todas las funciones implementadas en el nuevo API
A tener en cuenta
Por tratarse de funciones específicas del navegador, no estarán disponibles:
Funciones del DOM (Manejador de objetos del documento)
Funciones del BOM (Manejador de objetos del navegador)
JavaScript
Procesos
Procesos JavaScript
Descripción
Se ha añadido una nueva propiedad “Lenguaje” a los procesos. Las opciones disponibles son: V7 y JavaScript.
Los procesos con lenguaje JavaScript tienen las mismas propiedades que los procesos V7 salvo que en lugar del árbol de instrucciones disponemos de
un fichero de texto, en el cual escribiremos nuestro programa JavaScript.
Según el tipo de Entrada y el tipo de Salida dispondremos de distintos objetos:
Entrada
Ficha: VRegisterIn
Lista: VRegisterListIn
Salida
Ficha: VRegisterOut
Lista: VRegisterListOut
Por ejemplo en un proceso con entrada ficha y salida lista dispondremos de dos objetos: VRegisterIn con la ficha de entrada y VRegisterListOut con la
lista de salida.
Para ilustrarlo vamos a ver una comparativa del mismo proceso en V7 y en JavaScript con las siguientes tablas:
Partimos de una persona y cargamos su plural de repartos.
Cargamos las películas de los repartos.
Le pasamos las películas a la lista de salida.
Ordenamos la salida por año de mayor a menor.
Versión V7
Versión JavaScript
JavaScript
Fórmulas
Fórmulas JavaScript
Descripción
El lenguaje JavaScript ha sido implementado en las fórmulas de Velneo V7. Cualquier propiedad tipo fórmula de cualquier objeto puede ahora ser
escrita en V7 o JavaScript, independientemente del lenguaje de las otras fórmulas. Lo mismo sucede con los campos tipo fórmula dinámica que ahora
pueden escribirse en V7 o JavaScript.
En el nuevo editor de fórmulas, más simple y eficaz, disponemos de un combobox, situado en la toolbar superior, donde podemos seleccionar el
lenguaje deseado: V7 o JavaScript. Los asistentes como “Insertar campo” tienen en cuenta el lenguaje seleccionado e insertan el texto con la sintaxis
adecuada.
Por ejemplo, al insertar el campo NAME con lenguaje V7 será:
1
#NAME
y con JavaScript será:
1
vreg.fieldToString(“NAME”)
En el ejemplo se puede observar que en JavaScript ya elige el asistente automáticamente la función vreg.fieldToString de la clase VRegister según el
tipo de campo, decimales, signo, etc.
Las fórmulas JavaScript tienen conectado un objeto “vreg” de la clase VRegister a traves del cual se tiene acceso al contenido de los campos, variables
locales, globales y de sistema. Solo está disponible el juego de funciones de lectura, no el de modificación como en procesos, pués el objetivo de las
fórmulas es obtener un valor. También tienen conectado el objeto VApp, la aplicación.