Prefijos estándar de PowerBuilder

En más de una ocasión utilizamos tipos, objetos, etc., que no son los habituales, y cuando pretendemos usar sus prefijos correspondientes andamos con dudas o perdidos, por eso, y con el objetivo de siempre, de tener centralizada la información que he necesitado en más de una ocasión y he tenido que buscar repetidas veces, he decidido poner aquí también la lista de prefijos y calificadores estándar de PowerBuilder:

Calificadores de alcance

Alcance	Prefijo	Ejemplo
Argument	a	al_NameId
Global	g	gs_Name
Instance	i	ii_Count
Local	l	ls_Foo
Shared	s	si_Number

Prefijos de tipos de datos estándar

Tipo de dato	Prefijo	Ejemplo
Any	a	la_Raw
Blob	blb	ablb_Image
Boolean	b	lb_Exit
Character	c	lc_Name
Date	d	ld_BirthDate
DateTime	dt	ldt_Wreck
Decimal	dec	ldec_Salary
Double	db	gdb_OverTime
Integer	i	li_Count
Long	l	ll_RowCount
Real	r	sr_Illusion
String	s	ls_Bean
Time	tm	itm_MrWolf
Unsigned Integer	ui	lui_Handle
Unsigned Long	ul	gul_Ken

Prefijos de tipos de datos de objetos estándar

Objeto	Prefijo	Ejemplo
Application	app	gapp_PBDelta
ArrayBounds	ab	lab_Bound
CheckBox	cbx	icbx_Male
ClassDefinition	cldef	lcldef_Object
ClassDefinitionObject	cldefo	lcdefo_ThatObject
CommandButton	cb	lcb_Cancel
Connection	cn	lcn_Known
ConnectionInfo	cni	lcni_ServerInfo
ConnectObject	cno	scno_ConObj
ContextInformation	cxinfo	lcxinfo_ObjContext
ContextKeyword	cxk	lcxk_TheKey
CPlusPlus	cpp	lcpp_CModule
Datastore	ds	lds_StockData
Datawindow	dw	ldw_Employee
DatawindowChild	dwc	ldwc_States
DragObject	drg	ldrg_ByTheHair
DrawObject	drw	ldrw_PaintBrush
DropDownListBox	ddlb	lddlb_States
DropDownPictureListBox	ddplb	lddplb_StatesWithFlags
dwObject	dwo	ldwo_Column
DynamicDescriptionArea	dda	ldda_Execute
DynamicStagingArea	dsa	ldsa_MyQuery
EditMask	em	lem_PhoneNo
EnumerationDefinition	enum	lenum_Cycle
EnumerationItemDefinition	enumi	ienumi_Item
Environment	env	lenv_System
Error	err	gerr_Snarl
ExtObject	exto	gexto_Outside
Function_Object	fo	lfo_Function
Graph	gr	lgr_Sales
GraphObject	gro	lgro_Line
GrAxis	grx	lgrx_Profit
GrDispAttr	grda	igrda_Value
GroupBox	gb	igb_Employee
HScrollBar	hsb	ihsb_Percent
iNet	inet	linet_Web
InternetResult	ir	lir_Page
Line	li	lli_Arrow
ListBox	lb	llb_States
ListView	lv	llv_Filenames
ListViewItem	lvi	llvi_Item
MailFileDescription	mfd	lmfd_Mail
MailMessage	mm	lmm_Mail
MailRecipient	mr	lmr_Mail
MailSession	ms	lms_Session
MDIClient	mdi	lmdi_Frame
Menu	m	lm_Menu
MenuCascade	mc	lmc_WaterFall
Message	msg	lmsg_Whisper
MultiLineEdit	mle	lmle_Text
NonVisualObject	nvo	lnvo_Invisible
OLEControl	oc	loc_Bulls
OLECustomControl	occ	locc_Dial
OLEObject	oo	loo_Ghost
OLEStorage	ostg	gostg_WordFile
OLEStream	ostm	lostm_River
OMControl	omc	iomc_Temp
OMCustomControl	omcc	lomcc_Dial
OMEmbeddedControl	omec	lomec_Micro
OMObject	omo	iomo_Bob
OMStorage	omstg	somstg_Drive
OMStream	omstm	lomstm_Mersey
Oval	ov	lov_Circle
PBtoCPPObject	pb2cpp	lpb2cpp_Quad
Picture	p	lp_Smile
PictureButton	pb	lpb_Click
PictureListBox	plb	lplb_Drives
Pipeline	pl	lpl_OilandGas
Powerobject	po	lpo_Source
ProfileCall	prc	lprc_Face
ProfileClass	prcl	lprcl_Room
ProfileLine	prl	iprl_Bob
ProfileRoutine	prr	lprr_Cat
Profiling	pr	lpr_Outline
RadioButton	rb	lrb_Male
Rectangle	rec	irec_Tum
RemoteObject	ro	iro_Employee
RichTextEdit	rte	lrte_Script
RoundRectange	rr	lrr_Lion
ScriptDefinition	sdef	lsdef_Mycode
Service	srv	lsrv_Charge
SimpleTypeDefinition	std	istd_MyType
SingleLineEdit	sle	lsle_Name
StaticText	st	lst_Prompt
Structure	str	lstr_Data
SystemFunctions	sf	lsf_Bay
Tab	tab	ltab_Strip
Timing	tmg	ltmg_Clock
TraceActivityNode	tran	ltran_Node
TraceBeginEnd	trbe	ltrbe_Start
TraceError	tre	ltre_Error
TraceFile	trf	itrf_TraceFile
TraceGarbageCollect	trgc	itrgc_Call
TraceLine	trln	strln_Rope
TraceObject	tro	ltro_Bob
TraceRoutine	trr	ltrr_Tiger
TraceSQL	trsql	ltrsql_MySQL
TraceTree	trt	ltrt_Birch
TraceTreeError	trte	ltrte_Err
TraceTreeGarbageCollect	trtgc	ltrtgc_Trash
TraceTreeLine	trtl	ltrtl_String
TraceTreeNode	trtn	ltrtn_Kilt
TraceTreeObject	trto	ltrto_Trace
TraceTreeRoutine	trtr	ltrtr_BobGrimmer
TraceTreeUser	trtu	ltrtu_User
TraceUser	tru	ltru_Blue
Transaction	tr	ltr_Trans
Transport	tp	ltp_Server
Treeview	tv	ltv_Directory
TreeviewItem	tvi	ltvi_Node
TypeDefinition	typdef	ltypdef_Details
UserObject	uo	luo_Control
VariableCardinalityDefinition	vcd	lvcd_Type
VariableDefinition	vd	lvd_Sore
VerticalScrollBar	vsb	lvsb_Amount
Window	w	w_PleaseWait
WindowObject	wo	lwo_WomanElement

Convención de nombres de clases

Clase	Prefijo	Ejemplo
menu	m_	m_principal
Standard class user object	n_	n_ds
Custom class user object	n_cst_	n_cst_customer
Global structure	s_	s_point
Visual user object	u_	u_pb
Window	w_	w_mdi

Otras consideraciones

Las funciones globales usan el prefijo gf_ y las funciones de objetos utilizan el prefijo of_
Las constantes no suelen tener prefijo y se escriben en mayúsculas.

Encabezados dinamicos. Con un par...

Como poner un encabezado dinamico a un dw... en mi caso nunca imprimo directamente el dw, sino que paso la info. a un ds, le planto el encabezado dinámico y luego lo imprimo.

En este post solo aparece el código para poner el encabezado que deseo, si quereis ampliarlo para poder imprimir datawindows según lo he descrito podéis mirar el post anterior.

Aunque ya lo he comentado en otros post, como dato curioso, si os fijáis, sería el primer argumento de la función, que correspondería al dw o ds al que le pondremos el encabezado, pues resulta que el tipo en un powerObject, precisamente para poder aplicar el encabezado tanto a dw como a ds.

El resto de argumentos podrían eliminarse, todo depende del encabezado que deseemos, en mi caso para el argumento as_application le paso una cosntante que corresponde con el nombre de la aplicación para saber desde donde se ha impreso; para el argumento as_title, le paso el title de la ventana donde esta el dw que corresponde siempre con lo que muestra; y por último un argumento con un string para poner información en el pie de la impresión (privado, confidencial, borrador, etc.).

En siguiente ilustración representa una imagen de como quedaría... emborrone el logo por temas de confidencialidad, por cierto, si vuestro logo difiere en dimensiones, tal vez fuese necesario modificar alguna medida.


Y para finalizar aquí desempolvado y listo para usar el código responsable de añadido dinámico:

string ls_objects, ls_object, ls_where, ls_type, ls_create string ls_aux, ls_modify long ll_len, ll_from, ll_to, ll_x, ll_widthObject, ll_width long ll_addWidth, ll_posY, ll_posY1, ll_posY2, ll_height integer li_r, li_orientation, li_width datawindow ldw_aux datastore lds_aux string ls_typeObject CONSTANT integer DISPLACEMENT = 300 CONSTANT integer WIDTHA4V = 3140 CONSTANT integer WIDTHA4H = 4640 ls_objects = apo_aux.DYNAMIC describe('datawindow.objects') /******************************************************************/ /* OBTENEMOS LA ORIENTACIÓN ADECUADA Y DESPLAZAMOS LOS OBJETOS */ /******************************************************************/ // Por defecto será vertical. li_orientation = 2 // Recorremos los todos objetos. ll_len = len(ls_objects) If ll_len > 0 Then ll_from = 1 Do ll_to = pos(ls_objects, "~t", ll_from) If ll_to = 0 Then ls_object = mid(ls_objects, ll_from) Else ls_object = mid(ls_objects, ll_from, ll_to - ll_from) End If If len(ls_object) > 0 Then ll_x = long(apo_aux.DYNAMIC describe(ls_object + '.x')) ll_widthObject = long(apo_aux.DYNAMIC describe(ls_object + '.width')) // Obtenemos hasta donde llegan horizontalmente. If ll_x + ll_widthObject > ll_width Then ll_width = ll_x + ll_widthObject End If // Lo desplazamos verticalmente si esta en el encabezado. ls_where = apo_aux.DYNAMIC describe(ls_object + '.band') If ls_where = 'header' Then ls_type = apo_aux.DYNAMIC describe(ls_object + '.type') If ls_type = 'line' Then ll_posY1 = long(apo_aux.DYNAMIC describe(ls_object + '.y1')) ll_posY2 = long(apo_aux.DYNAMIC describe(ls_object + '.y2')) ls_aux = apo_aux.DYNAMIC modify(ls_object + ".y1 = ~'" + string(ll_posY1 + DISPLACEMENT) + "~'") ls_aux = apo_aux.DYNAMIC modify(ls_object + ".y2 = ~'" + string(ll_posY2 + DISPLACEMENT) + "~'") Else ll_posY = long(apo_aux.DYNAMIC describe(ls_object + '.y')) ls_aux = apo_aux.DYNAMIC modify(ls_object + ".y = ~'" + string(ll_posY + DISPLACEMENT) + "~'") End If End If End If ll_from = ll_to + 1 Loop While (ll_to > 0) // Determinamos la orientación. If ll_width > WIDTHA4V Then // Horizontal li_orientation = 1 ll_addWidth = WIDTHA4H - WIDTHA4V End If /******************************************************************/ /* ASIGNAMOS LAS OPCIONES DE IMPRESIÓN */ /******************************************************************/ ls_aux = as_application + "/" + as_title If len(ls_aux) > 31 Then ls_aux = left(ls_aux, 28) + "..." End If ls_modify = "datawindow.print.margin.top=212 datawindow.print.margin.left=242 " & + "datawindow.print.margin.right=242 datawindow.print.margin.bottom=212" & + "datawindow.print.orientation=" + string(li_orientation) + " " & + "datawindow.print.documentname=~"" + ls_aux + "~"" ls_aux = apo_aux.DYNAMIC modify(ls_modify) /******************************************************************/ /* MODIFICAMOS EL ENCABEZADO DINÁMICAMENTE */ /******************************************************************/ // Modificamos la altura del encabezado. ll_height = long(apo_aux.DYNAMIC describe("datawindow.header.height")) ll_height += DISPLACEMENT ls_aux = apo_aux.DYNAMIC modify("datawindow.header.height=" + string(ll_height)) // Creamos el rectangulo superior. ls_create = "create rectangle(band=header x=~"0~" y=~"0~" height=~"224~" " & + "width=~"" + string(WIDTHA4V + ll_addWidth) + "~" " & + "brush.hatch=~"7~" brush.color=~"553648127~" pen.style=~"0~" pen.width=~"5~" " & + "pen.color=~"0~" background.mode=~"2~" background.color=~"16777215~")" ls_aux = apo_aux.DYNAMIC modify(ls_create) // Creamos el rectangulo inferior. ls_create = "create rectangle(band=header x=~"0~" y=~"220~" height=~"80~" " & + "width=~"" + string(WIDTHA4V + ll_addWidth) + "~" " & + "brush.hatch=~"6~" brush.color=~"14869218~" pen.style=~"0~" pen.width=~"5~" " & + "pen.color=~"0~" background.mode=~"1~" background.color=~"553648127~")" ls_aux = apo_aux.DYNAMIC modify(ls_create) // Creamos el bitmap. ls_create = "create bitmap(band=Header x=~"25~" y=~"25~" height=~"180~" width=~"750~" " & + "filename=~"G:\Data\desdes01\Bmpaplic\logo.bmp~")" ls_aux = apo_aux.DYNAMIC modify(ls_create) // Creamos la etiqueta con la entidad. ls_create = "create text(band=header color=~"0~" alignment=~"0~" border=~"0~" x=~"27~" y=~"228~" " & + "height=~"64~" width=~"530~" text=~"Nombre organización.~" font.face=~"Arial~" " & + "font.height=~"55~" font.weight=~"400~" font.family=~"2~" font.pitch=~"2~" " & + "font.charset=~"0~" background.mode=~"1~" background.color=~"553648127~")" ls_aux = apo_aux.DYNAMIC modify(ls_create) // Creamos la etiqueta con el usuario que lanzó la impresión. ls_create = "create text(band=header color=~"0~" alignment=~"1~" border=~"0~" " & + "x=~"" + string((WIDTHA4V + ll_addWidth) - 526) + "~" y=~"228~" " & + "height=~"64~" width=~"503~" text=~"" + upper(gs_usuario) + "~" font.face=~"Arial~" " & + "font.height=~"55~" font.weight=~"400~" font.family=~"2~" font.pitch=~"2~" " & + "font.charset=~"0~" background.mode=~"1~" background.color=~"553648127~")" ls_aux = apo_aux.DYNAMIC modify(ls_create) // Creamos etiqueta con el título del informe. If li_orientation = 1 Then // Horizontal li_width = 66 Else // Verical li_width = 36 End If If len(as_title) > li_width Then as_title = left(as_title, li_width - 3) + '...' End If ls_create = "create text(band=header color=~"0~" alignment=~"2~" border=~"0~" x=~"791~" y=~"60~" " & + "height=~"104~" width=~"" + string((WIDTHA4V + ll_addWidth) - (791 * 2)) + "~" text=~"" + as_title + "~" " & + "font.face=~"Arial~" font.height=~"85~" font.weight=~"700~" " & + "font.family=~"2~" font.pitch=~"2~" font.charset=~"0~" background.mode=~"1~" " & + "background.color=~"553648127~")" ls_aux = apo_aux.DYNAMIC modify(ls_create) // Creamos la etiqueta con el nombre de la aplicación. ls_create = "create text(band=header color=~"0~" alignment=~"2~" border=~"0~" x=~"791~" y=~"228~" " & + "height=~"60~" width=~"" + string((WIDTHA4V + ll_addWidth) - (791 * 2)) + "~" " & + "text=~"" + as_application + "~" font.face=~"Arial~" " & + "font.height=~"55~" font.weight=~"400~" font.family=~"2~" font.pitch=~"2~" " & + "font.charset=~"0~" background.mode=~"1~" background.color=~"553648127~")" ls_aux = apo_aux.DYNAMIC modify(ls_create) // Montamos la etiqueta con la fecha y hora. ls_create = "create text(band=header color=~"0~" alignment=~"1~" border=~"0~" " & + "x=~"" + string((WIDTHA4V + ll_addWidth) - 526) + "~" y=~"24~" " & + "height=~"64~" width=~"503~" text=~"" + string(today(),'d/mm/yyyy hh:mm') + "~" " & + "font.face=~"Arial~" font.height=~"55~" font.weight=~"400~" font.family=~"2~" " & + "font.pitch=~"2~" font.charset=~"0~" background.mode=~"1~" background.color=~"553648127~")" ls_aux = apo_aux.DYNAMIC modify(ls_create) // Montamos el computado con la información de las páginas. ls_create = "create compute(band=header color=~"0~" alignment=~"1~" border=~"0~" " & + "x=~"" + string((WIDTHA4V + ll_addWidth) - 526) + "~" y=~"92~" " & + "height=~"64~" width=~"503~" format=~"[GENERAL]~" " & + "expression=~"page() + '/' + pageCount()~" " & + "font.face=~"Arial~" font.height=~"55~" font.weight=~"400~" font.family=~"2~" " & + "font.pitch=~"2~" font.charset=~"0~" background.mode=~"1~" background.color=~"553648127~")" ls_aux = apo_aux.DYNAMIC modify(ls_create) /******************************************************************/ /* MODIFICAMOS EL PIE DINÁMICAMENTE */ /******************************************************************/ // Recogemos y modificamos la altura del pie. If trim(as_footer) <> '' Then ll_height = long(apo_aux.DYNAMIC describe("DataWindow.Footer.Height")) ls_aux = apo_aux.DYNAMIC modify("DataWindow.Footer.Height=" + string(ll_height + 100)) // Montamos la etiqueta solo si corresponde. ls_create = "create text(band=footer alignment=~"2~" text=~"" + as_footer + "~" border=~"0~" color=~"0~" " & + "x=~"0~" y=~"" + string(ll_height) + "~" height=~"80~" width=~"558~" font.face=~"Arial~" font.height=~"-12~" " & + "font.weight=~"700~" font.family=~"2~" font.pitch=~"2~" font.charset=~"0~" " & + "background.mode=~"2~" background.color=~"16777215~")" ls_aux = apo_aux.DYNAMIC modify(ls_create) End If End If Return li_r
Se aceptan sugerencias y mejoras. Saludos.

Copiar "Retrieval Arguments" entre dw/ds

Si has intentando traspasar la información de un dw/ds y existían campos computados u otros elementos que hiciesen referencia a los "Retrieval Argument" (sin considerar la SQL), habrás podido observar que dicha información no se procesa de modo correcto, si son computados no aparecen y si por ejemplo un grupo se basaba en ellos tampoco aparecía el grupo.

Este problema no sucede solo al hacer copia de datos entre los dw/ds, también sucede con en método ShareData.

Hasta aquí podríamos pensar que habría que buscar mediante "describe" o "modify" las opciones necesarias para conseguir nuestros objetivos, traspasar la información de los "Retrieval Arguments", pues bien, casi, casi... resulta que podemos obtener los "Retrieval Arguments", pero no existe medio material de asignarlos a un dw o ds sin tener que recurrir al método retrieve, y en algunos casos esta operación puede ser pesada y costosa, y necesitaremos evitarla a toda costa, bueno, pues como siempre depende del objetivo final, en mi caso necesitaba conseguir que los computados funcionasen y que los grupos también lo hiciesen, así que si no tenía opción de asignar la información directamente al control, lo que hice fue modificar dinámicamente los controles afectados.

Por un lado tiré en parte con código de las PFCs pare recuperar los "Retrieval Arguments", ampliando la función para poder obtener además el valor asociado, y por otro lado, preparé una función que permitía modificar los controles que contenían información asociada a los argumentos.

Aquí os muestro una función que usaremos en nuestro código y esta sacada de las PFCs.

// Definición: integer of_parseToArray(string as_source, string as_delimiter, ref string as_array[]) long ll_DelLen, ll_Pos, ll_Count, ll_Start, ll_Length, ll_null string ls_holder // Comprobación de nulos. IF IsNull(as_source) or IsNull(as_delimiter) Then SetNull(ll_null) Return ll_null End If // Comprobamos que exista algún texto. If Trim (as_source) = '' Then Return 0 End If // Obtenemos el tamaño del delimitador. ll_DelLen = Len(as_Delimiter) // Obtenemos la posición de la primera ocurrencia dentro del origen. ll_Pos = Pos(Upper(as_source), Upper(as_Delimiter)) // Solo si existe una entrada. If ll_Pos = 0 Then as_Array[1] = as_source Return 1 End If // Si hay más de una entrada entramos en un bucle para recoger y asignar // al array cada una de ellas. ll_Count = 0 ll_Start = 1 Do While ll_Pos > 0 // Establecemos la entrada actual. ll_Length = ll_Pos - ll_Start ls_holder = Mid(as_source, ll_start, ll_length) // Actualizamos la entrada actual y el contador. ll_Count ++ as_Array[ll_Count] = ls_holder // Establecemos la nueva posición de inicio. ll_Start = ll_Pos + ll_DelLen // Obtenemos la siguiente posición de la siguiente ocurrencia. ll_Pos = Pos(Upper(as_source), Upper(as_Delimiter), ll_Start) Loop // Establecemos la última entrada. ls_holder = Mid(as_source, ll_start, Len(as_source)) // Actualizamos el array y el contador si es necesario. If Len(ls_holder) > 0 Then ll_count++ as_Array[ll_Count] = ls_holder End If // Devolvemos el número de entradas encontradas. Return ll_Count

Ahora que ya tenemos esta función que nos facilitará la vida para este y otros códigos, vamos a recoger el dw/ds los argumentos ("Retrieval Arguments") que queremos traspasar.

Fijaros como detalle en la definición de esta función que en lugar de usar como tipo de argumento dw o ds e utilizado uno de tipo powerobject para que la misma función sirva para ambos casos y después, como consecuencia lógica, tengo que hacer las llamadas de modo dinámico:

// Definición: integer of_dwGetArguments(ref powerObject apo_aux, ref string as_argName[], ref string as_argDataTypes[], ref string as_argValues[]) string ls_dwargs, ls_dwargswithtype[], ls_args[], ls_types[] long ll_a, ll_args, ll_pos, ll_index n_cst_string luo_string // Comprobamos los argumentos. if IsNull(apo_aux) or not IsValid(apo_aux) then return -1 end if // Obtenemos el string con los argumentos del dw o ds. ls_dwargs = apo_aux.DYNAMIC Describe ( "DataWindow.Table.Arguments" ) // Separamos los argumentos utilizando la un array y obtenemos el número total. ll_args = luo_string.of_ParseToArray ( ls_dwargs, "~n", ls_dwargswithtype ) // Ahora separamos el nombre del argumento de su tipo y además obtenemos el valor. For ll_a = 1 to ll_args ll_pos = Pos ( ls_dwargswithtype[ll_a], "~t", 1 ) If ll_pos > 0 Then ll_index = UpperBound(as_argnames) + 1 as_argNames[ll_index] = Left ( ls_dwargswithtype[ll_a], ll_pos - 1 ) as_argDataTypes[ll_index] = Mid ( ls_dwargswithtype[ll_a], ll_pos + 1 ) // Cargamos el valor correspondiente. Si es de tipo array ponemos cadena vacía. If right(as_argDataTypes[ll_index], 4) = 'list' Then as_argValues[ll_index] = '' Else as_argValues[ll_index] = apo_aux.DYNAMIC Describe("evaluate('" + as_argNames[UpperBound(as_argnames)] + "',1)") End If End If Next Return UpperBound ( as_argnames )

Otra apreciación sobre la última función descrita es que solo se puede implementar sobre "Retrieval Arguments" que no sean de tipo array, pero esto no un impedimento para nuestros objetivos, ya que estos solo se puede usar en la sentencia SQL y nosotros los datos los traspasaremos con el método ShareData.

Ahora nos queda la parte en la que ponemos los "Retrieval Arguments" en el datawindow o datastore destino. Nota: en mi caso se trataba de imprimir un ds que podría proceder de un dw u otro ds, por eso el argumento utilizado es de este tipo, pero si queréis utilizarlo para ds o dw podéis aplicar el truco comentado de la función anterior.

// Definición: of_dwSetArguments(Ref datastore ads_aux, string as_argNames[], string as_argDataTypes[], string as_argValues[]) string ls_object, ls_objects, ls_type, ls_expression string ls_value, ls_aux integer li_len, li_to, li_from, li_x, li_pos // Obtenemos la colección de objetos de ds. ls_objects = ads_aux.describe('datawindow.objects') // Recorremos los todos objetos. li_len = len(ls_objects) If li_len > 0 Then // Inicializamos la variable necesaria desde la que buscamos el siguiente objeto. li_from = 1 // Recorremos todos los objetos. Do li_to = pos(ls_objects, "~t", li_from) // Obtenemos el nombre del objeto. If li_to = 0 Then ls_object = mid(ls_objects, li_from) Else ls_object = mid(ls_objects, li_from, li_to - li_from) End If If len(ls_object) > 0 Then // Obtenemos el tipo del objeto. ls_type = ads_aux.describe(ls_object + '.type') // Solo si es computado comprobamos si su expresión contiene "retrieval arguments". If ls_type = "compute" Then ls_expression = ads_aux.describe(ls_object + '.expression') // Para cada objeto miramos todos los "retrieval arguments". For li_x = 1 To upperBound(as_argNames) // Solo tratamos argumentos que no sean array. If right(as_argDataTypes[li_x], 4) = 'list' Then Continue Else li_pos = pos(ls_expression, as_argNames[li_x]) Do While li_pos > 0 // Comprobamos que no sea otro identificador distinto, para lo que // el carácter que lo precede y el que le sigue debe ser distinto // de letra o número. (si buscamos 'numeropi' que no tome 'numeropista') If ((li_pos = 1) Or match(mid(ls_expression, li_pos -1, 1), '[^A-Z^a-z^0-9]')) And & ((li_pos + len(as_argNames[li_x]) - 1 = len(ls_expression)) Or match(mid(ls_expression, li_pos + len(as_argNames[li_x]), 1), '[^A-Z^a-z^0-9]')) Then ls_value = as_argValues[li_x] // Obtenemos la nueva expresión para el computado en base al tipo de dato. Choose Case as_argDataTypes[li_x] Case 'number' ls_aux = ls_value Case 'string' ls_aux = "'" + ls_value + "'" Case 'date' ls_aux = "date('" + ls_value + "')" Case 'time' ls_aux = "time('" + ls_value + "')" Case 'datetime' ls_aux = "datetime(date(left('" + ls_value + "', 10)), time(mid('" + ls_value + "', 12, 8)))" Case Else // En un computado no podría aparecer otro tipo. End Choose ls_expression = replace(ls_expression, li_pos, len(as_argNames[li_x]), ls_aux) End If // Buscamos si la misma ocurrencia aparece otra vez. li_pos = pos(ls_expression, as_argNames[li_x]) Loop End If Next // Si se modifico la expresión para el compute la sustituimos con la nueva. If ls_expression <> ads_aux.describe(ls_object + '.expression') Then // Antes de hacer el modify, hay que añadir delante de las comillas dobles la virgulilla. li_pos = pos(ls_expression, '"') do while li_pos > 0 ls_expression = replace(ls_expression, li_pos, 0, "~~") li_pos = pos(ls_expression, '"', li_pos + 2) Loop ls_aux = ads_aux.Modify(ls_object + ".expression=~"" + ls_expression + "~"") End If End If End If li_from = li_to + 1 Loop While (li_to > 0) End If

Ya solo queda ver un ejemplo en el que se vea claramente como utilizar las funciones descritas hasta el momento. Ya comente que en mi caso utilizo este tinglado para añadir dinámicamente una cabecera standard a todos mis dw o ds en el momento de imprimirlos, para lo cual utilizo una función:

// Definición: of_printwithheader(ref datawindow adw_aux, string as_application, string as_title, string as_footer) string ls_syntax, ls_err, ls_argNames[], ls_argDataTypes[], ls_argValues[] integer li_r datastore lds_aux // Obtenemos la syntax del dw original. ls_syntax = adw_aux.Describe("datawindow.syntax") // Creamos el datastore para realizar los cambios sobre él y no sobre el dw original. lds_aux = CREATE datastore lds_aux.Create(ls_syntax, ls_err) // Modificamos los campos calculados si se basan en los argumentos. This.of_dwGetArguments(adw_aux, ls_argNames, ls_argDataTypes, ls_argValues) This.of_dwSetArguments(lds_aux, ls_argNames, ls_argDataTypes, ls_argValues) // Compartimos los datos del dw original con el ds. adw_aux.shareData(lds_aux) // Montamos los encabezados en el ds (NO DESCRITO EN ESTE POST). li_r = This.of_setHeader(lds_aux, as_application, as_title, as_footer) If li_r = 0 Then // Imprimimos el ds. li_r = lds_aux.print() End If // Dejamos de compartir los datos y eliminamos el ds temporal. lds_aux.shareDataOff() DESTROY lds_aux // Retornamos el valor de retorno de la impresión. Return li_r

Espero haber solucionado más de un quebradero de cabeza. Hasta pronto.

VerticalScrollPosition y HorizontalScrollPosition

Extendiendo el "Post" anterior podemos añadir el mensaje 276 para el control del desplazamiento horizontal. Para disponer de un control detallado de los posibles desplazamientos, las constantes que podríamos utilizar son:

// Mensajes de scroll. WM_HSCROLL 276 //Scroll Horizontal WM_VSCROLL 277 //Scroll Vertical // El parámetro LowWord determina como desplazarnos. CONTANT integer SB_LINEUP = 0 //Subir una línea. CONTANT integer SB_LINELEFT = 0 //Una posición a la izq. CONTANT integer SB_LINEDOWN = 1 //Bajar una línea CONTANT integer SB_LINERIGHT = 1 //Una posición a la dcha. CONTANT integer SB_PAGEUP = 2 //Subir una página. CONTANT integer SB_PAGELEFT = 2 //Una página a la izq. CONTANT integer SB_PAGEDOWN = 3 //Bajar una página. CONTANT integer SB_PAGERIGTH = 3 //Una posición a la dcha. CONTANT integer SB_PAGETOP = 6 //Ir arriba. CONTANT integer SB_LEFT = 6 //Ir a la izq. CONTANT integer SB_PAGEBOTTOM = 7 //Ir abajo. CONTANT integer SB_RIGHT = 7 //Ir a la dcha. CONTANT integer SB_ENDSCROLL = 8 //Ir al final.

De todos modos, al final he optado por otra solución en la que utilizo describe y modify sobre VerticalScrollPosition, HorizontalScrollPosition y Horizontal2ScrollPosition, ya que en mi caso, me interesa desplazarme a una posición en la que se visualiza un objeto en concreto, y me permitiría el control horizontal de las dos áreas visibles del dw si esta activado el atributo HSplitScroll. Así que la parte del código que controla el error queda del siguiente modo (tras controlar el error y notificarlo):

dw_x.setColumn(ls_campo) dw_x.modify("datawindow.VerticalScrollPosition = " & + dw_x.describe(ls_campo + ".y")) dw_1.setFocus()
¿Qué tal se portaron los Reyes?

Scroll en un datawindow con PowerScript

Tras un error controlado necesité poner el foco en el control que el usuario tiene que corregir, pero trabajando con un formulario de tipo freeform, con una fila que ocupa más de una página, si el control no esta visible, aunque reciba el foco no se desplaza el dw, por lo que es necesario desplazarlo manualmente desde código. Mandando un mensaje al control podremos hacer scroll en los dw desde el código:

// scroll hacia arriba una lína Send(Handle(dw_1), 277, 0, 0) // scroll hacia abajo una línea Send(Handle(dw_1), 277, 1, 0) // scroll hacia arriba una página Send(Handle(dw_1), 277, 2, 0) // scroll hacia abajo un página Send(Handle(dw_1), 277, 3, 0)
Felices Reyes

Convertir a números cardinales

En más de una ocasión me he visto en la necesidad de convertir el contenido de una variable numérica a un string con el número en cardinal representado con texto, así que en adelante si me sucede ya sólo tendré que llegarme hasta aquí. En esta ocasión principalmente encontrareis el código sin muchos comentarios como otras veces, deciros que es mejorable, que se puede hacer más genérica y tratar el género, la moneda para trabajar con distintas divisas, las apócopes, etc. En mi caso la he centrado en el Euro con sus correspondientes céntimos, si cambia la moneda que usáis y también tiene fracción, solo tendréis que cambiar los literales correspondientes. La declaración de la función sería: string f_numberToCardinal(decimal adc_value) y el código quedaría así:

string ls_r, ls_cadena, ls_aux int li_terna, li_fraccion, li_unidad integer li_decena, li_centena dec{0} ldc_entero boolean lb_todoCeros, lb_soloLaUnidad string ls_unidades[9], ls_decenas[9], ls_centenas[9] string ls_decenas1[0 to 6], ls_decenas2[0 to 6] ls_unidades = {'UN','DOS','TRES','CUATRO','CINCO', 'SEIS','SIETE','OCHO','NUEVE'} ls_decenas = {'','','TREINTA','CUARENTA','CINCUENTA', 'SESENTA','SETENTA','OCHENTA','NOVENTA'} ls_centenas = {'','DOSCIENTOS','TRESCIENTOS', 'CUATROCIENTOS','QUINIENTOS','SEISCIENTOS','SETECIENTOS','OCHOCIENTOS','NOVECIENTOS'} ls_decenas1 = {'DIEZ','ONCE','DOCE','TRECE', 'CATORCE','QUINCE','DIECISEÍS'} ls_decenas2 = {'VEINTE','VEINTIÚN','VEINTIDÓS', 'VEINTITRÉS','','','VEINTISÉIS'} // Recogemos la parte entera y la fracción. ldc_entero = truncate(adc_value, 0) li_fraccion = (truncate(adc_value, 2) - ldc_entero) * 100 Do While ldc_entero > 0 // Indicamos la terna actual. li_terna ++ // Se recorre el número por ternas. ls_cadena = '' li_unidad = mod(ldc_entero, 10) ldc_entero = truncate(ldc_entero / 10, 0) li_decena = mod(ldc_entero, 10) ldc_entero = truncate(ldc_entero / 10, 0) li_centena = mod(ldc_entero, 10) ldc_entero = truncate(ldc_entero / 10, 0) // Se analizan las unidades. If li_unidad <> 0 Then ls_cadena = ls_unidades[li_unidad] + ' ' End If // Se analizan las decenas. Choose Case li_decena Case 1 Choose Case li_unidad Case 0, 1, 2, 3, 4, 5, 6 ls_cadena = ls_decenas1[li_unidad] + ' ' Case Else ls_cadena = 'DIECI' + ls_cadena End Choose Case 2 Choose Case li_unidad Case 0, 1, 2, 3, 6 ls_cadena = ls_decenas2[li_unidad] + ' ' Case Else ls_cadena = 'VEINTI' + ls_cadena End Choose Case 3, 4, 5, 6, 7, 8, 9 If li_unidad = 0 Then ls_cadena = ls_decenas[li_decena] + ' ' + ls_cadena Else ls_cadena = ls_decenas[li_decena] + ' Y ' + ls_cadena End If End Choose // Se analizan las centenas. Choose Case li_centena Case 1 If li_unidad = 0 And li_decena = 0 Then ls_cadena = 'CIEN ' Else ls_cadena = 'CIENTO ' + ls_cadena End If Case 2, 3, 4, 5, 6, 7, 8, 9 ls_cadena = ls_centenas[li_centena] + ' ' + ls_cadena End Choose // Analizamos la terna. lb_todoCeros = ((li_unidad+li_decena+li_centena) = 0) lb_soloLaUnidad = (li_unidad = 1 And & (li_decena + li_centena = 0)) Choose Case li_terna Case 2 If Not lb_todoCeros Then If lb_soloLaUnidad Then ls_cadena = 'MIL ' Else ls_cadena += 'MIL ' End If End If Case 3 If Not lb_todoCeros Then If lb_soloLaUnidad Then ls_cadena += 'MILLÓN ' Else ls_cadena += 'MILLONES ' End If End If Case 4 If lb_soloLaUnidad Then ls_cadena = 'MIL MILLONES ' Else ls_cadena += 'MIL MILLONES ' End If Case Else If li_terna <> 1 Then ldc_entero = 0 ls_cadena = '' End If End Choose // Se monta el sultado de la terna actual con el de las anteriores. ls_r = ls_cadena + ls_r Loop // Utilizamos la recursividad para montar el literal de los decimales. If li_fraccion <> 0 Then ls_aux = trim(gf_numbertoletter(li_fraccion)) // Como se retorno como parte entera llega con EURO/EUROS y hay que quitarlo. ls_aux = trim(left(ls_aux, len(ls_aux) - 5)) If li_fraccion = 1 Then ls_aux = 'UN CÉNTIMO' Else ls_aux += ' CÉNTIMOS' End If End If // Montamos la salida final según corresponda. If li_terna = 0 Then // Solo tiene parte decimal. ls_r = ls_aux Else // Hay que añadir el modificar 'de' si es multiplo // de 1000000. If mod(truncate(adc_value,0),1000000)=0 Then ls_r+='DE ' // Añadimos la moneda a la parte entera. If truncate(adc_value, 0) = 1 Then ls_r = 'UN EURO' Else ls_r += 'EUROS' End If // Hay que añadir la parte decimal si la tiene. If ls_aux<>'' Then ls_r = trim(ls_r) + ' CON ' + ls_aux End If Return ls_r

Algo que es interesante es el uso de la recursividad para resolver el
tema de los céntimos... ¿Qué os parece? Bueno, para no salirme de la tónica... espero que también os sirva a vosotros también.

Números contenidos en otros

Si habéis trabajado con las APIs u otros lenguajes de programación conoceréis que determinados parámetros de muchas funciones están compuestos por la suma de más de un número, de tal modo que dicho número posteriormente permite conocer cuales son los que le componen. Para empezar, los números utilizados para conseguir la suma deben ser el doble que el anterior o si se representan en binario solo los que tengan el primer bit a uno:

  1          1
  2         10
  4        100
  8       1000
 16      10000
 32     100000
 64    1000000
128   10000000

Según lo anterior, un parámetro que contenga el número 145 estará compuesto por los números 128 + 16 + 1, otros entornos tienen su propia función para determinar si un número esta contenido en otro (por decirlo de algún modo), y no es el caso de PowerBuilder, por lo que tendremos que crearnos nuestra propia función para determinar esto, y así poder utilizar este tipo de números para trabajar con Apis o para nuestro uso directo. Según el ejemplo anterior el 145 en binario sería 10010001, de tal modo que es fácil determinar si el número decimal 16 (en binario 10000) esta dentro del 145, pasando ambos a binario y comprobando si la posición (de derecha a izquierda) del bit a 1 del número buscado, también es 1 en el número en el que se busca:

10010001 número en el que se busca
00010000 número buscado

Con la lógica seguida hasta este punto ya solo queda pasar ambos número a binario, por lo que, de modo elegante, sería una función para la operación de conversión y otra para la comparación del bit:

Convertir en binario - string xx_aBinario(ulong aul_numero):

// Tras las comprobaciones correspondientes del parámetro proporcionado, quedaría algo así. string ls_binario int li_resto Do Until aul_nummero = 0 li_resto = mod(aul_nummero ; 2) aul_number = aul_nummero / 2 // Se monta el binario de derecha a izquierda. ls_binario = string(li_resto) + ls_binario Loop Return ls_binario

Comparación del bit - contieneNumero(ulong aul_numeroContenedor,ulong aul_numeroContenido):

// Esta función se le llamaría del siguiente modo xx_contieneNumero(145, 16). // Si lo contiene retorna True, en caso contrario False. // Tras las comprobaciones pertinentes de los parámetros quedaría así: string ls_cotenerdor, ls_contenido ls_contenedor = string(aul_numeroContenedor) ls_contenido = string(aul_numeroContenido) If left(right(ls_contenedor,len(ls_conetido)),1)='1' Then Return True Else Return False End If

Este es un método como otro cualquiera, hay muchos otros, recuerdo que antes de conocer el tema de los bit en los binarios me dedicaba a montar un bucle donde obtenía el número mayor doble del anterior partiendo desde uno y que fuera inferior al numero contenedor, el resultado era el mayor contenido, después al restar al contenedor el número mayor contenido, repetía la operación y obtenía así cada uno de los contenidos en la suma, claro esta que en cuanto aparecía el que buscaba salia, en caso contrario indicaba que no estaba contenido... y esto sigue, si os dais una vuelta por las PFCs encontrareis otro método.

Como siempre, espero que os sirva.

Trabajar con años y meses comerciales

He podido ver en más de un programa como se trabaja con formulas para cálculos de interés con años y meses comerciales (en adelante calendario comercial) y luego para realizar operaciones entre fechas o liquidaciones se utiliza el calendario natural, por lo que al final no corresponden los resultados finales. La cuestión de todo el descabale se basa en que se utilizan funciones convencionales para calcular la diferencia entre dos fechas, cuando en realidad este tipo de formulas no funcionan, ya que asignan a cada mes su día final correcto según el calendario natural, pero el comercial, siempre debe tener 30 días, tanto si es febrero, como bisiesto o tiene 31 días.

Para evitar esto desarrollé un método que determina diferencia entre fechas utilizando el calendario comercial y con un par de funciones extras.

El método utiliza como argumentos iniciales dos fechas (desde y hasta), que son entre las que se tiene que calcular la diferencia, por otro lado, aparece otro parámetro de tipo boleano que permite indicar si hay que realizar ajuste por día de inicio o final de mes de la fecha hasta... no me parece claro como lo explique, así que un ejemplo: Si el día de la fecha "desde" es superior al día de la fecha "hasta" y el día de la fecha "hasta" es final de mes, se realiza un ajuste para que cuadre el resultado en meses. Ahora con fechas y números reales, si a una fecha inicial 30/12/2006 le sumamos dos meses (que no 60 días) obtenemos una fecha real final 28/02/2007, si descomponemos ambas fechas pasando a días cada una de sus partes y obtenemos la diferencia, nos arroja en este caso un resultado de 58, sin embargo en este caso para cálculos comerciales, me puede interesar que nos de los 60 días correspondientes a los 2 meses comerciales, ya que el fecha final es la que es porque no existe 30/02/xxxx. Este caso se detecta comprobando que la fecha "hasta" es un final de mes y que el día de la fecha "desde" es superior al día de la fecha "hasta", para lo que habría que indicar que se tengan en cuenta los días de diferencia entre ambas fechas en el resultado final.

Tener en cuenta si en nuestras cuentas de días se deben considerar los dos días pasados como argumentos o solo uno ellos. Fijaros que en el primer caso del 15/xx/xxxx al 15/xx+1/xxxx transcurren 31 días y no 30. Para considerar este último comentario en el algoritmo resultante solo tendríais que añadir, o no, una unidad al total resultante. Todo esto queda del siguiente modo:

long ll_r, ll_daysInitial, ll_daysEnd, ll_ajuste integer li_day setNull(ll_r) // Comprobamos los argumentos. If IsNull(ad_initial) Or IsNull(ad_end) Then Return ll_r End If // Calculamos el total de días para la fecha inicial. li_day = day(ad_initial) If li_day > 30 Then li_day = 30 End If ll_daysInitial = (year(ad_initial) * 360) + (month(ad_initial) * 30) + li_day // Calculamos el total de días para la fecha final. li_day = day(ad_end) If li_day > 30 Then li_day = 30 End If ll_daysEnd = (year(ad_end) * 360) + (month(ad_end) * 30) + li_day // Obtenemos la diferencia de días. ll_r = ll_daysEnd - ll_daysInitial // Según el tercer argumento booleano realizamos // o no el ajuste. If ab_ajustar Then If month(relativeDate(ad_end, 1)) > month(ad_end) Then ll_ajuste = day(ad_end) - day(ad_initial) If ll_ajuste > 0 Then ll_r += ll_ajuste End If End If End If Return ll_r

Como siempre, espero que os sea de utilidad al resto.

Crear objetos de Forma dinámica en un UserObject

Este post se origina con la respuesta que he dado en un foro de Sybase a este tema. Me parece interesante dejarlo aquí para que no se quede en el tintero, luego es muy difícil localizar temas antiguos en los foros.

La problemática surge de que en PB no se puede añadir un objeto, creado de modo dinámico, sobre un objeto de usuario visual. Sin embargo esto si se puede hacer sobre una ventana, así que utilizaremos esta opción para lograr lo que PB no nos permite hacer directamente.

Como se puede resolver... pues muy sencillo, hacemos el CREATE del objeto que queremos poner dinámicamente, le asignamos false a la propiedad visible y utilizamos la función OpenUserObject para pegarlo sobre la propia ventana donde se encuentra nuestro objeto visual, como el objeto esta invisible no se ve, después cambiamos mediante una función de API el padre del objeto creado dinámicamente y le asignamos como nuevo padre nuestro objeto visual y para terminar y antes de cambiar el atributo de visible, asignamos las propiedades que queremos al objeto en cuestión... Así se pierde mucho uno, por lo que lo mostraré con código. Reutilizaré el del post con las modificaciones necesarias para que funcione correctamente. Para poneros en antecedentes se trata de un objeto visual de usuario que se utilizará de barra de herramientas:

VARIABLES DE INSTANCIA DEL UO_BARRA_BOTONES:

PictureButton iPb_Button[] Integer iIndex[], iLastIndex window iw_win Long iHandle[] Integer iLastX = 4, iLastY = 4 Constant Integer HEIGHT_BUTTON = 88 Constant Integer WIDTH_BUTTON = 110

DECLARACIÓN DE FUNCIÓN EXTERNA:

Function ulong SetParent (ulong hWndChild, ulong hWndNewParent) Library "USER32.DLL"

CONSTRUCTOR DEL UO_BARRA_BOTONES:

iw_win = Parent

MÉTODO ADD:

////////////////////////////////////////////////// // Objeto: uo_barra_botones // // Función: of_add // // Argumentos: value integer ai_id // value string as_picture // value string as_tag // value boolean ab_initialstate // // Retorno: integer // // Descripción: Añade un botón en la barra y // recalcula la siguiente posición // ////////////////////////////////////////////////// iLastIndex = UpperBound(ipb_button) iLastIndex ++ ipb_button[iLastIndex] = Create PictureButton ipb_button[iLastIndex].visible = True // Después de crear el PictureButton lo ponemos sobre la // ventana donde esta el objeto visual de usuario. iw_win.openUserObject(ipb_button[iLastIndex]) // Obtenemos el Handle del PictureButton. iHandle[iLastIndex] = Handle(ipb_button[iLastIndex]) // Cambiamos el Padre del PictureButton asignandole ahora // como tal al uo_barra_botoenes SetParent( iHandle[iLastIndex], Handle(This)) // Aquí continuamos con el código normal... sin // olvidarse de hacerlo visible. ipb_button[iLastIndex].x = iLastX ipb_button[iLastIndex].y = iLastY ipb_button[iLastIndex].height = HEIGHT_BUTTON ipb_button[iLastIndex].Width = WIDTH_BUTTON ipb_button[iLastIndex].visible = True ipb_button[iLastIndex].enabled = ab_InitialState iLastX = iLastX + HEIGHT_BUTTON iIndex[iLastIndex] = ai_Id Return 1

Espero que os sirva a todos.

VScrollBar siempre visibles

Cuando la cantidad de páginas mostradas en un dw es solo una, la barra de desplazamiento vertical no aparece y en ocasiones estéticamente puede molestar. PowerBuilder no permite dejar la barra siempre visible y que esta este activa o no según corresponda, pero podemos simularlo utilizando APIS de Windows:

Declaración de funciones externas:

Function boolean ShowScrollBar(long hWnd, long wBar, boolean bShow) Library 'user32' Function boolean EnableScrollBar(long hWnd, ulong wSBflags, ulong wArrows) Library 'user32'

Función:

// Esta función debe llamarse siempre que se inserten o eliminen filas en el dw. Constant long SB_HORZ = 0 Constant long SB_VERT = 1 Constant long SB_CTL = 2 Constant long SB_BOTH = 3 Constant Long ESB_ENABLE_BOTH = 0 Constant Long ESB_DISABLE_BOTH = 3 long ll_pageCount string ls_aux ls_aux = dw_1.describe("evaluate('pageCount()', 0)") ll_pageCount = long(ls_aux) If ll_pageCount = 1 Then If dw_1.vScrollBar Then dw_1.vScrollBar = False ShowScrollBar(handle(dw_1),SB_VERT, True) EnableScrollBar(handle(dw_1),SB_VERT,ESB_DISABLE_BOTH) End If Else If Not dw_1.vScrollBar Then dw_1.vScrollBar = True EnableScrollBar(Handle(dw_1),SB_VERT,ESB_ENABLE_BOTH) End If End If

BreakPoints en el Debug (Los menos usados)

Todos utilizamos el debug, pero por lo general no aprovechamos toda su potencia. Ya estamos acostumbrados al Watch de PB, pero rara vez utilizamos las opciones avanzadas de los puntos de interrupción. Cada vez que me toca usarlas, tengo que tirar de la ayuda en html de PB, para recordar como se hacía, y en muchos casos tiramos por la calle de en medio poniendo un IF dentro del bucle que modifica una variable que queremos comprobar cuando alcanzo cierto valor.

Hoy ha tocado, y por eso he querido poner aquí y compartir la sencillez y potencia de las opciones avanzadas de los puntos de interrupción.

Parar cuando queremos parar si una variable cambia de valor:

El punto de interrupción se puede aplicar sobre cualquier variable dentro del alcance. Aquí hay una cosa importante, que es lo que siempre me ha estado confundiendo y es que si estamos en el Painter del Debug pero sin tener este arrancado, solo podemos indicar variables globales, para indicar que se pare cuando una variable local cambie, hay que lanzar el la aplicación en modo debug con una parada dentro del código donde se encuentra la variable local que deseamos utilizar para pausar el debug, y en ese momento ya podemos indicar que variable deseamos que pause el debug cuando esta cambie.

Para poner los puntos de interrupción asociados al cambio de la variable podemos arrastrarla desde el watch o la zona de variables a la zona de BreakPoints, o hacer en dichos sitios click con el botón derecho sobre la variable e indicar “Break on Change”, también en la ventana “Edit BreakPoints” en la ficha de “Variable” podemos añadir una nueva.

Como parar el debug cuando una variable alcance un valor determinado:

El método, creo que más sencillo, es poner un punto de interrupción normal y hacer doble click sobre él en la zona “Breakpoints” y en el cuadro de diálogo que aparece poner la condición deseada, por ej.: li_x = 5, al aceptar, podremos ver en la zona Breakpoints dicha condición del siguiente modo: objeto.evento.linea when li_x = 5.

Además, podemos indicar el número total de ocurrencias que deben darse para realizar una parada, de tal modo que si ponemos un punto de interrupción e indicamos que han de darse 3 ocurrencias, has que no se pase tres veces por ese punto no se pausara el debug, una vez pausado se reinicia el contador interno y sucederá lo mismo si otra vez se llega a 3 veces (según este ejemplo).

Si al introducir el número de ocurrencia lo hacemos junto con una condición no se pausará del debug has que dicha condición se de tres veces.

Lo que falta:

Sería una gozada poder parar el debug cuando una variable cambiara X veces. Cuidado, no hay que confundir esta opción con la de que se pause el debug en un punto determinado del código cuando la variable alcance un valor. Si os fijáis en el cuadro de diálogo “Edit Breakpoints” en la ficha “Variables”, podemos introducir la variable que deseamos que pare el debug cuando cambie, pero sin poder indicarle aquí el número de veces.

Evaluación de Traslation Toolkit de PB

Hemos tenido que traducir una aplicación en la empresa, y hemos evaluado tres posibilidades para realizar esta tarea: directamente sobre una copia de los fuentes, mediante una herramienta denominada Enable de "Best In", o mediante PowerBuilder Translation Toolkit, herramienta de todos conocida, por incluirse en el paquete de aplicaciones de PB, pero que pocos han necesitado usar.

Entre las tres opciones, y pensando que incialmente que deberían mantenerse tanto la versión en Español como la de Ingles, y no siendo un requerimiento cambiar de idioma en "Caliente", se decidió usar Translation Toolkit.

Mi opinión es que es una herramienta útil inicialmente, ya que extrae frases de donde uno no se lo espera, como por ejemplo de los checkBox, de los DisplayValue de los DropDawnListBox, etc., pero peca en el tema de los redimensionamientos de las cajas donde aparecen los textos, y el problema no es que no ajuste los tamaños inicialmente, sino que biene despues.

Una vez traducido todo en un diccionario almacenado en una BD, podemos generar el nuevo código con las frases traducidas, y luego nos queda la ardua labor de redimensionar las cajas necesarias... bueno, esto podría se parte del trabajo, pero la putada no es esta, la putada es que al cambiar una frase de un objeto de una librería y pedirle que genere otra vez la versión traducida, te machaca toda la pbl donde se encuentre dicho objeto, por lo que habría que volver a redimensionar todos los controles.

Al final, en nuestro caso, después de la traducción inicial se decidió mantener solo la versión traducida, por lo que ya tocamos directamente sobre el código y nos quitamos de rollos.

La siguiente imagen corresponde con el módulo que permite definir el proyecto y marcar los objetos del mismo que deben traducirse:

Esta otra imagen corresponde con el módulo que permite traducir las frases, lo que esta bien para esto es que dispone de un acceso independiente para acceder solo a este módulo para que un traductor se pueda encargar de esta parte, sin acceso al resto de la herramienta:

Y por último os muestro una pantalla donde se seleccionan los objetos que se quieren traducir, en este caso se seleccionan los objetos para los que hay que cambiar las frases:

Evaluación Visual Expert

Este producto ya lo vi hace tiempo y recientemente he tenido la oportunidad de asistir a una presentación del mismo en mi empresa, ya que se plantean la posibilidad de adquirirlo. Los AP tenemos que dar el visto bueno, y después, como en cualquier gran multinacional, empiezan los trámites burocráticos, hasta conseguir la compra. En principio, los tres AP pensamos que pueden ayudarnos en nuestro trabajo, ya que da mucha facilidad a la hora de localizar objetos dentro de la aplicación, pero ante todo la mayor ventaja es la evaluación de impacto sobre el cambio de cualquier elemento, ya que podemos visualizar de un modo cómodo, el resto de elementos que hacen uso del que nosotros queremos cambiar. Saber usarlo no parece complicado, por lo menos en cuanto a las cosas sencillas y elementales, los detalles complejos supongo que se podrán resolver mediante la ayuda, aunque esta pueda ser algo escasa, o más que escasa, que carezca de suficientes palabras claves para localizar lo que nos interesa, esto lo comento, por que en la misma presentación tuvimos una duda de uso e intente buscar en la ayuda y fue imposible localizar lo que queríamos resolver. También facilita la generación de documentación técnica e informes como por ejemplo variables sin utilizar, pudiendo especificar el alcance de las mismas, y otra serie de filtros, en general este apartado esta bien, lastima que no exista aún aplicaciones que generen la documentación funcional y el manual de usuario. El producto es multilenguaje (francés, ingles y español) y puedes cambiar el idioma en caliente, pero hay cosas que no se traducen, por supuesto la ayuda siempre estará en correcto ingles.En definitiva son muchos más pros que contras y nos puede ayudar bastante, claro esta que hay que conocer sus apellidos, que en este caso, hoy por hoy ronda los 7.000 € e incluye tres licencias, y cuantas más licencias necesites, como es de esperar, más económica resulta cada una de ellas. Si queréis más información la podéis encontrar en la Web de Visual Expert. Este es el aspecto general de la aplicación:

Aun tendremos que realizar una revisión pendiente, por lo que iré actualizando directamente el post, para poner cualquier información que se interesante destacar.

Función para obtener el módulo

Tal vez aquí se podría abrir un tema de discusión, en cuanto a la capacidad de las funciones de sistema de PB para tratar números de precisión doble o real. Muchas de estas funciones, como por ejemplo truncate, round o string (para conversiones de números), solo son capaces de trabajar adecuadamente con variables decimal, aunque la ayuda no lo especifique. Por otro lado, y centrandome en el tema que me ocupa en este post, la función mod, que si parece ser capaz de trabajar con variables de precisión doble, no figurá en el browser/funtions/systemfuntions que este sobrescrita, y por código o en el watch del debug, se puede comprobar que debe existir una definición para doble y otra para long. Además, por razones de precisión cuando debe obtenerse los módulos de números muy grandes, se recomienda utilizar números enteros y no fraccionados o decimales, y el algoritmo que se necesita para dicha operación requiere cortar el número como si se tratase de una cadena, y en base de datos, el número con el que tenemos que trabajar en nuestro caso esta almacenado como cadena, ya que a excepción de la comprobación del dígito de control, no se realiza ninguna otra operación, por esto he creado una función que admite dos parámetros, por un lado un string con el número que del que hay que obtener el módulo y otro argumento con el divisor, en este caso un integer. La función queda así:

DEFINICIÓN:

integer uf_modlong(string as_valor, integer ai_divisor)

CÓDIGO:

integer li_total, li_desde, li_hasta, li_r string ls_mod, ls_aux boolean lb_salir li_total = len(as_valor) Do // Calculamos el fragmento del string que debemos tratar. li_desde = li_hasta + 1 li_hasta = li_desde + 8 - len(ls_mod) // Determinamos si hay que continuar partiendo. If li_total >= li_desde Then // Hay que continuar partiendo. ls_aux = ls_mod ls_aux += mid(as_valor, li_desde, li_hasta-li_desde+1) // Calculamos el módulo. ls_mod = string(mod(long(ls_aux), ai_divisor)) Else // Hemos realizado todas las particiones necesarias. lb_salir = True li_r = integer(ls_mod) End If Loop Until lb_salir Return li_r

Comprobación del dígito de control del IBAN

En este script, partimos de la premisa de disponer del IBAN formateado adecuadamente, así iremos al grano, y dejo que cada cual utilice las comprobaciones que considere oportunas para ver si el IBAN tiene el formato adecuado. Para concretar más el formato utilizado para el ejemplo será AANNCCCCCCCCCCCCCCCCCCCC, donde:

• AA: Código del país de la entidad (Letras en mayúsculas).
• NN: Dígito de control del IBAN (Números).
• CCCCCCCCCCCCCCCCCCCC: Número de cuenta.

En primer lugar convertimos las letras a números, contando que la A vale 10, la B vale 11 y así sucesivamente, de tal modo que BE62510007547061 quedaría 111462510007547061.

ls_letras = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ls_aux = string(pos(ls_letras, left(as_IBAN, 1))+9)
ls_aux += string(pos(ls_letras, mid(as_IBAN, 2, 1))+9)

En segundo paso consiste en mover los primeros seis caracteres a la derecha de tal modo que 111462510007547061 quedará 510007547061111462:

as_IBAN = mid(as_IBAN, 5) + ls_aux + mid(as_IBAN, 3, 2)

Y para finalizar hay que comprobar si el resto de la división del número obtenido entre 97 es 1. Si el resultado fuese distinto, el dígito de control sería incorrecto.

mod(double(as_IBAN), 97)

En este último punto hay un temita que puede tenerse en cuenta, y es que por razones de precisión se recomienda realizar esta operación con números enteros y no fraccionados o decimales, y como pordrá comprobarse el número con el que hay que operar es mayor que el que se puede almacenar en un unsignedlong (mayor entero en PB), como un entero de 32 bits o 64 bits representa un máximo de 9 ó 18 dígitos, se puede realizar la operación por partes tal y como describo a continuación:

1. Cálculo del módulo 97 de los primeros 9 dígitos del número.
   
   Ej: mod(510007547, 97) = 74
2. Construcción del siguiente entero de 9 dígitos, colocando en primer lugar el resultado del paso anterior. seguido por los siguientes 7/8 dígitos del número y calcular el módulo 97.
   
   Ej: mod(740611114, 97) = 12.
3. Repetir el paso dos hasta que todos los dígitos del número hayan sido procesados. Ej: mod(1262, 97) = 1

Script para eliminar caracteres no deseados

El siguiente script permite eliminar caracteres no deseados de un string, en este caso en concreto, elimina todos los que no sean una letra mayúscula o un número, pero si se quiere modificar los caracteres que han de eliminarse, simplemente se debe cambiar el argumento proporcionado a la función match y si fuese necesario jugar con la negación de las sentencias If. DEFINICIÓN:

public string gf_limpiar(string as_texto)

CÓDIGO:

string ls_aux integer li_pos, li_len ls_aux = '[^0-9^A-Z]' If match(as_texto, ls_aux) Then li_pos = 1 li_len = len(as_texto) Do Until li_pos > li_len If match(mid(as_texto, li_pos, 1), ls_aux) Then as_texto = mid(as_texto, 1, li_pos -1) & + mid(as_texto, li_pos + 1) li_len -- Else li_pos ++ End If Loop End If Return as_texto

Standards ISO

Para la implementación de un algoritmo de validación del IBAN, que publicaré más adelante, he necesitado localizar la norma ISO que identifica que letras están asociadas con cada país. He encontrado por un lado la "English country names and code elements - ISO 3166 Code lists" publicado por el propio organismo que la implemento, y por otro lado, como siempre días después intentando localizar la página mencionada, he llegado hasta la web ADAGO, concretamente a la lista de standards ISO. Además de aparecer la lista de códigos de países hay un montón de standards interesantes.