<?php
/* include("devildrey33.php");
$Base = new devildrey33(devildrey33_TipoPlantilla::Articulo, basename(__FILE__));
$Base->InicioPlantilla("Colorear código con PHP (Parte 3 JavaScript)");*/
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = '<meta name="description" content="Colorear código">
<meta name="keywords" content="Colorear código JavaScript">';
$Base->InicioPlantilla(basename(__FILE__), "Colorear código con PHP (Parte 3 JavaScript)", $META);
$Base->InicioBlog(basename(__FILE__), "Colorear código con PHP (Parte 3 JavaScript)");
?>
<!-- INTRODUCCION -->
<p>Siguiendo los tutoriales para pintar código utilizando PHP, hoy toca ver como pintaremos un archivo JavaScript.</p>
<p>A diferencia de los dos últimos tutoriales, este ya empieza a complicarse, ya que los códigos escritos en javascript tienen palabras clave que deben utilizar un tipo de color, y que debemos diferenciar del resto.</p>
<p>Por ello vamos a tener que hacer un diccionario de palabras clave para JavaScript de forma que nos sea fácil añadir palabras que vayamos descubriendo que van en otro color.</p>
<p>También hay que remarcar que las cadenas de caracteres tienen complicaciones añadidas ya que funcionan al estilo C, y estas pueden contener ciertos caracteres engañosos.</p>
<!-- FIN_INTRODUCCION -->
<p>Para empezar vamos a ver un código JavaScript básico, de forma que nos podamos hacer una idea de que cosas necesitamos pintar :</p>
<?php
$Base->PintarCodigo->PintarArchivoJavaScript("IDEjemploJavaScript", "Ejemplo absurdo de JavaScript", "../Ejemplos/ColorearCodigoPHP/ColorearCodigoPHP_JavaScript_Ejemplo.php", "EjemploJavaScript");
?>
<p>A primera vista este código JavaScript no sirve para nada xD, pero podemos ver una aproximación de los colores que vamos a necesitar, y en qué casos necesitamos aplicarlos.</p>
<p>Hay tres tipos de palabras clave, las que son más comunes de cualquier lenguaje de programación : '<b>if</b>', '<b>switch</b>', '<b>break</b>', '<b>return</b>', '<b>default</b>', '<b>var</b>', etc... y estas van en un color azul oscuro. Las que son mas para tratamiento interno de datos java script, que en este caso solo vemos '<b>parseInt</b>', pero hay otras como por ejemplo '<b>setInterval</b>', '<b>setTimeout</b>', '<b>eval</b>', etc.. que irán en un color verde azulado. Y por ultimo palabras claves relacionadas con acciones del navegador que en este caso solo vemos '<b>alert</b>' pero también existen otras como '<b>document</b>', '<b>window</b>', '<b>scroll</b>', etc.. y estas van en un color lila.</p>
<p>Además de las palabras clave, vemos que las cadenas de caracteres van en un color azul más brillante, y que los valores numéricos van en color rojo.</p>
<p>Con este análisis ya podemos empezar a pensar un algoritmo viable para hacer el trabajo.</p>
<p>Lo ideal como se comento antes, seria tener un array que nos sirva de diccionario, al que fácilmente le podamos añadir más palabras clave con su color pertinente. Además de tener un diccionario de palabras también estaría bien tener un diccionario de delimitadores, ya que en este caso lo mas fácil va a ser separar todas las palabras que podamos en strings independientes, y para ello no nos vale separarlas solo si tienen un espacio como delimitador ya que por ejemplo podemos tener la sentencia "<b>2+2</b>", y los números deberían ir en rojo, pero el símbolo sumar debería ir en azul oscuro, y analizar esta cadena podría ser un infierno.</p>
<p>Bien entonces la propuesta más prometedora es hacer un array de palabras clave con su color correspondiente, y un array que contenga únicamente los delimitadores.</p>
<?php
<?php
/* include("devildrey33.php");
$Base = new devildrey33(devildrey33_TipoPlantilla::Articulo, basename(__FILE__));
$Base->InicioPlantilla("Devildrey33 Windows Library");*/
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = '<meta name="description" content="Devildrey33 Windows Library">
<meta name="keywords" content="DWL, Devildrey33 Windows Library">';
$Base->InicioPlantilla(basename(__FILE__), "Devildrey33 Windows Library", $META);
$Base->InicioBlog(basename(__FILE__), "Devildrey33 Windows Library");
?>
<!-- INTRODUCCION -->
<p>Esta librería es la base para la mayoría de aplicaciones desarrolladas por Josep Antoni Bover. Fue creada en el año 2002 ante la necesidad de tener controles fuera del look estandar de windows xp, y tambien para facilitarme la vida a la hora de crear aplicaciones bajo windows.</p>
<p>En los tiempos actuales en los que ya se va normalizando el uso de Windows 7 y windows xp va desapareciendo, esta libreria ha empezado a perder su utilidad. Pero de todas formas es un excelente ejemplo de como programar desde cero controles como el ListView, TreeView, PopupMenu, Button, etc... sin utilizar nada de los controles estandar de windows.</p>
<!-- FIN_INTRODUCCION -->
<p>Se podria decir que el estilo a la hora de controlar eventos es bastante parecido al MFC, y personalmente me ha servido para aprender muchisimo sobre el API de windows.</p>
<h2>DWLArbolEx</h2>
<img src="../Web/Graficos/DWLArbolEx.png" style="float:right;" alt="DWLArbolEx" />
<p>Control que simula un TreeView de windows, con algunas particularidades :</p>
<ul>
<li>Scrolls propios completamente personalizables en apariencia.</li>
<li>Posibilidad de añadir botones en las barras de scroll.</li>
<li>SubSeleccion (cuando seleccionamos un nodo padre, todos los hijos quedan SubSeleccionados).</li>
<li>Posibilidad de añadir una imagen de fondo, y que quede translucida debajo de los nodos.</li>
<li>Colores de los nodos totalmente personalizables de forma individual (Fondo y Texto : Normal, Resaltado, Seleccionado, SubSeleccionado, Presionado. ademas del Borde.)</li>
<li>Efectos de resaltado tanto en los nodos como en el borde del control, como en los scrollbars.</li>
<li>Fuentes independientes para cada nodo, utilizando HFONTS previamente cargados en memoria.</li>
<li>Funciones virtuales que permiten re-emplazar practicamente cada fase de pintado.</li>
<?php
/* include("devildrey33.php");
$Base = new devildrey33(devildrey33_TipoPlantilla::Articulo, basename(__FILE__));
$Base->InicioPlantilla("Conversor UTF8 - Windows1252");*/
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = '<meta name="description" content="UTF8 a Windows1252">
<meta name="keywords" content="Conversor UTF8 a CP1252">';
$Base->InicioPlantilla(basename(__FILE__), "Conversor UTF8 - Windows1252", $META);
$Base->InicioBlog(basename(__FILE__), "Conversor UTF8 - Windows1252");
?>
<!-- INTRODUCCION -->
<p>Este 'conversor' es una aplicación que me facilita la vida a la hora de convertir archivos de código <b>cpp</b> y <b>h</b> recursivamente de una codificación a otra.</p>
<p>Lo bueno que tiene esta aplicación es que convierte recursivamente todos los archivos de código que pueda contener un directorio (incluyendo sus subdirectorios).</p>
<p>Por otra parte no tiene interface grafico, y es una simple aplicación de consola. Además guarda los archivos originales con la extensión .OLD</p>
<!-- FIN_INTRODUCCION -->
<p>Este proyecto consiste en dos simples aplicaciones que convierten todos los archivos C, Cpp y H del directorio donde se encuentren ubicados los ejecutables.</p>
<p>La razón principal por la que se creó el proyecto es porque la mayoría de mi código en C/C++ se ha creado bajo VisualStudio, y este por defecto guarda todos los archivos bajo la codificación Windows-1252 en mi PC. El problema viene cuando hay que documentar un código utilizando Doxygen, e incluir esta documentación en un sitio web el cual trabaja con la codificación UTF8.</p>
<p>En principio no es un problema muy grave si el código consiste en un par de archivos, ya que desde el mismo VisualStudio se puede cambiar la codificación de los archivos, pero por ejemplo con la <a href="DWL.php">DWL</a> existen más de 175 archivos de código, y cambiar la codificación uno a uno puede terminar en una tarde tediosa, que además puede acabar siendo una pérdida de tiempo total.</p>
<p>Por ello acabe por hacer este proyecto que consiste en 2 aplicaciones : <strong>UTF8aWindows1252.exe</strong> y <strong>Windows1252aUTF8.exe</strong></p>
<p>Lo que hacen es bastante simple, ya que escanean recursivamente el directorio donde se encuentran los ejecutables, y todos los archivos que encuentran con la extensión C, CPP y H son leídos en memoria y re-escritos a la codificación que se requiera.</p>
<p>Por razones de seguridad los archivos originales se renombran añadiéndoles la extensión .OLD de forma de que si hay algún problema puedan ser recuperados.</p>
<p>El código fuente viene todo en el archivo <strong>UTF8aWindows1252.cpp</strong> para los dos conversores.</p>
<p>La cosa es simple, si deseas compilar el conversor UTF8 a Windows1252, el principio del archivo <strong>UTF8aWindows1252.cpp</strong> debería quedar así :</p>
<?php
/* -[INICIO devildrey33.IDC1]-
<?php
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = '<meta name="description" content="Working with google APIs">' . Intro() . '<meta name="keywords" content="google api, google apis">';
$Base->InicioPlantilla(basename(__FILE__), "Working with google APIs", $META);
$Base->InicioBlog(basename(__FILE__), "Working with google APIs", TRUE);
/* TRUE = imatge a la dreta */
$File_Source_1 = '../Codigo/GoogleAPI/simple_gAPI_example_empty.html';
$File_Source_2 = '../Codigo/GoogleAPI/simple_gAPI_example.html';
?>
<script type="text/javascript">
$Base.CargarCSS('Barba_Posts.css');
</script>
<!-- <div style="display: inline-block; margin-bottom: 30px;"> -->
<p>We’ve already seen <a href="how-to-use-google-app-scripts" target="_blank">how to develop a whole web app using the "Web App Scripts"</a>.</p>
<p>However, many times we would like to keep our web app into another place/server, or just connect an existing web app with the google services, so in this case we must use the google APIs to interact with the google services.</p>
<p>We're going to split this explanation in 2 parts:</p>
<ul>
<li><b>Grant access to the APIs</b></li>
<li><b>Access the API</b> (authorization and methods to access)</li>
</ul>
<p>The first part is common, and you would need to set it whatever type of client access you'd like to use. The second, though, can be implemented in many languages, as well as in the client or the server side. Here we're going to focus on how to implement it with javascript. Let’s see how to do it.</p>
<!-- </div> -->
<h2>Grant access to the APIs</h2>
<?php
include "devildrey33.php";
$Base = new devildrey33();
$HEAD = "";
$Base->InicioPlantilla(basename(__FILE__), "Logs de acceso", $HEAD);
if (devildrey33_Opciones::Administrador() > 0) {
echo "<article class='Blog'>";
phpinfo();
echo "</article>";
} else {
echo "<script>\$Base.MostrarErrorAjax(404, true);</script>";
echo "<script>\$Admin.Desloguear();</script>";
}
$Base->FinPlantilla();
<?php
/* include("devildrey33.php");
$Base = new devildrey33(devildrey33_TipoPlantilla::Articulo, basename(__FILE__));
$Base->InicioPlantilla("Instalar Ubuntu bajo VirtualBox en Windows");*/
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = '<meta name="description" content="Ubuntu bajo VirtualBox">
<meta name="keywords" content="Ubuntu virtualbox">';
$Base->InicioPlantilla(basename(__FILE__), "Instalar Ubuntu bajo VirtualBox en Windows", $META);
$Base->InicioBlog(basename(__FILE__), "Instalar Ubuntu bajo VirtualBox en Windows");
?>
<!-- INTRODUCCION -->
<p>VirtualBox es una aplicación que nos permite instalar sistemas operativos con el hardware emulado dentro de nuestro sistema operativo. Dicho así suena un poco confuso, por lo que vamos a imaginarnos que queremos instalar una versión de linux en nuestra máquina, pero queremos ver este linux dentro de una ventana de windows. Pues esto es lo que hace VirtualBox.</p>
<p>También hay que remarcar que lo podemos hacer al revés, es decir, desde nuestro linux nativo instalar windows para que se muestre en una ventana de linux.</p>
<p>De todas formas la intención de este tutorial es servir como base para luego poder hacer algunos tutoriales programando con el protocolo X11 server (dicho de forma burda programar aplicaciones con entorno gráfico para linux)</p>
<!-- FIN_INTRODUCCION -->
<ul style="clear:both">
<li>1 <a href='#InstalarVBox'>Instalación de VirtualBox</a></li>
<li>2 <a href='#ConfigurarVbox'>Creación y configuración de una máquina virtual</a></li>
<li>3 <a href='#InstalarUbuntu'>Instalación de Ubuntu</a></li>
<li>4 <a href='#ConfigurarUbuntu'>Configuración de Ubuntu</a></li>
</ul>
<p>El primer paso será descargar las últimas versiones de Virtual Box y de Ubuntu :</p>
<p>Para empezar iremos descargando la ultima ISO de Ubuntu ya que son alrededor de 700mb y es lo que más tardara : <a href="http://www.ubuntu.com/download/ubuntu/download">Descargar Ubuntu</a>.</p>
<div class='nota'>Podéis elegir la versión que mas os guste siempre que sea de 32 bits, yo personalmente elegiría la última versión 11.04 en 32 bits. Con mi portátil por ejemplo me he encontrado que al hacer la prueba con el Ubuntu de 64bits no me reconocía capacidades de 64bits, mientras que en mi ordenador de sobremesa la cosa ha funcionado perfectamente con la de 64bits.</div>
<img src='../Web/Graficos/DownloadUbuntu.png' alt='Descargar Ubuntu' />
<p>En segundo lugar descargaremos el instalador de VirtualBox para windows desde este enlace : <a href="https://www.virtualbox.org/wiki/Downloads">Descargar VirtualBox</a>.</p>
<?php
/* include("devildrey33.php");
$Base = new devildrey33(devildrey33_TipoPlantilla::Articulo, basename(__FILE__));
$Base->InicioPlantilla("Tutorial WinAPI C++ 3.6 (Creación del ObjetoProgressBar)");-*/
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = '<meta name="description" content="Tutorial WINAPI">
<meta name="keywords" content="WINAPI C++, WINAPI, C++">';
$Base->InicioPlantilla(basename(__FILE__), "Tutorial WinAPI C++ 3.6 (Creación del ObjetoProgressBar)", $META);
$Base->InicioBlog(basename(__FILE__), "Tutorial WinAPI C++ 3.6 (Creación del ObjetoProgressBar)");
?>
<!-- INTRODUCCION -->
<p>Estareis pensando... pero bueno, si ya hemos hecho nuestro propia barra de progreso hace 5 tutoriales... pues si.. pero creo interesante que tambien veais el funcionamiento del ProgressBar de windows.</p>
<p>Pues nada, vamos a hacer lo mismo que en los anteriores controles estandar y encapsularemos en una clase que tendrá de nombre ObjetoProgressBar, y que heredara de ObjetoControlEstandar (La clase ObjetoControlEstandar se describe en el tutorial <a href="/Blog/Tutorial_WINAPI_3_3">3.3 Creación del ObjetoEditBox</a>).</p>
<!-- FIN_INTRODUCCION -->
<p> Veamos su declaración :</p><div style="clear:both"></div>
<?php
$Base->PintarCodigo->PintarArchivoC("IDObjetoProgressBar", "Archivo : ObjetoProgressBar.h", "../Codigo/Tutoriales_WinAPI/Objetos Tutorial/ObjetoProgressBar.h", "ObjetoProgressBar");
?>
<p>Lo primero que vemos es una función para crear la ProgressBar, después tenemos varias funciones para asignar / obtener el mínimo, el máximo y el valor de la barra, que son : AsignarRango, ObtenerRagon, Mínimo, Máximo y Valor.</p>
<p>Veamos la función CrearProgressBar :</p>
<?php
$Base->PintarCodigo->PintarArchivoC("IDCrearProgressBar", "Archivo : ObjetoProgressBar.cpp", "../Codigo/Tutoriales_WinAPI/Objetos Tutorial/ObjetoProgressBar.cpp", "ObjetoProgressBar::CrearProgressBar");
?>
<p>Lo primero que se hace es llamar a la función ObjetoIniciarCommonControls::Iniciar. Esta función llama a la API <a href="http://msdn.microsoft.com/en-us/library/bb775697(VS.85).aspx" target="_blank">InitCommonControlsEx</a> para iniciar los controles estándar de windows para nuestra aplicación. Al iniciar los CommonControlEx podemos utilizar controles que no son estandar de windows 95, y adoptar el aspecto grafico del sistema operativo (siempre que la aplicacion tenga su archivo .manifest).</p>
<p>Lo segundo que se hace es llamar a la API <a href="http://msdn.microsoft.com/en-us/library/ms632680(VS.85).aspx" target="_blank">CreateWindowEx</a> con el segundo parámetro "PROGRESS_CLASS" (que es una macro para identificar la clase). Esto hace que el control creado se convierta en un PROGRESSBAR. </p>
<p>Lo siguiente es llamar a la función _ConectarControl, que re-emplazara el WindowProcedure de la ProgressBar por el nuestro.</p>
<?php
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = '<meta name="description" content="Referencia selectores css, Ejemplos selectores css">
<meta name="keywords" content="CSS, Selectores CSS, :link, :visited, :active, :hover, :focus, :first-letter, :fisrt-child, :before, :after, :lang, :first-of-type, :last-of-type, :only-of-type, :only-child, :nth-child, :nth-last-child, :nth-pf-type, :nth-last-of-type, :last-child, :root, :empty, :target, :enabled, :disabled, :checked, :not, ::selection">
<meta name="robots" content="index, follow">';
$Base->InicioPlantilla(basename(__FILE__), "Referéncia CSS : Selectores", $META);
$Base->InicioBlog(basename(__FILE__), "Referéncia CSS : Selectores");
/*
include("devildrey33.php");
$Base = new devildrey33(devildrey33_TipoPlantilla::Articulo, basename(__FILE__));
$DeclaracionesHeadExtras = '
<meta name="description" content="Referencia selectores css, Ejemplos selectores css">
<meta name="keywords" content="CSS, Selectores CSS, :link, :visited, :active, :hover, :focus, :first-letter, :fisrt-child, :before, :after, :lang, :first-of-type, :last-of-type, :only-of-type, :only-child, :nth-child, :nth-last-child, :nth-pf-type, :nth-last-of-type, :last-child, :root, :empty, :target, :enabled, :disabled, :checked, :not, ::selection">
<meta name="robots" content="index, follow">
<link href="/css/PropiedadesCSS.css" rel="stylesheet" type="text/css" />';
$Base->InicioPlantilla("Referéncia CSS : Reglas", $DeclaracionesHeadExtras, '<a href="/Doc/">Doc</a>/<a href="/Doc/CSS/">CSS</a>/Selectores');*/
include "../Web/CSS_BD.php";
$Selectores = new CSS_BD();
?>
<!-- INTRODUCCION -->
<p>Los selectores CSS son una parte fundamental que todo el que se aventure a crear una hoja de estilos CSS debería conocer mínimamente. En esencia estos selectores nos permiten referirnos a una parte en concreto de la página web para poder estilizarla a nuestra conveniencia.</p>
<p>Dentro de un documento HTML podemos identificar cada etiqueta de una forma básica por el nombre de la etiqueta, por una clase, o por una ID. Pero además también podemos crear selectores para una gran variedad de situaciones, por ejemplo podemos crear un selector que se refiera a cuando el mouse está encima de una etiqueta, un selector que busque una etiqueta dentro de una etiqueta, un selector que busque una etiqueta antes o después de una determinada etiqueta, etc..</p>
<!-- FIN_INTRODUCCION -->
<p>En este artículo voy a enumerar todos los selectores CSS disponibles hasta la fecha de hoy, además incluiré ejemplos para cada uno de ellos.</p>
<?php
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = '<meta name="description" content="Virus fotos 05/06">' . Intro() . '<meta name="keywords" content="Virus fotos 05/06, Virus email fotos 05/05, Email fotos 05/06">' . Intro();
$Base->InicioPlantilla(basename(__FILE__), "Aplicación para eliminar el virus "Fotos 05/06"", $META);
$Base->InicioBlog(basename(__FILE__), "Aplicación para eliminar el virus "Fotos 05/06"");
/*
include("devildrey33.php");
$Base = new devildrey33(devildrey33_TipoPlantilla::Articulo, basename(__FILE__));
$Base->InicioPlantilla("Aplicación para eliminar el virus "Fotos 05/06"");*/
?>
<!-- INTRODUCCION -->
<p>En el verano del 2010 aparecio un virus que se propagaba por el correo electronico con el asunto "fotos 05/06" el cual mostraba una fotografia a un tamaño muy reducido y que al clickar encima de ella nos descargaba un archivo que se llama "foto28_.com". Si lllegabamos a ejecutar este archivo la máquina quedaba infectada por este virus, que entre otras cosas se dedica a enviar a todos nuestros contactos del messenger el mismo correo por tal de expandirse.</p>
<p>En principio este virus no tiene mucho de extraordinario a comparacion de otros, pero me toco la moral porque varios de mis contactos se infectaron, y me enviaban más copias del virus sin que ellos se dieran cuenta. Entre esos contactos que me enviaban el virus estaban mi padre y mi hermana, con lo que practicamente tenia asegurado el tener que desplazarme para eliminar el virus de sus maquinas.... pero como en el verano del 2010 hacia mucha calor, se me ocurrio que podria hacer una aplicacion que eliminara el virus y asi me ahorraria el desplazamiento y me quedaria tan fresco en casa.</p>
<!-- FIN_INTRODUCCION -->
<p>Al final inverti varias horas en la creacion de esta aplicacion, y aparte de ayudar a mis familiares, tambien lo colgue en mi web, y de esta forma mi aplicacion a pesar de costarme unas horas de trabajo hizo un gran servicio a muchos internautas afectados.</p>
<h3>Observaciones</h3>
<ul>
<li>El virus crea una carpeta oculta llamada 'cmos' en la raiz de la unidad donde tenemos instalado el windows</li>
<li>Si existe conexion a internet, al ejecutarse por primera vez, se descarga varios archivos de algun otro sitio (que no me he molestado a averiguar), en caso de no tener conexion a internet solo crea la carpeta 'cmos' sin ocultarla.</li>
<li>Una vez descargado el virus se crean cinco archivos : "?:\cmos\id", "?:\cmos\xlb.cpl", "?:\cmos\xln.cpl", "?:\cmos\xlr.exe", y "?:\cmos\xlr2.exe" </li>
<li>De los archivos que se crear, se enlazan cuatro al registro de windows de forma que se arranquen al iniciar el sistema.</li>
<li>El archivo original del virus es un archivo COM de 64ks que solo tiene codigo para descargar el resto del virus y enlazarlo al sistema.</li>
<li>Una vez el virus se encuentra activo, tus contactos recibiran correos iguales a la foto que se ve más arriba.</li>
</ul>
<?php
/* include("devildrey33.php");
$Base = new devildrey33(devildrey33_TipoPlantilla::Articulo, basename(__FILE__));
$DeclaracionesHeadExtras = '
';
$Base->InicioPlantilla("Tutorial HTML5 Canvas2D parte 3 (degradado lineal)", $DeclaracionesHeadExtras); */
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = '<meta name="description" content="Tutorial HTML5 Canvas2D parte 3">
<meta name="keywords" content="HTML5 Canvas2D, Canvas2D">';
$Base->InicioPlantilla(basename(__FILE__), "Tutorial HTML5 Canvas2D parte 3 (degradado lineal)", $META);
$Base->InicioBlog(basename(__FILE__), "Tutorial HTML5 Canvas2D parte 3 (degradado lineal)");
?>
<script type="text/javascript">
function PintarDegradados() {
// Inicializo el canvas
var Canvas = document.getElementById("canvas");
if (Canvas.getContext) { Context = Canvas.getContext("2d"); }
else { alert("Tu navegador no soporta el objeto canvas!"); return; }
// Pinto el fondo gris claro
Context.fillStyle = "#EEEEEE";
Context.fillRect(0, 0, Context.canvas.width, Context.canvas.height);
// Creo los degradados lineales
// -[INICIO devildrey33.vertical]-
var GradientVertical = Context.createLinearGradient(0, 20, 0, 80);
$Fecha = date("d/m/Y", filemtime("CSS_BD.php"));
echo "<br /><div class='devildrey33_Nota'>" . CSSTipo::Plural($TipoSalida) . " documentadas : <b>" . $Documentadas["Documentadas"] . "/" . $Documentadas["Total"] . "</b><br />Modificado por última vez : <i>" . $Fecha . "</i>.</div>";
$Base->FinBlog();
$Base->FinPlantilla();
} elseif ($TipoSalida == eTipo::RaizCSS) {
$Base = new devildrey33();
$META = '<meta name="description" content="Referencia css, Ejemplos css">' . '<meta name="keywords" content="CSS">' . '<meta name="robots" content="index, follow">';
$Base->InicioPlantilla(basename(__FILE__), "Referéncia CSS", $META);
$Base->InicioDoc(basename(__FILE__), "Referéncia CSS");
echo '<br />' . '<div><a href="/Doc/CSS/Colores/">Colores</a></div>' . '<div><a href="/Doc/CSS/Degradados/">Degradados</a></div>' . '<div><a href="/Doc/CSS/Unidades/">Unidades</a></div>' . '<div><a href="/Doc/CSS/Propiedades/">Propiedades</a></div>' . '<div><a href="/Doc/CSS/Funciones/">Funciones</a></div>' . '<div><a href="/Doc/CSS/Reglas/">Reglas</a></div>' . '<div><a href="/Doc/CSS/Selectores/">Selectores</a></div><hr />';
$CSS_BD = new CSS_BD();
$Documentadas = $CSS_BD->MostrarTodo();
$Fecha = date("d/m/Y", filemtime("CSS_BD.php"));
echo "<br /><div class='devildrey33_Nota'>Proporción de la documentación terminada : <b>" . $Documentadas["Documentadas"] . "/" . $Documentadas["Total"] . "</b><br />Modificado por última vez : <i>" . $Fecha . "</i>.</div>";
echo "<hr />";
$Base->FinBlog();
$Base->FinPlantilla();
} elseif ($TipoSalida == eTipo::RaizDoc) {
$Base = new devildrey33();
$META = '<meta name="robots" content="index, follow">';
$Base->InicioPlantilla(basename(__FILE__), "Documentación", $META);
$Base->InicioDoc(basename(__FILE__), "Documentación");
echo '<br />' . '<div><a href="/Doc/CSS/">CSS</a></div>' . '<div><a href="/Doc/DWL/">DWL</a></div>';
$Base->FinBlog();
$Base->FinPlantilla();
}
}
?>
<?php
/*include("devildrey33.php");
$Base = new devildrey33(devildrey33_TipoPlantilla::Articulo, basename(__FILE__));
$Base->InicioPlantilla("Tutorial WINAPI C++ 1.3 (Creación de un ObjetoVentana)");*/
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = '<meta name="description" content="Tutorial WINAPI">
<meta name="keywords" content="WINAPI C++, WINAPI, C++">';
$Base->InicioPlantilla(basename(__FILE__), "Tutorial WINAPI C++ 1.3 (Creación de un ObjetoVentana)", $META);
$Base->InicioBlog(basename(__FILE__), "Tutorial WINAPI C++ 1.3 (Creación de un ObjetoVentana)");
?>
<!-- INTRODUCCION -->
<p>Este es el primer punto interesante del tutorial, como encapsular una ventana en una clase que podamos heredar y modificar a nuestro antojo.</p>
<p>La idea es tener una clase que podamos heredar, y que a partir de ella podamos crear distintos modelos de ventana, sin tener que re-escribir mucho código.</p>
<p> En especial este tutorial nos demostrara como crear varias ventanas del mismo tipo re-utilizando el mismo objeto.</p>
<!-- FIN_INTRODUCCION -->
<p>Para empezar el problema más importante que se nos presenta es que la función WindowProcedure debe ser estática, y esto no nos interesa, ya que esta función es la primera que necesitaremos sobre-escribir. Además esto también nos produciría algún que otro problema cuando intentásemos acceder a miembros de la misma clase no estáticos.</p>
<p>La solución más viable es enlazar ese WindowProcedure estático a otra función no estática que además será virtual. De esta forma queda solucionado el problema más grave a la hora de diseñar esta clase, aunque sea a costa de otro callback más dentro del WindowProcedure.</p>
<p>Otra cosa que debemos pensar es que un control es básicamente una ventana, pero no tiene porqué tener las mismas funciones, así que estaría bien crear un modelo base para ventanas y controles. A partir de este modelo ya podremos crearnos ventanas y controles más específicos.</p>
<p>Veamos como quedaría estructurada la cosa : </p>
<?php
$Base->PintarCodigo->PintarArchivoC("IDPlantillaEventos", "Archivo : PlantillaEventos.h", "../Codigo/Tutoriales_WinAPI/Objetos Tutorial/PlantillaEventos.h", "PlantillaEventos");
?>
<p>Para empezar creamos una plantilla destinada a controlar todos los eventos de una ventana. Esta plantilla depende del TIPO_DEVUELTO que por norma sera LRESULT pero puede ser BOOL en caso de los dialogos, y retornara VALOR_DEVUELTO en los mensajes por defecto (que sera 0 para casi todo, menos para los controles estandar de windows).</p>
<p>Aunque no veamos el codigo de GestorMensajes, hay que destacar que el GestorMensajes debera retornar VALOR_DEVUELTO si se ha procesado el evento en este GestorMensajes, o USAR_GESTOR_POR_DEFECTO si no se ha procesado ninguno de nuestros eventos. Al devolver USAR_GESTOR_POR_DEFECTO le estamos diciendo al _GestorMensajes estatico que devuelva el WindowProcedure por defecto.</p>
<p>Si creamos cualquier control que mande eventos a su ventana padre, aqui seria donde deberiamos definir dicho evento. Ahora veamos el ObjetoHWND :</p>
<?php
$Base->PintarCodigo->PintarArchivoC("IDObjetoHWND", "Archivo : ObjetoHWND.h", "../Codigo/Tutoriales_WinAPI/Objetos Tutorial/ObjetoHWND.h", "ObjetoHWND");
<div class='Bola_Expandible_Texto'>Rojo</div>
</div>
<div class='Bola_Expandible' style='background-color:green;'>
<div class='Bola_Expandible_Texto'>Verde</div>
</div>
<div class='Bola_Expandible' style='background-color:blue;'>
<div class='Bola_Expandible_Texto'>Azul</div>
</div>
<!--[FIN devildrey33.HTML]-->
*/
// $Base->InicioPlantilla("CSS3 : Efecto bola expandible", $DeclaracionesHeadExtras);
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = '<meta name="description" content="CSS3 Bola expandible">
<meta name="keywords" content="CSS3, Bola expandible, CSS3 Bola expandible">';
$Base->InicioPlantilla(basename(__FILE__), "CSS3 : Efecto bola expandible", $META);
$Base->InicioBlog(basename(__FILE__), "CSS3 : Efecto bola expandible");
?>
<!-- INTRODUCCION -->
<p>Hoy para no repetirme mucho con el tema del canvas os voy a mostrar cómo he creado el efecto de la bola expandible que podéis ver en la parte superior del menú de la derecha con los iconos del facebook, twitter, google plus y rss.</p>
<p>Este efecto se ha hecho únicamente utilizando CSS3 sin necesidad de JQuery ni JavaScript, pero por esa razón no funciona en explorer. Como ya he comentado en más de una ocasión me niego a torturarme haciendo código que funcione en explorer, cuando en otros navegadores funciona perfectamente sin necesidad de romperse mucho la cabeza.</p>
<!-- FIN_INTRODUCCION -->
<p>Si los desarrolladores web le dieran la espalda directamente al explorer en vez de adaptar sus códigos exclusivamente para él, estoy convencido de que o los usuarios de explorer abrirían los ojos, o que los de microsoft se pondrían las pilas. Parece mentira que llevemos más de 10 años con este tipo de peleas.</p>
<p>Dejando a un lado mi pique personal con el navegador de microsoft, vamos a ver que necesitamos para crear el efecto de la bola expandible.</p>
<p>En primer lugar necesitamos un contenedor para cada bola, y un contenedor para el texto de cada bola. Veamos como quedaría el código HTML :</p>
<?php
$Base->PintarCodigo->PintarArchivoHTML("IDHTML", "Código HTML", "CSS3_BolaExpandible.php", "HTML");
?>
<?php
/* include("devildrey33.php");
$Base = new devildrey33(devildrey33_TipoPlantilla::Articulo, basename(__FILE__));
$Base->InicioPlantilla("Tutorial WinAPI C++ 3.11 (Terminando el Ensamblador)");*/
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = '<meta name="description" content="Tutorial WINAPI">
<meta name="keywords" content="WINAPI C++, WINAPI, C++">';
$Base->InicioPlantilla(basename(__FILE__), "Tutorial WinAPI C++ 3.11 (Terminando el Ensamblador)", $META);
$Base->InicioBlog(basename(__FILE__), "Tutorial WinAPI C++ 3.11 (Terminando el Ensamblador)");
?>
<!-- INTRODUCCION -->
<p>Esta es la ultima parte del tercer tutorial, donde juntaremos todos los controles estandar que hemos visto anteriormente y formaremos una aplicacion encargada de hacer una lista de archivos.</p>
<p>Con esa lista de archivos la aplicacion podra comprimirlos todos para luego insertarlos en el ejecutable del Instalador.</p>
<p>Y tambien le indicaremos la ruta predeterminada de la instalación.</p>
<!-- FIN_INTRODUCCION -->
<p>Ahora que tenemos todos los controles necesarios, además del ejecutable de la instalación solo nos queda hacer el programa para ensamblar la instalación con los archivos.</p>
<p>La idea es hacer un programa que nos permita seleccionar los archivos que queremos meter dentro del instalador, y nos pida datos, como el directorio por defecto y el archivo que se usara como instalador.</p>
<p>Además le añadiremos posibilidad de cargar y guardar proyectos de instalador.</p>
<p>Por último en vez de utilizar una ventana como siempre utilizaremos un dialogo y veremos en que se diferencian.</p>
<p>Vamos al lio, lo primero será crear un ObjetoDialogo para contener diálogos de windows :</p>
<?php
$Base->PintarCodigo->PintarArchivoC("IDObjetoDialogo", "Archivo : ObjetoDialogo.h", "../Codigo/Tutoriales_WinAPI/Objetos Tutorial/ObjetoDialogo.h", "ObjetoDialogo");
?>
<p>Aunque parece prácticamente igual que un ObjetoVentana hay que destacar que el _GestorMensajes retorna BOOL mientras que el el ObjetoVentana retorna LRESULT. Esto no es porque ami me guste mas… y a decir verdad no se la razón de ello, simplemente si vamos a usar un dialogo necesitamos utilizar WindowProcedures que retornen BOOL. Y aquí está la razón de porque utilizamos la clase plantilla PlantillaEventos a la hora de basar todas nuestras ventanas / diálogos / controles.</p>
<p>Por último la función CrearDialogo solo recibe un parámetro, que es la ID que tiene el dialogo en los recursos. Para especificar los estilos del dialogo hay que hacerlo mediante el editor de recursos.</p>
<p>Veamos la declaración de un dialogo pequeño que necesitaremos para poner nombre al nuevo proyecto DialogoNuevoProyecto :</p>
<?php
/* include("devildrey33.php");
$Base = new devildrey33(devildrey33_TipoPlantilla::Articulo, basename(__FILE__));
$HEAD = "
";
$Base->InicioPlantilla("Varios ejemplos de menus", $HEAD);*/
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = "<meta name='description' content='Ejemplos menús'>\n\t<meta name='keywords' content='Menu CSS, Menu JavaScript'>";
$Base->InicioPlantilla(basename(__FILE__), "Varios ejemplos de menús", $META);
$Base->InicioBlog(basename(__FILE__), "Varios ejemplos de menús");
echo "<script>\$Base.CargarCSS('Blog_varios-ejemplos-de-menus.css');</script>";
?>
<!-- INTRODUCCION -->
<p>He estado haciendo pruebas con menús y sobretodo con CSS para practicar con las transiciones, y me estoy dando cuenta de que en CSS resulta muy difícil por no decir imposible en algunas situaciones hacer código re-aprovechable para las animaciones/transiciones en el sentido de que si añades/modificas/eliminas un menú tendrás que volver a editar el CSS. En cambio en JavaScript si te lo montas bien puedes hacer las cosas más dinámicas de forma que si modificas el menú no tengas que tocar ni JavaScript ni CSS.</p>
<p>La intención en principio era trastear un rato con transiciones complejas, ya que exceptuando el primer ejemplo los demás al desplegarse utilizan una transición, y al resaltar sus items utilizan otra transición dentro de la primera.</p>
<p>También he querido poner énfasis en hacer los menús lo más cómodos posible, dejando retrasos (delay) al plegarse para que el usuario tenga tiempo de moverse por el menú.</p>
<!-- FIN_INTRODUCCION -->
<br /><hr />
<h2>Menú Subrayado (JQuery)</h2>
<p>Este es un menú simple sin sub-menús que tiene una animación en el subrayado implementada en JQuery. Esta animación debe calcular el ancho y la posición del item donde está el mouse para calcular el ancho y la posición inicial de la barra de subrayado.</p>
<p>Se podría hacer también con CSS, pero no veo ninguna forma de hacerlo dinámico es decir que calcule automáticamente los items del menú para desplazar la barra del subrayado, así que la única solución viable que veo seria medir cada parte del menú, e implementar una transición especificando la posición para cada parte del menú.</p>
<p>Para este caso en concreto yo he apostado por la comodidad de poder añadir/modificar/eliminar items sin tener que tocar código javascript ni css.</p>
<iframe src='/Ejemplos/Menus/MenuSubrayado.html' class='postit Centrado' id="Marco1"></iframe>
<div class='Centrado'>
<a href="/Lab/Ejemplos/Menus/MenuSubrayado.html" class="Boton-Normal">Ver código de ejemplo</a>
<?php
/* include("devildrey33.php");
$Base = new devildrey33(devildrey33_TipoPlantilla::Articulo, basename(__FILE__));
$DEH = "
<link href='./Ejemplos/Tutorial_HTML5/Tutorial_HTML5_8_Ejemplo.css' rel='stylesheet' type='text/css' />
";
$Base->InicioPlantilla("Creación de páginas web desde cero (8 Menus)", $DEH);*/
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = '<meta name="description" content="Tutorial HTML">
<meta name="keywords" content="Tutorial HTML">';
$Base->InicioPlantilla(basename(__FILE__), "Creación de páginas web desde cero (8 Menus)", $META);
$Base->InicioBlog(basename(__FILE__), "Creación de páginas web desde cero (8 Menus)");
?>
<link href='../Ejemplos/Tutorial_HTML5/Tutorial_HTML5_8_Ejemplo.css' rel='stylesheet' type='text/css' />
<!-- INTRODUCCION -->
<p>En este tutorial podréis ver cómo crear un menú simple para vuestras páginas web que no requiere grandes conocimientos de programación.</p>
<p>Por otro lado este menú no será ni mucho menos tan flexible como el que se muestra en el articulo <a href="MenuWebFijo.php">Menu PHP + XML + JQuery + JavaScript + CSS</a>. Pero tampoco requeriréis conocimientos de PHP ni de JQuery ni de JavaScript para hacerlo, lo cual es una ventaja para aquellos que estáis empezando en esto.</p>
<p>En esencia se construirá todo el menú utilizando estilos CSS, y podréis ver entre otras cosas que podéis mostrar y ocultar etiquetas dependiendo de vuestras necesidades.</p>
<!-- FIN_INTRODUCCION -->
<p>Existen dos formas de ocultar etiquetas : "<i>display:none</i>" y "<i>visibility:hidden</i>". Con la propiedad "<i>display</i>" ya hemos visto que podemos hacer varias cosas, y una de ellas es ocultar etiquetas, de todas formas y aunque es mas compatible con navegadores viejos considero que es mejor utilizar la propiedad "<i>visibility</i>" ya que la propiedad display puede que la necesitemos para otras cosas en la misma etiqueta. Por esa razón en este ejemplo se utilizara la propiedad "<i>visibility</i>" a la hora de mostrar y ocultar etiquetas.</p>
<p>De todas formas estas propiedades no hacen exactamente lo mismo, si por ejemplo hacemos "<i>display:none</i>" en un elemento, este elemento al estar oculto no ocupara espacio, por el contrario si utilizamos "<i>visibility:hidden</i>" aunque no se vea el elemento el navegador reservara su espacio mostrándolo en blanco.</p>
<p>En esencia cada menú consistirá en tres etiquetas, la primera "<b>MenuPadre</b>" será la encargada de mostrar el titulo para el menú y de contener dentro una segunda etiqueta a la cual llamaremos "<i>SubMenu</i>". La etiqueta "<b>SubMenu</b>" representara un marco oculto donde ubicaremos todos los enlaces que queramos mostrar, estos enlaces irán en una tercera etiqueta llamada "<b>SubMenuItem</b>" de forma que queden resaltados al pasar el mouse por encima.</p>
<div>
<img src="../Web/Graficos/Tutorial_HTML5_8_1.png" alt='Esquema menu' style='float:left' />
<?php
/*include("devildrey33.php");
$Base = new devildrey33(devildrey33_TipoPlantilla::Articulo, basename(__FILE__));
$Base->InicioPlantilla("Colorear código con PHP (Parte 1 XML)");*/
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = '<meta name="description" content="Colorear código">
<meta name="keywords" content="Colorear código XML">';
$Base->InicioPlantilla(basename(__FILE__), "Colorear código con PHP (Parte 1 XML)", $META);
$Base->InicioBlog(basename(__FILE__), "Colorear código con PHP (Parte 1 XML)");
?>
<!-- INTRODUCCION -->
<p>Últimamente ando bastante liado intentando automatizar varios aspectos de www.devildrey33.es, en especial estoy creándome unas funciones para colorear todo tipo de códigos.</p>
<p>La idea es tener un conjunto de funciones php que me faciliten la vida a la hora de mostrar archivos de código.</p>
<p>Para empezar vamos a hacer algo fácil, que será colorear un código XML con el formato que utiliza Dreamweaver.</p>
<!-- FIN_INTRODUCCION -->
<p>En primer lugar tenemos que tener muy claro que partes hay que poner de un color o de otro. En un archivo XML básicamente tenemos cuatro partes diferenciales que van a ir cada una en un color, y son : <b>etiquetas</b>, <b>cadenas de caracteres</b>, <b>conjuntos de datos</b>, y <b>comentarios</b>.</p>
<p>Veamos un ejemplo básico de un archivo XML :</p>
<?php
/* -[INICIO devildrey33.ID1]-
<!-- Comentario -->
<Etiqueta Atributo='Cadena de caracteres'>Conjunto de datos</Etiqueta>
-[FIN devildrey33.ID1]-*/
$Base->PintarCodigo->PintarArchivoXML("EjemploXML", "Ejemplo XML", basename(__FILE__), "ID1");
?>
<p>Como podéis ver el comentario está pintado de color gris, la etiqueta de color azul, la cadena de caracteres del atributo de color verde, y los datos internos de la etiqueta de color negro.</p>
<p>Obviamente podemos poner los colores como nos plazca, pero personalmente prefiero tener esta configuración de colores, que me es más familiar. Google chrome por ejemplo utiliza su propia configuración de colores y en vez de tener cuatro colores para diferenciar las distintas partes del XML tiene cinco.</p>
<p>Ahora vamos a hacer unos estilos css los cuatro colores que queremos usar :</p>
<?php
/* include("devildrey33.php");
$Base = new devildrey33(devildrey33_TipoPlantilla::Articulo, basename(__FILE__));
$Base->InicioPlantilla("Tutorial WINAPI C++ 1.5 (Creación de nuestro ObjetoBoton)");*/
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = '<meta name="description" content="Tutorial WINAPI">
<meta name="keywords" content="WINAPI C++, WINAPI, C++">';
$Base->InicioPlantilla(basename(__FILE__), "Tutorial WINAPI C++ 1.5 (Creación de nuestro ObjetoBoton)", $META);
$Base->InicioBlog(basename(__FILE__), "Tutorial WINAPI C++ 1.5 (Creación de nuestro ObjetoBoton)");
?>
<!-- INTRODUCCION -->
<p>En este tutorial vamos a aplicar varios conceptos anteriores que son la creacion de ventanas y utilizar el GDI de windows para dar paso a la creacion de nuestro primer control desde cero.</p>
<p>Aunque windows ya nos ofrece toda una gama de controles listos para utilizar, siempre es interesante ver y comprender como podemos crear nosotros mismos nuestro propio control. Ademas hay muchos casos en los que podemos necesitar algo que no sea 'estandar' por lo que al final nos sera mas conveniente crear este tipo de cosas partiendo de cero.</p>
<!-- FIN_INTRODUCCION -->
<p>Diría que el 90% de la gente que ha programado controles, programaron un botón la primera vez, y yo no fui una excepción. Por suerte vosotros vais a tener una orientación bastante mas enfocada de la que obtuve yo en su tiempo, lo que os permitirá hacer un botón chulo utilizando funciones de pintado del GDI de Windows junto con la clase ObjetoHWND que creamos anteriormente.</p>
<p>A la hora de hacer cualquier control hay que tener muy claras sus funciones y que tipo de comportamiento seguirá. En este caso sabemos que queremos un botón con el borde redondeado, el cual tenga todos los colores configurables, y podamos cambiar su fuente. Además este botón tendrá un efecto de resaltado cuando el mouse pase por encima, y un efecto de presión cuando pulsemos con el mouse encima de este. </p>
<p>Lo primero de todo va a ser hacernos nuestra clase base para controles, de la misma forma que tenemos la clase ObjetoVentana ahora vamos a hacer una clase ObjetoControl enfocada a controles que tienen una ventana padre.</p>
<?php
$Base->PintarCodigo->PintarArchivoC("IDObjetoControl", "Archivo : ObjetoControl.h", "../Codigo/Tutoriales_WinAPI/Objetos Tutorial/ObjetoControl.h", "ObjetoControl");
?>
<p>Vamos a tener que modificar el mensaje <a href="http://msdn.microsoft.com/en-us/library/ms645616(VS.85).aspx" target="_blank">WM_MOUSEMOVE</a> para llamar a la API <a href="http://msdn.microsoft.com/en-us/library/ms646265(VS.85).aspx" target="_blank">TrackMouseEvent</a>. Esta API lo que hace es informarnos cuando el mouse sale del control mediante el mensaje <a href="http://msdn.microsoft.com/en-us/library/ms645615(VS.85).aspx" target="_blank">WM_MOUSELEAVE</a>. En el mensaje <a href="http://msdn.microsoft.com/en-us/library/ms645615(VS.85).aspx" target="_blank">WM_MOUSELEAVE</a> hay que poner el miembro _MouseDentro a false, para que cuando vuelva a entrar el mouse en el control se use la API TrackMouseEvent. (Todo esto se hace en la plantilla PlantillaEventos.</p>
<?php
$Base->PintarCodigo->PintarArchivoC("IDEventos_Mouse", "Archivo : PlantillaEventos.h", "../Codigo/Tutoriales_WinAPI/Objetos Tutorial/PlantillaEventos.h", "Eventos_Mouse");
?>
<p>Como cada control tendrá sus colores, y la verdad es un engorro ir creando una función para asignar y otra para obtener el color, crearemos una macro que nos ahorrara tener que escribir dichas funciones. La idea es que la macro reciba un parametro, que será el nombre de las funciones asignar y obtener, ademas también creara una variable del tipo COLORREF que tendrá el mismo nombre con el carácter '_' delante. </p>
<?php
<?php
/* include("devildrey33.php");
$Base = new devildrey33(devildrey33_TipoPlantilla::Articulo, basename(__FILE__));
$Base->InicioPlantilla("FlexBox para diseños responsive", $HEAD);*/
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = "<meta name='description' content='FlexBox responsive'>\n\t<meta name='keywords' content='CSS, FlexBox, responsive, media query, css order, css flex-flow, css flex, @media'>";
$Base->InicioPlantilla(basename(__FILE__), "FlexBox para diseños responsive", $META);
$Base->InicioBlog(basename(__FILE__), "FlexBox para diseños responsive");
echo "<script>\$Base.CargarCSS('Blog_flex-box-y-media-queries.css');</script>";
?>
<!-- INTRODUCCION -->
<p>El CSS sigue avanzando y el modelo FlexBox ya ha llegado a la fase de candidato final, por lo que ya funciona en todos los navegadores, prácticamente al 100%.</p>
<p>Hoy voy a explicar un poco como podemos crear un documento responsive, aprovechando las ventajas del modelo FlexBox. Si combinamos el FlexBox con la regla <a href="/Doc/CSS/Reglas/@media">@media</a> podemos conseguir documentos totalmente responsive con unas pocas declaraciones CSS, y un marcaje HTML muy claro.</p>
<p>El modelo FlexBox nos permite tener un contenedor al cual podemos establecer si queremos mostrar sus hijos por columnas o por filas. La idea es crear una cabecera, un marco principal (que será la FlexBox), y un footer. Dentro del marco principal crearíamos un menú de navegación, un artículo, y un menú lateral alternativo.</p>
<!-- FIN_INTRODUCCION -->
<p>El objetivo es que si la resolución es menor que 500 pixeles la página se muestre únicamente a base de filas, ya que los menús laterales no cabrían.</p>
<div style='position:relative; padding-top:20px;'>
<div class='Marca800'></div>
<div class='Marca500'></div>
<div class='Marca300'></div>
<span style="color:red; position:absolute; left:250px;">300px</span>
<span style="color:orange; position:absolute; left:450px;">500px</span>
<span style="color:green; position:absolute; left:750px;">800px</span>
<br />
<iframe id='Ejemplo' src="/Ejemplos/FlexBox/Documento.html"></iframe>
</div><br />
<h2>Maquetación HTML</h2>
<?php
include "Web/devildrey33.php";
$Web = new devildrey33();
$Web->InicioPlantilla(basename(__FILE__), "devildrey33.es", "");
$ArrayDatos = (require dirname(__FILE__) . '/Web/Passwords.php');
// Valores de las configuraciones del htaccess
$htaccess = devildrey33_htaccess::ObtenerValores();
?>
<article class='Blog' pagina='FaqBarba.php'>
<br />
<h2>Instal·lació</h2>
<p>Et vaig dir que la web no funcionaba si no la posaves a l'arrel del servidor, però ara ja es pot fer anar desde un sub-directori.</p>
<?php
if ("/" . Base::PathRelativo_Raiz() !== $htaccess["RewriteBase"]) {
echo "<p>Desde aquesta arrel " . Base::URL_Raiz() . " es necesita un '<code>RewriteBase /" . Base::PathRelativo_Raiz() . "</code>' i tens ho configurat com a '<code style='color:red; font-weight:bold'>RewriteBase " . $htaccess["RewriteBase"] . "</code>'. " . "Obre aquest enllaç per solucionar-ho : <a href='AsignarRaiz.php' target='_blank'>AsignarRaiz.php</a>, i despres recarrega el Faq.";
} else {
echo "<p>Desde aquesta arrel " . Base::URL_Raiz() . " es necesita un '<code>RewriteBase /" . Base::PathRelativo_Raiz() . "</code>' i tens ho configurat com a '<code style='color:green; font-weight:bold'>RewriteBase " . $htaccess["RewriteBase"] . "</code>'. ";
}
?>
<div class='nota'>No utulitzis espais ni caracters raros per l'arrel del directori. </div>
<p>Si el <code>RewriteBase</code> no està configurat correctament, no funcionara cap enllaç que no estigui acabat amb <code>.php</code> ni tampoc funcionaran les peticions Ajax (el 99% de les peticions son al directori virtual <code>/cmd/</code>). </p>
<ul>
<li><b>Si vols accedir a la web desde http://localhost/directori web/</b> però pot ser que alguna imatge o alguna url no funcionin correctament.
</li>
<li><b>Si vols que la web funcioni al 100%</b> exactament com en el servidor de 1and1, hauras de configurar-te el servidor de forma que la web quedi a l'arrel, es a dir <b>NO VAL</b> : <code style="color:red">http://localhost/devildrey33</code>, hauras d'enllaçarte un domini d'aquest estil : <code style="color:green">http://devildrey33.st0rm</code> amb el VirtualHost dintre del httpd.conf (recorda que tambè hauras de modificar l'arxiu de hosts), o posar-la a <code style="color:green">http://localhost/</code> directament.</li>
<?php
echo "<li><b>La web pot funcionar sense BD</b>, pero obviament no podras accedir a certes funcions. Si necesites les funcions de la BD (comentaris i stats varis) has de crear la BD <b>" . $ArrayDatos["NOM-BD"] . "</b> amb login '<b>root</b>', pass '<b>" . $ArrayDatos["PASS-Barba"] . "</b>'.</li>";
?>
</ul>
}
.Div_Separador {
border-bottom-style:dashed;
border-bottom-width:1px;
border-bottom-color:#CCC;
height:1px;
}
</style>
';
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = '<meta name="description" content="CSS Unidades">
<meta name="keywords" content="CSS, CSS3, CSS3 Unidades">';
$Base->InicioPlantilla(basename(__FILE__), "Referéncia CSS : Unidades", $META);
$Base->InicioBlog(basename(__FILE__), "Referéncia CSS : Unidades");
?>
<!-- INTRODUCCION -->
<p>En CSS se necesita estar constantemente asignando tamaños a los distintos tipos de objetos de la web, para ello existen varias alternativas, pero quizás lo mas difícil es elegir con cabeza la que más nos conviene.</p>
<p>Básicamente se pueden desglosar estas alternativas en dos grupos : tamaños relativos, y tamaños absolutos. Los tamaños relativos vienen a ser los porcentajes, pixeles, etc.. que dependiendo de la resolución pueden cambiar mucho. Los tamaños absolutos son Centímetros, Pulgadas, etc.. ya que un centímetro mide lo mismo aquí que en Marte.</p>
<!-- FIN_INTRODUCCION -->
<p>A la hora de elegir un determinado tipo de tamaño para nuestro sitio web, hay que pensar en su finalidad, si por ejemplo va a ser una web que acabara imprimida, nos conviene utilizar medidas absolutas para que en el papel siempre queden igual. En cambio si nuestro sitio web va a ser más bien para presentaciones online nos conviene más un tamaño relativo que pueda adaptarse a distintos tipos de resoluciones.</p>
<h2>Unidades de tamaño relativas</h2><br />
<table class="Tabla">
<tr>
<th>Unidad</th>
<?php
/* include("devildrey33.php");
$Base = new devildrey33(devildrey33_TipoPlantilla::Articulo, basename(__FILE__));
$DeclaracionesHeadExtras = '
<script type="text/javascript" src="js/TestVelocidad.js"></script>
<link href="./css/ComparativaNavegadores.css" rel="stylesheet" type="text/css" />
';
$Base->InicioPlantilla("Comparativa navegadores 2011", $DeclaracionesHeadExtras);*/
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = '<meta name="description" content="Comparativa navegadores 2011">
<meta name="keywords" content="Comparativa navegadores">';
$Base->InicioPlantilla(basename(__FILE__), "Comparativa navegadores 2011", $META);
$Base->InicioBlog(basename(__FILE__), "Comparativa navegadores 2011");
?>
<script type="text/javascript" src="/Ejemplos/TestVelocidad/TestVelocidad.js"></script>
<!-- INTRODUCCION -->
<p>En este articulo se verán las diferencias principales entre los navegadores que se usan actualmente (Google chrome, Mozilla firefox, Safari, Opera y Internet explorer), sobretodo enfocaremos esta comparativa en términos de velocidad y de soporte de nuevas tecnologías.</p>
<p>Se van a tener en cuenta varios estilos css que a mi entender son muy básicos y necesarios, y la velocidad de ejecución con códigos javascript.</p>
<!-- FIN_INTRODUCCION -->
<p>Empezaremos por un repaso rápido de algunos estilos css de última generación, y veremos que navegadores los soportan.</p>
<div style='clear:both'></div>
<table class="Tabla">
<tr>
<th> </th>
<th>Chrome 8</th>
<?php
/* include("devildrey33.php");
$Base = new devildrey33(devildrey33_TipoPlantilla::Articulo, basename(__FILE__));
$Base->InicioPlantilla("Tutorial C++ 4 Creación de archivos DUMP.");*/
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = '<meta name="description" content="Tutorial WINAPI">
<meta name="keywords" content="WINAPI C++, WINAPI, C++">';
$Base->InicioPlantilla(basename(__FILE__), "Tutorial C++ 4 Creación de archivos DUMP", $META);
$Base->InicioBlog(basename(__FILE__), "Tutorial C++ 4 Creación de archivos DUMP");
?>
<!-- INTRODUCCION -->
<p>Los archivos DUMP son una forma de depurar aplicaciones con windows. La idea consiste en que cuando una aplicación falla críticamente se guarda un archivo con el contenido de la memoria de esta.</p>
<p>Más tarde podemos abrir esos archivos con el Visual Studio y depurar la aplicación (siempre que tengamos su código fuente a mano).</p>
<p>Por ejemplo <a href='/Blog/BubaTronik'>BubaTronik</a> si tiene un error critico, crea un archivo dump y pide al usuario permiso para mandarme este archivo dump a mi cuenta de correo. Cosa que es muy útil para depurar errores que yo no he visto en mi maquina.</p>
<!-- FIN_INTRODUCCION -->
<p>Para ver cómo funciona este proceso, vamos a hacer una aplicación muy básica que consistirá en una ventana vacía, la cual al ser clickeada con el botón izquierdo provocara un error crítico.</p>
<h2>Función MAIN</h2>
<?php
$Base->PintarCodigo->PintarArchivoC("IDMain", "", "../Codigo/Tutoriales_WinAPI/4 Tutorial crear archivo DUMP/main.cpp", "WinMain");
?>
<p>Lo más destacable de esta función WinMain son las <linea cid='IDMain' l='3,4'>dos primeras líneas de código (3,4)</linea>. En la primera declaramos una variable del tipo <linea cid='IDMain' l='3'>LPTOP_LEVEL_EXCEPTION_FILTER</linea> diseñada para guardar la dirección de una función que hace de filtro de errores.</p>
<p>Luego llamamos a la API <a cid='IDMain' l='4' href="http://msdn.microsoft.com/en-us/library/windows/desktop/ms680634(v=vs.85).aspx" target="_new">SetUnhandledExceptionFilter</a> para asignar nuestra función para filtrar los errores, y esta nos devuelve la dirección del filtro de errores por defecto que tenía asignado la aplicación.</p>
<p>Con esto acabamos de re-direccionar los errores críticos a nuestra propia función, en la cual podemos entre otras osas escribir el archivo DUMP.</p>
<h2>Función FiltroError</h2>
<?php
$Base->PintarCodigo->PintarArchivoC("IDFiltroError", "", "../Codigo/Tutoriales_WinAPI/4 Tutorial crear archivo DUMP/main.cpp", "FiltroError");
?>
<?php
/* include("devildrey33.php");
$Base = new devildrey33(devildrey33_TipoPlantilla::Articulo, basename(__FILE__));
$Base->InicioPlantilla("WebGL");*/
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = "<meta name='description' content='Ejemplos WebGL'>\n\t<meta name='keywords' content='WebGL'>";
$Base->InicioPlantilla(basename(__FILE__), "WebGL", $META);
$Base->InicioBlog(basename(__FILE__), "WebGL");
?>
<!-- INTRODUCCION -->
<p>WebGL es el nombre que utiliza el nuevo sistema para renderizar gráficos en 3d específicamente diseñado para HTML5, dicho sistema está basado en OpenGL, y recientemente ha llegado a la versión 1.0 por lo que ya ha pasado las fase beta, y ahora empiezan a salir aplicaciones web que utilizan esta nueva tecnología. De todas formas aunque la especificación de WebGL sea la 1.0 esto no quiere decir que los navegadores sean capaces hacerla correr al 100%, y aun pasara algún tiempo hasta que la gran mayoría de los navegadores funcionen a la perfección con aplicaciones WebGL.</p>
<p>En la práctica esto es un avance bastante prometedor ya que convierte a la mayoría de navegadores en plataformas para visualizar gráficos en 3d (con la excepción de internet explorer como no...)</p>
<!-- FIN_INTRODUCCION -->
<p>Por el momento aun solo existen demostraciones de dicha tecnología, que desde mi punto de vista aun requiere algunas optimizaciones, pero lo que se empieza a ver es muy esperanzador, y no me extrañaría que en un futuro empezaran a salir juegos sin nada que envidiar bajo esta plataforma (aunque aún queda mucho por hacer).</p>
<p>El concepto de renderizar juegos bajo esta plataforma es muy innovador ya que es totalmente independiente del sistema operativo, por lo que correría tanto en windows como en linux sin necesidad de adaptar nada en teoría. Aunque para ser sinceros tenemos los señores de microsoft que siempre hacen lo que más les conviene y no es precisamente adaptarse a los estándares, por lo que no sería de extrañar que dichas aplicaciones requieran código especial para internet explorer. De todas formas sigue siendo un concepto muy innovador y el tiempo nos dirá como acaba.</p>
<p>Además este sistema creo que acabara re-emplazando las antiguas animaciones en flash que han quedado estancadas en el pasado (sinceramente odio el flash, y en la actualidad supone un problema para plataformas de 64 bits que a día de hoy aun siguen en versión beta)</p>
<p>Algunas de las presentaciones que más me han impresionado son las siguientes :</p>
<h2>Cycleblob</h2>
<p>Esta presentación / juego viene a ser como un remake de la película Tron convertida a videojuego, y aunque no presenta unos gráficos extraordinarios es un muy buen ejemplo de lo que se puede hacer con WebGL. El juego dispone de varios niveles, y la posibilidad de añadir hasta 5 competidores controlados por la CPU.</p>
<img src="../Web/Graficos/Cycleblob2.png" alt="CycleBlob" />
<img src="../Web/Graficos/Cycleblob.png" alt="CycleBlob" />
<p>Pagina web oficial : <a href="http://www.cycleblob.com/" target="_blank">CycleBlob</a> </p>
<h2>Chrome Experiments WebGL</h2>
<p>Recientemente la gente de google han habilitado este portal donde los desarrolladores pueden colgar sus experimentos con opengl para que el resto del mundo pueda verlos.</p>
<?php
include $_SERVER['DOCUMENT_ROOT'] . "/Web/devildrey33.php";
$Base = new devildrey33();
if (!isset($_POST["SinPlantilla"])) {
$Base->InicioPlantilla(basename(__FILE__), "Test HTML", "");
}
?>
<!-- -[INICIO devildrey33.char]-
abc
-[FIN devildrey33.char]- -->
<div style='padding:10px'>
<h2>HTML</h2>
<?php
/* -[INICIO devildrey33.HTML]-
<html>
<head>
<title>Ejemplo colorear HTML</title>
<link href='ColorearCodigoPHP_HTML_Ejemplo.css' rel='stylesheet' type='text/css' />
<!-- Código CSS -->
<style>.MiEstilo { margin-left:auto; margin-right:auto; }</style>
<style>
.MiEstilo {
margin-left:auto;
<?php
/* include("devildrey33.php");
$Base = new devildrey33(devildrey33_TipoPlantilla::Articulo, basename(__FILE__));
$Base->InicioPlantilla("Tutorial WINAPI C++ 1.1 (POO y WinMain)");*/
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = '<meta name="description" content="Tutorial WINAPI">
<meta name="keywords" content="WINAPI C++, WINAPI, C++">';
$Base->InicioPlantilla(basename(__FILE__), "Tutorial WINAPI C++ 1.1 (POO y WinMain)", $META);
$Base->InicioBlog(basename(__FILE__), "Tutorial WINAPI C++ 1.1 (POO y WinMain)");
?>
<!-- INTRODUCCION -->
<p>Introducción básica a la <strong>P</strong>rogramación <strong>O</strong>rientada a <strong>O</strong>bjetos :</p>
<p>En la programación orientada a objetos, un objeto es un conjunto de métodos que se han diseñado para llevar a cabo una tarea. En este ámbito debemos pensar que el objeto contiene miembros públicos desde donde otros objetos accederán a el, y miembros privados que se utilizan internamente para realizar la tarea del objeto. Si aplicamos esto a la programación orientada a objetos bajo windows debemos tener claro que una ventana será un objeto, los botones de esa ventana también serán objetos que residirán dentro de esta, y dichos botones no serán accesibles entre ellos, es decir el botón 1 no sabe el texto que tiene el botón 2 y viceversa. En el caso de que necesitáramos pasarle el texto del botón 1 al botón 2 esto se llevaría a cabo desde el objeto ventana, ya que dicho objeto tiene acceso a los métodos y funciones públicos de los 2 botones. </p>
<!-- FIN_INTRODUCCION -->
<p>
<img src= "../Web/Graficos/ObjetosCalculadora.png" alt="Grafico objetos calculadora" style="float:right" />Para ver este concepto más claro vamos a plantearnos que necesitamos hacer una calculadora. Esa calculadora requiere una ventana, diez botones con los números del 0 al 9, cinco botones para las operaciones básicas (suma, resta, multiplicación, división y resultado), un marcador para que podamos ver los resultados por pantalla que ademas realizara las operaciones de la calculadora. En la parte derecha podéis ver un esquema de como podríamos estructurar los objetos de la calculadora.
</p><p>
Una vez tengamos esta estructuración en mente, ya podemos empezar a darle forma. Empezaremos por ver la función WinMain de Windows, que viene a ser un substituto del típico int main(void) .
</p><p>
La función quedaría más o menos así :
</p>
<?php
$Base->PintarCodigo->PintarArchivoC("IDWinMain", "Archivo : Tutorial_WinMain.cpp", "../Codigo/Tutoriales_WinAPI/Tutorial_WinMain.cpp", "WinMain");
?>
<p>Como podéis ver el WinMain nos da 4 parámetros :</p>
<?php
/* include("devildrey33.php");
$Base = new devildrey33(devildrey33_TipoPlantilla::Articulo, basename(__FILE__));
$Base->InicioPlantilla("Tutorial WINAPI C++ 2.1 (Creación del ObjetoEscena)");*/
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = '<meta name="description" content="Tutorial WINAPI">
<meta name="keywords" content="WINAPI C++, WINAPI, C++">';
$Base->InicioPlantilla(basename(__FILE__), "Tutorial WINAPI C++ 2.1 (Creación del ObjetoEscena)", $META);
$Base->InicioBlog(basename(__FILE__), "Tutorial WINAPI C++ 2.1 (Creación del ObjetoEscena)");
?>
<!-- INTRODUCCION -->
<p>Esta parte del tutorial consistira en crear un objeto que se encargara de gestionar la escena. La escena seran todos aquellos graficos que se tengan que pintar en la venana, y en este caso consistira en un fondo y varias 'ventanas' translucidas. </p>
<p>Necesitaremos crear cuatro modelos de ventanas translucidas por lo que sera una buena idea hacer un modelo base del cual poder derivar nuestras futuras tres ventanas translucidas, que seran : Marcador, Tablero, Mensaje y Records.</p>
<!-- FIN_INTRODUCCION -->
<p>Bueno para empezar todos conoceréis el típico juego de la serpiente que va comiendo fichas, y se hace mas grande, en el que la única dificultad reside en no chocar con ella misma o con los muros. </p>
<p>El juego en si no es muy complicado de programar, pero lo que se pretende es tener en primera instancia una base para un entorno grafico que nos pueda servir tanto para este juego, como para otro tipo de aplicaciones.</p>
<p>Lo primero será definir que queremos que haga esta interfaz grafica, y como estructurarla de forma que luego resulte simple añadir nuevas funciones a esta.</p>
<p>Lo que se busca es : Una ventana padre que pueda contener un fondo, y que simule dentro de ella unas ventanas translucidas que se usaran en este caso para mostrar el juego, el marcador, mensajes como la pausa, y los records.</p>
<p>Para cumplir estos objetivos se diseñaran 2 clases básicas : ObjetoEscena y ObjetoEscena_VentanaTranslucida.</p>
<p>El ObjetoEscena deberá ser capaz de mostrar una o mas ventanas translucidas, y el ObjetoEscena_VentanaTranslucida se encargara de pintar los gráficos que necesitemos para dicha ventana. Por ello necesitaremos crear estas dos clases paralelamente ya que no podrán funcionar una sin la otra.</p>
<p>Veamos la declaración de ObjetoEscena :</p>
<?php
$Base->PintarCodigo->PintarArchivoC("IDObjetoEscena", "Archivo : ObjetoEscena.h", "../Codigo/Tutoriales_WinAPI/Objetos Tutorial/ObjetoEscena.h", "ObjetoEscena");
?>
<p>Esta clase en esencia tiene una función para crear la ventana, 2 funciones / eventos que re-emplazaran los eventos de pintado, y varias funciones para interactuar con la escena. Además también contiene un vector de ObjetoEscena_VentanaTranslucida en el cual se almacenaran todas las ventanas translucidas que necesitemos crear.</p>
<p>La idea es que esta clase pinte un fondo partiendo de una imagen BMP, y luego pinte encima cada ventana translucida de forma ordenada. Para entenderlo mejor pintaremos todos los objetos que contiene nuestra escena, empezando por el último objeto visible hasta el primero.</p>
<?php
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = '<meta name="description" content="Tutorial WINAPI">
<meta name="keywords" content="WINAPI C++, WINAPI, C++">';
$Base->InicioPlantilla(basename(__FILE__), "Tutorial WINAPI C++ 1.4 (Entorno gráfico de windows GDI)", $META);
$Base->InicioBlog(basename(__FILE__), "Tutorial WINAPI C++ 1.4 (Entorno gráfico de windows GDI)");
/*include("devildrey33.php");
$Base = new devildrey33(devildrey33_TipoPlantilla::Articulo, basename(__FILE__));
$Base->InicioPlantilla("Tutorial WINAPI C++ 1.4 (Entorno gráfico de windows GDI)");*/
?>
<!-- INTRODUCCION -->
<p>Con este tutorial empezaremos a tocar la parte grafica de las ventanas, cosa que nos servira mas adelante para moldear y pintar todos los controles de creacion propia a nuestro antojo.</p>
<p>En esencia vamos a ver como responder al mensaje <b>WM_PAINT</b> de windows, que es el encargado de avisarnos cuando una ventana necesita repintarse. Luego utilizaremos este mensaje para escribir una cadena de caracteres en la ventana, y pintar el fondo de toda la ventana utilizando un color aleatorio.</p>
<p></p>
<!-- FIN_INTRODUCCION -->
<p>Aun recuerdo cuando hice un cursillo de programación básico, y mi profesor decía : hay 2 tipos de programadores en esencia, los que mueven datos, y los que mueven gráficos. Ahora le doy la razón, a pesar de que una aplicación no solo son gráficos o datos y siempre se requiere de las dos partes, y yo tengo una afición especial para añadir acabados gráficos que marquen la diferencia. </p>
<p>Supongo que más de uno recordara Windows 95/98/ME, con sus gráficos 100% rectangulares, pues os sorprendería ver la de aplicaciones con un acabado excelente bajo esos sistemas operativos, y no precisamente gracias a los controles estándar de windows. Yo personalmente tengo una serie de controles creados por mi que simulan gran parte de los controles estándar de windows con varias mejoras graficas y que además son perfectamente configurables en su apariencia. Actualmente con windows 7 y windows vista la cosa ha mejorado mucho en cuanto al aspecto grafico, pero no por ello tenemos que usar los controles por defecto del windows.</p>
<p>Bueno dejando de banda mi historial académico y versiones antiguas de windows, empezaremos a familiarizarnos con el GDI de windows. Windows esta hecho de tal forma que cuando necesita repintar algo, solo repinta lo que necesite cambios, es decir si minimizamos una ventana windows repintara la porción de la pantalla donde estaba esa ventana.</p>
<p>Pongamos por ejemplo una ventana con 4 controles dentro, y windows necesita repintar la mitad de la ventana, la cual solo contiene 2 controles. Que pasara? Windows mandara un mensaje <a href="http://msdn.microsoft.com/en-us/library/dd145213%28VS.85%29.aspx" target="_blank">WM_PAINT</a> a la ventana indicando que esta debe repintarse, además windows mirara que controles están dentro de la región de repintado, y repetirá el mensaje <a href="http://msdn.microsoft.com/en-us/library/dd145213%28VS.85%29.aspx" target="_blank">WM_PAINT</a> en los controles que queden dentro.</p>
<p>Para poder pintar cualquier cosa en windows necesitamos obtener el HDC de la ventana que queremos pintar. El HDC es una herramienta de windows para pintar gráficos, y está formado por varios objetos. Para empezar un HDC tiene un objeto HBITMAP, que es donde se almacenan los gráficos en esencia, también tiene un objeto HFONT que enlaza con la fuente seleccionada que se usa para pintar texto, un objeto HPEN que simboliza una pluma de un color para pintar líneas, un HBRUSH que simboliza una brocha para pintar regiones de un color, y otros objetos. </p>
<p>Desde un mensaje <a href="http://msdn.microsoft.com/en-us/library/dd145213%28VS.85%29.aspx" target="_blank">WM_PAINT</a> para acceder al DC debemos usar las API's <a href="http://msdn.microsoft.com/en-us/library/dd183362%28VS.85%29.aspx" target="_blank">BeginPaint</a> y <a href="http://msdn.microsoft.com/en-us/library/dd162598(v=VS.85).aspx" target="_blank">EndPaint</a>, ya que estas funciones están preparadas para pintar SOLO la porción que windows necesita. Dentro de la estructura <a href="http://msdn.microsoft.com/en-us/library/dd162768(VS.85).aspx" target="_blank">PAINTSTRUCT</a> podemos encontrar la región que se requiere pintar, o podemos ignorar esos datos y pintar todo el HDC, y dejar que windows pinte la porción que necesite (cosa que será más lenta pero más cómoda).</p>
<?php
$Base->PintarCodigo->PintarArchivoC("IDWM_PAINT", "Archivo : PlantillaEventos.h", "../Codigo/Tutoriales_WinAPI/Objetos Tutorial/PlantillaEventos.h", "WM_PAINT");
?>
<p>Si por el contrario queremos acceder a un HDC para repintarlo nosotros mismos sin enviar el mensaje <a href="http://msdn.microsoft.com/en-us/library/dd145213%28VS.85%29.aspx" target="_blank">WM_PAINT</a>, debemos utilizar las API's <a href="http://msdn.microsoft.com/en-us/library/dd144871%28VS.85%29.aspx" target="_blank">GetDC</a> y <a href="http://msdn.microsoft.com/en-us/library/dd162920(v=VS.85).aspx" target="_blank">ReleaseDC</a>. Hay casos en los que podemos necesitar repintar nuestra ventana / control, por ejemplo si queremos hacer un efecto de resaltado cuando pasamos por encima con el mouse, debemos repintar la ventana una vez cuando el mouse esta dentro, y una vez cuando el mouse sale. </p>
<?php
$Base->PintarCodigo->PintarArchivoC("IDRePintar", "Archivo : Tutorial_GDI.cpp", "../Codigo/Tutoriales_WinAPI/1.04 Tutorial GDI/Tutorial_GDI.cpp", "RePintar");
<?php
/* include("devildrey33.php");
$Base = new devildrey33(devildrey33_TipoPlantilla::Articulo, basename(__FILE__));
$Base->InicioPlantilla("Tutorial WinAPI C++ 3.4 (Creación del ObjetoButton)");*/
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = '<meta name="description" content="Tutorial WINAPI">
<meta name="keywords" content="WINAPI C++, WINAPI, C++">';
$Base->InicioPlantilla(basename(__FILE__), "Tutorial WinAPI C++ 3.4 (Creación del ObjetoButton)", $META);
$Base->InicioBlog(basename(__FILE__), "Tutorial WinAPI C++ 3.4 (Creación del ObjetoButton)");
?>
<!-- INTRODUCCION -->
<p>En este tutorial veremos el funcionamiento del control BUTTON de windows. Para ello lo encapsularemos en una clase que tendrá de nombre ObjetoButton, y que heredara de ObjetoControlEstandar (La clase ObjetoControlEstandar se describe en el tutorial <a href="Tutorial_WINAPI_3_3.php" target="_self">3.3 Creación del ObjetoEditBox</a>).</p>
<p>Tambien veremos como responder cuando el usuario presiona encima del boton mediante el mensaje WM_COMMAND, y como decirle que fuente debe utilizar (si no deseamos la fuente estandar de windows) mediante el mensaje WM_SETFONT.</p>
<!-- FIN_INTRODUCCION -->
<p>Veamos su declaración :</p><div style="clear:both"></div>
<?php
$Base->PintarCodigo->PintarArchivoC("IDObjetoButton", "Archivo : ObjetoButton.h", "../Codigo/Tutoriales_WinAPI/Objetos Tutorial/ObjetoButton.h", "ObjetoButton");
?>
<p>Como podemos ver, esta clase tiene un miembro para crear el botón, un mimebro para asignar su texto, un miembro para obtener su texto, y un miembro privado que tendrá la funete del botón cargada en memoria.</p>
<p>Veamos la función CrearButton :</p>
<?php
$Base->PintarCodigo->PintarArchivoC("IDCrearButton", "Archivo : ObjetoButton.cpp", "../Codigo/Tutoriales_WinAPI/Objetos Tutorial/ObjetoButton.cpp", "ObjetoButton::CrearButton");
?>
<p>Lo primero que se hace es llamar a la función ObjetoIniciarCommonControls::Iniciar. Esta función llama a la API <a href="http://msdn.microsoft.com/en-us/library/bb775697(VS.85).aspx" target="_blank">InitCommonControlsEx</a> para iniciar los controles estándar de windows para nuestra aplicación. Antiguamente en VC6 esto era necesario si queríamos trabajar con controles estándar, pero ahora mismo a decir verdad ya no se si es necesario, porque en mi maquina me funcionan igual los ejemplos tanto si llamo a <a href="http://msdn.microsoft.com/en-us/library/bb775697(VS.85).aspx" target="_blank">InitCommonControlsEx</a> como si no… y en la MSDN no dice nada.. Por lo que prefiero mantener este codigo por si las moscas.</p>
<p>Lo segundo que se hace es llamar a la API <a href="http://msdn.microsoft.com/en-us/library/ms632680(VS.85).aspx" target="_blank">CreateWindowEx</a> con el segundo parámetro “BUTTON” (que es el nombre de la clase). Esto hace que el control creado se convierta en un BUTTON. Para ver más nombres de control mira este enlace de la MSDN : <a href="http://msdn.microsoft.com/en-us/library/ms632679(VS.85).aspx" target="_blank">CreateWindow</a> (Casi al final hay una tabla que muestra los nombres de classe mas comunes)</p>
<p>Lo siguiente es llamar a la función _ConectarControl, que re-emplazara el WindowProcedure del Button por el nuestro.</p>
<?php
/* include("devildrey33.php");
$Base = new devildrey33(devildrey33_TipoPlantilla::Articulo, basename(__FILE__));
$Base->InicioPlantilla("PHP : Objeto devildrey33_PintarCodigo");*/
include "../Web/devildrey33.php";
$Base = new devildrey33();
$META = '<meta name="description" content="Colorear código">
<meta name="keywords" content="devildrey33_PintarCodigo">';
$Base->InicioPlantilla(basename(__FILE__), "PHP : Objeto devildrey33_PintarCodigo", $META);
$Base->InicioBlog(basename(__FILE__), "PHP : Objeto devildrey33_PintarCodigo");
?>
<!-- INTRODUCCION -->
<p>Este objeto es en el que he basado los 6 tutoriales anteriores sobre Colorear código con PHP.</p>
<p>Uno de los problemas de parsear el código y mostrarlo, es que requiere que el servidor PHP realice ciertos cálculos, y por ello puede resultar pesado para ciertos sitios web.</p>
<p>Si por ejemplo tenemos un sitio con 10000 visitas diarias y tenemos que hacer el parsing de un código 10000 veces al día, estoy seguro que en más de un momento si el servidor pudiera hablar nos diría muchas palabras mal sonantes.</p>
<p>Por ello este objeto tiene incorporado un sistema que guarda el parsing realizado en un archivo del servidor para ahorrarle trabajo, lo que se traduce en una respuesta más rápida por parte de él al mostrar las páginas web a los usuarios.</p>
<!-- FIN_INTRODUCCION -->
<p>Por si solo este objeto me ofrece la posibilidad de pintar códigos tal y como los veo en los programas que utilizo para desarrollarlos, y además sin necesidad de tener que re-escribirlos en el documento HTML final.</p>
<p>Si por ejemplo tengo el archivo main.c, y quiero mostrar una parte de él en un documento HTML, utilizando una simple línea de código este objeto realiza el parsing y lo muestra en el documento HTML final. Anteriormente he comentado que estos parsings se guardan en el servidor PHP una vez realizados para agilizar el proceso, pero esto no es inconveniente si al cabo de una semana decido modificar el archivo main.c, ya que este mismo objeto comprobara que la fecha de modificación del archivo main.c sea anterior a la del archivo del parsing. En caso contrario este objeto volverá a parsear la porción de código indicada y guardara nuevamente los cambios.</p>
<p>Además también crea un marco que nos facilita la visualización del código y que viene con las líneas numeradas, por si luego hay que explicar de esas líneas específicamente que sea mucho más fácil de hacer.</p>
<p>En esencia para cada tipo de código existen 3 funciones :</p>
<ul>
<li>Pintar...</li>
<li>PintarTexto...</li>
<li>PintarArchivo...</li>
</ul>
<p>La primera función recibe una cadena de caracteres y realiza el parsing al lenguaje especificado.</p>
<p>La segunda función básicamente es como la primera, con la diferencia de que devuelve el código para mostrar el marco además del código parseado y pintado a su lenguaje correspondiente.</p>