JQMGenerator = new Blockly.Generator( "CafeSQL" ) ;
CafeGenerator = JQMGenerator

VALUE = "input_value"
STATEMENT = "input_statement"
FIELDINPUT = "field_input"
FIELDDROPDOWN = "field_dropdown"


Agregar( "TTexto", "Texto {DContenido|field_input}", {salida: true, color: "240"}, ["'{DContenido}'", 0] )
Agregar( "TCampo", 'Campo {DContenido|field_variable|{"variableTypes":["EsCampo"],"defaultType":"EsCampo","variable":"CCampo1"}',{salida:"Campo",color:"green"},["`{DContenido}`",0] )
Agregar( "TTabla", 'tabla {DContenido|field_variable|{"variableTypes":["EsTabla","Tabla"],"defaultType":"EsTabla","variable":"TTabla1"}', {salida:"Tabla",color:"green"},["`{DContenido}`",0] )
Agregar( "TUrl", "URL {DContenido|field_input}", {salida: true, color: "240"},  ["{DContenido}", 0] )
Agregar("TNumero", 'Núm {DContenido|field_input}', {salida:true,color:"blue"}, ["{Number([DContenido])}",0])
Agregar("TFecha", 'Fecha {Año|field_number|{"min":"1900","max":"2100", "value":"'+((new Date()).getFullYear())+'"}{Mes|field_dropdown|{"options":'+(function(){
    return JSON.stringify("ENE0FEB0MAR0ABR0MAY0JUN0JUL0AGO0SEP0OCT0NOV0DIC".split(0).map(function(n,i){return [n, i+""]}))
})()+'}{Día|field_number|{"value":"1","min":"1","max":"31"}', {salida:true, color:"green"}, function(D){
    D.Mes++ ;
    if( D["Mes"]<10 ) D["Mes"] = "0"+D["Mes"] ;
    if( D["Día"]<10 ) D["Día"] = "0"+D["Día"] ;
    podriaSerBisiesto = D["Año"] % 4 == 0 ;
    noPuedeSerBisiesto = D["Año"] % 100 == 0 ;
    maxDiaFebrero = 28
    if( podriaSerBisiesto && !noPuedeSerBisiesto ) maxDiaFebrero++ ;
    if( D.Mes == 2 ) if( D["Día"] > maxDiaFebrero ) D["Día"] = maxDiaFebrero ;
    return '"{Año}-{Mes}-{Día}"'.procesar(D) ;
})

Agregar(
    'TCampoTabla'
    , 'campo {DSubCampo|field_variable|{"variableTypes":["EsCampo"],"defaultType":"EsCampo","variable":"CCampo1"} de la tabla {DTabla|field_variable|{"variableTypes":["EsTabla"],"defaultType":"EsTabla","variable":"TTabla1"}'
    , { salida: true, color: "green" }
    , ['`{DTabla}`.`{DSubCampo}`',0]
)

//------------------------------------------------ NUEVAS HABILIDADES

Agregar(
    'TDescargar'
    , 'Descargar en var. {DVariable|input_value|{"check":"PHPVariable"} desde la url {DUrl|input_value|{"check":"URL"}'
    , { esStatement: true, color: "#770055" }
    , '{DVariable} = file_get_contents( "{DUrl}" ) ;\n'
)
Agregar(
    'TParam'
    , 'param {DParam|field_variable|{"variable":"Cambia mi nombre"}'
    , { salida: "Parametro", color: "#007722" }
    , ['${DParam}',0]
)
Agregar(
    'TFiltrar'
    , 'Filtrar variable {DVariable|input_value|{"check":"PHPVariable"} param {DParam|'
)

Agregar(
    'TTSV'
    , 'Abrir CSV {DArchivo|field_input|{"text":"miarchivo.tsv"} separador {DSep|field_dropdown|{"options":[ ["Coma ,", ","],["Punto y coma", ";"], ["Tabulado", "\\t"] ]}'
    , { esStatement: true, color: "#007722" }
    , function(D){return `
// Abrir archivo TSV ${D.DArchivo}
if( true) {
    $separador = "${D.DSep}" ;
    $archivo = file_get_contents( "${D.DArchivo}" ) ;
    $renglones = explode( "\\n", $archivo ) ;
    if( count($renglones)>1 ) {
        $tit = explode( $separador, $renglones[0] ) ;
        $lista = [] ;
        for( $i = 1 ; $i < count($renglones) ; $i = $i+1 ) {
            $conjunto = [] ;
            $extraido = explode( $separador, $renglones[$i] ) ;
            foreach( $tit as $clave=>$titulo ) {
                $conjunto[trim($titulo)] = trim( $extraido[$clave] ) ;
            }
            $lista[] = (object)$conjunto ;
        }
        $resultado = $lista ;
    }
    else $resultado = [] ;
}
else $resultado = [] ;
    `}
)
//------------------------------------------------ CREATE TABLE

Agregar(
    'TCrearTabla'
    , 'CREATE TABLE {DNombre|field_variable|{"variableTypes":["EsTabla","Tabla"],"defaultType":"EsTabla","variable":"TTabla1"}}{D|input_dummy}¿IF NOT EXISTS? {DSiExiste|field_checkbox}{D|input_dummy}{DCampos|input_statement}'
    , { salida: true, color: "#955500" }
    , function(D){
        return [('CREATE TABLE '+((D.DSiExiste=="TRUE"&&'IF NOT EXISTS')||"")+' `{DNombre}`  (\n').procesar(D)+D.DCampos.replace(",","")+');\n',0]
    }
)
Agregar(
    'TCampoNuevo'
    , 'Agregando {A|input_dummy}campo {DCampo|input_value|{"check":"Campo"} del tipo {DTipo|input_value|{"check":"Definicion"} características... {DAdicional|input_value}'
    , { esStatement: true, color: "#957700" }
    , function(D){
        if( D.DTipo.indexOf("BOOLEAN") > -1 ) D.DAdicional = D.DAdicional.replace( /DEFAULT\s\'(.*?)\'/, function(a,b){ return "DEFAULT "+b } ) ;
        return ', {DCampo} {DTipo} {DAdicional}\n'.procesar(D)
    }
)
Agregar(
    'TAutoIncremental'
    , 'AUTOINCREMENT'
    , { salida: true, color: "black" }
    , [ ' AUTOINCREMENT', 0 ]
)
Agregar(
    'TNumericoEntero'
    , 'INTEGER max cifras{DMax|field_number}'
    , { salida: "Definicion", color: "#953300" }
    , function(D){
        return [' INTEGER'+(!D.DMax?"":"({DMax})".procesar(D)),0]
    }
)
Agregar(
    'TNumericoDecimales'
    , 'REAL max cifras {DMax|field_number} max cifras dec {DMaxDec|field_number}'
    , { salida: "Definicion", color: "#953300" }
    , function(D) {
        return [
            ' FLOAT'+( D.DMax ? "({DMax}, {[DMaxDec]||2})".procesar(D):"" )
        ,0]
    }
)

Agregar(
    'TVarChar'
    , 'VARCHAR({DMax|field_number|{"value":"40"})'
    , { salida: "Definicion", color: "#959900" }
    , function(D) {
        return [' VARCHAR({[DMax]||50})'.procesar(D),0]
    }
)
Agregar(
    'TNotNull'
    , 'NOT NULL{DOtro|input_value}'
    , { salida: true, color: "black" }
    , [ ' NOT NULL{DOtro}',0 ]
)
Agregar(
    'TPrimaryKeyInline'
    , 'PRIMARY KEY{DOtro|input_value}'
    , { salida: true, color: "black" }
    , [ ' PRIMARY KEY {DOtro}',0 ]
)
Agregar(
    'TFecha'
    , 'DATETIME'
    , { salida: "Definicion", color: "#959900" }
    , [ ' DATE', 0 ]
)
Agregar(
    'TMarcaDeTiempo'
    , 'TIMESTAMP DEFAULT CURRENT_TIMESTAMP'
    , { salida: "Definicion", color: "#959900" }
    , [ '  TIMESTAMP DEFAULT CURRENT_TIMESTAMP',0 ]
)
Agregar(
    'TDefault'
    , "DEFAULT '{DValor|field_input}'{DOtro|input_value}"
    , { salida: true, color: "black" }
    , [ ' DEFAULT \'{DValor}\' {DOtro}',0 ]
)
Agregar(
    'TBooleano'
    , 'BOOLEAN'
    , { salida: true, color: "#959900" }
    , [ ' BOOLEAN', 0 ]
)
// ------------------------------------------------ INSERT INTO
Agregar(
    'TEjecutar'
    , 'Ejecutar sentencia SQL {DSentencia|input_value} Si OK {DOk|input_value} Si NO {DNo|input_value}'
    , { esStatement: true, color: "#770055", renglones: 2 }
    , `
$conexion = conectar() ;
$resultado = $conexion->query( "{DSentencia}" );
if( $resultado ) print "{DOk}" ;
else print "{DNo}" ;
    `
)
Agregar(
    'TInsertar'
    , 'INSERT INTO {B|input_dummy}tabla {DTabla|input_value|{"check":"Tabla"}'
    + '({DCampos|input_value|{"check":"OrdenInsertar"})'
    + 'VALUES {DValoresNuevos|input_value}'
    , { salida: true, siguiente: "ModoInsertar", color: "#AADD00" }
    , function(D){return[`INSERT INTO ${D.DTabla}\n${D.DCampos}\n${D.DValoresNuevos.trim()}`,0]}//({DCampos})\nVALUES]
)
Agregar(
    'TListaValores'
    , 'comenzando con... {B|input_dummy}{DLista|input_statement}'
    , { salida: true, color: "#AADD00" }
    , ['VALUES\n (\n{DLista}\n)',0]
)
Agregar(
    'TInsertarOrden'
    , 'los campos {ENTER|input_dummy}{DCampos|input_statement}'
    , { salida: "OrdenInsertar", color: "#AADD00" }
    , ['({[DCampos].slice(0,-1)}) \n',0]
)
Agregar(
    'TInsertarValores'
    , 'conjunto valores {BR|input_dummy}{DLista|input_statement|{"check":"Valores"}'
    , { salida: true, color: "#AADD00" }
    , ['({[DLista].slice(0,-1)}),\n',0]
)
Agregar(
    'TValores'
    , 'valor {DValor|field_input|{"text":"abc"}'
    , { anterior: "Valores", siguiente: "Valores", color: "#88BB00" }
    , "'{DValor}',"
)

Agregar(
    'TValores2'
    , 'valor {DValor|input_value|{"text":"abc"}'
    , { anterior: "Valores", siguiente: "Valores", color: "#88BB00" }
    , "'{DValor}',"
)

//------------------------------------------------ SELECT FROM

Agregar(
    "TSelect"
    , 'SELECT campos {DCampos|input_statement} FROM tabla {DTabla|input_value|{"check":"Tabla"}'
    , {salida: "SelectSQL", siguiente: true,renglones:2, color: "red"}
    , function(E){E.DCampos = E.DCampos.slice(0,-1);return ["SELECT\n{DCampos}\nFROM\n{DTabla}\n".procesar(E),0]}
)
Agregar(
    "TFin", "ningun/a más", {anterior:true, color: "black"}, ";\n"
)

Agregar(
    "TTodos"
    , "* todos los campos"
    , {anterior:true, color: "red"}
    , "* "
)
Agregar(
    "TCampoSinAlias"
    , 'campo {DCampo|field_variable|{"variableTypes":["EsCampo"],"defaultType":"EsCampo","variable":"CCampo1"}'
    , {esStatement:true, color: "red"}
    , "`{DCampo}`,"
)

Agregar(
    "TCampoConAlias", 'campo {DCampo|field_variable|{"variableTypes":["EsCampo"],"defaultType":"EsCampo","variable":"CCampo1"} ALIAS  {DAlias|field_input|{"text":"CAlias1"}'
    , {esStatement:true, color: "red"}
    , "`{DCampo}` `{DAlias}`,"
)

Agregar(
    "TConcatenar"
    , 'CONCAT_WS {D|input_dummy}Junta {DJuntador|field_input}{DCampos|input_statement} alias {DAlias|input_value}'
    , {esStatement: true, color: "red"}
    , "CONCAT_WS( '{DJuntador}', {[DCampos].slice(0,-1)} ) {DAlias},"
)

//------------------------------------------------ WHERE

Agregar(
    "TDonde", "WHERE {D|input_dummy} campos que cumplan con{DContenido|input_statement}"
    , {esStatement:true, renglones:1, color: "#FFA500"}
    , "WHERE\n{DContenido}\n"
)
Agregar(
    "TCaso", "...primeramente{DContenido|input_value}"
    , {esStatement:true , color: "#FFA500"}
    , "{DContenido}\n"
)
Agregar(
    "TY", "AND {DContenido|input_value}"
    , {esStatement:true, color: "#FFA500"}
    , function(D){ if(D.DContenido.trim()=="") return "" ; return "AND {DContenido}\n".procesar(D)}
)
Agregar(
    "TO", "OR {DContenido|input_value}"
    , {esStatement:true, color: "#FFA500"}
    , function(D){ if(D.DContenido.trim()=="") return "" ; return "OR {DContenido}\n".procesar(D)}
)
Agregar(
    "TEs", '{DCampo|input_value} {DModo|field_dropdown|{"options":[["es igual","="],["es distinto","!="],["es mayor",">"],["es mayor o igual",">="],["es menor","<"],["es menor o igual","<="]]} que/a {DContenido|input_value}'
    , {salida:true,renglones:1, color: "#FFA500"}
    , ["{DCampo}{DModo}{DContenido}\n",0]
)
Agregar(
    "TContiene", '{DCampo|input_value} LIKE {DModo|field_dropdown|{"options":[["contiene","%E%"],["comienza con","E%"],["termina con","%E"]]} {DContenido|input_value}'
    , {salida:true,renglones:1, color: "#FFA500"}
    , function(D) {
        D.DContenido = D.DModo.replace( "E", D.DContenido.slice(1,-1) ) ;
        return ["{DCampo} LIKE '{DContenido}'\n".procesar(D),0]
    }
)

//------------------------------------------------ ORDER BY

Agregar(
    "TOrdenamiento", 'ORDER BY {DContenido|input_statement}'
    , {esStatement:true, color: "#00AAA5"}
    , "ORDER BY\n{[DContenido].slice(0,-1)}\n"
)

Agregar( "TPrimero", 'primero por...{DContenido|input_value}', {esStatement:true,color:"#00AAA5"}, "{DContenido}" )
Agregar( "TLuego", 'luego por...{DContenido|input_value}', {esStatement:true,color:"#00AAA5"}, "{DContenido}" )
Agregar( "TPrimeroS", 'primero por...{DContenido|input_value}', {esStatement:true,color:"red"}, "{DContenido}," )
Agregar( "TLuegoS", 'luego por...{DContenido|input_value}', {esStatement:true,color:"red"}, "{DContenido}," )

Agregar(
    "TAscendente", 'ASC {DCampo|input_value}'
    ,{salida:true, color:"#00AAA5"}
    , ["{DCampo} ASC,",0]
)
Agregar(
    "TDescendente", 'DESC {DCampo|input_value}'
    ,{salida:true, color:"#00AAA5"}
    , ["{DCampo} DESC,",0]
)

//------------------------------------------------ CANTIDAD

Agregar(
    'TPrimeros'
    , 'LIMIT primeros {DNumero|input_value|{"check":"Number"}'
    , { esStatement: true, color: "" }
    , 'LIMIT\n{DNumero}\n'
)
Agregar(
    'TPrimerosDesde'
    , 'LIMIT {DNumero|input_value|{"check":"Number"},  {DOffset|input_value|{"check":"Number"}'
    , { esStatement: true, color: "" }
    , 'LIMIT\n{[DNumero]||100}, {[DOffset]||0}\n'
)

//------------------------------------------------ PHP

Agregar( "PIniciarPHP", "Código PHP {D|input_dummy}{DContenido|input_statement}", {color:"#FFAA22"}, "< \?php\n{DContenido}" ) 

Agregar(
    "PErrores", 'Habilitar ver errores', {esStatement: true, color: "#A5AA00"}
    , function(){return"\n// Bloque: PErrores\nini_set('display_errors', 1);\nini_set('display_startup_errors', 1);\nerror_reporting(E_ALL);"}
)
Agregar(
    "PConector", 'Conector para MySQLi {D|input_dummy}'
    +'Host: {DHost|field_input|{"text":"localhost"}{D|input_dummy}'
    +'Usuario: {DUsuario|field_input|{"text":"tu usuario"}{D|input_dummy}'
    +'Contraseña: {DContra|field_input|{"text":"contraseña"}{D|input_dummy}'
    +'Base inicial: {DBase|field_input|{"text":"nombre de la base"}'
    , {esStatement:true, color:"#A5AA00"}
    , function(D) {
        return "function conectar() { return new mysqli("
        + '"'+D.DHost+'", '
        + '"'+D.DUsuario+'", '
        + '"'+D.DContra+'", '
        + '"'+D.DBase+'" '
        +"); }\n"
    }
)

Agregar(
    'TGenerar'
    , 'Imprimir resultados en formato {DFormato|field_dropdown|{"options":[["JSON","json"],["CSV con coma","csvcoma"],["CSV con punto y coma","csvpc"],["TSV", "tsv"],["Tabla HTML","tablahtml"]]}'
    , { esStatement: true, color: "#554400"}
    , function(D){
        var Extender = "" ;
        switch( D.DFormato ) {
            case "tsv":
                Extender = "print arraytocsv( $resultado, '\\t' ) ;\n"
                break ;
            case "csvcoma":
                Extender = "print arraytocsv( $resultado, ',' ) ;\n"
                break ;
            case "csvpc":
                Extender = "print arraytocsv( $resultado, ';' ) ;\n"
                break ;
            case "json":
                Extender = "print json_encode( $resultado ) ;\n" ;
                break ;
            case "tablahtml":
                Extender = `
print '<table data-filter="true" data-mode="columntoggle" class="ui-responsive" data-filter-placeholder="Filtrar por..." data-role="table" >'."\\n" ;
print "<thead><tr>" ;
foreach( $resultado[0] as $titulo => $valor )
print "<th>$titulo</th>" ;
print "</tr></thead><tbody>" ;
foreach( $resultado as $renglon => $ficha ) {\n
  print "<tr>" ;
  foreach( $ficha as $columna ) {
      print "<td>$columna</td>" ;
  }
  print "</tr>\\n";
}
print "</tbody></table>\\n" ;
`;
                break ;
        }
        CodigoCSV = `
	function arraytocsv( $array, $separador="\\t" ) {
		$primer = $array[0] ;
		$titulos = [] ;
		foreach( $array[0] as $titulo => $valor ) {
			$titulos[] = $titulo ;
		}
		$resultado = implode( $separador, $titulos ) . "\\n" ;
		foreach( $array as $cadaConjunto ) {
			$lista = [] ;
			foreach( $cadaConjunto as $titulo=>$valor ) {
				$lista[] = $valor ;
			}
			$resultado .= implode( $separador, $lista ) . "\\n" ;
		}
		return $resultado ;
	}
    
    `   ;
        console.log(Extender)
        return "\n// Generar código\n"+(D.DFormato.indexOf("sv")>-1?CodigoCSV:"")+Extender ;
        
    }
)
Agregar(
    'TGenerarConArchivo'
    , 'Imprimir resultados con ayuda del archivo {DArchivo|field_input|{"text":"archivovista.php"}'
    , { esStatement: true, color: "#554400"}
    , function(D){
        return `
// Generar código con ayuda del archivo de view ${D.DArchivo}
foreach( $resultado as $x ) {
    include "${D.DArchivo}" ;
}
        `
    }
)

Agregar(
    "TRecuperar", 'Recuperar con SQL {DSQL|input_value|{"check":"SelectSQL"}'
    , {esStatement:true, color: "#A56644", renglones:"varios"}
    , function(E){
        E.DSQL = E.DSQL.replace( /\n|\t/g, " " ) ;
        
        console.log( 4500,E.DFormato )
        return `

// Bloque: TRecuperar
function recuperar( $sql ) {
    $conexion = conectar() ;
    $conexion->set_charset( "utf8" ) ;
    if( $conexion ) {
        $resultados = $conexion->query( $sql ) ;
        if( $resultados ) {
            $retornar = [] ;
            while( $retornar[] = $resultados->fetch_object() ) ;
            array_pop( $retornar ) ;
            $conexion->close() ;
            return $retornar ;
        }
        else {
            $conexion->close() ;
            return [ (object)["error"=>"Error en consulta", "consulta"=>$sql] ] ;
        }
    }
    else {
        $conexion->close() ;
        return [ (object)["error"=>"Error en conexión"] ] ;
    }
}

$resultado = recuperar( "{DSQL}" );
`.procesar(E) ;
        
    }
)
//------------------------------------------------ Formulario

Agregar(
    "TGET"
    , '$_GET["{DDato|field_input}"]'
    , {salida: true, color: "blue" }
    , ['$_GET["{DDato}"]',0]
)
Agregar(
    "TPOST"
    , '$_POST["{DDato|field_input}"]'
    , {salida: true, color: "blue" }
    , ['$_POST["{DDato}"]',0]
)
Agregar(
    "TVariable"
    , '${DNombre|field_variable|{"variable":"Cambia mi nombre"}'
    , {salida:"PHPVariable", color: "#CC0011"}
    , ['${DNombre}',0]
)
Agregar(
    `TVariable2`
    , '${DNombre|field_variable|{"variable":"Cambia mi nombre"} ¿Coma?{TComa|field_checkbox}¿Entre comillas?{TComillas|field_checkbox}'
    , { esStatement: true, color: "#CC0011" }
    , function(D){TComillas=D.TComillas=="TRUE"?`'`:"";return `${TComillas}$${D.DNombre}${TComillas}${[D.TComa]=="TRUE"?",":""}`}
)
Agregar(
    'TUrl'
    , 'URL {DUrl|field_input|{"text":"https://"}'
    , { salida: "URL", color: "#006611" }
    , ['{DUrl}',0]
)
Agregar(
    "TSiExiste"
    , 'Vale {DNombre|input_value} sino {DOtro|field_input}'
    , {salida:true, color: "green"}
    , ['(isset({DNombre}) ? {DNombre} : {DOtro})', 0]
)
Agregar(
    "TAsignar"
    , 'Asignar a {DVariable|input_value} = {DOtro|input_value}'
    , {esStatement: true, color: "green", renglones:1}
    , function(D){
        if( D.DVariable.trim() == "" ) return "// Falta la variable\n" ;
        if( D.DOtro.trim() == "" ) return "// Falta lo que se asigna\n" ;
        return '{DVariable} = {DOtro} ;\n'.procesar(D)
    }
)
//------------------------------------------------ Funciones de Blockly


function Agregar( $nombre, $codigo, $datos, $funcion ) {
    CafeGenerator[$nombre] = function(E) {
        var aqui = this ;
        aqui.Data = {} ;
        Datos = this.Datos.forEach(function(cadaDato, num){
            //if(num==0) return cadaDato ; 
            X = cadaDato.split("|")
            Tipo = X[1]
            Nombre = X[0]
            if( Tipo == "input_statement" )
                aqui.Data[Nombre] = CafeGenerator.statementToCode( E, Nombre, 0 );
            else if( Tipo == "input_value" )
                aqui.Data[Nombre] = CafeGenerator.valueToCode( E, Nombre, 0 );
            else if( Tipo.substr(0,5) == "field" ){
                if( Tipo.indexOf("variable") > -1 )
                aqui.Data[Nombre] =  AreaDeTrabajo.getVariableById(E.getFieldValue( Nombre )).name ;
                else aqui.Data[Nombre] = E.getFieldValue(Nombre)
                
            }
//            return X
        })
        console.log(aqui.Data)
        if($funcion.tipo()=="[object Function]") return $funcion(aqui.Data) ;
        if($funcion.tipo()=="[object Array]" ) return [ $funcion[0].procesar(aqui.Data), $funcion[1] ];
        return $funcion.procesar(aqui.Data) ;
    }
    Blockly.Blocks[$nombre] = {
        init: function() {
            
            $ = {} ;
            var n = 0 ;
            $.args0 = [] ;
            this.Datos = [] ;
            var aqui = this ;
            $.message0 = $codigo.replace( /{(.*?)}/g, function(a,b){
                X = b.split("|")
                aqui.Datos.push(b)
                Y = ({
                    type: X[1]
                    , name: X[0]
                })
                if( X.length > 2 ) {
                    console.log(X[2])
                    try {
                        
                        Otro = JSON.parse( X[2]+"}" )
                        for( var j in Otro ) Y[j] = Otro[j] ;
                        console.log(110,Otro)
                    }
                    catch(E) {
                        console.log( -10, Y, X[2]+"}" )
                    }
                }
                console.log( Y )
                $.args0.push(Y) ;
                s = "%"+(++n)
                return s
                
            })
            
            if( $datos.color ) $.colour = $datos.color ;
            if( $datos.siguiente ) $.nextStatement = $datos.siguiente === true ? null : $datos.siguiente ;
            if( $datos.anterior ) $.previousStatement = $datos.anterior === true ? null : $datos.anterior ;
            if( $datos.salida ) $.output = $datos.salida ===true ? null: $datos.salida ;
            if( $datos.entrada ) $.input = $datos.entrada===true ? null : $datos.entrada ;
            if( $datos.renglones == 1 ) $.inputsInline = true ;
            else if( $datos.renglones ) $.inputsInline = false ;
            if( $datos.esStatement ) {
                $.nextStatement = null ; $.previousStatement = null ;
            }
            console.log($)
            this.jsonInit($)
            
        }
    }
}


function CrearComponenteHTML( $nombre, $etiqueta, $color, $funcion ) {
    CafeGenerator[$nombre] = $funcion ;
    
    Blockly.Blocks[$nombre] = {
        init: function() {
            
            this.jsonInit({
                args0: [
                    {
                        type: "input_statement"
                        , name: "DAtributo"
                    }
                    , {
                        type: "input_statement"
                        , name: "DContenido"
                    }
                ]
                , colour: $color || 0
                , message0: "Componente "+$etiqueta+" con atributos %1 de contenido %2"
            })
            this.datos = [$etiqueta,"IS|DAtributo", "IS|DContenido"]
        }
    }
    
    
}


JQMGenerator.scrub_ = function(block, code, opt_thisOnly) {
  const nextBlock = block.nextConnection && block.nextConnection.targetBlock();
  const nextCode = opt_thisOnly ? '' : JQMGenerator.blockToCode(nextBlock);
  return code +  nextCode;
};