<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN" "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
<!ENTITY mdash "&#38;#x2014;">
<!ENTITY hellip "&#x2026;">
<!ENTITY introduction SYSTEM "introduction.xml">
<!ENTITY interface SYSTEM "interface.xml">
<!ENTITY fileoperations SYSTEM "fileoperations.xml">
<!ENTITY projects SYSTEM "projects.xml">
<!ENTITY build SYSTEM "build.xml">
<!ENTITY debugger SYSTEM "debugger.xml">
<!ENTITY glade SYSTEM "glade.xml">
<!ENTITY preferences SYSTEM "preferences.xml">
<!ENTITY tools SYSTEM "tools.xml">
<!ENTITY authors SYSTEM "authors.xml">
<!ENTITY license SYSTEM "license.xml">
<!ENTITY appversion "2.0.2">
<!ENTITY manrevision "2.7">
<!ENTITY date "April 2006">
<!ENTITY app "anjuta">
]>
<!-- =============Document Header ============================= -->
<book id="index" lang="es">
 <bookinfo>
  <title>Manual del EID Anjuta</title>
  <edition>v1.0.0</edition>
  <abstract role="description">
  	<para>Manual para el  EID Anjuta</para>
  </abstract>
  
	<author role="maintainer">
		<firstname>Naba</firstname>
		<surname>Kumar</surname>
	</author>
	<author>
		<firstname>Andy</firstname>
		<surname>Piper</surname>
	</author>
	<author>
		<firstname>Biswapesh</firstname>
		<surname>Chattopadhyayr</surname>
	</author>
	<author>
		<firstname>Johannes</firstname>
		<surname>Schmid</surname>
	</author>

  <copyright>
   <year>2001-2002</year>
   <year>2006-2008</year>
   <holder>Naba Kumar, Andy Piper, Biswapesh Chattopadhyay</holder>
   <holder>Johannes Schmid</holder>
  </copyright><copyright><year>2007-2009</year><holder>Jorge González (jorgegonz@svn.gnome.org)</holder></copyright>
  
  <legalnotice>
   <para>Se concede permiso para copiar, distribuir o modificar este documento según las condiciones de la <citetitle>GNU Free Documentation License</citetitle>, Versión 1.1 o cualquier versión posterior publicada por la Free Software Foundation sin Secciones invariantes, Textos de portada y Textos de contraportada. Encontrará una copia de la <citetitle>GNU Free Documentation License</citetitle> visitando su <ulink type="http" url="http://www.fsf.org">página web</ulink> o escribiendo a: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, EE. UU.</para>
   <para>Muchos de los nombres usados por compañías para distinguir sus productos y servicios se mencionan como marcas comerciales. Donde aparezcan dichos nombres en cualquier documentación GNOME, y para que los miembros del proyecto de documentación las reconozcan dichas marcas comerciales, dichos nombres se imprimen en mayúsculas o iniciales mayúsculas.</para>
  </legalnotice>

	<revhistory>
		<revision>
		  <revnumber>Manual de Anjuta 2.1.0</revnumber>
		  <date>2007</date>
		  <revdescription>
			 <para role="author">Johannes Schmid<email>jhs@gnome.org</email></para>
			 <para role="publisher">Equipo de Anjuta</para>
		  </revdescription>
		</revision>
	</revhistory>
		
 </bookinfo>
 <!-- Document Body -->
 <!-- Introduction -->
  <!-- ============= Introduction ============================== -->
 <chapter id="introduction">
  <title>Introducción</title>
  <para><application>Anjuta</application> es un Editor Integrado de Desarrollo (EID) versátil para el escritorio GNOME. Tiene ciertas características para facilitar la programación que incluyen gestión de proyectos, asistentes de aplicación, un depurador interactivo integrado, un diseñador de IU Glade integrado, una ayuda API de devhelp integrada, un perfilador de memoria Valgrind integrado, un perfilador de rendimiento grpof integrado, un generador de clases, un potente editor de código fuente, búsqueda de fuentes y mucho más.</para>

  <para>Anjuta Devstudio se ha diseñado para ser simple de operar pero suficientemente potente para cumplir con todos sus necesidades de programación. Muchas características han evolucionado desde los primeros días y se han añadido algunas otras muy atractivas. Los desarrolladores se centran en proporcionar potencia y usabilidad al mismo tiempo sin sobrecargar los sentidos y haciendo que el desarrollo de su software sea placentero. Los desarrolladores siempre estarán ocupados para ofrecerle una de las mejores experiencias con EID, mejorando todas las características y estabilizándolo. Los desarrolladores esperan que pase un buen rato usando Anjuta. De lo contrario, ayúdelos a mejorar Anjuta informando de errores y haciendo sugerencias.</para>
  <para>La siguiente captura ilustra alguna de las cosas que encontrará en Anjuta.</para>

  <para>
  <figure id="anjuta-scrshot">
   <title>Anjuta en acción</title>
   <screenshot>
   <screeninfo>Anjuta en acción</screeninfo>
   <graphic format="PNG" fileref="figures/anjuta-in-action.png" srccredit="jhs"/>
   </screenshot>
   </figure>
  </para>

  <para>Anjuta tiene un sistema de empotramiento muy flexible y avanzado que le permite disponer todas las vistas de la forma que quiera. Puede arrastrar y soltar las vistas usando las barras de arrastre y reordenar la disposición. Las disposiciones son persistentes para cada proyecto, de tal forma que puede mantener distintas disposiciones especiales en diferentes proyectos. Todas las vistas empotrables son minimizables para evitar el desorden en la ventana principal. Las vistas minimizadas aparecen como iconos en la parte izquierda de la ventana principal. Todas las acciones de los menús son configurables escribiendo en el menú (la forma usual de GNOME) o a través una interfaz de configuración de los atajos de teclado.</para>

  <para>Por favor, informe de cualquier problema con <application>Anjuta</application>: esto ayudará a mejorar el software así como ayuda a la comunidad código abierto.</para>
 </chapter>

 <!-- Getting Familiar with Anjuta -->
 <chapter id="familiar">
  <title>Familiarizarse con Anjuta</title>
 <!-- ============= Getting Familiar: Menus  ============-->
  <sect1 id="menu-and-shortcuts">
   <title>Menús y atajos de teclado</title>
   <para>En la parte superior de la ventana principal de <application>Anjuta</application> está la barra de menú. Puede acceder a casi todas las funcionalidades de Anjuta desde los elementos del menú. Las operaciones se han agrupado de acuerdo con su tipo. Por ejemplo, las operaciones con archivos se han agrupado dentro del menú <guisubmenu>Archivo</guisubmenu>.</para>
	
    <figure id="menubar">
      <title>Barra de menú</title>
	  <screenshot>
      <screeninfo>Barra de menú de Anjuta</screeninfo>
       <graphic fileref="figures/menubar.png" format="PNG" srccredit="jhs"/>
      </screenshot>
    </figure>
    
    <figure id="file-menu">
      <title>Menú Archivo</title>
      <screenshot>
      <screeninfo>Menú Archivo</screeninfo>
       <graphic fileref="figures/file_menu.png" format="PNG" srccredit="jhs"/>
      </screenshot>
    </figure>
	
   <para>Las teclas rápidas, o aceleradores de teclado, están disponibles para muchos elementos de los menús. Todas las teclas rápidas se muestran junto con los elementos del menú correspondientes. A continuación se listan algunas teclas rápidas útiles.</para>
	
   <para>
    <itemizedlist>
     <listitem>
      <para><emphasis>Página del editor de selección:</emphasis> <keycombo><keycap>Ctrl</keycap><keycap>Tab</keycap></keycombo> (adelante) y <keycombo><keycap>Ctrl</keycap><keycap>Mayús</keycap><keycap>Tab</keycap></keycombo> (atrás). También puede seleccionar las páginas  pulsando con el botón derecho del ratón en las solapas de notas y seleccionando una solapa del editor (útil cuando no se pueden ver a la vez todas las solapas del editor). Algunas configuraciones del escritorio pueden haber asignado teclas de acceso rápido. En ese caso, deberá reconfigurarlas (no en Anjuta, porque son fijas) si quiere disponer de esas combinaciones de teclas.</para>
     </listitem>
     <listitem>
      <para><emphasis>Ayuda contextual:</emphasis> <keycombo><keycap>Mayús</keycap><keycap>F1</keycap></keycombo>. Sitúe el cursor sobre una palabra (por ejemplo, el nombre de la función) para la que quiere obtener la ayuda de la API y pulse este atajo. La ayuda contextual sólo funciona si tiene <emphasis>Devhelp</emphasis> instalado. Si no tiene instalado <application>Devhelp</application>, el menú de ayuda contextual y la barra de botones estarán inactivas. Puede obtenerlo de la página web de <application>Devhelp</application>. También tendrá que instalar los libros relacionados con<application>Devhelp</application>.</para>
     </listitem>
     <listitem>
      <para><emphasis>Autocompletar:</emphasis> <keycombo><keycap>Ctrl</keycap><keycap>Intro</keycap></keycombo>. Pulse la combinación de teclas con el cursor ubicado al final de una palabra incompleta y se mostrará una lista de palabras que coincidan con la parte restante. Desplace la lista y seleccione la palabra correcta de la lista, si encuentra una.</para>
     </listitem>
     <listitem>
      <para><emphasis>Más teclas rápidas:</emphasis> Consulte las teclas rápidas mostradas en la parte derecha de las etiquetas de los elementos del menú. También se pueden cambiar como se explica en el siguiente consejo.</para>
     </listitem>
    </itemizedlist>
   <tip>
   <title>Personalizar los atajos de teclado</title>
   <para>Puede cambiar las combinaciones de teclas predeterminadas usando <menuchoice><guisubmenu>Editar</guisubmenu><guimenuitem>Preferencias</guimenuitem></menuchoice> y seleccionando la solapa <interface>Combinaciones de teclas</interface>.</para>
   </tip>
   </para>
  </sect1>

<!-- ============= Getting Familiar: Main window  ============-->
  <sect1 id="main-win">
   <title>Ventana principal</title>
   <para>La ventana principal contiene varias vistas que se pueden reordenar arrastrando sus barras de título. También se pueden minimizar pulsando en los botones de minimizar en la parte izquierda de las barras de título.</para>

   <para>
    <orderedlist>
     <listitem>
      <para>La <interface>Ventana de documentos</interface> tendrá un documento activo cada vez (si hay algún archivo abierto). Todos los comandos del archivo se aplican en este documento. Puede cambiar a cualquier página pulsando en su solapa. Puede hacer lo mismo pulsando con el botón derecho del ratón en las solapas de la página y eligiendo el documento del menú emergente que aparecerá. Esto es especialmente útil cuando tiene muchos archivos abiertos pero no todos son visibles en el área de las solapas de la página.</para>
	 </listitem>
     <listitem>
      <para>La <interface>Ventana de proyecto</interface> muestra un árbol con los archivos del proyecto si tiene un proyecto abierto. De otra forma, la <interface>Ventana de proyecto</interface> generalmente está oculta. Pulsar dos veces sobre cualquier elemento en la <interface>Ventana de proyecto</interface> abrirá ese archivo.</para>
     </listitem>
      <listitem>
      <para>La <interface>Ventana de archivos</interface> muestra un árbol de archivos. Si no hay un proyecto abierto, el árbol de archivos apunta a la raíz del sistema de archivos, pero puede cambiarlo en las preferencias. Si un proyecto está abierto muestra todos los archivos dentro del proyecto. Pulsar dos veces abre un archivo en la aplicación apropiada según esté configurado en las preferencias MIME de GNOME. Pulsar con el botón derecho abre un menú emergente que le proporciona opciones sobre cómo abrir el archivo.</para>
     </listitem>
      <listitem>
      <para>La <interface>Ventana de símbolos</interface> muestra un árbol con los símbolos disponibles en el proyecto generados desde el analizador <application>ctags</application>. Al pulsar dos veces se abre una ventana del editor con el archivo y líneas correspondientes.</para>
      <para>También existe una <interface>Barra de búsqueda</interface> en la ventana Símbolos en la que puede buscar símbolos.</para>
     </listitem>
     <listitem>
      <para>La <interface>ventana de mensajes</interface> listará todos los mensajes (salidas tanto <filename>stdout</filename> como <filename>stderr</filename>) cuando se ejecute un comando externo. La <interface>ventana de mensajes</interface> generalmente está oculta, pero aparece tan pronto como se ejecuta un comando externo, ya sea durante la compilación del archivo o proyecto, las sesiones de depuración, las búsquedas o muchas otras operaciones. <application>Anjuta</application> también añade suspropios mensajes cuando es necesario.</para>
      <para>Los colores que se usan para mostrar los mensajes son importantes. Los mensajes mostrados en el color de fondo estándar (generalmente negro) son mensajes normales. Los que se muestran en azul son mensajes importantes, como mensajes de error u otra información. Los mensajes mostrados en rojo están <emphasis>enlazados</emphasis>. Al pulsar dos veces sobre esos mensajes irá a archivo y número de línea particulares especificados en el mensaje.</para>
      <para>Por ejemplo, cuando compila un archivo que contiene errores aparecerán algunos mensajes en rojo mostrando los problemas y dónde ocurren. Al pulsar dos veces sobre dichos mensajes se abrirá el archivo y se resaltará la línea que contiene el error.</para>
     </listitem>
     <listitem>
      <para>La <interface>Ventana del terminal</interface> es una emulación de un terminal donde puede ejecutar comandos igual que en la aplicación Terminal de GNOME.</para>
     </listitem>
    </orderedlist>
   </para>
   <note>
   <title>Gestión de sesiones</title>
   <para>Todos los ajustes, incluyendo los tamaños y posiciones de las ventanas, se guardan al salir de <application>Anjuta</application>. La gestión de las sesiones aún está bajo desarrollo, así que no debería salir de <application>Anjuta</application> sin haber guardado antes sus documentos. <application>Anjuta</application> mostrará una advertencia si intenta salir con documentos sin guardar abiertos.</para>
   </note>
  </sect1>
 </chapter>

 <!-- File operations -->
  <chapter id="file-operations">
  <title>Operaciones con archivos</title>
  
  <!-- ============= File operations: Creating a new file === -->
  <sect1 id="creating-files">
   <title>Crear un archivo nuevo e insertar texto</title>
    <sect2 id="new-file">
    <title>Crear un archivo nuevo</title>
     <para>Para crear un archivo nuevo, elija <menuchoice><guisubmenu>Archivo</guisubmenu><guimenuitem>Nuevo</guimenuitem></menuchoice> de la barra de menú o pulse el botón <guibutton>Archivo nuevo</guibutton> en la barra de herramientas. Se abrirá una nueva página en el editor (o una nueva ventana si el documento padre está en una ventana). Este nuevo documento se llamará <filename>newfile#1</filename>, <filename>newfile#2</filename>, <filename>newfile#3</filename> y demás.</para>
	   <important>
	   <title>Guardar archivo</title>
	   <para>Debería guardar sus documentos nuevos tan pronto como le sea posible para evitar cualquier pérdida de datos en caso de cuelgue.</para>
	   </important>
    </sect2>
    <sect2 id="file-wizard">
    <title>Asistente de archivos</title>
     <para>También se puede usar un asistente para crear un archivo nuevo. Para crear un archivo nuevo, elija <menuchoice><guisubmenu>Archivo</guisubmenu><guisubmenu>Nuevo</guisubmenu><guimenuitem>Archivo</guimenuitem></menuchoice> de la barra de menú. Esto abrirá el diálogo Archivo nuevo. Seleccione el tipo de archivo. Introduzca el nombre del archivo. El sufijo se añadirá automáticamente. Puede añadir información sobre la licencia (de acuerdo con la licencia a su elección) y una cabecera. En caso de que sea una cabecera C o C++, también puede añadir una plantilla de cabecera. Pulse <guibutton>Aceptar</guibutton> para validar la creación. <figure id="new-file-wizard">
       <title>Nuevo asistente de archivos</title>
       <screenshot>
        <screeninfo>El diálogo Abrir archivo</screeninfo>
        <graphic fileref="figures/new_file_wizard.png" format="PNG" srccredit="jnoel"/>
       </screenshot>
      </figure></para>
     <para><application>Anjuta</application> ocasionalmente crea nuevos archivos durante algunas operaciones. Por ejemplo, algunas operaciones sobre Subversion, tales como <command>diff</command> y <command>view log</command> crean archivos nuevos y añaden la salida allí. Estos se pueden guardar en un archivo real igual que los nuevos archivos normales.</para>
     </sect2>
     <sect2 id="inserting-macros">
      <title>Insertar macros</title>
       <para>Puede usar <emphasis>macros</emphasis> para editar rápidamente secuencias repetitivas de texto.</para>
       <important>
       <para>El complemento de macros debe estar activado.</para>
       </important>
      <sect3 id="inserting">
       <title>Insertar</title>
       <para>Existen dos tipos de macros disponibles: Los macros de Anjuta y los macros de usuario (se muestran como «Mis macros»). Los macros de Anjuta no son modificables por el usuario. Por otra parte, los macros del usuario se pueden definir y modificar por el usuario.</para>
       <para>Para insertar una macro, mueva el cursor al lugar deseado. Seleccione <menuchoice><guisubmenu>Editar</guisubmenu><guisubmenu>Macros</guisubmenu><guimenuitem>Macros...</guimenuitem></menuchoice>. Aparecerá la ventana de diálogo. Seleccione la macro deseada de la lista. El resultado de la expansión de la macro se mostrará en la ventana así como un resumen en la ventana de diálogo. Elija <guibutton>Insertar</guibutton>. Se insertará el texto de la macro expandida en la posición del cursor.</para>
       <para>Otra posibilidad para insertar un macro es seleecionar <menuchoice><guisubmenu>Editar</guisubmenu><guisubmenu>Macros</guisubmenu><guimenuitem>Insertar macro…</guimenuitem></menuchoice>, después pulsar el atajo de teclado sobre la macro seleccionado. <figure id="display-macro">
         <title>Macro</title>
          <screenshot>
           <screeninfo>El diálogo Macro</screeninfo>
           <graphic fileref="figures/display_macro.png" format="PNG" srccredit="jnoel"/>
          </screenshot>
        </figure></para>
       </sect3>
       <sect3 id="defining-macro">
        <title>Definir macros</title>
        <para>Desde la ventana de Insertar macro, elija <guibutton>Añadir</guibutton> o seleccione <menuchoice><guisubmenu>Editar</guisubmenu><guisubmenu>Macros</guisubmenu><guimenuitem>Añadir macro...</guimenuitem></menuchoice>. Aparecerá la ventana de Añadir/editar. Introduzca el nombre de la macro, elija o defina una categoría e introduzca un atajo. Después edite el texto relativo a la macro. El carácter «|» indicará la posición del cursor después de la inserción de la macro. Elija <guibutton>Aceptar</guibutton>. La macro se añadirá a la lista.</para>
        <para>También puede borrar un macro seleccionándolo en la lista (sólo Mis macros) y después eligiendo <guibutton>Eliminar</guibutton>. Ésto sólo funciona para los macros del usuario (Mis macros).</para>
        <para>De la misma manera se puede editar un macro y modificarlo seleccionándolo en la lista y eligiendo después <guibutton>Editar</guibutton>. <figure id="add-edit-macro">
          <title>Añadir/Editar macro</title>
          <screenshot>
           <screeninfo>Diálogo Añadir/Editar</screeninfo>
           <graphic fileref="figures/add_edit_macro.png" format="PNG" srccredit="jnoel"/>
          </screenshot>
         </figure></para>
       </sect3>
       <sect3 id="macro-keyword">
        <title>Palabras clave de los macros</title>
        <para>Están disponibles las palabras clave para los macros. Pueden integrarse en la definición de la macro. Los nombres de estas palabras clave de los macros comienzan y finalizan con el carácter « @ ».</para>
        <para>Las palabras clave de macro disponibles son: @DATE_TIME@, @DATE_YMD@, @DATE_Y@, @USER_NAME@, @FILE_NAME@, @FILE_NAME_UP@, @FILE_NAME_UP_PREFIX@, @EMAIL@, @TABSIZE@, @INDENTSIZE@ y @USETABS@. <figure id="keyword-macro">
         <title>Palabra clave de la macro</title>
          <screenshot>
           <screeninfo>La palabra clave de la macro</screeninfo>
           <graphic fileref="figures/keyword_macro.png" format="PNG" srccredit="jnoel"/>
          </screenshot>
         </figure></para>
      </sect3>
     </sect2>
  </sect1>

 <!-- ============= File operations: Opening and saving files === -->
  <sect1 id="open-save-files">
   <title>Abrir y guardar archivos</title>
   <para>
    <orderedlist>
     <listitem>
      <para><emphasis>Abrir un archivo:</emphasis> para abrir un archivo existente elija <menuchoice><guisubmenu>Archivo</guisubmenu><guimenuitem>Abrir</guimenuitem></menuchoice> de la barra de menú, pulse el botón <guibutton>Abrir</guibutton> de la barra de herramientas o pulse <keycombo><keycap>Ctrl</keycap><keycap>O</keycap></keycombo>. Esto mostrará el diálogo <interface>Abrir archivo</interface>. <figure id="open-file">
        <title>Diálogo Abrir archivo</title>
        <screenshot>
		<screeninfo>El diálogo Abrir archivo</screeninfo>
         <graphic fileref="figures/open_file.png" format="PNG" srccredit="jnoel"/>
        </screenshot>
       </figure> Seleccione o introduzca el archivo que quiere abrir, después pulse <guibutton>Abrir</guibutton>. Para abrir más de un archivo a la vez, seleccione múltiples archivos pulsando primero la tecla <keycap>Ctrl</keycap> y pulsando sobre los archivos en la lista y pulse <guibutton>Abrir</guibutton>. Si cambia de opinión, pulse <guibutton>Cancelar</guibutton> para cerrar el diálogo sin abrir el archivo.</para>
	  <para>
	   <figure id="open-file-multiple">
        <title>Diálogo Abrir múltiples archivos</title>
        <screenshot>
		<screeninfo>El diálogo Abrir archivo en el modo de múltiple selección</screeninfo>
         <graphic fileref="figures/open_file_multiple.png" format="PNG" srccredit="jnoel"/>
        </screenshot>
       </figure>
	  </para>
	  <para>Puede activar la opción <emphasis>Mostrar archivos ocultos</emphasis> a través del menú emergente que aparece al pulsar con el botón derecho en el diálogo Abrir archivo. Esta opción hará que los archivos ocultos (archivos que comienzan por «.») sean visibles en la lista de archivos. Pulse de nuevo para ocultarlos. El diálogo de selección de archivo de <application>Anjuta</application> también tiene un filtro para tipos de archivo incluido. Seleccione el filtro de tipo de archivo apropiado en el diálogo y la lista de archivos se limitará a los archivos del tipo seleccionado.</para>
     </listitem>
     
     <listitem>
      <para><emphasis>Guardar un archivo:</emphasis>. Para guardar un archivo elija <menuchoice><guisubmenu>Archivo</guisubmenu><guimenuitem>Guardar</guimenuitem></menuchoice> de la barra de menú, pulse el botón <guibutton>Guardar</guibutton> en la barra de herramientas, o pulse <keycombo><keycap>Ctrl</keycap><keycap>S</keycap></keycombo>. Esto guardará el archivo. Si el archivo es nuevo aparecerá un diálogo <interface>Guardar como</interface>. Introduzca un nombre de archivo y pulse <guibutton>Guardar</guibutton> para guardar el archivo nuevo con el nombre proporcionado. <screenshot>
	    <screeninfo>Guardar como archivo</screeninfo>
            <graphic fileref="figures/save_as_file.png" format="PNG" srccredit="jnoel"/>
           </screenshot></para>
	   <note>
	   <title>Autoguardar archivos</title>
		<para>Si ha habilitado el autoguardado, Anjuta no guardará ningún archivo nuevo. Primero debe guardarlos manualmente. Lo mismo se aplica a la opción <guimenuitem>Guardar todos</guimenuitem>: Anjuta no guardará ningún archivo nuevo si no los ha guardado antes manualmente. <emphasis>Debe guardar un archivo manualmente para que el autoguardado o <guimenuitem>Guardar todos</guimenuitem> funcionen con ellos.</emphasis></para>
	   </note>
     </listitem>

     <listitem>
      <para><emphasis>Guardar un archivo con un nombre diferente:</emphasis> Puede guardar un archivo con un nombre nuevo explícitamente. Para hacerlo, elija <menuchoice><guisubmenu>Archivo</guisubmenu><guimenuitem>Guardar como</guimenuitem></menuchoice> de la barra de menú. Aparecerá un diálogo <interface>Guardar como</interface> preguntándole por el nombre de archivo nuevo. Introduzca el nombre y pulse <guibutton>Guardar</guibutton>.</para>
      <note>
       <title>Sobreescribir archivo al guardar</title>
       <para>Cuando use <guimenuitem>Guardar como</guimenuitem> sobre un archivo ya existente, el original no se borra. Se deja sin cambiar desde la última vez que se guardó. Si un archivo con el nombre de archivo nuevo ya existe, aparecerá un diálogo de confirmación, para asegurar que quiere sobreescribirlo. Pulsar <guibutton>Sí</guibutton> sobreescribirá el archivo con el archivo que está guardando.</para>
      </note>
     </listitem>
     
     <listitem>
      <para><emphasis>Cerrar un archivo:</emphasis> para cerrar un archivo, elija <menuchoice><guisubmenu>Archivo</guisubmenu><guimenuitem>Cerrar</guimenuitem></menuchoice> de la barra de menú, o pulse el botón <guibutton>Cerrar</guibutton> de la barra de herramientas. (El archivo también se puede cerrar pulsando sobre la X en la solapa del nombre del archivo.) Esto cerrará el archivo actual. Si el archivo no está guardado o es un archivo nuevo, entonces <application>Anjuta</application> le preguntará si quiere guardar el archivo antes de cerrarlo.</para>
     </listitem> 
    </orderedlist>
   </para>
  </sect1>
 
 <!-- ============= File operations: Editing files === -->
  <sect1 id="editing-files">
   <title>Editar archivos</title>
   <para><application>Anjuta</application> posee cierto número de características de ayuda para la edición y el trabajo con archivos de código fuente. Las siguientes secciones describen cómo usar algunas de las interesantes características disponibles.</para>
   <sect2 id="editor-margins-sec">
   <title>Márgenes del editor</title>
      <para><emphasis>Márgenes del editor:</emphasis> los márgenes del editor son las pequeñas áreas en la parte izquierda del editor que sirven para algunos propósitos especiales. Existen tres márgenes de editor disponibles el <emphasis>margen del número de línea</emphasis>, el <emphasis>margen de marcadores</emphasis> y el <emphasis>margen de plegado del código</emphasis>. De forma predeterminada (esto es, cuando inicia <application>Anjuta</application> por primera vez) sólo el margen de plegado del código será visible. El resto se puede hacer visible desde el menú <menuchoice><guimenu>Ver</guimenu><guisubmenu>Editor</guisubmenu></menuchoice>. <figure id="editor-margins">
        <title>Márgenes del editor</title>
        <screenshot>
         <screeninfo>La barra de herramientas de etiquetas</screeninfo>
         <graphic fileref="figures/editor_margins.png" format="PNG" srccredit="naba"/>
        </screenshot>
       </figure></para>
       <para>El <emphasis>Margen de números de línea</emphasis> es el más grande de los tres márgenes (y ligeramente más oscuro que el resto) y muestra los números de línea del documento. El <emphasis>Margen de números de línea</emphasis> puede hacerse visible o invisible conmutando <menuchoice><guimenu>Ver</guimenu><guisubmenu>Editor</guisubmenu><guimenuitem>Margen de números de línea</guimenuitem></menuchoice>. Pulsando con el botón izquierdo sobre este margen seleccionará la línea entera (incluyendo. si está presente, la última línea nueva). Puede establecer las propiedades de la tipografía para el margen de los números de línea en las preferencias.</para>
	  <para>El <emphasis>Margen de marcadores</emphasis> se puede hacer mostrar u ocultar a través de <menuchoice><guimenu>Ver</guimenu><guisubmenu>Editor</guisubmenu><guimenuitem>Margen de marcadores</guimenuitem></menuchoice>. Este margen muestra iconos gráficos para marcar la línea dada. Los marcadores que se mostrarán en éste margen son los Marcadores (icono rectangular azul), los Puntos de parada (círculo rojo) y los Indicadores de línea (flecha amarilla). Los marcadores se usan para indicar líneas marcadas que se pueden cambiar desde <menuchoice><guimenu>Ir a</guimenu><guisubmenu>Marcador</guisubmenu><guimenuitem>Cambiar marcador</guimenuitem></menuchoice> con el cursor sobre esa línea. Un marcador de puntos de parada se usa en la depuración para marcar la línea con puntos de para de la depuración (consulte la sección de depuración para obtener más detalles). Un marcador de indicador se usa para indicar la posición actual del programa en el depurador.</para>
       <para>El <emphasis>Margen de plegado del código</emphasis> es donde el árbol de plegado es visible. Pulsando sobre esos nodos del árbol de plegado plegará o desplegará los bloques de código. Se dibujará un guión bajo debajo de la línea plegada para que sea más obvio que se ha plegado un bloque de código bajo la línea. Para obtener más detalles acerca del plegado de código, consulte la sección <emphasis>Plegado de código</emphasis> debajo.</para>
       <note>
       <title>Marcador de márgenes invisibles</title>
        <para>Si no se ve el margen del marcador, Anjuta mostrará los marcadores cambiando el color del fondo de la línea. Por ejemplo, si hay un marcador de punto de parada en una línea y el margen del marcador no se ve, esa línea se mostrará en un fondo rojo. De forma similar, para los marcadores y los marcadores indicadores de línea el color de fondo de la línea será azul cielo y amarillo respectivamente. Si no le gustan estos colores (quizá por el contraste entre ellos), active el <emphasis>Margen de marcadores</emphasis> desde <menuchoice><guimenu>Ver</guimenu><guisubmenu>Editor</guisubmenu><guimenuitem>Margen de marcadores</guimenuitem></menuchoice>. <figure id="editor-markers">
          <title>El editor marca cuando el margen del marcador es invisible</title>
          <screenshot>
           <screeninfo>La barra de herramientas de etiquetas</screeninfo>
           <graphic fileref="figures/editor_markers.png" format="PNG" srccredit="naba"/>
          </screenshot>
         </figure></para>
       </note>
      </sect2>
      <sect2 id="editor-guides-sec">
      <title>Guías del editor</title>
      <para>Se puede hacer que el editor cree cierta información del documento, que de otra manera no sería visible, incluyendo las <emphasis>guías de sangría</emphasis>, <emphasis>espacios en blanco</emphasis> y los <emphasis>caracteres de fin de línea</emphasis>. Se pueden hacer visibles o invisibles conmutando los elementos del menú en <menuchoice><guimenu>Ver</guimenu><guisubmenu>Editor</guisubmenu></menuchoice>. Las guías de sangría son las pequeñas líneas punteadas dibujadas para conectar las llaves coincidentes en el código fuente. Cuando el cursor está encima de uno de esas llaves coincidentes, las guías de sangría punteadas se resaltan para proporcionar una región visual del sangrado.</para>
       <figure id="editor-guides">
        <title>Editor con guías</title>
        <screenshot>
         <screeninfo>Editor con guías</screeninfo>
         <graphic fileref="figures/editor_guides.png" format="PNG" srccredit="naba"/>
        </screenshot>
      </figure>
    </sect2>
   <sect2 id="highlighting">
   <title>Resaltado de sintaxis</title>
   <para><application>Anjuta</application> puede resaltar la sintaxis muchos lenguajes diferentes. Esto generalmente se hace automáticamente determinando el tipo del archivo desde la extensión de archivo. Si <application>Anjuta</application> no puede determinar el tipo del archivo, entonces no habrá resaltado de sintaxis. Puede forzar un estilo de resaltado particular seleccionándolo del menú <menuchoice><guimenu>Ver</guimenu><guisubmenu>Editor</guisubmenu><guisubmenu>Modo de resaltado</guisubmenu></menuchoice>.</para>
    <note>
     <para>Anjuta usa un archivo de propiedades llamado <filename>$prefix/share/anjuta/properties/anjuta.properties</filename>, tiene el mismo formato que el archivo de propiedades SciTE pero no usa todas sus propiedades. El estilo de cada elemento para todos los idiomas está definido en un archivo llamado <filename>$prefix/share/anjuta/properties/styles.properties</filename>. Usa algunas propiedades comunes definidas por Anjuta en el archivo <filename>$home/.config/anjuta/scintilla/editor-style.properties</filename>.</para>
   </note>
   </sect2>
   <sect2 id="codefolding">
    <title>Plegado de código</title>
    <para>Anjuta puede mostrar <emphasis>plegados de código</emphasis> para archivos fuente en lenguajes estructurados por bloques (tales como C, C++, Pascal y Java). Todos los bloques de código en el archivo fuente se pueden plegar o desplegar pulsando en los puntos de plegado en el margen de plegado de la ventana del <interface>Editor</interface> (generalmente un símbolo +/- o unas flechas arriba/abajo). Estos puntos de plegado aparecen automáticamente para archivos fuente que usan bloques de código.</para>
    <para>El plegado de código es especialmente útil al editar archivos fuente grandes que se extienden varios miles de líneas. Una vez que se cierran los pliegues, el documento parece más pequeño, facilitando el examinado y la edición del archivo.</para>
    <note>
     <para>Note que el plegado del código y las guías del editor sólo están disponibles en el editor basado en Scintilla.</para>
	</note>
   </sect2>
   <sect2 id="autoformat">
    <title>Autoformatear el código fuente</title>
    <para>Anjuta pueda sangrar automáticamente (autoformatear) archivos C o C++ fuente o de cabecera. Ésto proporciona al código un aspecto limpio, aumentando su legibilidad, reduce la probabilidad de errores de sintaxis y, por encima de todo, ahorra tiempo. Para autoindentar el archivo fuente actual, elija <menuchoice><guimenu>Editar</guimenu><guimenuitem>Sangría automática</guimenuitem></menuchoice> en la barra de menú. Cambie el estilo del formateo personalizando las opciones en las preferencias.</para>
   </sect2>
  </sect1>

 <!-- ============= File operations: Browsing with the tags browser ===   -->
  <sect1 id="browsing-files">
   <title>Examinador de símbolos</title>
   <para>Puede examinar código C y C++ y archivos de cabecera usando <emphasis>etiquetas</emphasis> en los archivos. Una etiqueta (o <emphasis>símbolo</emphasis>) se refiere al nombre de una entidad, como la definición de una función, estructura o macro. Anjuta analiza código fuente en C y C++ para buscar las etiquetas disponibles.</para>
   <para><application>Anjuta</application> examinará las etiquetas en todos los fuentes y archivos de cabecera de un proyecto abierto. Puede ir a cualquier definición de función, definición de estructura, definición de clase o cualquier otra etiqueta sin tener que abrir manualmente el archivo. Ni siquiera necesita saber en qué archivo se encuentra la etiqueta. El examinador de símbolos lista todos los símbolos disponibles en el proyecto. <figure id="symbol-browser">
     <title>Examinador de símbolos</title>
     <screenshot>
      <screeninfo>Examinador de símbolos</screeninfo>
      <graphic fileref="figures/symbol_browser.png" format="PNG" srccredit="jhs"/>
     </screenshot>
    </figure></para>
   <tip>
    <title>Sincronización de etiquetas</title>
    <para>No tiene que preocuparse sobre la sincronización y actualización de la base de datos de las etiquetas. <application>Anjuta</application> se encargará de todo. Sólo tiene que decidir a qué etiqueta quiere ir.</para>
   </tip>
   
  </sect1>

  <!-- ============= File operations: Searching and replacing in files === -->
  <sect1 id="search-replace-files">
   <title>Buscar y reemplazar texto en los archivos</title>
    <sect2 id="searching">
    <title>Búsqueda</title>
      <para>Para buscar un <emphasis>texto</emphasis> o una <emphasis>expresión regular</emphasis> en el archivo actual, elija <menuchoice><guimenu>Editar</guimenu><guisubmenu>Buscar</guisubmenu><guimenuitem>Buscar...</guimenuitem></menuchoice> o pulse <keycombo><keycap>Alt</keycap><keycap>F</keycap></keycombo>. Esto abrirá el diálogo <interface>Buscar</interface>.</para>
      <para>Use la caja de texto para especificar la cadena para buscar y seleccione si es una cadena normal o una expresión regular (RegExp). También es posible especificar la dirección de la búsqueda, si la búsqueda es sensible a capitalización o no y el ámbito de búsqueda. Pulse <guibutton>Buscar</guibutton> para comenzar la búsqueda.</para>
      <para>Si la búsqueda es satisfactoria, Anjuta saltará al texto coincidente o realizará otra acción (dependiendo de la <guilabel>Acción de búsqueda</guilabel> que elija en la solapa <guilabel>Buscar objetivo</guilabel>). Si la búsqueda no es satisfactoria, Anjuta mostrará un mensaje indicando que no se encontró el texto de búsqueda.</para>
      <para>Si quiere buscar de nuevo, pulse el botón <guibutton>Buscar</guibutton> en la barra de herramientas principal o pulse <keycombo><keycap>Ctrl</keycap><keycap>G</keycap></keycombo>. Esto buscará la siguiente coincidencia (<keycombo><keycap>Mayús</keycap><keycap>Ctrl</keycap><keycap>G</keycap></keycombo> para la coincidencia anterior). Puede incluso cambiar el texto de búsqueda al hacer esto. Introduzca la cadena nueva en la caja de texto <guilabel>Expresión de búsqueda</guilabel> en la barra de herramientas principal.</para>
      <figure id="search-expr">
      <title>Diálogo de búsqueda de texto</title>
        <screenshot>
        <graphic fileref="figures/search_expr.png" format="PNG" srccredit="jhs"/>
        </screenshot>
      </figure>
	  <para>Para parar una búsqueda prolongada, pulse el botón <guibutton>Detener</guibutton>.</para>
    </sect2>
    <sect2 id="search-range">
    <title>Especificar el ámbito de búsqueda</title>
      <para>En la solapa <interface>Buscar objetivo</interface>, defina la ubicación de la búsqueda y la acción que realizar en caso de que la búsqueda tenga éxito.</para>
      <para>Puede definir el máximo número de acciones que realizar.</para>
      <figure id="search-target">
      <title>Diálogo Buscar objetivo</title>
        <screenshot>
        <graphic fileref="figures/search_target.png" format="PNG" srccredit="jhs"/>
        </screenshot>
      </figure>
      <para>Puede seleccionar qué texto se buscará.</para>
      <figure id="search-target-in">
      <title>Buscar en el objetivo elegido</title>
       <screenshot>
       <graphic fileref="figures/search_target_in.png" format="PNG" srccredit="jhs"/>
       </screenshot>
      </figure>
      <sect3 id="search-file">
      <title>Buscar en archivos</title>
       <para>Para buscar un texto en su proyecto, ajuste <guilabel>Buscar en</guilabel> Todos los archivos del proyecto.</para>
       <para>Introduzca en <guilabel>Buscar expresión</guilabel> el texto que quiere buscar y especifique las opciones de búsqueda, tales como <guilabel>Coincidir con capitalización</guilabel> o <guilabel>Coincidir con palabras completas</guilabel>. Pulse <guibutton>Buscar</guibutton> para comenzar la búsqueda.</para>
       <para>Para buscar texto en un conjunto de archivos, establezca <guilabel>Buscar en</guilabel> para especificar patrones de archivos. Defina las variables de búsqueda. Pulse <guibutton>Buscar</guibutton> para comenzar la búsqueda.</para>	 
         <figure id="search-file-pattern">
         <title>Buscar patrones de archivo</title>
          <screenshot>
          <graphic fileref="figures/search_file_pattern.png" format="PNG" srccredit="jhs"/>
          </screenshot>
       </figure>

      </sect3>		 

	</sect2>
    <sect2 id="search-action">
    <title>Especificar la acción de la búsqueda</title>
      <para>Puede seleccionar qué acción se realizará en caso de que la búsqueda tenga éxito.</para>
      <para>Dependiendo de las selecciones anteriores (<guilabel>Buscar en</guilabel>, <guilabel>Dirección de búsqueda</guilabel> y demás) algunas acciones pueden no estar disponibles.</para>
      <figure id="search-target-action">
      <title>Selección de búsqueda de acción de objetivo</title>
       <screenshot>
       <graphic fileref="figures/search_target_action.png" format="PNG" srccredit="jhs"/>
       </screenshot>
      </figure>
  
    </sect2>
    <sect2 id="replacing">
    <title>Reemplazar</title>
      <para>Buscar y reemplazar es similar a la búsqueda simple de texto, excepto que también especifica el texto de reemplazo en la caja de texto <guilabel>Reemplazar con</guilabel>, y si se debe preguntar antes de realizar la acción de reemplazar (Reemplazar la siguiente coincidencia o Reemplazar todas las coincidencias).</para>
      <figure id="replace">
      <title>Reemplazar</title>
        <screenshot>
        <graphic fileref="figures/search_replace.png" format="PNG" srccredit="jhs"/>
        </screenshot>
      </figure>
	  <para>Elija <guibutton>Reemplazar</guibutton> para reemplazar la cadena coincidente o <guibutton>Adelante</guibutton> para saltar al siguiente texto coincidente.</para>

	</sect2>
    <sect2 id="search-setting">
    <title>Ajustes de búsqueda</title>
      <para>También puede guardar las opciones de búsqueda.</para>
      <para>El elemento resaltado en rojo es el elemento activo. El elemento predeterminado es el ajuste de búsqueda que se carga al lanzar Anjuta.</para>
      <figure id="search-setting-fig">
      <title>Diálogo de ajustes de búsqueda</title>
        <screenshot>
        <graphic fileref="figures/search_setting.png" format="PNG" srccredit="jhs"/>
        </screenshot>
       </figure>
    </sect2>

  </sect1>

 <!-- ============= File operations: Printing Files === -->
   <sect1 id="printing">
    <title>Imprimir un archivo</title>
    <para>La vista previa de impresión se puede obtener seleccionando <menuchoice><guisubmenu>Archivo</guisubmenu><guimenuitem>Vista previa de impresión</guimenuitem></menuchoice>. Esto renderizará el archivo actual y presentará una vista previa de la impresión. Los códigos fuente que estén resaltados en el editor también se resaltarán de forma similar en la impresión (y en la impresión). Existen opciones adicionales para imprimir los números de línea, ajustar líneas y/o cabeceras en las preferencias de impresión del editor en la solapa <guilabel>Impresión</guilabel> de las preferencias del complemento del editor. <figure>
       <title>Vista preliminar de impresión de un archivo C</title>
       <screenshot>
       <screeninfo>Vista previa de impresión</screeninfo>
        <graphic fileref="figures/print_preview.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure></para> 
    <para>
	 <figure>
       <title>Preferencias de impresión</title>
       <screenshot>
	   <screeninfo>Preferencias de impresión</screeninfo>
        <graphic fileref="figures/prefs_print.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure>
	</para>
	<para>Cuando esté listo para imprimir y satisfecho con la vista previa, seleccione <menuchoice><guisubmenu>Archivo</guisubmenu><guimenuitem>Imprimir</guimenuitem></menuchoice> o <guibutton>Imprimir</guibutton> de la ventana de vista previa de impresión. Esto mostrará el diálogo de impresión actual tal y como se muestra debajo. Seleccione los parámetros de impresión adecuados e imprima el archivo con el botón <guibutton>Imprimir</guibutton>.</para>
	<para>Se puede ajustar la distribución horizontal o vertical, el tamaño del papel, la orientación del papel y el tipo de papel. Recuerde ajustarlo debidamente en concordancia con su impresora, de otra manera puede que no se imprima correctamente.</para>
	<para>
	 <figure>
       <title>Diálogo de impresión</title>
       <screenshot>
	   <screeninfo>Diálogo de impresión</screeninfo>
        <graphic fileref="figures/print_dlg.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure>
	</para>
   </sect1>
 </chapter>


 <!-- Project Management -->
 <!-- ============= Project management ====================== -->
 <chapter id="project-management">
  <title>Gestión de proyectos</title>
  
  <para>Anjuta tiene un potente complemento de Gestión de proyectos que puede abrir la mayoría de los proyectos basados en <ulink type="info" url="info:automake">automake/autoconf</ulink>. Puede que falle en algunos proyectos con configuración antigua, pero siempre que el proyecto esté realizado usando automake/autoconf de forma típica, entonces debería funcionar.</para>

  <para>Lo interesante de Anjuta es que no almacena ninguna información del proyecto aparte de la que ya está disponible en la estructura del proyecto. Esto es, no hay datos de proyecto separados y mantenidos por Anjuta, y todo el procesamiento de los proyectos se realiza directamente con la propia estructura del proyecto. Esto permite que el proyecto se mantenga o desarrolle fuera de Anjuta sin tener que realizar cambios al formato específico de Anjuta. Ya que técnicamente los proyectos en Anjuta son simplemente proyectos automake, se pueden desarrollar junto con otras plataformas, programas o herramientas sin ningún problema.</para>

  <sect1 id="new-project">
   <title>Crear un proyecto nuevo</title>
   <sect2 id="new-project-from-template">
   <title>Crear un proyecto nuevo desde una plantilla</title>
   <para>El complemento de asistente de proyecto usa un potente motor de procesado de plantillas llamado <application>autogen</application>. Todos los proyectos nuevos se crean desde plantillas escritas con sintaxis <application>autogen</application>. El asistente de proyectos le permite crear proyectos nuevos desde una selección de plantillas de proyectos. La selección incluye proyectos genéricos, planos (sin subdirectorios), GTK+, GNOME, Java, Python y muchos más. Se pueden descargar e instalar plantillas nuevas de forma sencilla ya que simplemente son una colección de archivos de texto.</para>

   <para>Para crear un proyecto nuevo, elija el elemento del menú <menuchoice><guisubmenu>Archivo</guisubmenu><guisubmenu>Nuevo</guisubmenu><guimenuitem>Proyecto...</guimenuitem></menuchoice> para iniciar el asistente. Lea la primera página cuidadosamente. Pulse en <guibutton>Siguiente</guibutton> para continuar.</para>
   <para>En la segunda página seleccione el tipo de aplicación que desea crear. Pulse <guibutton>Siguiente</guibutton> para continuar.</para>

   <para>Introduzca todos los detalles necesarios para su proyecto en las siguientes páginas. Puede cambiar estos ajustes posteriormente pero no es recomendable no prestarlos atención para mantener mejor la integridad del proyecto. En muchas de las cajas de entrada que seguirán (excepto la caja de <guilabel>Autor</guilabel>) no se permiten los espacios en blanco o cualquier carácter no alfanumérico, excepto el guión bajo (_) y el guión (-).</para>

   <para>También puede especificar si su proyecto tendrá <emphasis>soporte de internacionalización</emphasis> usando <application>gettext</application> (para obtener más detalles lea la <ulink type="info" url="info:gettext">página de información de gettext</ulink>). Esto le dará a su proyecto soporte multi-idioma para diferentes idiomas regionales tales como el español, el inglés, el francés, etc. El resto de las opciones son para ajustar si la nota de derechos de autor de GNU debe aparecer en los comentarios en la parte superior de cada archivo, y permitir la información de menú del escritorio GNOME si es necesario. El soporte de bibliotecas compartidas permite añadir módulos de bibliotecas compartidas en el proyecto posteriormente, Si está pensando tener bibliotecas en su proyecto, sería buena idea activarlo. Dependiendo del tipo de proyecto que se esté creando, se podría pedir otra información.</para>

   <para>El paso final es comprobar la información que acaba de proporcionar. Pulse <guibutton>Terminar</guibutton> para comenzar a generar el proyecto.</para>

   <para>Una vez que se ha generado el proyecto, puede probarlo construyéndolo y ejecutándolo.</para>
  </sect2>
   <sect2 id="importing-project">
    <title>Importar proyectos</title>
    <para>La característica de importación de proyectos se usa para importar un proyecto ya existente y convertirlo en un proyecto <application>Anjuta</application>. Active el asistente de importación de proyectos desde <menuchoice><guimenu>Archivo</guimenu><guimenu>Nuevo</guimenu><guimenuitem>Proyecto desde fuentes existentes</guimenuitem></menuchoice> y siga las instrucciones dictadas por el asistente. Una vez que el proyecto esté importado, se podrá abrir en <application>Anjuta</application> como cualquier otro proyecto de <application>Anjuta</application>.</para>
	<note>
	<para>La característica de importación de proyectos sólo funciona para proyectos existentes que usen<ulink type="info" url="info:automake">autoconf/automake</ulink> y para un número muy limitado de archivos planos Makefile.</para>
	</note>
   </sect2>
  </sect1>
  
  <sect1 id="load-save-projects">
   <title>Cargar y guardar proyectos</title>
   <sect2 id="loading-project">
    <title>Cargar proyectos</title>
    <para>Para abrir un proyecto elija el elemento del menú <menuchoice><guisubmenu>Archivo</guisubmenu><guimenuitem>Abrir...</guimenuitem></menuchoice>. Seleccione el archivo de proyecto (<filename>*.anjuta</filename>) en el diálogo y pulse <guibutton>Aceptar</guibutton>.</para> 

    <para>Si el proyecto se ha abierto recientemente, entonces lo encontrará listado en el menú <menuchoice><guisubmenu>Archivo</guisubmenu><guisubmenu>Recientes</guisubmenu></menuchoice>. Elija el archivo de proyecto de la lista y se abrirá el proyecto.</para>
    <para>Tan pronto como se abra el proyecto, <application>Anjuta</application> entrará en el <emphasis>Modo proyecto</emphasis>. Hay tres paneles en la ventana de proyecto. La primera es el panel del proyecto y lista los archivos de proyecto organizados por tipos de archivo. La segunda es el examinador de símbolos, que ya se ha discutido en la sección <emphasis>Examinador de símbolos</emphasis>. El tercer panel es la vista de archivo del proyecto y es más o menos similar a un gestor de archivos en miniatura. En la vista de archivo todos los archivos presentes en el árbol de proyecto son visibles. Al pulsar con el botón derecho del ratón sobre esos archivos aparecerá un menú contextual con las operaciones sobre archivos.</para>
    <para>Si el proyecto es un árbol CVS, entonces también se listarán los números de revisión de archivo correspondientes a la derecha de los nombres de archivo en el panel de vista de archivo.</para>
   </sect2>
   <sect2 id="saving-project">
    <title>Guardar proyectos</title>
    <para>El proyecto se guarda automáticamente al cerrar porque todos los cambios se realizan directamente en la estructura del proyecto.</para>
   </sect2>
  </sect1>

  <sect1 id="projects-structure">
  <title>Estructura del proyecto</title>
  <para>Aquí está la <interface>Ventana de proyecto</interface> con su menú contextual (accesible pulsando con el botón derecho del ratón). <figure id="project-window">
    <title>Ventana de proyecto</title>
    <screenshot>
     <screeninfo>La ventana de proyecto</screeninfo>
     <graphic fileref="figures/project-window.png" format="PNG" srccredit="jhs"/>
    </screenshot>
   </figure></para>
  <para>La <interface>Ventana de proyecto</interface> lista el proyecto en una jerarquía estándar de <ulink type="info" url="info:automake"><application>automake</application></ulink> organizada en <emphasis>grupos</emphasis> de <emphasis>objetivos</emphasis>. Los grupos corresponden con los directorios de su proyecto y los objetivos corresponden con objetivos <application>automake</application> normales (no confundir con objetivos de make). La <interface>Ventana de proyecto</interface> tiene dos partes; una parte (la inferior) muestra la jerarquía completa del proyecto y la otra parte (la superior) lista directamente objetivos importantes. Los objetivos importantes los constituyen los archivos ejecutables y las bibliotecas objetivo; haciéndolos muy accesibles desde la vista. Esto es particularmente útil en proyectos grandes donde la jerarquía puede ser muy profunda y difícil de navegar sólo desde el árbol. Los objetivos están compuestos de archivos de fuentes.</para>

  <para>
  <itemizedlist>
   <listitem>
    <para>Los <emphasis>grupos</emphasis> se usan para organizar lógicamente los objetivos. Un proyecto puede contener cualquier número de grupos. Cada grupo puede tener tanto subgrupos como objetivos. En proyectos automake, los grupos son sólo subdirectorios en el proyecto. El nivel superior del grupo se llama «raíz» y siempre es «/».</para>
   </listitem>
   <listitem>
    <para>Los <emphasis>objetivos</emphasis> son los objetivos de construcción en el proyecto, tales como los programas (binarios ejecutables), scripts, bibliotecas, datos misceláneos, etc. No todos los tipos de objetivos se construyen desde los fuentes, pero existen para organizar las fuentes y por ello puede que no existan físicamente (ej. un objetivo de datos misceláneos). Los objetivos existen bajo grupos. Consulte <link linkend="adding-target">Añadir objetivos</link> para ver una lista completa de los tipos de objetivos disponibles.</para>
   </listitem>
   <listitem>
    <para>Los <emphasis>Archivos fuente</emphasis> son los archivos usados para construir los objetivos o sólo son parte de ellos. Sólo existen bajo los objetivos. Muchos tipos de objetivos esperan cierto tipo de archivos fuente (ej. tipos de objetivo Programas y Bibliotecas), pero algunos pueden aceptar cualquier archivo (ej. los objetivos de Datos misceláneos).</para>
   </listitem>
  </itemizedlist>
  </para>

  <para>Cada uno de los grupos de proyecto y objetivos es configurable de una forma <application>automake</application> estándar. Puede ajustar las opciones del compilador y del enlazador directamente para cada objetivo, o ajustar variables de <application>configure</application>. Los grupos permiten establecer destinos de instalación para sus objetivos.</para>

  <para>Al igual que un gestor de archivos, la vista del gestor de proyectos también tiene acciones convenientes (accesibles desde el menú contextual) para los archivos de fuentes y objetivos.</para>

  <para>Muchas herramientas de la línea de comandos están disponibles para mantener y gestionar un proyecto y cada herramienta tiene sus reglas y capacidades específicas. <application>Anjuta</application> intenta automatizar la mayoría de las operaciones comunes usando complementos. No obstante, puede que ocasionalmente deba realizar algunas de ellas manualmente.</para>
  
  <para>Puede usar otras herramientas o editar los archivos de proyecto a mano simultáneamente. No importa si el proyecto está cargado en <application>Anjuta</application> o no, <application>Anjuta</application> se actualizará con cualquier cambio externo que se realice sobre el proyecto.</para>
  </sect1>
 
  <sect1 id="groups-and-targets">
   <title>Grupos y objetivos</title>

   <sect2 id="adding-groups">
    <title>Añadir grupos</title>
    <para>Para añadir un grupo nuevo (que es un directorio en proyectos basados en automake): <itemizedlist>
         <listitem>
           <para>Seleccione <menuchoice><guisubmenu>Proyecto</guisubmenu><guimenuitem>Añadir grupo</guimenuitem></menuchoice> y aparecerá un diálogo para añadir un grupo nuevo.</para>
         </listitem>
         <listitem>
           <para>Seleccione el grupo bajo el cuál quiere añadir el grupo nuevo.</para>
         </listitem>
         <listitem>
            <para>Seleccione el nombre del nuevo grupo y pulse <guibutton>Añadir</guibutton>.</para>
         </listitem>
        </itemizedlist></para>
     <para>Con proyectos en automake, se creará un directorio nuevo con el nombre proporcionado bajo el directorio padre del grupo.</para>
    <para>También puede añadir un grupo nuevo directamente desde la ventana de <interface>Proyecto</interface>. Pulse con el botón derecho del ratón en el grupo bajo el cual quiere añadir el grupo nuevo, después elija <guimenuitem>Añadir grupo</guimenuitem> del menú contextual.</para>
   </sect2>

   <sect2 id="removing-group">
    <title>Quitar grupos</title>
    <para>Para eliminar un grupo: <itemizedlist>
     <listitem>
       <para>Pulse con el botón derecho del ratón en el grupo en la vista del <interface>Gestor de proyectos</interface>.</para>
     </listitem>
     <listitem>
       <para>Seleccione <guimenuitem>Eliminar</guimenuitem> del menú contextual.</para>
     </listitem>
    </itemizedlist></para>
    <para>También se eliminarán del proyecto el objetivo y los fuentes asociados con el grupo. (Aunque no se borran del sistema de archivos. Aún podrá añadirlos posteriormente.)</para>
   </sect2>

   <sect2 id="adding-target">
    <title>Añadir objetivos</title>
    <para>Para añadir un objetivo nuevo: <itemizedlist>
      <listitem>
       <para>Seleccione <menuchoice><guisubmenu>Proyecto</guisubmenu><guimenuitem>Añadir objetivo</guimenuitem></menuchoice> y aparecerá un diálogo para añadir un objetivo nuevo.</para>
     </listitem>
     <listitem>
      <para>Seleccione el grupo bajo el cual quiere añadir el objetivo.</para>
     </listitem>
     <listitem>
      <para>Seleccione el tipo de objetivo.</para>
     </listitem>
     <listitem>
      <para>Introduzca un nombre para el objetivo nuevo y pulse <guibutton>Añadir</guibutton>.</para>
     </listitem>
    </itemizedlist></para>
    <para>También puede añadir un objetivo nuevo directamente desde la ventana de <interface>Proyecto</interface>. Pulse con el botón derecho del ratón en el grupo bajo el cual quiere añadir el objetivo, después elija <guimenuitem>Añadir objetivo</guimenuitem> del menú contextual.</para>
    <para>El nombre del objetivo generalmente requiere algunos prefijos y sufijos estándar, dependiendo del tipo de objetivo. Anjuta le advertirá si el nombre no es válido y puede proporcionarle un ejemplo de nombre.</para>
    <para>Existen varios tipos de objetivos para un proyecto automake. Éstos son: <itemizedlist>
     <listitem>
      <para>El tipo de objetivo <emphasis>Programa</emphasis> es para binarios ejecutables. Seleccione esto si quiere añadir un ejecutable al proyecto. De forma predeterminada todos los objetivos programa se instalarán en el directorio estándar para los ejecutables, ej. /usr/bin o /üsr/local/bin. Puede evitarlo especificando un directorio de instalación diferente en las propiedades del grupo.</para>
     </listitem>
     <listitem>
      <para>El tipo de objetivo <emphasis>Biblioteca compartida</emphasis> es para bibliotecas dinámicas o compartidas. Seleccione esto si está añadiendo una biblioteca compartida al proyecto. De forma predeterminada todas las bibliotecas compartidas se instalan en el directorio estándar para las bibliotecas compartidas, ej. /usr/lib o /usr/local/lib. Puede evitarlo especificando un directorio de instalación diferente en las propiedades del grupo.</para>
     </listitem>
     <listitem>
      <para>El tipo de objetivo <emphasis>Biblioteca estática</emphasis> es para bibliotecas estáticas. Seleccione esto si está añadiendo una biblioteca estática al proyecto. De forma predeterminada todas las bibliotecas estáticas se instalan en el directorio estándar para bibliotecas estáticas, ej. /usr/lib o /usr/lib/local. Puede evitarlo especificando un directorio de instalación diferente en las propiedades del grupo.</para>
     </listitem>
     <listitem>
      <para>El tipo de objetivo <emphasis>Módulo de Java</emphasis> es para el módulo de Java. Seleccione este tipo si está agrupando los fuentes de Java en un módulo. Debe proporcionar un directorio de instalación para este objetivo donde se instalarán los archivos .class. Se puede establecer en las propiedades de grupo del grupo al que pertenece este objetivo.</para>
      <note>
       <para>Sólo puede haber un módulo de Java en un grupo. Esta es una restricción de automake. Para obtener más detalles, lea las páginas de información de automake.</para>
      </note>
     </listitem>
     <listitem>
      <para>El tipo de objetivo <emphasis>Módulo de Python</emphasis> es para el módulo de Python. Seleccione esto si está agrupando los fuentes de Python en un módulo. Debe proporcionar un directorio de instalación para este objetivo donde se instalarán los archivos de fuentes. Se puede establecer en las propiedades de grupo del grupo al que pertenece este objetivo.</para>
     </listitem>
     <listitem>
      <para>El objetivo <emphasis>Scripts</emphasis> es para agrupar scripts. Se instalarán en el directorio estándar de los ejecutables.</para>
     </listitem>
     <listitem>
      <para>El tipo de objetivo <emphasis>Datos misceláneos</emphasis> es para agrupar archivos simples en el proyecto. Se debe especificar un directorio de instalación en las propiedades del grupo.</para>
     </listitem>
     <listitem>
      <para>El tipo de objetivo <emphasis>Archivos de cabecera</emphasis> es para agrupar los archivos de cabecera C/C++ que deben ser instalados en el sistema (por ejemplo como parte del API de una biblioteca). Para los archivos de cabeceras que no necesitan instalarse, hágalos parte del objetivo Programa junto con los fuentes. Se instalarán en el directorio «inlcude» estándar a no ser que la ruta de instalación esté especificada en sus propiedades de grupo.</para>
     </listitem>
     <listitem>
      <para>Los tipos de objetivo <emphasis>Documentación de man</emphasis> e <emphasis>Información de documentación</emphasis> son para agrupar la documentación de man y de la información respectivamente. De forma predeterminada se instalarán en los directorios estándar de instalación.</para>
     </listitem>
    </itemizedlist></para>
   </sect2>
   <sect2 id="removing-target">
    <title>Eliminar objetivos</title>
    <para>Para eliminar un objetivo: <itemizedlist>
       <listitem>
        <para>Pulse con el botón derecho del ratón en el objetivo en la vista del <interface>Gestor de proyectos</interface>.</para>
       </listitem>
       <listitem>
        <para>Seleccione <guimenuitem>Eliminar</guimenuitem> del menú contextual.</para>
       </listitem>
      </itemizedlist></para>
    <para>También se eliminarán del proyecto los fuentes asociados con los objetivos (aunque no se borran del sistema de archivos).</para>
   </sect2>
  </sect1>

  <sect1 id="adding-removing-sources">
   <title>Añadir y quitar archivos</title>
   <sect2 id="adding-sources">
    <title>Añadir archivos de fuentes</title>
    <para>Seleccione el elemento del menú <menuchoice><guisubmenu>Proyecto</guisubmenu><guimenuitem>Añadir archivo fuente</guimenuitem></menuchoice>. En el diálogo seleccione el objetivo al que se debería añadir el archivo y el archivo propiamente dicho. Puede añadir varios archivos de una vez. Para ello, seleccione múltiples archivos en el diálogo de selección usando la tecla <keycap>Mayús</keycap> o <keycap>Ctrl</keycap>. Después pulse el botón <guibutton>Añadir</guibutton> para añadir los archivos al proyecto.</para>
    <para>De forma predeterminada el editor de archivos estará preseleccionado para la adición en el diálogo. Otra forma conveniente de añadir un archivo es seleccionarlo en el <interface>Gestor de archivos</interface> y elegir <guimenuitem>Añadir al proyecto</guimenuitem> desde el menú contextual.</para>
    <para>Si el archivo que ha seleccionado ya se ha añadido al proyecto, entonces <application>Anjuta</application> no lo añadirá de nuevo. También le advertirá que el archivo ya se ha añadido.</para>
    <para>Si el archivo que ha elegido no está en el directorio del proyecto, se le pedirá una confirmación para copiar el archivo en el directorio del objetivo. <application>Anjuta</application> no puede añadir archivos que están fuera del directorio del objetivo.</para>
   </sect2>
   <sect2 id="removing-sources">
    <title>Eliminar archivos de fuentes</title>
    <para>Para eliminar un archivo del proyecto seleccione el archivo que quiere eliminar desde la <interface>Ventana de proyecto</interface> y elija <guimenuitem>Eliminar</guimenuitem> del menú contextual.</para>
    <para>Aparecerá un diálogo de confirmación y se eliminará el archivo del proyecto.</para>
    <important>
     <title>El archivo no se borra.</title>
     <para>El archivo no se borra del sistema de archivos. Sigue existiendo y puede añadirlo de nuevo posteriormente. El archivo sólo se elimina de la lista del proyecto y no se tendrá en cuenta para ninguna de las operaciones del proyecto tales como la compilación, construcción o distribución.</para>
     </important>
   </sect2>
  </sect1>
  
  <sect1 id="project-config">
   <title>Configurar un proyecto</title>
   <para>La configuración de un proyecto incluye ajustar las opciones de compilación correctas para los objetivos, grupos y para el proyecto en si. Puede establecer estas opciones en sus respectivos diálogos de propiedades.</para>

   <para>Puede usar libremente las variables de autoconf y automake que se ajustan automáticamente para el proyecto durante la configuración. Aparte de las variables ajustadas automáticamente, también puede definir sus propias variables en las <link linkend="project-properties">Propiedades del proyecto</link> y usarlas en las propiedades. Esto hará más sencilla la actualización de las opciones posteriormente, especialmente cuando la variable se usa en diversos objetivos.</para>

   <para>Algunas de las variables más comunes están listadas aquí. Para ver la lista completa consulte <ulink url="info:automake">documentación de información de automake</ulink>. <itemizedlist>
      <listitem>
       <para><emphasis>$(prefix)</emphasis>: El prefijo de instalación. El proyecto se instala en varios subdirectorios bajo este prefijo. De forma predeterminada es /usr/local.</para>
      </listitem>
      <listitem>
       <para><emphasis>($bindir)</emphasis>: El directorio de instalación de los binarios ejecutables. Todos sus objetivos ejecutables y los scripts se instarán en este directorio. De forma predeterminada es $(prefix)/bin.</para>
      </listitem>
      <listitem>
       <para><emphasis>$(libdir)</emphasis>: El directorio de instalación para las bibliotecas. Todas las bibliotecas de sus objetivos (las compartidas y las estáticas) se instalarán en este directorio o un subdirectorio bajo él. De forma predeterminada es $(prefix)/lib.</para>
      </listitem>
      <listitem>
       <para><emphasis>$(module_CFLAGS)</emphasis> y $(module_LIBS): Estas opciones las establece <application>configure</application> para los paquetes de los que su proyecto depende. Los paquetes que usa el proyecto se establecen en las <link linkend="project-properties">Propiedades del proyecto</link>. «module» es grupo de paquetes que proporciona en las propiedades del proyecto.</para>
      </listitem>
     </itemizedlist></para>


   <sect2 id="project-properties">
    <title>Propiedades del proyecto</title>
    <para>El diálogo de propiedades del proyecto sólo se puede obtener eligiendo <menuchoice><guisubmenu>Proyecto</guisubmenu><guimenuitem>Propiedades</guimenuitem></menuchoice> de la barra de menú de nivel superior. Puede: <itemizedlist>
     <listitem>
      <para>Establezca el nombre del proyecto, la versión y el URL en la página <guibutton>General</guibutton>. Las variables de <application>configure</application> también se pueden usar en estos campos. El URL es la página donde se han de enviar los informes de error del proyecto.</para>
     </listitem>
     <listitem>
      <para>Añada y elimine dependencias para su proyecto en la página <guibutton>Paquetes</guibutton>. Consulte más abajo para obtener más detalles.</para>
     </listitem>
     <listitem>
      <para>Cree más variables de configuración en la página <guibutton>Variables</guibutton> para usarlas en las propiedades de grupo y objetivo.</para>
     </listitem>
    </itemizedlist></para>
    <para>Las dependencias son paquetes externos que usa el proyecto y que son necesarios para construirlo. Sólo los paquetes instalados usando <ulink url="info:pkg-config">pkg-config</ulink> se pueden añadir desde esta interfaz. Para otros, se puede editar manualmente el archivo configure.ac para los demás. <figure>
       <title>Diálogo Propiedades del proyecto</title>
       <screenshot>
	   <screeninfo>Diálogo Propiedades del proyecto</screeninfo>
        <graphic fileref="figures/project_info.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure></para>
   <para>Las dependencias de paquetes externos se agrupan en <emphasis>módulos</emphasis>, de tal forma que sus opciones de construcción combinadas se pueden añadir convenientemente a diferentes objetivos. Los <emphasis>módulos</emphasis> simplemente son nombres arbitrarios dados a los grupos de paquetes y se pueden llamar de cualquier forma (sólo se permiten caracteres alfanuméricos y guión bajo «_» en el nombre del módulo). Generalmente siguen el nombre de los objetivos en los que se usarán. Consecuentemente, para proyectos pequeños con un solo objetivo solamente un módulo es suficiente para mantener todas las dependencias.</para>
   <para>Cada paquete exporta un conjunto de <emphasis>opciones de compilación</emphasis> y <emphasis>bibliotecas</emphasis>. Se añaden todas juntas para todos los paquetes bajo un módulo y se definen las variables de configuración <emphasis>$(module_CFLAGS)</emphasis> y <emphasis>$(module_LIBS)</emphasis>. Éstas variables se pueden usar en las <link linkend="group-properties">Propiedades del grupo</link> y las <link linkend="target-properties">Propiedades del objetivo</link>.</para>
   <para>Para añadir una dependencia de un paquete: <itemizedlist>
     <listitem>
      <para>Seleccione <menuchoice><guisubmenu>Proyecto</guisubmenu><guimenuitem>Propiedades</guimenuitem></menuchoice> para mostrar el diálogo de propiedades del proyecto.</para>
     </listitem>
     <listitem>
      <para>Seleccione la solapa <guibutton>Paquetes</guibutton> para mostrar la página de los paquetes.</para>
     </listitem>
     <listitem>
      <para>Seleccione el <emphasis>módulo</emphasis> para añadir al paquete. Si no hay ningún módulo creado o no hay un módulo apropiado, cree uno pulsando <guibutton>Añadir módulo</guibutton>. Proporcione un nombre al módulo, preferiblemente en LETRAS MAYÚSCULAS (se distinguen mayúsculas y minúsculas) para que coincida con el resto de las variables de <application>configure</application> (use caracteres alfanuméricos y el guión bajo «_» exclusivamente) y pulse <keycap>Intro</keycap> para crearlo.</para>
     </listitem>
     <listitem>
      <para>Pulse <guibutton>Añadir paquete</guibutton> para mostrar el diálogo de selección de paquetes.</para>
     </listitem>
     <listitem>
      <para>Seleccione el paquete para añadir y pulse <guibutton>Añadir</guibutton>.</para>
     </listitem>
     <listitem>
      <para>Pulse <guibutton>Cerrar</guibutton> para cerrar el diálogo de propiedades.</para>
     </listitem>
    </itemizedlist></para>
   </sect2>

   <sect2 id="group-properties">
    <title>Propiedades del grupo</title>
    <para>Para establecer propiedades del grupo, pulse dos veces en el grupo en la ventana <interface>Proyecto</interface> para abrir el diálogo <interface>Propiedades de grupo</interface>. (Alternativamente puede pulsar con el botón derecho del ratón sobre el grupo y seleccionar <guimenuitem>Propiedades</guimenuitem> del menú contextual). <figure>
       <title>Diálogo Propiedades del grupo</title>
       <screenshot>
	   <screeninfo>Diálogo Propiedades del grupo</screeninfo>
        <graphic fileref="figures/project_group.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure></para>

    <para>Las propiedades establecidas para un grupo se aplican a todos los objetivos bajo él. De tal forma que cualquier opción del compilador o enlazador aquí establecidas serán automáticamente parte de todos los objetivos en él (además de las propiedades individuales del objetivo). Las siguientes opciones están disponibles en las Propiedades de grupo. <itemizedlist>
		    <listitem>
		     <para><emphasis>Inclusiones</emphasis>: establezca sus directorios de inclusión para sus objetivos C y C++. Aquí debe proporcionar las opciones completas de inclusión del compilador, ej. -I/usr/include/blah. Las rutas de inclusión se usarán para buscar los archivos de inclusión en sus archivos de fuentes. Aquí también puede añadir otras opciones del compilador, pero es preferible establecerlas en sus respectivas propiedades de <emphasis>opciones del compilador</emphasis> (ver más abajo).</para>
           </listitem>
		    <listitem>
		     <para><emphasis>Ajustes del compilador</emphasis>: establezca aquí las opciones específicas del compilador. Existen campos diferentes para las distintas categorías del compilador. Las opciones que se pueden establecer dependen del compilador usado actualmente. El compilador predeterminado para C/C++ es gcc/g++ (el compilador GNU de C). Para obtener más detalles consulte la <ulink url="info:gcc">información de documentación de gcc</ulink>.</para>
           </listitem>
		    <listitem>
		     <para><emphasis>Directorios de instalación</emphasis>: los objetivos del grupo que requieren directorios de instalación obtendrán un campo para introducir el directorio de instalación. De tal forma que sus directorios de instalación son relativos a una de las muchas variables de directorio de <application>automake</application>, tales como $(prefix), $(bindir), $(libdir), $(datadir), etc.</para>
           </listitem>
          </itemizedlist></para>
   </sect2>

   <sect2 id="target-properties">
    <title>Propiedades del destino</title>
    <para>Cualquier propiedad establecida para un objetivo se aplica sólo sobre ese objetivo. Un objetivo también hereda las propiedades del grupo que lo contiene.</para>
	  <para>Para establecer las propiedades del objetivo, pulse dos veces el objetivo en la <interface>Ventana de proyecto</interface> para abrir el diálogo Propiedades del objetivo. (También puede acceder al menú pulsando con el botón secundario del ratón y seleccionando <guimenuitem>Propiedades</guimenuitem> del menú contextual). <figure>
       <title>Diálogo Propiedades del objetivo</title>
       <screenshot>
	   <screeninfo>Diálogo Propiedades del objetivo</screeninfo>
        <graphic fileref="figures/project_target.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure></para>
    <para>Aquí puede añadir los módulos que ha añadido en las <link linkend="project-properties">Propiedades del proyecto</link> a un objetivo específico. Para activar el módulo simplemente conmute la caja de verificación junto al nombre del módulo. Esto añadirá automáticamente opciones de inclusión y enlazado sobre ese objetivo y le permitirá usar el módulo en ese objetivo.</para>
    <sect3 id="target-advanced">
    <title>Opciones avanzadas del objetivo</title>
    <para>Los siguientes campos están disponibles en la configuración avanzada del objetivo, a la que se llega pulsando el botón <guibutton>Avanzadas...</guibutton> en el diálogo de propiedades del objetivo.</para>
    <para>
    <figure>
       <title>Diálogo Propiedades del objetivo</title>
       <screenshot>
	   <screeninfo>Diálogo Propiedades del objetivo</screeninfo>
        <graphic fileref="figures/project_target_details.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure>
		   <itemizedlist>
		    <listitem>
		     <para><emphasis>Ajustes del compilador</emphasis>: establezca aquí las opciones específicas del compilador. Existen campos diferentes para las distintas categorías del compilador. Las opciones que se pueden establecer dependen del compilador usado actualmente. El compilador predeterminado para C/C++ es gcc/g++ (el compilador GNU de C). Para obtener más detalles consulte la <ulink url="info:gcc">información de documentación de gcc</ulink>.</para>
            </listitem>
		    <listitem>
		     <para><emphasis>Opciones del enlazador:</emphasis> Establezca las opciones del enlazador que se usarán al enlazar el objetivo. Se aplica sólo a objetivos tipo programa y biblioteca. Consulte <ulink url="info:ld">documentación de ld</ulink> para ver las opciones disponibles del enlazador.</para>
            </listitem>
		    <listitem>
		     <para><emphasis>Bibliotecas</emphasis>: Establece las bibliotecas de las que depende el objetivo.</para>
           </listitem>
          </itemizedlist>

    </para>
    </sect3>
   </sect2>
  </sect1>
  
 </chapter>

 <!-- Build -->
 <!-- ============= Build ====================== -->
 <chapter id="building">
  <title>Construir</title>
  <para>Anjuta gestiona proyectos de <application>autotools</application>. Es capaz de gestionar otros tipos de proyectos como los escritos para Makefile pero la interfaz actual de construcción está pensada para proyectos de autotools. Es útil tener cierto conocimiento acerca de ellos para entender mejor cómo se construye un proyecto.</para>
  <para>Un proyecto de autotools se construye en tres pasos:</para>
  <para>
     <orderedlist>
      <listitem><para>Generar</para></listitem>
      <listitem><para>Configurar</para></listitem>
      <listitem><para>Construir</para></listitem>
     </orderedlist>
  </para>
  <para><emphasis>Construir</emphasis> es el paso principal en el que se generan todos los archivos objeto del código fuente. Se puede dividir en dos subfases: <emphasis>Compilar</emphasis> y <emphasis>Enlazar</emphasis>. En la fase <emphasis>Compilar</emphasis> se genera cada archivo objeto de su correspondiente archivo fuente. Por ejemplo, un archivo fuente <filename>hola.c</filename> generará <filename>hola.o</filename> después de compilarlo. Generalmente no tiene que preocuparse por estos archivos; simplemente piense en ellos como archivos intermedios. En la fase <emphasis>Enlazar</emphasis> se enlazan todos los archivos objetos y bibliotecas juntos para crear el ejecutable final. Algunos lenguajes de programación no necesitan la fase <emphasis>Compilar</emphasis> y <emphasis>Enlazar</emphasis>. Además, el paso <emphasis>Construir</emphasis> se usa para generar otros archivos, como la documentación que no necesita tales fases.</para>
  <para><emphasis>Configurar</emphasis> es el paso en el que se ajusta el árbol de los fuentes a su sistema. Los proyectos de <application>autotools</application> se pueden construir en una gran variedad de sistemas usando diferentes compiladores y usando diferentes funciones de bibliotecas. Este paso ejecuta el script <filename>configure</filename> que comprobará varias características de su sistema y creará algunos de los archivos necesarios para realizar la construcción (tales como <filename>Makefile</filename> y <filename>config.h</filename>). Este paso también se usa para seleccionar opciones de construcción, por ejemplo, desactivar la optimización para hacer más fácil la depuración o desactivar alguna parte experimental de un programa.</para>
  <para><emphasis>Generar</emphasis> es el paso en el que se crea el script <filename>configure</filename> y otros archivos relacionados. El script <filename>configure</filename> se usa para ejecutar varias comprobaciones del sistema sobre muchos elementos. Es muy difícil escribirlo a mano. Es más, el conjunto de <application>autotools</application> tiene unas reglas para organizar un proyecto, como algunos archivos obligatorios: <filename>NEWS</filename> o <filename>COPYING</filename>. Incluye varias herramientas para crear todos los archivos necesarios desde archivos más simples escritos por el desarrollador tales como <filename>configure.in</filename> (o <filename>configure.ac</filename>) y <filename>Makefile.am</filename>. Todas estas herramientas se ejecutan comúnmente en el directorio del proyecto desde el script <filename>autogen.sh</filename>. Este paso es útil sólo para un desarrollador (alguien que modifique los archivos fuente), ya que el script <filename>configure</filename> sólo depende de los archivos fuente, se distribuye con el paquete del proyecto. Note que los archivos makefile creados por configure incluyen algunas reglas para regenerar el proyecto automáticamente cuando sea necesario, de tal forma que no es necesario ejecutarlo directamente muy a menudo.</para>
 <para>Para obtener más detalles acerca de cómo funcionan éstas herramientas, lea las páginas de información acerca de <ulink type="info" url="info:automake"><application>automake</application></ulink> y <ulink type="info" url="info:autoconf"><application>autoconf</application></ulink>.</para>


 <!-- Build: Generate and Configure -->

 <sect1 id="build-configure">
  <title>Generar y configurar</title>
  <sect2 id="configure">
   <title>Configurar un proyecto</title>
   <para>Debe ejecutar este script antes de poder construir su proyecto. Esto generalmente se ejecuta una sola vez en el comienzo del primer proceso de construcción; por ejemplo, justo después de extraer el tarball de los fuentes del proyecto de una distribución. Después de eso, la configuración se gestiona automáticamente por los procesos de construcción subsecuentes. Si ha usado el <emphasis>Asistente de configuración</emphasis> para crear la aplicación, entonces no necesitará ejecutarlo de forma separada: el asistente lo ejecutará como parte del proceso de generación del proyecto.</para>
   <para>No existe ningún requerimiento para ejecutarlo una sola vez. Se puede ejecutar en cualquier momento, generalmente cuando se necesitan cambiar las opciones de configuración. Algo que notar es que si el archivo <filename>config.h</filename> del directorio del nivel superior se cambia, ejecutar <filename>configure</filename> de nuevo no lo sobreescribirá.</para>
   <para>Tanto los pasos de generación como de configuración se lanzan con un sólo elemento del menú: <menuchoice><guisubmenu>Construir</guisubmenu><guimenuitem>Configurar el proyecto...</guimenuitem></menuchoice>. Este elemento del menú muestra un diálogo donde puede escoger: <itemizedlist>
     <listitem><para>Indica si quiere ejecutar el paso de generación o no</para>
      <para>Debe ejecutarse una vez al comienzo del proyecto, después se gestiona automáticamente por el proceso de construcción. Puede forzar su ejecución seleccionando la casilla de verificación <interface>Regenerar el proyecto</interface> en caso de que encuentre alguna dificultad al construir los proyectos (ej. si obtiene errores de construcción después de modificar muchos archivos de construcción).</para>
     </listitem>
     <listitem><para>El nombre de configuración</para>
      <para>Este nombre se usa para referirse a cada configuración. Algunas configuraciones (Predeterminada, Depuración, Optimizada) ya están definidas de forma predeterminada. Una configuración incluye un directorio de construcción y algunas opciones de configuración.</para>
     </listitem>
     <listitem><para>El directorio de construcción</para>
      <para>Éste es el nombre del directorio de construcción. En la configuración predeterminada es el mismo directorio que el directorio de fuentes pero autotools soporta la construcción en un directorio distinto.</para> 
      <note><para>Cada configuración debe tener un directorio de construcción diferente y si una configuración usa el directorio fuente, entonces no puede tener otras configuraciones al mismo tiempo. Debe ejecutar <menuchoice><guisubmenu>Construir</guisubmenu><guimenuitem>Quitar configuración</guimenuitem></menuchoice> en las otras configuraciones que usen el directorio fuente antes de añadir una configuración nueva.</para></note>
     </listitem>
     <listitem><para>Opciones de configuración</para>
      <para>Estas opciones se pasan al script <filename>configure</filename>. Algunas son prefijos estándar, tales como --prefix y CFLAGS; otras dependen del proyecto. Puede obtener una lista completa de las opciones de configuración permitidas ejecutando el script <filename>configure</filename> con el argumento --help.</para>
     </listitem>
    </itemizedlist></para>
  </sect2>
  <sect2 id="select-configure">
   <title>Seleccionar una configuración</title>
   <para>Si creó diferentes configuraciones puede seleccionar cuál es la activa seleccionándolo en <menuchoice><guisubmenu>Construir</guisubmenu><guimenuitem>Seleccionar configuración</guimenuitem></menuchoice>.</para>
  </sect2>
  <sect2 id="clean-configure">
   <title>Limpiar la configuración</title>
   <para>Para limpiar un proyecto y dejarlo en un estado que requiera volver al paso de configuración debe elegir <menuchoice><guisubmenu>Construir</guisubmenu><guimenuitem>Eliminar configuración</guimenuitem></menuchoice>. Ejecutará <command>make distclean</command> y borra más archivos que <guimenuitem>Limpiar proyecto</guimenuitem>. En otras palabras, deja el proyecto como si se acabase de extraer del paquete tarball de la distribución. Note que no quita el directorio de configuración en sí, pero puede hacerlo usted mismo.</para>
  </sect2>
 </sect1>


 <!-- Build: Compile and Build -->

 <sect1 id="build-compile-and-build">
  <title>Compilar y construir</title>
  <sect2 id="build-compile">
   <title>Compilar un archivo</title>
   <para>En un proyecto los archivos fuente individuales se pueden compilar separadamente en objetos (archivos <filename>*.o</filename>). Aunque no debe preocuparse por esos archivos objeto, a veces es útil compilar un archivo primero (por ejemplo, para asegurarse de que no hay errores de sintaxis). Compilar un proyecto entero puede llevar mucho tiempo, especialmente en el caso de aplicaciones grandes y complejas. Por ello probablemente pasará por series ciclos de edición-compilación mientras esté desarrollando el proyecto.</para>
   <para>Para compilar un archivo elija el elemento del menú <menuchoice><guisubmenu>Construcción</guisubmenu><guimenuitem>Compilar</guimenuitem></menuchoice> o pulse <keycap>F11</keycap>. Esto compilará el archivo activo.</para>
  </sect2>

  <sect2 id="build-build">
   <title>Construir un ejecutable</title>
   <para><application>Anjuta</application> no tiene línea de comandos separada, simplemente porque no es necesario. El proceso de construcción compilará todos los archivos fuente y los enlazará junto a las bibliotecas. El comando de construcción no recompilará aquellos archivos que ya están actualizados (esto es la <emphasis>comprobación de dependencias</emphasis>). Si ya ha compilado todos los archivos individualmente, entonces la única tarea que el proceso de construcción realizará es el enlazado. Si ya ha construido el proyecto y no se ha modificado ningún archivo dependiente, también se evitará el proceso de enlazado.</para>
   <para>¿Entonces cómo influye la comprobación de las dependencias en el desarrollo del proyecto? Si ha modificado un archivo, entonces todos los archivos de fuentes que dependen del archivo modificado se recompilan. Durante el proceso de construcción se comprueban todos los archivos (no sólo los archivos objeto y el ejecutable) para estas dependencias. Si se encuentra que un archivo en particular depende de algún otro archivo que se ha modificado, entonces ese archivo se regenerará.</para>
   <para>Ya que ahora ha entendido el valor de las comprobaciones de las dependencias, ¿puede imaginarse cómo sería su vida (de programador) si no estuviese allí? Si aún no puede responder, entonces lo descubrirá cuando comience a desarrollar proyectos.</para>
   <para><menuchoice><guisubmenu>Construir</guisubmenu><guimenuitem>Construir</guimenuitem></menuchoice> construirá todos los archivos en el directorio del archivo  activo.</para>
   <para><menuchoice><guisubmenu>Construir</guisubmenu><guimenuitem>Construir proyecto</guimenuitem></menuchoice> construirá el proyecto entero; se construyen todos los directorios recursivamente.</para>
  </sect2>
 </sect1>


 <!-- Build: Other operations -->

 <sect1 id="build-other">
  <title>Otras operaciones</title>
  <sect2 id="build-dist">
   <title>Crear un paquete de distribución</title>
   <para>Para construir la distribución tarball del proyecto, elija <menuchoice><guisubmenu>Construir</guisubmenu><guimenuitem>Construir tarball</guimenuitem></menuchoice>. Esto creará el tarball (<filename>*.tar.gz</filename>) y lo pondrá en el nivel superior del directorio del proyecto. Copie el archivo a un lugar seguro para su distribución.</para>
  </sect2>
  <sect2 id="build-install">
   <title>Instalar un proyecto</title>
   <para>Eligiendo el elemento del menú <menuchoice><guisubmenu>Construir</guisubmenu><guimenuitem>Instalar</guimenuitem></menuchoice> instalará la aplicación generada en su sistema.</para>
   <note>
    <title>Instalación amplia en el sistema</title>
    <para>Debe haber iniciado sesión como «root» para realizar una instalación amplia en el sistema. También note que para que una aplicación de GNOME use los pixmaps en el proyecto, debe estar instalado como una aplicación amplia en el sistema. De otra forma, cuando la aplicación se ejecute en su proyecto, habrá muchos errores  «pixmap no encontrado». Puede configurar Anjuta para que use <command>sudo</command> o <command>su</command> antes de instalar el proyecto, en las preferencias de construcción.</para>
   </note>
  </sect2>
  <sect2 id="build-clean">
   <title>Limpiar</title>
   <para>Borra todos los archivos generados por el proceso, incluyendo los archivos objeto (archivos <filename>*.o</filename>) y los ejecutables. Se puede aplicar sobre un directorio o sobre el proyecto entero.</para>
   <para>Elija el elemento del menú <menuchoice><guisubmenu>Construir</guisubmenu><guimenuitem>Limpiar proyecto</guimenuitem></menuchoice> para limpiar todos los archivos del proyecto.</para>
   <para>Elija el elemento del menú <menuchoice><guisubmenu>Construir</guisubmenu><guimenuitem>Limpiar</guimenuitem></menuchoice> para limpiar sólo el directorio del actual archivo activo.</para>
  </sect2>

 </sect1>

</chapter>

 <!-- Debugging -->
 <!-- ============= Debugging ====================== -->
 <chapter id="debugging">
  <title>Depurar</title>
  <para>
   <emphasis>Depurar es de humanos, reparar es divino...</emphasis>
  </para>
  <para>Bien, la parte <emphasis>humana</emphasis> es de lo que trata esta sección. ¡La parte <emphasis>divina</emphasis> es cosa suya!</para>
  <para>Cuando un programa no se comporta de la forma que se supone que debería, se dice que el programa tiene errores o <emphasis>bugs</emphasis>. Esto no se refiere a errores de compilación —esos son simplemente errores y son relativamente fáciles de eliminar, porque el compilador proporciona información acerca de dónde están. Por otra parte, los «bugs» son errores que suceden durante la ejecución del programa y que pueden ser muy difíciles de detectar.</para>
  <para>Cualquier programa que piense que no tiene errores realmente nunca está libre de ellos. Todo lo que se puede hacer es tratar de reducir los errores al mínimo. El proceso de eliminar errores se conoce como <emphasis>depuración</emphasis>. <emphasis>Anjuta</emphasis> proporciona un entorno de depuración muy potente y amigable (realmente es un envoltorio IGU sobre <application>gdb</application>, una herramienta de la línea de comandos para depurar que es estándar en GNU/Linux).</para>
  <para>El depurador sigue y traza la ejecución de un programa y proporciona varias vistas de información necesarias para estudiar la ejecución del programa.</para>

 <!-- Debugger: Start and stop -->

 <sect1 id="debugger-session">
  <title>Iniciar y parar</title>

  <para>El depurador siempre se inicia con un programa cargado. Hay dos formas de hacerlo: <itemizedlist>
    <listitem><para><emphasis>Ejecutar un ejecutable</emphasis></para></listitem>
    <listitem><para><emphasis>Acoplar un proceso</emphasis></para></listitem>
   </itemizedlist><note>
    <para>Prácticamente todas las características de Anjuta las proporcionan los complementos. Si no ve los menús descritos aquí es probable que el complemento del depurador no esté cargado. Vaya a <menuchoice><guisubmenu>Editar</guisubmenu><guimenuitem>Preferencias</guimenuitem><guimenuitem>General</guimenuitem><guimenuitem>Complementos instalados</guimenuitem></menuchoice> y compruebe que el complemento del depurador está instalado. Es un complemento activable por el usuario, de tal forma que se carga o descarga bajo petición.</para>
   </note></para>

  <sect2 id="debug-run">
   <title>Ejecutar un ejecutable</title>
   <para>Ejecutar un programa con o sin el depurador se hace desde el mismo menú, seleccione <menuchoice><guisubmenu>Ejecutar</guisubmenu><guimenuitem>Ejecutar programa</guimenuitem></menuchoice> para ejecutar un programa sin el depurador y <menuchoice><guisubmenu>Ejecutar</guisubmenu><guimenuitem>Depurar programa</guimenuitem></menuchoice> para ejecutarlo con el depurador.</para>
   <note>
    <para>Para hacer un mejor uso del depurador, se recomienda encarecidamente que construya el programa con la información de depuración (-g para gcc) y sin optimización (-O0 para gcc). Esto se puede realizar seleccionando la configuración de depuración antes de construir el programa por primera vez.</para>
   </note>
   <para>Puede seleccionar qué programa ejecutar y su entorno usando <menuchoice><guisubmenu>Ejecutar</guisubmenu><guimenuitem>Parámetros del programa…</guimenuitem></menuchoice>. Puede escoger: <itemizedlist>
     <listitem><para>El programa que quiere depurar</para>
      <para>El menú desplegable de la caja de combinación desplegable del objetivo ya está rellenada con todos los ejecutables del proyecto actual. Pero puede seleccionar otro ejecutable que no forme parte del proyecto. El depurador acepta ejecutables de libtool, es decir scripts generados por libtool, que envuelven al ejecutable real.</para>
     </listitem>
     <listitem><para>Los parámetros de la línea de comandos</para></listitem>
     <listitem><para>El directorio de trabajo</para></listitem>
     <listitem><para>Variables de entorno</para>
      <para>Las variables de entorno en gris claro son las variables de entorno actuales. Aquí puede añadir, modificar o quitar las variables de entorno.</para>
      <tip><para>Para depurar Anjuta usando Anjuta puede usar un tema diferente para reconocer inmediatamente la instancia en depuración añadiendo, por ejemplo puede añadir «GTK2_RC_FILES=/usr/share/themes/Crux/gtk-2.0/gtkrc».</para></tip>
     </listitem>
     <listitem><para>Indica si el programa se debe ejecutar en un terminal o no. De ser así, se usa el complemento del terminal de Anjuta.</para></listitem>
    </itemizedlist></para>
  </sect2>
	
  <sect2 id="debug-attach">
  <title>Acoplar a un proceso</title>
   <para>También es posible acoplar a un proceso en ejecución y depurarlo eligiendo el elemento del menú <menuchoice><guisubmenu>Ejecutar</guisubmenu><guimenuitem>Depurar proceso…</guimenuitem></menuchoice>. Aparecerá una lista de todos los procesos en ejecución del sistema.</para>
   <figure id="attach">
    <title>Diálogo Acoplar al proceso</title>
    <screenshot>
	<screeninfo>Diálogo Acoplar al proceso</screeninfo>
     <graphic fileref="figures/attach.png" format="PNG" srccredit="andyp"/>
    </screenshot>
   </figure>
   <para>Seleccione el proceso que acoplar y pulse <guibutton>Aceptar</guibutton> para iniciar el depurador, acóplelo al proceso seleccionado y párelo.</para>
   <note>
    <para>Actualmente no es posible cargar la información de los símbolos para los procesos acoplados. Deben incluirse en el proceso.</para>
   </note>
  </sect2>
  
  <sect2 id="debug-stop">
   <title>Parar el depurador</title>
    <para>Elija el elemento del menú <menuchoice><guisubmenu>Ejecutar</guisubmenu><guimenuitem>Detener el depurador</guimenuitem></menuchoice> para parar el depurador. Esta opción matará el programa que se está depurando. Si el depurador se ha acoplado a un proceso en ejecución, simplemente se desacoplará sin matarlo. Obtendrá una caja de confirmación si un programa está actualmente acoplado o ejecutándose.</para>
  </sect2>

  <sect2 id="debug-add-sources">
   <title>Añadir directorios fuente</title>
   <para>Elija el elemento del menú <menuchoice><guisubmenu>Depurar</guisubmenu><guimenuitem>Añadir rutas de fuentes…</guimenuitem></menuchoice> para mostrar una caja de diálogo que le permitirá añadir y quitar directorios de fuentes.</para>
   <para>La mayoría de los ejecutables incluyen rutas de archivo completas, de tal forma que definir los directorios donde están los archivos de fuentes no es útil. Pero algunos ejecutables incluyen sólo los nombres de archivo sin rutas, en este caso el depurador buscará los archivos de fuentes en todos esos directorios. El orden de los directorios puede ser importante si varios archivos tienen el mismo nombre, así que puede cambiarlo usando los botones <guibutton>Arriba</guibutton> y <guibutton>Abajo</guibutton>. La lista de directorios se envía al depurador al iniciarse. Después de cambiarla, deberá reiniciar el depurador para que los cambios se tengan en cuenta.</para>
  </sect2>

 </sect1>
 
 <!-- Debugger: Execution -->
 
 <sect1 id="debugger-exec">
  <title>Ejecución</title>
  <para>Se puede controlar al detalle la ejecución de un programa en el depurador. El programa se puede ejecutar paso a paso o permitir que continúe hasta que encuentre un punto de parada. Esta ejecución es esencial para seguir el comportamiento del programa. Como la edición de vídeo, el programa se puede ejecutar a <emphasis>cámara lenta</emphasis> con la capacidad de ir hacia atrás, pausar, parar y demás. Aunque aún no se puede ir hacia atrás.</para>
  <para>Los métodos que se pueden ejecutar en el programa mientras se está depurando se describen en las siguientes secciones. Esos comandos están disponibles sólo cuando el programa ya se ha iniciado.</para>
  
  <sect2 id="dbg-step-in">
   <title>Paso a paso (avanzar)</title>
   <para>Elija el elemento del menú <menuchoice><guisubmenu>Depurar</guisubmenu><guimenuitem>Avanzar</guimenuitem></menuchoice> o pulse el icono <guibutton>Avanzar</guibutton> en la <interface>barra de herramientas del depurador</interface> para avanzar un paso en un programa.</para>
   <para>La ejecución paso a paso ejecuta sólo una sentencia del programa (desde el lugar donde se ha parado) y después devuelve el control. Si la sentencia que se está ejecutando contiene una o más funciones, el depurador trata de entrar en las funciones y ejecutarlas paso a paso (en la secuencia en la que las funciones se ejecutan). Una vez que la sentencia se ha ejecutado y se ha devuelto el control, es posible estudiar varios parámetros del programa.</para>
   <para>Si la <interface>ventana de desensamblado</interface> tiene el foco cuando se selecciona este comando, ejecuta sólo una instrucción del ensamblador.</para>
  </sect2>

  <sect2 id="dbg-step-over">
   <title>Paso a paso (avanzar sobre)</title>
   <para>Elija el elemento del menú <menuchoice><guisubmenu>Depurar</guisubmenu><guimenuitem>Avanzar sobre</guimenuitem></menuchoice> o pulse el icono <guibutton>Avanzar sobre</guibutton> en la <interface>barra de herramientas del depurador</interface> para avanzar sobre sentencias en un programa.</para>
   <para><emphasis>Avanzar sobre</emphasis> es similar a <emphasis>avanzar</emphasis>, excepto que no ejecuta paso a paso ninguna función de la sentencia. La sentencia se ejecutará de una pasada.</para>
   <para>Si la <interface>ventana de desensamblado</interface> tiene el foco cuando se selecciona este comando, entonces ejecuta una instrucción de ensamblador pero no para dentro si esta instrucción llama a una subrutina.</para>
   <note>
    <para>Si se carga una biblioteca dinámica durante el paso, el programa no se parará al final del paso. Se ejecutará hasta que encuentre un punto de parada o lo pare manualmente.</para>
   </note>
  </sect2>
  
  <sect2 id="dbg-step-out">
   <title>Paso a paso (avanzar al final)</title>
   <para>Elija el elemento del menú <menuchoice><guisubmenu>Depurar</guisubmenu><guimenuitem>Avanzar al final</guimenuitem></menuchoice> o pulse el icono <guibutton>Avanzar al final</guibutton> en la <interface>barra de herramientas del depurador</interface> para avanzar al final en un programa.</para>
   <para><emphasis>Avanzar al final</emphasis> ejecutará la función actual hasta que salga. El programa se parará una vez que salga de la función. Avanzar al final no es realmente una ejecución paso a paso porque no sólo ejecuta una sentencia, ejecuta la función entera hasta que la función vuelve a la función que la llamó.</para>
  </sect2>
  
  <sect2 id="dbg-run">
   <title>Ejecutar/Seguir</title>
   <para>Elija el elemento del menú <menuchoice><guisubmenu>Depurar</guisubmenu><guimenuitem>Ejecutar/Seguir</guimenuitem></menuchoice> o pulse en el icono <guibutton>Ejecutar/Seguir</guibutton> en la <interface>barra de herramientas del depurador</interface> para continuar con la ejecución de un programa.</para>
   <para>Esta opción continua la ejecución del programa hasta que se encuentra un punto de parada o el programa finalice.</para>
  </sect2>

  <sect2 id="dbg-runto">
   <title>Ejecutar hasta</title>
   <para>Elija el elemento del menú <menuchoice><guisubmenu>Depurar</guisubmenu><guimenuitem>Ejecutar hasta cursor</guimenuitem></menuchoice> o pulse en el icono <guibutton>Ejecutar hasta cursor</guibutton> en la <interface>Barra de herramientas del depurador</interface> para ejecutar hasta la línea en la que se encuentra el cursor.</para>
   <para>Esta opción continua la ejecución del programa hasta la línea o la dirección (si la <interface>Ventana de desensamblado</interface> tiene el foco) donde se alcanza al cursor.</para>
  </sect2>
  
  <sect2 id="dbg-stop">
   <title>Parar el programa</title>
   <para>Mientras el programa se está ejecutando y tiene el control no se puede realizar ninguna acción de depuración. Para obtener el control mientras el programa se está ejecutando elija el elemento del menú <menuchoice><guisubmenu>Depurar</guisubmenu><guimenuitem>Pausar el programa</guimenuitem></menuchoice> o pulse en el icono <guibutton>Pausar el programa</guibutton> en la <interface>barra de herramientas del depurador</interface>. Esto interrumpirá el programa y devolverá el control al depurador.</para>
  </sect2>
  
 </sect1>
 
<!-- ============= Debugging: Breakpoints ====================== -->
 
 <sect1 id="debugging-breaks">
  <title>Puntos de parada</title>
  <para>Al depurar un programa es útil poder parar la ejecución del programa en un punto en particular, de tal forma que se pueda examinar el estado del programa en esa ubicación. Los puntos de parada permiten que esto pase. Los puntos de parada se pueden establecer en diferentes ubicaciones en un archivo fuente para después hacer que el programa se ejecute. Cuando se encuentra un punto de parada se suspende la ejecución del programa, activando las expresiones para que se evalúen, que las variables se inspecciones, que se estudie la traza de la pila y demás.</para>

  <sect2 id="breaks-list">
   <title>Listar los puntos de parada</title>
   <para>La <interface>ventana lista de puntos de parada</interface> se puede abrir eligiendo <menuchoice><guisubmenu>Ver</guisubmenu><guimenuitem>Puntos de parada</guimenuitem></menuchoice>.</para>
   <para>
    <figure>
      <title>Vista del punto de parada</title>
      <screenshot>
       <screeninfo>Vista del punto de parada</screeninfo>
       <graphic fileref="figures/brk_dlg.png" format="PNG" srccredit="andyp"/>
      </screenshot>
    </figure>
   </para>
   <para>La vista tiene las siguientes columnas: <variablelist>
     <varlistentry>
      <term>Ubicación</term>
      <listitem>
       <para>Esta es la posición del punto de parada en el archivo fuente. Cuando el punto de parada lo establece el depurador, puede obtener información adicional tal como la función que contiene el punto de parada.</para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Dirección</term>
      <listitem>
       <para>Este campo está rellenado con la dirección del punto de parada cuando el depurador lo establece.</para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Tipo</term>
      <listitem>
       <para>Esto siempre muestra «punto de parada». Se usará en una versión posterior soportando diferentes tipos de puntos de parada.</para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Condición</term>
      <listitem>
       <para>Esta es la condición del punto de parada, está vacía si no se define ninguna condición.</para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Conteo de pasadas</term>
      <listitem>
       <para>Cuando el depurador no se está ejecutando, ésta columna muestra el conteo de pasadas del punto de parada, será cero si no está definido.</para>
       <para>Cuando el depurador se está ejecutando, si el conteo de pasadas es cero, esta columna muestra el número de veces que este punto de parada se ha disparado. Si el conteo de pasadas no es cero, entonces se muestran ambos números. El conteo de pasadas es el segundo número.</para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Estado</term>
      <listitem>
       <para>Éste es el estado del punto de parada. Puede ser: <itemizedlist>
         <listitem><para>Pendiente: el punto de parada no está establecido en su programa.</para></listitem>
         <listitem><para>Permanente: el punto de parada está establecido (el número de ID entre los paréntesis).</para></listitem>
         <listitem><para>Temporal: el punto de parada está establecido pero se borrará al alcanzarse.</para></listitem>
        </itemizedlist></para>
      </listitem>
     </varlistentry>
    </variablelist></para>
   <note>
    <para>Todos los puntos de parada se mantienen entre las sesiones de Anjuta incluso si corresponden con ubicaciones no existentes. En este caso su estado pasa a ser pendiente. La interfaz trata de establecerlos cada vez que el programa se inicia o se carga una nueva biblioteca dinámica.</para>
   </note>
  </sect2>  

  <sect2 id="breaks-set">
   <title>Añadir o establecer puntos de parada</title>
   <para>Elija el elemento del menú <menuchoice><guisubmenu>Depurar</guisubmenu><guimenuitem>Añadir punto de parada…</guimenuitem></menuchoice> o <menuchoice><guimenuitem>Añadir punto de parada…</guimenuitem></menuchoice> en el menú emergente de la lista de puntos de parada para abrir el diálogo <interface>Añadir punto de parada</interface>.</para>
   <para>
    <figure>
      <title>Diálogo de adición de punto de parada</title>
      <screenshot>
	   <screeninfo>Diálogo de adición de punto de parada</screeninfo>
       <graphic fileref="figures/brk_add.png" format="PNG" srccredit="mkv"/>
      </screenshot>
    </figure>
   </para>
   <para>Introduzca la ubicación y opcionalmente, la condición de parada y el conteo de pasadas, después pulse <guibutton>Aceptar</guibutton> para establecer el punto de parada. <variablelist>
     <varlistentry>
      <term>Ubicación</term>
      <listitem>
       <para>Introduzca la ubicación en la que quiere establecer el punto de parada. Se puede especificar en uno de los siguientes formatos:</para>
       <para>
        <orderedlist>
         <listitem><para>Nombre_de_archivo:Número_de_línea</para></listitem>
         <listitem><para>Nombre_de_la_función</para></listitem>
         <listitem><para>Archivo:Nombre_de_la_función</para></listitem>
        </orderedlist>
       </para>
       <para>El primero es obvio; la ubicación se refiere al número de línea <emphasis>Número_de_línea</emphasis> en el archivo fuente <emphasis>Archivo</emphasis>. La segunda se refiere a la primera línea de la función <emphasis>Nombre_de_la_función</emphasis>. La tercera es similar a la segunda, excepto que esta notación se usa donde existe más de una función con el nombre <emphasis>Nombre_de_la_función</emphasis> en el programa. Es posible diferenciarlas proporcionando el <emphasis>Archivo</emphasis>, de tal forma que la notación se refiere a la función <emphasis>Nombre_de_la_función</emphasis> en el archivo <emphasis>Archivo</emphasis>.</para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Condición</term>
      <listitem>
       <para>El parámetro <emphasis>Condición</emphasis> muestra una expresión asociada que se debería evaluar con un valor booleano; esto es, la evaluación de la expresión debe resultar en «TRUE(1)» o «FALSE(0)». Si la evaluación final no es un valor booleano, entonces se hará un cambio de tipo («typecast») a booleano.</para>
       <para>Cada vez que se encuentre el punto de parada durante la ejecución se evaluará la condición. El depurador parará la ejecución sólo si la evaluación devuelve un valor «TRUE», de otra forma continuará con la ejecución como si no hubiese habido un punto de parada.</para>
       <para>El valor predeterminado, si deja el campo vacío, de la <emphasis>Condición</emphasis> es siempre TRUE. El depurador parará la ejecución en la posición del punto de parada.</para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Conteo de pasadas</term>
      <listitem>
       <para>El <emphasis>conteo de pasadas</emphasis> es un valor entero (sin signo) que le dice al depurador que salte el punto de parada ése número de veces antes de considerarlo. El <emphasis>conteo de pasadas</emphasis> tiene una prioridad más alta que la <emphasis>condición de parada</emphasis>. Sólo cuando el <emphasis>conteo de pasadas</emphasis> llega a cero el depurador evaluará la <emphasis>condición de parada</emphasis> (si hay alguna condición establecida). Si no hay ninguna condición establecida, el depurador parará la ejecución una vez que el <emphasis>conteo de pasadas</emphasis> llegue a cero.</para>
       <para>El valor predeterminado, si deja el campo vacío, del <emphasis>Conteo de pasadas</emphasis> es cero. El punto de parada se considerará cuando se encuentre por primera vez.</para>
      </listitem>
     </varlistentry>
    </variablelist></para>
   <para>Un punto de parada también se puede establecer seleccionando una línea en el editor y eligiendo el elemento del menú <menuchoice><guisubmenu>Depurar</guisubmenu><guimenuitem>Conmutar punto de parada</guimenuitem></menuchoice> en el elemento del menú contextual o pulsando el icono <guibutton>Conmutar punto de parada</guibutton> en la <interface>Barra de herramientas del depurador</interface>.</para>
   <tip>
    <para>Los puntos de parada se pueden añadir incluso si el depurador no se ha iniciado o la biblioteca dinámica no se ha cargado aún. Pero no se pueden añadir mientras un programa se está ejecutando bajo el control del depurador.</para>
   </tip>
  </sect2>
  
  <sect2 id="breaks-edit">
   <title>Editar puntos de parada</title>
   <para>Puede cambiar la condición y el conteo de pasadas seleccionando el punto de parada en la lista de puntos de parada y pulsando en el elemento <menuchoice><guimenuitem>Editar punto de parada</guimenuitem></menuchoice> del menú emergente.</para>
   <para>Edite las entradas como se requiere y pulse <guibutton>Aceptar</guibutton> para efectuar los cambios.</para>
  </sect2>

  <sect2 id="breaks-del">
   <title>Borrar puntos de parada</title>
   <para>Seleccione el pinto de parada en la vista de la lista de puntos de parada y pulse <menuchoice><guimenuitem>Quitar punto de parada</guimenuitem></menuchoice> para borrarlo.</para>
   <para>Un punto de parada existente también se puede borrar seleccionando su línea en el editor y eligiendo el elemento del menú <menuchoice><guisubmenu>Depurar</guisubmenu><guimenuitem>Conmutar punto de parada</guimenuitem></menuchoice>, el elemento del menú emergente <menuchoice><guimenuitem>Conmutar punto de parada</guimenuitem></menuchoice> o el icono <guibutton>Conmutar punto de parada</guibutton> en la <interface>Barra de herramientas del depurador</interface>.</para>
   <para>Puede quitar todos los puntos de parada pulsando en <menuchoice><guisubmenu>Depurar</guisubmenu><guimenuitem>Quitar todos los puntos de parada</guimenuitem></menuchoice> o en <menuchoice><guimenuitem>Quitar todos los puntos de parada</guimenuitem></menuchoice> en el menú contextual de la lista de puntos de parada.</para>
  </sect2>

  <sect2 id="breaks-enbdis">
   <title>Activar o desactivar puntos de parada</title>
   <para>Pulse en la columna Activar de la <interface>Ventana de lista de puntos de parada</interface> o en el elemento del menú <menuchoice><guimenuitem>Activar punto de parada</guimenuitem></menuchoice> para activar o desactivar el punto de parada seleccionado. El punto de parada se activará o desactivará, dependiendo de su estado actual.</para>
   <para>Para desactivar todos los puntos de parada pulse <menuchoice><guisubmenu>Depurar</guisubmenu><guimenuitem>Desactivar todos los puntos de parada</guimenuitem></menuchoice> o pulse <menuchoice><guimenuitem>Desactivar todos los puntos de parada</guimenuitem></menuchoice> en el menú contextual.</para>
  </sect2>
 </sect1>

<!-- ============= Debugging: Expressions ====================== -->
 <sect1 id="debugging-expr">
  <title>Expresiones</title>

  <sect2 id="var-local">
   <title>Listar las variables locales</title>
   <para>Cuando un programa se está ejecutando bajo el control del depurador, la <interface>Ventana de lista de locales</interface> se puede abrir eligiendo <menuchoice><guisubmenu>Ver</guisubmenu><guimenuitem>Locales</guimenuitem></menuchoice>.</para>
   <para>Las variables locales del marco actual (la función actual en la que el control de programa está presente) se muestran en la <interface>Ventana de locales</interface>. Durante la ejecución del programa (ej. durante la ejecución paso a paso) se actualizarán las variables locales. Si el valor de alguna variable cambió en el último paso de depuración, su valor se resaltará en rojo. Las variables se presentan en una forma de árbol fácil de ver: <figure>
      <title>Variables locales</title>
      <screenshot>
	  <screeninfo>Variables locales</screeninfo>
       <graphic fileref="figures/local_variables.png" format="PNG" srccredit="naba"/>
      </screenshot>
    </figure></para>
   <para>El valor de una variable local se puede modificar seleccionándola y pulsando en la columna <guilabel>Valor</guilabel>.</para>
   <note>
    <para><application>gdb</application> cada vez se usa más y más como «backend» para un «frontend» gráfico. Se ha mejorado recientemente en ésta área. Se recomienda usar la última versión (6.6) de gdb. En versiones anteriores gdb se puede colgar cuando el «frontend» pregunta por un puntero con un valor no válido (pero no usado).</para>
   </note>
  </sect2>

  <sect2 id="var-watch">
   <title>Listar las expresiones vigiladas</title>
   <para>Inspeccionar o evaluar una expresión proporciona el resultado sólo una vez. Para monitorizar continuamente algunas variables o expresiones, use la <emphasis>vigilancia de expresiones</emphasis>.</para>
   <para>Elija el elemento del menú <menuchoice><guisubmenu>Ver</guisubmenu><guimenuitem>Vigilancias</guimenuitem></menuchoice> para mostrar la <interface>ventana de vigilancias</interface>.</para>
  </sect2>

  <sect2 id="watch-add">
   <title>Añadir una expresión para vigilar</title>
   <para>Pulse con el botón derecho del ratón en la <interface>Ventana de vigilancias</interface> para abrir el menú contextual. Elija el elemento del menú <guimenuitem>Añadir vigilancia…</guimenuitem>. Alternativamente  puede usar <menuchoice><guisubmenu>Depurar</guisubmenu><guimenuitem>Añadir vigilancia…</guimenuitem></menuchoice>. Aparecerá un diálogo preguntando por la expresión. Introduzca la expresión y pulse <guibutton>Aceptar</guibutton>.</para>
   <para>De forma predeterminada las expresiones vigiladas se actualizan automáticamente cada vez que el programa se para. Esto se puede cambiar en el diálogo añadir vigilancia o posteriormente usando el elemento del menú <guimenuitem>Autoactualizar</guimenuitem> en el menú contextual de la <interface>Ventana de vigilancias</interface>. Una expresión vigilada se puede actualizar manualmente eligiendo <guimenuitem>Actualizar vigilancia</guimenuitem> o <guimenuitem>Actualizar todo</guimenuitem> en el menú anterior.</para>
   <para>No es necesario que el depurador se esté ejecutando para añadir una nueva expresión a la vigilancia. Si el depurador no se está ejecutando o la expresión correspondiente no se puede encontrar, el «frontend» tratará de crear la vigilancia de la expresión cada vez que el programa se pare.</para>
  </sect2>

  <sect2 id="watch-remove">
   <title>Eliminar una expresión vigilada</title>
   <para>Seleccione la expresión para vigilar que quiere quitar en la <interface>ventana de vigilancia de expresiones</interface>, después abra el menú contextual pulsando con el botón derecho del ratón y elija el elemento del menú <guimenuitem>Eliminar</guimenuitem>.</para>
   <para>Se pueden quitar todas las vigilancias eligiendo <guimenuitem>Eliminar todo</guimenuitem> en el menú contextual de la <interface>ventana de vigilancia</interface>.</para>
  </sect2>

  <sect2 id="expr-eval">
   <title>Evaluar expresiones</title>
   <para>Cuando el control se devuelve desde un programa —posiblemente en un punto de parada— es posible evaluar expresiones o inspeccionar los valores de las variables en el programa. Elija el elemento del menú <menuchoice><guisubmenu>Depurar</guisubmenu><guimenuitem>Inspeccionar/Evaluar...</guimenuitem></menuchoice>, <menuchoice><guimenuitem>Inspeccionar/Evaluar...</guimenuitem></menuchoice> en el menú emergente del editor o pulse el botón <guibutton>Inspeccionar</guibutton> en la <interface>Barra de herramientas de depuración</interface>.</para>
   <para>Aparecerá una ventana mostrando la evaluación de la expresión resaltada en el editor. Puede evaluar una nueva expresión pulsando en la columna <guilabel>nombre</guilabel> e introduciendo la nueva expresión.</para>
   <para>Puede añadir la expresión directamente en la lista de expresiones para vigilar pulsando el botón <guibutton>Añadir</guibutton>.</para>
  </sect2>

  <sect2 id="expr-hiver">
   <title>Inspeccionar expresiones en la ventana del editor</title>
   <para>Cuando la depuración está activada con el programa parado, puede obtener el valor de una expresión simplemente poniendo el puntero sobre ella y dejándolo un tiempo corto. Si la expresión ya está presente en la ventana <interface>Local</interface> o la ventana de <interface>Vigilancias</interface> su valor se mostrará en una ventana de consejo.</para>
   <para>Actualmente sólo funciona para variables simples, no para estructuras o vectores («array»).</para>
  </sect2>

 </sect1>

<!-- ============= Debugging: Program Stack ====================== -->
 <sect1 id="debugging-stack">
  <title>Traza de la pila</title>

  <sect2 id="stack-win">
   <title>Ventana de pila</title>
   <para>La <interface>ventana de la traza de la pila</interface> muestra el contenido de la pila del programa. Lista todas las funciones y sus argumentos en la secuencia en la que se llamaron. También hay un número que representa cada llamada. Este número se llama <emphasis>marco</emphasis>. Cada llamada en la traza existe en un marco diferente. Esto comienza desde el marco 0 (la última función llamada) y crece a medida que el anidamiento de funciones se haga mayor.</para>
   <para>Elija el elemento del menú <menuchoice><guisubmenu>Ver</guisubmenu><guimenuitem>Pila</guimenuitem></menuchoice> para abrir la traza de la pila para el programa que se está depurando.</para>
   <para>
    <figure>
      <title>Ventana de la traza de la pila</title>
      <screenshot>
	   <screeninfo>Ventana de la traza de la pila</screeninfo>
       <graphic fileref="figures/stack.png" format="PNG" srccredit="andyp"/>
      </screenshot>
    </figure>
   </para>
   <para>Una pequeña flecha apunta al marco seleccionado actualmente en la traza de la pila. De forma predeterminada, éste será el marco 0, la última función llamada. Toda la evaluación e inspección de expresiones o variables se referenciará a este marco. El rango de las variables o expresiones evaluadas se limitará a las del marco seleccionado. Lo mismo se aplica para expresiones nuevas sólo en la vigilancia.</para>
  </sect2>
  
  <sect2 id="stack-frame">
   <title>Establecer el marco actual</title>
   <para>Al pulsar dos veces sobre cualquier marco de traza la pila se establecerá ese marco como el marco actualmente seleccionado (la flecha apuntará al marco, indicando que se ha seleccionado como el marco actual). Alternativamente, abra el <interface>menú de operaciones</interface> pulsando con el botón derecho sobre la <interface>ventana de traza de la pila</interface> y elija el elemento del menú <guimenuitem>Establecer el marco actual</guimenuitem> para establecer el marco.</para>
   <para>Cambiar el marco de la pila cambia el contenido de la <interface>ventana de lista de locales</interface> pero no la <interface>ventana de vigilancias</interface> ya que cada expresión se evalúa en el marco usado cuando se definió.</para>
  </sect2>
 </sect1>

<!-- ============= Debugging: Program Thread ====================== -->
 <sect1 id="debugging-thread">
  <title>Hilos</title>

  <sect2 id="thread-win">
   <title>Ventana de hilos</title>
   <para>La <interface>Ventana de hilos</interface> muestra todos los hilos usados por el programa e indica el hilo actual. Para abrir esta ventana elija el elemento del menú <menuchoice><guisubmenu>Ver</guisubmenu><guimenuitem>Hilo</guimenuitem></menuchoice>.</para>
   <para>Una pequeña flecha apunta al hilo actual. Cuando el programa se para, corresponde al hilo en el que se ha interrumpido. Cada hilo tiene su propio marco de la pila, de tal forma que cambiar el hilo actual cambia el marco de la pila actual.</para>
  </sect2>

  <sect2 id="set-thread">
   <title>Establecer el hilo actual</title>
   <para>Al pulsar dos veces sobre cualquier hilo en la lista de hilos se establecerá ese hilo como el hilo actualmente seleccionado (la flecha apuntará al hilo, indicando que se ha seleccionado como el hilo actual). Alternativamente, abra el <interface>menú de operaciones</interface> pulsando con el botón derecho sobre la <interface>ventana de la lista de hilos</interface> y elija el elemento del menú <guimenuitem>Establecer el hilo actual</guimenuitem> para establecer el hilo.</para>
   <para>Al cambiar el hilo también cambiará el valor de los registros de la CPU y el marco actual de la pila, de tal forma que la <interface>ventana de locales</interface> también cambiará.</para>
  </sect2>
 </sect1>

<!-- ============= Debugging: CPU ====================== -->
 <sect1 id="debugging-cpu">
  <title>CPU</title>

  <sect2 id="cpu-regs">
   <title>Ventana de registros</title>
   <para>Es posible examinar el contenido de los registros internos de la CPU (microprocesador). Elija el elemento del menú <menuchoice><guisubmenu>Ver</guisubmenu><guimenuitem>Registros</guimenuitem></menuchoice>. Aparecerá una ventana listando todos los registros disponibles en el microprocesador y su correspondiente contenido.</para>
   <para>Si cualquier valor de un registro se cambió en el último paso de depuración, su valor se resaltará en rojo. Es posible cambiar el valor de un registro seleccionándolo y pulsando en la columna </para>
  </sect2>

  <sect2 id="cpu-memory">
   <title>Ventana de memoria</title>
   <para>Elija el elemento del menú <menuchoice><guisubmenu>Ver</guisubmenu><guimenuitem>Memoria</guimenuitem></menuchoice> para abrir la <interface>ventana de memoria</interface> para el programa que se está depurando. Esta ventana muestra el contenido de toda la memoria.</para>
   <para>La primera columna muestra las direcciones de memoria en hexadecimal, la segunda muestra el contenido de la memoria en hexadecimal y la última columna muestra el contenido de la memoria en ASCII.</para>
   <para>Hasta el espacio de direccionamiento de un microprocesador de 32 bits es bastante grande (4 Gigabytes) de tal forma que es bastante difícil ir a una dirección en particular con la barra de desplazamiento. Pero puede pulsar con el botón derecho del ratón para mostrar un menú contextual y seleccionar <menuchoice><guimenuitem>Ir a la dirección</guimenuitem></menuchoice> para obtener una pequeña caja de texto editable donde puede introducir una dirección en hexadecimal.</para>
  </sect2>

  <sect2 id="cpu-disassembly">
   <title>Ventaba de desensamblado</title>
   <para>Elija el elemento del menú <menuchoice><guisubmenu>Ver</guisubmenu><guimenuitem>Desensamblado</guimenuitem></menuchoice> para abrir la <interface>ventana de desensamblado</interface> para el programa que se está depurando.</para>
   <para>La primera columna es la dirección en hexadecimal. En la segunda columna puede tener una etiqueta al comienzo de la línea que termina con un punto y coma, o una instrucción en ensamblador que comienza tras 4 caracteres espacio.</para>
   <para>De nuevo, ya que el espacio de direccionamiento es muy grande, la barra de desplazamiento es bastante inútil. Puede pulsar con el botón derecho del ratón, obtener un nuevo menú y seleccionar <menuchoice><guimenuitem>Ir a la dirección</guimenuitem></menuchoice> para obtener una pequeña caja de texto editable donde puede introducir una dirección en hexadecimal. La posición en la ventana de desensamblado se cambiará al valor del contador del programa cuando se pare el programa.</para>
  </sect2>
 </sect1>

<!-- Debugger: Others-->
 <sect1 id="debugger-others">
  <title>Otros</title>

  <para>Existe cierto número de características del depurador que se no se usan tan frecuentemente y no están muy bien integradas en el nuevo front-end pero se está trabajando en ello.</para>

  <sect2 id="dbg-dyna-libs">
   <title>Bibliotecas cargadas dinámicamente</title>
   <para>Para obtener una lista de las bibliotecas usadas dinámicamente por el programa, elija el elemento del menú <menuchoice><guisubmenu>Depurar</guisubmenu><guisubmenu>Información</guisubmenu><guimenuitem>Bibliotecas compartidas</guimenuitem></menuchoice>. Esto abrirá una nueva ventana que listará todas las bibliotecas compartidas que el programa ha cargado y sus ubicaciones en la memoria. También muestra si la tabla de símbolos se ha cargado o no (Sí/No).</para>
   <para>
    <figure>
      <title>Ventana de bibliotecas compartidas</title>
      <screenshot>
	   <screeninfo>Ventana de bibliotecas compartidas</screeninfo>
       <graphic fileref="figures/sharedlibs.png" format="PNG" srccredit="andyp"/>
      </screenshot>
    </figure>
   </para>
  </sect2>

  <sect2 id="dbg-signal">
   <title>Señales del núcleo</title>
   <para>Las señales del núcleo son una forma de señalizar procesos en Linux. La lista de señales disponibles para un programa se puede mostrar eligiendo el elemento del menú <menuchoice><guisubmenu>Depurar</guisubmenu><guisubmenu>Información</guisubmenu><guimenuitem>Señales del núcleo</guimenuitem></menuchoice>. Se abrirá una ventana listando todas las señales disponibles en el sistema junto con una breve descripción de cada señal.</para>
   <para>
    <figure>
      <title>Ventana de señales del núcleo</title>
      <screenshot>
	   <screeninfo>Ventana de señales del núcleo</screeninfo>
       <graphic fileref="figures/signals.png" format="PNG" srccredit="andyp"/>
      </screenshot>
    </figure>
   </para>
   <para>Existen tres columnas que especifican qué hacer cuando se recibe una señal:</para>
   
   <orderedlist>
    <listitem>
     <para><emphasis>Parar</emphasis>; esto le dice al depurador si debe parar la ejecución del programa (y devolver el control) cuando el programa recibe esta señal.</para>
    </listitem>
    <listitem>
     <para><emphasis>Imprimir</emphasis>; esto de dice al depurador si debe mostrar la señal recibida.</para>
    </listitem>
    <listitem>
     <para><emphasis>Pasar</emphasis>; esto le dice al depurador si debe pasar la señal al programa.</para>
    </listitem>
   </orderedlist>
   <note>
    <para>El menú emergente que se muestra al pulsar con el botón derecho del ratón tiene todos sus elementos desactivados porque las funciones correspondientes aún no están implementadas.</para>
   </note>
  </sect2>

  <sect2 id="dbg-files">
   <title>Información acerca de archivos usados</title>
   <para>Es posible obtener alguna información acerca de los archivos usados por el programa depurado, eligiendo el elemento del menú <menuchoice><guisubmenu>Depurar</guisubmenu><guisubmenu>Información</guisubmenu><guimenuitem>Información de archivos objetivo</guimenuitem></menuchoice>. Se abrirá una ventana mostrando esta información.</para>
  </sect2>

  <sect2 id="dbg-program">
   <title>Información acerca del programa depurado</title>
   <para>Es posible obtener alguna información acerca del programa depurado eligiendo el elemento del menú <menuchoice><guisubmenu>Depurar</guisubmenu><guisubmenu>Información</guisubmenu><guimenuitem>Programa</guimenuitem></menuchoice>. Se abrirá una ventana mostrando esta información.</para>
  </sect2>
 
  <sect2 id="dbg-kernel">
   <title>Información acerca de la estructura del núcleo</title>
   <para>Es posible obtener alguna información de los datos del núcleo acerca de los procesos actuales eligiendo el elemento del menú <menuchoice><guisubmenu>Depurar</guisubmenu><guisubmenu>Información</guisubmenu><guimenuitem>User struct del núcleo</guimenuitem></menuchoice>. Se abrirá una ventana mostrando esta información.</para>
  </sect2>

  <sect2 id="var-global">
   <title>Información acerca de las variables globales</title>
   <para>Es posible listar todas las variables globales eligiendo el elemento del menú <menuchoice><guisubmenu>Depurar</guisubmenu><guisubmenu>Información</guisubmenu><guimenuitem>Variables globales</guimenuitem></menuchoice>. Se abrirá una ventana listando todas las variables globales.</para>
  </sect2>

  <sect2 id="stack-frame-info">
   <title>Información acerca del marco actual</title>
   <para>Es posible obtener información acerca del marco actualmente seleccionado eligiendo el elemento del menú <menuchoice><guisubmenu>Depurar</guisubmenu><guisubmenu>Información</guisubmenu><guimenuitem>Marco actual</guimenuitem></menuchoice>. Se abrirá una ventana describiendo el marco actual.</para>
  </sect2>

  <sect2 id="stack-arg-info">
   <title>Información acerca de los argumentos actuales de la función</title>
   <para>Es posible obtener información acerca de los argumentos de la función actual eligiendo el elemento del menú <menuchoice><guisubmenu>Depurar</guisubmenu><guisubmenu>Información</guisubmenu><guimenuitem>Argumentos</guimenuitem></menuchoice>. Se abrirá una ventana describiendo los argumentos.</para>
  </sect2>
  
  <sect2 id="dbg-command">
   <title>Comando de usuario</title>
   <para>Para enviar directamente un comando al «backend» elija el elemento del menú <menuchoice><guimenu>Depurar</guimenu><guimenuitem>Comando del depurador</guimenuitem></menuchoice>. Se mostrará un pequeño diálogo donde podrá introducir los comandos que se enviarán al depurador cuando pulse <keycap>Intro</keycap>.</para>
   <note>
    <para>El «frontend» envía este comando directamente al «backend» sin ninguna comprobación. Por ejemplo, si establece un punto de parada como este, no aparecerá en la <interface>ventana de lista de puntos de parada</interface>. Es mejor evitar el uso de este comando a no ser que sepa exactamente qué está haciendo.</para>
   </note>
  </sect2>
 </sect1> 

 </chapter>

 <!-- Glade Interface Designer -->
 <chapter id="glade">
	<title>Diseñador de interfaces Glade</title>

	<sect1>
		<title>Inicio rápido</title>
		<para>Si no quiere leer todo este aburrido manual, aquí existen unos pocos pasos para tener todo esto listo para su uso: <orderedlist>
				<listitem><para>Debería tener un proyecto que contenga un archivo Glade abierto;</para></listitem>
				<listitem><para>A diferencia del diseñador Glade original, el complemento de Anjuta usa la pulsación doble para crear manejadores para la señal predeterminada. Puede realizar pulsaciones en widgets (ej. cambiar la solapa actual en un GtkNotebook) manteniendo pulsada la tecla «Windows» o «Super»;</para></listitem>
				<listitem><para>Abra <menuchoice><guimenuitem>Preferencias</guimenuitem><guimenuitem>Diseñador de IGU Glade</guimenuitem></menuchoice> y seleccione las tres opciones superiores <guilabel>Insertar manejador al editar</guilabel>, <guilabel>Distribución del diseñador separada</guilabel> y <guilabel>Añadir recursos automáticamente</guilabel>;</para></listitem>
				<listitem><para>Compruebe la opción <menuchoice><guimenuitem>Ver</guimenuitem><guimenuitem>Diseñador</guimenuitem></menuchoice> y mueva esta ventana a un lugar mejor;</para></listitem>
				<listitem><para>Cambie al archivo de Glade en el área de diseño y al archivo de código fuente que debería contener las llamadas desde el archivo Glade, después pulse <menuchoice><guimenuitem>Glade</guimenuitem><guimenuitem>Asociar el último diseñador y el último editor</guimenuitem></menuchoice>;</para></listitem>
				<listitem><para>Opcionalmente seleccione un destino para la imagen y otros recursos en el gestor de proyectos y pulse <guilabel>Establecer como objetivo de recurso predeterminado</guilabel> en el menú contextual.</para></listitem>
			</orderedlist></para>
	</sect1>
	
	<sect1>
		<title>Cuestiones de uso general de Glade</title>
		<para>El complemento de Glade básicamente copia las funcionalidades del diseñador de Glade, pero tiene algunas características especiales. Las cuatro ventanas del diseñador de Glade son el área de diseño, la paleta, el inspector de widgets y el editor de propiedades. Tienen el mismo propósito que en el diseñador individual, así que consulte el <ulink type="help" url="ghelp:glade">Manual del diseñador de interfaces Glade</ulink> para ver su descripción. Una funcionalidad adicional le permite usar la estructura de Anjuta de una forma más efectiva y se describe aquí.</para>
	</sect1>

	<sect1>
		<title>Asociación de editor y diseñador</title>
		<para>Puede asociar el editor de textos y el diseñador Glade para cambiar fácilmente entre ambos e insertar manejadores de esbozos para manejadores nuevos que haya introducido. Puede asociar más de un editor a un diseñador. Se usará el editor más reciente o el asociado con el widget de nivel superior. Existen dos formas de asociar un editor y un diseñador. La primera forma es usando el diálogo de asociaciones. La segunda forma es elegir el diseñador y el editor de documentos en cualquier orden y seleccionar el elemento del menú <menuchoice><guimenuitem>Glade</guimenuitem><guimenuitem>Asociar el último diseñador y el último editor</guimenuitem></menuchoice>.</para>
	</sect1>

	<sect1>
		<title>Diálogo de asociaciones</title>
		<para>Le permite crear y gestionar las asociaciones. Para crear una asociación seleccione diseñador y editor en las cajas de combinación y pulse <guibutton>Asociar</guibutton>. También puede seleccionar el documento cambiando a él en el gestor de documentos o la lista de ventanas en el menú principal. La lista en el medio del diálogo muestra las asociaciones existentes. Un par de controles debajo están pensadas para editar las propiedades de las asociaciones. Aquí está su descripción: <variablelist>
				<varlistentry>
					<term><guilabel>RegExp especial</guilabel></term>
					<listitem><para>Apócope de «expresión regular especial». Se usa para definir una posición especial para insertar esbozos.</para></listitem>
				</varlistentry>
				<varlistentry>
					<term><guilabel>Nombre del widget</guilabel></term>
					<listitem><para>El nombre del widget de nivel superior al que pertenece esta asociación.</para></listitem>
				</varlistentry>
				<varlistentry id="glade-position-type">
					<term><guilabel>Tipo de posición</guilabel></term>
					<listitem><para>Describe una posición en la que se insertará un manejador de esbozos. <guilabel>Después del principio</guilabel> significa después de una marca especial (que se introducirá en la entrada <guilabel>RegExp especial</guilabel>) y <guilabel>Antes del final</guilabel> significa antes de la marca especial de final. La marca predeterminada de inicio es /* window_name callbacks */ y la marca predeterminada de final es /* end of window_name callbacks */. Se puede omitir window_name.</para></listitem>
				</varlistentry>
			</variablelist></para>
	</sect1>
	
	<sect1 id="glade-default-signal">
		<title>Señal predeterminada</title>
		<para>Pulsar dos veces en un widget en el área de diseño creará un nuevo manejador para la señal predeterminada usando una plantilla predefinida para su nombre. Por ejemplo, la señal predeterminada es «pulsado» para un botón. «conmutado» para una caja de combinación, etc. Si la opción <guilabel>Insertar manejador al editar</guilabel> está activada entonces se insertará un nuevo manejador de esbozos en la posición que depende del ajuste <guilabel>Tipo de posición</guilabel>.</para>
	</sect1>
	
	<sect1>
		<title>Insertar un esbozo</title>
		<para>Uno de los objetivos más importantes de la integración de <application>Anjuta</application> y <application>Glade</application> es crear automáticamente manejadores de esbozos, para que no necesite realizar mucho trabajo rutinario, que se hará automáticamente.</para>
		<para>Existen varias formas de crear un esbozo: <itemizedlist>
				<listitem><para>Automáticamente si la opción <guilabel>Insertar manejador al editar</guilabel> está activada</para></listitem>
				<listitem><para>Usando <menuchoice><guimenuitem>Glade</guimenuitem><guimenuitem>Insertar manejador de esbozos, posición automática</guimenuitem></menuchoice> en el menú principal</para></listitem>
				<listitem><para>Usando el elemento <guilabel>Insertar manejador de esbozos</guilabel> en el menú contextual del documento de texto</para></listitem>
			</itemizedlist></para>
	</sect1>

	<sect1>
		<title>Preferencias</title>
		<variablelist>
			<varlistentry>
				<term><guilabel>Insertar manejador al editar</guilabel></term>
				<listitem><para>Activa la inserción de un manejador de esbozo en el editor asociado después de introducir un manejador nuevo en un editor de señales o al crear un <link linkend="glade-default-signal">manejador predeterminado de señales</link></para></listitem>
			</varlistentry>
			<varlistentry>
				<term><guilabel>Distribución del diseñador separada</guilabel></term>
				<listitem><para>Desacopla el área de diseño del gestor de documentos para que pueda acoplarlo separadamente desde editores de texto.</para></listitem>
			</varlistentry>
			<varlistentry>
				<term><guilabel>Añadir recursos automáticamente</guilabel></term>
				<listitem><para>Cuando todos los elementos están seleccionados (ej. imágenes) se añadirán al destino en el proyecto actual. Puede elegir el objetivo usando el menú contextual del gestor de proyectos o introduciendo el ID del objetivo en la entrada bajo el botón de verificación.</para></listitem>
			</varlistentry>
			<varlistentry>
				<term><guilabel>Plantilla del manejador</guilabel></term>
				<listitem><para>Puede elegir entre dos formatos de nombrar automáticamente el manejador de señales.</para></listitem>
			</varlistentry>
		</variablelist>
	</sect1>

</chapter>

 <!-- Preferences -->
 <!-- Preferences -->
 <chapter id="preferences">
  <title>Preferencias</title>
  <para>Las preferencias son formas para que <application>Anjuta</application> se ajuste a sus gustos. Active <menuchoice><guimenu>Editar</guimenu><guimenuitem>Preferencias</guimenuitem></menuchoice> para mostrar el diálogo de preferencias. Algunas preferencias se explican debajo.</para>
  <sect1 id="prefs-general"><title>General</title>
    <orderedlist>
     <listitem><para><emphasis>Directorio del proyecto:</emphasis> Es la ruta donde planea poner todos sus proyectos. El asistente de aplicación crea los proyectos nuevos sólo en este directorio. El directorio de proyecto predeterminado es ~/Projects y generalmente es suficiente para la mayoría de las personas.</para>
     </listitem>
      <listitem><para><emphasis>Información del usuario:</emphasis> Proporciona su nombre y dirección de correo electrónico. No se utilizan para registrar el software, sino para crear entradas en el archivo ChangeLog e insertar otros bits de texto.</para>
      </listitem>
     </orderedlist>
    </sect1>
    <sect1 id="prefs-files"><title>Gestor de archivos</title>
    <orderedlist>
     <listitem><para><emphasis>Directorio raíz si no hay un proyecto abierto</emphasis> es la ruta donde apunta la raíz del gestor de archivos si actualmente no hay ningún proyecto abierto.</para>
     </listitem>
      <listitem><para><emphasis>Filtro de archivos:</emphasis> Puede filtrar algunos archivos del árbol de archivos, por ejemplo los archivos ocultos o los archivos ignorados por el sistema de control de versiones que generalmente significa que se general durante la compilación y no se deberían cambiar.</para>
      </listitem>
     </orderedlist>
    </sect1>
 </chapter>

 <!-- Tools -->
 <!-- new chapter -->
 <chapter id="tools">
  <title>Herramientas definidas por el usuario</title>

  <sect1 id="tools-intro">
  <title>Introducción</title>
  <para>Algunas veces encontrará que las funcionalidades propias proporcionadas por Anjuta son insuficientes. En estos casos, puede que esté tentado a añadir la característica al código fuente de Anjuta usted mismo o enviar una petición de implementación de característica. No obstante, ambos casos suelen ser lentos y problemáticos, especialmente si su herramienta es especializada. Bajo estas circunstancias, es mejor usar el entorno de trabajo de las herramientas de Anjuta.</para>

  <para>Anjuta proporciona un potente entorno de trabajo para definir herramientas definidas por el usuario para extender su funcionalidad. Las herramientas acceden a casi todas las características del EID a través del uso de variables. Puede añadir herramientas bajo cualquier elemento del menú, entradas específicas, salidas y redirecciones de errores dentro del entorno de trabajo de la IGU así como proporcionar parámetros de la línea de comandos a la herramienta.</para>
	<note>
	<para>El complemento de herramientas debe estar activado para usar esta característica.</para>
	</note>
  </sect1>

  <sect1 id="tools-example">
  <title>Ejemplos de herramientas</title>
  <para>Este es un simple ejemplo de cómo usar el complemento de herramientas para integrar el script generador de registro de cambios de GNOME.</para>

  <figure id="tool-list">
    <title>La herramienta de edición</title>
    <screenshot>
	<screeninfo>La herramienta de edición</screeninfo>
     <graphic fileref="figures/tool-editor.png" format="PNG" srccredit="jhs"/>
    </screenshot>
   </figure>

  </sect1>

</chapter>

 <!-- Authors -->
  <chapter id="authors">
  <title>Autores</title>
   <para>Naba Kumar fundó el proyecto <application>Anjuta</application>. Visite <ulink type="http" url="http://anjuta.org/credits">esta lista en línea</ulink> para conocer todos los contribuidores de Anjuta.</para>

   <para>Para obtener más información acerca de <application>Anjuta</application>, visite la página web del proyecto en <ulink type="http" url="http://anjuta.org/">http://anjuta.org</ulink>. Los informes de error se deben rellenar usando la página de seguimiento de errores en el sitio web de desarrollo del proyecto en <ulink type="http" url="http://www.sourceforge.net/projects/anjuta"> http://www.sourceforge.net/projects/anjuta</ulink>.</para>
   
   <para>Naba Kumar, Andy Piper, Biswapesh Chattopadhyay y Johannes Schmid escribieron este manual. Envíe cualquier comentario y sugerencia acerca de este manual a la lista de desarrollo de Anjuta <email>anjuta-devel@list.sourceforge.net</email>. También se pueden enviar comentarios a traes de la página del proyecto en SourceForge.</para> 
</chapter>


 <!-- License -->
 <chapter id="license">
  <title>Licencia</title>
   <para>Este programa es software libre; puede redistribuirlo y/o modificarlo bajo los términos de la <ulink type="ghelp" url="gnome-help:gpl">Licencia Pública General GNU</ulink> tal como la publica la Free Software Foundation; tanto en la versión 2 de la Licencia, o (a su opción) cualquier otra versión posterior.</para>
   <para>Este programa se distribuye con la esperanza de que le sea útil, pero SIN NINGUNA GARANTÍA; sin incluso la garantía implícita de MERCANTILIDAD o IDONEIDAD PARA UN PROPÓSITO PARTICULAR. Vea la <citetitle>Licencia Pública General GNU</citetitle> para más detalles.</para>
   <para>Una copia de la <citetitle>Licencia Pública General GNU</citetitle> está incluidacomo un apéndice de la <citetitle>Guía del usuario de GNOME</citetitle>. También puede obtener una copia de la <citetitle>Licencia Pública General GNU</citetitle> a través de la Free Software Foundation visitando <ulink type="http" url="http://www.fsf.org">su página web</ulink> o escribiendo a la <address> Free Software Foundation, Inc. <street>51 Franklin Street</street> Fifth Floor <city>Boston</city>, <state>MA</state><postcode>02110-1301</postcode><country>EE. UU.</country></address></para>
</chapter>

</book>
