<?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="eu">
 <bookinfo>
  <title>Anjuta garapen-ingurune integratuaren eskuliburua</title>
  <edition>v1.0.0</edition>
  <abstract role="description">
  	<para>Anjuta garapen-ingurune integratuaren eskuliburua</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>
  
  <legalnotice>
   <para>Baimena ematen da dokumentu hau kopiatu, banatu eta/edo aldatzeko Free Software Foundation-ek argitaratutako <citetitle>GNU Dokumentazio Librearen Lizentzia</citetitle>ren 1.1. bertsioan edo berriago batean ezarritako baldintzak betetzen badira; Atal aldaezinik, Aurreko azaleko testurik eta Atzeko azaleko testurik gabe. <citetitle>GNU Dokumentazio Librearen Lizentzia</citetitle>ren kopia bat lortzeko Free Software Foundation-en bidez, bisitatu <ulink type="http" url="http://www.fsf.org">euren webgunea</ulink>, edo idatzi hona: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.</para>
   <para>Enpresek euren produktu eta zerbitzuak bereizteko erabiltzen dituzten izen asko marka erregistratu moduan hartu behar dira. Izen horiek GNOMEren edozein agiritan agertzen direnean, GNOMEren dokumentazio-proiektuko kideak marka erregistratuak direla konturatu badira, izen horiek osorik maiuskulaz edo hasierako letra maiuskulaz idatzi dituzte.</para>
  </legalnotice>

	<revhistory>
		<revision>
		  <revnumber>Anjutaren eskuliburua 2.1.0</revnumber>
		  <date>2007</date>
		  <revdescription>
			 <para role="author">Johannes Schmid<email>jhs@gnome.org</email></para>
			 <para role="publisher">Anjutaren lantaldea</para>
		  </revdescription>
		</revision>
	</revhistory>
		
 </bookinfo>
 <!-- Document Body -->
 <!-- Introduction -->
  <!-- ============= Introduction ============================== -->
 <chapter id="introduction">
  <title>Sarrera</title>
  <para>
  <application>Anjuta</application> is a versatile Integrated Development
  Environment (IDE) for the GNOME desktop. It features a number of advanced
  programming facilities includes project management, application
  wizards, an interactive debugger, an integrated Glade UI designer,
  integrated Devhelp API help, an integrated Valgrind memory profiler,
  an integrated gprof performance profiler, a class generator, a powerful
  source editor, source browsing, and more.
  </para>

  <para>
  Anjuta DevStudio has been designed to be simple to operate yet powerful enough
  to fulfill all your programming needs. We've added many new features to Anjuta
  over the course of its development. Our focus is on delivering
  power and usability at the same time and
  making your software development enjoyable without overloading your senses. We intend to
  continue improving and stabilizing Anjuta to give you the best IDE experience possible.
  We hope you will have a good time
  using Anjuta. If not, please help us make it better by reporting bugs and
  suggestions.
  </para>
  <para>
  The following screenshot illustrates some of the things you will find in Anjuta.
  </para>

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

  <para>
  Anjuta has a flexible and advanced docking system that allows you to
  lay out all views in whatever way you like. You can drag and drop the views
  using drag bars and rearrange the layout. The layouts are persistent for
  each project so you can maintain different layouts for different projects.
  All dock views are minimizable to avoid clutter in the main window. Minimized
  views appear as icons on the left side of the main window. You can configure all menu actions
  either by typing when the cursor is over a menu item (the usual GNOME way) or through
  a dedicated shortcut configuration user interface.
  </para>

  <para>
  Please report any problems with <application>Anjuta</application> - this will help to 
  improve the software, as well as helping the open source community.
  </para>
 </chapter>

 <!-- Getting Familiar with Anjuta -->
 <chapter id="familiar">
  <title>Anjuta ezagutzen</title>
 <!-- ============= Getting Familiar: Menus  ============-->
  <sect1 id="menu-and-shortcuts">
   <title>Menuak eta laster-teklak</title>
   <para>
   At the top of the <application>Anjuta</application> main window is the menu bar. 
   You can access almost all of Anjuta's functionality through 
   menu items. Operations have been grouped according to their type. For 
   example, file operations have been grouped into 
   the <guisubmenu>File</guisubmenu> menu.
   </para>
	
    <figure id="menubar">
      <title>Menu-barra</title>
	  <screenshot>
      <screeninfo>Anjuta-ren menu-barra</screeninfo>
       <graphic fileref="figures/menubar.png" format="PNG" srccredit="jhs"/>
      </screenshot>
    </figure>
    
    <figure id="file-menu">
      <title>Fitxategia menua </title>
      <screenshot>
      <screeninfo>Fitxategia menua </screeninfo>
       <graphic fileref="figures/file_menu.png" format="PNG" srccredit="jhs"/>
      </screenshot>
    </figure>
	
   <para>
    Shortcut keys are available for many menu items. All shortcut 
	keys are shown alongside the corresponding menu items. Some other useful shortcuts are listed here.
   </para>
	
   <para>
    <itemizedlist>
     <listitem>
      <para>
       <emphasis>Switch Editor Page:</emphasis> <keycombo><keycap>Ctrl</keycap><keycap>Alt</keycap><keycap>Page Up</keycap></keycombo>
       (forward) and <keycombo><keycap>Ctrl</keycap><keycap>Alt</keycap><keycap>Page Down</keycap></keycombo>
       (backward). You can
	   also switch pages by right-clicking on the notebook tabs and selecting a filename from the pop-up menu
	   (useful when all the tabs in the editor are not visible at once). Some desktop configurations
	   may already have these shortcut keys assigned. In that case, you will need to reconfigure them
	   (not in Anjuta, because they are fixed) if you want to use these shortcuts.
      </para>
     </listitem>
     <listitem>
      <para>
	   <emphasis>Context Help:</emphasis> <keycombo><keycap>Shift</keycap><keycap>F1</keycap></keycombo>.
       Place the cursor on the word (for example, the
	   function name) for which you want to get API help and type this shortcut. Context help
	   only works if you have <application>Devhelp</application> installed; otherwise,
       the context help menu and toolbar button
	   will be inactive. You can get Devhelp from the <application>Devhelp</application>
	   website. You will also have to install the related <application>Devhelp</application> books.
      </para>
     </listitem>
     <listitem>
      <para>
	  <emphasis>Autocomplete:</emphasis> <keycombo><keycap>Ctrl</keycap><keycap>Enter</keycap></keycombo>.
      Type this shortcut with the cursor placed
	  at the end of an incomplete word and a list of words matching the remaining part will appear.
	  Scroll and select the right word from the list if you find one.
      </para>
     </listitem>
     <listitem>
      <para>
	  <emphasis>More shortcuts:</emphasis> Look for the shortcut keys displayed on the right side
	  of menu item labels. Shortcuts can also be changed as explained in the tip below.
      </para>
     </listitem>
    </itemizedlist>
   <tip>
   <title>Pertsonalizatu laster-teklak</title>
   <para>
   You can change the default shortcuts by choosing <menuchoice><guisubmenu>Edit</guisubmenu>
	   <guimenuitem>Preferences</guimenuitem></menuchoice> and selecting the <interface>
	   Shortcuts</interface> tab.
   </para>
   </tip>
   </para>
  </sect1>

<!-- ============= Getting Familiar: Main window  ============-->
  <sect1 id="main-win">
   <title>Leiho nagusia</title>
   <para>
    The main window contains several view windows which can be rearranged by
	dragging on their title bars. They can also be minimized by clicking on the
    minimize buttons on the left of title bars.
   </para>

   <para>
    <orderedlist>
     <listitem>
      <para>
       The <interface>Documents window</interface> 
	   will have one document active at a time (if there are any files opened). All 
	   file commands will apply to this active document. You can switch to 
	   any document by clicking on its tab. You can do the same by right-clicking 
	   on the page tabs and choosing the document from the pop-up menu that will 
	   appear. This is especially useful when you have a lot of files opened, but not 
	   all of them are visible in the page tab area.
	   </para>
	 </listitem>
     <listitem>
      <para>
       The <interface>Project window</interface> shows a tree of project files if 
	   you have a project opened. Otherwise, the <interface>Project window</interface> 
	   is usually hidden. Double-clicking on any item in the 
	   <interface>Project window</interface> will open that file.
      </para>
     </listitem>
      <listitem>
      <para>
       The <interface>Files window</interface> shows a file tree. If no project is open, the file
       tree usually points to the file system root but you can change this in the preferences. If a project is 
       open, the window shows all files in the project. Double-clicking opens a file in the appropriate application
       as configured in the GNOME MIME preferences. Right-clicking opens a context menu which gives you
       choices about how to open the file.
      </para>
     </listitem>
      <listitem>
      <para>
       The <interface>Symbols window</interface> shows a tree of available symbols in the project
       generated from the <application>ctags</application> parser. Double-clicking opens an editor window with the corresponding file
       and line.
      </para>
      <para><interface>Bilaketa-fitxa</interface> bat ere badago ikurren leihoan, ikurrak bilatzeko.</para>
     </listitem>
     <listitem>
      <para><interface>Mezu-leihoa</interface>n mezu guztiak zerrendatuko dira kanpoko komando bat exekutatzen denean (<filename>stdout</filename> eta <filename>stderr</filename> irteerak). <interface>Mezu-leihoa</interface> ezkutuan egoten da normalean, baina kanpoko komando bat exekutatu bezain laster agertzen da (adibidez, konpilatzea, araztea, bilatzea eta abar). Hor erakusten dira <application>Anjuta</application>ren mezuak, behar denean.</para>
      <para>
	  The colors used to display the messages are important. Messages 
	  displayed in the standard foreground color (usually black) are normal 
	  messages. Messages displayed in orange are warnings, and those displayed in red are errors.
	  Warning and error messages are <emphasis>linked</emphasis>:
	  double-clicking on such a message will take you to the particular file and 
	  line number specified in the message.
      </para>
      <para>
      For example, when you compile a file which contains errors, some red 
	  messages will appear showing what the problems are, and where they occur. 
	  Double-clicking on such messages will open the file and highlight the 
	  line containing the error.
	  </para>
     </listitem>
     <listitem>
      <para>
       The <interface>Terminal window</interface> is a terminal emulator where you can type commands
       just like in the GNOME Terminal application.
      </para>
     </listitem>
    </orderedlist>
   </para>
   <note>
   <title>Saio-kudeaketa</title>
   <para>
   All settings, including window sizes and positions, are 
   saved when you exit <application>Anjuta</application>. Session management is still 
   under development, so you should not exit <application>Anjuta</application> with 
   any unsaved documents. <application>Anjuta</application> will display a warning 
   if you try to exit with unsaved documents still open.
   </para>
   </note>
  </sect1>
 </chapter>

 <!-- File operations -->
  <chapter id="file-operations">
  <title>Fitxategi-eragiketak</title>
  
  <!-- ============= File operations: Creating a new file === -->
  <sect1 id="creating-files">
   <title>Creating a new file and inserting text</title>
    <sect2 id="new-file">
    <title>Creating a New File</title>
     <para>
     To create a new file, choose <menuchoice><guisubmenu>File</guisubmenu>
     <guimenuitem>New</guimenuitem></menuchoice> from the menu bar, or click on the 
     <guibutton>New File</guibutton> button on the main toolbar. A new page will 
     appear in the editor (or a new window if the parent document is windowed). 
     New documents will be named <filename>newfile#1</filename>, 
     <filename>newfile#2</filename>, <filename>newfile#3</filename> and 
     so on. 
     </para>
	   <important>
	   <title>Gorde fitxategia</title>
	   <para>Dokumentu berriak lehenbailehen gordetzea komeni da, sistemak huts egiten badu daturik ez galtzeko.</para>
	   </important>
    </sect2>
    <sect2 id="file-wizard">
    <title>Fitxategien morroia</title>
     <para>
      A wizard can also be used to create a new file. To create a new file, choose
      <menuchoice><guisubmenu>File</guisubmenu><guisubmenu>New</guisubmenu> 
      <guimenuitem>File</guimenuitem></menuchoice> from the menu bar.
      This will open the New File dialog. Select the file type. Enter the filename. 
      The suffix will be automatically added. 
      You can add license information (according to your license choice) and a header.
      In case of a C/C++ header file, you can also add an header template.
      Click <guibutton>OK</guibutton> to validate the creation.
      <figure id="new-file-wizard">
       <title>Fitxategi berrien morroia</title>
       <screenshot>
        <screeninfo>'Ireki fitxategia' elkarrizketa-koadroa</screeninfo>
        <graphic fileref="figures/new_file_wizard.png" format="PNG" srccredit="jnoel"/>
       </screenshot>
      </figure>
     </para>
     <para>
       <application>Anjuta</application> occasionally also creates new file windows during some
        operations. For example, some Subversion operations such as <command>Diff</command> and
        <command>View Log</command>
        create new file windows and add the output there. You can save the contents of these windows
        to real files if you like.
     </para>
     </sect2>
     <sect2 id="inserting-macros">
      <title>Makroak txertatzea</title>
       <para>
         You can use <emphasis>macros</emphasis> to quickly edit repetitive sequences of text.
       </para>
       <important>
       <para>
        The Macro plugin must be activated.
       </para>
       </important>
      <sect3 id="inserting">
       <title>Txertatzea</title>
       <para>
        Two types of macros are available: Anjuta macros and user macros (displayed as "My macros"). Anjuta macros 
        are not modifiable, but you can define and modify your own user macros.
       </para>
       <para>
        To insert a macro, move the cursor to the desired place. Select  
        <menuchoice><guisubmenu>Edit</guisubmenu><guisubmenu>Macros</guisubmenu>
        <guimenuitem>Macros...</guimenuitem></menuchoice>. A dialog window appears. Select the 
        desired macro in the list. The result of the macro expansion is displayed in the window and a
        summary is shown in the dialog window. Choose <guibutton>Insert</guibutton>. The expanded macro
        text is inserted at the cursor position.
       </para>
       <para>
        Another way to insert a macro is to select <menuchoice><guisubmenu>Edit</guisubmenu>
        <guisubmenu>Macros</guisubmenu><guimenuitem>Insert Macro...</guimenuitem></menuchoice>, 
        then to press the desired macro shortcut.
        <figure id="display-macro">
         <title>Makroa</title>
          <screenshot>
           <screeninfo>Makroen elkarrizketa-koadroa</screeninfo>
           <graphic fileref="figures/display_macro.png" format="PNG" srccredit="jnoel"/>
          </screenshot>
        </figure>
       </para>
       </sect3>
       <sect3 id="defining-macro">
        <title>Makroak definitzea</title>
        <para>
          From the Insert Macro window, choose <guibutton>Add</guibutton> or select <menuchoice>
          <guisubmenu>Edit</guisubmenu><guisubmenu>Macros</guisubmenu><guimenuitem>Add Macro...
          </guimenuitem></menuchoice>. The Add/Edit window appears. Enter the macro name, choose or 
          define a category and enter a shortcut. Then edit text relative to your macro. The character 
          ' | ' will indicate the cursor position after the macro insertion. Choose
          <guibutton>OK</guibutton>. The macro is added to the list.
        </para>
        <para>
          You can also erase a macro by selecting it in the list and choosing
          <guibutton>Remove</guibutton>.  This only works for user macros (My Macros), of course.
        </para>
        <para>
          Similarly, you can edit and modify a macro by selecting it in the list and choosing
         <guibutton>Edit</guibutton>.
         <figure id="add-edit-macro">
          <title>Gehitu/Editatu makroa</title>
          <screenshot>
           <screeninfo>Gehitu/Editatu elkarrizketa-koadroa</screeninfo>
           <graphic fileref="figures/add_edit_macro.png" format="PNG" srccredit="jnoel"/>
          </screenshot>
         </figure>	
        </para>
       </sect3>
       <sect3 id="macro-keyword">
        <title>Makroen gako-hitzak</title>
        <para>
          Macro keywords are available. They can be included in macro definitions.
          These macro keywords start and finish with the character ' @ '.
        </para>
        <para>
         Available macro keywords are @DATE_TIME@, @DATE_YMD@, @DATE_Y@, @USER_NAME@, @FILE_NAME@,
         @FILE_NAME_UP@, @FILE_NAME_UP_PREFIX@, @EMAIL@, @TABSIZE@, @INDENTSIZE@, and @USETABS@.
         <figure id="keyword-macro">
         <title>Gako-hitza makroa</title>
          <screenshot>
           <screeninfo>Gako-hitza makroa</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>Fitxategiak irekitzea eta gordetzea</title>
   <para>
    <orderedlist>
     <listitem>
      <para>
       <emphasis>Opening a file:</emphasis> 
	   To open an existing file, choose <menuchoice><guisubmenu>File</guisubmenu>
	   <guimenuitem>Open</guimenuitem></menuchoice> from the menu bar, click on 
	   the <guibutton>Open</guibutton> button on the toolbar, or press 
	   <keycombo><keycap>Ctrl</keycap><keycap>O</keycap></keycombo>. This will 
	   display the <interface>Open File</interface> dialog.
       <figure id="open-file">
        <title>'Ireki fitxategia' elkarrizketa-koadroa</title>
        <screenshot>
		<screeninfo>'Ireki fitxategia' elkarrizketa-koadroa</screeninfo>
         <graphic fileref="figures/open_file.png" format="PNG" srccredit="jnoel"/>
        </screenshot>
       </figure>
       Select or enter the name of file you want to open, then click 
	   <guibutton>Open</guibutton>. To open more than one file at once, select multiple files
	   to open by holding down the <keycap>Ctrl</keycap> key and clicking each file in turn; then
	   press <guibutton>Open</guibutton>. If you change your mind, click 
	   <guibutton>Cancel</guibutton> to dismiss the dialog without opening 
	   the file.
      </para>
	  <para>
	   <figure id="open-file-multiple">
        <title>'Ireki fitxategi bat baino gehiago' elkarrizketa-koadroa</title>
        <screenshot>
		<screeninfo>'Ireki fitxategia' elkarrizketa koadroa, fitxategi bat baino gehiago hautatzeko moduan</screeninfo>
         <graphic fileref="figures/open_file_multiple.png" format="PNG" srccredit="jnoel"/>
        </screenshot>
       </figure>
	  </para>
	  <para>
	   You can enable the <emphasis>Show Hidden Files</emphasis> option through the pop-up menu
       that appears when you right-click in the Open File dialog.  This option will make hidden
	   files (files starting with ".") visible in the file list. Clear the option to hide hidden files.
       The Open File dialog also has a built-in
	   file type filter. Select the appropriate file type filter in the dialog and the file
	   list will be limited to the files of the selected type only.
	  </para>
     </listitem>
     
     <listitem>
      <para>
       <emphasis>Saving a file:</emphasis> 
	   To save a file, choose <menuchoice><guisubmenu>File</guisubmenu>
	   <guimenuitem>Save</guimenuitem></menuchoice> from the menu bar, click on 
	   the <guibutton>Save</guibutton> button on the toolbar, or press 
	   <keycombo><keycap>Ctrl</keycap><keycap>S</keycap></keycombo>. This will 
	   save the file. If the file is new, a <interface>Save As</interface> dialog will 
	   appear. Enter a filename and click <guibutton>Save</guibutton> to save the new file 
	   with the name supplied.
	   <screenshot>
	    <screeninfo>Gorde fitxategi gisa</screeninfo>
            <graphic fileref="figures/save_as_file.png" format="PNG" srccredit="jnoel"/>
           </screenshot>
      </para>
	   <note>
	   <title>File autosave</title>
		<para>
		If you have enabled autosave, Anjuta will not autosave any new files. 
		You must first save them manually. The same applies to the 
		<guimenuitem>Save All</guimenuitem> option: Anjuta will not save new files, 
		if you haven't saved them first manually. <emphasis>You must save a file manually 
		before autosave or <guimenuitem>Save All</guimenuitem> will work with it.</emphasis>    
		</para>
	   </note>
     </listitem>

     <listitem>
      <para>
      <emphasis>Saving a file with a different name:</emphasis> 
	  You can explicitly save a file with a new filename. To do this, choose 
	  <menuchoice><guisubmenu>File</guisubmenu><guimenuitem>Save As</guimenuitem></menuchoice> 
	  from the menu bar. A <interface>Save As</interface> dialog will appear prompting you to 
	  enter the new filename. Enter the name and click <guibutton>Save</guibutton>.
      </para>
      <note>
       <title>Gorde fitxategia gainidatzita</title>
       <para>
        When you use <guimenuitem>Save As</guimenuitem> with an existing file, 
		the original is not deleted. It is left unchanged since the last save. 
		If a file with the new filename already exists, a confirmation dialog 
		will appear to ensure that you want to overwrite it. Clicking 
		<guibutton>Yes</guibutton> will overwrite the file with the file you 
		are saving.
       </para>
      </note>
     </listitem>
     
     <listitem>
      <para>
      <emphasis>Closing a file:</emphasis> 
	  To close a file, choose <menuchoice><guisubmenu>File</guisubmenu>
	  <guimenuitem>Close</guimenuitem></menuchoice> from the menu bar, or click on the 
	  <guibutton>Close</guibutton> button on the toolbar. (You can also close a file
	  by clicking the X in its filename tab.) This will close
	  the current file. If the file is not saved, or is a new file, then 
	  <application>Anjuta</application> will prompt you to save the file before 
	  closing it.
      </para>
     </listitem> 
    </orderedlist>
   </para>
  </sect1>
 
 <!-- ============= File operations: Editing files === -->
  <sect1 id="editing-files">
   <title>Fitxategiak editatzea</title>
   <para>
    <application>Anjuta</application> has a number of features which help you
    edit and work with source files. The following sections describe how to use 
	some of the interesting features available.
   </para>
   <sect2 id="editor-margins-sec">
   <title>Editorearen marjinak</title>
      <para><emphasis>Editor Margins:</emphasis> Editor margins appear to the
	   left of the editor and are used for some special purposes. There are three editor margins available:
       the <emphasis>line number margin</emphasis>, the <emphasis>marker margin</emphasis>
       and the <emphasis>code fold margin</emphasis>.
       By default (that is, when you run <application>Anjuta</application> for the first time) only
       the code fold margin will be visible. The rest can be made visible via
       <menuchoice><guimenu>View</guimenu><guisubmenu>Editor</guisubmenu></menuchoice>.
       <figure id="editor-margins">
        <title>Editorearen marjinak</title>
        <screenshot>
         <screeninfo>Etiketen tresna-barra</screeninfo>
         <graphic fileref="figures/editor_margins.png" format="PNG" srccredit="naba"/>
        </screenshot>
       </figure>
       </para>
       <para>
	   The <emphasis>line number margin</emphasis> is largest of all the three margins (and is slightly
	   darker then rest) and displays a document's line numbers.
	   The <emphasis>line number margin</emphasis> can be shown or hidden
	   by toggling <menuchoice><guimenu>View</guimenu><guisubmenu>Editor</guisubmenu>
	   <guimenuitem>Line Numbers Margin</guimenuitem></menuchoice>. Left-clicking on this margin
	   will select an entire line (including the trailing newline, if present). You can set font
	   properties for the line number margin in the preferences.
      </para>
	  <para>The <emphasis>marker margin</emphasis> can be shown or hidden
	   via <menuchoice><guimenu>View</guimenu><guisubmenu>Editor</guisubmenu>
	   <guimenuitem>Markers Margin</guimenuitem></menuchoice>. This margin displays graphical icons
	   to mark the given line. The margin may display bookmark markers
	   (blue and rectangular), breakpoint markers (red and circular)
       and line indicator markers (which look like a yellow pointed arrow).
       A bookmark marker indicates a bookmarked line, and can
	   be toggled via <menuchoice><guimenu>Goto</guimenu><guisubmenu>Bookmark</guisubmenu><guimenuitem>
	   Toggle Bookmark</guimenuitem></menuchoice>
	   with the cursor placed on that line. A breakpoint marker is used in the debugger to indicate a
	   debugging breakpoint (see the Debugging section for more details). A line indicator
	   marker is used to indicate the current program position in the debugger.
       </para>
       <para>
        The <emphasis>code fold margin</emphasis> is where the folding tree is visible. Clicking 
        on folding tree nodes will fold or unfold code blocks. An underline will also
        be drawn below a folded line to make it more obvious that a block of code has been 
        folded below the line. For more details on code folding, see the section <emphasis>Code Folding</emphasis>
        below.
       </para>
       <note>
       <title>Marjina-markatzaile ikusezina</title>
        <para>
         If the marker margin is not visible, Anjuta displays markers by changing the
         background color of a line. For example, if a breakpoint marker is set in 
         a line and the marker margin is not visible, that line will be displayed with a red
         background. Similarly, for a bookmark marker and a line indicator marker the background
         color of the line will be sky blue and yellow, respectively. If you do not like this
         (perhaps due to some contrasting themes), enable the marker margin
         via <menuchoice><guimenu>View</guimenu><guisubmenu>Editor</guisubmenu>
         <guimenuitem>Marker Margin</guimenuitem></menuchoice>.
         <figure id="editor-markers">
          <title>Editor markers when the marker margin is invisible</title>
          <screenshot>
           <screeninfo>Etiketen tresna-barra</screeninfo>
           <graphic fileref="figures/editor_markers.png" format="PNG" srccredit="naba"/>
          </screenshot>
         </figure>
        </para>
       </note>
      </sect2>
      <sect2 id="editor-guides-sec">
      <title>Editorearen gidak</title>
      <para>The editor can be set to display certain document information which is
      normally invisible, including <emphasis>indentation guides</emphasis>, <emphasis>white space</emphasis>
      and <emphasis>line end characters</emphasis>. They can be make
      visible or invisible by toggling the menu items in <menuchoice><guimenu>View</guimenu>
      <guisubmenu>Editor</guisubmenu></menuchoice>. Indentation guides are small dotted lines 
      drawn to connect matching braces in source code. When the cursor is over a
      matching brace, its dotted indentation guide is highlighted to emphasize the indentation level visually.
      </para>
       <figure id="editor-guides">
        <title>Gidadun editorea</title>
        <screenshot>
         <screeninfo>Gidadun editorea</screeninfo>
         <graphic fileref="figures/editor_guides.png" format="PNG" srccredit="naba"/>
        </screenshot>
      </figure>
    </sect2>
   <sect2 id="highlighting">
   <title>Sintaxia nabarmentzea</title>
   <para>
    <application>Anjuta</application> can highlight the syntax of many different languages. 
	This is usually done automatically by determining the type of a file from its 
	extension. If <application>Anjuta</application> cannot determine the type of 
	a file, there will be no syntax highlighting. You can explicitly force a particular 
	highlight style by selecting the style from the menu 
	<menuchoice><guimenu>View</guimenu><guisubmenu>Editor</guisubmenu><guisubmenu>
	Highlight Mode</guisubmenu></menuchoice>.
   </para>
    <note>
     <para>
	Anjuta uses a properties file named
	<filename>$prefix/share/anjuta/properties/anjuta.properties</filename>,
	which has the same format as a SciTE properties file but does not use
	all properties. The style of each element for all languages is
	defined in a file named 
	<filename>$prefix/share/anjuta/properties/styles.properties</filename>.
	It uses some common properties defined by Anjuta in the file
	<filename>$home/.config/anjuta/scintilla/editor-style.properties</filename>.
     </para>
   </note>
   </sect2>
   <sect2 id="codefolding">
    <title>Kodeak tolestea</title>
    <para>
     Anjuta can display <emphasis>code folds</emphasis> for source files in block-structured
     languages (such as C, C++, Pascal, and Java).
     All code blocks in a source file can be folded or unfolded by clicking on the
     fold points in the code fold margin of the <interface>Editor</interface> window
	 (usually a +/- symbol or up/down arrow). These fold points automatically appear for 
	 source files which use code blocks.
    </para>
    <para>
     Code folding is especially useful when editing large source files with
     thousands of lines. Once the folds are closed, a document appears to become 
	 smaller, facilitating easy browsing and editing of the file.
    </para>
    <note>
     <para>
	  Please note that code folding and editor guides are only available in
      the Scintilla-based editor.
	 </para>
	</note>
   </sect2>
   <sect2 id="autoformat">
    <title>Iturburu-kodeari formatua automatikoki ematea</title>
    <para>
      Anjuta can automatically indent (auto-format) C or C++ source or header files. This gives a clean look to
      the source code, increases legibility, reduces the likelihood of syntax errors,
      and above all saves time. To auto-indent the current source file, choose
      <menuchoice><guimenu>Edit</guimenu><guimenuitem>Auto Indent
      </guimenuitem></menuchoice> on the menu bar. You can change the style of formatting by customizing the 
      choices in the preferences.
    </para>
   </sect2>
  </sect1>

 <!-- ============= File operations: Browsing with the tags browser ===   -->
  <sect1 id="browsing-files">
   <title>The Symbol Browser</title>
   <para>
    You can browse C and C++ source and header files using <emphasis>tags</emphasis> in the files. 
	A tag (or <emphasis>symbol</emphasis>) refers to a named entity such as a function definition, structure, or macro.
    Anjuta scans open C and C++ source and header files for available tags.
   </para>
   <para>
    <application>Anjuta</application> will automatically scan for tags 
    in all of the source and header files of any open project. You can
	jump to any function definition, structure definition, class definition or other tag 
	without manually opening the containing file. You don't even have to know which file the
	tag is found in. The symbol browser
    lists all available symbols in the project.
    <figure id="symbol-browser">
     <title>Ikur-arakatzailea</title>
     <screenshot>
      <screeninfo>Ikur-arakatzailea</screeninfo>
      <graphic fileref="figures/symbol_browser.png" format="PNG" srccredit="jhs"/>
     </screenshot>
    </figure>
    </para>
   <tip>
    <title>Tag synchronization</title>
    <para>Ez duzu arduratu behar etiketen datu-basea sinkronizatzeaz eta eguneratzeaz. <application>Anjuta</application>k bere gain hartzen du dena. Zein etiketara joan nahi duzun aukeratu behar duzu, besterik ez.</para>
   </tip>
   
  </sect1>

  <!-- ============= File operations: Searching and replacing in files === -->
  <sect1 id="search-replace-files">
   <title>Fitxategietan testua bilatzea eta ordeztea</title>
    <sect2 id="searching">
    <title>Bilatzea</title>
      <para>
       To search for a <emphasis>string</emphasis> or <emphasis>regular expression</emphasis>
       in the current file, choose <menuchoice><guimenu>Edit</guimenu>
       <guisubmenu>Search</guisubmenu><guimenuitem>Find</guimenuitem></menuchoice>
       or press <keycombo><keycap>Ctrl</keycap><keycap>Alt</keycap><keycap>F</keycap></keycombo>.
       This will open the <interface>Find</interface> dialog. 
      </para>
      <para>
       Use the text box to specify the string to search for, and select whether it is a normal 
       string or a regular expression. You can also specify the direction of 
       search, whether the search is case-sensitive or not, and the scope of the search. Click 
       <guibutton>Search</guibutton> to start searching.
      </para>
      <para>
       If the search is successful, Anjuta will jump to the matched text or perform another action
       (according to the <guilabel>Search Action</guilabel> you choose in the <guilabel>Search Target</guilabel> tab). If the search is not successful, Anjuta will display 
       a message indicating that the search text was not found.
      </para>
      <para>
       If you want to search again, click the <guibutton>Search</guibutton> button again
       or press <keycombo><keycap>Ctrl</keycap><keycap>G</keycap></keycombo>. This will 
       find the next match (use <keycombo><keycap>Shift</keycap><keycap>Ctrl</keycap>
       <keycap>G</keycap></keycombo> for the previous match). You can even 
       change the search text when you do this; enter the new string in the 
       <guilabel>Search Expression</guilabel> text box in the search dialog.
      </para>
      <figure id="search-expr">
      <title>'Bilatu testua' elkarrizketa-koadroa</title>
        <screenshot>
        <graphic fileref="figures/search_expr.png" format="PNG" srccredit="jhs"/>
        </screenshot>
      </figure>
	  <para>
	    To stop a long search, press the <guibutton>Stop</guibutton> button.
	  </para>
    </sect2>
    <sect2 id="search-range">
    <title>Bilaketa-barrutia zehaztea</title>
      <para>
        In the <interface>Search Target</interface> tab, define the search location and the action 
		to be performed if the search succeeds.
      </para>
      <para>
        You can define the maximum number of actions to be performed.
      </para>
      <figure id="search-target">
      <title>Bilaketa-helburua elkarrizketa-koadroa</title>
        <screenshot>
        <graphic fileref="figures/search_target.png" format="PNG" srccredit="jhs"/>
        </screenshot>
      </figure>
      <para>
        You can select which text will be searched.
      </para>
      <figure id="search-target-in">
      <title>'Bilatu helburua hemen' aukera</title>
       <screenshot>
       <graphic fileref="figures/search_target_in.png" format="PNG" srccredit="jhs"/>
       </screenshot>
      </figure>
      <sect3 id="search-file">
      <title>Fitxategietan bilatzea</title>
       <para>
         To find text in your project, set <guilabel>Search In</guilabel> to
	     All Project Files.
       </para>
       <para>
         In the <guilabel>Search Expression</guilabel> tab, enter the text you want to search for and specify search options, such as the <guilabel>Match case</guilabel>
         or <guilabel>Match complete words</guilabel> options.
         Click <guibutton>Search</guibutton> to start searching.
       </para>
       <para>
         To find text in a set of files, set <guilabel>Search In</guilabel> to
	     Specify File Patterns. Define the search variables.  
         Click <guibutton>Search</guibutton> to start searching.		 
       </para>	 
         <figure id="search-file-pattern">
         <title>Bilatu fitxategi-eredua</title>
          <screenshot>
          <graphic fileref="figures/search_file_pattern.png" format="PNG" srccredit="jhs"/>
          </screenshot>
       </figure>

      </sect3>		 

	</sect2>
    <sect2 id="search-action">
    <title>Specifying a Search Action</title>
      <para>
        You can select which action will be performed when a search succeeds.
      </para>
      <para>
        Depending on the previous selections (<guilabel>Search In</guilabel>, <guilabel>Search Direction</guilabel>
        , and so on),
		some actions may be unavailable.
      </para>
      <figure id="search-target-action">
      <title>'Bilaketa-helburuaren ekintzak' aukera</title>
       <screenshot>
       <graphic fileref="figures/search_target_action.png" format="PNG" srccredit="jhs"/>
       </screenshot>
      </figure>
  
    </sect2>
    <sect2 id="replacing">
    <title>Ordeztea</title>
      <para>
       Searching and replacing is similar to just finding text, except that you 
       also specify the replacement text in the <guilabel>Replace With</guilabel> text box, 
       and also specify whether or not you want to be prompted before each replacement takes place
	   (Replace First Match or Replace All Matches).
      </para>
      <figure id="replace">
      <title>Ordeztea</title>
        <screenshot>
        <graphic fileref="figures/search_replace.png" format="PNG" srccredit="jhs"/>
        </screenshot>
      </figure>
	  <para>Agerraldia ordezteko aukeratu <guibutton>Ordeztu</guibutton> botoia, eta hurrengo agerraldira saltatzeko aukeratu <guibutton>Aurrera</guibutton> botoia.</para>

	</sect2>
    <sect2 id="search-setting">
    <title>Bilaketaren ezarpenak</title>
      <para>
        You may also save search options.
      </para>
      <para>
        The item highlighted in red is the active item. The default item specifies search
		settings which are loaded when Anjuta launches.
      </para>
      <figure id="search-setting-fig">
      <title>Bilaketa-ezarpena elkarrizketa-koadroa</title>
        <screenshot>
        <graphic fileref="figures/search_setting.png" format="PNG" srccredit="jhs"/>
        </screenshot>
       </figure>
    </sect2>

  </sect1>

 <!-- ============= File operations: Printing Files === -->
   <sect1 id="printing">
    <title>Fitxategi bat inprimatzea</title>
    <para>
     You can perform a print preview by selecting 
	 <menuchoice><guisubmenu>File</guisubmenu><guimenuitem>Print Preview</guimenuitem></menuchoice>.
	 This will render the current file and present a preview of the print. Source code which
	 is highlighted in the editor is also highlighted similarly in the preview (and subsequent print).  The
	 <guilabel>Printing</guilabel> tab of your editor plugin preferences contains additional
	 options which let you print with line numbers, wrapped lines and/or headers.
	 <figure>
       <title>C fitxategiaren inprimatzeko aurrebista</title>
       <screenshot>
       <screeninfo>Inprimatzeko aurrebista</screeninfo>
        <graphic fileref="figures/print_preview.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure>
	</para> 
    <para>
	 <figure>
       <title>Inprimatzeko hobespenak</title>
       <screenshot>
	   <screeninfo>Inprimatzeko hobespenak</screeninfo>
        <graphic fileref="figures/prefs_print.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure>
	</para>
	<para>
	When you are ready to print and satisfied with the preview, select 
	<menuchoice><guisubmenu>File</guisubmenu><guimenuitem>Print</guimenuitem></menuchoice>
	or <guibutton>Print</guibutton> from the print preview window. This will bring up the
	actual print dialog as shown below. Select the appropriate print parameters and press
	<guibutton>Print</guibutton> to print the file.
	</para>
	<para>
	You can also set landscaped or portrait page layout and the paper size, page orientation
	and paper type. Remember to set them up properly according to your printer,
	otherwise printing may not look correct.
	</para>
	<para>
	 <figure>
       <title>Inprimatzeko elkarrizketa-koadroa</title>
       <screenshot>
	   <screeninfo>Inprimatzeko elkarrizketa-koadroa</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>Proiektu-kudeaketa</title>
  
  <para>
  Anjuta has a powerful Project Manager plugin which can open most
  <ulink type="info" url="info:automake">automake/autoconf</ulink>-based projects.
  It might fail on some
  oddly-configured projects, but as long as the project uses
  automake/autoconf in a typical way, it should work.
  </para>

  <para>
  The neat thing is that Anjuta does not store any project information beyond what
  is already available in the project structure. That is, there is no separate
  project data maintained by Anjuta and all project processing is done
  directly within the project structure. This allows a project to be
  maintained or developed outside Anjuta without any need to convert to or from
  an Anjuta-specific format. Since technically Anjuta
  projects are just automake projects, mixed development (with both Anjuta and
  non-Anjuta users) or switching back and forth between Anjuta and other
  tools is quite possible without any hindrance.
  </para>

  <sect1 id="new-project">
   <title>Proiektu berria sortzea</title>
   <sect2 id="new-project-from-template">
   <title>Creating a project from a template</title>
   <para>
   The project wizard plugin uses a powerful template processing engine
   called <application>autogen</application>. All new projects are created from
   templates that
   are written in <application>autogen</application> syntax. The project wizard
   lets you create new
   projects from a selection of project templates. The selection includes
   simple generic, flat (no subdirectory), GTK+, GNOME, Java, Python
   projects and more. New templates can be easily downloaded and
   installed since each template is just a collection of text files.
   </para>

   <para>
    To create a project, choose the menu item <menuchoice><guisubmenu>File</guisubmenu><guisubmenu>New</guisubmenu>
    <guimenuitem>Project …</guimenuitem></menuchoice>
    to start the application wizard.
    Read the first page carefully. Click on 
	<guibutton>Next</guibutton> to proceed.
   </para>
   <para>
    Select the type of application you want to create in the
    second page.
    Click on <guibutton>Next</guibutton> to proceed.   
   </para>

   <para>
    On the following pages, enter all necessary
    details for your project. You can change these settings later, but
    it is advisable to set them right initially in order to maintain the project's
    integrity.
    White spaces or any non-alphanumeric characters, except 
    underscore (_) and dash (-), are not allowed in many of the entry boxes 
	that follow (except perhaps the
    <guilabel>Author</guilabel> text box).
	</para>

   <para>
    You can also specify whether your  
    project will have <emphasis>internationalization support</emphasis> 
    using <application>gettext</application> (read the
    <ulink type="info" url="info:gettext">gettext info page</ulink> for 
	more details). This gives your project multilingual support for 
	different languages such as English, French and Dutch.
    The rest of the options are for setting whether the GNU copyright 
	statement should appear in the comments at the top of each file, and for
	enabling GNOME desktop menu information if necessary. Shared library
    support allows you to add shared library modules later on. If
    you plan to have libraries in your project, it would be good to enable this.
    Depending on the project type that is being created, Anjuta may request
    additional information.
   </para>

   <para>Sartutako informazioa egiaztatu behar da azken urratsean. Proiektua sortzen hasteko, egin klik <guibutton>Amaitu</guibutton> botoian.</para>

   <para>
    Once the project has been generated, you can try it out by 
    building it and executing it.
   </para>
  </sect2>
   <sect2 id="importing-project">
    <title>Proiektuak inportatzea</title>
    <para>
     The import project feature is used to import an already existing project and convert it into an
     <application>Anjuta</application> project. Activate the import project wizard via
     <menuchoice><guimenu>File</guimenu><guimenu>New</guimenu>
	<guimenuitem>Project from existing sources</guimenuitem></menuchoice>
     and follow the instructions dictated by the wizard. Once a project has been imported, it can be
     opened in <application>Anjuta</application> subsequently just like any other <application>
     Anjuta</application> project.
    </para>
	<note>
	<para>
	The import project feature only works if your existing project uses
    <ulink type="info" url="info:automake">autoconf/automake</ulink> or,
    to a very limited extent, a plain Makefile.
	</para>
	</note>
   </sect2>
  </sect1>
  
  <sect1 id="load-save-projects">
   <title>Proiektuak kargatzea eta gordetzea</title>
   <sect2 id="loading-project">
    <title>Proiektuak kargatzea</title>
    <para>Proiektu bat irekitzeko, aukeratu <menuchoice><guisubmenu>Fitxategia</guisubmenu><guimenuitem>Ireki…</guimenuitem></menuchoice> menu-elementua. Hautatu proiektu-fitxategia (<filename>*.anjuta</filename>) elkarrizketa-koadroan, eta egin klik <guibutton>Ados</guibutton> botoian.</para> 

    <para>
     If the project has recently been opened, then you will find it listed in the 
     menu <menuchoice><guisubmenu>File</guisubmenu><guisubmenu>Recent</guisubmenu></menuchoice>. 
	 Choose the project filename from the list, and the project will be opened. 
    </para>
    <para>
     As soon as a project is opened, <application>Anjuta</application> will enter 
	 <emphasis>Project mode</emphasis>. There are three panes in the project window. The
     first is the project pane and lists project files organized by file type. The second
     is the symbol browser, which has already been discussed in the section <emphasis>The Symbol Browser</emphasis>. The third pane is the file view of the project and
     is more or less similar to a mini file-manager. In the file view, all the files present
     in the project tree are visible. Right-clicking on these files will pop up a
     context menu with file operations.
    </para>
    <para>
     If the project is also a CVS tree, then corresponding file revision numbers are also
     listed to the right of file names in the file view pane.
    </para>
   </sect2>
   <sect2 id="saving-project">
    <title>Proiektuak gordetzea</title>
    <para>Automatikoki gordetzen da proiektua, proiektua ixtean; izan ere, aldaketa guztiak proiektuaren egituran egiten dira zuzenean.</para>
   </sect2>
  </sect1>

  <sect1 id="projects-structure">
  <title>Proiektuaren egitura</title>
  <para>
   Here is the <interface>Project window</interface> with its  
   context menu
   (accessible by clicking on the right mouse button). 
   <figure id="project-window">
    <title>Project window</title>
    <screenshot>
     <screeninfo>The Project window</screeninfo>
     <graphic fileref="figures/project-window.png" format="PNG" srccredit="jhs"/>
    </screenshot>
   </figure>
  </para>
  <para>
  The <interface>Project window</interface> displays the project's
  <ulink type="info" url="info:automake"><application>automake</application></ulink>
  hierarchy organized
  into <emphasis>groups</emphasis> of <emphasis>targets</emphasis>. Groups correspond to
  directories in your project and targets
  correspond to normal <application>automake</application> targets (not to be confused
  with make targets). The <interface>Project window</interface> actually
  has two parts: the lower part
  shows the complete project hierarchy and the upper part
  lists important targets directly. Important targets include executable
  and library targets; the view makes these easily accessible.
  This is particularly useful in large projects where the hierarchy
  can be deep and hard to navigate from the tree alone. Targets are, in
  turn, composed of source files.
  </para>

  <para>
  <itemizedlist>
   <listitem>
    <para>
      <emphasis>Groups</emphasis> are used to logically organize targets.
      A project can contain any number of groups. Each group can have subgroups
      as well as targets. In automake projects, groups are just subdirectories
      in the project. The top-level group is always labeled "/".
    </para>
   </listitem>
   <listitem>
    <para>
      <emphasis>Targets</emphasis> are the build targets in the project, such as
      programs (executable binaries), scripts, libraries and miscellaneous data.
      Not all target types are built from sources; some exist just to
      organize sources and therefore may not exist physically (e.g. a
      Miscellaneous Data target).
      Targets exist under groups. See <link linkend="adding-target">"Adding targets"</link> for
      a full list of available target types.
    </para>
   </listitem>
   <listitem>
    <para>
      <emphasis>Source files</emphasis> may be used to build targets, though some source files
      simply belong to targets. They exist only under targets. Many target types
      expect certain type of source files (e.g. the Programs and Libraries target
      types), but some can accept any file (e.g. a Miscellaneous Data target).
    </para>
   </listitem>
  </itemizedlist>
  </para>

  <para>
  Each project group and target is configurable in the standard
  <application>automake</application> way. You can set compiler and linker
  flags directly for each target, or set <application>configure</application> variables. Groups allow
  you to set an installation destination for their targets.
  </para>

  <para>
  Just like the file manager, the project manager view also has convenience actions
  (accessible from the context menu) for source
  files and targets.
  </para>

  <para>
   Many command-line tools are available to maintain and manage a project, 
   and each tool has its own specific rules and capabilities.
   <application>Anjuta</application> tries to automate most common
   operations using plugins. However, you might occasionally still need
   to perform certain operations manually.
  </para>
  
  <para>
   You may modify a project's structure using external tools or by hand-editing the project
   files.   It doesn't matter whether the project is loaded in
   <application>Anjuta</application> or not. <application>Anjuta</application>
   will update itself with any external changes made to a project.
  </para>
  </sect1>
 
  <sect1 id="groups-and-targets">
   <title>Taldeak eta helburuak</title>

   <sect2 id="adding-groups">
    <title>Taldeak gehitzea</title>
    <para>
     To add a new group (which is a directory in automake-based projects):
        <itemizedlist>
         <listitem>
           <para>
           Select <menuchoice><guisubmenu>Project</guisubmenu>
	   <guimenuitem>Add Group</guimenuitem></menuchoice> and a dialog to
           add a new group will pop up. 
           </para>
         </listitem>
         <listitem>
           <para>Select the group under which to add the new group.</para>
         </listitem>
         <listitem>
            <para>Enter the name of the new group and click <guibutton>Add</guibutton>.</para>
         </listitem>
        </itemizedlist>
     </para>
     <para>
     With automake projects,
     a new directory with the given name will be created under the parent
     group's directory.
    </para>
    <para>
     You can also add a new group from the <interface>Project</interface> window directly.  Right-click the group
     under which to add the new group, then choose
     <guimenuitem>Add Group</guimenuitem> from the context menu.
    </para>
   </sect2>

   <sect2 id="removing-group">
    <title>Taldeak kentzea</title>
    <para>
    To remove a group:
    <itemizedlist>
     <listitem>
       <para>Right-click the group in the <interface>Project Manager</interface> view.</para>
     </listitem>
     <listitem>
       <para>Select <guimenuitem>Remove</guimenuitem> from the
       context menu.</para>
     </listitem>
    </itemizedlist>
    </para>
    <para>
      The target and sources associated
      with the group will also be removed from the project. (They are not
      deleted from the file system, though. You can add them to the project again later if you like.)
    </para>
   </sect2>

   <sect2 id="adding-target">
    <title>Helburuak gehitzea</title>
    <para>Helburu berria gehitzea: <itemizedlist>
      <listitem>
       <para>Select <menuchoice><guisubmenu>Project</guisubmenu>
       <guimenuitem>Add Target</guimenuitem></menuchoice> and a dialog to
       add a new target will popup.</para>
     </listitem>
     <listitem>
      <para>Hautatu zein talderi gehitu nahi diozun helburua.</para>
     </listitem>
     <listitem>
      <para>Hautatu helburu mota.</para>
     </listitem>
     <listitem>
      <para>Enter a name for the new target and click <guibutton>Add</guibutton>.</para>
     </listitem>
    </itemizedlist></para>
    <para>
     You can also add a new target from the <interface>Project</interface> window directly.
     Right-click the group
     under which to add the target, then select
     <guimenuitem>Add target</guimenuitem> from the context menu.
    </para>
    <para>
     Target names usually require some standard prefix and suffix, depending
     on the type of target. Anjuta will warn you if a name is not valid and
     may provide an example of a valid name.
    </para>
    <para>
     There are several target types for automake projects. They are:
    <itemizedlist>
     <listitem>
      <para>
       The <emphasis>Program</emphasis> target type is for executable binaries. Select
       this type if you want to add an executable to the project. By default, all program
       targets will be installed in the standard executable directory, e.g.
       /usr/bin or /usr/local/bin. You can override this by specifying a different
       installation directory in the properties of the group containing the target.
      </para>
     </listitem>
     <listitem>
      <para>
       The <emphasis>Shared Library</emphasis> target type is for shared or dynamic libraries.
       Select this type if you are adding a shared library to the project. By default, all
       shared libraries are installed in the standard libraries directory, e.g.
       /usr/lib or /usr/local/lib. You can override this by specifying a different
       installation directory in the properties of the group containing the target.
      </para>
     </listitem>
     <listitem>
      <para>
       The <emphasis>Static Library</emphasis> target type is for static libraries.
       Select this type if you are adding a static library to the project. By default,
       all static libraries are installed in the standard libraries directory, e.g.
       /usr/lib or /usr/local/lib. You can override this by specifying a different
       installation directory in the properties of the group containing the target.
      </para>
     </listitem>
     <listitem>
      <para>
       The <emphasis>Java Module</emphasis> target type is for Java modules. Select
       this type if you are grouping Java sources into a module. You need to provide
       an installation directory for this target where the .class files will
       be installed. It can be set in the properties of the group containing the target.
      </para>
      <note>
       <para>
         There can really be only one Java module in a group. This is a
         restriction made by automake. Please read the automake info page for more
         details.
       </para>
      </note>
     </listitem>
     <listitem>
      <para>
       The <emphasis>Python Module</emphasis> target type is for Python modules. Select
       this type if you are grouping Python sources into a module. You need to provide
       an installation directory for this target where the sources will
       be installed. It can be set in the properties of the group containing the target.
      </para>
     </listitem>
     <listitem>
      <para>
        The <emphasis>Scripts</emphasis> target type is for grouping scripts. They will be
        installed in the standard executable directory.
      </para>
     </listitem>
     <listitem>
      <para>
        The <emphasis>Miscellaneous Data</emphasis> target type is for grouping
        simple files in a project. You must specify an installation directory
        in the group properties.
      </para>
     </listitem>
     <listitem>
      <para>
        The <emphasis>Header Files</emphasis> target type is for grouping C/C++
        header files that need to be installed on a system (for example as part
        of a library API). (For header files that do not need to be installed,
        make them part of the Program target along with the sources.) Header files will
        be installed in the standard include directory unless an installation path
        is specified in the group properties.
      </para>
     </listitem>
     <listitem>
      <para>
        The <emphasis>Man Documentation</emphasis> and <emphasis>Info Documentation</emphasis>
        target types are for grouping man and info documentation respectively.
        By default, documentation files will be installed in the standard installation directories.
      </para>
     </listitem>
    </itemizedlist>
    </para>
   </sect2>
   <sect2 id="removing-target">
    <title>Helburuak kentzea</title>
    <para>
      To remove a target:
      <itemizedlist>
       <listitem>
        <para>Right-click the target in the <interface>Project Manager</interface> view.</para>
       </listitem>
       <listitem>
        <para>Select <guimenuitem>Remove</guimenuitem> from the
        context menu.</para>
       </listitem>
      </itemizedlist>
    </para>
    <para>
      The sources associated with the targets
      will also be removed from the project (they are not deleted from the
      file system, though).
    </para>
   </sect2>
  </sect1>

  <sect1 id="adding-removing-sources">
   <title>Fitxategiak gehitzea eta kentzea</title>
   <sect2 id="adding-sources">
    <title>Iturburu-fitxategiak gehitzea</title>
    <para>
     Select the menu item <menuchoice><guisubmenu>Project</guisubmenu>
	 <guimenuitem>Add Source File</guimenuitem></menuchoice>.
	From the dialog, select the target to which the file should be added and
    the file itself. You can add multiple files at once. To do that, select
    multiple files from the file selection dialog using either the <keycap>Shift</keycap> or <keycap>Ctrl</keycap>
    key. Then click <guibutton>Add</guibutton> to add the
    files to the project.
    </para>
    <para>
    By default, the current editor file will be preselected for addition in the
    dialog. Another convenient way to add a file is to right-click it in the
    <interface>File Manager</interface> and choose
    <guimenuitem>Add to project</guimenuitem> from the
    context menu.	
    </para>
    <para>
     If the file you choose has already been added to the project, then
     <application>Anjuta</application> will not add it again. 
     It will also give you a warning that the file has already been added.
    </para>
    <para>
     If the file you choose is not in the project directory, you will be asked
     to confirm that you wish to copy the file into the target's directory.
     <application>Anjuta</application> cannot add files which are 
	 outside of a target's directory without copying them in.
    </para>
   </sect2>
   <sect2 id="removing-sources">
    <title>Iturburu-fitxategiak kentzea</title>
    <para>
     To remove a file from the project, right-click the file you want to remove
     in the <interface>Project window</interface> and
	 choose <guimenuitem>Remove</guimenuitem> from the context menu.
    </para>
    <para>Berresteko elkarrizketa-koadroa agertzen da, eta fitxategia proiektutik kentzen da.</para>
    <important>
     <title>Fitxategia ez da ezabatzen!</title>
     <para>
     The file is not deleted from the filesystem. It still exists, and you can
     add it back again later if you so wish. The file is only removed from the project 
	 listing, and will not take part in any project operations such as compiling, 
	 building, or distribution.
     </para>
     </important>
   </sect2>
  </sect1>
  
  <sect1 id="project-config">
   <title>Proiektu-konfigurazioa</title>
   <para>
    Project configuration involves setting the correct build flags for
    targets, groups and the project itself. You can set these flags in their
    respective properties dialogs.
   </para>

   <para>
    You can freely use autoconf and automake variables that are automatically
    set for the project during configuration. Apart from these automatically
    set variables, you can also define your own variables in
    <link linkend="project-properties">Project Properties</link> and use them in
    properties. This will make it easy to update flags later, especially when
    a variable is used in several targets.
   </para>

   <para>
    Some of the many common variables are listed here. For full list of them
    see the <ulink url="info:automake">automake info documentation</ulink>.

     <itemizedlist>
      <listitem>
       <para>
         <emphasis>$(prefix)</emphasis>: The installation prefix. The project
         is installed under various subdirectories under this prefix. By default
         it is /usr/local.
       </para>
      </listitem>
      <listitem>
       <para>
         <emphasis>$(bindir)</emphasis>: The installation directory for
         executable binaries. All your executable and script targets will
         be installed in this directory. By default, it is $(prefix)/bin.
       </para>
      </listitem>
      <listitem>
       <para>
         <emphasis>$(libdir)</emphasis>: The installation directory for
         libraries. All your library targets (both shared and static) will
         be installed in this directory or a subdirectory below it.
         By default, it is $(prefix)/lib.
       </para>
      </listitem>
      <listitem>
       <para>
         <emphasis>$(module_CFLAGS)</emphasis> and $(module_LIBS): These
         flags are set by <application>configure</application> for the packages that your project
         depends on. The packages used by the project are set in
         <link linkend="project-properties">Project Properties</link>. 'module'
         is a package group that you specify in the project properties as described below.
       </para>
      </listitem>
     </itemizedlist>

   </para>


   <sect2 id="project-properties">
    <title>Proiektu-propietateak</title>
    <para>
    The project properties dialog can be opened only by
    choosing <menuchoice><guisubmenu>Project</guisubmenu>
    <guimenuitem>Properties</guimenuitem></menuchoice> from the toplevel menu bar. You can:
    <itemizedlist>
     <listitem>
      <para>
      Set the project name, version and URL in the <guibutton>General</guibutton> page.
      <application>configure</application> variables can also be use in these fields. The URL is the
      bug report URL for the project.
      </para>
     </listitem>
     <listitem>
      <para>
      Add and remove dependencies for your project in the
      <guibutton>Packages</guibutton> page. See below for details.
      </para>
     </listitem>
     <listitem>
      <para>
      Create more configure variables in the <guibutton>Variables</guibutton> page
      to use in group and target properties.
      </para>
     </listitem>
    </itemizedlist>
    </para>
    <para>
    Dependencies
    are external packages that the project uses and are hence required
    to build it. Only packages installed using
    <ulink url="info:pkg-config">pkg-config</ulink>
    can be added from this interface. For others, the configure.ac file can
    be edited manually.
    <figure>
       <title>Proiektuaren propietateen elkarrizketa-koadroa</title>
       <screenshot>
	   <screeninfo>Proiektuaren propietateen elkarrizketa-koadroa</screeninfo>
        <graphic fileref="figures/project_info.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure>
   </para>
   <para>
    External package dependencies are grouped into <emphasis>modules</emphasis>,
    so that their combined build flags can be conveniently added to different
    targets. <emphasis>Modules</emphasis> are just arbitrary
    groups of packages and can be named anything (only alphanumeric characters and _ are
    allowed in module names). Usually, they follow the name of
    targets they would be used in. Consequently, for small projects with single 
    targets, just one module to hold all dependencies is enough.
   </para>
   <para>
    Each package exports a set of <emphasis>compiler flags</emphasis>
    and <emphasis>libraries</emphasis>. They are aggregated together for
    all packages under a module, and <application>configure</application> variables
    <emphasis>$(module_CFLAGS)</emphasis> and
    <emphasis>$(module_LIBS)</emphasis> are defined. These variables can then
    be used in <link linkend="group-properties">Group properties</link>
    and <link linkend="target-properties">Target properties</link>.
   </para>
   <para>Pakete-mendekotasuna gehitzeko: <itemizedlist>
     <listitem>
      <para>
      Select <menuchoice><guisubmenu>Project</guisubmenu>
      <guimenuitem>Properties</guimenuitem></menuchoice> to bring up the project
      properties dialog.
      </para>
     </listitem>
     <listitem>
      <para>Select the tab <guibutton>Packages</guibutton> to bring up the Packages
      page.</para>
     </listitem>
     <listitem>
      <para>
      Select the <emphasis>module</emphasis> to add the package to. If there
      is no module created yet or there is no appropriate module, create one
      by clicking <guibutton>Add module</guibutton>. Give a sensible name to the
      module, preferably in UPPERCASE to match other <application>configure</application> variables
      (only use alphanumeric and '_' characters) and press <keycap>Enter</keycap>
      to create it.
      </para>
     </listitem>
     <listitem>
      <para>Click <guibutton>Add Package</guibutton> to bring up the package selection dialog.</para>
     </listitem>
     <listitem>
      <para>Hautatu gehitzeko paketea, eta egin klik <guibutton>Gehitu</guibutton> botoian.</para>
     </listitem>
     <listitem>
      <para>Sakatu <guibutton>Itxi</guibutton> propietateen elkarrizketa-koadroa ixteko.</para>
     </listitem>
    </itemizedlist></para>
   </sect2>

   <sect2 id="group-properties">
    <title>Taldearen propietateak</title>
    <para>
    To edit a group's properties, double-click the group in the
    <interface>Project</interface> window to open the <interface>Group Properties</interface> dialog.
    (You can alternatively right-click the group
    and select <guimenuitem>Properties</guimenuitem> from the context menu.)
     <figure>
       <title>Group properties dialog</title>
       <screenshot>
	   <screeninfo>Group properties dialog</screeninfo>
        <graphic fileref="figures/project_group.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure>
    </para>

    <para>
         Properties set for a group apply to all
         the targets under it. So any compiler or linker flags set for a group will
         be automatically be part of all the targets in it (in addition to
         each target's individual properties). The following fields are available in the Group
         Properties dialog.

		   <itemizedlist>
		    <listitem>
		     <para>
                <emphasis>Includes</emphasis>: Set your include directories for your C and C++ targets here.
                You need to provide the full include options of the compiler
                here, e.g. -I/usr/include/blah. The include paths will be used
                to find header files included by your source files. (You can also
                add other compiler flags here, but it's preferable
                to set them in their respective <emphasis>compiler flags</emphasis> fields as described below.)
             </para>
           </listitem>
		    <listitem>
		     <para>
                <emphasis>Compiler flags</emphasis>: Set your compiler-specific
                flags here. There are different fields for different compiler
                categories. Flags that can be set here depend on the actual
                compiler used. The default compiler used for C/C++ is gcc/g++
                (the GNU C compiler). Check out the <ulink url="info:gcc">gcc info
                documentation</ulink> for more details.
             </para>
           </listitem>
		    <listitem>
		     <para>
                <emphasis>Install directories</emphasis>: The dialog will display
                a field for each target in the group
                that requires an installation directory. Set each installation
                directory as relative to one of the many <application>automake</application>
                directory variables, such as $(prefix), $(bindir), $(libdir),
                or $(datadir).
             </para>
           </listitem>
          </itemizedlist>

    </para>
   </sect2>

   <sect2 id="target-properties">
    <title>Helburuaren propietateak</title>
    <para>
     Any properties set for a target apply to that target only.  A target also inherits
		 properties from its containing group.
		</para>
	  <para>
    To set a target's properties, double-click the target
    in the <interface>Project window</interface> to open the Target Properties dialog. (You can
    alternatively right-click the target and select <guimenuitem>Properties</guimenuitem> from
    the context menu.)
     <figure>
       <title>Target properties dialog</title>
       <screenshot>
	   <screeninfo>Target properties dialog</screeninfo>
        <graphic fileref="figures/project_target.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure>
    </para>
    <para>
        You can add the modules you have added in <link linkend="project-properties">Project properties</link>
        to a specific target here. To activate the module simply toggle the checkbox
        next to the module name. This will automatically add include and linker
        flags to that target and enable you to use the module within this target.
    </para>
    <sect3 id="target-advanced">
    <title>Advanced target options</title>
    <para>
    The following fields are available in the advanced target configuration that
    you reach when you clicked the <guibutton>Advanded...</guibutton> button in the
    target properties dialog.
    </para>
    <para>
    <figure>
       <title>Target properties dialog</title>
       <screenshot>
	   <screeninfo>Target properties dialog</screeninfo>
        <graphic fileref="figures/project_target_details.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure>
		   <itemizedlist>
		    <listitem>
		     <para>
                <emphasis>Compiler settings</emphasis>: Set your compiler-specific
                flags here. There are different fields for different compiler
                categories. Flags that can be set here depend on the actual
                compiler used. The default compiler used for C/C++ is gcc/g++
                (the GNU C compiler). Check out the <ulink url="info:gcc">gcc info
                documentation</ulink> for more details.
             </para>
            </listitem>
		    <listitem>
		     <para>
                <emphasis>Linker flags</emphasis>: Set linker flags that should
                be used when linking the target. These flags apply only to Program
                and Library targets. See the <ulink url="info:ld">ld info documentation</ulink>
                for available linker options.
             </para>
            </listitem>
		    <listitem>
		     <para>
                <emphasis>Libraries</emphasis>: Set the libraries that the
                target depends on.
             </para>
           </listitem>
          </itemizedlist>

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

 <!-- Build -->
 <!-- ============= Build ====================== -->
 <chapter id="building">
  <title>Building</title>
  <para>
   Anjuta handles <application>autotools</application> projects. It is able to cope with other kinds of
   projects, such as projects using a user-written Makefile, but the current build
   interface is targeted at autotools projects. Some knowledge of them is
   useful to better understand the way a project is built.
  </para>
  <para>
   An autotools project is built in three steps:
  </para>
  <para>
     <orderedlist>
      <listitem><para>Generate</para></listitem>
      <listitem><para>Konfiguratu</para></listitem>
      <listitem><para>Build</para></listitem>
     </orderedlist>
  </para>
  <para>
   <emphasis>Build</emphasis> is the main step in which all target files are
   generated from the source files. It can be divided into
   two subphases: <emphasis>Compile</emphasis> and <emphasis>Link</emphasis>.
   In the <emphasis>Compile</emphasis> phase each object file is generated from 
   its corresponding source file. For instance, a source file <filename>hello.c</filename>
   will generate <filename>hello.o</filename> after compilation. Usually you do not need 
   to worry about these object files — just think of them as intermediate files. 
   In the <emphasis>Link</emphasis> phase, all object files and libraries
   are linked together to create the final executable.
   Some programming languages do not need a <emphasis>Compile</emphasis>
   and a <emphasis>Link</emphasis> phase. Moreover the <emphasis>Build</emphasis> step
   may be used to generate other files, like documentation which doesn't need such phases.
  </para>
  <para>
   <emphasis>Configure</emphasis> is the step in which the source tree is adjusted
   to your system. <application>autotools</application> projects can be built on a wide range of systems using
   different compilers and having different library functions. This step runs a
   script named <filename>configure</filename> that will check for various characteristics
   of your system
   and create some of the files required to perform a build (such as 
   <filename>Makefile</filename> and <filename>config.h</filename>).
   This step is used to select build options, too; for
   instance, a build option may disable optimization to make debugging easier or disable some
   experimental part of a program.
  </para>
  <para>
   <emphasis>Generate</emphasis> is the step in which the <filename>configure</filename>
   script and other related files are created. The <filename>configure</filename>
   script used above needs to run on
   various systems and checks a lot of things. It would be quite difficult to write it
   by hand. Moreover <application>autotools</application> enforces some project organization rules
   such as the presence of some mandatory files: <filename>NEWS</filename> and <filename>COPYING</filename>, for example.
   It includes several tools
   to create necessary files from simpler files written by the developer
   such as <filename>configure.in</filename> (or <filename>configure.ac</filename>) and
   <filename>Makefile.am</filename>. All these tools are commonly run
   from a script named <filename>autogen.sh</filename> in the project directory. This step is useful only
   for a developer (someone modifying the source files), as the
   <filename>configure</filename> script depends only on the source files, and is distributed within the
   project package.
   Note that the makefiles created by <application>configure</application> include some rules
   to automatically regenerate the project when needed, so it often not needed to
   rerun it directly.
 </para>
 <para>Tresna horri buruzko informazio gehiago behar baduzu, ikus <ulink type="info" url="info:automake"><application>automake</application></ulink>ren eta <ulink type="info" url="info:autoconf"><application>autoconf</application></ulink>en informazio-orriak.</para>


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

 <sect1 id="build-configure">
  <title>Generate and Configure</title>
  <sect2 id="configure">
   <title>Configure a project</title>
   <para>
    You need to run this step before being able to build your project. This is
    usually run only once at the beginning of the first build process —
    for example, just after you have extracted a source tarball of a
    project distribution. After that, configuration is automatically handled by the 
    subsequent build processes.
    If you have used the <emphasis>Application Wizard</emphasis> 
    to create the application, then you will not need to run this 
    separately: the wizard will run it as a part of the project generation process.
   </para>
   <para>
    There is no requirement to run this only once. It can be 
    run at any time, usually when the configuration options need to be changed. One thing to 
    note is that if the <filename>config.h</filename> file in the top level directory is 
    changed, running <filename>configure</filename> again will not overwrite it.
   </para>
   <para>
    Both generate and configure steps are launched with a single menu item:
    <menuchoice><guisubmenu>Build</guisubmenu>
    <guimenuitem>Configure Project…</guimenuitem></menuchoice>.
    This menu item brings a dialog where you can choose:
    <itemizedlist>
     <listitem><para>Whether you want to run the generate step or not</para>
      <para>
       The generate step needs to be run once at the beginning of the project; then it is automatically
       handled by the build process. You can force it to run by checking the checkbox
       <interface>Regenerate project</interface>; you might do this if you encounter
       difficulties while building a project (e.g. if you receive build errors
       after you've modified lots of build files).
      </para>
     </listitem>
     <listitem><para>The configuration name</para>
      <para>
       This name is used to refer to each configuration. Some configurations (Default,
       Debug, Optimized) are already defined by default. One configuration includes
       a build directory and some configuration options.
      </para>
     </listitem>
     <listitem><para>The build directory</para>
      <para>
       This is the build directory name. In the Default configuration, it is the same
       directory as the source directory but autotools supports building in a
       different directory.
      </para> 
      <note><para>
       Each configuration must have a different build directory and if one configuration
       uses the source directory, you cannot have other configurations at the same time.
       You need to run <menuchoice><guisubmenu>Build</guisubmenu>
       <guimenuitem>Remove Configuration</guimenuitem></menuchoice> on the configuration
       using the source directory before adding a new configuration.
      </para></note>
     </listitem>
     <listitem><para>Configure options</para>
      <para>
       These options are passed to the <filename>configure</filename> script. Some are standard, such as --prefix and CFLAGS; others depend on the project. You can get a list of allowed configuration options by
       running the <filename>configure</filename> script with the <option>--help</option> argument.
      </para>
     </listitem>
    </itemizedlist>
   </para>
  </sect2>
  <sect2 id="select-configure">
   <title>Select a configuration</title>
   <para>
    If you have created different configurations, you can select which one is active by
    selecting it in <menuchoice><guisubmenu>Build</guisubmenu>
    <guimenuitem>Select Configuration</guimenuitem></menuchoice>.
   </para>
  </sect2>
  <sect2 id="clean-configure">
   <title>Clean a configuration</title>
   <para>
    To clean the project and leave it in a state that requires rerunning the
    configure step, choose <menuchoice><guisubmenu>Build</guisubmenu>
    <guimenuitem>Remove Configuration</guimenuitem></menuchoice>.
    It run <command>make distclean</command> and deletes more files than <guimenuitem>Clean Project</guimenuitem>.
    In other words, it leaves the project
    as though it has just been extracted from a distribution tarball. Note
    that it does not remove the configuration directory itself; you can
    do that yourself if you like.
   </para>
  </sect2>
 </sect1>


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

 <sect1 id="build-compile-and-build">
  <title>Compile and Build</title>
  <sect2 id="build-compile">
   <title>Compiling a file</title>
   <para>
    In a project, individual source files can be compiled separately into objects 
    (<filename>*.o</filename> files). Although you do not have to worry about these object 
    files, sometimes it is handy to compile a file first (for example, to make sure there are 
    no syntax errors). Building a whole project can take a lot of time, especially in the case of 
    larger and more complex applications. Therefore, you will probably go through a series of 
    edit-compile iterations while developing a project.
   </para>
   <para>Fitxategi bat konpilatzeko, aukeratu <menuchoice><guisubmenu>Eraiki</guisubmenu><guimenuitem>Konpilatu</guimenuitem></menuchoice>, edo sakatu <keycap>F11</keycap>. Fitxategi aktiboa konpilatzen da.</para>
  </sect2>

  <sect2 id="build-build">
   <title>Exekutagarria eraikitzea</title>
   <para>
    <application>Anjuta</application> has no separate link command, simply because 
    it is not necessary. The build process will compile all source files and link them together 
    along with the necessary libraries. The build command will not recompile those files which are 
    already up-to-date (this is called the <emphasis>dependency check</emphasis>). 
    If you have already compiled all files individually, then the only thing the build 
    step performs is the link. If you have already built the project and no dependent file has been 
    modified, even the link stage will be skipped.
   </para>
   <para>
    So how exactly does the dependency check influence project development? 
    If you have modified a file, then all of the source files that depend on the modified 
    file are recompiled. All files (not just the object files and executable) in the 
    project are checked for these dependencies during the build process. If it is found that 
    a particular file is dependent on some other file which has been modified, then that file 
    will be regenerated.
   </para>
   <para>
    Can you imagine how your life (as a programmer) would be if the dependency check were not there? If you 
    cannot answer just yet, then you will find out when you start developing big projects!
   </para>
   <para>
    <menuchoice><guisubmenu>Build</guisubmenu><guimenuitem>Build</guimenuitem></menuchoice> 
    will build all files in the directory of the currently active file. 
   </para>
   <para>
    <menuchoice><guisubmenu>Build</guisubmenu>
    <guimenuitem>Build Project</guimenuitem></menuchoice> will build 
    the whole project — all subdirectories are built recursively.
   </para>
  </sect2>
 </sect1>


 <!-- Build: Other operations -->

 <sect1 id="build-other">
  <title>Other operations</title>
  <sect2 id="build-dist">
   <title>Banaketa-pakete bat sortzea</title>
   <para>
    To build a tarball distribution of the project choose <menuchoice><guisubmenu>Build</guisubmenu>
    <guimenuitem>Build Tarball</guimenuitem></menuchoice>. This will create a 
    tarball (<filename>*.tar.gz</filename>) and put it in the top-level project directory. 
    Copy the file to a safe place for distribution.
   </para>
  </sect2>
  <sect2 id="build-install">
   <title>Installing a project</title>
   <para><menuchoice><guisubmenu>Eraiki</guisubmenu><guimenuitem>Instalatu</guimenuitem></menuchoice> menu-elementua aukeratzen bada, sisteman instalatzen da sortutako aplikazioa.</para>
   <note>
    <title>System-wide installation</title>
    <para>
     You must be logged in as root to perform a system-wide install. Also note that for a GNOME 
     application to use the pixmaps in the project, it must be installed as a system-wide 
     application. Otherwise, when the application is executed in your project, there will be 
     lots of "pixmap not found" errors. You can configure Anjuta to use <command>sudo</command>
     or <command>su</command> before installing the project in the build preferences.
    </para>
   </note>
  </sect2>
  <sect2 id="build-clean">
   <title>Cleaning</title>
   <para>
    This deletes all of the files generated by the build process, including
    all object files (<filename>*.o</filename> files) and the executable(s).
    It can be applied on one directory or the whole project.
   </para>
   <para>
    Choose the menu item <menuchoice><guisubmenu>Build</guisubmenu>
    <guimenuitem>Clean Project</guimenuitem></menuchoice> to clean all project
    files.
   </para>
   <para>
    Choose the menu item <menuchoice><guisubmenu>Build</guisubmenu>
    <guimenuitem>Clean</guimenuitem></menuchoice> to clean only the directory
    of the current active file.
   </para>
  </sect2>

 </sect1>

</chapter>

 <!-- Debugging -->
 <!-- ============= Debugging ====================== -->
 <chapter id="debugging">
  <title>Arazketa</title>
  <para>
   <emphasis>Edonork egin dezake arazketa. Konpontzea beste kontu bat da...</emphasis>
  </para>
  <para><emphasis>Edonork</emphasis> egin dezakeen zatiari buruzkoa da atal hau. <emphasis>Bestea</emphasis> ez dago gure esku!</para>
  <para>
   When a program does not behave in the way it is supposed to, we say the program
   contains a <emphasis>bug</emphasis>. A bug is not a compilation error — 
   compilation errors are relatively easy to clear, because the compiler tells you 
   where the problems are. By contrast, bugs are errors 
   that happen during program execution and they can be hard (sometimes very hard!) 
   to detect.
  </para>
  <para>Ustez programazio-errorerik gabeak diren programak ere ez dira inoiz erabat programazio-akatsik gabeak. Programaren programazio-erroreak murrizten saiatzea besterik ezin dugu egin. Programazio-erroreak kentzeko prozesua <emphasis>arazketa</emphasis> da, eta arazteko erabiltzen den tresna, berriz, <emphasis>araztailea</emphasis>. Arazketa-ingurune erabilerraza eta ahalmen handikoa du <application>Anjuta</application>k (izatez, <application>gdb</application>ren gaineko GUI biltzailea da, komando-lerroko arazteko tresna ahaltsua, eta Linux-erako estandarra).</para>
  <para>Araztaileek programen exekuzioaren segimendua egiten dute eta aztarnei jarraitzen diete, eta programen exekuzioa aztertzeko beharrezko informazioaren zenbait ikuspegi ematen dituzte.</para>

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

 <sect1 id="debugger-session">
  <title>Abiaraztea eta gelditzea</title>

  <para>
   The debugger is always started with a program loaded. There are two ways to do this:
   <itemizedlist>
    <listitem><para><emphasis>Exekutagarri bat exekutatzea</emphasis></para></listitem>
    <listitem><para><emphasis>Prozesu bati uztartzea</emphasis></para></listitem>
   </itemizedlist>
   <note>
    <para>
     Almost every feature of Anjuta is provided by a plugin. If you do not see
     the menus described here. It is probably because the debugger plugin is not
     loaded. Go in 
     <menuchoice><guisubmenu>Edit</guisubmenu><guimenuitem>Preferences</guimenuitem><guimenuitem>General</guimenuitem><guimenuitem>Installed plugins</guimenuitem></menuchoice>
     and check that the debugger plugin is loaded.
     It is an user activatable plugin, so loaded or unloaded on request.
    </para>
   </note>
  </para>

  <sect2 id="debug-run">
   <title>Exekutagarri bat exekutatzea</title>
   <para>
     Running a program with or without the debugger uses the same menu: select
     <menuchoice><guisubmenu>Run</guisubmenu><guimenuitem>Run Program</guimenuitem></menuchoice> 
     to run a program without the debugger and
     <menuchoice><guisubmenu>Run</guisubmenu><guimenuitem>Debug Program</guimenuitem></menuchoice>
     to run it with the debugger.
   </para>
   <note>
    <para>
     In order to better use the debugger, it is strongly recommended that you build your program
     with debugging information (-g for gcc) and no optimization (-O0 for gcc). This can be
     done by selecting the Debug configuration before building the program for the first time.
    </para>
   </note>
   <para>
    You can select which program to run and its environment using
    <menuchoice><guisubmenu>Run</guisubmenu><guimenuitem>Program Parameters…</guimenuitem></menuchoice>. 
    You can choose:
    <itemizedlist>
     <listitem><para>The program that you want to debug</para>
      <para>
       The drop-down menu of the target drop-down combination box 
       is pre-filled with all executables of the current project. But you can alternatively
       select another executable which is not part of the project. The debugger also accepts libtool
       executables; these are scripts generated by libtool which wrap real executables.
      </para>
     </listitem>
     <listitem><para>The command-line parameters</para></listitem>
     <listitem><para>The working directory</para></listitem>
     <listitem><para>Environment variables</para>
      <para>
       Environment variables displayed in light gray are the current environment variables. You can
       add, modify or remove environment variables here.
      </para>
      <tip><para>
       To debug Anjuta using Anjuta, you can use a different theme to change the look of the instance
       being debugged; for example, you could add "GTK2_RC_FILES=/usr/share/themes/Crux/gtk-2.0/gtkrc".
      </para></tip>
     </listitem>
     <listitem><para>Whether the program should run in a terminal or not.  If so, the Anjuta terminal plugin is used.</para></listitem>
    </itemizedlist>
   </para>
  </sect2>
	
  <sect2 id="debug-attach">
  <title>Prozesu bati uztartzea</title>
   <para>
    It is also possible to attach to a running process and debug it by choosing the menu item
    <menuchoice><guisubmenu>Run</guisubmenu>
	<guimenuitem>Debug Process …</guimenuitem></menuchoice>. A list of all
    processes running on the system will appear. 
   </para>
   <figure id="attach">
    <title>'Uztartu prozesuari' elkarrizketa-koadroa</title>
    <screenshot>
	<screeninfo>'Uztartu prozesuari' elkarrizketa-koadroa</screeninfo>
     <graphic fileref="figures/attach.png" format="PNG" srccredit="andyp"/>
    </screenshot>
   </figure>
   <para>	
    Select the process to attach to and click <guibutton>OK</guibutton> to start the debugger,
    attach to the selected process and stop it.
   </para>
   <note>
    <para>
     It is currently not possible to load symbol information for an attached
 	process. Symbols should be included in the process. 
    </para>
   </note>
  </sect2>
  
  <sect2 id="debug-stop">
   <title>Araztailea gelditzea</title>
    <para>
     Choose the menu item <menuchoice><guisubmenu>Run</guisubmenu>
     <guimenuitem>Stop Debugger</guimenuitem></menuchoice> to stop the debugger.
     This will kill the program which is being debugged. If the debugger has
     been attached to a running process, the debugger will just detach from it without killing
     it. You will get a confirmation box if a program is currently attached or running.
   </para>
  </sect2>

  <sect2 id="debug-add-sources">
   <title>Adding source directories</title>
   <para>
    Choose the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
    <guimenuitem>Add source paths…</guimenuitem></menuchoice> to display a dialog
    box allowing you to add and remove source directories.
   </para>
   <para>
    Most executables include full file paths, so defining the directories where are the source files
    is normally not useful. But some executables include only file names without paths; in this case,
    the debugger will search for source files in all these directories.
    The order of directories can be important if several files have the same name, so
    you can change it using the <guibutton>Up</guibutton> and <guibutton>Down</guibutton>  buttons.
    The directory list is sent to the debugger when it is started. After changing it,
    you need to restart the debugger to cause it to use the new list.
   </para>
  </sect2>

 </sect1>
 
 <!-- Debugger: Execution -->
 
 <sect1 id="debugger-exec">
  <title>Exekutatzea</title>
  <para>
   Execution of a program in the debugger can be finely controlled. The program can be 
   executed in single steps, or allowed to continue until it encounters a breakpoint. 
   Executing like this is essential for tracking program behavior. Like a video editing 
   session, the program can be executed in <emphasis>slow motion</emphasis>
   with the ability to go forward, pause, stop, and so on. You cannot go backward yet though.
  </para>
  <para>
   The methods those can be used to execute a program in the debugger are described in 
   the following sections. These commands are available only when the program has already
   been started.
  </para>
  
  <sect2 id="dbg-step-in">
   <title>Urratsez urrats (aurreratu)</title>
   <para>Programa batean sartzeko, aukeratu <menuchoice><guisubmenu>Araztu</guisubmenu><guimenuitem>Eman urrats bat aurrera</guimenuitem></menuchoice> menu-elementua, edo egin klik <interface>Arazteko tresna-barra</interface>ko <guibutton>Eman urrats bat aurrera</guibutton> ikonoan.</para>
   <para>
    Single stepping executes only one statement of the program (from the place where it 
	has stopped) and then returns control. If the statement that is executed contains one 
	or more functions, the debugger tries to step inside the functions (in the sequence in 
	which the functions are executed). Once the statement is executed and
    control is passed back, you can study your program's state.
   </para>
   <para>
    If the <interface>Disassembly window</interface> has the focus when this command is selected,
    it executes only one assembler instruction.
   </para>
  </sect2>

  <sect2 id="dbg-step-over">
   <title>Urratsez urrats (egin jauzi)</title>
   <para>Programa bateko instrukzioetan jauzi egiteko, aukeratu <menuchoice><guisubmenu>Araztu</guisubmenu><guimenuitem>Egin jauzi</guimenuitem></menuchoice> menu-elementua, edo egin klik <interface>Arazteko tresna-barra</interface>ko <guibutton>Egin jauzi</guibutton> ikonoan.</para>
   <para><emphasis>Eman urrats bat aurrera</emphasis>ren antzekoa da <emphasis>Egin jauzi</emphasis>, baina ez da sartzen exekutatzen ari den instrukzioko funtzioetan. Instrukzioa etenik gabe exekutatzen da.</para>
   <para>
    If the <interface>Disassembly window</interface> has the focus when this command is selected,
    it executes one assembler instruction but does not stop inside if this instruction is a call
    to a subroutine. 
   </para>
   <note>
    <para>Urratsa eman bitartean liburutegi dinamiko bat kargatzen bada, programa ez da gelditzen urratsaren amaieran. Exekutatzen jarraituko du eten-puntu batera iritsi arte edo geldiarazi arte.</para>
   </note>
  </sect2>
  
  <sect2 id="dbg-step-out">
   <title>Urratsez urrats (irten)</title>
   <para>Programa batetik irteteko, aukeratu <menuchoice><guisubmenu>Araztu</guisubmenu><guimenuitem>Irten</guimenuitem></menuchoice> menu-elementua, edo egin klik <interface>Arazteko tresna-barra</interface>ko <guibutton>Irten</guibutton> ikonoan.</para>
   <para><emphasis>Irten</emphasis>ek uneko funtzioa exekutatzen du itzuli arte. Programa gelditu egiten da funtziotik irten ondoren. Irtetea ez da, berez, urratsez urratseko exekuzioa, ez baitu instrukzio bakar bat exekutatzen; funtzio osoa exekutatzen du, funtzio hori deitu duen funtziora itzuli arte.</para>
  </sect2>
  
  <sect2 id="dbg-run">
   <title>Exekutatu/Jarraitu</title>
   <para>Programa exekutatzen jarraitzeko, aukeratu <menuchoice><guisubmenu>Araztu</guisubmenu><guimenuitem>Exekutatu/Jarraitu</guimenuitem></menuchoice> menu-elementua, edo egin klik <interface>Arazteko tresna-barra</interface>ko <guibutton>Exekutatu/Jarraitu</guibutton> ikonoan.</para>
   <para>
    This option continues the execution of the program until a breakpoint is 
	encountered, or the program exits.
   </para>
  </sect2>

  <sect2 id="dbg-runto">
   <title>Exekutatu kurtsoreraino</title>
   <para>
    Choose the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
    <guimenuitem>Run to Cursor</guimenuitem></menuchoice>
    or click on the <guibutton>Run to Cursor</guibutton> icon in the 
	<interface>Debug toolbar</interface> to run until the line at the cursor is reached.
   </para>
   <para>
    This option continues the execution of the program until the line or the
    address (if the <interface>Disassembly window</interface> has the focus) at
    the cursor is reached. 
   </para>
  </sect2>
  
  <sect2 id="dbg-stop">
   <title>Gelditu programa</title>
   <para>
    While the program is running and has control, no debugging tasks can be 
	performed. To obtain control while the program is running, choose the menu item
	<menuchoice><guisubmenu>Debug</guisubmenu>
	<guimenuitem>Pause Program</guimenuitem></menuchoice> or click on the
    <guibutton>Pause Program</guibutton> icon in the <interface>Debug toolbar</interface>.
    This will interrupt the program and return control to the debugger.
   </para>
  </sect2>
  
 </sect1>
 
<!-- ============= Debugging: Breakpoints ====================== -->
 
 <sect1 id="debugging-breaks">
  <title>Eten-puntuak</title>
  <para>
   When debugging a program, it is useful to be able to stop the execution of the program at
   a particular point, so that the state of the program can be examined at that location. 
   Breakpoints enable this to happen. Breakpoints can be set at different locations in a 
   source file and then the program is allowed to run. When a breakpoint is encountered, 
   the execution of the program is suspended, enabling expressions to be evaluated, 
   variables to be inspected, the stack trace to be studied, and so on.
  </para>

  <sect2 id="breaks-list">
   <title>Eten-puntuak zerrendatzea</title>
   <para><interface>Eten-puntuen zerrendaren leihoa</interface> irekitzeko, aukeratu <menuchoice><guisubmenu>Ikusi</guisubmenu><guimenuitem>Eten-puntuak</guimenuitem></menuchoice></para>
   <para>
    <figure>
      <title>Eten-puntuen ikuspegia</title>
      <screenshot>
       <screeninfo>Eten-puntuen ikuspegia</screeninfo>
       <graphic fileref="figures/brk_dlg.png" format="PNG" srccredit="andyp"/>
      </screenshot>
    </figure>
   </para>
   <para>
    The view has the following columns:
    <variablelist>
     <varlistentry>
      <term>Location</term>
      <listitem>
       <para>
        This is the position of the breakpoint in the source file. When the breakpoint
        is set by the debugger, you can get additional information such as the function
        containing the breakpoint.
       </para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Address</term>
      <listitem>
       <para>
        This field is filled with the 
        address of the breakpoint when it is set by the debugger.
       </para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Type</term>
      <listitem>
       <para>
        This always displays "breakpoint". It will be used
        in a future release supporting different kinds of breakpoints.
       </para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Condition</term>
      <listitem>
       <para>
        This is the breakpoint condition. It is empty if no condition is defined.
       </para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Pasaldi kopurua</term>
      <listitem>
       <para>
        When the debugger is not running, this column displays the pass count of the breakpoint,
        or zero if it is not defined.
       </para>
       <para>
        When the debugger is running, if the pass count is zero, this column displays
        the number of times this breakpoint has been triggered. If the pass count is not
        zero, both numbers are displayed. The pass count is the second number.
       </para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>State</term>
      <listitem>
       <para>
        This is the state of the breakpoint. It may be
        <itemizedlist>
         <listitem><para>Pending: the breakpoint is not set in your program.</para></listitem>
         <listitem><para>Permanent: the breakpoint is set (its id number in given inside parentheses).</para></listitem>
         <listitem><para>Temporary: the breakpoint is set but will be deleted if reached.</para></listitem>
        </itemizedlist>
       </para>
      </listitem>
     </varlistentry>
    </variablelist>
   </para>
   <note>
    <para>
     All breakpoints are kept across Anjuta sessions even if they correspond to
     a non-existing location. In this case their states are set as pending. The interface
     tries to set them each time the program is started or a new dynamic library is loaded. 
    </para>
   </note>
  </sect2>  

  <sect2 id="breaks-set">
   <title>Eten-puntuak gehitzea edo ezartzea</title>
   <para>
    Choose the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
    <guimenuitem>Add Breakpoint…</guimenuitem></menuchoice>
    or <menuchoice><guimenuitem>Add Breakpoint…</guimenuitem></menuchoice>
	in the breakpoint list popup menu to open the <interface>add breakpoint</interface> dialog.
   </para>
   <para>
    <figure>
      <title>Eten-puntua gehitzeko elkarrizketa-koadroa</title>
      <screenshot>
	   <screeninfo>Eten-puntua gehitzeko elkarrizketa-koadroa</screeninfo>
       <graphic fileref="figures/brk_add.png" format="PNG" srccredit="mkv"/>
      </screenshot>
    </figure>
   </para>
   <para>
    Enter the location and, optionally, the
    break condition and the pass count; then click <guibutton>OK</guibutton> to set the 
    breakpoint.
    <variablelist>
     <varlistentry>
      <term>Location</term>
      <listitem>
       <para>
        Enter the location at which to set the breakpoint. It can be specified in any of
        the following formats:
       </para>
       <para>
        <orderedlist>
         <listitem><para>Fitxategi_izena:Lerro_zenbakia</para></listitem>
         <listitem><para>Funtzio_izena</para></listitem>
         <listitem><para>Fitxategia:Funtzio_izena</para></listitem>
        </orderedlist>
       </para>
       <para>
        The first format is obvious — the location refers to the line number 
        <emphasis>Line_number</emphasis> in the source file <emphasis>File</emphasis>. 
        The second format refers to the first line of the function 
        <emphasis>Function_name</emphasis>. The third is similar to the second, except that 
        this notation is used where there is more than one function with the name 
        <emphasis>Function_name</emphasis> in the program. It is possible to 
        differentiate between them by providing the <emphasis>File</emphasis>, so the 
        notation refers to the function <emphasis>Function_name</emphasis> in the 
        file <emphasis>File</emphasis>.
       </para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Condition</term>
      <listitem>
       <para>
        The <emphasis>Condition</emphasis> parameter displays a associated expression
        which should evaluate to a Boolean value — that is, the 
        evaluation of the expression should result in either TRUE(1) or FALSE(0). 
        If the final evaluation value is not a Boolean value, then it will be 
        appropriately type cast to a Boolean.
       </para>
       <para>
        Every time the breakpoint is encountered during your program's execution, the break 
        condition will be evaluated. The debugger will break the execution only if 
        the evaluation results in a TRUE value, otherwise it will continue the 
        execution as though there had been no breakpoint.
       </para>
       <para>
        The default value, if you leave this field blank, of <emphasis>Condition</emphasis>
        is TRUE. The debugger will always break the execution at the breakpoint location.
       </para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Pass Count</term>
      <listitem>
       <para><emphasis>Pasaldi kopurua</emphasis> zeinurik gabeko osoko balioa da, eta eten-puntua kontuan hartu aurretik zenbat bider saltatu behar duen adierazten dio araztaileari. <emphasis>Etete-baldintzak</emphasis> baino lehentasun handiagoa du <emphasis>Pasaldi kopuruak</emphasis>. Soilik <emphasis>Pasaldi kopurua</emphasis> zerora iristean ebaluatzen du araztaileak <emphasis>Etete-baldintza</emphasis> (halako baldintzarik baldin badago). Halako baldintzarik ez badago, <emphasis>Pasaldi kopurua</emphasis> zerora iritsi orduko eteten du exekuzioa araztaileak.</para>
       <para>
        The default value, if you leave this field blank, of the <emphasis>Pass count</emphasis>
        is zero. The breakpoint will be considered when it is first encountered.
       </para>
      </listitem>
     </varlistentry>
    </variablelist>
   </para>
   <para>
    A breakpoint may also be set by selecting a line in the editor
    and choosing the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
	<guimenuitem>Toggle Breakpoint</guimenuitem></menuchoice> in the editor context
	menu
        or the <guibutton>Toggle Breakpoint</guibutton> icon in the 
	<interface>Debug toolbar</interface>.
   </para>
   <tip>
    <para>
     Breakpoints can be added even if the debugger is not started, or in a dynamic
     library which is not loaded yet. But they cannot be added while a program is running
     under control of the debugger.
    </para>
   </tip>
  </sect2>
  
  <sect2 id="breaks-edit">
   <title>Eten-puntuak editatzea</title>
   <para>
    You can change the condition and the pass count by
    selecting the breakpoint in the breakpoint list and clicking <menuchoice><guimenuitem>Edit Breakpoint</guimenuitem></menuchoice>
    in the popup menu.
   </para>
   <para>Editatu sarrerak behar bezala, eta, aldaketak gauzatzeko, egin klik <guibutton>Ados</guibutton> botoian.</para>
  </sect2>

  <sect2 id="breaks-del">
   <title>Eten-puntuak ezabatzea</title>
   <para>
    Select the breakpoint in the breakpoint list view and click on
    <menuchoice><guimenuitem>Remove Breakpoint</guimenuitem></menuchoice> to delete it.
   </para>
   <para>
    A existing breakpoint may also be deleted by selecting its line in the editor
    and choosing the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
	<guimenuitem>Toggle Breakpoint</guimenuitem></menuchoice>,
    the editor context menu item
	<menuchoice><guimenuitem>Toggle Breakpoint</guimenuitem></menuchoice>
    or the <guibutton>Toggle Breakpoint</guibutton> icon in the 
	<interface>Debug toolbar</interface>.
   </para>
   <para>
    You can remove all breakpoints by clicking on <menuchoice><guisubmenu>Debug</guisubmenu>
	<guimenuitem>Remove All Breakpoints</guimenuitem></menuchoice> or on
    <menuchoice><guimenuitem>Remove All Breakpoints</guimenuitem></menuchoice> in
    the breakpoint list context menu.
   </para>
  </sect2>

  <sect2 id="breaks-enbdis">
   <title>Eten-puntuak gaitzea edo desgaitzea</title>
   <para>
    Click on the Enable column of the <interface>Breakpoint list window</interface> or
    in the context menu item <menuchoice><guimenuitem>Enable Breakpoint</guimenuitem></menuchoice>
    to enable or disable the selected breakpoint. 
	The breakpoint will be enabled or disabled, depending on its current state.
   </para>
   <para>
    To disable all breakpoints, click on <menuchoice><guisubmenu>Debug</guisubmenu>
	<guimenuitem>Disable All Breakpoints</guimenuitem></menuchoice> or on
    <menuchoice><guimenuitem>Disable All Breakpoints</guimenuitem></menuchoice> in
    the breakpoint list context menu.
   </para>
  </sect2>
 </sect1>

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

  <sect2 id="var-local">
   <title>Listing local variables</title>
   <para>
    When a program is running under the control of the debugger, the 
    <interface>Locals list window</interface> can be opened by 
    choosing <menuchoice><guisubmenu>View</guisubmenu>
    <guimenuitem>Locals</guimenuitem></menuchoice>.
   </para>
   <para>
    Local variables of the current frame (the current function in which the program control
    is present) are displayed in the <interface>Locals window</interface>.
    During execution of the program (e.g. during single stepping), local
    variables will be updated. If any variable value was changed in the last debugging step, its
    value will be highlighted in red. Variables are presented in a tree form for easy
    view.
    <figure>
      <title>Aldagai lokalak</title>
      <screenshot>
	  <screeninfo>Aldagai lokalak</screeninfo>
       <graphic fileref="figures/local_variables.png" format="PNG" srccredit="naba"/>
      </screenshot>
    </figure>
   </para>
   <para>
    The value of a local variable can be modified by selecting it and clicking in
    the <guilabel>Value</guilabel> column.
   </para>
   <note>
    <para>
     <application>gdb</application> is more and more often used as a back end for a graphical front end. It
     has been improved recently in this area. It is recommended that you use the latest
     version (6.6) of gdb. With older versions, gdb can crash when the front end
     asks for an pointer with an invalid (but unused) value.
    </para>
   </note>
  </sect2>

  <sect2 id="var-watch">
   <title>Zaindutako adierazpenak zerrendatzea</title>
   <para>
    Inspecting or evaluating an expression provides the result only once. To continuously 
	monitor some variables or expressions, use <emphasis>expression watches</emphasis>.
   </para>
   <para>
	   Choose the menu item <menuchoice><guisubmenu>View</guisubmenu><guimenuitem>Watches</guimenuitem>
	   </menuchoice> to display the <interface>Watches window</interface>.
   </para>
  </sect2>

  <sect2 id="watch-add">
   <title>Zaintzeko adierazpena gehitzea</title>
   <para>
    Right-click on the <interface>Watches window</interface>
    to open the context menu. Choose the 
	menu item <guimenuitem>Add Watch…</guimenuitem>. Alternatively, you can
    use <menuchoice><guisubmenu>Debug</guisubmenu>
	<guimenuitem>Add Watch…</guimenuitem></menuchoice>
    A dialog prompting for the expression will appear. Enter the expression and 
    click <guibutton>OK</guibutton>.
   </para>
   <para>
    By default watch expressions are updated automatically 
    each time the program is stopped. This can be changed in the add watch dialog
    or later using the <guimenuitem>Automatic update</guimenuitem> menu item in the
    <interface>Watches window</interface> context menu. A watched expression
    can be updated manually by choosing
    <guimenuitem>Update Watch</guimenuitem> or <guimenuitem>Update All</guimenuitem> in
    the context menu.
   </para>
   <para>
    It is not necessary to have the debugger running to add a new watch expression.
    If the debugger is not running or the corresponding expression cannot be found, 
    the front end will try to create the watch expression each time the program
    is stopped.
   </para>
  </sect2>

  <sect2 id="watch-remove">
   <title>Removing a watched expression</title>
   <para>
    Right-click the watch expression that you want to remove in the <interface>Watches 
	window</interface>, then choose the context
	menu item <guimenuitem>Remove</guimenuitem> to remove it.
   </para>
   <para>
    All watches can be removed by choosing <guimenuitem>Remove All</guimenuitem> in the
    context menu of the <interface>Watches window</interface>.
   </para>
  </sect2>

  <sect2 id="expr-eval">
   <title>Adierazpenak ebaluatzea</title>
   <para>
    When control is returned from a program — possibly at a breakpoint — 
	it is possible to evaluate expressions or inspect the values of variables in the 
	program. Choose the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
    <guimenuitem>Inspect/Evaluate …</guimenuitem></menuchoice>, 
    <menuchoice><guimenuitem>Inspect/Evaluate …</guimenuitem></menuchoice>
    in the context menu of the editor or click 
	the <guibutton>Inspect</guibutton> button on the <interface>Debug Toolbar</interface>. 
   </para>
   <para>
	   A window will appear showing the evaluation of the expression
	   highlighted in the editor.
	   You can evaluate a new expression by clicking on the <guilabel>name</guilabel> column
	   and entering the new one.
   </para>
   <para>
    You can add the expression to the list of watched expressions directly by 
    clicking on the <guibutton>Add</guibutton> button. 
   </para>
  </sect2>

  <sect2 id="expr-hiver">
   <title>Inspecting expressions in editor window</title>
   <para>
    When the debugger is active with the program stopped, you can get the value of an
    expression just by putting the mouse pointer over it and staying there for a short time.
    If the expression is already present in the <interface>Locals</interface> or <interface>Watches</interface> window, its value is
    displayed in a tooltip.
   </para>
   <para>
    This capability is currently working only for simple variables, not for structures or arrays.
   </para>
  </sect2>

 </sect1>

<!-- ============= Debugging: Program Stack ====================== -->
 <sect1 id="debugging-stack">
  <title>Stack Trace</title>

  <sect2 id="stack-win">
   <title>Pila-leihoa</title>
   <para>
    The <interface>stack trace window</interface> shows the contents of the 
	program stack. It lists all functions and their arguments in the 
	sequence they were called. There is also a number representing each call. 
	This number is called the <emphasis>frame</emphasis>. Each call in the trace 
	exists in a different frame. This starts from frame 0 (the last function
    called) and grows higher as function nesting becomes deeper.
   </para>
   <para>
	   Choose the menu item <menuchoice><guisubmenu>View
	   </guisubmenu><guimenuitem>Stack</guimenuitem></menuchoice> to open the stack trace for the program 
	being debugged.
   </para>
   <para>
    <figure>
      <title>Pila-aztarnaren leihoa</title>
      <screenshot>
	   <screeninfo>Pila-aztarnaren leihoa</screeninfo>
       <graphic fileref="figures/stack.png" format="PNG" srccredit="andyp"/>
      </screenshot>
    </figure>
   </para>
   <para>
    A small arrow points to the currently selected frame in the stack trace. By 
	default, this will be frame 0, the last function called. All evaluation 
	and inspection of expressions or variables will be with reference to this selected 
	frame. The scope of variables or expressions being evaluated will be limited 
	to the selected frame only. The same applies for new expressions only in the watch.
   </para>
  </sect2>
  
  <sect2 id="stack-frame">
   <title>Uneko markoa ezartzea</title>
   <para>
    Double-clicking on any frame in the stack trace sets that frame as the 
	currently selected frame.  The arrow will point to the frame, indicating that it 
	has been selected as the current frame. Alternatively, open the 
	context menu by right-clicking on the 
	<interface>Stack trace window</interface>, and choose the menu item 
	<guimenuitem>Set current frame</guimenuitem> to set the frame.
   </para>
   <para>
    Changing the stack frame changes the <interface>Locals window</interface>
    content, but not the <interface>Watches window</interface> as each
    expression is evaluated in the frame used when it was defined.
   </para>
  </sect2>
 </sect1>

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

  <sect2 id="thread-win">
   <title>Harien leihoa</title>
   <para>
    The <interface>Thread window</interface> shows all threads used by the program
    and indicates the current thread. Choose the menu item <menuchoice><guisubmenu>View</guisubmenu>
    <guimenuitem>Thread</guimenuitem></menuchoice> to open this window.
   </para>
   <para>
    A small arrow points to the current thread. When the
    program is stopped, the current thread is the thread which has been interrupted.
    Each thread has its own stack frame, so changing the current thread changes
    the current stack frame. 
   </para>
  </sect2>

  <sect2 id="set-thread">
   <title>Uneko haria ezartzea</title>
   <para>
    Double-clicking on any thread in the thread list will set that thread as the 
	currently selected thread. The arrow will point to the thread, indicating that it 
	has been selected as the current thread. Alternatively, open the 
	context menu by right-clicking on the 
	<interface>Thread list window</interface>, and choose the menu item 
	<guimenuitem>Set current thread</guimenuitem> to set the thread.
   </para>
   <para>
    Changing the thread changes the value of CPU registers and the current
    stack frame, so the <interface>Locals window</interface> changes too.
   </para>
  </sect2>
 </sect1>

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

  <sect2 id="cpu-regs">
   <title>Erregistro-leihoa</title>
   <para>
    It is possible to examine the contents of the internal registers of the 
	CPU (microprocessor). Choose the menu item <menuchoice><guisubmenu>View</guisubmenu>
	<guimenuitem>Registers</guimenuitem></menuchoice>. A window listing all 
	available registers in the microprocessor and their corresponding contents 
	will appear.
   </para>
   <para>
    If any register value was changed in the last debugging step, its
    value will be highlighted in red. It is possible to change one register value
    by selecting it and clicking in the <guilabel>value</guilabel> column.    
   </para>
  </sect2>

  <sect2 id="cpu-memory">
   <title>Memoria-leihoa</title>
   <para>
    Choose the menu item <menuchoice><guisubmenu>View</guisubmenu><guimenuitem>Memory 
	</guimenuitem></menuchoice> to open the <interface>memory window</interface>
    for the program being debugged. This window shows the contents of all memory. 
   </para>
   <para>
    The first column displays memory addresses in hexadecimal, the second displays memory contents
    in hexadecimal and the last column shows memory contents in ASCII.
   </para>
   <para>
    The addressing space of even a 32-bit microprocessor is quite large (4 gigabytes),
    so it is very difficult to go to a particular address with the scrollbar. But
    you can click on the right mouse button to display a context menu and select
    <menuchoice><guimenuitem>Goto address</guimenuitem></menuchoice> to get
    a small edit box where you can enter an address in hexadecimal.
   </para>
  </sect2>

  <sect2 id="cpu-disassembly">
   <title>Desmihiztatze-leihoa</title>
   <para>
    Choose the menu item <menuchoice><guisubmenu>View</guisubmenu><guimenuitem>Disassembly
	</guimenuitem></menuchoice> to open the <interface>disassembly window</interface>
    for the program being debugged.
   </para>
   <para>
    The first column displays addresses in hexadecimal. In the second column, you can
    have a label starting at the beginning of the line and ending with a colon or
    a assembly-language instruction indented by 4 space characters.
   </para>
   <para>
    Again, as the addressing space is very large, the scrollbar is quite useless.
    You can click on the right mouse button to display the context menu and select
    <menuchoice><guimenuitem>Goto address</guimenuitem></menuchoice> to get
    a small edit box where you can enter an address in hexadecimal. The position
    in the disassembly window will be changed to the program counter value when
    the program is stopped.
   </para>
  </sect2>
 </sect1>

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

  <para>Horren maiz erabiltzen ez diren hainbat arazketa-eginbide dago; ez daude interfazean hain ondo txertatuak, baina badabiltza.</para>

  <sect2 id="dbg-dyna-libs">
   <title>Dinamikoki kargatutako liburutegiak</title>
   <para>
    To obtain a list of the dynamic libraries used by a program, choose the 
	menu item <menuchoice><guisubmenu>Debug</guisubmenu><guisubmenu>Info</guisubmenu>
	<guimenuitem>Shared Libraries</guimenuitem></menuchoice>. This will bring 
	open a window which will list all shared libraries the program has loaded 
	and their locations in memory. It also shows whether each library's symbol table is 
	loaded or not (Yes/No).
   </para>
   <para>
    <figure>
      <title>Liburutegi partekatuen leihoa</title>
      <screenshot>
	   <screeninfo>Liburutegi partekatuen leihoa</screeninfo>
       <graphic fileref="figures/sharedlibs.png" format="PNG" srccredit="andyp"/>
      </screenshot>
    </figure>
   </para>
  </sect2>

  <sect2 id="dbg-signal">
   <title>Nukleoaren seinaleak</title>
   <para>
    Kernel signals are a way of signaling between processes in Linux. The list 
	of signals available for a program can be displayed by choosing the menu item
    <menuchoice><guisubmenu>Debug</guisubmenu><guisubmenu>Info</guisubmenu><guimenuitem>Kernel Signals</guimenuitem></menuchoice>.
    A window will open which lists all signals available in the system along with
    a brief description of each signal.
   </para>
   <para>
    <figure>
      <title>Nukleoaren seinaleen leihoa</title>
      <screenshot>
	   <screeninfo>Nukleoaren seinaleen leihoa</screeninfo>
       <graphic fileref="figures/signals.png" format="PNG" srccredit="andyp"/>
      </screenshot>
    </figure>
   </para>
   <para>
    There are three columns which specify what to do when a signal is received:
   </para>
   
   <orderedlist>
    <listitem>
     <para><emphasis>Gelditu</emphasis>: programak seinale bat jasotzean programaren exekuzioa gelditu (eta kontrola itzuli) behar duen ala ez adierazten dio araztaileari.</para>
    </listitem>
    <listitem>
     <para><emphasis>Erakutsi</emphasis>: jasotako seinalea bistaratu behar duen ala ez adierazten dio araztaileari.</para>
    </listitem>
    <listitem>
     <para><emphasis>Pasatu</emphasis>: jasotako seinalea programari pasatu behar dion ala ez adierazten dio araztaileari.</para>
    </listitem>
   </orderedlist>
   <note>
    <para>
     The context menu that is displayed when you click on the right mouse button has
     all its items disabled because the corresponding functions are not implemented
     yet.
    </para>
   </note>
  </sect2>

  <sect2 id="dbg-files">
   <title>Erabilitako fitxategiei buruzko informazioa</title>
   <para>
    You can get some information about the files used by the debugged program
	by choosing the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
	<guisubmenu>Information</guisubmenu><guimenuitem>Target files</guimenuitem></menuchoice>. 
	A window will open displaying this information.
   </para>
  </sect2>

  <sect2 id="dbg-program">
   <title>Araztutako programei buruzko informazioa</title>
   <para>
    You can get some information about the debugged program
	by choosing the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
	<guisubmenu>Information</guisubmenu><guimenuitem>Program</guimenuitem></menuchoice>. 
	A window will open displaying this information.
   </para>
  </sect2>
 
  <sect2 id="dbg-kernel">
   <title>Nukleoaren egiturari buruzko informazioa</title>
   <para>
    You can get some information about kernel data for the current process
	by choosing the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
	<guisubmenu>Information</guisubmenu><guimenuitem>Kernel user struct</guimenuitem></menuchoice>. 
	A window will open displaying this information.
   </para>
  </sect2>

  <sect2 id="var-global">
   <title>Aldagai orokorrei buruzko informazioa</title>
   <para>
    You can list all global variables
	by choosing the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
	<guisubmenu>Information</guisubmenu><guimenuitem>Info Global Variable</guimenuitem></menuchoice>. 
	A window will open listing all global variables.
   </para>
  </sect2>

  <sect2 id="stack-frame-info">
   <title>Uneko markoari buruzko informazioa</title>
   <para>
    You can obtain information about the currently selected frame 
	by choosing the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
	<guisubmenu>Information</guisubmenu><guimenuitem>Info Current Frame</guimenuitem></menuchoice>. 
	A window will open describing the current frame.
   </para>
  </sect2>

  <sect2 id="stack-arg-info">
   <title>Uneko funtzio-argumentuei buruzko informazioa</title>
   <para>
    You can obtain information about the arguments of the current function 
	by choosing the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
	<guisubmenu>Information</guisubmenu><guimenuitem>Arguments</guimenuitem></menuchoice>. 
	A window will open describing the arguments.
   </para>
  </sect2>
  
  <sect2 id="dbg-command">
   <title>Erabiltzaile-komandoa</title>
   <para>Komando bat zuzenean motorrera bidaltzeko, aukeratu <menuchoice><guimenu>Araztu</guimenu><guimenuitem>Arazte-komandoa</guimenuitem></menuchoice> menu-elementua. Elkarrizketa-koadro txiki bat irekitzen da komandoak idazteko, eta araztailera bidaltzen dira komando horiek <keycap>Sartu</keycap> sakatzean.</para>
   <note>
    <para>
     The front end sends this command directly to the back end without performing any checks.
     By example if you set a breakpoint like this, it will not appear in the
     <interface>breakpoint list window</interface>. It is better to avoid using this
     command unless you know exactly what you are doing.
    </para>
   </note>
  </sect2>
 </sect1> 

 </chapter>

 <!-- Glade Interface Designer -->
 <chapter id="glade">
	<title>Glade Interface Designer</title>

	<sect1>
		<title>Quick start</title>
		<para>
			If you don't want to read all this boring manual, here is few steps to
			get all things ready for use:
			<orderedlist>
				<listitem><para>
					You should have a project containing Glade file opened;
				</para></listitem>
				<listitem><para>
					Unlike original Glade designer, Anjuta plugin uses double click
					for creating handlers for default signal. You can perform a click
					on widgets (e.g. switch current tab in a GtkNotebook)
					by keeping "Windows" or "Super" key pressed;
				</para></listitem>
				<listitem><para>
					Open
					<menuchoice><guimenuitem>Preferences</guimenuitem>
					<guimenuitem>Glade GUI Designer</guimenuitem></menuchoice>
					and check the three topmost flags
					<guilabel>Insert handler on edit</guilabel>,
					<guilabel>Separated designer layout</guilabel>
					and <guilabel>Automatically add resources</guilabel>;
				</para></listitem>
				<listitem><para>
					Check
					<menuchoice>
						<guimenuitem>View</guimenuitem>
						<guimenuitem>Designer</guimenuitem>
					</menuchoice>
					flag and move this window to a better place;
				</para></listitem>
				<listitem><para>
					Switch to a Glade file in the design area and to the source code file that
					should contain callbacks for the Glade file, then press
					<menuchoice><guimenuitem>Glade</guimenuitem>
					<guimenuitem>Associate last designer and editor</guimenuitem></menuchoice>;
				</para></listitem>
				<listitem><para>
					Optionally select a target for image and other resources in the
					project manager and press <guilabel>Set as default resource target</guilabel>
					in the context menu.
				</para></listitem>
			</orderedlist>
		</para>
	</sect1>
	
	<sect1>
		<title>Glade general usage questions</title>
		<para>
			Glade plugin mostly copies functionality of standalone Glade
			designer, but there are some special features. The four windows of
			the Glade desinger are design area, palette, widgets inspector and
			property editor. They have the same purpose as in the standalone
			designer, so please consult
			<ulink type="help" url="ghelp:glade">Glade Interface Designer Manual</ulink>
			for their description. An extra functionality allows you to
			use infrastructure of Anjuta more effectively and is described here.
		</para>
	</sect1>

	<sect1>
		<title>Editor and designer association</title>
		<para>
			You can associate text editor and Glade designer so you will easily
			switch between them and automatically insert handler stubs for
			newly entered handlers. You can associate more then one editor to
			a designer. The most recent editor or associated with the current
			toplevel widget will be used.
			There are two ways of associating editor and designer.
			The first way is using associations dialog. The second way is to
			choose designer and editor document in any order and then press
			<menuchoice><guimenuitem>Glade</guimenuitem>
			<guimenuitem>Associate last designer and editor</guimenuitem></menuchoice>
			menu item.
		</para>
	</sect1>

	<sect1>
		<title>Associations dialog</title>
		<para>
			Allows you to create and manager associations. To create an
			association select designer and editor in the comboboxes and press
			<guibutton>Associate</guibutton>. You can also select the document by
			switching to it in document manager or windows list in the main menu.
			The list in the middle of the dialog shows existing associations.
			A couple of controls below are intended for editing association properties.
			Here is their description:
			<variablelist>
				<varlistentry>
					<term><guilabel>Spec regexp</guilabel></term>
					<listitem><para>
						Shortened from "special regular expression". Used for defining
						a custom position for inserting stubs.
					</para></listitem>
				</varlistentry>
				<varlistentry>
					<term><guilabel>Widget name</guilabel></term>
					<listitem><para>
							The name of the toplevel widget this assoctiation belongs to.
					</para></listitem>
				</varlistentry>
				<varlistentry id="glade-position-type">
					<term><guilabel>Position type</guilabel></term>
					<listitem><para>
						Describes a position at which a handler stub will be inserted.
						<guilabel>After begin</guilabel> means after special mark
						(which may be entered in the <guilabel>Spec regexp</guilabel> entry)
						and <guilabel>before end</guilabel> means before special end mark.
						Default begin mark is /* window_name callbacks */ and default end
						mark is /* end of window_name callbacks */. window_name may be ommited.
					</para></listitem>
				</varlistentry>
			</variablelist>
		</para>
	</sect1>
	
	<sect1 id="glade-default-signal">
		<title>Default signal</title>
		<para>
			Double click on a widget in the design area will create a new handler
			for default signal using a predefined template for its naming.
			For example, the default signal is "clicked" for button, "toggled" for
			check box, etc.
			If <guilabel>Insert handler on edit</guilabel> option is enabled then a new handler stub will be inserted to the position
			which depends on <guilabel>Position type</guilabel> setting.
		</para>
	</sect1>
	
	<sect1>
		<title>Inserting a stub</title>
		<para>
			One of the most valuable goal of <application>Anjuta</application> and
			<application>Glade</application> integration is automatical creating of
			handler stubs, so you will not need to do a lot of routine work for that,
			it will be done automatically.
		</para>
		<para>
			There are several ways to create a stub:
			<itemizedlist>
				<listitem><para>
						Automatically if <guilabel>Insert handler on edit</guilabel> option
						if enabled
					</para></listitem>
				<listitem><para>
						Using
						<menuchoice><guimenuitem>Glade</guimenuitem>
						<guimenuitem>Insert handler stub, autoposition</guimenuitem></menuchoice>
						in hte main menu
					</para></listitem>
				<listitem><para>
						Using <guilabel>Insert handler stub</guilabel> item in the context
						menu of text document
					</para></listitem>
			</itemizedlist>
		</para>
	</sect1>

	<sect1>
		<title>Hobespenak</title>
		<variablelist>
			<varlistentry>
				<term><guilabel>Insert handler on edit</guilabel></term>
				<listitem><para>
					Enables inserting a handler stub into the associated editor after
					entering a new handler into signal editor or creating a
					<link linkend="glade-default-signal">default signal handler</link>
				</para></listitem>
			</varlistentry>
			<varlistentry>
				<term><guilabel>Separated designer layout</guilabel></term>
				<listitem><para>
						Detaches the design area from document manager so you can dock it
						separately from text editors.
					</para></listitem>
			</varlistentry>
			<varlistentry>
				<term><guilabel>Automatically add resources</guilabel></term>
				<listitem><para>
					When checked then all resources (e.g. images) will be added to
					the target in the current project. You can choose the target
					using project manager context menu or by entering target id in
					the entry below the check button.
				</para></listitem>
			</varlistentry>
			<varlistentry>
				<term><guilabel>Handler template</guilabel></term>
				<listitem><para>
						You can choose between the two formats of automatic naming of
						signal handler.
				</para></listitem>
			</varlistentry>
		</variablelist>
	</sect1>

</chapter>

 <!-- Preferences -->
 <!-- Preferences -->
 <chapter id="preferences">
  <title>Hobespenak</title>
  <para>
   Preferences are ways to customize <application>Anjuta</application> to suit
   your tastes. Activate <menuchoice><guimenu>Edit</guimenu><guimenuitem>Preferences</guimenuitem>
   </menuchoice> to bring up the preferences dialog. Some preferences are explained below.
  </para>
  <sect1 id="prefs-general"><title>Orokorra</title>
    <orderedlist>
     <listitem><para>
      <emphasis>Project Directory</emphasis> is the path where you plan to put all your projects.
      The application wizard creates new projects in this directory only. The default project directory
      is ~/Projects and generally this is fine for most people.
      </para>
     </listitem>
      <listitem><para>
       <emphasis>User Info:</emphasis> Provide your name and email address here. These are not
       used to do software registration; rather, they are used to create ChangeLog entries and other
       text insertions.</para>
      </listitem>
     </orderedlist>
    </sect1>
    <sect1 id="prefs-files"><title>Fitxategi-kudeatzailea</title>
    <orderedlist>
     <listitem><para>
      <emphasis>Root directory if no project is open</emphasis> is the path where
      the root of the file manager points if no project is currently open.
      </para>
     </listitem>
      <listitem><para>
       <emphasis>File Filter:</emphasis> You can filter out some files from the file tree, for example,
       hidden files, or files that are ignored by the version control system which usually means they are
       generated at build time and should not be changed.
       </para>
      </listitem>
     </orderedlist>
    </sect1>
 </chapter>

 <!-- Tools -->
 <!-- new chapter -->
 <chapter id="tools">
  <title>Erabiltzaileak definitutako tresnak</title>

  <sect1 id="tools-intro">
  <title>Sarrera</title>
  <para>
  You'll sometimes find the built-in functionality provided by Anjuta to be
  insufficient. In these cases, you might be tempted to either add the
  feature yourself to the Anjuta codebase or submit a feature request to
  implement the feature. However, both approaches are likely to be slow
  and problematic, especially if your tool is a specialized one. In these
  circumstances, it is advisable to use the Anjuta tools framework instead.
  </para>

  <para>
  Anjuta provides a powerful framework for defining user-defined tools for
  extending its functionality. Tools have access to almost all features of
  the IDE through the use of variables. You can add tools under any menu item,
  specify input, output and error redirection within the GUI framework and
  supply command-line parameters to the tool.
  </para>
	<note>
	<para>Tresnen plugina gaitu egin behar da eginbide hori erabiltzeko.</para>
	</note>
  </sect1>

  <sect1 id="tools-example">
  <title>Tresnen adibideak</title>
  <para>
  This is a simple example how to use the tools plugin to integrate the GNOME ChangeLog
	generation script.
  </para>

  <figure id="tool-list">
    <title>Tresna-editorea</title>
    <screenshot>
	<screeninfo>Tresna-editorea</screeninfo>
     <graphic fileref="figures/tool-editor.png" format="PNG" srccredit="jhs"/>
    </screenshot>
   </figure>

  </sect1>

</chapter>

 <!-- Authors -->
  <chapter id="authors">
  <title>Egileak</title>
   <para>
    The <application>Anjuta</application> project was founded by Naba Kumar.
	<ulink type="http" url="http://anjuta.org/credits">This page</ulink>
	 lists all Anjuta contributors.
   </para>

   <para>
    For more information on <application>Anjuta</application>, please visit the project 
    website at <ulink type="http" url="http://anjuta.org/">http://anjuta.org</ulink>. 
    Bug reports should be made using the Bug Tracker at the project development site 
    <ulink type="http" url="http://www.sourceforge.net/projects/anjuta">
    http://www.sourceforge.net/projects/anjuta</ulink>.
   </para>
   
   <para>
    This manual was written by Naba Kumar, Andy Piper, Biswapesh Chattopadhyay and Johannes Schmid.
    Please send all comments and suggestions regarding 
    this manual to the Anjuta Devel list <email>anjuta-devel-list@gnome.org</email>. Comments may also be submitted via the 
    project trackers at SourceForge.
   </para> 
</chapter>


 <!-- License -->
 <chapter id="license">
  <title>Lizentzia</title>
   <para>Programa hau software librea da; birbana eta/edo alda dezakezu Free Software Foundation-ek argitaratutako <ulink type="ghelp" url="gnome-help:gpl">Lizentzia Publiko Orokorra</ulink>ren 2. bertsioan, edo (nahiago baduzu) bertsio berriago batean, jasotako baldintzak betez gero.</para>
   <para>Programa hau erabilgarria izango delakoan banatzen da, baina INOLAKO BERMERIK GABE; era berean, ez da bermatzen beraren EGOKITASUNA MERKATURATZEKO edo HELBURU PARTIKULARRETARAKO ERABILTZEKO. Argibide gehiago nahi izanez gero, ikus <citetitle>GNU Lizentzia Publiko Orokorra</citetitle>.</para>
   <para><citetitle>GNU Lizentzia Publiko Orokorra</citetitle>ren kopia <citetitle>GNOMEren erabiltzaile</citetitle>aren gidaren eranskinean daukazu. <citetitle>GNU Dokumentazio Librearen Lizentzia</citetitle>ren kopia bat lor dezakezu Free Software Foundation-en bidez, bisitatu <ulink type="http" url="http://www.fsf.org"> euren webgunea</ulink>, edo idatzi hona: <address> Free Software Foundation, Inc. <street>51 Franklin Street</street> Fifth Floor<city>Boston</city>, <state>MA</state><postcode>02110-1301</postcode><country>USA</country></address></para>
</chapter>

</book>
