Mostra la font per a Drf-reader/ca

<languages/>
[[Category:SAPO]]
[[Category:Devel]]


=== DLL_EXPORTS ===

<pre>

void drf_clear_errors()
Descr:Borra todos los mensajes de error del almacenamiento interno de la librería dinámica.

int drf_get_num_errors();
Descr:Obtiene el número de mensajes de error almacenados por la librería dinámica.
Return:número de mensajes almacenados.

const char* drf_get_error(int idx)
Descr:Obtiene el mensaje de error indicado por idx (referenciado a 0).
p:idx: Número de mensaje a obtener. Rango entre: 0 y (drf_get_num_errors()-1) ambos incluidos.
Return: Éxito: Puntero a una cadena de caracteres ASCII terminada por el byte NUL ('\0')
        Error: NULL en caso que el valor de idx esté fuera de rango.

int drf_to_json(char *path,FILE *json,int options)
Descr:Serializa a JSON un archivo DRF.
p:path: Ruta al fichero DRF a serializar en formato Windows ANSI.
p:json: puntero FILE ya abierto y con la escritura habilitada.
p:options: Selecciona que información se serializará. Valores possibles:
   DRF_GET_GENERIC_INFO
   DRF_GET_MACHINE_INFO
   DRF_GET_DRAFT_INFO
   DRF_GET_ALL_INFO
o una combinación de los valores anteriores via or bit a bit

Return: Éxito : retorna valor igual a 0
        Error : retorna valor diferente de 0

</pre>


=== TAGS ===

Codificación a JSON de los datos:

Internamente el DRF guarda la información como una lista de tags. Cada tag puede contener uno o varios elementos del mismo tipo.

Al codificar un DRF a JSON se codifica como un objeto donde se usa el nombre del tag como clave y el contenido de éste como valor.
En caso que el tag pueda contener más de un valor, la librería serializa el contenido como un vector.

Como el formato DRF soporta más tipos que el JSON, la librería los convertirá a un tipo soportado por el JSON. La siguiente tabla muestra a que 
tipo del JSON se convierte cada tipo del DRF 

<pre>
    DRF  | JSON   
  -------+--------
  byte   | 
  int16  | int
  int32  |
  -------+-------
  float  | float
  -------+-------
  string | string*

*) Todos los strings contienen solo caracteres ASCII (encoding:ASCII-7)
</pre>


==== TAGS GENERIC INFO ====

<pre>

*Software string
Nombre del programa que ha generado el fichero .DRF

*DrawName string
Referencia del dibujo (max. 256 carac).

*Company string
Compañía que ha creado el dibujo (max. 30 carac).

</pre>


==== TAGS MACHINE INFO ====

<pre>

*Machine string
Referencia de la máquina. (max. 30 carac) 

*MachineType string
Modelo de la máquina. Sólo es válido un modelo definido en el sistema de diseño. (p.e. LEAVERS)

*Description string
Descripción o información adicional de la máquina.

*Serial string
Num. serie de la máquina. (max. 30 carac) . Puede contener carácteres no numéricos.

*Version int32 [RASCHEL SU]
Versión de la máquina raschel SU (versión 1 .. 4).
   versión 1 . Sin ahorrador de memoria
   versión 2 . Con ahorrador de memoria (repeticiones)
   versión 3 . Sin ahorrador de memoria + información empresa.
   versión 4 . Con ahorrador de memoria (repeciciones) + información empresa.

*Jacquard int32
Número de barras de Jacquard independientes. Valores posibles: 
   0 : No jacquard
   1 : 1 jacquard o fina barra simple
   2 : 2 jacquard raschel o fina barra doble.

*Fronture int32 [RASCHEL DOUBLE NEEDLE BAR]
Número de fonturas de la máquina
   1 : 1 fontura
   2 : 2 fontures (delante / detrás)

*BarsRepeat int32
Altura del diseño.

*NumRepeats int32
Num de repeticiones en el diseño.

*NumBars int32
Numero de barras que tiene el telar.

*Plate int32
En máquinas raschel (textronic), indica la posición de la plancha.
En máquinas leavers indica donde empiezan los brodeurs.

*JacqNeedles int32
Numero de agujas de Jacquard del telar.

*MachNeedles int32
Numero total de agujas del telar.

*BarsOffset int32
Desplazamiento de barras (orillos=zona perdida)

*JacqOffset int32
Deplazamiento de las agujas de jacquard en el telar.

*MaxDisp int32 [RASCHEL SU]
Deplazamiento máximo general de las barras para máquinas raschel SU.

*Proximity int32
Para máquinas raschel, distáncia máxima a la que se pueden acercar dos barras del mismo grupo.

*ProximityCollindant int32
Para máquinas raschel, distáncia máxima a la que se pueden acercar dos barras del mismo grupo colindantes.

*JacqRt int32
Deplazamiento Rt del jacquard:

para máquinas raschel:
   no jacquard: rt = 0
   jacquard simple o doble: rt = 1
Indica cuántas agujas se desplaza la lectura del jacaquard en las pasadas alternadas.

para máquinas leavers
   no fina barra:      0
   fina barra simple: -1
   fina barra doble:   0
Indica cuántas agujas se desplaza la lectura del jacquard (desde la posición derecha de la máquina en las pasadas alternadas).

*JacqRtCourse int32
Indica que pasadas se aplica el valor JacqRt.
   0:pasadas pares
   1: pasadas impares

*FinalGauge float
Galga de producto tejido aplicando encongimiento (medida en agujas/pulgada)

*FinalQuality float
Calidad de producto tejido aplicando elasticidad (medida en pasadas/centímetro).

*RealGauge float
Galga de máquina (medida en agujas/pulgada)-

*RealQuality float
Calidad de máquina (medida en pasadas/centímetro).

*Shrinkage float
Porcentage de encongimiento en agujas (0-100%)

*Elasticity float
Porcentage de elasticidad en pasadas (0-100%)

*BarNumBar int32(NumBars)
Numero de cada una de las barras del telar (valor numérico consecutivo)

*BarName string(NumBars)
Nombre o identificador de cada una de las barras del telar

*BarGroup int32(NumBars)
En máquinas raschel el número de grupo de la barra.

*BarStop int32(NumBars)
Posición 0 de la barra.

*BarUtil int32(NumBars)
Visibilidad de la barra en el sistema de diseño.

*BarType int32(NumBars)
Tipo de hilo por defecto de la barra.

*BarMaxGimp int32
Guimpada máxima en agujas de la barra.

*BarDrive int32
En máquinas raschel SU, el número de getribe de la barra.

*BarFactor int32
En máquinas raschel SU, multiplicador de la barra.
1: factor de 1 agulla
2: factor de 2 agulles,
4: factor de 4 agulles.
...


*BarInvert int32
En máquinas raschel SU, les barres invertides. 
1: barra invertida.
0: barra no invertida.

*BarWork int32
Trabajo de la barra en el sistema de diseño.

   0: Chainette
   1: Jacquard     [1]
   2: Brodeur
   3: Gros
   4: Fin
   5: Brillant
   6: Picot
   7: Corde
   8: Lycra
   9: Fond
  10: Bloc
  11: Cord
  12: Guimp
  13: Nul
  14: Jacq 0/2,6/4 [1]
  15: Jacq 0/2,8/6 [1]
  16: Fine Bar.  [sup]
  17: Braquette"
  18: Jacquard     [2]
  19: Jacq 0/2,6/4 [2]
  20: Jacq 0/2,8/6 [2]
  21: Fine Bar.  [inf]
  22: Jacquard
  23: Fine Barre
  24: Fallplate
  25: Embrodery
  26: EFS
  27: Reservé 1
  28: Reservé 2
  29: Jacq 0/2,6/4
  30: Jacq 0/2,8/6
  31: Bord
  32: Lisieres
  33: Romaines
  34: Sonnette
  35: Guimp devant
  36: Petite Corde
  37: Fileur
  38: Separation
  39: Corde Termo
  40: Solv rom
  41: Vis
  42: Jacquard     [3]
  43: Jacquard     [4]
  44: Space Fabric


*BarKnit
En máquines raschel textronic tipous de lligada:
  0 : no planxa
  1 : lligada 1 (mecanica)
  2 : lligada 2 (binaria)
  3 : lligada 3 (mecánica (2))
  4 : lligada 4 (binària (2))

*BarTimes
En máquines raschel textonic temps de la lligada
  0 : no planxa
  2 : temps 2 (p.e) 0202 0202 0202
  4 : temps 4 (p.e) 0220 0220 0220

*BarMode
En máquines raschel textronic el mode la la barra:
  0 : mode A (p.e 0220)
  1 : mode B (p.e 2002)

*BarModif int32
En máquines raschel textronic indica que la barra no es pot deslligar
  0 : no es pot deslligar
  1 : si es pot deslligar

*BarTension int32
Tensió de la barra a les simulacions.

*BarNumFingers int32(NumBars)
Número de pasadors de la barra

*BarModeDrop int32(NumBars)
Ponderación de cada uno de los 7 bits que se usan para indicar el desplazamiento de la barra. Valores:

 Valor | B7 | B6 | B5 | B4 | B3 | B2 | B1
 ------+----+----+----+----+----+----+----
    0  |  8 |  8 |  8 |  4 |  2 |  1 |1/2
 ------+----+----+----+----+----+----+----
    1  | 16 |  8 |  8 |  4 |  2 |  1 |1/2
 ------+----+----+----+----+----+----+----
    2  | 16 | 16 |  8 |  4 |  2 |  1 |1/2
 ------+----+----+----+----+----+----+----
    3  | 32 | 16 |  8 |  4 |  2 |  1 |1/2
 ------+----+----+----+----+----+----+----
    4  |  8 |  8 |  8 |  8 |  4 |  2 | 1
 ------+----+----+----+----+----+----+----
    5  | 16 |  8 |  8 |  8 |  4 |  2 | 1
 ------+----+----+----+----+----+----+----
    6  |  4 |  4 |  4 |  4 |  2 |  1 | 1
 ------+----+----+----+----+----+----+----
    7  |  0 |  0 |  0 |  1 |  2 |  1 |1/2
 ------+----+----+----+----+----+----+----
    8  |  4 |  4 |  4 |  4 |  2 |  1 |1/2


*BarMaxDesp int32(NumBars)
Desplazamiento máximo de la barra en agujas

*BarActive byte(NumBars)
Sólo para maquinas EL. Indica si la barra esta en uso o no.

*BarHalvesUp byte(NumBars)
Si en la pasada se incrementa la posición de la barra en BarHalvesUp agujas o más, entonces , se añade media aguja a la posición final.

*BarHalvesDn byte(NumBars)
Si en la pasada se decrementa la posición de la barra en BarHalvesDwn agujas o más, entonces , se le resta media aguja a la posición final.

*BarString int32(NumBars)
Valors:
0:
1:ple
2:1f 1x
3:1x 1f
4:buit


*BarFronture int32(NumBars)
Solo se usa en las máquinas de doble frontura. Da la frontura en la que empieza a trabajar la barra.Valores:
0: primera forntura
1: segunda frontura

*BarDropsUtil int32(7*NumBars)
indica como se deben perforar los 7 posiciones correspondientes a la barra:

Valor:
0: Usado. Siempre a 1. Es decir: no perforar nunca
1: Usado, Se perforara o no en funcion del desplazamiento de la barra
2: Usado. Siemre a 0. Es decir, se perfora siempre
3: No usado. No se perfora

*FingerStop int32(num_fingers) num_fingers=BarNumFingers(0) + ... + BarNumFingers(NumBars-1)
Stop del pasador relativo al stop de la barra.

*FingerType int32(num_fingers) num_fingers=BarNumFingers(0) + ... + BarNumFingers(NumBars-1)
Tipo de pasador.

*CGF1Card int32
ha de estar a 0.

*CGF1Type int32
Número de columnas útiles en el cartón.

*CGF1Taille int32
Número de columnas totales que caben del cartón.

*CGF1Numlines int32
numero de entradas de las que consta la especificación del cartón.

*CGF1Script string(CGF1Numlines)
Lista de cadenas de caracteres que detallan como se ha de perforar  cada columna del cartón empezando por la columna de mas a la derecha.
Cada cadena de caracteres tiene el formato: <codigo de tipo> <espacio> <numero de repeticiones>. Ex: "LC 1".
Los codigos de tipo validos son:
   LC: Laçage
   TC: Trou de centrage
   TS: Trou de centrage simple
   EL: Element vide
   GF: Gros fil
   VB: Value

*CGF1Descrip string(CGF1Numlines)
Descripción de cada entada del cartón.

Ex:

  CGF1Script | CGF1Descrip
 ------------+--------------
   "LC 1"    |  "Laçage"
   "TC 1"    |  "Trou de centrage"
   "GF 6"    |  "braquettes"  
   "GF 4"    |  "stum"                                                                                                      
   "GF 30"   |  "guimpes"                                                                                                    
   "TC 1"    |  "Trou de centrage"                                                                                            
   "LC 1"    |  "Laçage"                                                                                                       
   "GF 26"   |  "guimpes"                                                                                                
   "GF 4"    |  "stum"                                                                                                   
   "GF 6"    |  "braquettes"                                                                                               
   "GF 3"    |  "brodeus"                                                                                                  
   "TC 1"    |  "Trou de centrage"                                                                                         
   "LC 1"    |  "Laçage"                                                                                                      
   "GF 39"   |  "brodeus"                                                                                                 
   "TC 1"    |  "Trou de centrage"                                                                                           
   "LC 1"    |  "Laçage"                                                                                                    
                                                                                                                           
                                                                                                                          
  L T                GF39                   L T G   GF6  GF4          GF26            L T               GF30           GF4  GF6  T L
  C C _____________________________________ C C F  ____  __  ________________________ C C ____________________________  __  ____ C C
  1 1/                                     \1 1/3\/    \/  \/                        \1 1/                            \/  \/    \1 1
/------------------------------------------------------------------------------------------------------------------------------------\
|    OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO.  OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO.  OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO    |
| O  .O.O.O.OOOOOOO.OOO.OOOOOO.O.O.OOOOOOOOOO  OOOOOOOOOOO..O..OO...O.OO.....O..O..OOOO  OO...O...OOO.OOOOO...O.....O..OO..OOOOOO  O |
|    OOOOO.OO.O...OOO..O..OO.OO.OOOO.O..OO.O.  OOOOOO...OOOO.O.OOOO..O.OO.OOO..O.O.O...  ..OOO.OO..O.OO....O.O..O.OOOOOOOOOOOO...    |
|  ().OO.OO...OOOOOOOO.OO...O.OOOO..OO....O..()O..OOOOOOOOOOO.O....OO..O..OOO..OO.O.O..()OO.....OOO...OO..OO.O.OOO.OO.OOOOOOOOOOO()  |
|    ........................................  ...............OO..OO..O.......O........  ...........O...O...O.O...O...O..........    |
| O  .O....OO.O.O....O.O.OOO..O.O.OO.O..OOO.O  ..O...........OOO.OOO.OOOOOOO.OOO.OOO.OO  OOOOOOOOOOOOOOOOOOOO.OOOOOOOOO..........  O |
|    O.OOOOOOO.O.OOOO.O.OOOOOO.O.OOOO.OO.OOO.  OOO..........OOOOOOOOOOOOOOOOOOOOOOOOOO.  OOOOOOOOOOOOOOOOOOOOOOOOOOOOOO..........    |
\------------------------------------------------------------------------------------------------------------------------------------/    

*CGF2Card int32
ha de estar a 0.

*CGF2Type int32
Número de columnas útiles en el cartón.

*CGF2Taille int32
Número de columnas totales que caben del cartón.

*CGF2Numlines int32
numero de entradas de las que consta la especificación del cartón.

*CGF2Script string(CGF2Numlines)
Especificación del cartón. Formateado igual que CGF1Script.

*CGF2Descrip string(CGF2Numlines)
Descripción de cada entada del cartón.

*CFBCard int32
ha de estar a 1.

*CFBType int32
Número de columnas útiles en el cartón.

*CFBTaille int32
Número de columnas totales que caben del cartón multiplicadas por 8.Ex:
si el cartón tiene 75 columnas CFBTaille=75*8=600

*CFBNumlines int32
numero de entradas de las que consta la especificación del cartón.

*CFBScript string(CFBNumlines)
Especificación del cartón. Formateado igual que CGF1Script. Excepto que los tipos aceptados
son:
   LC: Laçage
   TC: Trou de centrage
   TS: Trou de centrage simple
   EL: Element vide
   FB: Fine barre
   VB: Value

Es decir el tipo "GF" no existe para este tag y en su lugar hay el tipo "FB"

*CFBDescrip string(CFBNumlines)
Descripción de cada entada del cartón.

*CFBNGaits int32
Número de entradas para mapear las repeticiones de agujas de Fine Barre a los cartones en función de la repetición.

*CFBGaitNRepeat int32(CFBNGaits)
Número de repetición a mapear

*CFBGaitNBar int32(CFBNGaits)
Número de aguja a mapear

*CFBGaitNGait int32(CFBNGaits)
Indice de agujero en el cartón




</pre>


==== TAGS DRAFT DATA ====

<pre>

*NumCourses int32
Numero de pasadas del dibujo sin tener en cuenta las repeticiones.

*BarNeedle int16(NumCourses*NumBars)
Despazamientos medidos en agujas de las barras en cada pasada. Ordenados de la siguiente manera:

   BarNeedle(0)              Desplazamiento barra 1 en la primera pasada.
   BarNeedle(1)              Desplazamiento barra 1 en la segunda pasada.
   .
   .
   BarNeedle(NumCourses-1)   Desplazamiento barra 1 en la última pasada.
   BarNeedle(NumCourses)     Desplazamiento barra 2 en la primera pasada.
   .
   .
   BarNeedel(NumCourses*2-1) Desplazamiento barra 2 en la última pasada.
   BarNeedle(NumCourses)     Desplazamiento barra 3 en la primera pasada.
   .

*BarNeedleB int16(NumCourses*NumBars)
Solo se utiliza en maquinas de doble frontura. Es equivalente a BarNeedle pero contiene la información
para la segunda frontura.

*BarHalves byte(NumCourses*NumBars)
Incremento de 1/2 aguja en el movimiento de la barra introducido manualmente por el diseñador desde el menú de Bareme


*BarKnitting byte(NumCourses*NumBars)
Indica en las maquinas que hacen 2 movimientos por pasada que movimiento se realiza
Valores:
 0 : Movimiento 0 0 . No liga
 1 : Movimeinto 0 1 . Liga
 2 : Movimeinto 1 0 . Liga
 3 : Movimeinto 1 1 . No liga


*BarKnittingB byte(NumCourses*NumBars)
Solo se utiliza en maquinas de doble frontura. Es equivalente a BarKnitting pero contiene la información
para la segunda frontura.

*Layout_JacqData byte(NumCourses*JacqNeedles*Jacquard)
Cada byte guarda un bit de Jacquard. Valores:
0: T
1: H

*Layout_FrontureData byte(NumCourses*JacqNeedles*Jacquard)
Solo se utiliza en maquinas de doble frontura. Es equivalente a Layout_JacqData pero contiene la información
para la segunda frontura.

*Layout_WBData byte(NumCourses*JacqNeedles*Jacquard)
Solo se utiliza en maquinas CLIPTRONIC . Contiene los datos para la barra de Embrodery(WB) en el mismo formato que
Layout_JacqData.

*LayoutCourNRepeats int32
Numero de repeticiones de pasadas. Las repeticiones de pasadas afectan por igual las barras de dibujo y el jacquard.

*LayoutCourNLayouts int32
Numero de bloques de pasadas a repetir

*LayoutCourRepeat int32(LayoutCourNLayouts)
Numero de pasadas que contiene cada bloque a repetir

*LayoutCourWhich int32(LayoutCourNRepeats)
indice del bloque que a repetir

*LayoutCourTimes int32(LayoutCourNRepeats)
numero de veces que se ha de repetir el bloque. Ejemplo:

Normalmente como los dibujos suelen ser bastante repetitivos, para ahorrar trabajo y memoria no se guardan todas las pasadas
del dibujo. En un dibujo como el siguiente :

    +------------------------------------------------------------------------------------------+
    |  ,~.~._,~.~._,~.~._,~.~._,~.~._,~.~._,~.~.    ,~.~._,~.~._,~.~._,~.~._,~.~._,~.~._,~.~.  | 
    | / O.O   O.O   O.O   O.O   O.O   O.O   O.O \  / O.O   O.O   O.O   O.O   O.O   O.O   O.O \ | 
    |( O:@:O O:@:O O:@:O O:@:O O:@:O O:@:O O:@:O )( O:@:O O:@:O O:@:O O:@:O O:@:O O:@:O O:@:O )| 
    | \ O'O   O'O   O'O   O'O   O'O   O'O   O'O /  \ O'O   O'O   O'O   O'O   O'O   O'O   O'O / | 
    |  )   . ,   . ,   . ,   . ,   . ,   . ,   (    )   . ,   . ,   . ,   . ,   . ,   . ,   (  | 
/\  | (  * -@- * -@- * -@- * -@- * -@- * -@- *  )  (  * -@- * -@- * -@- * -@- * -@- * -@- *  ) | 
 A  |  )   ' `   ' `   ' `   ' `   ' `   ' `   (    )   ' `   ' `   ' `   ' `   ' `   ' `   (  | 
 g  | / O.O   O.O   O.O   O.O   O.O   O.O   O.O \  / O.O   O.O   O.O   O.O   O.O   O.O   O.O \ | 
 u  |( O:@:O O:@:O O:@:O O:@:O O:@:O O:@:O O:@:O )( O:@:O O:@:O O:@:O O:@:O O:@:O O:@:O O:@:O )| 
 j  | \ O'O   O'O   O'O   O'O   O'O   O'O   O'O /  \ O'O   O'O   O'O   O'O   O'O   O'O   O'O / | 
 a  |  ·~·~·^·~·~·^·~·~·^·~·~·^·~·~·^·~·~·^·~·~·    ·~·~·^·~·~·^·~·~·^·~·~·^·~·~·^·~·~·^·~·~·  | 
 s  +------------------------------------------------------------------------------------------+
     Pasadas >

Si se mira lo que hay guardado en el archivo se encontraría algo similar a :
                     
    +---------------+
    |  ,~.~._,~.~.  |
    | / O.O   O.O \ |
    |( O:@:O O:@:O )|
    | \ O'O   O'O / |
    |  )   . ,   (  |
/\  | (  * -@- *  ) | 
 A  |  )   ' `   (  |
 g  | / O.O   O.O \ |
 u  |( O:@:O O:@:O )|
 j  | \ O'O   O'O / |
 a  |  ·~·~·^·~·~·  |
 s  +---------------+
     Pasadas >


Esto pasa por que se ha guardado solo una vez cada bloque que se repite. En este caso los bloques que se han usado:

     A      B        C
  +----+ +------+ +-----+
  |  ,~| |.~._,~| |.~.  | 
  | / O| |.O   O| |.O \ | 
  |( O:| |@:O O:| |@:O )| 
  | \ O| |'O   O| |'O / | 
  |  ) | |  . , | |  (  | 
  | (  | |* -@- | |*  ) |
  |  ) | |  ' ` | |  (  | 
  | / O| |.O   O| |.O \ | 
  |( O:| |@:O O:| |@:O )|
  | \ O| |'O   O| |'O / |  
  |  ·~| |·~·^·~| |·~·  | 
  +----+ +------+ +-----+

Se puede ver con facilidad que la sequencia de bloques para obtener el dibujo es: A B B B B B B C A B B B B B B C

LayoutCourNLayouts=3 pues hay tres bloques distintos ( A , B , C )

LayoutCourRepeat=Array(
   numero de pasadas de A,
   numero de pasadas de B,
   numero de pasadas de C
)

NOTA: El número total de pasadas ha de ser igual a la suma de pasadas de los bloques de repeticiones. Es decir:
NumCourses=LayoutCourRepeat(0)+...+LayoutCourRepeat(LayoutCourNLayouts-1)

Luego para codificar que se desea 1 repetición de A, 6 repeticiones de B y una repeticion de C se haria de la siguiente manera:

                         idx  |  LayoutCourWhich | LayoutCourTimes | Significado
                      --------+------------------+-----------------+------------------
                        _     |                  |                 |
                       /  0   |         1        |       1         | Bloque 1 (A) repetir una vez
                       |      |                  |                 |
                       |  1   |         2        |       6         | Bloque 2 (B) repetir 6 veces
                       |      |                  |                 |
                       |  2   |         3        |       1         | Bloque 3 (C) repetir una vez
LayoutCourNRepeats=6  <       |                  |                 |
                       |  3   |         1        |       1         | Bloque 1 (A) repetir una vez
                       |      |                  |                 |
                       |  4   |         2        |       6         | Bloque 2 (B) repetir 6 veces
                       |      |                  |                 |
                       \_ 5   |         3        |       1         | Bloque 3 (C) repetir una vez
                              |                  |                 |




*LayoutJacqNRepeats int32
Numero de repeticiones de agujas. Solo afecta el jacquard. Sigue el mismo sistema que las repeticiones de pasadas.

*LayoutJacqNLayouts int32
Numero de bloques de agujas a repetir

*LayoutJacqRepeat int32(LayoutJacqNLayouts)
Numero de agujas que contiene cada bloque a repetir

*LayoutJacqWhich int32(LayoutJacqNRepeats)
indice del bloque que a repetir

*LayoutJacqTimes int32(LayoutJacqNRepeats)
numero de veces que se ha de repetir el bloque.

</pre>