// -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
//
//  libanjuta interfaces. Generate stubs with anjuta-idl-compiler.pl
// 
//  Copyright (C) 2004 Naba Kumar  <naba@gnome.org>
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU Library General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

#include <glib-object.h>

/**
 * SECTION:ianjuta-file
 * @title: IAnjutaFile
 * @short_description: Implemented by plugins that can open files.
 * @see_also: #IAnjutaFileSavable
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-file.h
 * 
 * Any plugin that can open files should implemented this interface. Along
 * with the 'File Loader::SupportedMimeTypes' property of the plugin in
 * .plugin file, it will be used by the loader to open files of that type.
 */
interface IAnjutaFile
{
	/**
	 * ianjuta_file_open:
	 * @obj: Self
	 * @uri: URI to open.
	 * @err: Error propagation and reporting
	 *
	 * The implementor opens the given URI.
	 */
	void open (const gchar *uri);
	
	/**
	 * ianjuta_file_get_uri:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Returns the URI that was opened with ianjuta_file_open().
	 *
	 * Return value: The last URI opened.
	 */
	gchar* get_uri ();
	
	/**
	 * SECTION:ianjuta-file-savable
	 * @title: IAnjutaFileSavable
	 * @short_description: Implemented by plugins that can save files.
	 * @see_also: #IAnjutaFile
	 * @stability: Unstable
	 * @include: libanjuta/interfaces/ianjuta-file-savable.h
	 * 
	 * Plugins implementing #IAnjutaFile inteface that can also save files
	 * should also implement this interface.
	 */
	interface IAnjutaFileSavable
	{
		/**
		 * IAnjutaFileSavable::save_point:
		 * @obj: Self
		 * @entered: TRUE if save point is entered, FALSE otherwise.
		 * 
		 * This signal is emitted when the editor enters or leave the save
		 * point. Save point is the point where the contents were saved to
		 * non-volatile memory (e.g. disk). For example, performing undo/redo
		 * will enter or leave the save point in an editor.
		 */
		void ::save_point (gboolean entered);
		
		/**
		 * IAnjutaFileSavable::saved:
		 * @obj: Self
		 * @uri: URI where the content is saved.
		 * 
		 * This signal is emitted when the content is saved.
		 */
		void ::saved (const gchar *uri);
		
		/**
		 * ianjuta_file_savable_save:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 * 
		 * Saves the content to the original URI from which it was loaded.
		 */
		void save ();
		
		/**
		 * ianjuta_file_savable_save_as:
		 * @obj: Self
		 * @uri: URI to save the content.
		 * @err: Error propagation and reporting
		 * 
		 * Saves the content to a different URI.
		 */
		void save_as (const gchar *uri);
		
		/**
		 * ianjuta_file_savable_set_dirty:
		 * @obj: Self
		 * @dirty: 
		 * @err: Error propagation and reporting
		 * 
		 * if @dirty is TRUE, sets dirty for the content. Save point will be
		 * left and the content will be considered not saved. Otherwise,
		 * content will considered saved and save-point will be entered.
		 */
		void set_dirty (gboolean dirty);
		
		/**
		 * ianjuta_file_savable_is_dirty:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 * 
		 * Returns the dirty status of the content.
		 *
		 * Return value: TRUE if dirty, FALSE otherwise.
		 */
		gboolean is_dirty ();
	}
}

/**
 * SECTION:ianjuta-stream
 * @title: IAnjutaStream
 * @short_description: Implemented by plugins that can open file streams
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-stream.h
 * 
 */
interface IAnjutaStream
{
	#include <stdio.h>
	
	/**
	 * ianjuta_stream_open:
	 * @obj: Self
	 * @stream: Stream to open from.
	 * @err: Error propagation and reporting
	 *
	 * The implementor opens the given stream.
	 */
	void open (FILE* stream);
	
	/**
	 * SECTION:ianjuta-stream-savable
	 * @title: IAnjutaStreamSavable
	 * @short_description: Implemented by plugins that can save file streams
	 * @see_also: 
	 * @stability: Unstable
	 * @include: libanjuta/interfaces/ianjuta-stream-savable.h
	 * 
	 */
	interface IAnjutaStreamSavable
	{
		/**
		 * ianjuta_stream_save:
		 * @obj: Self
		 * @stream: Stream to save to.
		 * @err: Error propagation and reporting
		 *
		 * The implementor saves the content to the given stream.
		 */
		void save (FILE* stream);
	}
}

/**
 * SECTION:ianjuta-markable
 * @title: IAnjutaMarkable
 * @short_description: Implemented by editors (or views) with markers support
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-markable.h
 * 
 */
interface IAnjutaMarkable
{
	enum Error
	{
		INVALID_LOCATION
	}

	enum Marker
	{
		LINEMARKER,
		BOOKMARK,
		BREAKPOINT_DISABLED,
		BREAKPOINT_ENABLED,
		PROGRAM_COUNTER
	}

	void ::marker_clicked (gboolean double_click, gint location);

	/**
	 * ianjuta_markable_mark:
	 * @obj: Self
	 * @location: Location at which the marker to set.
	 * @marker: Type of marker to be used
	 * @err: Error propagation and reporting
	 *
	 * Marks the specified location with the given marker type. Location is
	 * implementation depenedent. For example, for an editor location means
	 * lines where markers are set.
	 *
	 * Return value: Handle of the location marked. Can be used later to obtain
	 * new location, if it has been moved due to addetions/deletions in the
	 * implementor object.
	 */
	gint mark (gint location, Marker marker);

	/**
	 * ianjuta_markable_location_from_handle:
	 * @obj: Self
	 * @handle: Handle of location.
	 * @err: Error propagation and reporting
	 *
	 * Location where a marker is set could have moved by some operation in
	 * the implementation. To retrieve the correct location where the marker
	 * has moved, pass the handle retured by ianjuta_markable_mark() to this
	 * method.
	 *
	 * Return value: Current location where the marker was set.
	 */
	gint location_from_handle (gint handle);

	/**
	* ianjuta_markable_unmark:
	* @obj: Self
	* @location: Location where the marker is set.
	* @marker: The marker to unset.
	* @err: Error propagation and reporting
	*
	* Clears the @marker at given @location.
	*/
	void unmark (gint location, Marker marker);
	
	/**
	* ianjuta_markable_is_marker_set:
	* @obj: Self
	* @location: Location to check.
	* @marker: Marker to check.
	* @err: Error propagation and reporting 
	* 
	* Check if the @marker is set at the given @location.
	* 
	* Returns: TRUE if the marker is set at the location, other false.
	*/
	gboolean is_marker_set (gint location, Marker marker);
	
	/**
	* ianjuta_markable_delete_all_markers:
	* @obj: Self
	* @marker: Marker to delete.
	* @err: Error propagation and reporting
	* 
	* Delete the @marker from all locations.
	*/
	void delete_all_markers (Marker marker);
}

/**
 * SECTION:ianjuta-indicable
 * @title: IAnjutaIndicable
 * @short_description: Implemented by indicate that indicate a range
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-indicable.h
 * 
 */
interface IAnjutaIndicable
{
	#include <libanjuta/interfaces/ianjuta-iterable.h>
	enum Indicator
	{
		NONE,
		IMPORTANT,
		WARNING,
		CRITICAL
	}
	
	void set (IAnjutaIterable *begin_location, IAnjutaIterable *end_location, Indicator indicator);
	void clear ();
}

/**
 * SECTION:ianjuta-iterable
 * @title: IAnjutaIterable
 * @short_description: Implemented by objects that can iterate
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-iterable.h
 * 
 */
interface IAnjutaIterable
{
	/**
	* ianjuta_iterable_first:
	* @obj: Self
	* @err: Error propagation and reporting
	*
	* Set iter to first element position. Returns FALSE if
	* there is no element in the iterable (hence does not have first).
	* The iter points to the first valid item.
	*
	* Returns: TRUE if sucessful, other FALSE.
	*/
	gboolean first ();
	
	/**
	* ianjuta_iterable_next:
	* @obj: Self
	* @err: Error propagation and reporting
	*
	* Set the iter position to next element position. Iter can go until one
	* item past the last item and lands in end-iter. end-iter does not point
	* to any valid item and signifies end of the list. Returns FALSE if iter
	* was already at end-iter (iter can not go past it) and remains pointed
	* to the end-iter.
	*
	* Returns: TRUE if sucessful, otherwise FALSE if already at end-iter.
	*/
	gboolean next ();
	
	/**
	* ianjuta_iterable_previous:
	* @obj: Self
	* @err: Error propagation and reporting
	* 
	* Set the iter position to previous element position. Returns FALSE if
	* there is no previous element and the iter remains pointed to the first
	* element.
	*
	* Returns: TRUE if sucessful, other FALSE.
	*/
	gboolean previous ();
	
	/**
	* ianjuta_iterable_last:
	* @obj: Self
	* @err: Error propagation and reporting
	* 
	* Set iter position to end-iter (one past last element) position.
	* Returns FALSE if there is no element in the iterable (already
	* at end-iter).
	*
	* Returns: TRUE if sucessful, other FALSE.
	*/
	gboolean last ();
	
	/**
	* ianjuta_iterable_foreach:
	* @obj: Self
	* @callback: Callback to call for each element.
	* @user_data: user data that is passed back to the callback.
	* @err: Error propagation and reporting
	*
	* Call callback for each element in the list. Call back is passed the
	* same iter, but with different position set (from first to last). This
	* method does not affect current position. i.e. current position is
	* restored at the end of this method.
	*/
	void foreach (GFunc callback, gpointer user_data);
	
	/**
	* ianjuta_iterable_set_position:
	* @obj: Self
	* @position: New position for the iter.
	* @err: Error propagation and reporting
	* 
	* Sets the current position of the iter to @position. The given @position
	* must be from 0 to length - 1 (#ianjuta_iter_get_length()) to point to
	* a valid element. Passing @position < 0 will set it to end-iter. It
	* returns TRUE for the above cases. FLASE will be returned, if
	* out-of-range @position is passed (@position > length - 1) and iter is
	* set to end-iter.
	*
	* Returns: TRUE if successfully set (i.e. @position is within the range or
	* end-iter). otherwise returns FALSE (i.e. @position is out of data range).
	*/
	gboolean set_position (gint position);
	
	/**
	* ianjuta_iterable_get_position:
	* @obj: Self
	* @err: Error propagation and reporting
	*
	* Index of the current iter in the iterable. It will be
	* from 0 to length - 1 (ianjuta_iter_get_length()) if iter is pointed
	* at valid element. It will return -1 if iter is pointed at end-iter.
	*
	* Returns: integer index, or -1 for end-iter.
	*/
	gint get_position ();

	/**
	* ianjuta_iterable_get_length:
	* @obj: Self
	* @err: Error propagation and reporting
	* 
	* Length of the iterable (number of elements indexable by it).
	*
	* Returns: total length of the list.
	*/
	gint get_length ();

	/**
	* ianjuta_iterable_clone:
	* @obj: Self
	* @err: Error propagation and reporting
	* 
	* Clones the iterable. The returned iterable object must be unrefed
	* when done.
	*
	* Returns: A new instance of this iterable pointing at the same location.
	*/
	IAnjutaIterable *clone ();

	/**
	* ianjuta_iterable_assign:
	* @obj: Self
	* @src_iter: Source iter from which to copy the assignment.
	* @err: Error propagation and reporting
	* 
	* Assigns the iter position from @src_iter.
	*
	*/
	void assign (IAnjutaIterable *src_iter);

	/**
	* ianjuta_iterable_compare:
	* @obj: Self
	* @iter2: Second iter to compare.
	* @err: Error propagation and reporting
	* 
	* Compares the position of @iter2 with this @obj. Returns -1
	* value if this @obj is smaller than @iter2. Returns +1 value
	* if this @obj is larger than @iter2. And returns 0 if both are equal.
	* If you want difference of the iter positions, use
	* #ianjuta_iterable_diff(). This method is meant for fast comparision.
	* 
	* Returns: 0 if equal, -1 if @obj is smaller than @iter2
	* or +1 if @obj is larger than @iter2.
	*
	*/
	gint compare (IAnjutaIterable *iter2);
	
	/**
	* ianjuta_iterable_diff:
	* @obj: Self
	* @iter2: Second iter to differenciate.
	* @err: Error propagation and reporting
	* 
	* Compares the position of @iter2 with this @obj and returns difference
	* in position of the two (@obj - @iter2).
	* 
	* Returns: The position difference of @obj - @iter2
	*
	*/
	gint diff (IAnjutaIterable *iter2);
	
	/**
	 * SECTION:ianjuta-iterable-tree
	 * @title: IAnjutaIterableTree
	 * @short_description: Implemented by tree objects that can iterate
	 * @see_also: 
	 * @stability: Unstable
	 * @include: libanjuta/interfaces/ianjuta-iterable-tree.h
	 * 
	 */
	interface IAnjutaIterableTree
	{
	
		/** 
		* ianjuta_iterable_tree_parent:
		* @obj: Self
		* @err: Error propagation and reporting
		* 
		* Set iter position to parent of curernt iter. If there is no parent,
		* returns FALSE (current iter position is not changed)
		*
		* Returns: TRUE if sucessful, otherwise FALSE.
		*/
		gboolean parent ();
		
		/**
		* ianjuta_iterable_tree_children:
		* @obj: Self
		* @err: Error propagation and reporting
		*
		* Iter position set to first child of current iter. If there is no
		* children, return NULL (iter position is not changed).
		*
		* Returns: TRUE if sucessful, otherwise FALSE.
		*/
		gboolean children ();
		
		/**
		* ianjuta_iterable_tree_has_children:
		* @obj: Self
		* @err: Error propagation and reporting
		*
		* Returns true if current iter has children
		*
		* Returns: TRUE if there are children, otherwise FALSE.
		*/
		gboolean has_children ();
		
		/**
		* ianjuta_iterable_tree_foreach_post:
		* @obj: Self
		* @callback: Callback to call for each element.
		* @user_data: User data to pass back to callback.
		* @err: Error propagation and reporting
		* 
		* Call callback for each element in post order.
		*/
		void foreach_post (GFunc callback, gpointer user_data);
		
		/**
		* ianjuta_iterable_tree_foreach_pre:
		* @obj: Self
		* @callback: Callback to call for each element.
		* @user_data: User data to pass back to callback.
		* @err: Error propagation and reporting
		* 
		* Call callback for each element in pre order.
		*/
		void foreach_pre (GFunc callback, gpointer user_data);
	}
}

/**
 * SECTION:ianjuta-buildable
 * @title: IAnjutaBuildable
 * @short_description: Implemented by plugins that can build
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-buildable.h
 * 
 */
interface IAnjutaBuildable
{
	enum Command
	{
		COMMAND_COMPILE,
		COMMAND_BUILD,
		COMMAND_BUILD_TARBALL,
		COMMAND_INSTALL,
		COMMAND_CONFIGURE,
		COMMAND_GENERATE,
		COMMAND_CLEAN,
		COMMAND_EXECUTE,
		N_COMMANDS
	}
	
	/** 
	* ianjuta_buildable_set_command:
	* @obj: Self
	* @command_id: Command to override.
	* @command: Build command to override.
	* @err: Error propagation and reporting.
	*
	* Overrides the default command for the given command.
	*/
	void set_command (Command command_id, const gchar *command);
	
	/** 
	* ianjuta_buildable_get_command:
	* @obj: Self
	* @command_id: Command to get override.
	* @err: Error propagation and reporting.
	*
	* Retrieves the currently set command override.
	* 
	* Returns: The overridden command. NULL if no override set.
	*/
	const gchar* get_command (Command command_id);
	
	/** 
	* ianjuta_buildable_reset_commands:
	* @obj: Self
	* @err: Error propagation and reporting.
	*
	* Resets the command overrides to defaults.
	*/
	void reset_commands ();
	
	/** 
	* ianjuta_buildable_build:
	* @obj: Self
	* @uri: fixme
	* @err: Error propagation and reporting.
	*
	* fixme
	*/
	void build (const gchar *uri);
	
	/**
	* ianjuta_buildable_clean:
	* @obj: Self
	* @uri: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*/
	void clean (const gchar *uri);
	
	/**
	* ianjuta_buildable_install:
	* @obj: Self
	* @uri: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*/
	void install (const gchar *uri);
	
	/**
	* ianjuta_buildable_configure:
	* @obj: Self
	* @uri: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*/
	void configure (const gchar *uri);
	
	/**
	* ianjuta_buildable_generate:
	* @obj: Self
	* @uri: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*/
	void generate (const gchar *uri);
	
	/**
	* ianjuta_buildable_execute:
	* @obj: Self
	* @uri: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*/
	void execute (const gchar *uri);
}

/**
 * SECTION:ianjuta-help
 * @title: IAnjutaHelp
 * @short_description: Implemented by plugins that can provide help support
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-help.h
 * 
 */
interface IAnjutaHelp
{

	/**
	* ianjuta_help_search:
	* @obj: Self
	* @query: fixme
	* @err: Error propagation and reporting
	* 
	* fixme
	*/
	void search (const gchar *query);
}

/**
 * SECTION:ianjuta-loader
 * @title: IAnjutaLoader
 * @short_description: Interface to load file or stream
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-loader.h
 * 
 * Loaders can deterime correct plugin to open a file or stream.  They
 * themselves can not load it, but will correctly redirect the request to
 * an implementor of IAnjutaFile, IAnjutaFileSavable, IAnjutaStream or
 * IAnjutaStreamSavable, depending on the mime-type, meta-type or any other
 * requirements.
 */
interface IAnjutaLoader
{
	#include <libanjuta/anjuta-plugin.h>
	/**
	* ianjuta_loader_find_plugins:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* Returns all plugins supporting loader interface.
	*/
	List<AnjutaPlugin*> find_plugins ();
	
	/**
	 * SECTION:ianjuta-file-loader
	 * @title: IAnjutaFileLoader
	 * @short_description: Loader to load files 
	 * @see_also: 
	 * @stability: Unstable
	 * @include: libanjuta/interfaces/ianjuta-file-loader.h
	 * 
	 * Loaders can deterime correct plugin to open a file.
	 */
	interface IAnjutaFileLoader
	{
		/**
		 * ianjuta_file_loader_load:
		 * @obj: Self
		 * @uri: URI to load
		 * @readonly: Open in readonly mode.
		 * @err: Error propagation and reporting
		 *
		 * Determines a plugin which can open the given file, activates it
		 * opening the file and returns the interface of the plugin activated.
		 * 
		 * Return value: Plugin interface used to load the file.
		 */
		GObject* load (const gchar *uri, gboolean readonly);
		
		/**
		 * ianjuta_loader_peek_interface:
		 * @obj: Self
		 * @uri: Meta file to peek
		 * @err: Error propagation and reporting
		 *
		 * Peeks the file and determines the interface which can load
		 * this file.
		 *
		 * Return value: Plugin interface name that can load the file.
		 */
		gchar* peek_interface (const gchar *uri);
	}
	
	/**
	 * SECTION:ianjuta-stream-loader
	 * @title: IAnjutaStreamLoader
	 * @short_description: Loader to load streams 
	 * @see_also: 
	 * @stability: Unstable
	 * @include: libanjuta/interfaces/ianjuta-stream-loader.h
	 * 
	 * StreamLoaders can deterime correct plugin to open a stream.
	 */
	interface IAnjutaStreamLoader
	{
		#include <stdio.h>
		
		/**
		 * ianjuta_stream_loader_load:
		 * @obj: Self
		 * @stream: Stream to load
		 * @readonly: Open in readonly mode.
		 * @err: Error propagation and reporting
		 *
		 * Determines a plugin which can open the given stream, activates it
		 * opening the stream and returns the interface of the plugin activated.
		 * 
		 * Return value: Plugin interface used to load the stream.
		 */
		GObject* load (FILE *stream, gboolean readonly);
		
		/**
		 * ianjuta_stream_loader_peek_interface:
		 * @obj: Self
		 * @stream: Stream to load
		 * @err: Error propagation and reporting
		 *
		 * Peeks the stream and determines the interface which can load
		 * this stream.
		 *
		 * Return value: Plugin interface name that can load the stream.
		 */
		gchar* peek_interface (FILE *stream);
	}
}

/**
 * SECTION:ianjuta-document
 * @title: IAnjutaDocument
 * @short_description: Interface for all kind of editable resources that
 * will be managed by IAnjutaDocumentManager
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-document.h
 * 
 */
interface IAnjutaDocument
{
	/**
	 * IAnjutaDocument::update_ui:
	 * @obj: Self
	 * 
	 * This signal is emitted when the document assumes the UI must be updated
	 * because some internal state of the document has changed. For example, if
	 * current line position is changed, it needs to be reflected to the UI.
	 */
	void   ::update_ui ();

	/**
	 * ianjuta_document_get_filename:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Allows obtaining of the filename the editor was loaded from.
	 *
	 * Return value: The name of the file. Not to be freed by caller.
	 */
	const gchar* get_filename ();	
	
	/**
	 * ianjuta_document_can_undo:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Can the editor undo the last operation?
	 *
	 * Returns true if editor can undo, else FALSE
	 */
	gboolean can_undo();
	
	/**
	 * ianjuta_document_can_redo:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Can the editor redo the last operation?
	 *
	 * Returns true if editor can redo, else FALSE
	 */
	gboolean can_redo ();
	
	/**
	 * ianjuta_document_undo:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Undo last operation
	 */
	void undo ();
	
	/**
	 * ianjuta_document_redo:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Redo last undo operation
	 */
	void redo ();

	/**
	 * ianjuta_document_begin_undo_action:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Begins the mark of undoable action. Calls to this are stacked and
	 * each must be ended with ianjuta_document_end_action().
	 */
	void begin_undo_action ();
	
	/**
	 * ianjuta_document_end_undo_action:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Ends the mark of undoable action.
	 */
	void end_undo_action ();
	
	/**
	 * ianjuta_document_grab_focus:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Grabs the focus.
	 */
	void grab_focus ();
	
	/**
		 * ianjuta_document_cut:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Cut selection to clipboard.
		 */
		void cut ();
	
		/**
		 * ianjuta_document_copy:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Copy selection to clipboard.
		 */
		void copy ();
		
		/**
		 * ianjuta_document_paste:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Paste clipboard at current position.
		 */
		void paste ();
	
		/**
		 * ianjuta_document_clear:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Clear selection
		 */
		void clear ();
}

/**
 * SECTION:ianjuta-editor
 * @title: IAnjutaEditor
 * @short_description: Text editor interface
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-editor.h
 * 
 */
interface IAnjutaEditor
{
	#include <gtk/gtkwidget.h>
	#include <libanjuta/interfaces/ianjuta-iterable.h>
	
	enum Error
	{
		DOESNT_EXIST
	}
	
	enum Attribute
	{
		TEXT,
		KEYWORD,
		COMMENT,
		STRING
	}
	
	/**
	 * IAnjutaEditor::char_added:
	 * @position: The iter position where @ch is added.
	 * @ch: The character that has been added.
	 * @obj: Self
	 * 
	 * This signal is emitted when any character is added inside the editor.
	 * The newly added character is @ch which has been inserted at @position.
	 */
	void   ::char_added (GObject *position, gchar ch);
	
	/**
	 * IAnjutaEditor::changed:
	 * @position: The iter position where change happend.
	 * @added: TRUE if added, FALSE if deleted.
	 * @length: Length of the text changed.
	 * @lines: Number of lines added or removed.
	 * @text: The text added or removed.
	 * @obj: Self
	 * 
	 * This signal is emitted when any text change happens in editor.
	 * The changes begin at @position. @text is not garanteed to be NULL
	 * terminated. Use @length to read the text. @lines represent the
	 * number of line breaks in the added or removed text.
	 */
	void   ::changed (GObject *position, gboolean added, gint length, gint lines, const gchar *text);
	
	/**
	 * ianjuta_editor_get_tabsize:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Returns the tabsize (in spaces) currently used by the editor.
	 *
	 * Returns: tabsize in number of spaces
	 */
	gint   get_tabsize ();
	
	/**
	 * ianjuta_editor_set_tabsize:
	 * @obj: Self
	 * @tabsize: Tabsize in spaces
	 * @err: Error propagation and reporting
	 *
	 * Sets the tabsize of the editor.
	 */
	void   set_tabsize (gint tabsize);
	
	/**
	 * ianjuta_editor_get_use_spaces:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Returns if the editor uses spaces for filling up tab characters.
	 *
	 * Returns: TRUE if yes, FALSE if no.
	 */
	gboolean   get_use_spaces ();
	
	/**
	 * ianjuta_editor_set_use_space:
	 * @obj: Self
	 * @use_spaces: TRUE to use spaces, FALSE to use tab char directly.
	 * @err: Error propagation and reporting
	 *
	 * Sets if the editor should use spaces for filling up tab characters.
	 */
	void   set_use_spaces (gboolean use_spaces);
	
	/**
	 * ianjuta_editor_set_auto_indent:
	 * @obj: Self
	 * @auto_indent: TRUE to enable auto-indent, FALSE to disable
	 *
	 * Sets whether the editor should auto-indent itself. A plugin that does
	 * custom auto-indent can set this to false and override the preferences
	 * setting
	 */
	void set_auto_indent (gboolean auto_indent);
	
	/**
	 * ianjuta_editor_erase_range:
	 * @obj: Self
	 * @position_start: Start position of chars to erase.
	 * @position_end: End position of chars to erase.
	 * @err: Error propagation and reporting
	 *
	 * Erases the chars between positions pointed by @position_start and
	 * @position_end. The character pointed by @position_start is included,
	 * while pointed by @position_end is not include in the range. After
	 * the erase operation, all active iters, except these two, are no
	 * longer guranteed to be valid. At the end the operation, these two
	 * iters point to the same position which is the position where erase
	 * happend (usually the original @position_start position).
	 */
	void   erase (IAnjutaIterable *position_start, IAnjutaIterable *position_end);
	
 	/**
	 * ianjuta_editor_erase_all:
 	 * @obj: Self
 	 * @err: Error propagation and reporting
 	 *
	 * Empties the whole editor buffer. There will be zero characters.
	 * After the erase operation, none of the active iters are guranteed
	 * to be valid. 
 	 */
	void   erase_all ();
	
	/**
	 * ianjuta_editor_insert:
	 * @obj: Self
	 * @position: Character position in editor where insert will take place.
	 * @text: Text to append.
	 * @length: Length of @text to use.
	 * @err: Error propagation and reporting
	 *
	 * Inserts @length characters from @text buffer at given @position of
	 * editor buffer. If @length is -1, the whole @text is used.
	 */
	void   insert (IAnjutaIterable *position, const gchar *text, gint length);
	
	/**
	 * ianjuta_editor_append:
	 * @obj: Self
	 * @text: Text to append.
	 * @length: Length of @text to use.
	 * @err: Error propagation and reporting
	 *
	 * Appends @length characters from @text buffer at the end of editor
	 * buffer. If @length is -1, the whole @text is used. @length is in bytes.
	 */
	void   append (const gchar *text, gint length);
	
	/**
	 * ianjuta_editor_goto_line:
	 * @obj: Self
	 * @lineno: line number where carat will be moved.
	 * @err: Error propagation and reporting
	 *
	 * Carat is moved to the given @lineno line and text view is scrolled to
	 * bring it in viewable area of the editor.
	 */
	void   goto_line (gint lineno);
	
	/**
	 * ianjuta_editor_goto_start:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Carat is moved to the begining of editor and text view is scrolled to
	 * bring it in viewable area of the editor.
	 */
	void   goto_start ();
	
	/**
	 * ianjuta_editor_goto_end:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Carat is moved to the end of editor and text view is scrolled to
	 * bring it in viewable area of the editor.
	 */
	void   goto_end ();
	
	/**
	 * ianjuta_editor_goto_position:
	 * @obj: Self
	 * @position: Character position where carat will be moved.
	 * @err: Error propagation and reporting
	 *
	 * Carat is moved to the given @position and text view is scrolled to
	 * bring @position in viewable area of the editor.
	 */
	void goto_position (IAnjutaIterable *position);
	
	/**
	 * ianjuta_editor_get_text:
	 * @obj: Self
	 * @begin: Begining iterator
	 * @end: End iterator
	 * @err: Error propagation and reporting
	 *
	 * Gets text characters beginning from @begin (including char
	 * pointed by @begin) and ending with @end (excluding character
	 * pointed by @end). The characters returned are utf-8 encoded.
	 * The iterators @begin and @end could be in either order. The returned
	 * text, however, is in right order. If both @begin and @end points
	 * to the same position, NULL is returned.
	 *
	 * Returns: A buffer of utf-8 characters.
	 * The returned buffer must be freed when no longer required.
	 */
	gchar* get_text (IAnjutaIterable *begin, IAnjutaIterable *end);

	/**
	 * ianjuta_editor_get_text_all:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Gets all text characters in the editor.
	 * The characters returned are utf-8 encoded.
	 *
	 * Returns: A buffer of utf-8 characters containing all text from editor.
	 * The returned buffer must be freed when no longer required.
	 */
	gchar* get_text_all ();
	
	/**
	 * ianjuta_editor_line_from_position:
	 * @obj: Self
	 * @position: Position you want to know the line from
	 * @err: Error propagation and reporting
	 *
	 * Get the line number in which @position locates.
	 * Returns: Line which corresponds to @position
	 *
	 */
	int get_line_from_position (IAnjutaIterable *position);
	
	/**
	 * ianjuta_editor_get_lineno:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Obtains current line number on which carat is.
	 *
	 * Return value: Line number.
	 */
	gint   get_lineno ();
	
	/**
	 * ianjuta_editor_get_length:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Get length of complete text in editor. This will be the total
	 * number of characters in the file or buffer.
	 *
	 * Return value: Text length.
	 */
	gint   get_length ();
	
	/**
	 * ianjuta_editor_get_current_word:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Obtains the word on which carat is currently on.
	 *
	 * Return value: Current word.
	 */
	gchar* get_current_word ();

	/**
	 * ianjuta_editor_get_current_column:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Obtains number of the current column in the editor.
	 *
	 * Return value: Current column.
	 */
	gint get_column ();
	
	/**
	* ianjuta_editor_get_line_begin_position:
	* @obj: Self
	* @line: fixme
	* @err: Error propagation and reporting.
	*
	* fixme
	*
	* Returns: fixme
	*/
	IAnjutaIterable* get_line_begin_position (gint line);
	
	/**
	* ianjuta_editor_get_line_end_position:
	* @obj: Self
	* @line: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	* 
	* Returns: fixme
	*/
	IAnjutaIterable *get_line_end_position (gint line);
	
	/**
	 * ianjuta_editor_get_overwrite:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Obtains editor overwirte mode: TRUE = Override, FALSE = Insert.
	 *
	 * Return value: editor mode.
	 */
	gboolean get_overwrite ();
	
	
	/**
	 * ianjuta_editor_set_popup_menu:
	 * @obj: Self
	 * @menu: Popupmenu
	 * @err: Error propagation and reporting
	 *
	 * Set Editor popup menu. This is the menu shown in the editor when one
	 * right-clicks on it.
	 *
	 */
	void set_popup_menu (GtkWidget *menu);
	
	/*
	 * ianjuta_editor_get_offset:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Get current caret position in integer character offset. Deprecated.
	 * Use ianjuta_editor_get_position() instead.
	 *
	 * Returns: Current character position since the begining of file.
	 */
	gint   get_offset ();
	
	/*
	 * ianjuta_editor_get_position:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Get current caret position.
	 *
	 * Returns: Iterator that points to the current position.
	 */
	IAnjutaIterable*   get_position ();
	
	/**
	 * ianjuta_editor_get_position_from_offset:
	 * @obj: Self
	 * @offset: Character offset position where the iter will be set
	 * @err: Error propagation and reporting
	 *
	 * Creates and returns an iter for editor cells. The iter is
	 * placed at the unicode character position where the given offset
     * @offset happens to fall. The returned iter is cell (character)
	 * iter and not byte iter, so all iter operations
	 * on it are character (not byte) iteration, including all position
     * and index references in the iter.
     *
     * The iter must be unreferrenced by the caller when done.
	 * The iter navigates (next/previous) in step of unicode
	 * characters (one unicode character == one cell).
	 * 
	 * Retrun value: a newly created iter of IAnjutaEditorCell placed at the
	 * given @offset position.
	 */
	IAnjutaIterable* get_position_from_offset (gint offset);
	
	/**
	 * ianjuta_editor_get_start_position:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Gets the iter positioned at the start of the editor buffer.
	 *
	 * Retrun value: Cell iter set to the begining of the editor.
	 */
	IAnjutaIterable* get_start_position ();
	
	/**
	 * ianjuta_editor_get_end_position:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Gets the iter positioned at the end of the editor buffer. The
	 * returned iter is the end-iter which does not point to any valid
	 * character in the buffer (it is pointed one step beyond the last
	 * valid character).
	 * 
	 * Retrun value: Cell iter set to the end of the editor (end-iter).
	 */
	IAnjutaIterable* get_end_position ();

	/**
	 * SECTION:ianjuta-editor-selection
	 * @title: IAnjutaEditorSelection
	 * @short_description: Text editor selection interface
	 * @see_also: 
	 * @stability: Unstable
	 * @include: libanjuta/interfaces/ianjuta-editor-selection.h
	 * 
	 */
	interface IAnjutaEditorSelection
	{
		#include <libanjuta/interfaces/ianjuta-editor-cell.h>
		/**
		 * ianjuta_editor_selection_has_selection:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Returns TRUE if editor has any text selected. The selection
		 * positions can be retrieved with ianjuta_editor_selection_get_start()
		 * and ianjuta_editor_selection_get_end().
		 * 
		 * Returns: TRUE if there is text selected else FALSE.
		 */
		gboolean has_selection ();
		
		/**
		 * ianjuta_editor_selection_get:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Gets curerntly selected text in editor.
		 * 
		 * Returns: A newly allocated buffer of currently selected characters.
		 * NULL if there is no selection. The returned buffer must be freed after
		 * use.
		 */
		gchar* get ();
		
		/**
		 * ianjuta_editor_selection_set:
		 * @obj: Self
		 * @start: Begin of selection
		 * @end: End of selection
		 * @err: Error propagation and reporting
		 *
		 * Select characters between start and end. Start and end don't have to
		 * be ordered.
		 */
		void set (IAnjutaIterable* start, IAnjutaIterable* end);
		
		/**
		 * ianjuta_editor_selection_get_start:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Gets start position of selection text. If there is no selection,
		 * returns -1.
		 *
		 * Return: Start of selection or NULL if there is no selection.
		 */
		IAnjutaIterable* get_start ();
		
		/**
		 * ianjuta_editor_selection_get_end:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Get end position of selection. If there is no selection, returns
		 * NULL.
		 * 
		 * Return: End of selection or NULL if there is no selection.
		 */
		IAnjutaIterable* get_end ();

		/**
		 * ianjuta_editor_selection_select_block:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Selects current block of code. The definition of block of code
		 * depends on highlight mode used (programming language). Some
		 * highlight mode does not have block concept, in that case this
		 * method does not do anything.
		 */
		void select_block ();
		
		/**
		 * ianjuta_editor_selection_select_function:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Select current function block. The definition of function block
		 * depends on highlight mode used (programming language). Some
		 * highlight mode does not have function concept, in that case this
		 * method does not do anything.
		 */
		void select_function ();

		/**
		 * ianjuta_editor_selection_select_to_brace:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Select to brace. Some highlight mode does not have braces concept,
		 * in that case, this method does not do anything.
		 */
		void select_to_brace ();
		
		/**
		 * ianjuta_editor_edit_select_all:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Select whole buffer.
		 */
		void select_all ();

		/**
		 * ianjuta_editor_selection_replace:
		 * @obj: Self
		 * @text: Replacement text.
		 * @length: Length of the text to used in @text.
		 * @err: Error propagation and reporting
		 *
		 * Replaces currently selected text with the @text. Only @length amount
		 * of characters are used from @text buffer to replace.
		 */
		void replace (const gchar *text, gint length);
	}
	
	/**
	 * SECTION:ianjuta-editor-search
	 * @title: IAnjutaEditorSearch
	 * @short_description: Text editor search interface
	 * @see_also: 
	 * @stability: Unstable
	 * @include: libanjuta/interfaces/ianjuta-editor-search.h
	 * 
	 */
	interface IAnjutaEditorSearch
	{
	  #include <libanjuta/interfaces/ianjuta-editor-cell.h>
		
		/**
		 * ianjuta_editor_search_forward:
		 * @obj: Self
		 * @search: String to search for
		 * @start: Where to search from
	 	 * @end: Where to stop searching
	 	 * @result_start: Will be set to the start of the search_result (or NULL)
	 	 * @result_end: Will be set to the end of the search_result (or NULL)
	 	 * @err: Error propagation and reporting
	 	 *
	 	 * Search forward from start to end
	 	 *
	 	 */
		gboolean forward (const gchar* search, gboolean case_sensitive, IAnjutaEditorCell* start, IAnjutaEditorCell* end, IAnjutaEditorCell** result_start, IAnjutaEditorCell** result_end);
				
		/**
		 * ianjuta_editor_search_backward:
		 * @obj: Self
		 * @search: String to search for		 
		 * @start: Where to search from
		 * @end: Where to stop searching
		 * @result_start: Will be set to the start of the search_result (or NULL)
		 * @result_end: Will be set to the end of the search_result (or NULL)
		 * @err: Error propagation and reporting
		 *
		 * Search backward from end to start
		 *
		 */
		 
		 gboolean backward (const gchar* search, gboolean case_sensitive, IAnjutaEditorCell* start, IAnjutaEditorCell* end, IAnjutaEditorCell** result_start, IAnjutaEditorCell** result_end);	
	}
	
	
	/**
	 * SECTION:ianjuta-editor-convert
	 * @title: IAnjutaEditorConvert
	 * @short_description: Text editor convert interface
	 * @see_also: 
	 * @stability: Unstable
	 * @include: libanjuta/interfaces/ianjuta-editor-convert.h
	 * 
	 */
	interface IAnjutaEditorConvert
	{
		/**
		 * ianjuta_editor_convert_to_upper:
		 * @obj: Self
		 * @start_position: Start position.
		 * @end_position: End position.
		 * @err: Error propagation and reporting
		 *
		 * change characters from start position to end position to uppercase.
		 *
		 */
		void to_upper (IAnjutaIterable *start_position, IAnjutaIterable *end_position);
		
		/**
		 * ianjuta_editor_convert_to_lower:
		 * @obj: Self
		 * @start_position: Start position.
		 * @end_position: End position.
		 * @err: Error propagation and reporting
		 *
		 * change characters from start position to end position to lowercase
		 *
		 */
		void to_lower (IAnjutaIterable *start_position, IAnjutaIterable *end_position);
	}
	
	/**
	 * SECTION:ianjuta-editor-line-mode
	 * @title: IAnjutaEditorLineMode
	 * @short_description: Text editor line mode
	 * @see_also: 
	 * @stability: Unstable
	 * @include: libanjuta/interfaces/ianjuta-editor-line-mode.h
	 * 
	 */
	interface IAnjutaEditorLineMode
	{
		enum Type
		{
			LF,
			CR,
			CRLF
		}
		
		/**
		 * ianjuta_editor_line_mode_get:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Get current line ending mode. It is auto-detected from the
		 * buffer contents.
		 */
		Type get ();
		
		/**
		 * ianjuta_editor_line_mode_set:
		 * @obj: Self
		 * @mode: Line mode to set.
		 * @err: Error propagation and reporting
		 *
		 * Set the line ending mode to the given @mode. Existing line end
		 * characters in the buffer are not touched. Only the newly added
		 * texts will have @mode line end characters.
		 */
		void set (Type mode);

		/**
		 * ianjuta_editor_line_mode_convert:
		 * @obj: Self
		 * @mode: Line mode to convert.
		 * @err: Error propagation and reporting
		 *
		 * Set the line ending mode to the given @mode and convert all line end
		 * characters in the buffer to @mode line end characters.
		 */
		void convert (Type mode);
		
		/**
		 * ianjuta_editor_line_mode_fix:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Convert EOL characters to majority of line mode. This is helpful
		 * when the buffer contains mixed line modes and we want to fix it.
		 */
		void fix ();
	}
	
	/**
	 * SECTION:ianjuta-editor-assist
	 * @title: IAnjutaEditorAssist
	 * @short_description: Editor assistance framework
	 * @see_also: 
	 * @stability: Unstable
	 * @include: libanjuta/interfaces/ianjuta-editor-assist.h
	 * 
	 */
	interface IAnjutaEditorAssist
	{
		/* IAnjutaEdiotrAssist::assist_chosen:
		 * @obj: self
		 * @selection: The selection index
		 *
		 * User's selection from the choices. It is the index of the choice
		 * presented with ianjuta_editor_assist_suggest().
		 */
		void ::assist_chosen (gint selection);
		
		/**
		 * ianjuta_editor_assist_suggest:
		 * @obj: Self
		 * @choices: list of choices.
 		 * @char_alignment: Character alignment.
		 * @err: Error propagation and reporting
		 * 
		 * Suggest a list of choices to the user. The suggestions are viewed 
		 * at char_alignment which should be the beginning of the completed word.
		 * If choices is NULL, and assist_end signal
		 * will occur
		 *
		 */
		void suggest (List<const gchar*> choices, IAnjutaIterable *position, int char_alignment);
		
		/** ianjuta_editor_assist_hide_suggestions
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Hide current suggestions but do not emit assist_end signal.
		 * This is useful when temporary waiting for more context
		 */
		void hide_suggestions ();
		
		/**
		 * ianjuta_editor_assist_tip:
		 * @obj: Self
		 * @tips: list of alternative tips.
		 * @char_alignment: Character alignment.
		 * @err: Error propagation and reporting
		 *
		 * Show tips showing more information on current context. No user feedback
		 * is required when tips are shown. @char_alignment indicates
		 * the position before which is the known context and after which are
		 * the suggestions. Usually the editor would use this to
		 * align the choices displayed such that the carat is just at this
		 * position when the choices are displayed.
		 *
		 */
		void show_tips (List<const gchar*> tips, IAnjutaIterable *position, gint char_alignment);
		
		/**
		 * ianjuta_editor_assist_cancel_tip:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Cancels the last shown tooltip
		 */
		void cancel_tips ();
		
		/**
		 * ianjuta_editor_assist_get_suggestions:
		 * @obj: Self
		 * @context: The context for the suggestions.
		 * @err: Error propagation and reporting
		 *
		 * Usually the editor might have some suggestions to make
		 * for a context. For example in a simple word completion context.
		 * If the editor has no suggestions to make, it returns NULL.
		 * 
		 * Returns: A list of suggestions for the given context or NULL
		 * if there is nothing to suggest.
		 * 
		 * Returns: A list of dynamically allocated strings. The whole
		 * list, including the the strings should be freed when done.
		 */
		List<const gchar*> get_suggestions (const gchar *context);
	}
	
	/**
	 * SECTION:ianjuta-editor-hover
	 * @title: IAnjutaEditorHover
	 * @short_description: Text editor hover interface
	 * @see_also: 
	 * @stability: Unstable
	 * @include: libanjuta/interfaces/ianjuta-editor-hover
	 * 
	 */
	interface IAnjutaEditorHover
	{
	  #include <libanjuta/interfaces/ianjuta-iterable.h>
	
		void ::hover_over (GObject* position);
		void ::hover_leave (GObject* position);
		
		void display (IAnjutaIterable* position, const gchar *info);
	}
	
	/**
	 * SECTION:ianjuta-editor-language
	 * @title: IAnjutaEditorLanguage
	 * @short_description: Text editor language interface
	 * @see_also: 
	 * @stability: Unstable
	 * @include: libanjuta/interfaces/ianjuta-editor-language.h
	 * 
	 */
	interface IAnjutaEditorLanguage
	{
		void ::language_changed (const gchar *language);
		
		/**
		 * ianjuta_editor_language_get_supported_languages:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Return a list of languages supported by the editor
		 * Note: These list contains the names in the form
		 * the editor implementation knows them
		 *
		 */
		
		const List<const gchar*> get_supported_languages ();
		
		/**
		 * ianjuta_editor_language_name:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * FIXME
		 *
		 */

		const gchar *get_language_name (const gchar* language);
		
		/**
		 * ianjuta_editor_language_get_language:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Return the name of the currently used language
		 *
		 */

		const gchar *get_language ();
		
		/**
		 * ianjuta_editor_language_set_language:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 * @lang: Language
		 *
		 * Force the editor to use a given language
		 *
		 */
		
		void set_language (const gchar* language);
	}
	
	/**
	 * SECTION:ianjuta-editor-folds
	 * @title: IAnjutaEditorFolds
	 * @short_description: Text editor folds inteface
	 * @see_also: 
	 * @stability: Unstable
	 * @include: libanjuta/interfaces/ianjuta-editor-folds.h
	 * 
	 */
	interface IAnjutaEditorFolds
	{
		/**
		 * ianjuta_editor_view_open_folds:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Open all folds
		 *
		 */
		void open_all ();
		
		/**
		 * ianjuta_editor_view_close_folds:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Close all folds
		 *
		 */
		void close_all ();
		
		/**
		 * ianjuta_editor_view_toggle_fold:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Open/Close current fold
		 *
		 */
		void toggle_current ();
	}
	
	/**
	 * SECTION:ianjuta-editor-view
	 * @title: IAnjutaEditorView
	 * @short_description: Text editor view interface
	 * @see_also: 
	 * @stability: Unstable
	 * @include: libanjuta/interfaces/ianjuta-editor-view.h
	 * 
	 * An editor view is a visual representation of the editor. An editor
	 * can have multiple views. All views of an editor show the same editor
	 * content (buffer). Consequently, any change done in one view is
	 * updated in all other views.
	 */
	interface IAnjutaEditorView
	{
		/**
		 * ianjuta_editor_view_create:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Creates a new view for the editor. The newly created view gets
		 * the user focus and scrolls to the same location as last view.
		 */
		void create ();
		
		/**
		 * ianjuta_editor_view_remove_current:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Removes currently focused editor view. It does not remove the
		 * last view of the editor. That is, if currently there is only
		 * one view of the editor, this function does nothing.
		 */
		void remove_current ();
		
		/**
		 * ianjuta_editor_view_get_count:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Total number of views currently present. It will never be less
		 * than 1. Invalid return values are considered error condition.
		 */
		gint get_count ();
	}
	
	/**
	 * SECTION:ianjuta-editor-comment
	 * @title: IAnjutaEditorComment
	 * @short_description: Text editor comment interface
	 * @see_also: 
	 * @stability: Unstable
	 * @include: libanjuta/interfaces/ianjuta-editor-comment.h
	 * 
	 */
	interface IAnjutaEditorComment
	{
		/**
		 * ianjuta_editor_comment_block:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Comment/Uncomment out selected block
		 */
		void block();
		
		/**
		 * ianjuta_editor_comment_box:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Comment/Uncomment out selected block
		 */
		void box();
		
		/**
		 * ianjuta_editor_comment_stream:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Comment/Uncomment out selected block
		 */
		void stream();
	}
	
	/**
	 * SECTION:ianjuta-editor-zoom
	 * @title: IAnjutaEditorZoom
	 * @short_description: Text editor zoom interface
	 * @see_also: 
	 * @stability: Unstable
	 * @include: libanjuta/interfaces/ianjuta-editor-zoom.h
	 * 
	 */
	interface IAnjutaEditorZoom
	{
		/**
		 * ianjuta_editor_zoom_in:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Zoom in
		 */
		void in ();
		
		/**
		 * ianjuta_editor_zoom_out:
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Zoom out
		 */
		void out ();
	}
	
	/**
	 * SECTION:ianjuta-editor-goto
	 * @title: IAnjutaEditorGoto
	 * @short_description: Text editor navigation interface
	 * @see_also: 
	 * @stability: Unstable
	 * @include: libanjuta/interfaces/ianjuta-editor-goto.h
	 * 
	 */
	interface IAnjutaEditorGoto
	{
		/**
		 * ianjuta_editor_goto_start_block()
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Moves cursor to the start of the current block
		 */
		void start_block();
		
		/**
		 * ianjuta_editor_goto_end_block()
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Moves cursor to the end of the current block
		 */
		void end_block();

		/**
		 * ianjuta_editor_goto_matching_brace()
		 * @obj: Self
		 * @err: Error propagation and reporting
		 *
		 * Moves cursor to matching brace
		 */
		void matching_brace();
		
	}
}

/**
 * SECTION:ianjuta-editor-cell
 * @title: IAnjutaEditorCell
 * @short_description: Text editor character cell
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-editor-cell.h
 * 
 * Represents a cell in editor. A cell corresponds to a unicode
 * character along with all associated styles (such as colors and font).
 * A cell may or may not have style. If style is supported in the
 * editor, it is assumed all cells will have styles and hence every
 * IAnjutaEditorCell interface instance will have additionally
 * IAnjutaEditorCellStyle implemented.
 */
interface IAnjutaEditorCell
{
	#include <libanjuta/interfaces/ianjuta-editor.h>
	
	/**
	 * ianjuta_editor_cell_get_character:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Returns the unicode character in this cell. A NULL terminated
	 * string is returned that is the multibyte unicode character.
	 * NULL is returned if the cell does not have any character.
	 * 
	 * Retruns: a newly created string representing the cell's unicode
	 * character.
	 */
	gchar *get_character ();
	
	/**
	 * ianjuta_editor_cell_get_length:
	 * @obj: self
	 * @err: Error propagation and reporting.
	 *
	 * Gets the length of the cell in bytes. That is, length of the
	 * unicode character.
	 * 
	 * Returns: Length of the unicode character.
	 */
	gint get_length ();

	/**
	 * ianjuta_editor_cell_get_char:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Returns the byte of the unicode character in this cell at given
	 * index @char_index. @char_index can vary from 0 to length of the
	 * unicode string minus 1. Out of range index is not allowed
	 * (asserted) and return is undefined.
	 * 
	 * Since there is dynamic allocation of unicode character string
	 * involved in ianjuta_editor_cell_get_character(), this function
	 * is mainly useful for fast iteration (such as copying data).
	 * 
	 * Retruns: a byte character.
	 */
	gchar get_char (gint char_index);
	
	IAnjutaEditorAttribute get_attribute ();
	
	/**
	 * SECTION:ianjuta-editor-cell-style
	 * @title: IAnjutaEditorCellStyle
	 * @short_description: Text editor cell style interface
	 * @see_also: 
	 * @stability: Unstable
	 * @include: libanjuta/interfaces/ianjuta-editor-cell-style.h
	 * 
	 */
	interface IAnjutaEditorCellStyle
	{
		gchar* get_font_description ();
		gchar* get_color();
		gchar* get_background_color();
	}
}

/**
 * SECTION:ianjuta-bookmark
 * @title: IAnjutaBookmark
 * @short_description: Bookmark interface
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-bookmark.h
 * 
 */
interface IAnjutaBookmark
{
	/**
	 * ianjuta_bookmark_toggle:
	 * @obj: Self
	 * @location: The location where bookmark is toggled.
	 * @ensure_visible: If the location must be made visible.
	 * @err: Error propagation and reporting
	 *
	 * Toggle bookmark at given @location
	 *
	 */
	void toggle (gint location, gboolean ensure_visible);
	
	/**
	 * ianjuta_bookmark_first:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Goto first bookmark
	 *
	 */
	void first ();
	
	/**
	 * ianjuta_bookmark_last:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Goto last bookmark
	 *
	 */
	void last ();
	
	/**
	 * ianjuta_bookmark_next:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Goto next bookmark
	 *
	 */
	void next ();
	
	/**
	 * ianjuta_bookmark_previous:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Goto previous bookmark
	 *
	 */
	void previous ();
	
	/**
	 * ianjuta_bookmark_clear_all:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Clear all bookmarks
	 *
	 */
	void clear_all ();
}

/**
 * SECTION:ianjuta-editor-factory
 * @title: IAnjutaEditorFactory
 * @short_description: Text editor factory that creates IAnjutaEditor objects
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-editor-factory.h
 * 
 */
interface IAnjutaEditorFactory
{
	#include "ianjuta-editor.h"
	
	/**
	 * ianjuta_editor_factory_new_editor:
	 * @obj: Self
	 * @uri: Uri to open
	 * @filename: filename to open
	 * @err: Error propagation and reporting
	 *
	 * Get a new GtkWidget* which implements IAnjutaEditor
	 *
	 * Return value: An object implementing IAnjutaEditor
	 */
	IAnjutaEditor* new_editor (const gchar* uri, const gchar* filename);
}

/**
 * SECTION:ianjuta-document-manager
 * @title: IAnjutaDocumentManager
 * @short_description: Interface for plugin that manages all the editors
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-document-manager.h
 * 
 */
interface IAnjutaDocumentManager
{
	#include "ianjuta-document.h"
	#include "ianjuta-editor.h"
	
	enum Error
	{
		DOESNT_EXIST
	}

	/**
	* ianjuta_document_manager_get_uri:
	* @obj: Self
	* @file: short filename
	* @err: Error propagation and reporting.
	* 
	* Given the short filename, finds the URI of the file, if the
	* editor that has it loaded is found. If there is no editor that has
	* this file opened, returns NULL.
	* 
	* Return value: the URI of the file, if an editor is found for it.
	*/
	gchar* get_uri (const gchar *file);
	
	/**
	* ianjuta_document_manager_find_document_with_uri:
	* @obj: Self
	* @uri: the file uri.
	* @err: Error propagation and reporting.
	* 
	* Finds the document that has the file with URI @uri loaded. Only
	* the editor that matches the URI will be searched.
	* 
	* Return value: the document that corresponds to given URI. NULL if
	* there is no editor loaded with this URI.
	*/
	IAnjutaDocument* find_document_with_uri (const gchar *uri);
	
	/**
	* ianjuta_document_manager_goto_uri_line:
	* @obj: Self
	* @uri: URI of the file to go to.
	* @lineno: the line number in the file to go to.
	* @err: Error propagation and reporting.
	* 
	* Loads the given file if not loaded yet, set its editor as current editor
	* and moves cursor to the given line in the editor.
	* 
	* Return value: the editor where the mark has been put. NULL if none.
	*/
	IAnjutaEditor* goto_uri_line (const gchar *uri, gint lineno);
	
	/** 
	* ianjuta_document_manager_goto_uri_line_mark:
	* @obj: Self
	* @uri: URI of the file to go to.
	* @lineno: the line number in the file to go to.
	* @mark: TRUE if the line should be marked with a marker.
	* @err: Error propagation and reporting
	* 
	* Loads the given file if not loaded yet, set its editor as current editor
	* and moves cursor to the given line in the editor. Optionally also marks
	* the line with line marker if @mark is given TRUE.
	* 
	* Return value: the editor where the mark has been put. NULL if none.
	*/
	IAnjutaEditor* goto_uri_line_mark (const gchar *uri, gint lineno, gboolean mark);
	
	/**
	* ianjuta_document_manager_get_current_document:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* Gets the current document.
	* 
	* Return value: the currently active document. NULL if none is there.
	*/
	IAnjutaDocument* get_current_document ();
	
	/** 
	* ianjuta_document_manager_set_current_document:
	* @obj: Self
	* @document: the document to set as current.
	* @err: Error propagation and reporting.
	* 
	* Sets the given document as current document.
	*/
	void set_current_document (IAnjutaDocument *document);
	
	/**
	* ianjuta_document_manager_get_doc_widgets:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* Gets a list of widgets for open documents. Each widget is
	* a GTK_WIDGET(InjutaDocument*)
	*
	* Return value: a list of widgets for all open documents
	* The returned list (but not the data in the list) must be
	* freed after use.
	*/
	List<GtkWidget*> get_doc_widgets ();

	/**
	* ianjuta_document_manager_add_buffer:
	* @obj: Self
	* @name: Name of the editor buffer.
	* @content: Initial content of the buffer.
	* @err: Error propagation and reporting.
	* 
	* Creates a new editor buffer of the given name and sets the given
	* content as its initial content.
	* 
	* Return value: the IAnjutaEditor instance that has been added.
	*/
	IAnjutaEditor* add_buffer (const gchar *name, const gchar* content);
	
	/**
	* ianjuta_document_manager_remove_document:
	* @obj: Self
	* @document: Document to close.
	* @save_before: If true, saves the document before closing.
	* @err: Error propagation and reporting.
	*
	* Closes and removes the given document. If @save_before is TRUE, also
	* saves the document before closing.
	*
	* Return value: TRUE if the document was removed, else FALSE.
	*/
	gboolean remove_document (IAnjutaDocument *document, gboolean save_before);

	/**
	* ianjuta_document_manager_add_document:
	* @obj: Self
	* @document: the document to add
	* @err: Error propagation and reporting.
	*
	* Adds a document to the document manager. This will open a new
	* Notebook tab and show the document there
	*
	*/
	void add_document (IAnjutaDocument* document);
	
}

/**
 * SECTION:ianjuta-message-view
 * @title: IAnjutaMessageView
 * @short_description: A view where messages of different kind can be shown
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-message-view.h
 * 
 */
interface IAnjutaMessageView
{
	enum Type
	{
		TYPE_NORMAL,
		TYPE_INFO,
		TYPE_WARNING,
		TYPE_ERROR
	}
	
	/**
	* IAnjutaMessageView::message_clicked:
	* @obj: Self
	* @message: fixme
	* @err: Error propagation and reporting.
	*
	* fixme
	*/
	void ::message_clicked (const gchar *message);
	
	/** 
	* IAnjutaMessageView::buffer_flushed:
	* @obj: Self
	* @line: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*/
	void ::buffer_flushed (const gchar *line);
	
	/**
	* ianjuta_message_view_buffer_append:
	* @obj: Self
	* @text: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*/
	void buffer_append (const gchar *text);
	
	/**
	* ianjuta_message_view_append:
	* @obj: Self
	* @type: fixme
	* @summary: fixme
	* @details: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*/
	void append (Type type, const gchar *summary, const gchar *details);
	
	/**
	* ianjuta_message_view_clear:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* fixme
	*/
	void clear ();
	
	/**
	* ianjuta_message_view_select_next:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* fixme
	*/
	void select_next ();
	
	/**
	* ianjuta_message_view_select_previous:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* fixme
	*/
	void select_previous ();
	
	/**
	* ianjuta_message_view_get_current_message:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* fixme
	*/
	const gchar* get_current_message ();
	
	/**
	* ianjuta_message_view_get_all_messages:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* fixme
	*/
	List<const gchar*> get_all_messages ();
}

/**
 * SECTION:ianjuta-message-manager
 * @title: IAnjutaMessageManager
 * @short_description: The plugin that managers all message views
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-message-manager.h
 * 
 */
interface IAnjutaMessageManager
{
	#include "ianjuta-message-view.h"
	
	enum Error
	{
		DOESNT_EXIST
	}
	/**
	 * ianjuta_message_manager_add_view:
	 * @obj: Self
	 * @name: Name/Title of the new view
	 * @icon: Path to an icon or ""
	 * @err: Error propagation and reporting
	 *
	 * Adds a new view to the message-manager
	 *
	 * Return value: The new message-view
	 */
	IAnjutaMessageView* add_view (const gchar *name, const gchar *icon);
	
	/**
	 * ianjuta_message_manager_remove_view:
	 * @obj: Self
	 * @view: The view to remove
	 * @err: Error propagation and reporting
	 *
	 * Remove view from the message-manager. The view
	 * will become invalid.
	 */
	void remove_view (IAnjutaMessageView *view);
	
	/**
	 * ianjuta_message_manager_get_current_view:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Get the view with is currently on top of 
	 * the notebook or NULL if the message-manager is empty.
	 *
	 * Return value: Current view; #IAnjutaMessageView object.
	 * NULL, if there is no views.
	 */
	IAnjutaMessageView* get_current_view ();
	
	/**
	 * ianjuta_message_manager_get_view_by_name:
	 * @obj: Self
	 * @name: Name/Title of the view
	 * @err: Error propagation and reporting
	 *
	 * Get the view with the given name or NULL if
	 * it does not exist.
	 *
	 * Return value: The message-view or NULL
	 */
	IAnjutaMessageView* get_view_by_name (const gchar *name);
	
	/**
	 * ianjuta_message_manager_get_all_views:
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Get all message-views
	 *
	 * Return value: A GList* of all views. You must not
	 * manipulate the list.
	 */
	List<IAnjutaMessageView*> get_all_views ();
	
	/**
	 * ianjuta_message_manager_set_current_view:
	 * @obj: Self
	 * @view: A message view
	 * @err: Error propagation and reporting
	 *
	 * Set view to be on top of the notebook.
	 *
	 */
	void set_current_view (IAnjutaMessageView *view);
	
	/**
	 * ianjuta_message_manager_set_view_title:
	 * @obj: Self
	 * @view: A message view
	 * @title: Sets the title of view.
	 * @err: Error propagation and reporting
	 *
	 * Sets the title of view.
	 *
	 */
	void set_view_title (IAnjutaMessageView *view, const gchar *title);
}

/**
 * SECTION:ianjuta-file-manager
 * @title: IAnjutaFileManager
 * @short_description: File manager plugin
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-file-manager.h
 * 
 */
interface IAnjutaFileManager
{

	/**
	* IAnjutaFileManager::section_changed:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* fixme
	*/
	void ::section_changed (const gchar *uri);
	
	/**
	* ianjuta_file_manager_set_root:
	* @obj: Self
	* @root_uri: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*/
	void set_root (const gchar *root_uri);
	
	/**
	* ianjuta_file_manager_get_selected:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* fixme
	*/
	gchar* get_selected ();
	
	/**
	* ianjuta_file_manager_set_selected:
	* @obj: Self
	* @uri: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme.
	*/
	void set_selected (const gchar *uri);
}

/**
 * SECTION:ianjuta-terminal
 * @title: IAnjutaTerminal
 * @short_description: Interface for command line terminals
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-terminal.h
 * 
 */
interface IAnjutaTerminal
{
	#include <sys/types.h>
		
	/**
	* ianjuta_terminal_execute_command:
	* @obj: Self
	* @directory: fixme
	* @command: fixme
	* @err: Error propagation and reporting.
	*
	* fixme
	* 
	* Returns: fixme
	*/
	pid_t execute_command (const gchar* directory, const gchar *command);
}

/**
 * SECTION:ianjuta-project-manager
 * @title: IAnjutaProjectManager
 * @short_description: Interface for project managers
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-project-manager.h
 * 
 */
interface IAnjutaProjectManager
{
	enum ElementType
	{
		UNKNOWN,
		SOURCE,
		TARGET,
		GROUP
	}
	
	enum TargetType
	{
		TARGET_UNKNOWN,
		TARGET_SHAREDLIB,
		TARGET_STATICLIB,
		TARGET_EXECUTABLE
	}
	
	enum Capabilities
	{
		CAN_ADD_NONE     = 0,
		CAN_ADD_GROUP    = 1 << 0,
		CAN_ADD_TARGET   = 1 << 1,
		CAN_ADD_SOURCE   = 1 << 2
	}
	
	// Signals
	
	/**
	* IAnjutaProjectManager::element_added:
	* @obj: Self
	* @element_uri: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*/
	void ::element_added (const gchar *element_uri);
	
	/** 
	* IAnjutaProjectManager::element_removed:
	* @obj: Self
	* @element_uri: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*/
	void ::element_removed (const gchar *element_uri);
	
	/**
	* IAnjutaProjectManager::element_selected:
	* @obj: Self
	* @element_uri: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*/
	void ::element_selected (const gchar *element_uri);
	
	// Methods
	
	/**
	* ianjuta_project_manager_get_element_type:
	* @obj: Self
	* @element_uri: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	ElementType get_element_type (const gchar *element_uri);
	
	/**
	* ianjuta_project_manager_get_elements:
	* @obj: Self
	* @element_type: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	* 
	* Returns: fixme
	*/
	List<const gchar*> get_elements (ElementType element_type);
	
	/**
	* ianjuta_project_manager_get_target_type:
	* @obj: Self
	* @target_uri: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	* 
	* Returns: fixme
	*/
	TargetType get_target_type (const gchar *target_uri);
	
	/**
	* ianjuta_project_manager_get_targets:
	* @obj: Self
	* @target_type: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	* 
	* Returns: fixme
	*/
	List<const gchar*> get_targets (TargetType target_type);
	
	/**
	* ianjuta_project_manager_get_parent:
	* @obj: Self
	* @element_uri: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gchar* get_parent (const gchar *element_uri);
	
	/**
	* ianjuta_project_manager_get_children:
	* @obj: Self
	* @element_uri: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	List<const gchar*> get_children (const gchar *element_uri);
	
	/**
	* ianjuta_project_manager_get_selected:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* fixme
	*/
	gchar* get_selected ();
	
	/**
	* ianjuta_project_manager_get_capabilities:
	* @obj: Self
	* @err: Error propagation and reporting.
	*
	* Returns the capabilites of project whether it can add group, target
	* sources etc.
	*
	* Returns: Supported capabilites.
	*/
	Capabilities get_capabilities ();

	/**
	* ianjuta_project_manager_add_source:
	* @obj: Self
	* @source_uri_to_add: fixme
	* @default_location_uri: fixme
	* @err: Error propagation and reporting.
	*
	* Prompt the user to add a file to the project. If the user selects
	* multiple files only the first uri is returned.
	*
	* Returns: element URIs. Must be freed when no longer required.
	*/
	gchar* add_source (const gchar *source_uri_to_add, const gchar *default_location_uri);
	
	/**
	* ianjuta_project_manager_add_sources:
	* @obj: Self
	* @source_uris_to_add: fixme
	* @default_location_uri: fixme
	* @err: Error propagation and reporting.
	*
	* Prompt the user to add a file to the project. If the user selects
	* multiple files only the first uri is returned.
	*
	* Returns: element URIs. Must be freed when no longer required.
	*/
	List<const gchar*> add_sources (List<const gchar*> source_uri_to_add, const gchar *default_location_uri);
	
	/**
	* ianjuta_project_manager_add_target:
	* @obj: Self
	* @target_name_to_add: fixme
	* @default_location_uri: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	* 
	* Returns:
	*/
	gchar* add_target (const gchar *target_name_to_add, const gchar *default_location_uri);
	
	/**
	* ianjuta_project_manager_add_group:
	* @obj: Self
	* @group_name_to_add: fixme
	* @default_location_uri: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	* 
	* Returns: fixme
	*/
	gchar* add_group (const gchar *group_name_to_add, const gchar *default_location_uri);
	
	/**
	* ianjuta_project_manager_is_open:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* fixme
	*/ 
	gboolean is_open ();
}

/**
 * SECTION:ianjuta-todo
 * @title: IAnjutaTodo
 * @short_description: Task manager interface
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-todo.h
 * 
 */
interface IAnjutaTodo
{

	/**
	* ianjuta_to_do_load:
	* @obj: Self
	* @uri: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*/
	void load(const gchar *uri);
}

/**
 * SECTION:ianjuta-wizard
 * @title: IAnjutaWizard
 * @short_description: Interface for wizards that can create new stuffs
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-wizard.h
 * 
 */
interface IAnjutaWizard
{

	/**
	* ianjuta_wizard_activate:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* fixme
	*/
	void activate();
}

/**
 * SECTION:ianjuta-debugger
 * @title: IAnjutaDebugger
 * @short_description: Debugger interface
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-debugger.h
 * 
 */
interface IAnjutaDebugger
{
	#include "ianjuta-message-view.h"
	#include <libanjuta/anjuta-error.h>
	#include <sys/types.h>

	/* Types */
	enum Error
	{
		OK              =  0,
		NOT_READY,
		NOT_RUNNING,
		NOT_STOPPED,
		NOT_LOADED,
		NOT_STARTED,
		NOT_CONNECTED,
		NOT_IMPLEMENTED,
		CANCEL,
		UNABLE_TO_CREATE_VARIABLE,
		UNABLE_TO_ACCESS_MEMORY,
		UNABLE_TO_OPEN_FILE,
		UNSUPPORTED_FILE_TYPE,
		UNSUPPORTED_VERSION,
		UNABLE_TO_FIND_DEBUGGER,
		ALREADY_DONE,
		UNKNOWN_ERROR,
		OTHER_ERROR
	}

	enum Data
	{
		INFORMATION,
		BREAKPOINT,
		FRAME,
		VARIABLE,
		REGISTER
	}

	enum OutputType
	{
		OUTPUT,
		WARNING_OUTPUT,
		ERROR_OUTPUT,
		INFO_OUTPUT
	}

	enum State
	{
		BUSY,
		STOPPED,
		STARTED,
		PROGRAM_LOADED,
		PROGRAM_STOPPED,
		PROGRAM_RUNNING
	}

	struct Frame
	{
		gint thread;
		guint level;
		gchar *args;
		gchar *file;
		guint line;
		gchar *function;
		gchar *library;
		gulong address;
	}

	/* Call back functions */
	typedef void (*Callback) (const gpointer data, gpointer user_data, GError* err);
	typedef void (*GListCallback) (const GList* list, gpointer user_data, GError* err);
	typedef void (*GCharCallback) (const gchar *value, gpointer user_data, GError* err);
	typedef void (*OutputCallback) (OutputType type, const gchar *output, gpointer user_data);
	typedef void (*MemoryCallback) (gulong address, guint length, const gchar *data, gpointer user_data, GError *err);

	/* Signals */

	/**
	* IAnjutaDebugger::debugger_started:
	* @obj: Self
	* 
	* fixme
	*/
	void ::debugger_started ();

	/**
	* IAnjutaDebugger::debugger_stopped:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* fixme
	*/
	void ::debugger_stopped (GError *err);

	/**
	* IAnjutaDebugger::program_loaded:
	* @obj: Self
	* 
	* fixme
	*/
	void ::program_loaded ();

	/**
	* IAnjutaDebugger::program_running:
	* @obj: Self
	* 
	* fixme
	*/
	void ::program_running ();

	/**
	* IAnjutaDebugger::program_stopped:
	* @obj: Self
	* 
	* fixme
	*/
	void ::program_stopped ();	

	/**
	* IAnjutaDebugger::program_exited:
	* @obj: Self
	* 
	* fixme
	*/
	void ::program_exited ();

	/**
	* IAnjutaDebugger::sharedlib_event:
	* @obj: Self
	* 
	* fixme
	*/
	void ::sharedlib_event ();

	/**
	* IAnjutaDebugger::program_moved:
	* @obj: Self
 	* @pid: process id, 0 when unknown
	* @tid: thread id, 0 when unknown
	* @address: program counter address, 0 when unknown
	* @file: source file where is the program counter, NULL when unknown
	* @line: line number if file name above is not NULL
	* 
	* This signal is emitted when the debugger know the current program 
	* location. Most of the time, after the program has stopped but it
	* could happen even if it is still running.
	*/
	void ::program_moved (gint pid, gint tid, gulong address, const gchar* file, guint line);

	/**
	* IAnjutaDebugger::frame_changed:
	* @obj: Self
	* @frame: fixme
	* @thread: thread
	* 
	* fixme
	*/
	void ::frame_changed (guint frame, gint thread);	

	/**
	* IAnjutaDebugger::signal_received:
	* @obj: Self
	* @name: Signal name
	* @description: Signal description
	* 
	* fixme
	*/
	void ::signal_received (const gchar* name, const gchar* description);	

	/**
	* IAnjutaDebugger::debugger_ready:
	* @obj: Self
	* @status: fixme
	* 
	* fixme
	*/
	void ::debugger_ready (State state);

	
	/**
	* ianjuta_debugger_get_state:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	State get_state ();	


	

	/**
	* ianjuta_debugger_load:
	* @obj: Self
	* @file: fixme
	* @mime_type: fixme
	* @source_search_directories: fixme
	* @terminal: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: TRUE if sucessful, other FALSE.
	*/
	gboolean load (const gchar *file, const gchar *mime_type, const List<const gchar*> source_search_directories);
	
	/**
	* ianjuta_debugger_attach:
	* @obj: Self
	* @pid: fixme
	* @source_search_directories: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: TRUE if sucessful, other FALSE.
	*/
	gboolean attach (pid_t pid, const List<const gchar*> source_search_directories);
	
	/**
	* ianjuta_debugger_start:
	* @obj: Self
	* @args: command line argument of the program
	* @terminal: TRUE if the program need a terminal
	* @stop: TRUE if program is stopped at the beginning
	* @err: Error propagation and reporting.
	* 
	* Start a loaded program under debugger control.
	*
	* Returns: TRUE if sucessful, other FALSE.
	*/
	gboolean start (const gchar *args, gboolean terminal, gboolean stop);
	
	/**
	* ianjuta_debugger_unload:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean unload ();
	
	/**
	* ianjuta_debugger_quit:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* Quit the debugger, can wait until the debugger is ready.
	*
	* Returns: TRUE if sucessful, other FALSE.
	*/
	gboolean quit ();

	/**
	* ianjuta_debugger_abort:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* Quit the debugger as fast as possible.
	*
	* Returns: TRUE if sucessful, other FALSE.
	*/
	gboolean abort ();
	
	/**
	* ianjuta_debugger_run:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean run ();
	
	/**
	* ianjuta_debugger_step_in:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean step_in ();
	
	/**
	* ianjuta_debugger_step_over:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean step_over ();
	
	/**
	* ianjuta_debugger_step_out:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean step_out ();
	
	/**
	* ianjuta_debugger_run_to:
	* @obj: Self
	* @uri: fixme
	* @line: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean run_to (const gchar *uri, gint line);
	
	/**
	* ianjuta_debugger_exit:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean exit ();
	
	/**
	* ianjuta_debugger_interrupt:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean interrupt ();

	
	
	/**
	* ianjuta_debugger_inspect:
	* @obj: Self
	* @name: fixme
	* @callback: fixme
	* @user_data: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean inspect (const gchar* name, Callback callback, gpointer user_data);
	
	/**
	* ianjuta_debugger_evaluate:
	* @obj: Self
	* @name: fixme
	* @value: fixme
	* @callback: fixme
	* @user_data: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean evaluate (const gchar* name, const gchar* value, Callback callback, gpointer user_data);
	
	/**
	* ianjuta_debugger_print:
	* @obj: Self
	* @variable: fixme
	* @callback: fixme
	* @user_data: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean print (const gchar *variable, Callback callback, gpointer user_data);
	
	/**
	* ianjuta_debugger_list_local:
	* @obj: Self
	* @callback: fixme
	* @user_data: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean list_local (Callback callback, gpointer user_data);

	/**
	* ianjuta_debugger_list_argument:
	* @obj: Self
	* @callback: fixme
	* @user_data: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean list_argument (Callback callback, gpointer user_data);
	
	/**
	* ianjuta_debugger_info_signal:
	* @obj: Self
	* @callback: fixme
	* @user_data: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean info_signal (Callback callback, gpointer user_data);
	
	/**
	* ianjuta_debugger_info_sharedlib:
	* @obj: Self
	* @callback: fixme
	* @user_data: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean info_sharedlib (Callback callback, gpointer user_data);
	
	/**
	* ianjuta_debugger_handle_signal:
	* @obj: Self
	* @name: fixme
	* @stop: fixme
	* @print: fixme
	* @ignore: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean handle_signal (const gchar *name, gboolean stop, gboolean print, gboolean ignore);
	
	/**
	* ianjuta_debugger_info_frame:
	* @obj: Self
	* @frame: fixme
	* @callback: fixme
	* @user_data: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean info_frame (guint frame, Callback callback, gpointer user_data);
	
	/**
	* ianjuta_debugger_info_args:
	* @obj: Self
	* @callback: fixme
	* @user_data: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean info_args (Callback callback, gpointer user_data);
	
	/**
	* ianjuta_debugger_info_target:
	* @obj: Self
	* @funx: fixme
	* @user_data: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean info_target (Callback callback, gpointer user_data);
	
	/**
	* ianjuta_debugger_info_program:
	* @obj: Self
	* @callback: fixme
	* @user_data: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean info_program (Callback callback, gpointer user_data);
	
	/**
	* ianjuta_debugger_info_udot:
	* @obj: Self
	* @callback: fixme
	* @user_data: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean info_udot (Callback callback, gpointer user_data);
	
	
	/**
	* ianjuta_debugger_info_variables:
	* @obj: Self
	* @callback: fixme
	* @user_data: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean info_variables (Callback callback, gpointer user_data);
	
	/**
	* ianjuta_debugger_list_frame:
	* @obj: Self
	* @callback: fixme
	* @user_data: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean list_frame (Callback callback, gpointer user_data);
	
	/**
	* ianjuta_debugger_set_frame:
	* @obj: Self
	* @frame: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean set_frame (guint frame);

	/**
	* ianjuta_debugger_list_thread:
	* @obj: Self
	* @callback: fixme
	* @user_data: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean list_thread (Callback callback, gpointer user_data);
	
	/**
	* ianjuta_debugger_set_thread:
	* @obj: Self
	* @frame: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean set_thread (gint thread);

	/**
	* ianjuta_debugger_info_threads:
	* @obj: Self
	* @thread: fixme
	* @callback: fixme
	* @user_data: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean info_thread (gint thread, Callback callback, gpointer user_data);

	/**
	* ianjuta_debugger_list_register:
	* @obj: Self
	* @callback: fixme
	* @user_data: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean list_register (Callback callback, gpointer user_data);

	/**
	* ianjuta_debugger_send_command:
	* @obj: Self
	* @command: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean send_command (const gchar *command);

	/**
	* ianjuta_debugger_callback:
	* @obj: Self
	* @callback: fixme
	* @user_data: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	gboolean callback (Callback callback, gpointer user_data);

	/**
	* ianjuta_debugger_enable_log:
	* @obj: Self
	* @log: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	void enable_log (IAnjutaMessageView *log);

	/**
	* ianjuta_debugger_disable_log:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* fixme
	*
	* Returns: fixme
	*/
	void disable_log ();

	/**
	 * SECTION:ianjuta-debugger-breakpoint
	 * @title: IAnjutaDebuggerBreakpoint
	 * @short_description: Breakpoint Debugger interface
	 * @see_also: 
	 * @stability: Unstable
	 * @include: libanjuta/interfaces/ianjuta-debugger-breakpoint.h
	 * 
	 */
	interface IAnjutaDebuggerBreakpoint
	{	
		
		enum Type
		{
			REMOVED = 1 << 0,
			UPDATED = 1 << 17,
			ON_LINE = 1 << 1,
			ON_ADDRESS = 1 << 2,
			ON_FUNCTION = 1 << 3,
			ON_READ = 1 << 4,
			ON_WRITE = 1 << 5,
			WITH_ENABLE = 1 << 16,
			WITH_IGNORE = 1 << 15,
			WITH_TIME = 1 << 11,
			WITH_CONDITION = 1 << 12,
			WITH_TEMPORARY = 1 << 13
		}

		struct Item
		{
			gint type;
			guint id;
			gchar *file;
			guint line;
			gchar *function;
			gulong address;
			gboolean enable;
			guint ignore;
			guint times;
			gchar *condition;
			gboolean temporary;
		}

		enum Method
		{
			SET_AT_ADDRESS = 1 << 0,
			SET_AT_FUNCTION = 1 << 1,
			ENABLE = 1 << 2,
			IGNORE = 1 << 3,
			CONDITION = 1 << 4
		}

		/**
		* ianjuta_debugger_breakpoint_implement:
		* @obj: Self
		* @err: Error propagation and reporting.
		* 
		* Return all implemented methods.
		*
		* Returns: A OR of IAnjutaDebuggerBreakpointMethod
		* corresponding to all implemented optional methods.
		*/
		gint implement ();
		
		/**
		* ianjuta_debugger_breakpoint_set_at_line:
		* @obj: Self
		* @file: File containing the breakpoint
		* @line: Line number where is the breakpoint
		* @callback: Callback to call when the breakpoint has been set
		* @user_data: User data that is passed back to the callback
		* @err: Error propagation and reporting.
		* 
		* Set a breakpoint at the specified line in the file.
		*
		* Returns: TRUE if the request succeed and the callback is called. If 
		* FALSE, the callback will not be called.
		*/
		gboolean set_at_line (const gchar* file, guint line, IAnjutaDebuggerCallback callback, gpointer user_data);

	
		/**
		* ianjuta_debugger_breakpoint_set_at_address:
		* @obj: Self
		* @address: Address of the breakpoint
		* @callback: Callback to call when the breakpoint has been set
		* @user_date: User data that is passed back to the callback
		* @err: Error propagation and reporting.
		* 
		* Set a breakpoint at the specified address.
		* This function is optional.
		*
		* Returns: TRUE if the request succeed and the callback is called. If 
		* FALSE, the callback will not be called.
		*/
		gboolean set_at_address (gulong address, IAnjutaDebuggerCallback callback, gpointer user_data);
	
		/**
		* ianjuta_debugger_breakpoint_set_at_function:
		* @obj: Self
		* @file: File containing the breakpoint
		* @function: Function name where the breakpoint is put
		* @callback: Callback to call when the breakpoint has been set
		* @user_data: User data that is passed back to the callback
		* @err: Error propagation and reporting.
		* 
		* Set a breakpoint at the beginning of the specified function. 
		* This function is optional.
		*
		* Returns: TRUE if the request succeed and the callback is called. If 
		* FALSE, the callback will not be called.
		*/
		gboolean set_at_function (const gchar* file, const gchar* function, IAnjutaDebuggerCallback callback, gpointer user_data);
	
		/**
		* ianjuta_debugger_breakpoint_clear:
		* @obj: Self
		* @id: Breakpoint identification number
		* @callback: Callback to call when the breakpoint has been cleared
		* @user_data: User data that is passed back to the callback
		* @err: Error propagation and reporting.
		* 
		* Clear a breakpoint put by any set functions. The Id of the breakpoint
		* is given in the callback of the set functions.
		*
		* Returns: TRUE if the request succeed and the callback is called. If 
		* FALSE, the callback will not be called.
		*/
		gboolean clear (guint id, IAnjutaDebuggerCallback callback, gpointer user_data);

		/**
		* ianjuta_debugger_breakpoint_list:
		* @obj: Self
		* @callback: Callback to call with the list of breakpoints
		* @user_data: User data that is passed back to the callback
		* @err: Error propagation and reporting.
		* 
		* List all breakpoints set in the debugger. It is useful to
		* know how many time a breakpoint has been hit.
		*
		* Returns: TRUE if the request succeed and the callback is called. If 
		* FALSE, the callback will not be called.
		*/
		gboolean list (IAnjutaDebuggerCallback callback, gpointer user_data);

		/**
		* ianjuta_debugger_breakpoint_enable:
		* @obj: Self
		* @id: Breakpoint identification number
		* @enable: TRUE to enable the breakpoint, FALSE to disable it
		* @callback: Callback to call when the breakpoint has been changed
		* @user_data: User data that is passed back to the callback
		* @err: Error propagation and reporting.
		* 
		* Enable of disable a breakpoint. This function is optional.
		*
		* Returns: TRUE if the request succeed and the callback is called. If 
		* FALSE, the callback will not be called.
		*/
		gboolean enable (guint id, gboolean enable, IAnjutaDebuggerCallback callback, gpointer user_data);
	
		/**
		* ianjuta_debugger_breakpoint_ignore:
		* @obj: Self
		* @id: Breakpoint identification number
		* @ignore: Number of time a breakpoint must be ignored
		* @callback: Callback to call when the breakpoint has been changed
		* @user_data: User data that is passed back to the callback
		* @err: Error propagation and reporting.
		* 
		* This allow to ignore the breakpoint a number of time before stopping.
		* This function is optional.
		*
		* Returns: TRUE if the request succeed and the callback is called. If 
		* FALSE, the callback will not be called.
		*/
		gboolean ignore (guint id, guint ignore, IAnjutaDebuggerCallback callback, gpointer user_data);
	
		/**
		* ianjuta_debugger_breakpoint_condition:
		* @obj: Self
		* @id: Breakpoint identification number
		* @condition: fixme
		* @callback: Callback to call when the breakpoint has been changed
		* @user_data: User data that is passed back to the callback
		* @err: Error propagation and reporting.
		* 
		* Add a condition, evaluate in the program context, on the breakpoint,
		* the program will stop when it reachs the breakpoint only if the
		* condition is true. This function is optional.
		*
		* Returns: TRUE if the request succeed and the callback is called. If 
		* FALSE, the callback will not be called.
		*/
		gboolean condition (guint id, const gchar* condition, IAnjutaDebuggerCallback callback, gpointer user_data);
	}

	/**
	* SECTION:ianjuta-debugger-variable
	* @title: IAnjutaDebuggerVariable
	* @short_description: Variables interface for debuggers
	* @see_also: 
	* @stability: Unstable
	* @include: libanjuta/interfaces/ianjuta-debugger-variable.h
	* 
 	* This interface is used to examine and change values of expression.
	* It is based on the MI2 variable object interface of gdb. A
	* variable needs to be created before being able to get or set its
	* value and list its children. 
	*/
	interface IAnjutaDebuggerVariable
	{
		struct Object
		{
			gchar *name;
			gchar *expression;
			gchar *type;
			gchar *value;
			gboolean changed;
			gboolean exited;
			gboolean deleted;
			gint children;
		}

		/**
		* ianjuta_debugger_variable_create:
		* @obj: Self
		* @expression: Variable expression
		* @callback: Callback to call when the variable has been created
		* @user_data: User data that is passed back to the callback
		* @err: Error propagation and reporting.
		* 
		* Create a new variable object in the current thread and frame.
		*
		* Returns: TRUE if the request succeed and the callback is
		* called. If FALSE, the callback will not be called.
		*/
		gboolean create (const gchar *expression, IAnjutaDebuggerCallback callback, gpointer user_data);

		/**
		* ianjuta_debugger_variable_list_children:
		* @obj: Self
		* @name: Variable name
		* @callback: Callback to call when the children have been
		* created
		* @user_data: User data that is passed back to the callback
	 	* @err: Error propagation and reporting.
		* 
		* List and create objects for all children of a
		* variable object.
		*
		* Returns: TRUE if the request succeed and the callback is
		* called. If FALSE, the callback will not be called.
		*/
		gboolean list_children (const gchar *name, IAnjutaDebuggerCallback callback, gpointer user_data);

		/**
		* ianjuta_debugger_variable_evaluate:
		* @obj: Self
		* @name: Variable name
		* @callback: Callback to call with the variable value
		* @user_data: User data that is passed back to the callback
		* @err: Error propagation and reporting.
		*
		* Get the value of one variable or child object.
		*
		* Returns: TRUE if the request succeed and the callback is
		* called. If FALSE, the callback will not be called.
		*/
		gboolean evaluate (const gchar *name, IAnjutaDebuggerCallback callback, gpointer user_data);

		/**
		* ianjuta_debugger_variable_assign:
		* @obj: Self
		* @name: Variable name
		* @value: Variable value
		* @err: Error propagation and reporting.
		* 
		* Set the value of one variable or child object.
		*
		* Returns: TRUE if the request succeed and the callback is
		* called. If FALSE, the callback will not be called.
		*/
		gboolean assign (const gchar *name, const gchar *value);

		/**
		* ianjuta_debugger_variable_update:
		* @obj: Self
		* @callback: Callback to call with the list of all changed
		* variables
		* @user_data: User data that is passed back to the callback
		* @err: Error propagation and reporting.
		* 
		* List all changed variable objects since the last call.
		*
		* Returns: TRUE if the request succeed and the callback is
		* called. If FALSE, the callback will not be called.
		*/
		gboolean update (IAnjutaDebuggerCallback callback, gpointer user_data);

		/**
		* ianjuta_debugger_variable_destroy:
		* @obj: Self
		* @name: Variable name
		* @err: Error propagation and reporting.
		* 
		* Delete a previously created variable or child object 
		* including its own children.
		*
		* Returns: TRUE if the request succeed and the callback is
		* called. If FALSE, the callback will not be called.
		*/
		gboolean destroy (const gchar *name);
	}
	
	/**
	* SECTION:ianjuta-debugger-register
	* @title: IAnjutaDebuggerRegister
	* @short_description: Register interface for debuggers
	* @see_also: 
	* @stability: Unstable
	* @include: libanjuta/interfaces/ianjuta-debugger-register.h
	* 
 	* This interface is used to examine and change values of CPU registers.
	*/
	interface IAnjutaDebuggerRegister
	{

		struct Data
		{
			guint num;
			gchar *name;
			gchar *value;
		}

		/**
		* ianjuta_debugger_register_list:
		* @obj: Self
		* @callback: Callback to call with the register list
		* @user_data: User data that is passed back to the callback
		* @err: Error propagation and reporting.
		* 
		* List all registers of the target. This function can be called without
		* a program loaded, the value field of register structure is not filled.
		*
		* Returns: TRUE if the request succeed and the callback is
		* called. If FALSE, the callback will not be called.
		*/
		gboolean list (IAnjutaDebuggerCallback callback, gpointer user_data);

		/**
		* ianjuta_debugger_register_update:
		* @obj: Self
		* @callback: Callback call with the list of all modified registers
		* @user_data: User data that is passed back to the callback
		* @err: Error propagation and reporting.
		* 
		* Return all modified registers since the last call. Only the num and
		* value field are used.
		*
		* Returns: TRUE if the request succeed and the callback is
		* called. If FALSE, the callback will not be called.
		*/
		gboolean update (IAnjutaDebuggerCallback callback, gpointer user_data);

		/**
		* ianjuta_debugger_register_write:
		* @obj: Self
		* @value: Modified register with a new value
		* @err: Error propagation and reporting.
		* 
		* Change the value of one register. Only the num and value field are used.
		*
		* Returns: TRUE if the request succeed.
		*/
		gboolean write (Data *value);
	}
	
	/**
	* SECTION:ianjuta-debugger-memory
	* @title: IAnjutaDebuggerMemory
	* @short_description: Memory interface for debuggers
	* @see_also: 
	* @stability: Unstable
	* @include: libanjuta/interfaces/ianjuta-debugger-memory.h
	* 
 	* This interface is used to examine the target memory.
	*/
	interface IAnjutaDebuggerMemory
	{
		struct Block
		{
			gulong address;
			guint length;
			gchar *data;
		}

		/**
		* ianjuta_debugger_memory_inspect:
		* @obj: Self
		* @address: Start address of the memory block
		* @length: Length of memory block
		* @callback: Call back with a IAnjutaDebuggerMemoryBlock as argument
		* @user_data: User data that is passed back to the callback
		* @err: Error propagation and reporting.
		* 
		* Read a block of the target memory.
		*
		* Returns: TRUE if the request succeed and the callback is
		* called. If FALSE, the callback will not be called.
		*/
		gboolean inspect (gulong address, guint length, IAnjutaDebuggerCallback callback, gpointer user_data);
	}

	/**
	* SECTION:ianjuta-debugger-instruction
	* @title: IAnjutaDebuggerInstruction
	* @short_description: Debugger interface for machine instruction
	* @see_also: 
	* @stability: Unstable
	* @include: libanjuta/interfaces/ianjuta-debugger-instruction.h
	* 
 	* This interface is used to debuger as machine instruction level.
	*/
	interface IAnjutaDebuggerInstruction
	{
	
		struct ALine
		{
			gulong address;
			const gchar *label;
			const gchar *text;
		}

		struct Disassembly
		{
			guint size;
			ALine data[];	
		}	

		/**
		* ianjuta_debugger_instruction_disassemble:
		* @obj: Self
		* @address: Start address of the memory block
		* @length: Length of memory block
		* @callback: Call back with a IAnjutaDebuggerInstructionDisassembly as argument
		* @user_data: User data that is passed back to the callback
		* @err: Error propagation and reporting.
		* 
		* Disassemble a part of the memory
		*
		* Returns: TRUE if the request succeed and the callback is
		* called. If FALSE, the callback will not be called.
		*/
		gboolean disassemble (gulong address, guint length, IAnjutaDebuggerCallback callback, gpointer user_data);

		/**
		* ianjuta_debugger_instruction_step_in:
		* @obj: Self
		* @err: Error propagation and reporting.
		* 
		* Execute one assembler instruction in the program.
		*
		* Returns: TRUE if the request succeed and the callback is called. If 
		* FALSE, the callback will not be called.
		*/
		gboolean step_in ();
	
		/**
		* ianjuta_debugger_instruction_step_over:
		* @obj: Self
		* @err: Error propagation and reporting.
		* 
		* Execute one assembler instruction in the program, if the instruction
		* is a function call, continues until the function returns.
		*
		* Returns: TRUE if the request succeed and the callback is called. If 
		* FALSE, the callback will not be called.
		*/
		gboolean step_over ();
	
		/**
		* ianjuta_debugger_instruction_run_to_address:
		* @obj: Self
		* @address: Run to this addresss
		* @err: Error propagation and reporting.
		* 
		* Start the program until it reachs the address address
		*
		* Returns: TRUE if the request succeed and the callback is called. If 
		* FALSE, the callback will not be called.
		*/
		gboolean run_to_address (gulong address);
	}
		
}

/**
* SECTION:ianjuta-debug-manager
* @title: IAnjutaDebugManager
* @short_description: Common graphical interface to all debugger
* @see_also: 
* @stability: Unstable
* @include: libanjuta/interfaces/ianjuta-debug-manager.h
* 
* This interface wrap the real debugger plugin and provide a 
* common graphical user interface.
*/

interface IAnjutaDebugManager
{
	#include "ianjuta-debugger.h"
	#include "ianjuta-debugger-breakpoint.h"

	/* Signals */

	/**
	* IAnjutaDebugManager::debugger_started:
	* @obj: Self
	* 
	* This signal is emitted when the debugger is started.
	*/
	void ::debugger_started ();

	/**
	* IAnjutaDebugManager::debugger_stopped:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* This signal is emitted when the debugger is stopped.
	*/
	void ::debugger_stopped (GError *err);

	/**
	* IAnjutaDebugManager::program_loaded:
	* @obj: Self
	* 
	* This signal is emitted when a program is loaded most of the
	* time just before the first program_stopped signal.
	*/
	void ::program_loaded ();

	/**
	* IAnjutaDebugManager::program_unloaded:
	* @obj: Self
	* 
	* This signal is emitted when a program is unloaded. If the
	* debugger is stopped while a program is loaded, this signal
	* is emitted before the debugger_stopped signal.
	*/
	void ::program_unloaded ();

	/**
	* IAnjutaDebugManager::program_started:
	* @obj: Self
	* 
	* This signal is emitted when the program is started. If the
	* program starts and is stopped by the debugger, a program-stopped
	* signal will be emitted too. If the program starts is not stopped
	* by the debugger a program-running signal will be emitted.
	*/
	void ::program_started ();

	/**
	* IAnjutaDebugManager::program_exited:
	* @obj: Self
	* 
	* This signal is emitted when the program is unloaded. If the
	* debugger is stopped while a program is running or stopped, this
	* signal is emitted before the program_unloaded signal.
	*/
	void ::program_exited ();

	/**
	* IAnjutaDebugManager::program_stopped:
	* @obj: Self
	* 
	* This signal is emitted when the program is stopped.
	*/
	void ::program_stopped ();	

	/**
	* IAnjutaDebugManager::program_running:
	* @obj: Self
	* 
	* This signal is emitted when the program is running.
	*/
	void ::program_running ();


	/**
	* IAnjutaDebugManager::sharedlib_event:
	* @obj: Self
	* 
	* This signal is emitted when a new shared library is loaded. It
	* is useful to try to set pending breakpoints those could be in
	* the newly loaded library.
	*/
	void ::sharedlib_event ();

	/**
	* IAnjutaDebugManager::program_moved:
	* @obj: Self
 	* @pid: process id, 0 when unknown
	* @tid: thread id, 0 when unknown
	* @address: program counter address, 0 when unknown
	* @file: source file where is the program counter, NULL when unknown
	* @line: line number if file name above is not NULL
	* 
	* This signal is emitted when the debugger know the current program 
	* location. Most of the time, after the program has stopped but it
	* could happen even if it is still running.
	*/
	void ::program_moved (gint pid, gint tid, gulong address, const gchar* file, guint line);

	/**
	* IAnjutaDebugManager::frame_changed:
	* @obj: Self
	* @frame: frame
	* @thread: thread
	* 
	* This signal is emitted when the current frame is changed. It is
	* equal to the top frame in the interrupted thread when the
	* program stops but can be changed afterward by the user.
	* Several commands use this current frame, by example the register
	* window display the register values for the current thread only.
	*/
	void ::frame_changed (guint frame, gint thread);	

	/**
	* IAnjutaDebugManager::location_changed:
	* @obj: Self
	* @address: program counter address, 0 when unknown
	* @uri: source file where is the program counter, NULL when unknown
	* @line: line number if file name above is not NULL
	* 
	* This signal is emitted when the current location is changed. It is
	* equal to the program location when the program stops but can be
	* changed afterward by the user.
	*/
	void ::location_changed (gulong address, const gchar* uri, guint line);	

	/**
	* IAnjutaDebugManager::signal_received:
	* @obj: Self
	* @name: Signal name
	* @description: Signal description
	* 
	* This signal is emitted when the debugged program receives a
	* unix signal.
	*/
	void ::signal_received (const gchar* name, const gchar* description);	

	/**
	* IAnjutaDebugManager::breakpoint_changed:
	* @obj: Self
	* @breakpoint: Breakpoint
	* @err: Error propagation and reporting.
	* 
	* This signal is emitted when a breakpoint is changed. It includes
	* new breakpoint and deleted breakpoint.
	*/
	void ::breakpoint_changed (IAnjutaDebuggerBreakpointItem *breakpoint);
}

/**
 * SECTION:ianjuta-vcs
 * @title: IAnjutaVcs
 * @short_description: Version control system interface
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-vcs.h
 * 
 */
interface IAnjutaVcs
{
	/**
	 * ianjuta_vcs_add:
	 * @filename: String with the filename
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Add filename to the cvs repositry.
	 */
	void add(const gchar* filename);
	
	/**
	 * ianjuta_cvs_remove:
	 * @filename: String with the filename
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Remove filename to the cvs repositry. Note that the file
	 * is not removed physicly. This function will fail if the file
	 * still exists on disc.
	 */
	void remove(const gchar* filename);
	
	/**
	 * ianjuta_vcs_update:
	 * @filename: String with the filename
	 * @recurse: TRUE to recurse into subdirectories
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Update filename with the cvs repositry.
	 */
	void update(const gchar* filename, gboolean recurse);
	
	/**
	 * ianjuta_vcs_commit:
	 * @filename: String with the filename
	 * @log: The log message for the commit or ""
	 * @recurse: TRUE to recurse into subdirectories
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Commit changes in filename to the cvs repositry.
	 */
	void commit(const gchar* filename, const gchar* log, gboolean recurse);	
}

/**
 * SECTION:ianjuta-macro
 * @title: IAnjutaMacro
 * @short_description: Macro processor interface
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-macro.h
 * 
 */
interface IAnjutaMacro
{
	/**
	 * ianjuta_macro_insert:
	 * @key: Key of the macro
	 * @obj: Self
	 * @err: Error propagation and reporting
	 *
	 * Insert Macro to editor
	 */
	void insert(const gchar* key);
}

/**
 * SECTION:ianjuta-symbol
 * @title: IAnjutaSymbol
 * @short_description: Source code symbol interface
 * @see_also: #IAnjutaSymbolManager
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-symbol.h
 * 
 */
interface IAnjutaSymbol
{
	#include <gdk/gdkpixbuf.h>
	
	enum Type
	{
		TYPE_UNDEF = 0,                // Unknown type
		TYPE_CLASS = 1,                // Class declaration
		TYPE_ENUM = 2,                 // Enum declaration
		TYPE_ENUMERATOR = 4,           // Enumerator value
		TYPE_FIELD = 8,                // Field (Java only)
		TYPE_FUNCTION = 16,            // Function definition
		TYPE_INTERFACE = 32,           // Interface (Java only)
		TYPE_MEMBER = 64,              // Member variable of class/struct
		TYPE_METHOD = 128,             // Class method (Java only)
		TYPE_NAMESPACE = 256,          // Namespace declaration
		TYPE_PACKAGE = 512,            // Package (Java only)
		TYPE_PROTOTYPE = 1024,         // Function prototype
		TYPE_STRUCT = 2048,            // Struct declaration
		TYPE_TYPEDEF = 4096,           // Typedef
		TYPE_UNION = 8192,             // Union
		TYPE_VARIABLE = 16384,         // Variable
		TYPE_EXTERNVAR = 32768,        // Extern or forward declaration
		TYPE_MACRO = 65536,            //  Macro (without arguments)
		TYPE_MACRO_WITH_ARG = 131072,  // Parameterized macro
		TYPE_FILE = 262144,            // File (Pseudo tag)
		TYPE_OTHER = 524288,           // Other (non C/C++/Java tag)
		TYPE_MAX = 1048575             // Maximum value
	}

	// Field masks -- used mainly for search
	enum Field
	{
		FIELD_NONE = 0,                 // Undefined
		FIELD_NAME = 1,                 // Name field
		FIELD_TYPE = 2,                 // Type field
		FIELD_FILE = 4,                 // File field
		FIELD_LINE = 8,                 // Line number field
		FIELD_POSITION = 16,            // Byte pos of symbol (Obsolete)
		FIELD_SCOPE = 32,               // Scope of the symbol field
		FIELD_INHERITANCE = 64,         // Parent classes
		FIELD_ARGUMENTS = 128,          // Argument list
		FIELD_LOCAL = 256,              // If it has local scope
		FIELD_TIME = 512,               // Modification time (File symbol only)
		FIELD_VARTYPE = 1024,           // Variable Type
		FIELD_ACCESS = 2048,            // Access type
		FIELD_IMPLEMENTATION = 4096,    // Implementation (e.g. virtual)
		FIELD_LANGUAGE = 8192,          // Language (File symbols only)
		FIELD_INACTIVE = 16384,         // Inactive file (File symbols only)
		FIELD_POINTER = 32768,          // Inactive file (File symbols only)
		FIELD_MAX = 65535               // Maximum value
	}
	
	// Methods
	Type type ();                // Symbol type [int value]
	const gchar *type_str ();	 // Symbol type [const char* value]
	const gchar *type_name ();	 // Symbol type name. e.g. a member which name is 
								 // 'my_foo_member'.
	const gchar *name ();        // Symbol name
	const gchar *args ();        // Args list (functions/prototypes/macros)
	const gchar *scope ();       // Scope of symbol
	const gchar *inheritance (); // Parent classes
	const gchar *var_type ();    // Variable type (maps to struct for typedefs)
	const gchar *access ();      // Access type (public/protected/private/etc.)
	const gchar *impl ();        // Implementation (e.g. virtual)
	const gchar *uri ();   	     // URI in which the symbol occurs
	gulong line ();              // Line number of the symbol
	gboolean is_local ();        // Is the symbol of local scope
	
	const GdkPixbuf *icon ();          // Pixbuf icon representing the symbol
}

/**
 * SECTION:ianjuta-symbol-manager
 * @title: IAnjutaSymbolManager
 * @short_description: Source code symbols manager inteface
 * @see_also: #IAnjutaSymbol
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-symbol-manager.h
 * 
 */
interface IAnjutaSymbolManager
{
	#include "ianjuta-iterable.h"
	#include "ianjuta-symbol.h"

	/**
	* ianjuta_symbol_manager_search:
	* @obj: Self
	* @match_types: fixme
	* @match_name: fixme
	* @partial_name_match: fixme
	* @global_search: fixme
	* @err: Error propagation and reporting.
	* 
	* Database query. Returned iterable must be unrefed after use.
	* 
	* Returns: fixme
	*/
	IAnjutaIterable* search (IAnjutaSymbolType match_types, const gchar *match_name, gboolean partial_name_match, gboolean global_search);
	
	/**
	* ianjuta_symbol_manager_get_members:
	* @obj: Self
	* @symbol_name: fixme
	* @global_search: fixme
	* @err: Error propagation and reporting.
	* 
	* Database query. Returned iterable must be unrefed after use.
	* 
	* Returns: fixme
	*/
	IAnjutaIterable* get_members (const gchar *symbol_name, gboolean global_search);
	
	/**
	* ianjuta_symbol_manager_get_parents:
	* @obj: Self
	* @symbol_name: fixme
	* @err: Error propagation and reporting.
	* 
	* fixme
	* 
	* Returns: fixme
	*/
	IAnjutaIterable* get_parents (const gchar *symbol_name);
}

/**
 * SECTION:ianjuta-print
 * @title: IAnjutaPrint
 * @short_description: Print interface
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-print.h
 * 
 */
interface IAnjutaPrint
{
	/**
	* ianjuta_print_print:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* Print the plugin (the file in case of the editor). In most cases this will show
	* a print dialog
	*/
	void print();
	
	/**
	* ianjuta_print_print:
	* @obj: Self
	* @err: Error propagation and reporting.
	* 
	* Show print preview dialog
	*/

	void print_preview();
}

/**
 * SECTION:ianjuta-language-support
 * @title: IAnjutaLanguageSupport
 * @short_description: Programming language specific supports from plugins
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-language-support.h
 * 
 */
interface IAnjutaLanguageSupport
{
    List<const gchar*> get_supported_languages ();
    gboolean supports(const gchar *language);
}

/**
 * SECTION:ianjuta-preferences
 * @title: IAnjutaPreferences
 * @short_description: Preferences interface
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-preferences
 * 
 */
interface IAnjutaPreferences
{
	#include <libanjuta/anjuta-preferences.h>
	/**
	 * ianjuta_preferences_merge:
	 * @obj: Self
	 * @prefs: AnjutaPreferences to install to
	 * @err: Error propagation and reporting.
	 * 
	 * When called, the plugin should install it's preferences
	 */
	void merge(AnjutaPreferences* prefs);
	
	/**
	 * ianjuta_preferences_unmerge:
	 * @obj: Self
	 * @prefs: AnjutaPreferences to install to
	 * @err: Error propagation and reporting.
	 * 
	 * When called, the plugin should uninstall it's preferences
	 */
	void unmerge(AnjutaPreferences* prefs);
}

/**
 * SECTION:ianjuta-plugin-factory
 * @title: IAnjutaPluginFactory
 * @short_description: Create Anjuta plugin objects
 * @see_also:
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-plugin-factory.h
 * 
 * This interface is used to create all Anjuta plugin objects. It is
 * already implemented inside Anjuta by an object able to load plugins written
 * in C. In order to load plugins in other languages (or in a different way),
 * a loader plugin implementing this interface must be written first, probably
 * in C.
 */

interface IAnjutaPluginFactory
{
	#include <libanjuta/anjuta-plugin.h>
	#include <libanjuta/anjuta-shell.h>
	#include <libanjuta/anjuta-plugin-handle.h>

	/**
	 * IAnjutaPluginFactoryError:
	 * @IANJUTA_PLUGIN_FACTORY_MISSING_LOCATION: Module file location is
	 *	missing in .plugin file
	 * @IANJUTA_PLUGIN_FACTORY_MISSING_TYPE: Plugin type (just after
	 *	double colon following location) is missing in .plugin file
	 * @IANJUTA_PLUGIN_FACTORY_MISSING_MODULE: Module file name not found,
	 *	plugin module is probably not installed
	 * @IANJUTA_PLUGIN_FACTORY_UNLOADABLE_MODULE: Module file cannot be
	 *	loaded, not a shared library perhaps
	 * @IANJUTA_PLUGIN_FACTORY_MISSING_FUNCTION: Module does not contain
	 *	registration function, library is not an anjuta plugin or
	 *	is not for the right version
	 * @IANJUTA_PLUGIN_FACTORY_INVALID_TYPE: Module has not registered
	 * 	plugin type, library is not an anjuta plugin or not for
	 *	the right version
	 * @IANJUTA_PLUGIN_FACTORY_UNKNOWN_ERROR: Another error
 	 *
 	 * These enumeration is used to specify errors.
	 */
	enum Error
	{
		OK = 0,
		MISSING_LOCATION,
		MISSING_TYPE,
		MISSING_MODULE,
		INVALID_MODULE,
		MISSING_FUNCTION,
		INVALID_TYPE,
		UNKNOWN_ERROR,
	}

	/**
	 * ianjuta_plugin_factory_new_plugin:
	 * @obj: Self
	 * @handle: Plugin information
	 * @shell: Anjuta shell
	 * @err: Error propagation and reporting.
	 * 
	 * Create a new AnjutaPlugin object from the plugin information handle,
	 * give it the AnjutaShell object as argument.
	 *
	 * Return value: a new plugin object
	 */
	AnjutaPlugin* new_plugin (AnjutaPluginHandle* handle, AnjutaShell *shell);
}

/**
 * SECTION:ianjuta-language
 * @title: IAnjutaLanguage
 * @short_description: Interface to manager multiple programming languages
 * @see_also: 
 * @stability: Unstable
 * @include: libanjuta/interfaces/ianjuta-language.h
 * 
 */

interface IAnjutaLanguage
{
  #include <libanjuta/interfaces/ianjuta-editor-language.h>
typedef gint Id;

	/*
	 * ianjuta_language_from_mime_type:
	 * @obj: Self
	 * @mime_type: A mime type to get the language for
	 *
	 * Returns: A language Id or 0 in case no language was found
	 */
	 Id get_from_mime_type (const gchar* mime_type);
	 
	/*
	 * ianjuta_language_from_string:
	 * @obj: Self
	 * @string: A string representation of the language. Note that multiple
	 * strings may describe the language like C++ and Cpp
	 *
	 * Returns: A language Id or 0 in case no language was found
	 */
	 Id get_from_string (const gchar* string);
	 
 	/*
	 * ianjuta_language_get_name:
	 * @obj: Self
	 * @id: A valid language id
	 *
	 * Returns: The main name of the language. When you call ianjuta_language_from_string()
	 * before that method the string you get here might be different to the one you passed 
	 * because the language might have multiple string representations
	 */
	 const gchar* get_name(Id id);

	/*
	 * ianjuta_language_get_strings
	 * @obj: Self
	 * @id: A valid language id
	 *
	 * Returns: A list of strings that represent this language that language
	 */
	 List<const gchar*> get_strings(Id id);
	 
	 /*
	  * ianjuta_language_get_from_editor:
	  * @obj: Self
	  * @editor: An object implementing IAnjutaEditorLanguage
	  * @err: Error propagation
	  *
	  * Conviniece method to get the id directly from the editor
	  *
	  * Returns: A valid language id or 0
	  */
	  
	  IAnjutaLanguageId get_from_editor (IAnjutaEditorLanguage* editor);
	  
	  	 /*
	  * ianjuta_language_get_name_from_editor:
	  * @obj: Self
	  * @editor: An object implementing IAnjutaEditorLanguage
	  * @err: Error propagation
	  *
	  * Conviniece method to get the name directly from the editor
	  *
	  * Returns: A language name or NULL
	  */
	  
	  const gchar* get_name_from_editor (IAnjutaEditorLanguage* editor);
}
