GDICT_TYPE_DATABASE

#define GDICT_TYPE_DATABASE	      (gdict_database_get_type ())

GDICT_TYPE_STRATEGY

#define GDICT_TYPE_STRATEGY	      (gdict_strategy_get_type ())

GDICT_TYPE_MATCH

#define GDICT_TYPE_MATCH              (gdict_match_get_type ())

GDICT_TYPE_DEFINITION

#define GDICT_TYPE_DEFINITION         (gdict_definition_get_type ())

GdictDatabase

typedef struct _GdictDatabase GdictDatabase;

A GdictDatabase represents a database inside a dictionary source.

GdictStrategy

typedef struct _GdictStrategy GdictStrategy;

A GdictStrategy represents a matching strategy inside a dictionary source.

GdictMatch

typedef struct _GdictMatch GdictMatch;

A GdictMatch represents a single match for a word inside a dictionary source.

GdictDefinition

typedef struct _GdictDefinition GdictDefinition;

A GdictDefinition represents a single definition for a word inside a dictionary source.

GdictContext

typedef struct _GdictContext GdictContext;

The GdictClientContext struct contains private data only.

GdictContextIface

typedef struct {
  GTypeInterface base_iface;
  
  /* methods, not signals */
  gboolean (*get_databases)     (GdictContext  *context,
  			         GError       **error);
  gboolean (*get_strategies)    (GdictContext  *context,
  			         GError       **error);
  gboolean (*match_word)        (GdictContext  *context,
  			         const gchar   *database,
  			         const gchar   *strategy,
  			         const gchar   *word,
  			         GError       **error);
  gboolean (*define_word)       (GdictContext  *context,
  			         const gchar   *database,
  			         const gchar   *word,
  			         GError       **error);  
  
  /* signals */
  void (*lookup_start)     (GdictContext    *context);
  void (*lookup_end)       (GdictContext    *context);
  
  void (*database_found)   (GdictContext    *context,
  			    GdictDatabase   *database);
  void (*strategy_found)   (GdictContext    *context,
  			    GdictStrategy   *strategy);
  void (*match_found)      (GdictContext    *context,
  			    GdictMatch      *match);
  void (*definition_found) (GdictContext    *context,
  			    GdictDefinition *definition);
  
  /* fired each time there's an error; the GError is owned
   * by the context, and should never be modified or freed
   */
  void (*error)            (GdictContext    *context,
  			    const GError    *error);

  /* padding for future expansion */
  void (*_gdict_context_1) (void);
  void (*_gdict_context_2) (void);
  void (*_gdict_context_3) (void);
  void (*_gdict_context_4) (void);
} GdictContextIface;

GDICT_CONTEXT_ERROR

#define GDICT_CONTEXT_ERROR	(gdict_context_error_quark ())

enum GdictContextError

typedef enum {
  GDICT_CONTEXT_ERROR_PARSE,
  GDICT_CONTEXT_ERROR_NOT_IMPLEMENTED,
  GDICT_CONTEXT_ERROR_INVALID_DATABASE,
  GDICT_CONTEXT_ERROR_INVALID_STRATEGY,
  GDICT_CONTEXT_ERROR_INVALID_COMMAND,
  GDICT_CONTEXT_ERROR_NO_MATCH,
  GDICT_CONTEXT_ERROR_NO_DATABASES,
  GDICT_CONTEXT_ERROR_NO_STRATEGIES
} GdictContextError;

These identify the various errors that can occur while calling GdictContext functions. Implementations should use these general error codes, but might provide other errors.

gdict_context_error_quark ()

GQuark      gdict_context_error_quark       (void);

gdict_database_ref ()

GdictDatabase* gdict_database_ref           (GdictDatabase *db);

Increases the reference count of db by one.

Since 1.0

gdict_database_unref ()

void        gdict_database_unref            (GdictDatabase *db);

Decreases the reference count of db by one. If the reference count reaches zero, db is destroyed.

Since 1.0

gdict_database_get_name ()

const gchar* gdict_database_get_name        (GdictDatabase *db);

Gets the short name of the database, to be used with functions like gdict_context_match_word() or gdict_context_define_word().

Since 1.0

gdict_database_get_full_name ()

const gchar* gdict_database_get_full_name   (GdictDatabase *db);

Gets the full name of the database, suitable for display.

Since 1.0

gdict_strategy_get_type ()

GType       gdict_strategy_get_type         (void);

gdict_strategy_ref ()

GdictStrategy* gdict_strategy_ref           (GdictStrategy *strat);

Increases the reference count of strat by one.

Since 1.0

gdict_strategy_unref ()

void        gdict_strategy_unref            (GdictStrategy *strat);

Decreases the reference count of strat by one. If the reference count reaches zero, the GdictStrategy object is freed.

Since 1.0

gdict_strategy_get_name ()

const gchar* gdict_strategy_get_name        (GdictStrategy *strat);

FIXME

Since 1.0

gdict_strategy_get_description ()

const gchar* gdict_strategy_get_description (GdictStrategy *strat);

FIXME

Since 1.0

gdict_match_get_type ()

GType       gdict_match_get_type            (void);

gdict_match_ref ()

GdictMatch* gdict_match_ref                 (GdictMatch *match);

FIXME

Since 1.0

gdict_match_unref ()

void        gdict_match_unref               (GdictMatch *match);

FIXME

Since 1.0

gdict_match_get_word ()

const gchar* gdict_match_get_word           (GdictMatch *match);

FIXME

Since 1.0

gdict_match_get_database ()

const gchar* gdict_match_get_database       (GdictMatch *match);

FIXME

Since 1.0

gdict_definition_get_type ()

GType       gdict_definition_get_type       (void);

gdict_definition_ref ()

GdictDefinition* gdict_definition_ref       (GdictDefinition *def);

Increases the reference count of def by one.

Since 1.0

gdict_definition_unref ()

void        gdict_definition_unref          (GdictDefinition *def);

Decreases the reference count of def by one. If the reference count reaches zero, the GdictDefinition object is freed.

Since 1.0

gdict_definition_get_total ()

gint        gdict_definition_get_total      (GdictDefinition *def);

Retrieves the total number of definitions that were found on a dictionary.

Since 1.0

gdict_definition_get_word ()

const gchar* gdict_definition_get_word      (GdictDefinition *def);

Retrieves the word used by the dictionary database to store the definition.

Since 1.0

gdict_definition_get_database ()

const gchar* gdict_definition_get_database  (GdictDefinition *def);

Retrieves the full name of the dictionary database where the definition is stored.

Since 1.0

gdict_definition_get_text ()

const gchar* gdict_definition_get_text      (GdictDefinition *def);

Retrieves the text of the definition.

Since 1.0

gdict_context_get_type ()

GType       gdict_context_get_type          (void);

gdict_context_set_local_only ()

void        gdict_context_set_local_only    (GdictContext *context,
                                             gboolean local_only);

Sets whether only local resources will be used when querying for databases, strategies, matches or definitions.

Since 1.0

gdict_context_get_local_only ()

gboolean    gdict_context_get_local_only    (GdictContext *context);

Gets whether only local resources will be used when querying.

Since 1.0

gdict_context_lookup_databases ()

gboolean    gdict_context_lookup_databases  (GdictContext *context,
                                             GError **error);

Query context for the list of databases available. Each time a database is found, the "database-found" signal is fired.

Since 1.0

gdict_context_lookup_strategies ()

gboolean    gdict_context_lookup_strategies (GdictContext *context,
                                             GError **error);

Query context for the list of matching strategies available. Each time a new strategy is found, the "strategy-found" signal is fired.

Since 1.0

gdict_context_match_word ()

gboolean    gdict_context_match_word        (GdictContext *context,
                                             const gchar *database,
                                             const gchar *strategy,
                                             const gchar *word,
                                             GError **error);

Query context for a list of word matching word inside database, using strategy as a matching strategy. Each time a matching word is found, the "match-found" signal is fired.

Since 1.0

gdict_context_define_word ()

gboolean    gdict_context_define_word       (GdictContext *context,
                                             const gchar *database,
                                             const gchar *word,
                                             GError **error);

Query context for a list of definitions of word inside database. Each time a new definition is found, the "definition-found" signal is fired.

Since 1.0