initial commit

5 files changed, 1128 insertions, 0 deletions

diff --git a/files/es/creación_de_componentes_xpcom/index.html b/files/es/creación_de_componentes_xpcom/index.html
new file mode 100644
index 0000000000..036df7b989
--- /dev/null
+++ b/files/es/creación_de_componentes_xpcom/index.html
@@ -0,0 +1,274 @@
+---
+title: Creación de Componentes XPCOM
+slug: Creación_de_Componentes_XPCOM
+tags:
+  - Todas_las_Categorías
+  - XPCOM
+  - páginas_a_traducir
+translation_of: Mozilla/Tech/XPCOM/Guide/Creating_components
+---
+<p></p><div class="prevnext" style="text-align: right;">
+    <p><a href="/es/docs/Creating_XPCOM_Components:Preface">Siguiente  »</a></p>
+</div><p></p>
+
+<h3 id="Prefacio" name="Prefacio"><a href="/es/Creación_de_Componentes_XPCOM/Prefacio" title="es/Creación_de_Componentes_XPCOM/Prefacio">Prefacio</a></h3>
+
+<dl>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Prefacio#Qui.C3.A9n_debe_leer_este_Libro" title="es/Creación_de_Componentes_XPCOM/Prefacio#Qui.C3.A9n_debe_leer_este_Libro">Quién debe leer este libro</a></dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Prefacio#Organizaci.C3.B3n_del_Tutorial" title="es/Creación_de_Componentes_XPCOM/Prefacio#Organizaci.C3.B3n_del_Tutorial">Organización del tutorial</a></dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Prefacio#Continuando_con_los_Ejemplos" title="es/Creación_de_Componentes_XPCOM/Prefacio#Continuando_con_los_Ejemplos">Continuando con los ejemplos</a></dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Prefacio#Convenciones" title="es/Creación_de_Componentes_XPCOM/Prefacio#Convenciones">Convenciones</a></dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Prefacio#Agradecimientos" title="es/Creación_de_Componentes_XPCOM/Prefacio#Agradecimientos">Agradecimientos</a></dd>
+</dl>
+
+<h3 id="Un_vistazo_de_XPCOM" name="Un_vistazo_de_XPCOM"><a href="/es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM" title="es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM">Un vistazo a XPCOM</a></h3>
+
+<dl>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#La_Soluci.C3.B3n_XPCOM" title="es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#La_Soluci.C3.B3n_XPCOM">La Solución XPCOM</a></dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#Gecko" title="es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#Gecko">Gecko</a></dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#Componentes" title="es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#Componentes">Componentes</a></dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#Interfases" title="es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#Interfases">Interfaces</a>
+ <dl>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#Interfaces_y_Encapsulaci.C3.B3n" title="es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#Interfaces_y_Encapsulaci.C3.B3n">Interfaces y encapsulamiento</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#La_Interfaz_Base_nsISupports" title="es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#La_Interfaz_Base_nsISupports">La interfaz base <code>nsISupports</code></a></dd>
+ </dl>
+ </dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#Identificadores_XPCOM" title="es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#Identificadores_XPCOM">Identificadores XPCOM</a>
+ <dl>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#CID" title="es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#CID">CID</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#Contract_ID" title="es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#Contract_ID">Contract ID</a></dd>
+ </dl>
+ </dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#Factor.C3.ADas" title="es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#Factor.C3.ADas">Factorías</a>
+ <dl>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#XPIDL_y_Bibliotecas_de_Tipos" title="es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#XPIDL_y_Bibliotecas_de_Tipos">XPIDL y bibliotecas de tipos</a></dd>
+ </dl>
+ </dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#Servicios_de_XPCOM" title="es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#Servicios_de_XPCOM">Servicios de XPCOM</a></dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#Tipos_de_XPCOM" title="es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#Tipos_de_XPCOM">Tipos de XPCOM</a>
+ <dl>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#Tipos_de_M.C3.A9todos" title="es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#Tipos_de_M.C3.A9todos">Tipos de métodos</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#Cuenta_de_Referencias" title="es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#Cuenta_de_Referencias">Cuenta de referencias</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#C.C3.B3digos_de_Estatus" title="es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#C.C3.B3digos_de_Estatus">Códigos de estatus</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#Correlaciones_Variables" title="es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#Correlaciones_Variables">Correlaciones variables</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#C.C3.B3digos_de_Error_Comunes_de_XPCOM" title="es/Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM#C.C3.B3digos_de_Error_Comunes_de_XPCOM">Códigos de errores comunes de XPCOM</a></dd>
+ </dl>
+ </dd>
+</dl>
+
+<h3 id="Uso_de_Componentes_XPCOM" name="Uso_de_Componentes_XPCOM"><a href="/es/Creación_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM" title="es/Creación_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM">Uso de componentes XPCOM</a></h3>
+
+<dl>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM#Ejemplos_de_Componentes" title="es/Creación_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM#Ejemplos_de_Componentes">Ejemplos de componentes</a>
+
+ <dl>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM#Manejador_de_Cookies" title="es/Creación_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM#Manejador_de_Cookies">Manejador de cookies</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM#El_Componente_WebBrowserFind" title="es/Creación_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM#El_Componente_WebBrowserFind">El componente <strong>WebBrowserFind</strong></a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM#El_Componente_WebLock" title="es/Creación_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM#El_Componente_WebLock">El componente <strong>WebLock</strong></a></dd>
+ </dl>
+ </dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM#Uso_de_Componentes_en_Mozilla" title="es/Creación_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM#Uso_de_Componentes_en_Mozilla">Uso de componentes en Mozilla</a>
+ <dl>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM#Localizar_los_Componentes_de_Mozilla" title="es/Creación_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM#Localizar_los_Componentes_de_Mozilla">Localizar los componentes de Mozilla</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM#Usar_Componentes_XPCOM_en_tu_Cpp" title="es/Creación_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM#Usar_Componentes_XPCOM_en_tu_Cpp">Usar componentes XPCOM en tu CPP</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM#XPConnect:_Usar_Componentes_XPCOM_desde_un_Script" title="es/Creación_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM#XPConnect:_Usar_Componentes_XPCOM_desde_un_Script">XPConnect: Usar componentes XPCOM desde un Script</a></dd>
+ </dl>
+ </dd>
+</dl>
+
+<h3 id="Interior_del_Componente" name="Interior_del_Componente"><a href="/es/Creación_de_Componentes_XPCOM/Interior_del_Componente" title="es/Creación_de_Componentes_XPCOM/Interior_del_Componente">Interior del Componente</a></h3>
+
+<dl>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Interior_del_Componente#Creaci.C3.B3n_de_Componentes_en_C.2B.2B" title="es/Creación_de_Componentes_XPCOM/Interior_del_Componente#Creaci.C3.B3n_de_Componentes_en_C.2B.2B">Creación de componentes en C++</a></dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Interior_del_Componente#Inicializaci.C3.B3n_de_XPCOM" title="es/Creación_de_Componentes_XPCOM/Interior_del_Componente#Inicializaci.C3.B3n_de_XPCOM">Inicio de XPCOM</a>
+ <dl>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Interior_del_Componente#Registro_de_Manifiestos_de_XPCOM" title="es/Creación_de_Componentes_XPCOM/Interior_del_Componente#Registro_de_Manifiestos_de_XPCOM">Registro de manifiestos de XPCOM</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Interior_del_Componente#M.C3.A9todos_de_Registro_en_XPCOM" title="es/Creación_de_Componentes_XPCOM/Interior_del_Componente#M.C3.A9todos_de_Registro_en_XPCOM">Métodos de registro en XPCOM</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Interior_del_Componente#Autoregistro" title="es/Creación_de_Componentes_XPCOM/Interior_del_Componente#Autoregistro">Autoregistro</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Interior_del_Componente#El_Proceso_de_Paro" title="es/Creación_de_Componentes_XPCOM/Interior_del_Componente#El_Proceso_de_Paro">El proceso de paro</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Interior_del_Componente#Tres_Partes_de_una_Biblioteca_de_Componentes_XPCOM" title="es/Creación_de_Componentes_XPCOM/Interior_del_Componente#Tres_Partes_de_una_Biblioteca_de_Componentes_XPCOM">Tres partes de una biblioteca de componentes XPCOM</a></dd>
+ </dl>
+ </dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Interior_del_Componente#XPCOM_Glue" title="es/Creación_de_Componentes_XPCOM/Interior_del_Componente#XPCOM_Glue">XPCOM Glue</a>
+ <dl>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Interior_del_Componente#La_Biblioteca_Glue" title="es/Creación_de_Componentes_XPCOM/Interior_del_Componente#La_Biblioteca_Glue">La biblioteca Glue</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Interior_del_Componente#Clases_de_Cadenas_de_XPCOM" title="es/Creación_de_Componentes_XPCOM/Interior_del_Componente#Clases_de_Cadenas_de_XPCOM">Clases de cadenas de XPCOM</a></dd>
+ </dl>
+ </dd>
+</dl>
+
+<h3 id="Creaci.C3.B3n_de_el_C.C3.B3digo_del_Componente" name="Creaci.C3.B3n_de_el_C.C3.B3digo_del_Componente"><a href="/es/Creación_de_Componentes_XPCOM/Creación_de_el_Código_del_Componente" title="es/Creación_de_Componentes_XPCOM/Creación_de_el_Código_del_Componente">Creación del código del componente</a></h3>
+
+<dl>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Creación_de_el_Código_del_Componente#En_lo_que_Estaremos_Trabajando" title="es/Creación_de_Componentes_XPCOM/Creación_de_el_Código_del_Componente#En_lo_que_Estaremos_Trabajando">En lo que trabajaremos</a></dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Creación_de_el_Código_del_Componente#Registro_de_Componentes" title="es/Creación_de_Componentes_XPCOM/Creación_de_el_Código_del_Componente#Registro_de_Componentes">Registro de componentes</a>
+ <dl>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Creación_de_el_Código_del_Componente#El_Programa_regxpcom" title="es/Creación_de_Componentes_XPCOM/Creación_de_el_Código_del_Componente#El_Programa_regxpcom">El Programa <code>regxpcom</code></a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Creación_de_el_Código_del_Componente#Alternativas_de_Registro" title="es/Creación_de_Componentes_XPCOM/Creación_de_el_Código_del_Componente#Alternativas_de_Registro">Alternativas de registro</a></dd>
+ </dl>
+ </dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Creación_de_el_Código_del_Componente#Vistazo_del_C.C3.B3digo_Fuente_del_M.C3.B3dulo_WebLock" title="es/Creación_de_Componentes_XPCOM/Creación_de_el_Código_del_Componente#Vistazo_del_C.C3.B3digo_Fuente_del_M.C3.B3dulo_WebLock">Vistazo del código fuente del módulo <strong>WebLock</strong></a></dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Creación_de_el_Código_del_Componente#Adentr.C3.A1ndonos:_Includes_y_Constantes_Requeridos" title="es/Creación_de_Componentes_XPCOM/Creación_de_el_Código_del_Componente#Adentr.C3.A1ndonos:_Includes_y_Constantes_Requeridos">Adentrándonos: inclusiones y constantes requeridas</a>
+ <dl>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Creación_de_el_Código_del_Componente#Identificadores_en_XPCOM" title="es/Creación_de_Componentes_XPCOM/Creación_de_el_Código_del_Componente#Identificadores_en_XPCOM">Identificadores en XPCOM</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Creación_de_el_Código_del_Componente#Programando_el_Proceso_de_Registro" title="es/Creación_de_Componentes_XPCOM/Creación_de_el_Código_del_Componente#Programando_el_Proceso_de_Registro">Programando el proceso de registro</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Creación_de_el_Código_del_Componente#Los_M.C3.A9todos_de_Registro" title="es/Creación_de_Componentes_XPCOM/Creación_de_el_Código_del_Componente#Los_M.C3.A9todos_de_Registro">Métodos de Registro</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Creación_de_el_Código_del_Componente#Creaci.C3.B3n_de_una_Instancia_de_tu_Componente" title="es/Creación_de_Componentes_XPCOM/Creación_de_el_Código_del_Componente#Creaci.C3.B3n_de_una_Instancia_de_tu_Componente">Creación de una instancia del componente</a></dd>
+ </dl>
+ </dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Creación_de_el_Código_del_Componente#webLock1.cpp" title="es/Creación_de_Componentes_XPCOM/Creación_de_el_Código_del_Componente#webLock1.cpp"><code>webLock1.cpp</code></a></dd>
+</dl>
+
+<h3 id="Usar_Utilidades_de_XPCOM_para_Hacer_las_Cosas_M.C3.A1s_F.C3.A1ciles" name="Usar_Utilidades_de_XPCOM_para_Hacer_las_Cosas_M.C3.A1s_F.C3.A1ciles"><a href="/es/Creación_de_Componentes_XPCOM/Usar_Utilidades_de_XPCOM_para_Hacer_las_Cosas_Más_Fáciles" title="es/Creación_de_Componentes_XPCOM/Usar_Utilidades_de_XPCOM_para_Hacer_las_Cosas_Más_Fáciles">Usar utilidades de XPCOM para facilitar el proceso</a></h3>
+
+<dl>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Usar_Utilidades_de_XPCOM_para_Hacer_las_Cosas_Más_Fáciles#Macros_XPCOM" title="es/Creación_de_Componentes_XPCOM/Usar_Utilidades_de_XPCOM_para_Hacer_las_Cosas_Más_Fáciles#Macros_XPCOM">Macros XPCOM</a>
+
+ <dl>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Usar_Utilidades_de_XPCOM_para_Hacer_las_Cosas_Más_Fáciles#Macros_de_M.C3.B3dulo_de_XPCOM_gen.C3.A9ricos" title="es/Creación_de_Componentes_XPCOM/Usar_Utilidades_de_XPCOM_para_Hacer_las_Cosas_Más_Fáciles#Macros_de_M.C3.B3dulo_de_XPCOM_gen.C3.A9ricos">Macros de módulos XPCOM genéricos</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Usar_Utilidades_de_XPCOM_para_Hacer_las_Cosas_Más_Fáciles#Macros_Comunes_de_Implementaci.C3.B3n" title="es/Creación_de_Componentes_XPCOM/Usar_Utilidades_de_XPCOM_para_Hacer_las_Cosas_Más_Fáciles#Macros_Comunes_de_Implementaci.C3.B3n">Macros comunes de implementación</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Usar_Utilidades_de_XPCOM_para_Hacer_las_Cosas_Más_Fáciles#Macros_de_Declaraci.C3.B3n" title="es/Creación_de_Componentes_XPCOM/Usar_Utilidades_de_XPCOM_para_Hacer_las_Cosas_Más_Fáciles#Macros_de_Declaraci.C3.B3n">Macros de declaración</a></dd>
+ </dl>
+ </dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Usar_Utilidades_de_XPCOM_para_Hacer_las_Cosas_Más_Fáciles#webLock2.cpp" title="es/Creación_de_Componentes_XPCOM/Usar_Utilidades_de_XPCOM_para_Hacer_las_Cosas_Más_Fáciles#webLock2.cpp"><code>webLock2.cpp</code></a></dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Usar_Utilidades_de_XPCOM_para_Hacer_las_Cosas_Más_Fáciles#Clases_de_Cadenas_en_XPCOM" title="es/Creación_de_Componentes_XPCOM/Usar_Utilidades_de_XPCOM_para_Hacer_las_Cosas_Más_Fáciles#Clases_de_Cadenas_en_XPCOM">Clases de cadenas en XPCOM</a>
+ <dl>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Usar_Utilidades_de_XPCOM_para_Hacer_las_Cosas_Más_Fáciles#Usando_Cadenas" title="es/Creación_de_Componentes_XPCOM/Usar_Utilidades_de_XPCOM_para_Hacer_las_Cosas_Más_Fáciles#Usando_Cadenas">Implementando cadenas</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Usar_Utilidades_de_XPCOM_para_Hacer_las_Cosas_Más_Fáciles#nsEmbedString_y_nsEmbedCString" title="es/Creación_de_Componentes_XPCOM/Usar_Utilidades_de_XPCOM_para_Hacer_las_Cosas_Más_Fáciles#nsEmbedString_y_nsEmbedCString"><code>nsEmbedString</code> y <code>nsEmbedCString</code></a></dd>
+ </dl>
+ </dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Usar_Utilidades_de_XPCOM_para_Hacer_las_Cosas_Más_Fáciles#Punteros_Inteligentes" title="es/Creación_de_Componentes_XPCOM/Usar_Utilidades_de_XPCOM_para_Hacer_las_Cosas_Más_Fáciles#Punteros_Inteligentes">Punteros inteligentes</a></dd>
+</dl>
+
+<h3 id="Iniciando_WebLock" name="Iniciando_WebLock"><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock">Iniciando <strong>WebLock</strong></a></h3>
+
+<dl>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Llamado_al_Arrancar" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Llamado_al_Arrancar">Llamado al arrancar</a>
+
+ <dl>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Registro_para_Notificaciones" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Registro_para_Notificaciones">Registro para notificaciones</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Obtener_Acceso_al_Manejador_de_Categor.C3.ADas" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Obtener_Acceso_al_Manejador_de_Categor.C3.ADas">Obtener acceso al manejador de categorías</a></dd>
+ </dl>
+ </dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#El_Suministro_de_Acceso_a_WebLock" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#El_Suministro_de_Acceso_a_WebLock">Suministro de acceso a <strong>WebLock</strong></a></dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Creaci.C3.B3n_del_WebLock:_Programaci.C3.B3n_de_Interf.C3.A1z" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Creaci.C3.B3n_del_WebLock:_Programaci.C3.B3n_de_Interf.C3.A1z">Crear la interfaz de programación <strong>WebLock</strong></a></dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Definir_la_Interfaz_WebLock_en_XPIDL" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Definir_la_Interfaz_WebLock_en_XPIDL">Definir la interfaz <strong>WebLock</strong> en XPIDL</a>
+ <dl>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#La_Sintaxis_XPIDL" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#La_Sintaxis_XPIDL">Sintaxis XPIDL</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Scriptable_Interfaces" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Scriptable_Interfaces">Interfaces programables</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Subclassing_nsISupports" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Subclassing_nsISupports">Subclasificar <code>nsISupports</code></a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#La_Interfaz_Web_Locking" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#La_Interfaz_Web_Locking">Interfaz Web Locking</a></dd>
+ </dl>
+ </dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Implementaci.C3.B3n_de_WebLock" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Implementaci.C3.B3n_de_WebLock">Implementación de <strong>WebLock</strong></a>
+ <dl>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Macros_de_Declaraci.C3.B3n" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Macros_de_Declaraci.C3.B3n">Macros de Declaración</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Representaci.C3.B3n_de_Valores_Devueltos_en_XPCOM" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Representaci.C3.B3n_de_Valores_Devueltos_en_XPCOM">Representación de Valores Devueltos en XPCOM</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Generaci.C3.B3n_del_C.C3.B3digo_XPIDL" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Generaci.C3.B3n_del_C.C3.B3digo_XPIDL">Generación del Código XPIDL</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Obtenci.C3.B3n_del_Servicio_WebLock_desde_un_Cliente" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Obtenci.C3.B3n_del_Servicio_WebLock_desde_un_Cliente">Obtención del Servicio <strong>WebLock</strong> Service desde un Cliente</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Implementaci.C3.B3n_de_la_Interfaz_iWebLock" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Implementaci.C3.B3n_de_la_Interfaz_iWebLock">Implementación de la Interfaz <code>iWebLock</code></a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#El_Servicio_Directorios" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#El_Servicio_Directorios">El Servicio Directorios</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Modificar_Rutas_con_nsIFile" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Modificar_Rutas_con_nsIFile">Modificar Rutas con <code>nsIFile</code></a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Manipulaci.C3.B3n_de_Archivos_con_nsIFile" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Manipulaci.C3.B3n_de_Archivos_con_nsIFile">Manipulación de Archivos con <code>nsIFile</code></a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Usar_nsILocalFile_para_leer_informaci.C3.B3n" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Usar_nsILocalFile_para_leer_informaci.C3.B3n">Usar <code>nsILocalFile</code> para leer información</a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Processing_the_White_List_Data" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Processing_the_White_List_Data">Processing the White List Data</a></dd>
+ </dl>
+ </dd>
+ <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#iWebLock_m.C3.A9todo_por_m.C3.A9todo" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#iWebLock_m.C3.A9todo_por_m.C3.A9todo"><code>iWebLock</code> método por método</a>
+ <dl>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Lock_y_Unlock" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Lock_y_Unlock"><code>Lock</code> y <code>Unlock</code></a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#AddSite" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#AddSite"><code>AddSite</code></a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#RemoveSite" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#RemoveSite"><code>RemoveSite</code></a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#SetSites" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#SetSites"><code>SetSites</code></a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#GetNext" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#GetNext"><code>GetNext</code></a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#GetSites" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#GetSites"><code>GetSites</code></a></dd>
+  <dd><a href="/es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#HasMoreElements" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#HasMoreElements"><code>HasMoreElements</code></a></dd>
+ </dl>
+ </dd>
+</dl>
+
+<h3 id="Finishing_the_Component" name="Finishing_the_Component"><a href="/es/Creating_XPCOM_Components/Finishing_the_Component" title="es/Creating_XPCOM_Components/Finishing_the_Component">Finishing the Component</a></h3>
+
+<dl>
+ <dd><a href="/es/Creating_XPCOM_Components/Finishing_the_Component#Using_Frozen_Interfaces" title="es/Creating_XPCOM_Components/Finishing_the_Component#Using_Frozen_Interfaces">Using Frozen Interfaces</a>
+
+ <dl>
+  <dd><a href="/es/Creating_XPCOM_Components/Finishing_the_Component#Copying_Interfaces_Into_Your_Build_Environment" title="es/Creating_XPCOM_Components/Finishing_the_Component#Copying_Interfaces_Into_Your_Build_Environment">Copying Interfaces Into Your Build Environment</a></dd>
+  <dd><a href="/es/Creating_XPCOM_Components/Finishing_the_Component#Implementing_the_nsIContentPolicy_Interface" title="es/Creating_XPCOM_Components/Finishing_the_Component#Implementing_the_nsIContentPolicy_Interface">Implementing the <code>nsIContentPolicy</code> Interface</a></dd>
+  <dd><a href="/es/Creating_XPCOM_Components/Finishing_the_Component#Receiving_Notifications" title="es/Creating_XPCOM_Components/Finishing_the_Component#Receiving_Notifications">Receiving Notifications</a></dd>
+ </dl>
+ </dd>
+ <dd><a href="/es/Creating_XPCOM_Components/Finishing_the_Component#Implementing_the_nsIContentPolicy" title="es/Creating_XPCOM_Components/Finishing_the_Component#Implementing_the_nsIContentPolicy">Implementing the <code>nsIContentPolicy</code></a>
+ <dl>
+  <dd><a href="/es/Creating_XPCOM_Components/Finishing_the_Component#Uniform_Resource_Locators" title="es/Creating_XPCOM_Components/Finishing_the_Component#Uniform_Resource_Locators">Uniform Resource Locators</a></dd>
+  <dd><a href="/es/Creating_XPCOM_Components/Finishing_the_Component#Checking_the_White_List" title="es/Creating_XPCOM_Components/Finishing_the_Component#Checking_the_White_List">Checking the White List</a></dd>
+  <dd><a href="/es/Creating_XPCOM_Components/Finishing_the_Component#Creating_nsIURI_Objects" title="es/Creating_XPCOM_Components/Finishing_the_Component#Creating_nsIURI_Objects">Creating <code>nsIURI</code> Objects</a></dd>
+ </dl>
+ </dd>
+</dl>
+
+<h3 id="Building_the_WebLock_UI" name="Building_the_WebLock_UI"><a href="/es/Creating_XPCOM_Components/Building_the_WebLock_UI" title="es/Creating_XPCOM_Components/Building_the_WebLock_UI">Building the <strong>WebLock</strong> UI</a></h3>
+
+<dl>
+ <dd><a href="/es/Creating_XPCOM_Components/Building_the_WebLock_UI#User_Interface_Package_List" title="es/Creating_XPCOM_Components/Building_the_WebLock_UI#User_Interface_Package_List">User Interface Package List</a></dd>
+ <dd><a href="/es/Creating_XPCOM_Components/Building_the_WebLock_UI#Client_Code_Overview" title="es/Creating_XPCOM_Components/Building_the_WebLock_UI#Client_Code_Overview">Client Code Overview</a></dd>
+ <dd><a href="/es/Creating_XPCOM_Components/Building_the_WebLock_UI#XUL" title="es/Creating_XPCOM_Components/Building_the_WebLock_UI#XUL">XUL</a>
+ <dl>
+  <dd><a href="/es/Creating_XPCOM_Components/Building_the_WebLock_UI#The_XUL_Document" title="es/Creating_XPCOM_Components/Building_the_WebLock_UI#The_XUL_Document">The XUL Document</a></dd>
+  <dd><a href="/es/Creating_XPCOM_Components/Building_the_WebLock_UI#The_Locking_UI" title="es/Creating_XPCOM_Components/Building_the_WebLock_UI#The_Locking_UI">The Locking UI</a></dd>
+  <dd><a href="/es/Creating_XPCOM_Components/Building_the_WebLock_UI#Site_Adding_UI" title="es/Creating_XPCOM_Components/Building_the_WebLock_UI#Site_Adding_UI">Site Adding UI</a></dd>
+  <dd><a href="/es/Creating_XPCOM_Components/Building_the_WebLock_UI#weblock.xul" title="es/Creating_XPCOM_Components/Building_the_WebLock_UI#weblock.xul"><code>weblock.xul</code></a></dd>
+ </dl>
+ </dd>
+ <dd><a href="/es/Creating_XPCOM_Components/Building_the_WebLock_UI#Overlaying_New_User_Interface_Into_Mozilla" title="es/Creating_XPCOM_Components/Building_the_WebLock_UI#Overlaying_New_User_Interface_Into_Mozilla">Overlaying New User Interface Into Mozilla</a>
+ <dl>
+  <dd><a href="/es/Creating_XPCOM_Components/Building_the_WebLock_UI#webLockOverlay.xul" title="es/Creating_XPCOM_Components/Building_the_WebLock_UI#webLockOverlay.xul"><code>webLockOverlay.xul</code></a></dd>
+ </dl>
+ </dd>
+ <dd><a href="/es/Creating_XPCOM_Components/Building_the_WebLock_UI#Other_Resources" title="es/Creating_XPCOM_Components/Building_the_WebLock_UI#Other_Resources">Other Resources</a>
+ <dl>
+  <dd><a href="/es/Creating_XPCOM_Components/Building_the_WebLock_UI#weblock.css" title="es/Creating_XPCOM_Components/Building_the_WebLock_UI#weblock.css"><code>weblock.css</code></a></dd>
+  <dd><a href="/es/Creating_XPCOM_Components/Building_the_WebLock_UI#Image_Resources" title="es/Creating_XPCOM_Components/Building_the_WebLock_UI#Image_Resources">Image Resources</a></dd>
+ </dl>
+ </dd>
+</dl>
+
+<h3 id="Packaging_WebLock" name="Packaging_WebLock"><a href="/es/Creating_XPCOM_Components/Packaging_WebLock" title="es/Creating_XPCOM_Components/Packaging_WebLock">Packaging WebLock</a></h3>
+
+<dl>
+ <dd><a href="/es/Creating_XPCOM_Components/Packaging_WebLock#Component_Installation_Overview" title="es/Creating_XPCOM_Components/Packaging_WebLock#Component_Installation_Overview">Component Installation Overview</a></dd>
+ <dd><a href="/es/Creating_XPCOM_Components/Packaging_WebLock#Archiving_Resources" title="es/Creating_XPCOM_Components/Packaging_WebLock#Archiving_Resources">Archiving Resources</a></dd>
+ <dd><a href="/es/Creating_XPCOM_Components/Packaging_WebLock#The_WebLock_Installation_Script" title="es/Creating_XPCOM_Components/Packaging_WebLock#The_WebLock_Installation_Script">The <strong>WebLock</strong> Installation Script</a></dd>
+ <dd><a href="/es/Creating_XPCOM_Components/Packaging_WebLock#The_WebLock_Trigger_Script" title="es/Creating_XPCOM_Components/Packaging_WebLock#The_WebLock_Trigger_Script">The <strong>WebLock</strong> Trigger Script</a></dd>
+ <dd><a href="/es/Creating_XPCOM_Components/Packaging_WebLock#Distributing_Your_Component" title="es/Creating_XPCOM_Components/Packaging_WebLock#Distributing_Your_Component">Distributing Your Component</a></dd>
+</dl>
+
+<h3 id="Appendix_A_-_Setting_up_the_Gecko_SDK" name="Appendix_A_-_Setting_up_the_Gecko_SDK"><a href="/es/Creating_XPCOM_Components/Setting_up_the_Gecko_SDK" title="es/Creating_XPCOM_Components/Setting_up_the_Gecko_SDK">Appendix A - Setting up the Gecko SDK</a></h3>
+
+<dl>
+ <dd><a href="/es/Creating_XPCOM_Components/Setting_up_the_Gecko_SDK#Downloading_and_Setting_the_SDK" title="es/Creating_XPCOM_Components/Setting_up_the_Gecko_SDK#Downloading_and_Setting_the_SDK">Downloading and Setting the SDK</a></dd>
+ <dd><a href="/es/Creating_XPCOM_Components/Setting_up_the_Gecko_SDK#Building_a_Microsoft_Visual_Cpp_Project" title="es/Creating_XPCOM_Components/Setting_up_the_Gecko_SDK#Building_a_Microsoft_Visual_Cpp_Project">Building a Microsoft Visual Cpp Project</a>
+ <dl>
+  <dd><a href="/es/Creating_XPCOM_Components/Setting_up_the_Gecko_SDK#Creating_a_New_Project" title="es/Creating_XPCOM_Components/Setting_up_the_Gecko_SDK#Creating_a_New_Project">Creating a New Project</a></dd>
+  <dd><a href="/es/Creating_XPCOM_Components/Setting_up_the_Gecko_SDK#Adding_the_Gecko_SDK_to_the_Project_Settings" title="es/Creating_XPCOM_Components/Setting_up_the_Gecko_SDK#Adding_the_Gecko_SDK_to_the_Project_Settings">Adding the Gecko SDK to the Project Settings</a></dd>
+ </dl>
+ </dd>
+ <dd><a href="/es/Creating_XPCOM_Components/Setting_up_the_Gecko_SDK#A_Makefile_for_Unix" title="es/Creating_XPCOM_Components/Setting_up_the_Gecko_SDK#A_Makefile_for_Unix">A Makefile for Unix</a></dd>
+</dl>
+
+<h3 id="Appendix_B_-_Resources" name="Appendix_B_-_Resources"><a href="/es/Creating_XPCOM_Components/Resources" title="es/Creating_XPCOM_Components/Resources">Appendix B - Resources</a></h3>
+
+<dl>
+ <dd><a href="/es/Creating_XPCOM_Components/Resources#WebLock_Resources" title="es/Creating_XPCOM_Components/Resources#WebLock_Resources">WebLock Resources</a></dd>
+ <dd><a href="/es/Creating_XPCOM_Components/Resources#Gecko_Resources" title="es/Creating_XPCOM_Components/Resources#Gecko_Resources">Gecko Resources</a></dd>
+ <dd><a href="/es/Creating_XPCOM_Components/Resources#XPCOM_Resources" title="es/Creating_XPCOM_Components/Resources#XPCOM_Resources">XPCOM Resources</a></dd>
+ <dd><a href="/es/Creating_XPCOM_Components/Resources#General_Development_Resources" title="es/Creating_XPCOM_Components/Resources#General_Development_Resources">General Development Resources</a></dd>
+</dl>
+
+<p></p><div class="prevnext" style="text-align: right;">
+    <p><a href="/es/docs/Creating_XPCOM_Components:Preface">Siguiente  »</a></p>
+</div><p></p>
+
+<div class="licenseblock">
+<p>Copyright (c) 2003 by Doug Turner and Ian Oeschger. This material may be distributed only subject to the terms and conditions set forth in the <a class="external" href="http://www.opencontent.org/openpub/" rel="noopener">Open Publication License</a>, v1.02 or later. Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder. Distribution of the work or derivative of the work in any standard (paper) book form is prohibited unless prior permission is obtained from the copyright holder.</p>
+</div>
diff --git a/files/es/creación_de_componentes_xpcom/interior_del_componente/index.html b/files/es/creación_de_componentes_xpcom/interior_del_componente/index.html
new file mode 100644
index 0000000000..e69797653b
--- /dev/null
+++ b/files/es/creación_de_componentes_xpcom/interior_del_componente/index.html
@@ -0,0 +1,216 @@
+---
+title: Interior del Componente
+slug: Creación_de_Componentes_XPCOM/Interior_del_Componente
+tags:
+  - Todas_las_Categorías
+  - XPCOM
+---
+<p></p><div class="prevnext" style="text-align: right;">
+    <p><a href="/es/docs/Creación_de_Componentes_XPCOM:Using_XPCOM_Components" style="float: left;">« Anterior</a><a href="/es/docs/Creación_de_Componentes_XPCOM:Creating_the_Component_Code">Siguiente  »</a></p>
+</div> En el capítulo anterior describimos los componentes desde una perspectiva de un cliente de los componentes XPCOM, en este capútulo abordamos los componentes desde la perspectiva del desarrollador del programa. Léelo para ver como se implementan generalmente los componentes en XPCOM, o puedes brincarte al siguiente capítulo, donde el tutorial del componente WebLock te lleva paso a paso através del proceso de creación del componente. <span class="comment">XXX mediawiki...</span><span class="comment">XXX sucks</span><p></p>
+
+<h3 id="Creaci.C3.B3n_de_Componentes_en_C.2B.2B" name="Creaci.C3.B3n_de_Componentes_en_C.2B.2B">Creación de Componentes en C++</h3>
+
+<p>Empecemos por examinar como se escriben en C++ los componentes XPCOM. El tipo más común de componente es el escrito en C++ y compilado en una biblioteca compartida (una <abbr title="Dynamic Link Library">DLL</abbr> en un sistema Windows o una <abbr title="Dynamic Shared Object">DSO</abbr> en Unix).</p>
+
+<p>La imagen de abajo muestra la relación básica entre una biblioteca que contiene la implementación del código del componente que escribiste y la plataforma XPCOM en sí misma. En este diagrama, la superficie más externa del módulo es la biblioteca compartida en la que se define un componente.</p>
+
+<p><span id="Un_Componente_en_la_Plataforma_XPCOM"><a id="Un_Componente_en_la_Plataforma_XPCOM"></a><strong>Un Componente en la Plataforma XPCOM</strong></span></p>
+
+<p><img alt="Image:component-internals-framework.png"></p>
+
+<p>Cuando construyes un componente o un módulo y lo compilas dentro de una biblioteca, debe exportar un método llamado <code>NSGetModule</code>. Esta función <code>NSGetModule</code> es el punto de acceso a la biblioteca. Es llamado durante el registro y el desregistro del componente y cuando XPCOM quiere descubrir qué interfaces o clases implementa el módulo/biblioteca. En este capítulo abordaremos todo este proceso.</p>
+
+<p>Como ilustra <a href="#Un_Componente_en_la_Plataforma_XPCOM">Un Componente en la Plataforma XPCOM</a>, además del punto de acceso <code>NSGetModule</code>, están las interfaces <code>nsIModule</code> y <code>nsIFactory</code> que controlan la creación actual del componente y también las partes XPCOM glue y cadenas, que discutiremos un poco a detalle en la siguiente sección (Ve <a href="es/Creaci%c3%b3n_de_Componentes_XPCOM/Interior_del_Componente#XPCOM_Glue">XPCOM Glue</a>). Estas nos darán utilidades para desarrollo fácil más adelante como son punteros inteligentes, soporte de módulos genéricos e implementaciones simples de cadenas. La parte más larga y posiblemente la más compleja de un componente es el código específico del componente en sí mismo.</p>
+
+<div class="side-note">
+<p><span id="%C2%BFPero_D%C3%B3nde_Est%C3%A1n_los_Componentes?"><a id="%C2%BFPero_D%C3%B3nde_Est%C3%A1n_los_Componentes?"></a><strong>¿Pero Dónde Están los Componentes?</strong></span></p>
+
+<p>Los componentes residen en módulos y esos módulos son definidos en bibliotecas compartidas típicamente situadas en el directorio<em>components</em> de una aplicación XPCOM.</p>
+
+<p>Un conjunto de bibliotecas son almacenadas por defecto en este directorio components es lo que hay en una típica instalación de Gecko, dando la funcionalidad que consiste en trabajo en red, layout, composición, una interfaz de usuario multiplataforma y otros.</p>
+
+<p>Otra vista aún más básica de esta relación de componentes a archivos e interfaces que los definen se muestra en <a href="es/Creaci%c3%b3n_de_Componentes_XPCOM/Creaci%c3%b3n_del_C%c3%b3digo_del_Componente">Vista de Papel Cebolla de la creación del Componente XPCOM</a> en el próximo capítulo. El componente es una abstracción situada entre el módulo actual en el que se implementa y los objetos que el código de su factoría crea para que uso de los clientes.</p>
+</div>
+
+<h3 id="Inicializaci.C3.B3n_de_XPCOM" name="Inicializaci.C3.B3n_de_XPCOM">Inicialización de XPCOM</h3>
+
+<p>Para entender porqué y cuándo tu biblioteca de componentes es llamada, es importante entender el proceso de inicialización de XPCOM. Cuando inicia una aplicación, la aplicación puede<em>inicializar</em> XPCOM. La secuencia de eventos que lanza esta inicialización de XPCOM pueden ser lanzados por una ccioón del usuario o por el inicio de la aplicación en sí misma. Un buscador web que tiene embebido Gecko, por ejemplo, puede inicializar XPCOM al inicio atravéz de APIs embebidas. Otra aplicación puede este inicio hasta que XPCOM se necesite por primera vez. En otro caso, la secuencia de inicialización dentro de XPCOM es la misma.</p>
+
+<p>XPCOM inicia cuando la aplicación hace una llamada para inicializarlo. Los parámetros pasados a esta llamada de inicialización te permiten configurar algunos aspectos de XPCOM, incluyendo la personalización de la ubicación de directorios específicos. El propósito principal del API en este punto es cambiar que directorio<em>components</em> inspecciona cuando busca componentes XPCOM. Así es como se usa el API, por ejemplo, en el<em>Gecko Runtime Environment</em> (GRE).</p>
+
+<div class="side-note">
+<p><span id="Inicializaci%C3%B3n_de_XPCOM"><a id="Inicializaci%C3%B3n_de_XPCOM"></a><strong>Inicialización de XPCOM</strong></span></p>
+
+<p>Los seis pasos básicos para arrancar XPCOM son los siguientes:</p>
+
+<ol>
+ <li>La aplicación inicia XPCOM.</li>
+ <li>XPCOM envía una notificación que inicia el arranque.</li>
+ <li>XPCOM encuentra y procesa el<em>manifiesto del componente</em> (ve <a href="#Manifiestos_de_Componentes">Manifiestos de Componentes</a> abajo).</li>
+ <li>Si hay nuevos componentes, XPCOM los registra:
+  <ol>
+   <li>XPCOM llama el arranque del autoregistro.</li>
+   <li>XPCOM registra los nuevos componentes.</li>
+   <li>XPCOM llama el fin del autoregistro.</li>
+  </ol>
+ </li>
+ <li>Arranque completo de XPCOM: XPCOM notifica que ha iniciado.</li>
+</ol>
+
+<p>Los manifiestos de Componentes y bibliotecas de tipos son descritos en la siguiente sección, <a href="#Registro_de_Manifiestos_de_XPCOM">Registro de Manifiestos de XPCOM</a>.</p>
+</div>
+
+<h4 id="Registro_de_Manifiestos_de_XPCOM" name="Registro_de_Manifiestos_de_XPCOM">Registro de Manifiestos de XPCOM</h4>
+
+<p>XPCOM usa archivos especiales llamados manifiestos para cambiar y guardar información acerca de los componentes en el sistema local. Hay dos tipos de manifiestos que usa XPCOM para cambiar componentes:</p>
+
+<h5 id="Manifiestos_de_Componente" name="Manifiestos_de_Componente">Manifiestos de Componente</h5>
+
+<p>Cuando XPCOM inicia por primera vez, busca el<em>manifiesto de componentes</em> que es un archivo que lista todos los componentes registrados y guarda detalles de lo que exactamente puede hacer cada componente. XPCOM usa el manifiesto de componentes para determinar que componentes han sido sobreescritos. Empezando en Mozilla 1.2, este archivo es llamado <code>compreg.dat</code> y existe en el directorio<em>components</em>, pero hay esfuerzos por moverlo fuera de esta ubicación a una ubicación menos centrada en la aplicación y más centrada en el usuario. Cualquier aplicación bassada en Gecko puede escoger ponerlo en otro lado. XPCOM lee este archivo dentro de una base de datos en memoria.</p>
+
+<div class="side-note">
+<p><span id="Manifiestos_de_Componentes"><a id="Manifiestos_de_Componentes"></a><strong>Manifiestos de Componentes</strong></span></p>
+
+<p>El manifiesto de componente es una correlación de archivos a componentes y de componentes a clases. Especifica la siguiente información:</p>
+
+<ul>
+ <li>Ubicación en disco de los componentes registrados con el tamaño de archivo</li>
+ <li>ID de Clase relacionado a la Ubicación.</li>
+ <li>Contract ID relacionado al ID de Clase.</li>
+</ul>
+
+<p>El manifiesto del componente relaciona archivos de componentes a identificadores únicos para las implementaciones específicas (IDs de Clase), que en su momento son relacionados a identificadores de componente más generales (contract IDs).</p>
+</div>
+
+<h5 id="Manifiestos_de_Bibliotecas_de_Tipos" name="Manifiestos_de_Bibliotecas_de_Tipos">Manifiestos de Bibliotecas de Tipos</h5>
+
+<p>Otro archivo importante que lee XPCOM es el<em>manifiesto de bibliotecas de tipos</em>. Este archivo tambien se localiza en el directorio<em>components</em> y se llama <code>xpti.dat</code>. Incluye la ubicación y direcciones de búsqueda de todas las bibliotecas de tipos en el sistema. este archivo también lista todas las interfaces conocidas y enlaces a los archivos de bibliotecas de tipos que definen estas estructuras de interfaces. Estos archivos de bibliotecas de tipos son el core para que XPCOM pueda ser script y de la arquitectura de componentes binarios de XPCOM.</p>
+
+<div class="side-note">
+<p><span id="Manifiestos_de_Bibliotecas_de_Tipos"><a id="Manifiestos_de_Bibliotecas_de_Tipos"></a><strong>Manifiestos de Bibliotecas de Tipos</strong></span> Los manifiestos de bibliotecas de tipos contienen la siguiente información:</p>
+
+<ul>
+ <li>ubicación de todos los archivos de bibliotecas de tipos</li>
+ <li>correlación de todas las interfaces conocidas y bibliotecas de tipos donde están definidas estas estructuras.</li>
+</ul>
+</div>
+
+<p>Using the data in these two manifests, XPCOM knows exactly which component libraries have been installed and what implementations go with which interfaces. Additionally, it relates the components to the type libraries in which the binary representations of the interfaces they support are defined.</p>
+
+<p>The next section describes how to hook into the XPCOM startup and registration process and make the data about your component available in these manifests, so that your component will be found and registered at startup.</p>
+
+<h4 id="M.C3.A9todos_de_Registro_en_XPCOM" name="M.C3.A9todos_de_Registro_en_XPCOM">Métodos de Registro en XPCOM</h4>
+
+<div class="side-note">
+<p><span id="What_Is_XPCOM_Registration?"><a id="What_Is_XPCOM_Registration?"></a><strong>What Is XPCOM Registration?</strong></span></p>
+
+<p>In a nutshell, registration is the process that makes XPCOM aware of your component(s). As this section and the next describe, you can register your component explicitly during installation, or with the <code>regxpcom</code> program, or you can use the autoregistration methods in the Service Manager to find and register components in a specified components directory:</p>
+
+<ul>
+ <li>XPInstall APIs</li>
+ <li><code>regxpcom</code> command-line tool</li>
+ <li><code>nsIComponentRegistrar</code> APIs from Service Manager</li>
+</ul>
+
+<p>The registration process is fairly involved. This section introduces it in terms of XPCOM initialization, and the next chapter describes what you have to do in your component code to register your component with XPCOM.</p>
+</div>
+
+<p>Once the manifest files are read in, XPCOM checks to see if there are any components that need to be registered. There are two supported ways to go about registering your XPCOM component. The first is to use<em>XPInstall</em>, which is an installation technology that may or may not come with a Gecko application and provides interfaces for registering your component during installation. Another, more explicit way to register your component is to run the application <code>regxpcom</code>, which is built as part of Mozilla and is also available in the Gecko SDK. <code>regxpcom</code> registers your component in the default component registry.</p>
+
+<p>A Gecko embedding application may also provide its own way of registering XPCOM components using the interface that is in fact used by both XPInstall and <code>regxpcom</code>, <code>nsIComponentRegistrar</code>. An application, for example, could provide a "registration-less" component directory whose components are automatically registered at startup and unregistered at shutdown. Component discovery does not currently happen automatically in non-debug builds of Gecko, however.</p>
+
+<p>When the registration process begins, XPCOM broadcasts to all registered observers a notification that says XPCOM has begun the registration of new components. After all components are registered, another notification is fired saying that XPCOM is done with the registration step. The <code>nsIObserver</code> interface that handles this notification is discussed in <a href="es/Creating_XPCOM_Components/Starting_WebLock">Starting WebLock</a>.</p>
+
+<p>Once registration is complete and the notifications have fired, XPCOM is ready to be used by the application. If XPCOM registered your component, then it will be available to other parts of the XPCOM system. The <a href="#XPCOM_Initialization">XPCOM Initialization</a> section in this chapter describes registration in more detail.</p>
+
+<h4 id="Autoregistro" name="Autoregistro">Autoregistro</h4>
+
+<p>The term<em>autoregistration</em> is sometimes used synonymously with registration in XPCOM. In the <a href="#What_Is_XPCOM_Registration?">What Is XPCOM Registration?</a> note, we describe the three ways you can register components with XPCOM. Sometimes, applications use the <code>nsIComponentRegistrar</code> interface and create their own code for watching a particular directory and registering new components that are added there, which is what's often referred to as<em>autoregistration</em>. You should always know what the installation and registration requirements are for the applications that will be using your component.</p>
+
+<h4 id="El_Proceso_de_Paro" name="El_Proceso_de_Paro">El Proceso de Paro</h4>
+
+<p>When the application is ready to shutdown XPCOM, it calls <code>NS_ShutdownXPCOM</code>. When that method is called, the following sequence of events occurs:</p>
+
+<ol>
+ <li>XPCOM fires a shutdown notification to all registered observers.</li>
+ <li>XPCOM closes down the Component Manager, the Service Manager and associated services.</li>
+ <li>XPCOM frees all global services.</li>
+ <li>NS_ShutdownXPCOM returns and the application may exit normally.</li>
+</ol>
+
+<div class="side-note">
+<p><span id="The_Unstoppable_Shutdown"><a id="The_Unstoppable_Shutdown"></a><strong>The Unstoppable Shutdown</strong></span></p>
+
+<p>Note that shutdown observation is unstoppable. In other words, the event you observe cannot be used to implement something like a "Are you sure you want to Quit?" dialog. Rather, the shutdown event gives the component or embedding application a last chance to clean up any leftovers before they are released. In order to support something like an "Are you sure you want to quit" dialog, the application needs to provide a higher-level event (e.g., <code>startShutdown()</code>) which allows for cancellation.</p>
+
+<p>Note also that XPCOM services may deny you access once you have received the shutdown notification. It is possible that XPCOM will return an error if you access the <code>nsIServiceManager</code> at that point, for example, so you may have to keep a reference-counted pointer to the service you are interested in using during this notification.</p>
+</div>
+
+<h4 id="Component_Loaders" name="Component_Loaders">Component Loaders</h4>
+
+<p>Components can be written in many languages. So far this book has been focusing on "native components," shared libraries exporting a <code>NSGetModule</code> symbol. But if there is a<em>component loader</em> for Javascript installed, then you can also write a JavaScript component.</p>
+
+<p>To register, unregister, load and manage various component types, XPCOM abstracts the interface between the XPCOM component and XPCOM with the Component Loader. This loader is responsible for initialization, loading, unloading, and supporting the <code>nsIModule</code> interface on behalf of each component. It is the Component Loader's responsibility to provide scriptable component support.</p>
+
+<p>When building a "native" component, the component loader looks for an exported symbol from the components shared library. "Native" here includes any language that can generate a platform native dynamically loaded library. Scripting languages and other "non-native" languages usually have no way to build native libraries. In order to have "non-native" XPCOM components work, XPCOM must have a special component loader which knows how to deal with these type of components.</p>
+
+<p>XPConnect, for example, provides a component loader that makes the various types, including the interfaces and their parameters, available to JavaScript. Each language supported by XPCOM must have a component loader.</p>
+
+<h4 id="Tres_Partes_de_una_Biblioteca_de_Componentes_XPCOM" name="Tres_Partes_de_una_Biblioteca_de_Componentes_XPCOM">Tres Partes de una Biblioteca de Componentes XPCOM</h4>
+
+<p>XPCOM is like an onion<span class="comment">or a parfait! Everybody likes parfaits</span>. XPCOM components have at least three layers. From the innermost and moving outward these layers include:</p>
+
+<ul>
+ <li>The core XPCOM object</li>
+ <li>The factory code</li>
+ <li>The module code</li>
+</ul>
+
+<p>The core XPCOM object is the object that will implement the functionality you need. For example, this is the object that may start a network download and implement interfaces that will listen to the progress. Or the object may provide a new content type handler. Whatever it does, this object is at the core of the XPCOM component, and the other layers are supporting it, plugging it into the XPCOM system. A single library may have many of these core objects.</p>
+
+<p>One layer above the core object is the factory code. The factory object provides a basic abstraction of the core XPCOM object. <a href="es/Creating_XPCOM_Components/An_Overview_of_XPCOM">An Overview of XPCOM</a> discussed the factory design pattern that's used in a factory object. At this layer of the XPCOM Component Library, the factory objects are factories for the core XPCOM objects of the layer below.</p>
+
+<p>One more layer outward is the module code. The module interface provides yet another abstraction - this time of the factories - and allows for multiple factory objects. From the outside of the component library, there is only the single entry point, <code>NSGetModule()</code>. This point of entry may fan out to any number of factories, and from there, to any number of XPCOM objects.</p>
+
+<p>The following chapter details these layers in terms of the XPCOM interfaces that represent them. Here we will just introduce them. The factory design pattern in XPCOM is represented by the <code>nsIFactory</code> interface. The module layer is represented by the <code>nsIModule</code> interface. Most component libraries only need these two interfaces, along with the <code>nsISupports</code> interface, to have XPCOM load, recognize, and use their core object code.</p>
+
+<p>In the next section, we'll be writing the code that actually compiles into a component library, and you will see how each layer is implemented and how each interface is used. Following this initial, verbose demonstration of the APIs, we will introduce a faster more generic way of implementing the module and factory code using macros, which can make components much easier to create.</p>
+
+<h3 id="XPCOM_Glue" name="XPCOM_Glue">XPCOM Glue</h3>
+
+<p>XPCOM contains a lot of stuff. Most of the XPCOM interfaces are not frozen and are meant to be used only by the Gecko internals, not by clients. XPCOM provides many data structures from linked lists to <a class="external" href="http://en.wikipedia.org/wiki/AVL_tree">AVL trees</a>. Instead of writing your own linked list, it's tempting to reuse <code>nsVoidArray</code> or another publicly available class, but this might be a fatal mistake. At any time the class can change and give you unexpected behavior.</p>
+
+<p>XPCOM makes for a very open environment. At runtime you can acquire any service or component merely by knowing a CID, or Contract ID, and an IID. At last count there were over 1300 interfaces defined in XPIDL. Of those 1300 interfaces, less than 100 were frozen, which means that a developer has a good chance of stumbling upon useful interfaces that aren't frozen. If an interface isn't explicitly marked "FROZEN" in the IDL comments, however - and most of them aren't - it will cause your component to possibly break or crash when the version changes.</p>
+
+<h4 id="La_Biblioteca_Glue" name="La_Biblioteca_Glue">La Biblioteca Glue</h4>
+
+<p>In general you should avoid any unfrozen interfaces, any symbols in XPCOM, or any other part of Gecko libraries that aren't frozen. However, there are some unfrozen tools in XPCOM that are used so often they are practically required parts of component programming.</p>
+
+<p>The smart pointer class, <code>nsCOMPtr</code>, for example, which can make reference counting a lot less tedious and error-prone, is not actually frozen, and neither are <code>nsDebug</code>, a class for aiding in tracking down bugs, or <code>nsMemory</code>, a class to ensure that everyone uses the same heap, generic factory, and module. Instead of asking every developer to find and copy these various files into their own application, XPCOM provides a single library of "not-ready-to-freeze-but-really-helpful" classes that you can link into your application, as the following figure demonstrates.</p>
+
+<p><span id="XPCOM_Glue_and_Tools"><a id="XPCOM_Glue_and_Tools"></a><strong>XPCOM Glue and Tools</strong></span></p>
+
+<p><img alt="Image:xpcom-glue-tools.png"></p>
+
+<p>This is the glue library. It provides a bridge, or "glue" layer, between your component and XPCOM.</p>
+
+<p>A version of the glue library is built into XPCOM, and when your component uses it, it links a snapshot of this library: it includes a copy of these unfrozen classes directly, which allows the XPCOM library version to change without affecting the software. There is a slight footprint penalty to linking directly, but this gives your component freedom to work in any recent environment. If footprint is a big issue in your component or application, you can trim out the pieces you don't need.</p>
+
+<h4 id="Clases_de_Cadenas_de_XPCOM" name="Clases_de_Cadenas_de_XPCOM">Clases de Cadenas de XPCOM</h4>
+
+<p>The base string types that XPCOM uses are <code>nsAString</code> and <code>nsACString</code>. These classes are described in the Mozilla String Guide (see <a href="es/Creating_XPCOM_Components/Resources#Gecko_Resources">Gecko Resources</a>).</p>
+
+<p>The string classes that implement these abstract classes are another set of helpful, unfrozen classes in XPCOM. Most components and embedding applications need to link to some kind of string classes in order to utilize certain Gecko APIs, but the string code that Mozilla uses is highly complex and even more expensive than the glue code in terms of footprint (~100k). <code>nsEmbedString</code> and <code>nsEmbedCString</code> are available as very light string class implementations for component development, especially in small embedded applications. This string implementation does the bare minimum to support <code>nsAString</code>/<code>nsACString</code> string classes.</p>
+
+<p>In your own component, you can go "slim" and restrict yourself to the <code>nsEmbedString</code> or go "hog wild" and use all of the functionality of the other strings. WebLock restricts itself to using the simple <code>nsEmbedString</code> family of classes.</p>
+
+<p><span id="String_Classes_and_XPCOM"><a id="String_Classes_and_XPCOM"></a><strong>String Classes and XPCOM</strong></span></p>
+
+<p><img alt="Image:strings-in-xpcom.png"></p>
+
+<p>The glue library provides stub functions for the public functions that XPCOM provides (see <code><a href="https://dxr.mozilla.org/mozilla-central/source/xpcom/build/nsXPCOM.h" rel="custom">xpcom/build/nsXPCOM.h</a></code>). When the glue library is initialized, it dynamically loads these symbols from the XPCOM library, which allows the component to avoid linking directly with the XPCOM library. You shouldn't have to link to the XPCOM library to create a XPCOM component - in fact, if your component has to, then something is wrong. </p><div class="prevnext" style="text-align: right;">
+    <p><a href="/es/docs/Creating_XPCOM_Components:Using_XPCOM_Components" style="float: left;">« Anterior</a><a href="/es/docs/Creating_XPCOM_Components:Creating_the_Component_Code">Siguiente  »</a></p>
+</div> <p></p><div class="licenseblock">
+<p>Copyright (c) 2003 by Doug Turner and Ian Oeschger. This material may be distributed only subject to the terms and conditions set forth in the <a class="external" href="http://www.opencontent.org/openpub/" rel="noopener">Open Publication License</a>, v1.02 or later. Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder. Distribution of the work or derivative of the work in any standard (paper) book form is prohibited unless prior permission is obtained from the copyright holder.</p>
+</div><p></p>
diff --git a/files/es/creación_de_componentes_xpcom/prefacio/index.html b/files/es/creación_de_componentes_xpcom/prefacio/index.html
new file mode 100644
index 0000000000..5ba98982da
--- /dev/null
+++ b/files/es/creación_de_componentes_xpcom/prefacio/index.html
@@ -0,0 +1,39 @@
+---
+title: Prefacio
+slug: Creación_de_Componentes_XPCOM/Prefacio
+---
+<p>Este es un libro acerca de Gecko, y cómo crear componentes <a href="es/XPCOM">XPCOM</a> para aplicaciones basadas en Gecko. Aunque se hace énfasis en los pasos prácticos que sigues para que hagas tu código C++ dentro de un componente que pueda ser usado en Gecko, esperamos que esos pasos nos den también la ocasión de abordar todas las herramientas, técnicas y tecnologías que integran XPCOM. En consecuencia, este libro es arreglado de tal forma que puedes seguirlo y crear tus propios componentes o aprender distintos tópicos de XPCOM individualmente, como en una guía de referencia. Por ejemplo, la introducción incluye una discusión acerca de lo que son los componentes; y el primer capítulo - en el cual tu compilas un código básico y lo registras en Mozilla - apunta una discusión de la relación entre componentes y módulos de las interfases de XPCOM y del proceso de registro en general.
+</p><p>El principio de cada capítulo provee una lista de los tópicos más importantes tratados. Las secciones en la barra de al lado son incluidas para resaltar detalles técnicos. Al terminar el libro, si hemos hecho nuestro trabajo, habrás aprendido como construir componentes y sabrás algo acerca del framework para esos componentes en Gecko, que es XPCOM.
+</p>
+<h3 id="Quién_debe_leer_este_Libro"> Quién debe leer este Libro </h3>
+<p><a href="es/Creaci%c3%b3n_de_Componentes_XPCOM">Creación de Componentes XPCOM</a> está dirigido a desarrolladores C++. Aunque puedes crear componentes XPCOM en <a href="es/Javascript">Javascript</a> y otros lenguajes y aunque tal vez puedas seguir el libro como programador <a href="es/C">C</a>, el código de implementación está escrito en C++ y mucha de la discusión de cómo hacer tu código <i>dentro</i> de un componente XPCOM empieza desde C++. De cualquier modo no necesitas ser un experto en C++, aunque debes estar familiarizado con ideas básicas como herencia y encapsulación, ideas que cuando es posible son explicadas en el libro donde son usadas. También muchos de los ejemplos son en Javascript, que es usado en Mozilla para accesar componentes XPCOM como objetos script, así que estar familiarizado con ese lenguaje es útil también.
+</p><p>XPCOM significa Cross Platform Component Object Model(Modelo Componente Objeto Multiplataforma), como su nombre lo implica, XPCOM es similar al Microsoft COM, si tienes alguna experiencia con esta tecnología, grán parte de eso puede aplicarse a XPCOM. De cualquier modo este libro no asume ningún conocimiento previo de COM - todas las ideas básicas de COM serán introducidas.
+</p><p>Este libro provee un tutorial de cómo construir un componente XPCOM que controle el comportamiento de búsqueda; aunque XPCOM puede ser usado en muchos ambientes relacionados con búsqueda web, su principal cliente es Gecko, un buscador web embebido de código abierto, que cumple con estándares, donde es más fácil y práctico ilustrar la funcionalidad de XPCOM. Una descripción completa del componente de este turial puede ser encontrada en la sección <a href="es/Creaci%c3%b3n_de_Componentes_XPCOM/Creaci%c3%b3n_de_el_C%c3%b3digo_del_Componente#En_lo_que_Estaremos_Trabajando">En lo que Estaremos Trabajando</a> de este tutorial.
+</p>
+<div class="note">
+<p>A pesar de lo que dice la documentación, XPCOM no debe ser usado para hacer <a href="es/Plugins">NPAPI plugins</a> script. A partir de la versión 1.7.5 de Gecko(Firefox 1.0) una extensión especial NPAPI para llamar desde script es soportada vea <a href="es/Gecko_Plugin_API_Reference/Scripting_plugins">Scripting plugins</a>.
+</p>
+</div>
+<h3 id="Organización_del_Tutorial"> Organización del Tutorial </h3>
+<p>La siguiente lista da una reseña de de los pasos que seguiremos para crear un componente XPCOM llamado <i>Weblock</i>, el cual provee la funcionalidad de bloqueo de sitios a los buscadores basados en Gecko. Cada uno de estos pasos tiene su propio capitulo, en el que se discuten varios tópicos asociados al paso.
+</p>
+<ul><li> Crear el módulo genérico de módulo para el componente.
+</li><li> Usar macros C++, clases especiales de cadenas y punteros inteligentes para optimizar el código.
+</li><li> Definir la funcionalidad del componente; crear una interfaz <a href="es/XPIDL">XPIDL</a> para esa funcionalidad, crear el código específico para la implementación adaptada de la interfaz del componente <i>Weblock</i>.
+</li><li> Finalizar la implementación del componente <i>Weblock</i>: <code>nsIContentPolicy</code>, E/S de archivos, bloqueo, etc.
+</li><li> Creación de la interfaz de usuario del componente <i>Weblock</i>.
+</li><li> Empaquetar <i>Weblock</i> para su distribución e instalación.
+</li></ul>
+<h3 id="Continuando_con_los_Ejemplos"> Continuando con los Ejemplos </h3>
+<p>Hay dos formas diferentes de tener XPCOM en tu máquina para poder crear componentes. Si ya tienes un Mozilla construído o el código fuente de Mozilla 1.2 o posterior, entonces puedes usar la plataforma XPCOM disponible ahí. Si no tienes las fuentes de Mozilla, entonces puedes bajar el Gecko SDK, que es una colección de librerías y herramientas que componen la plataforma de componentes XPCOM.
+</p><p>No importa si compilas tu código en el directorio de las fuentes de Mozilla o usas el Gecko SDK, puedes construir tus propios componentes que usen los componentes previamente existentes en Gecko. el componente <b>Weblock</b> que describimos en este tutorial es un complemento práctico(y esperamos genuinamente útil) para el navegador. Para poder construirlo, tu Gecko SDK o tus fuentes de Mozilla deben ser versión 1.2 o superior (las interfaces XPCOM en versiones anteriores no fueron completamente congeladas).
+</p><p>Este Libro asume que estas usando el SDK en vez del directorio de las fuentes de Mozilla, de cualquier forma la diferencia entre ambos es mínima. Detalles acerca de cómo obtener el SDK, construir y obtener acceso programático a los componetes de Gecko se dan en el APENDICE del libro, <a href="es/Creaci%c3%b3n_de_Componentes_XPCOM/Configurar_el_Gecko_SDK">Configurar el Gecko SDK</a>.
+</p>
+<h3 id="Convenciones"> Convenciones </h3>
+<p>Las convenciones de formato listadas abajo se usan para designar tipos específicos de información en el libro y hacer las cosas más fáciles de encontrar. El objetivo es usar tan pocos formatos como sea posible, pero distinguir los diferentes tipos de información claramente.
+</p>
+<table class="standard-table"> <tbody><tr> <td class="header">Formato</td> <td class="header">Descripción</td> </tr> <tr> <td><b>bold</b></td> <td><b>nombres de componentes</b> aparecen en negro en el texto</td> </tr> <tr> <td><code>monospace</code></td> <td><code>referencias al código</code>, <code>nombres de interfaces</code> y <code>miembros</code> de interfaces (ejm. <code>createInstance()</code>) aparecen en letra monospaced. Líneas de código aparecen en cajas separadas. También <code>nombres de archivos</code> y <code>directorios</code> aparecen en letra monospaced.</td> </tr> <tr> <td><i>itálica</i></td> <td><i>variables</i> aparecen en letra itálica. Términos importantes y nuevos conceptos también aparecen en letra itálica la primera vez que aparecen en el texto. También aquellos términos que son explicados inmediatamente después de ser citados, o donde se le dice al lector que vaya a una sección en el libro en donde se describen dichos términos a detalle.</td> </tr> <tr> <td>link</td> <td>Referencias a otras secciones, imágenes y tablas también son links a esas secciones.</td> </tr>
+</tbody></table>
+<h3 id="Agradecimientos"> Agradecimientos </h3>
+<p>Gracias a Peter Lubczynski, John Gaunt, Ellen Evans y Alec Flett por sus revisiones técnicas. Un agradecimiento especial a Darin Fisher por sus observaciones tan meticulosas, lectura tan cercana y atención a los detalles.
+</p>
diff --git a/files/es/creación_de_componentes_xpcom/un_vistazo_de_xpcom/index.html b/files/es/creación_de_componentes_xpcom/un_vistazo_de_xpcom/index.html
new file mode 100644
index 0000000000..49896dabc1
--- /dev/null
+++ b/files/es/creación_de_componentes_xpcom/un_vistazo_de_xpcom/index.html
@@ -0,0 +1,281 @@
+---
+title: Un vistazo de XPCOM
+slug: Creación_de_Componentes_XPCOM/Un_vistazo_de_XPCOM
+tags:
+  - Todas_las_Categorías
+  - XPCOM
+translation_of: Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM
+---
+<p>Este es un libro acerca de XPCOM. Esta escrito en forma de un tutorial acerca de la creación de componentes XPCOM, pero cubre la mayoría de los aspectos, conceptos y terminología del modelo de componentes XPCOM en el camino.</p>
+<p>Este capítulo empieza con un tour rápido de XPCOM - una introducción a los conceptos básicos y tecnologías en XPCOM y el desarrollo de componentes. Las secciones principales en este capítulo introducen los conceptos a un nivel muy superficial, así que podremos discutirlos y usarlos con más familiaridad en el tutorial que describe la creación del componente Mozilla llamado <strong>Weblock</strong>.</p>
+<h3 id="La_Solución_XPCOM">La Solución XPCOM</h3>
+<p>El Modelo Componente Objeto Multiplataforma (XPCOM) es una plataforma que permite a los desarrolladores romper proyectos de software monolíticos en piezas modulares más pequeñas. Estas piezas, conocidas como <em>componentes</em> son ensamblados juntos nuevamente en tiempo de ejecución.</p>
+<p>El objetivo de XPCOM es permitir a diferentes piezas de software ser desarrolladas y construidas independientes unas de otras. Para permitir interoperabilidad entre componentes dentro de una aplicación, XPCOM separa la <em>implementación</em> de un componente de la <em>interfaz</em>, lo cual discutimos en <a href="#Interfases">Interfases</a>. Pero XPCOM también provee muchas herramientas y bibliotecas que habilitan la carga y manipulación de estos componentes, servicios que ayudan al desarrollador a escribir código modular multiplataforma, y soporte para versiones, así que los componentes pueden ser reemplazados o actualizados sin tener que romper o volver a crear la aplicación. Usando XPCOM, los desarrolladores crean componentes que pueden ser reutilizados en diferentes aplicaciones o pueden ser reemplazados para cambiar la funcionalidad de aplicaciones existentes.</p>
+<p>XPCOM no solamente soporta el desarrollo de componetes de software, también provee gran parte de la funcionalidad de una plataforma de desarrollo, como:</p>
+<ul> <li>gestión de componentes</li> <li>abstracción de archivos</li> <li>paso de mensajes objeto</li> <li>manejo de memoria</li>
+</ul>
+<p>Discutiremos los puntos de arriba a detalle en los siguientes capítulos, pero por ahora, puede ser útil pensar en XPCOM como una <em>plataforma para desarrollo de componentes</em>, en la que la que se incluyen características como las listadas arriba.</p>
+<h3 id="Gecko">Gecko</h3>
+<p>Aunque en algunos aspectos es similar a Microsoft COM, XPCOM está diseñado para ser usado primordialmente a nivel de aplicación. El uso más importante de XPCOM es dentro de <em>Gecko</em>, un buscador web embebido de código abierto, que cumple con estándares y un conjunto de herramientas para crear buscadores web y otras aplicaciones.</p>
+<p>XPCOM se encarga de accesar la funcionalidad de las bibliotecas de <em>Gecko</em> y embeber o extender Gecko. Este libro se enfoca en lo último - extender Gecko - pero las ideas fundamentales en el libro también serán importantes para los desarrolladores que embeban Gecko.</p>
+<p>Gecko es usado en muchas aplicaciones de internet, la mayoría buscadores. La lista incluye dispositivos como el Gateway/AOL, el Instant AOL y la Nokia Media Terminal. Gecko también se usa en el último cliente Compuserve, AOL para Mac OS X, Netscape 7 y por supuesto el cliente de Mozilla. En este momento, Gecko es el web browser de código abierto predominante.</p>
+<h3 id="Componentes">Componentes</h3>
+<p>XPCOM te permite construir un sistema en el que grandes proyectos de software pueden ser fragmentados en piezas más pequeñas. Estas piezas, conocidas como componentes, son normalmente diseñadas en pequeñas y reutilizables bibliotecas binarias(una <abbr title="Dynamic Link Library">DLL</abbr> en Windows, por ejemplo, o una <abbr title="Distributed Shared Object">DSO</abbr> en Unix), que pueden incluir uno o más componentes. Cuando hay dos o más componentes relacionados juntos en una biblioteca binaria, llamamos a la biblioteca <em>módulo</em>.</p>
+<p>Fragmentar el software en distintos componentes puede ayudar a hacerlo menos difícil de desarrollar y mantener. Más allá de esto, la programación modular basada en componentes tiene ciertas ventajas bien conocidas:</p>
+<table class="standard-table"> <tbody> <tr> <td class="header">Beneficio</td> <td class="header">Descripción</td> </tr> <tr> <td>Reutlizable</td> <td>El código modular puede ser reutilizado en otras aplicaciones y en otros contextos.</td> </tr> <tr> <td>Actualizaciones</td> <td>Puedes actualizar componentes sin tener que recompilar toda la aplicación.</td> </tr> <tr> <td>Rendimiento</td> <td>Cuando el código es modular, los módulos que no serán usados en seguida pueden ser "cargados durmiendo", o no ser cargados del todo, lo que puede mejorar el rendimiento de tu aplicación.</td> </tr> <tr> <td>Mantenimiento</td> <td>Aún cuando no estés actualizando un componente, diseñar tu aplicación de forma modular puede hacerte más fácil encontrar e mantener las partes de la aplicación en que estás interesado.</td> </tr> </tbody>
+</table>
+<p>Mozilla tiene más de cuatro millones de líneas de código, y ningún individuo por sí solo entiende el código fuente entero. La mejor forma de afrontar un proyecto de este tamaño es dividirlo en piezas más pequeñas y manejables, usar un modelo de programación basado en componentes y organizar ciertos grupos de componentes en módulos. La biblioteca de red, por ejemplo, consiste en componentes para cada uno de los protocolos, HTTP, FTP y otros, los cuales son armados juntos y enlazados en una sola biblioteca. Esta biblioteca es el módulo de trabajo en red, conocida también como "necko".</p>
+<p>El componente <abbr title="Hypertext Transfer Protocol">HTTP</abbr> en Gecko no expone las clases privadas que usa como componentes separados. El "stuff"</p>
+<p>The <abbr title="Hypertext Transfer Protocol">HTTP</abbr> component in Gecko doesn't expose private classes it uses as separate components. The "stuff" that's internal to the component stays internal, and isn't exposed to XPCOM. In the haste of early Mozilla development, components were created where they were inappropriate, but there's been an ongoing effort to remove XPCOM from places like this.</p>
+<p>Pero no siempre es buena idea dividir las cosas. Hay algunas cosas en el mundo que sólo trabajan si están juntas y otras que deberían estar separadas. Por ejemplo, el hijo de un autor no se comerá un sandwich de crema de cacahuate si no tiene jamón, porque en este mundo, la crema de cachuate y el jamón forman una unión inseparable (guácala, en México como en muchos lugares no opinamos lo mismo creo que fue un mal ejemplo, pero en fin esto es parte de la traducción y espero se entienda la idea). Con el software es similar. En áreas de código que están estrechamente acopladas en clases que son usadas sólo internamente, por ejemplo, el duro trabajo de dividir las cosas tal vez no sea un esfuerzo vano.</p>
+<p>El componente <abbr title="Hypertext Transfer Protocol">HTTP</abbr> en Gecko no expone las clases privadas que usa como componentes separados. El "material" que es interno del componente permanece interno y no es visible para XPCOM. Por la prisa al inicio del desarrollo de Mozilla, fueron creados componentes donde era inadecuado, pero se ha estado haciendo un grán esfuerzo para quitar XPCOM de estos lugares.</p>
+<h3 id="Interfaces">Interfaces</h3>
+<p>Generalmente es buena idea dividir el software en componentes, pero ¿Cómo hacer esto exactamente? La idea básica es identificar piezas de funcionalidad que esten relacionadas entre sí y entender cómo se comunican entre ellas. Cuando son definidos los canales de comunicación entre los distintos delimitadores de forma que se encuentran entre componentes y dichos delimitadores son formalizados se llaman <em>interfaces</em>.</p>
+<p>Las interfaces no son una idea nueva en programación. Todos hemos usado interfaces desde nuestro primer programa "Hola Mundo", donde la interface estaba entre el código que escribimos-el código de la aplicación-y el código de impresión. El código de aplicación usó una interfaz de una biblioteca, <code>stdio</code> para pintar la cadena "Hola Mundo" en la pantalla. La diferencia aquí es que una aplicación "Hola Mundo" en XPCOM encuentra esta pantalla pintando funcionalidad en tiempo de ejecución y nunca tiene que saber acerca de <code>stdio</code> cuando es compilado.</p>
+<p>Las interfaces permiten a los desarrolladores <em>encapsular</em> la implementación y la lógica interna de su programa y permitir a los clientes ignorar cómo se hacen las cosas y sólo usar el software.</p>
+<div class="side-note">
+<p><span id="Interfaces_y_programaci%C3%B3n_por_contrato"><a id="Interfaces_y_programaci%C3%B3n_por_contrato"></a><strong>Interfaces y programación por contrato</strong></span></p>
+<p>Una interfaz forma un acuerdo contractual entre componentes y clientes. No hay código que obligue estos acuerdos, pero ignorarlos puede ser fatal. En la programación basada en componentes, un componente garantiza que las interfaces que provee serán <em>inmutables</em>, es decir, proveerán el mismo acceso a los mismos métodos en diferentes versiones del componente, estableciendo un contrato con los clientes que usan el software. A este respecto, la programación basada en interfaces también es llamada <em>programación por contrato</em>.</p>
+</div>
+<h4 id="Interfaces_y_Encapsulación">Interfaces y Encapsulación</h4>
+<p>Entre delimitadores de componentes, la abstracción es crucial para el mantenimiento y la reutilización del software. Considera, por ejemplo, una clase que <em>no está</em> bien encapsulada; usar un método público de inicialización disponible libremente, como sugiere el ejemplo de abajo puede causar problemas.</p>
+<p><span id="Inicializacion_de_AlgunaClase"><a id="Inicializacion_de_AlgunaClase"></a><strong>Inicializacion de AlgunaClase</strong></span></p>
+<pre>class AlgunaClase
+{
+  public:
+    // Constructor
+    AlgunaClase();
+
+    // Virtual Destructor
+    virtual ~AlgunaClase();
+
+    // init method
+    void Init();
+
+    void HazAlgoUtil();
+};
+</pre>
+<p>Para que este sistema funcione correctamente, el programador del cliente debe prestar mucha atención a todas las reglas que el programador del componente estableció. Este es el acuerdo contractual de esta clase clase no encapsulada: un conjunto de reglas que definen cuando cada método puede ser llamado y cuando se espera que se haga. Una regla puede especificar que <code>HazAlgoUtil</code> puede ser llamado sólo después de una llamada a <code>Init()</code>. El método <code>HazAlgoUtil</code> puede hacer algún tipo de validación para asegurar que la condición de que <code>Init()</code> ha sido llamado, ha sido cumplida.</p>
+<p>Además de escribir código bien comentado que le diga al desarrollador del cliente las reglas acerca de <code>Init()</code>, el desarrollador puede seguir un par de pasos para hacer este contrato más claro. Primero, la construcción de un objeto puede ser encapsulada y proveer una <em>clase virtual</em> que defina el método <code>HazAlgoUtil</code>. De esta forma, construcción e inicialización pueden ser completamente ocultos de los clientes de la clase. En esta situación "semiencapsulada", la única parte de la clase que se ve esuna bien definida lista de métodos llamables (la interfaz). Una vez que la clase es encapsulada, la única interfaz que verá el cliente es esta:</p>
+<p><span id="Encapsulaci%C3%B3n_de_AlgunaInterfaz"><a id="Encapsulaci%C3%B3n_de_AlgunaInterfaz"></a><strong>Encapsulación de AlgunaInterfaz</strong></span></p>
+<pre>class AlgunaInterfaz
+{
+  public:
+    virtual void HazAlgoUtil() = 0;
+};
+</pre>
+<p>La implementación puede entonces derivar de esta clase e implementar el método virtual. Los clientes de este código pueden usar después un patrón de diseño factoría para crear el objeto (ve <a href="#Factorías">Factorías</a>) y después encapsular la implementación. En XPCOM, los clientes se escudan de la lógica interna de los componentes de esta forma y confiar en la interfaz para proveer acceso a la funcionalidad requerida.</p>
+<h4 id="La_Interfaz_Base_nsISupports">La Interfaz Base <code>nsISupports</code></h4>
+<p>Dos aspectos fundamentales en la programación basada en componentes e interfaces son: la <em>Vida del componente</em>, también llamada <em>posesión del objeto</em> y las <em>llamadas de interfaz</em>, o poder identificar que interfaces soporta un componente al momento de ejecución. Esta sección introduce la interfaz base, que es la madre de todas las interfaces en XPCOM, <code>nsISupports</code>, la cual proporciona soluciones a estos dos aspectos para los desarrolladores de XPCOM.</p>
+<h5 id="Posesión_de_Objetos">Posesión de Objetos</h5>
+<p>Como los componentes en XPCOM pueden implementar cualquier número de interfaces, dichas interfaces deben ser "contadas por referencia". Los componentes deben tener control de cuántas referencias a él tienen activas los clientes y borrarse ellos mismos cuando ese número llega a cero.</p>
+<p>Cuando un componente se crea, un entero dentro del componente almacena esta <em>cuenta de referencias</em>. La cuenta de referencias se incrementa automáticamente cuando el cliente hace una instancia del componente; durante el transcurso de vida del componente. En algún punto, todos los clientes pierden interés en el componente, en ese momento la cuenta llega a cero y el componente se borra a sí mismo.</p>
+<p>Cuando los clientes usan interfaces responsablemente, esto puede ser un proceso muy serio. XPCOM tiene herramientas para hacer esto más sencillo, como describiremos después. Podemos tener serios problemas cuando por ejemplo, un cliente usa una interfaz y olvida decrementar la cuenta de referencia. Cuando esto pasa, las interfaces tal vez nunca puedan ser liberadas y se desbordará la memoria. El sistema de cuenta de referencias es, como muchas otras cosas en XPCOM, un contrato entre clientes e implementaciones. Trabaja cuando la gente se pone de acuerdo con él, pero si no, las cosas pueden ir mal. Es responsabilidad de la funcion que crea el puntero a la interfaz añadir la referencia inicial o <em>posesión de referencia</em> a la cuenta.</p>
+<div class="side-note">
+<p><span id="Punteros_en_XPCOM"><a id="Punteros_en_XPCOM"></a><strong>Punteros en XPCOM</strong></span></p>
+<p>En XPCOM, "punteros" se refiere a los punteros de interfaz. La diferencia es muy sutil ya que los punteros de interfaz y los punteros comunes son sólo direcciones en memoria. Pero un puntero de interfaz debe poder implementar la interfaz base nsISupports, que también puede ser usada para llamar métodos como <code>AddRef</code>, <code>Release</code>, o <code>QueryInterface</code>.</p>
+</div>
+<p><code>nsISupports</code>, mostrado abajo, proporciona la funcionalidad básica para lidiar con el descubrimiento de la interfaz y la cuenta de referencias. Los miembros de esta interfaz, <code>QueryInterface</code>, <code>AddRef</code>, and <code>Release</code>, proporcionan los medios básicos para conseguir el interfaz correcto de un objeto, incrementando la cuenta de referencias y liberando objetos una vez que dejan de ser usados respectivamente. La interfaz <code>nsISupports</code> se muestra a continuación:</p>
+<p><span id="La_Interfaz_%3Ccode%3EnsISupports%3C/code%3E"><a id="La_Interfaz_%3Ccode%3EnsISupports%3C/code%3E"></a><strong>La Interfaz <code>nsISupports</code></strong></span></p>
+<pre>class Sample: public nsISupports
+{
+  private:
+    nsrefcnt mRefCnt;
+  public:
+    Sample();
+    virtual ~Sample();
+
+    NS_IMETHOD QueryInterface(const nsIID &amp;aIID, void **aResult);
+    NS_IMETHOD_(nsrefcnt) AddRef(void);
+    NS_IMETHOD_(nsrefcnt) Release(void);
+};
+</pre>
+<p>Los distintos tipos usados en la interfaz son descritos en la sección <a href="#Tipos_XPCOM">Tipos XPCOM</a> más adelante. Una implementación completa de la interfaz <code>nsISupports</code> se muestra abajo. Vea <a class="external" href="http://www.mozilla.org/projects/xpcom/QI.html">A Reference Implementation of QueryInterface</a> para información más detallada.</p>
+<p><span id="Implementaci%C3%B3n_de_la_interfaz_%3Ccode%3EnsISupports%3C/code%3E"><a id="Implementaci%C3%B3n_de_la_interfaz_%3Ccode%3EnsISupports%3C/code%3E"></a><strong>Implementación de la interfaz <code>nsISupports</code></strong></span></p>
+<pre>// inicializa la cuenta de referencias a 0
+Sample::Sample() : mRefCnt(0)
+{
+}
+Sample::~Sample()
+{
+}
+
+// típica implementación genérica de QI
+NS_IMETHODIMP Sample::QueryInterface(const nsIID &amp;aIID,
+                                  void **aResult)
+{
+  if (!aResult) {
+    return NS_ERROR_NULL_POINTER;
+  }
+  *aResult = NULL;
+  if (aIID.Equals(kISupportsIID)) {
+    *aResult = (void *) this;
+  }
+  if (!*aResult) {
+    return NS_ERROR_NO_INTERFACE;
+  }
+  // añade una referencia
+  AddRef();
+  return NS_OK;
+}
+
+NS_IMETHODIMP_(nsrefcnt) Sample::AddRef()
+{
+  return ++mRefCnt;
+}
+
+NS_IMETHODIMP_(nsrefcnt) Sample::Release()
+{
+  if (--mRefCnt == 0) {
+    delete this;
+    return 0;
+  }
+  // opcional: regresa la cuenta de referencias
+  return mRefCnt;
+}
+</pre>
+<h5 id="Descubrimiento_de_Objetos_de_Interfaz">Descubrimiento de Objetos de Interfaz</h5>
+<p><em>Herencia</em> es otro tópico muy importante en la programación orientada a objetos. Herencia es el medio por el que una clase es derivada de otra. Cuando una clase hereda de otra clase, le clase hija puede <em>sobreescribir</em> los comportamientos originales de la clase base sin tener que copiar todo el código de esa clase, en efecto creando una clase más específica, como en el ejemplo siguiente:</p>
+<p><br>
+<span id="Herencia_de_la_Clase_Simple"><a id="Herencia_de_la_Clase_Simple"></a><strong>Herencia de la Clase Simple</strong></span></p>
+<pre>class Figura
+{
+  private:
+    int m_x;
+    int m_y;
+
+  public:
+    virtual void Pintar() = 0;
+    Shape();
+    virtual ~Shape();
+};
+
+class Circulo : public Figura
+{
+  private:
+    int m_radio;
+  public:
+    virtual Pintar();
+    Circulo(int x, int y, int radio);
+    virtual ~Circulo();
+};
+</pre>
+<p><code>Circulo</code> es una clase derivada de <code>Figura</code>. En otras palabras un <code>Circulo</code> es una <code>Figura</code>, pero una <code>Figura</code> no es necesariamente un <code>Circulo</code>. En este caso, <code>Figura</code> es la <em>clase base</em> y <code>Circulo</code> es una <em>subclase</em> de <code>Figura</code>.</p>
+<p>En XPCOM, todas las clases derivan de la interfaz <code>nsISupports</code>, así que todos los objetos son <code>nsISupports</code> pero también son otras clases más específicas que necesitas para poder encontrarlas en tiempo de ejecución. En <a href="#Herencia_de_la_Clase_Simple">Herencia de la Clase Simple</a>, por ejemplo, ¿te gustaría poder preguntarle a la <code>Figura</code> si es un <code>Circulo</code> y poder usarlo como circulo si lo es? En XPCOM, esto es para lo que está la caracteríztica <code>QueryInterface</code> de la interfaz <code>nsISupports</code>: permite a los clientes encontrar y accesar diferentes interfaces de acuerdo a sus necesidades.</p>
+<p>En C++, puedes usar un aspecto verdaderamente avanzado conocido como <code>refernecia_dinámica&lt;&gt;</code>, que da una excepción si el objeto <code>Figura</code> no puede hacer referencia a <code>Circulo</code>. Pero habilitar las excepciones y <abbr title="Runtime Type Information">RTTI</abbr> puede no ser una opción por la mejora del rendimiento y la compatibilidad en varias plataformas, así que XPCOM hace las cosas diferente.</p>
+<div class="side-note">
+<p><span id="Excepciones_en_XPCOM"><a id="Excepciones_en_XPCOM"></a><strong>Excepciones en XPCOM</strong></span></p>
+<p>Las excepciones de C++ no son soportadas directamente en XPCOM. Todas las excepciones deben ser gestionadas dentro de un componente dado, antes de cruzar los límites de las interfaces. En XPCOM, todos métodos de interfaz deben regresar un valor de error <code>nsresult</code> (Vea la <a href="/es/Referencia_del_API_de_XPCOM" title="es/Referencia_del_API_de_XPCOM">Referencia del API de XPCOM</a> para ver la lista de códigos de error). Esos resultados de códigos de error se vuelven "excepciones" que gestiona XPCOM.</p>
+</div>
+<p>En vez de utilizar el RTTI de C++, XPCOM usa el método especial <code>QueryInterface</code> que referencía el objeto a la interfaz correcta si esa interfaz es soportada.</p>
+<p>A cada interfaz se le asigna un identificador que se genera de una herramienta comunmente llamada "uuidgen". Este identificador universal único es un número único de 128 bits. Usado en el contexto de una interfaz (similar a un componente, donde el contract ID(ID de contrato) hace esta función), a este número se le conoce como <em>IID</em>.</p>
+<p>Cuando un cliente quiere saber si un objeto soporta una interfaz dada, el cliente pasa el IID asignado a esa interfaz al método <code>QueryInterface</code> de ese objeto. Si el objeto soporta la interfaz requerida, añade una referencia a sí mismo y regresa un puntero a esa interfaz. Si el objeto no soporta la interfaz, regresa un error.</p>
+<pre>class nsISupports {
+  public:
+    long QueryInterface(const nsIID &amp; uuid,
+                        void **result) = 0;
+    long AddRef(void) = 0;
+    long Release(void) = 0;
+};
+</pre>
+<p>El primer parámetro de <code>QueryInterface</code> es una referencia a la clase llamada <code>nsIID</code>, que es una encapsulación básica del IID. De los tres métodos en la clase <code>nsIID</code>, <code>Equals</code>, <code>Parse</code>, and <code>ToString</code>, <code>Equals</code> es por mucho el más importante, porque se usa para comparar dos <code>nsIID</code>s en el proceso de requerimiento de esta interfaz.</p>
+<p>Cuando implementas la clase <code><a href="/es/docs/Mozilla/Tech/XPCOM/Reference/Interface/nsISupports" title="">nsISupports</a></code> (y verás en el capítulo <a href="/es/Creaci%C3%B3n_de_Componentes_XPCOM/Uso_de_Utilidades_XPCOM_para_hacer_las_cosas_m%C3%A1s_f%C3%A1ciles" title="es/Creación_de_Componentes_XPCOM/Uso_de_Utilidades_XPCOM_para_hacer_las_cosas_más_fáciles">Uso de Utilidades XPCOM para hacer las cosas más fáciles</a> como las macros pueden hacer este proceso mucho más sencillo), debes asegurarte que los métodos de la clase regresan un resultado válido cuando el cliente llama <code>QueryInterface</code> con el IID de <code>nsISupports</code>. <code>QueryInterface</code> debe soportar todas las interfaces que el componente soporta.</p>
+<p>En las implementaciones de <code>QueryInterface</code>, el parámetro IID es comparado con el <code>nsIID</code> de la clase. Si coinciden, el puntero <code>this</code> del objeto es referenciado a <code>void</code>, la cuenta de referencias se incrementa y la interfaz es devuelta al llamador. Si no coinciden, la clase regeresa un error y pone el valor de salida a <code>null</code>.</p>
+<p>En el ejemplo de arriba, es muy fácil usar referencias al estilo de C. Pero referenciar puede volverse más complicado donde debes primero referenciar a <code>void</code> y luego al tipo requerido porque debes regresar el puntero a la interfaz en el <abbr title="virtual table">vtable</abbr> correspondiente a la interfaz requerida. Referenciar puede volverse un problema cuando hay un orden ambiguo de herencia.</p>
+<h3 id="Identificadores_XPCOM">Identificadores XPCOM</h3>
+<p>Además del identificador de interfaz IID discutido en la sección anterior, XPCOM usa otros dos identificadores muy importantes para distinguir las clases y los componentes.</p>
+<div class="side-note">
+<p><span id="Clases_Identificadoras_de_XPCOM"><a id="Clases_Identificadoras_de_XPCOM"></a><strong>Clases Identificadoras de XPCOM</strong></span></p>
+<p>La clase <code>nsIID</code> es es un tupo definido para la clase <code>nsID</code>. Los otros tipos definidos de <code>nsID</code>, CID e IID, se refieren a implementaciones específicas de una clase en concreto y a una iterfaz específica, respectivamente.</p>
+<p>La clase <code>nsID</code> proporciona métodos como <code>Equals</code> para comparar identificadores en el código. Ve <a href="/es/Creaci%C3%B3n_de_Componentes_XPCOM/Creaci%C3%B3n_del_C%C3%B3digo_del_Componente#Identificadores_en_XPCOM" title="es/Creación_de_Componentes_XPCOM/Creación_del_Código_del_Componente#Identificadores_en_XPCOM">Identificadores en XPCOM</a> para mayor información de la clase <code>nsID</code>.</p>
+</div>
+<h4 id="CID">CID</h4>
+<p>Un CID es un número de 128 bits que identifica como únicos a una clase o un componente de manera muy parecida a la forma en que un IID identifica una interfaz. El CID para <code>nsISupports</code> se ve como este:</p>
+<p><code>00000000-0000-0000-c000-000000000046</code></p>
+<p>El largo de un CID puede hacer incómodo manejarlo en el código, así que muy a menudo verás #defines para los CIDs y otros identificadores usados, como en el siguiente ejemplo:</p>
+<pre>#define CID_EJEMPLO \
+{ 0x777f7150, 0x4a2b, 0x4301, \
+{ 0xad, 0x10, 0x5e, 0xab, 0x25, 0xb3, 0x22, 0xaa}}
+</pre>
+<p>También verás que <code>NS_DEFINE_CID</code> es muy usado. Esta simple macro declara una constante con el valor del CID:</p>
+<pre>static NS_DEFINE_CID(kWebShellCID, NS_WEB_SHELL_CID);
+</pre>
+<p>Un CID es algunas veces llamado <em>identificador de clase</em>. Si la clase a la que se refiere un CID implementa más de una interfaz, ese CID garantiza que la clase implementa todo ese conjunto de interfaces cuando se publica como congelado.</p>
+<h4 id="Contract_ID">Contract ID</h4>
+<p>Un contract ID es una cadena leible humanamente usada para accesar un componente. Un CID o un contract ID puede ser usado para obtener un componente desde el gestor de componentes. Este es el contract ID para el componente de Operación LDAP:</p>
+<pre>"@mozilla.org/network/ldap-operation;1"
+</pre>
+<p>El formato del contract ID es el <em>dominio</em> del componente, el <em>módulo</em>, el <em>nombre del componente</em> y el <em>número de versión</em> separados por diagonales.</p>
+<p>Como un CID, el contract ID se refiere a una implementación más que a una interfaz, como lo hace un IID. Pero un contract ID no está relacionado a ninguna implementación en específico, como el CID, por lo cual es más general. Más bien, un contract ID especifica un conjunto de interfaces dadas que requiere implementadas y cualquier número de CIDs diferentes pueden estar presentes y llenar ese requerimiento. Esta diferencia entre un contract ID y un CID es lo que hace posible sobreescribir componentes.</p>
+<h3 id="Factorías">Factorías</h3>
+<p>Una vez que el código es dividido en componentes, el código cliente típicamente usa el operador <code>new</code> para instanciar los objetos a usar:</p>
+<pre>SomeClass* component = new SomeClass();
+</pre>
+<p>Este patrón requiere que el cliente sepa algo acerca del componente, al menos qué tan grande es. El <em>patrón de diseño factoría</em> puede usarse para encapsular la construcción de objetos. El objetivo principal de una factoría es crear un objeto sin mostrar a los clientes la implementación e inicialización de este objeto. En el ejemplo <code>SomeClass</code> la construcción e inicialización de <code>SomeClass</code> que implementa la clase abstracta <code>SomeInterface</code>, es contenida dentro de la función <code>New_SomeInterface</code> que sigue el patrón de diseño factoría:</p>
+<p><span id="Encapsulaci%C3%B3n_del_Constructor"><a id="Encapsulaci%C3%B3n_del_Constructor"></a><strong>Encapsulación del Constructor</strong></span></p>
+<pre>int New_SomeInterface(SomeInterface** ret)
+{
+  // crea el objeto
+  SomeClass* out = new SomeClass();
+  if (!out) return -1;
+
+  // inicializa el objeto
+  if (out-&gt;Init() == FALSE)
+  {
+    delete out;
+    return -1;
+  }
+
+  // referencia de la interfaz
+  *ret = static_cast&lt;SomeInterface*&gt;(out);
+  return 0;
+}
+</pre>
+<p>La factoría es la clase que gestiona la creación de instancias separadas de un componente para su uso. En XPCOM, las factorías son implementaciones de la interfaz <code>nsIFactory</code> y usan un patrón de diseño factoría como el ejemplo de arriba para abstraer y encapsular la construcción e inicialización del objeto.</p>
+<p>El ejemplo en <a href="#Encapsulación_del_Constructor">Encapsulación del Constructor</a> es una versión simple sin estado de las factorías, pero programarlo en el mundo real usualmente no es tan simple y en general las factorías necesitan guardar un estado. La factoría necesita, por lo menos preservar información de qué objetos ha creado. Cuando una factoría gestiona instancias de una clase contenida en un biblioteca dinámica compartida, por ejemplo, necesita saber cuando puede descargar la biblioteca. Cuando la factoría preserva un estado, puedes preguntarle si hay referencias esperando y saber si la factoría creó objetos.</p>
+<p>Otro estado que puede guardar una factoría es si un objeto es o no <em>singleton</em>. Por ejemplo, si una factoría crea un objeto que se supone debe ser singleton, entonces las llamadas subsecuentes a la factoría por el objeto deben regresar el mismo objeto. Aunque que hay herramientas y mejores formas de gestionar un singleton (lo que discutiremos cuando hablemos del <code>nsIServiceManager</code>), un desarrollador tal vez quiera usar esta información para asegurarse de que sólo puede existir un objeto singleton sin importar lo que hagan los clientes.</p>
+<p>Los requerimientos de una clase factoría pueden gestionarse de una manera estrictamente funcional con el estado guardado en variables globales, pero hay beneficios de usar clases para las factorías. Cuando usas una clase para implementar la funcionalidad de una factoría, por ejemplo, derivas de la interfaz <code>nsISupports</code>, que te permite manejar el tiempo de vida de los objetos de la factoría por sí mismos. Esto es importante cuando quieres agrupar conjuntos de factorías y determinar si pueden ser descargados. Otro beneficio de usar la interfaz <code>nsISupports</code> es que puedes soportar otras interfaces al momento en que sean introducidas. Como mostraremos al discutir <code>nsIClassInfo</code>, algunas factorías permiten pedir información acerca de la implementación que tienen debajo, como el lenguaje en el está escrito el objeto, las interfaces que soporta, etc. Este tipo de "comprobación futura" es una ventaja clave que se obtiene al derivar de <code>nsISupports</code>.</p>
+<h4 id="XPIDL_y_Bibliotecas_de_Tipos">XPIDL y Bibliotecas de Tipos</h4>
+<p>Una manera fácil y potente de definir una interfaz es - en efecto, un requerimiento para definir interfaces en un ambiente multiplataforma, independiente del lenguaje- es usar un <em>lenguaje de definición de interfaces</em> (IDL). XPCOM usa su propia variante del Lenguaje de Definición de Interfaces (IDL) de CORBA OMG llamado XPIDL, que te permite especificar métodos, atributos y contantes de una interfaz dada y también definir herencia de interfaz.</p>
+<p>Hay algunas desventajas de definir tu interfaz usando XPIDL. No hay soporte para herencia múltiple de una sola cosa; si defines una interfaz nueva, no puede derivar de más de una interfaz; otra limitante de las intertfaces en XPIDL es que los nombres de los métodos deben ser únicos, no puedes tener dos métodos con el mismo nombre aunque tomen distintos parámetros, es decir no se permite la sobrecarga de funciones, y el trabajo que implica tener múltiples nombres de funciones no es agradable:</p>
+<pre>void AlgoConInt(in int x);
+void AlgoConString(in string x);
+void AlgoConURI(in nsIURI x);
+</pre>
+<p>De cualquier modo, estos pequeños inconvenientes palidecen en comparación con la funcionalidad ganada usando XPIDL. XPIDL te permite generar <em>bibliotecas de tipos</em>, o typelibs, que son archivos con la extensión <em>.xpt</em>. La biblioteca de tipo es una representación binaria de una interfaz o interfaces, permite el control programático y acceso de la interfaz, lo que es crucial para las interfaces que no son usadas en el mundo de C++. Cuando los componentes son accesados desde otros lenguajes,como puede hacerse en XPCOM, usan la biblioteca binaria de tipo para accesar a la interfaz, ver qué métodos soporta y llamar esos métodos. Este aspecto de XPCOM se llama <em>XPConnect</em>. XPConnect es la capa de XPCOm que permite el acceso a los componentes de XPCOM desde lenguajes como JavaScript. Ve <a href="/es/Creaci%C3%B3n_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM#Conexi.C3.B3n_a_Componentes_desde_la_Interfaz" title="es/Creación_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM#Conexi.C3.B3n_a_Componentes_desde_la_Interfaz">Conexión a Componentes desde la Interfaz</a> para más información de XPConnect.</p>
+<p>Cuando un componente es accesible desde un lenguaje distinto a C++, como JavaScript, se le ordena a su interfaz "reflejarse" en ese lenguaje. Cada interfaz reflejada debe tener una biblioteca de tipos correspondiente. Actualmente puedes escribir componentes en C, C++, Javascript (y algunas veces Python o Java, dependiendo del estado de las etiquetas respectivas) y hay esfuerzos tratando de construir etiquetas XPCOm para Ruby y Perl también.</p>
+<div class="side-note">
+<p><span id="Escribir_Componentes_en_Otros_Lenguajes"><a id="Escribir_Componentes_en_Otros_Lenguajes"></a><strong>Escribir Componentes en Otros Lenguajes</strong></span></p>
+<p>Tal vez no tengas acceso a algunas de las herramientas que XPCOM da para los desarrolladores en C++ (como macros, plantillas, punteros inteligentes y otros) cuando creas componentes en otros lenguajes, tal vez te tengas que conformar con el lenguaje en sí mismo prescindir de C++ y construir, por ejemplo, un componente XPCOm basado en Python que pueden ser usados desde JavaScript o vice versa.</p>
+<p>Ve <a href="/es/Creaci%C3%B3n_de_Componentes_XPCOM/Resources" title="es/Creación_de_Componentes_XPCOM/Resources">Resources</a> Para más información de Python y otros lenguajes para los que se ha añadido soporte en XPCOM.</p>
+</div>
+<p>Todas las interfaces públicas en XPCOM sin definidas usando la sintaxis XPIDL. Las Bibliotecas de tipos y los archivos de cabecera de C++ son generados a partir de estos archivos IDL y la herramienta que genera esos archivos se llama <em>compilador xpidl</em>. La sección <a href="/es/Creaci%C3%B3n_de_Componentes_XPCOM/Iniciando_WebLock#Definici.C3.B3n_de_la_Interfaz_WebLock_en_XPIDL" title="es/Creación_de_Componentes_XPCOM/Iniciando_WebLock#Definici.C3.B3n_de_la_Interfaz_WebLock_en_XPIDL">Definición de la Interfaz WebLock en XPIDL</a> describe la sintaxis XPIDL a detalle.</p>
+<h3 id="Servicios_de_XPCOM">Servicios de XPCOM</h3>
+<p>Cuando los clientes usan los componentes, normalmente <em>instancían</em> un nuevo objeto cada vez que necesitan la funcionalidad que da un componente. Este es el caso cuando, por ejemplo, los clientes lidian con archivos: cada archivo distinto es representado por un objeto diferente y muchos objetos de archivo pueden ser usados al mismo tiempo en cualquier momento.</p>
+<p>Pero también hay un tipo de objeto conocido como <em>servicio</em>, del cual siempre hay sólo una copia (aunque puede haber varios servicios corriendo al mismo tiempo). Cada vez que un cliente quiere accesar la funcionalidad de un servicio, se comunican con la misma instancia de ese servicio. Cuando un usuario busca un número telefónico en la base de datos de una compañía , por ejemplo, probablemente esa base de datos está representada por un "objeto" que es el mismo para todos los trabajadores. Si no lo fuera, la aplicación necesitaría varias copias de una gran base de datos en memoria, para una misma cosa y tal vez habría inconsistencias entre los datos grabados porque las copias serían diferentes.</p>
+<p>Dar este único punto de acceso a la funcionalidad es para lo que está el patrón de diseño singleton y es lo que los servicios hacen en una aplicación (y en un ambiente de desarrollo como XPCOM).</p>
+<p>En XPCOM, además del soporte y gestión de componentes, hay un número de servicios que ayudan al desarrollador a escribir componentes multiplataforma. Estos servicios incluyen una abstracción de archivos multiplataforma que da un acceso a archivos uniforme y potente, los servicios de directorio que mantienen la locación de la aplicación y locaciones específicas del sistema, manejo de memoria para asegurar que todos usen el mismo localizador de memoria y el sistema de notificación de eventos que permite el paso de mensajes simples. El tutorial mostrará cada uno de estos componentes y servicios en uso, y la <a href="/es/XPCOM_API_Reference" title="es/XPCOM_API_Reference">XPCOM API Reference</a> tiene una lista completa de las interfaces en éstas áreas.</p>
+<h3 id="Tipos_de_XPCOM">Tipos de XPCOM</h3>
+<p>Hay muchos tipos XPCOM declarados y macros simples que usaremos en los siguientes ejemplos, la mayoría de esos tipos son simples correlaciones. Los tipos más comunes son descritos en las siguientes secciones.</p>
+<h4 id="Tipos_de_Métodos">Tipos de Métodos</h4>
+<p>Los siguientes son un conjunto de tipos para asegurar la convención correcta de llamadas y tipos regresados de los métodos XPCOM.</p>
+<table class="standard-table"> <tbody> <tr> <td><code>NS_IMETHOD</code></td> <td>Tipo regresado en la declaración del método. Las declaraciones de métodos XPCOM deben usar este como su tipo de regreso.</td> </tr> <tr> <td><code>NS_IMETHODIMP</code></td> <td>Tipo de regreso de implementación del método. Las implementaciones de métodos XPCOM deben usar este como su tipo de regreso.</td> </tr> <tr> <td><code>NS_IMETHODIMP_(tipo)</code></td> <td>Tipo de regreso de implementaciones de casos especiales. Algunos métodos como <code>AddRef</code> y <code>Release</code> no regresan el tipo por defecto. Esta excepción es regrettable, pero requerida para cumplir la compatibilidad con COM.</td> </tr> <tr> <td><code>NS_IMPORT</code></td> <td>Forza el método a ser resuelto internamente por la biblioteca compartida.</td> </tr> <tr> <td><code>NS_EXPORT</code></td> <td>Forza el método a ser exportado por la biblioteca compartida.</td> </tr> </tbody>
+</table>
+<h4 id="Cuenta_de_Referencias">Cuenta de Referencias</h4>
+<p>Estas Macros manejan la cuenta de referencias.</p>
+<table class="standard-table"> <tbody> <tr> <td><code>NS_ADDREF</code></td> <td>Llama a <code>AddRef</code> en un objeto <code>nsISupports</code>.</td> </tr> <tr> <td><code>NS_IF_ADDREF</code></td> <td>Lo mismo que el anterior pero valida null antes de llamar a <code>AddRef</code>.</td> </tr> <tr> <td><code>NS_RELEASE</code></td> <td>Llama a <code>Release</code> en un objeto <code>nsISupports</code>.</td> </tr> <tr> <td><code>NS_IF_RELEASE</code></td> <td>Lo mismo que el anterior pero valida null antes de llamar a <code>Release</code>.</td> </tr> </tbody>
+</table>
+<h3 id="Códigos_de_Estatus">Códigos de Estatus</h3>
+<p>Estas macros prueban códigos de estatus.</p>
+<table class="standard-table"> <tbody> <tr> <td><code>NS_FAILED</code></td> <td>Regresa verdadero si el código de estatus pasado fue fallo.</td> </tr> <tr> <td><code>NS_SUCCEEDED</code></td> <td>Regresa verdadero si el código de estatus pasado fue éxito.</td> </tr> </tbody>
+</table>
+<h3 id="Correlaciones_Variables">Correlaciones Variables</h3>
+<table class="standard-table"> <tbody> <tr> <td><code>nsrefcnt</code></td> <td>Tipo de cuenta de referencias por defecto. Correlaciona un entero de 32-bits.</td> </tr> <tr> <td><code>nsresult</code></td> <td>Tipo de error por defecto. Correlaciona un entero de 32-bits.</td> </tr> <tr> <td><code>nsnull</code></td> <td>Valor nulo por defecto.</td> </tr> </tbody>
+</table>
+<h3 id="Códigos_de_Error_Comunes_de_XPCOM">Códigos de Error Comunes de XPCOM</h3>
+<table class="standard-table"> <tbody> <tr> <td><code>NS_ERROR_NOT_INITIALIZED</code></td> <td>Regresado cuando una instancia no está inicializada.</td> </tr> <tr> <td><code>NS_ERROR_ALREADY_INITIALIZED</code></td> <td>Regresado cuando una instancia ya fue inicializada.</td> </tr> <tr> <td><code>NS_ERROR_NOT_IMPLEMENTED</code></td> <td>Regresado por un método no implementado.</td> </tr> <tr> <td><code>NS_ERROR_NO_INTERFACE</code></td> <td>Regresado cuando una interfaz dada no es soportada.</td> </tr> <tr> <td><code>NS_ERROR_NULL_POINTER</code></td> <td>Regresado cuando un puntero válido es <code>nsnull</code>.</td> </tr> <tr> <td><code>NS_ERROR_FAILURE</code></td> <td>Regresado cuando un método falla. Caso de error genérico.</td> </tr> <tr> <td><code>NS_ERROR_UNEXPECTED</code></td> <td>Regresado cuando ocurre un error inesperado.</td> </tr> <tr> <td><code>NS_ERROR_OUT_OF_MEMORY</code></td> <td>Regresado cuando una localización de memoria falla.</td> </tr> <tr> <td><code>NS_ERROR_FACTORY_NOT_REGISTERED</code></td> <td>Regresado cuando una clase requerida no está registrada.</td> </tr> </tbody>
+</table>
+<p></p><div class="prevnext" style="text-align: right;">
+    <p><a href="/es/docs/Creación_de_Componentes_XPCOM:Prefacio" style="float: left;">« Anterior</a><a href="/es/docs/Creación_de_Componentes_XPCOM:Uso_de_Componentes_XPCOM">Siguiente  »</a></p>
+</div><p></p>
+<p></p>
diff --git a/files/es/creación_de_componentes_xpcom/uso_de_componentes_xpcom/index.html b/files/es/creación_de_componentes_xpcom/uso_de_componentes_xpcom/index.html
new file mode 100644
index 0000000000..b250d637c1
--- /dev/null
+++ b/files/es/creación_de_componentes_xpcom/uso_de_componentes_xpcom/index.html
@@ -0,0 +1,318 @@
+---
+title: Uso de Componentes XPCOM
+slug: Creación_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM
+tags:
+  - Todas_las_Categorías
+  - XPCOM
+translation_of: Mozilla/Tech/XPCOM/Guide/Creating_components/Using_XPCOM_Components
+---
+<p></p><div class="prevnext" style="text-align: right;">
+    <p><a href="/es/docs/Creación_de_Componentes_XPCOM:Un_Vistazo_de_XPCOM" style="float: left;">« Anterior</a><a href="/es/docs/Creación_de_Componentes_XPCOM:Interior_del_Componente">Siguiente  »</a></p>
+</div><p></p>
+
+<p>Una de las mejores formas de empezar a trabajar con XPCOM - especialmente cuando estás diseñando la interfaz de un componente que será usado por otros, como lo hacemos en <a href="es/Creaci%c3%b3n_de_Componentes_XPCOM/Iniciando_WebLock">Iniciando WebLock</a> - es observar como están usando los componentes XPCOM los clientes.</p>
+
+<p>Aplicaciones como el buscador Mozilla son clientes sofísticados y modularizados de Componentes XPCOM. De hecho, virtualmente toda la funcionalidad que asocias al buscador - navegación, manejo de ventanas, manejo de cookies, marcadores, seguridad, búsqueda, renderizado y otros aspectos - es definida en componentes XPCOM uy accesada por medio de las interfaces de esos componentes. Mozilla está<em>hecho</em> de componentes XPCOM.</p>
+
+<p>Este capítulo demuestra como Mozilla usa algunos de esos objetos XPCOM, como el CookieManager y muestra como se definirá el acceso al componente Weblock.</p>
+
+<h3 id="Ejemplos_de_Componentes" name="Ejemplos_de_Componentes">Ejemplos de Componentes</h3>
+
+<p>Puedes encontrar más sobre como puedes usar en particular los componentes descritos aquí en la <a href="es/XPCOM_API_Reference">XPCOM API Reference</a>. Por ahora, lo importante es ver como componentes como los que están en esta sección son obtenidos usando el buscador Mozilla.</p>
+
+<h4 id="Manejador_de_Cookies" name="Manejador_de_Cookies">Manejador de Cookies</h4>
+
+<p>La gestión de Cookies es uno de los muchos conjuntos de funcionalidad que están disponibles en el buscador en la forma de componente XPCOM y puede ser reutilizado por los desarrolladores que quieran una funcionalidad similar en sus aplicaciones. Siempre que un usuario accesa el Cookie Manager para ver, organizar o borrar cookies que han sido guardadas en el sistema, están usando el componente CookieManager detrás de las pantallas. <a href="#El_Diálogo_Cookie_Manager">El Diálogo Cookie Manager</a> muestra la interfaz de usuario <sup><a href="https://developer.mozilla.org/es/docs/Creaci%C3%B3n_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM#endnote_cookie-manager-ui">[cookie-manager-ui]</a></sup> que se presenta al usuario en Mozilla para trabajar con el componente CookieManager.</p>
+
+<p><span id="El_Di%C3%A1logo_Cookie_Manager"><a id="El_Di%C3%A1logo_Cookie_Manager"></a><strong>El Diálogo Cookie Manager</strong></span></p>
+
+<p><img alt="Image:cookie_mgr_dlog.png"></p>
+
+<p>Este Diálogo está escrito en <abbr title="XML UI Language">XUL</abbr> y JavaScript, usa una parte de XPCOM llamada<em>XPConnect</em> para conectarse sin parches al componente CookieManager (Ve <a href="#Conexión_a_Componentes_desde_la_interfaz">Conexión a Componentes desde la interfaz</a> abajo). XUL es sólo una forma de mostrar la funcionalidad del componente CookieManager, pero es particularmente útil en el mundo de Mozilla.</p>
+
+<p>La funcionalidad del componente CookieManager está disponeble atravéz de la interfaz <code>nsICookieManager</code>, que es comprendido dentro de los métodos públicos en la tabla de abajo.</p>
+
+<p><span id="La_Interfaz_nsICookieManager"><a id="La_Interfaz_nsICookieManager"></a><strong>La Interfaz nsICookieManager</strong></span></p>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <td><code>removeAll</code></td>
+   <td>Elimina todas las cookies de la lista de cookies.</td>
+  </tr>
+  <tr>
+   <td><code>enumerator</code></td>
+   <td>Enumera la lista de cookies.</td>
+  </tr>
+  <tr>
+   <td><code>remove</code></td>
+   <td>Elimina una cookie en particular de la lista.</td>
+  </tr>
+ </tbody>
+</table>
+
+<p>En XPCOM se garantiza que la interfaz permanece igual aún cuando la implementación debajo de ella cambie. Las interfaces son<em>públicas</em> en otras palabras y las implementaciones son privadas<sup><a href="https://developer.mozilla.org/es/docs/Creaci%C3%B3n_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM#endnote_private-xpcom-interfaces">[private-xpcom-interfaces]</a></sup>. Cuando un usuario selecciona una de las cookies mostradas en la lista y luego presiona el botón Eliminar, el método <code>Remove</code> de la interfaz <code>nsICookieManager</code> es llamado. La función es llevada a cabo poir el componente CookieManager y la cookie seleccionada es borrada del disco y eliminada de la lista.</p>
+
+<p>El trozo de código en <a href="#Obtener_el_Componente_CookieManager_en_JavaScript">Obtener el Componente CookieManager en JavaScript</a> muestra como el método <code>Remove()</code> del componente XPCOM CookieManager puede ser llamado desde JavaScript:</p>
+
+<p><span id="Obtener_el_Componente_CookieManager_en_JavaScript"><a id="Obtener_el_Componente_CookieManager_en_JavaScript"></a><strong>Obtener el Componente CookieManager en JavaScript</strong></span></p>
+
+<pre>// xpconnect al cookiemanager
+// obtener el componente cookie manager en JavaScript
+var cmgr = Components.classes["@mozilla.org/cookiemanager;1"]
+                     .getService();
+cmgr = cmgr.QueryInterface(Components.interfaces.nsICookieManager);
+
+// llamado como parte de la función largerDeleteAllCookies()
+function FinalizeCookieDeletions() {
+  for (var c=0; c&lt;deletedCookies.length; c++) {
+    cmgr.remove(deletedCookies[c].host,
+                deletedCookies[c].name,
+                deletedCookies[c].path);
+  }
+  deletedCookies.length = 0;
+}
+</pre>
+
+<div class="side-note">
+<p><span id="Conexi%C3%B3n_a_Componentes_desde_la_Interfaz"><a id="Conexi%C3%B3n_a_Componentes_desde_la_Interfaz"></a><strong>Conexión a Componentes desde la Interfaz</strong></span></p>
+
+<p>La interfaz de usuario de Mozilla usa un JavaScript al que se le ha dado acceso a los componentes XPCOM en el código de la aplicación con una tecnología llamada<em>XPConnect</em>.</p>
+
+<p>XPConnect permite a los métodos de la interfaz definidos via XPIDL ser llamados desde JavaScript como parte de los objetos JavaScript que representan instancias de componentes como el CookieManager.</p>
+
+<p>XPConnect es lo que enlaza el código de la aplicación a la interfaz de usuario del buscador Mozilla, a otros ambientes basados en Gecko XUL y JavaScript como xpcshell, que es un intérprete JavaScript de línea de comandos y una herramienta incluida en Mozilla.</p>
+
+<p>Ve <a class="external" href="http://www.mozilla.org/scriptable/" rel="freelink">http://www.mozilla.org/scriptable/</a> para más información sobre XPConnect y JavaScript.</p>
+</div>
+
+<p>Esto no es todo los que hay acerca del tema, desde luego, pero muestra un aspecto importante de XPCOM. Los arreglos contractuales que XPCOM forza abren una forma de<em>interoperabilidad binaria</em> -para poder accesar, usar y reutilizar componentes XPCOM en tiempo de ejecución. Y ellos hacen posible usar componentes escritos en otros lenguajes - como JavaScript, Python y otros - y usar componentes XPCOM basados en C++<em>desde</em> esos otros lenguajes también.</p>
+
+<p>En el buscador Mozilla, los componentes son usados desde JavaScript en la interfaz como en C++ o cualquier otro lenguaje. De hecho, una búsqueda en el código fuente de Mozilla revela que este componente CookieManager es llamado<em>sólo</em> desde JavaScript. Usaremos este componente desde JavaScript nosotros mismos como parte de este tutorial<sup><a href="https://developer.mozilla.org/es/docs/Creaci%C3%B3n_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM#endnote_cookie-manager-in-tutorial">[cookie-manager-in-tutorial]</a></sup>.</p>
+
+<div class="side-note">
+<p><span id="JavaScript_y_Mozilla"><a id="JavaScript_y_Mozilla"></a><strong>JavaScript y Mozilla</strong></span></p>
+
+<p>JavaScript es la<em>lingua franca</em> de la interfaz del buscador Mozilla y las etiquetas entre él y XPCOM están muy bien definidos.<em>Scriptabilidad</em>, esta habilidad de obtener y usar componentes desde JavaScript y otros lenguajes para los que han sido creadas etiquetas XPConnect, es un aspecto del código XPCOM.</p>
+</div>
+
+<h4 id="El_Componente_WebBrowserFind" name="El_Componente_WebBrowserFind">El Componente <code>WebBrowserFind</code></h4>
+
+<p>Todos los componentes son usados en funcionalidad de alto nivel del buscador como <code>nsWebBrowserFind</code> que contiene los métodos <code>find()</code> y <code>findNext()</code> para encontrar el contenido en páginas web y tareas de bajo nivel como manipulación de información. No todas las APIs de Mozilla deben ser integradas en XPCOM, mucha de la funcionalidad está disponible en componentes que pueden ser reutilizados por las extensiones del buscador y/o embebedores de Gecko.</p>
+
+<p>Además del componente CookieManager, por ejemplo, el componente WebBrowserFind es otra parte de una larga lista de interfaces de búsqueda web que puedes usar. Su interfaz <code>nsIWebBrowserFind</code> se muestra en <a href="#La_Interfaz_nsIWebBrowserFind">La Interfaz nsIWebBrowserFind</a>. Para usar este componente, los accesas mediante la interfaz <code>nsIWebBrowserFind</code> y llamas sus métodos.</p>
+
+<p><span id="La_Interfaz_nsIWebBrowserFind"><a id="La_Interfaz_nsIWebBrowserFind"></a><strong>La Interfaz nsIWebBrowserFind</strong></span></p>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <td><code>findNext</code></td>
+   <td>Encuentra la siguiente ocurrencia de la cadena buscada.</td>
+  </tr>
+  <tr>
+   <td><code>findBackwards</code></td>
+   <td>Atributo booleano que ajusta <code>findNext()</code> para buscar hacia arriba del documento.</td>
+  </tr>
+  <tr>
+   <td><code>searchFrames</code></td>
+   <td>Atributo booleano que indica si se busca o no en subframes del documento actual.</td>
+  </tr>
+  <tr>
+   <td><code>matchCase</code></td>
+   <td>Atributo booleano que indica si coincide o no el caso en la búsqueda.</td>
+  </tr>
+  <tr>
+   <td><code>entireWord</code></td>
+   <td>Atributo booleano que especifica si debe coincidir toda la palabra o no.</td>
+  </tr>
+ </tbody>
+</table>
+
+<p>Una vez que usas la interfaz para obtener el componente, puedes preguntarle al componente que otras interfaces soporta. Este servicio, que es definido en la interfaz básica <code>nsISupports</code> e implementado por todos los componentes XPCOM, te permite requerir y cambiar interfaces en un componente como parte de las capacidades de<em>mecanografía de objeto de tiempo de ejecución</em> de XPCOM. Es gestionada por el método <code>QueryInterface</code> que fue visto en el capítulo <a href="es/Creaci%c3%b3n_de_Componentes_XPCOM/%c2%bfQu%c3%a9_es_XPCOM%3f">¿Qué es XPCOM?</a>. La <a href="es/XPCOM_API_Reference">XPCOM API Reference</a> es una referencia de todos los componentes disponibles en Mozilla.</p>
+
+<h4 id="El_Componente_WebLock" name="El_Componente_WebLock">El Componente WebLock</h4>
+
+<p>Es hora de ver el componente <strong>WebLock</strong> como otro ejemplo de componentes XPCOM (ya que lo estarás creando muy pronto). En la programación orientada a objetos, es común diseñar primero la interfaz para definir la funcionalidad que tendrá la abstracción sin tener en cuenta como será hecha esta funcionalidad. Así que dejaremos del lado los detalles la implementación hasta el siguiente capítulo y veremos el componente desde afuera, desde la interfaz del componente WebLock.</p>
+
+<p><span id="La_Interfaz_IWebLock"><a id="La_Interfaz_IWebLock"></a><strong>La Interfaz IWebLock</strong></span></p>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <td><code>lock</code></td>
+   <td>Bloquea el buscador al sitio actual(o a la lista blanca de sitios aprobados leída del disco).</td>
+  </tr>
+  <tr>
+   <td><code>unlock</code></td>
+   <td>Desbloquea el buscador para uso irrestricto.</td>
+  </tr>
+  <tr>
+   <td><code>addSite</code></td>
+   <td>Añade un nuevo sitio a la lista blanca.</td>
+  </tr>
+  <tr>
+   <td><code>removeSite</code></td>
+   <td>Elimina un sitio dado de la lista blanca.</td>
+  </tr>
+  <tr>
+   <td><code>sites</code></td>
+   <td>Enumerador para la lista de sitios aprobados leída de la lista blanca.</td>
+  </tr>
+ </tbody>
+</table>
+
+<p>El componente WebLock es un programa que implementa todos los métodos descritos en la definición de la interfaz. Se registra a sí mismo para su uso al iniciar el buscador y tiene una factoría que crea una instancia de él para ser usada cuando el usuario o el administrador presionan el icono en la interfaz gráfica del buscador.</p>
+
+<h3 id="Uso_de_Componentes_en_Mozilla" name="Uso_de_Componentes_en_Mozilla">Uso de Componentes en Mozilla</h3>
+
+<p>Entonces ¿Cómo se obtienen los componentes en Mozilla?. Has visto algunos pedazos de JavaScript en secciones anteriores de este capítulo, pero no hemos explicado como XPCOM hace los componentes disponibles en general.</p>
+
+<p>Esta sección aborda el uso práctico de componentes en Mozilla. Está dividido en tres subsecciones: una acerca de como encontrar todos esos componentes binarios en Mozilla y otras dos que corresponden a cada una de las dos formas en las que los clientes accesan normalmente los componentes XPCOM:</p>
+
+<ul>
+ <li><a href="es/Creaci%c3%b3n_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM#Localizar_los_Componentes_de_Mozilla">Localizar los Componentes de Mozilla</a></li>
+ <li><a href="es/Creaci%c3%b3n_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM#Usar_Componentes_XPCOM_en_tu_Cpp">Usar Componentes XPCOM en tu Cpp</a></li>
+ <li><a href="es/Creaci%c3%b3n_de_Componentes_XPCOM/Uso_de_Componentes_XPCOM#XPConnect:_Usar_Componentes_XPCOM_desde_un_Script">XPConnect: Usar Componentes XPCOM desde un Script</a></li>
+</ul>
+
+<h4 id="Localizar_los_Componentes_de_Mozilla" name="Localizar_los_Componentes_de_Mozilla">Localizar los Componentes de Mozilla</h4>
+
+<p>Este libro trata de dar información de referencia para los componentes XPCOM y sus interfaces que están congeladas al momento de hacer este escrito. El <a class="external" href="http://www.mozilla.org/projects/embedding/">Mozilla embedding project</a> alberga las interfaces congeladas actuales.</p>
+
+<p>Mozilla también tiene algunas herramientas que pueden encontrar y desplegar información de las interfaces disponibles en Gecko como el<em>Visor de Componentes XPCOM</em> descrito abajo, y <a class="external" href="http://lxr.mozilla.org/">LXR</a>, que es una herramienta basada en web para ver el código fuente.</p>
+
+<p>El reto de hacer disponible buena información acerca de los componentes XPCOM para los posibles clientes, el proceso de congelar las interfaces que son implementadas por esos componentes aún está en progreso. El Visor de Componentes no distingue los componentes que ya están congelados de los que no. En el código fuente que ves en LXR, las interfaces que han sido congeladas han sido marcadas hasta arriba con <code>@status frozen</code>.</p>
+
+<h5 id="El_Visor_de_Componentes_XPCOM" name="El_Visor_de_Componentes_XPCOM">El Visor de Componentes XPCOM</h5>
+
+<p>El <a class="external" href="http://addons.mozilla.org/firefox/2230/">Visor de Componentes</a> es una extensión que puedes instalar en tu buscador (en sandbox, no está disponible por ahora):</p>
+
+<p><span id="Visor_de_Componentes_XPCOM"><a id="Visor_de_Componentes_XPCOM"></a><strong>Visor de Componentes XPCOM</strong></span> <img alt="Image:using-component-viewer.png"></p>
+
+<p>La columna de la izquierda muestra los componentes, en este caso un subconjunto resultado de la búsqueda de "gfx" como parte del contract ID y en la columna de la derecha una lista de las interfaces. Cuando abres un componente en la izquierda, puedes ver las interfaces que implementa y una lista con los métodos que tiene cada interfaz.</p>
+
+<p>El Visor de Componentes XPCOM puede ser extremadamente útil para esta fuente de grandes interrogantes, pero otra vez: despliega<em>todos</em> los componentes e interfaces contenidas dentro, muchas de las cuales no son prácticas para reutilizarse actualmente o lo suficientemente estables para ser usados viablemente en el desarrollo de tu propia aplicación. Usa estas listas con precaución.</p>
+
+<p><span class="comment">XXX mediawiki is t3h suxx0r</span> <span class="comment">XXX give me my C++</span></p>
+
+<h4 id="Usar_Componentes_XPCOM_en_tu_Cpp" name="Usar_Componentes_XPCOM_en_tu_Cpp">Usar Componentes XPCOM en tu Cpp</h4>
+
+<p>XPConnect hace fácil accesar los componentes XPCOM como objetos JavaScript, pero usar componentes XPCOM en C++ no es mucho más difícil.</p>
+
+<p><a href="#Gestionar_Cookies_desde_Cpp">Gestionar Cookies desde Cpp</a> duplica el código de <a href="#Obtener_el_Componente_CookieManager_en_JavaScript">Obtener el Componente CookieManager en JavaScript</a>, pero en C++ en vez de JavaScript.</p>
+
+<p> </p>
+
+<p><span id="Gestionar_Cookies_desde_Cpp"><a id="Gestionar_Cookies_desde_Cpp"></a><strong>Gestionar Cookies desde Cpp</strong></span></p>
+
+<pre>nsCOMPtr&lt;nsIServiceManager&gt; servMan;
+nsresult rv = NS_GetServiceManager(getter_AddRefs(servMan));
+if (NS_FAILED(rv))
+  return -1;
+
+nsCOMPtr&lt;nsICookieManager&gt; cookieManager;
+rv = servMan-&gt;GetServiceByContractID("@mozilla.org/cookiemanager",
+                                     NS_GET_IID(nsICookieManager),
+                                     getter_AddRefs(cookieManager));
+
+if (NS_FAILED(rv))
+  return -1;
+
+PRUint32 len;
+deletedCookies-&gt;GetLength(&amp;len);
+
+for (int c=0; c&lt;len; c++)
+    cookieManager-&gt;Remove(deletedCookies[c].host,
+                          deletedCookies[c].name,
+                          deletedCookies[c].path,
+                          PR_FALSE);
+</pre>
+
+<p><span class="comment">XXX: In the original document, there were only the first three parameters to the |Remove| call. I added |PR_FALSE| as a fourth parameter because the interface seems to require it: <a class="external" href="http://lxr.mozilla.org/mozilla/source/netwerk/cookie/public/nsICookieManager.idl#64" rel="freelink">http://lxr.mozilla.org/mozilla/sourc...Manager.idl#64</a> This problem also appears in the JavaScript version below, and I've added |false| as a fourth parameter there as well.</span></p>
+
+<p>Si tu aplicación está escrita en C++, entonces <a href="#Gestionar_Cookies_desde_Cpp">Gestionar Cookies desde Cpp</a> te muestra los pasos que debes seguir para obtener un componente XPCOM, especifica la interfaz en el componente que quieres usar y llama los métodos en esa interfaz.</p>
+
+<h4 id="XPConnect:_Usar_Componentes_XPCOM_desde_un_Script" name="XPConnect:_Usar_Componentes_XPCOM_desde_un_Script">XPConnect: Usar Componentes XPCOM desde un Script</h4>
+
+<p>El componente CookieManager que discutimos al principio del capítulo nos da una buena oportunidad para hablar después acerca de usar componentes desde JavaScript. En el siguiente fragmento de código del diálogo Gestor de Cookies en Mozilla, puedes ver un singletón del componente CookieManager siendo creado con el método <code>getService()</code> y usado para dar la funcionalidad que deja a los usuarios cargar y eliminar cookies desde la interfaz de usuario.</p>
+
+<p><span id="Gestionar_Cookies_desde_JavaScript"><a id="Gestionar_Cookies_desde_JavaScript"></a><strong>Gestionar Cookies desde JavaScript</strong></span></p>
+
+<pre>var cmgr = Components.classes["@mozilla.org/cookiemanager;1"]
+                     .getService();
+cmgr = cmgr.QueryInterface(Components.interfaces.nsICookieManager);
+
+function loadCookies() {
+  // load cookies into a table
+  var enumerator = cmgr.enumerator;
+  var count = 0;
+  var showPolicyField = false;
+  while (enumerator.hasMoreElements()) {
+    var nextCookie = enumerator.getNext();
+    nextCookie = nextCookie.QueryInterface(Components.interfaces.nsICookie);
+    /* .... */
+}
+function FinalizeCookieDeletions() {
+  for (var c=0; c&lt;deletedCookies.length; c++) {
+    cmgr.remove(deletedCookies[c].host,
+                deletedCookies[c].name,
+                deletedCookies[c].path,
+                false);
+  }
+  deletedCookies.length = 0;
+}
+</pre>
+
+<p><span class="comment">XXX: In the original document, there were only the first three parameters to the |remove| call. I added |false| as a fourth parameter because the interface seems to require it: <a class="external" href="http://lxr.mozilla.org/mozilla/source/netwerk/cookie/public/nsICookieManager.idl#64" rel="freelink">http://lxr.mozilla.org/mozilla/sourc...Manager.idl#64</a> This problem also appears in the C++ version above, and I've added |PR_FALSE| as a fourth parameter there as well.</span></p>
+
+<p>Después los métodos estan siendo llamados en el mismo CookieManager (ejm; <code>cookiemanager.remove</code>, que apunta a la función <code>remove()</code> en <a href="#La_Interfaz_nsICookieManager">La Interfaz nsICookieManager</a>), nota los objetos y métodos especiales XPConnect que reflejan el componente XPCOM en JavaScript.</p>
+
+<p><code>Components</code> es el objeto JavaScript que controla la conexión a componentes y <code>classes</code> es un array de todas las clases por las que puedes preguntar mediante el contract ID. Para instanciar un componente XPCOM en JavaScript, creas un nuevo objeto del componente y pasas el contract ID para el componente que quieres y preguntas si será un singleton o una instancia del componente el resultado regresado:</p>
+
+<pre>var cmgr = Components.classes["@mozilla.org/cookiemanager;1"]
+                     .getService();
+</pre>
+
+<p>El objeto resultante <code>cookiemanager</code> nos da acceso a todos los métodos de ese componente que sido definidos en IDL y compilados en una biblioteca de tipos. Usando el componente CookieManager puedes escribir código como este para borrar todas las cookies del sistema:</p>
+
+<pre>cmgr = Components.classes["@mozilla.org/cookiemanager;1"]
+                 .getService();
+cmgr = cmgr.QueryInterface(Components.interfaces.nsICookieManager);
+
+// delete all cookies
+function trashEm() {
+   cmgr.removeAll();
+}
+</pre>
+
+<p>Otro aspecto vital del pegamento de XPConnect que muestra este ejemplo es la disponibilidad del método <code>QueryInterface</code> en todos los objetos que son reflejados en JavaScript desde XPCOM. Como en C++, puedes usar este método para preguntar por otras interfaces que esten disponibles en el objeto dado.</p>
+
+<div class="side-note">
+<p><span id="Servicios_Frente_a_Instancias_Regulares"><a id="Servicios_Frente_a_Instancias_Regulares"></a><strong>Servicios Frente a Instancias Regulares</strong></span></p>
+
+<p>Si los clientes usarán tu componente como una instancia o un servicio es una pregunta de diseño, realmente y algo debes ser claro acerca ello en la documentación de tu componente. Ahora, el método <code>getService()</code> en este ejemplo llama mediante el método <code>createInstance()</code> que también está disponible para el objeto del Componente y cacha el resultado, haciéndolo un singleton en vez de una instancia normal.</p>
+
+<p>El patrón de diseño singleton que es usado para crear servicios es descrito en <a href="es/Creaci%c3%b3n_de_Componentes_XPCOM/Qu%c3%a9_es_XPCOM%3f#Servicios_de_XPCOM">Servicios de XPCOM</a></p>
+</div>
+
+<p>Recuerda, <code>QueryInterface</code> te permite requerir a un objeto las interfaces que soporta. En el caso del trozo en <a href="#La_Interfaz_nsICookieManager">La Interfaz nsICookieManager</a>, el método <code>QueryInterface</code> es usado para obtener la interfaz <code>nsICookie</code> del enumerador, así que, para instanciar, el código JavaScript puede accesar los atributos <code>value</code> y <code>name</code> para cada cookie.</p>
+
+<ol>
+ <li><div class="blockIndicator note"><strong>Nota:</strong> cookie-manager-ui</div> Nota que la interfaz no es parte del componente en sí mismo. XPCOM hace fácil usar componentes como CookieManager desde Mozilla's Cross Platform Front End (XPFE) y otras interfaces de usuario, pero el componente no tiene por sí mismo una IU(Interfaz de Usuario).</li>
+</ol>
+
+<ol>
+ <li><div class="blockIndicator note"><strong>Nota:</strong> private-xpcom-interfaces</div> Hay excepciones a esto. Algunas interfaces XPCOM también son privadas y no estan hechas para uso general. Las interfaces privadas no tienen los mismos requerimientos que las que son hechas públicas en IDL.</li>
+ <li><div class="blockIndicator note"><strong>Nota:</strong> cookie-manager-in-tutorial</div> El componente CookieManager es usado para proveer para la funcionalidad de bloqueo web descrita en este tutorial.</li>
+</ol>
+
+<p></p><div class="prevnext" style="text-align: right;">
+    <p><a href="/es/docs/Creating_XPCOM_Components:An_Overview_of_XPCOM" style="float: left;">« Anterior</a><a href="/es/docs/Creating_XPCOM_Components:Component_Internals">Siguiente  »</a></p>
+</div> <p></p><div class="licenseblock">
+<p>Copyright (c) 2003 by Doug Turner and Ian Oeschger. This material may be distributed only subject to the terms and conditions set forth in the <a class="external" href="http://www.opencontent.org/openpub/" rel="noopener">Open Publication License</a>, v1.02 or later. Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder. Distribution of the work or derivative of the work in any standard (paper) book form is prohibited unless prior permission is obtained from the copyright holder.</p>
+</div><p></p>
+
+<div class="noinclude"> </div>
+
+<p></p>