GnuiTaggedEntryFilterFunc ()

gboolean
(*GnuiTaggedEntryFilterFunc) (GnuiTaggedEntry *self,
                              const gchar *tag,
                              gpointer user_data);

A function type for determining whether a tag can be added

It is granted that the strings passed to the filter function are always non-NULL and with a length greater than zero, therefore the filter function must not check for NULL or "".

GnuiTaggedEntryMatchFunc ()

gboolean
(*GnuiTaggedEntryMatchFunc) (const gchar *entry_tag,
                             const gchar *other_tag,
                             gpointer user_data);

A function type for determining whether two tags match

The first argument passed to the match function is always a tag already in the entry, while the second argument is what is being checked for equality.

It is granted that the strings passed to the match function are always non-NULL and with a length greater than zero, therefore the match function must not check for NULL or "".

GnuiTaggedEntrySanitizeFunc ()

gchar *
(*GnuiTaggedEntrySanitizeFunc) (GnuiTaggedEntry *self,
                                const gchar *tag,
                                gpointer user_data);

A function type for allocating the strings that are added to the tagged entry as tags based on the given input

It is granted that the strings passed to the sanitize function are always non-NULL and with a length greater than zero, therefore the sanitize function must not check for NULL or "".

If tag must not be inserted this function must return NULL.

GnuiTaggedEntrySortFunc ()

gint
(*GnuiTaggedEntrySortFunc) (const gchar *tag_1,
                            const gchar *tag_2,
                            gpointer user_data);

A function type for sorting the tags added to the tagged entry

It is granted that the strings passed to the sort function are always non-NULL and with a length greater than zero, therefore the sort function must not check for NULL or "".

gnui_tagged_entry_new ()

GtkWidget *
gnui_tagged_entry_new (void);

Create a new tagged entry widget

gnui_tagged_entry_has_tag ()

gboolean
gnui_tagged_entry_has_tag (GnuiTaggedEntry * const self,
                           const gchar * const tag);

Get whether a tagged entry has a particular tag

A tagged entry must always have a match function; if the “match-function” property is set to NULL literal equality checks between strings will be performed in order to find the given tag.

gnui_tagged_entry_remove_tag ()

gboolean
gnui_tagged_entry_remove_tag (GnuiTaggedEntry * const self,
                              const gchar * const tag);

Remove a particular tag from a tagged entry

A tagged entry must always have a match function; if the “match-function” property is set to NULL literal equality checks between strings will be performed in order to find the tag to remove.

gnui_tagged_entry_remove_all_tags ()

void
gnui_tagged_entry_remove_all_tags (GnuiTaggedEntry * const self);

Remove all the tags from a tagged entry

gnui_tagged_entry_populate ()

gboolean
gnui_tagged_entry_populate (GnuiTaggedEntry * const self,
                            const gboolean pinned,
                            ...);

Clear and populate a tagged entry

gnui_tagged_entry_populate_strv ()

gboolean
gnui_tagged_entry_populate_strv (GnuiTaggedEntry * const self,
                                 const gchar * const * const tags,
                                 const gboolean pinned);

Clear and populate a tagged entry, using an array of strings as input

gnui_tagged_entry_add_tag ()

gboolean
gnui_tagged_entry_add_tag (GnuiTaggedEntry * const self,
                           const gchar * const tag,
                           const gboolean pinned);

Add a a tag to a tagged entry

gnui_tagged_entry_add_tags ()

gboolean
gnui_tagged_entry_add_tags (GnuiTaggedEntry * const self,
                            const gboolean pinned,
                            ...);

Add a group of tags to a tagged entry

gnui_tagged_entry_parse_expression ()

gsize
gnui_tagged_entry_parse_expression (GnuiTaggedEntry * const self,
                                    const gchar * const expression,
                                    const gboolean pinned);

Parse a delimited string and add its tags to a tagged entry

gnui_tagged_entry_rename_tag ()

gboolean
gnui_tagged_entry_rename_tag (GnuiTaggedEntry * const self,
                              const gchar * const old_name,
                              const gchar * const new_name);

Rename a particular tag in a tagged entry

A tagged entry must always have a match function; if the “match-function” property is set to NULL, in order to find the tag to rename literal equality checks between strings will be performed.

gnui_tagged_entry_set_pin ()

gboolean
gnui_tagged_entry_set_pin (GnuiTaggedEntry * const self,
                           const gchar * const tag,
                           const gboolean pinned);

Pin/unpin a given tag

A tagged entry must always have a match function; if the “match-function” property is set to NULL, in order to find the tag to pin/unpin literal equality checks between strings will be performed.

gnui_tagged_entry_set_pins ()

gboolean
gnui_tagged_entry_set_pins (GnuiTaggedEntry * const self,
                            const gboolean pinned,
                            ...);

Pin/unpin a group of tags

A tagged entry must always have a match function; if the “match-function” property is set to NULL, in order to find the tag to pin/unpin literal equality checks between strings will be performed.

gnui_tagged_entry_activate ()

void
gnui_tagged_entry_activate (GnuiTaggedEntry * const self);

Activate a tagged entry (similar to pressing ENTER)

gnui_tagged_entry_get_delimiter_chars ()

const gchar *
gnui_tagged_entry_get_delimiter_chars (GnuiTaggedEntry * const self);

Get the delimiter characters of a tagged entry

[get-property delimiter-chars]

gnui_tagged_entry_set_delimiter_chars ()

void
gnui_tagged_entry_set_delimiter_chars (GnuiTaggedEntry * const self,
                                       const gchar *delimiter_chars);

Set the delimiter characters of a tagged entry

If no delimiters are set, new tags can be added only by activating the tagged entry (usually by pressing ENTER).

[set-property delimiter-chars]

gnui_tagged_entry_get_filter_data ()

gpointer
gnui_tagged_entry_get_filter_data (GnuiTaggedEntry * const self);

Get the closure data passed to the “filter-function”

[get-property filter-data]

gnui_tagged_entry_set_filter_data ()

void
gnui_tagged_entry_set_filter_data (GnuiTaggedEntry * const self,
                                   const gpointer filter_data);

Set the closure data passed to the “filter-function”

If later you need to destroy filter_data , connect the address to the tagged entry's “destroy” signal.

1
2
3
4
5
6

g_signal_connect_swapped(
    my_tagged_entry,
    "destroy",
    G_CALLBACK(my_destroy_listener),
    filter_data
);

[set-property filter-data]

gnui_tagged_entry_get_filter_function ()

GnuiTaggedEntryFilterFunc
gnui_tagged_entry_get_filter_function (GnuiTaggedEntry * const self);

Get the function that determines whether a tag can be added

[get-property filter-function]

gnui_tagged_entry_set_filter_function ()

void
gnui_tagged_entry_set_filter_function (GnuiTaggedEntry * const self,
                                       const GnuiTaggedEntryFilterFunc filter_func);

Set the function that determines whether a tag can be added

It is granted that the strings passed to the filter function are always non-NULL and with a length greater than zero, therefore the filter function must not check for NULL or "".

[set-property filter-function]

gnui_tagged_entry_get_invalid ()

gboolean
gnui_tagged_entry_get_invalid (GnuiTaggedEntry * const self);

Get whether the tagged entry is in invalid state

[get-property invalid]

gnui_tagged_entry_set_invalid ()

void
gnui_tagged_entry_set_invalid (GnuiTaggedEntry * const self,
                               const gboolean invalid);

Set whether the tagged entry is in invalid state

[set-property invalid]

gnui_tagged_entry_get_match_data ()

gpointer
gnui_tagged_entry_get_match_data (GnuiTaggedEntry * const self);

Get the closure data passed to the “match-function”

[get-property match-data]

gnui_tagged_entry_set_match_data ()

void
gnui_tagged_entry_set_match_data (GnuiTaggedEntry * const self,
                                  const gpointer match_data);

Set the closure data passed to the “match-function”

If later you need to destroy match_data , connect the address to the tagged entry's “destroy” signal.

1
2
3
4
5
6

g_signal_connect_swapped(
    my_tagged_entry,
    "destroy",
    G_CALLBACK(my_destroy_listener),
    match_data
);

[set-property match-data]

gnui_tagged_entry_get_match_function ()

GnuiTaggedEntryMatchFunc
gnui_tagged_entry_get_match_function (GnuiTaggedEntry * const self);

Get the function that determines whether two tags match

[get-property match-function]

gnui_tagged_entry_set_match_function ()

void
gnui_tagged_entry_set_match_function (GnuiTaggedEntry * const self,
                                      const GnuiTaggedEntryMatchFunc match_func);

Set the function that determines whether two tags match

The first argument passed to the match function is always a tag already in the entry, whereas the second argument is what is being checked for equality.

It is granted that the strings passed to the match function are always non-NULL and with a length greater than zero, therefore the match function must not check for NULL or "".

A tagged entry must always have a match function; if match_func is set to NULL a literal equality check between string will be used as the match function.

[set-property match-function]

gnui_tagged_entry_get_modified ()

gboolean
gnui_tagged_entry_get_modified (GnuiTaggedEntry * const self);

Get whether the tagged entry has been modified by the user

[get-property modified]

gnui_tagged_entry_set_modified ()

void
gnui_tagged_entry_set_modified (GnuiTaggedEntry * const self,
                                const gboolean modified);

Set whether the tagged entry has been modified by the user

[set-property modified]

gnui_tagged_entry_get_placeholder_text ()

const char *
gnui_tagged_entry_get_placeholder_text
                               (GnuiTaggedEntry * const self);

Get the text that must be displayed when the tagged entry is empty

[get-property placeholder-text]

gnui_tagged_entry_set_placeholder_text ()

void
gnui_tagged_entry_set_placeholder_text
                               (GnuiTaggedEntry * const self,
                                const char * const placeholder_text);

Set the text that must be displayed when the tagged entry is empty

[set-property placeholder-text]

gnui_tagged_entry_get_sanitize_data ()

gpointer
gnui_tagged_entry_get_sanitize_data (GnuiTaggedEntry * const self);

Get the closure data passed to the “sanitize-function”

[get-property sanitize-data]

gnui_tagged_entry_set_sanitize_data ()

void
gnui_tagged_entry_set_sanitize_data (GnuiTaggedEntry * const self,
                                     const gpointer sanitize_data);

Set the closure data passed to the “sanitize-function”

If later you need to destroy sanitize_data , connect the address to the tagged entry's “destroy” signal.

1
2
3
4
5
6

g_signal_connect_swapped(
    my_tagged_entry,
    "destroy",
    G_CALLBACK(my_destroy_listener),
    sanitize_data
);

[set-property sanitize-data]

gnui_tagged_entry_get_sanitize_function ()

GnuiTaggedEntrySanitizeFunc
gnui_tagged_entry_get_sanitize_function
                               (GnuiTaggedEntry * const self);

Get the function that allocates the strings that must be added to the tagged entry as tags, based on the given input

It is granted that the strings passed to the sanitize function are always non-NULL and with a length greater than zero, therefore the sanitize function must not check for NULL or "".

[get-property sanitize-function]

gnui_tagged_entry_set_sanitize_function ()

void
gnui_tagged_entry_set_sanitize_function
                               (GnuiTaggedEntry * const self,
                                const GnuiTaggedEntrySanitizeFunc sanitize_func);

Set the function that allocates the strings that must be added to the tagged entry as tags, based on the given input

It is granted that the strings passed to the sanitize function are always non-NULL and with a length greater than zero, therefore the sanitize function must not check for NULL or "".

If this function set to NULL, g_strdup() will be used.

[set-property sanitize-function]

gnui_tagged_entry_get_sort_data ()

gpointer
gnui_tagged_entry_get_sort_data (GnuiTaggedEntry * const self);

Get the closure data passed to the “sort-function”

[get-property sort-data]

gnui_tagged_entry_set_sort_data ()

void
gnui_tagged_entry_set_sort_data (GnuiTaggedEntry * const self,
                                 const gpointer sort_data);

Get the closure data passed to the “sort-function”

If later you need to destroy sort_data , connect the address to the tagged entry's “destroy” signal.

1
2
3
4
5
6

g_signal_connect_swapped(
    my_tagged_entry,
    "destroy",
    G_CALLBACK(my_destroy_listener),
    sort_data
);

[set-property sort-data]

gnui_tagged_entry_get_sort_function ()

GnuiTaggedEntrySortFunc
gnui_tagged_entry_get_sort_function (GnuiTaggedEntry * const self);

Get the function that sorts the tags added to the tagged entry

[get-property sort-function]

gnui_tagged_entry_set_sort_function ()

void
gnui_tagged_entry_set_sort_function (GnuiTaggedEntry * const self,
                                     const GnuiTaggedEntrySortFunc sort_func);

Set the function that sorts the tags added to the tagged entry

It is granted that the strings passed to the sort function are always non-NULL and with a length greater than zero, therefore the sort function must not check for NULL or "".

Even if strcmp() takes less parameters than a GnuiTaggedEntrySortFunc, you can use strcmp() too as sort function.

[set-property sort-function]

gnui_tagged_entry_get_tags ()

const gchar * const *
gnui_tagged_entry_get_tags (GnuiTaggedEntry * const self);

Get the tagged entry's tags

[get-property tags]

gnui_tagged_entry_set_tags ()

void
gnui_tagged_entry_set_tags (GnuiTaggedEntry * const self,
                            const gchar * const * const tags);

Set the tagged entry's tags

The tags added using this function (or, equivalently, using g_object_set_property()) are always unpinned. For populating a tagged entry with pinned tags please use gnui_tagged_entry_populate_strv().

[set-property tags]

gnui_tagged_entry_invalidate_filter ()

void
gnui_tagged_entry_invalidate_filter (GnuiTaggedEntry * const self);

For each tag in the tagged entry call the “filter-function”

gnui_tagged_entry_invalidate_sort ()

void
gnui_tagged_entry_invalidate_sort (GnuiTaggedEntry * const self);

For each tag in the tagged entry call the “sort-function”

gnui_tagged_entry_get_text_delegate ()

GtkText *
gnui_tagged_entry_get_text_delegate (GnuiTaggedEntry * const self);

Get the tagged entry's GtkText delegate

GnuiTaggedEntrySignalHandlerTagAdded ()

void
(*GnuiTaggedEntrySignalHandlerTagAdded)
                               (GnuiTaggedEntry *self,
                                const gchar *tag,
                                gpointer user_data);

A handler function type for the “tag-added” signal

GnuiTaggedEntrySignalHandlerTagRemoved ()

void
(*GnuiTaggedEntrySignalHandlerTagRemoved)
                               (GnuiTaggedEntry *self,
                                const gchar *tag,
                                gpointer user_data);

A handler function type for the “tag-removed” signal

GnuiTaggedEntrySignalHandlerActivate ()

void
(*GnuiTaggedEntrySignalHandlerActivate)
                               (GnuiTaggedEntry *self,
                                gpointer user_data);

A handler function type for the “activate” signal

GnuiTaggedEntrySignalHandlerInvalidChanged ()

void
(*GnuiTaggedEntrySignalHandlerInvalidChanged)
                               (GnuiTaggedEntry *self,
                                gboolean invalid,
                                gpointer user_data);

A handler function type for the “invalid-changed” signal

GnuiTaggedEntrySignalHandlerModifiedChanged ()

void
(*GnuiTaggedEntrySignalHandlerModifiedChanged)
                               (GnuiTaggedEntry *self,
                                gboolean modified,
                                gpointer user_data);

A handler function type for the “modified-changed” signal

GNUI_TYPE_TAGGED_ENTRY

#define GNUI_TYPE_TAGGED_ENTRY (gnui_tagged_entry_get_type())

The GType of GnuiTaggedEntry

GnuiTaggedEntry

typedef struct _GnuiTaggedEntry GnuiTaggedEntry;

The GnuiTaggedEntry widget

The “delimiter-chars” property

  “delimiter-chars”          char *

A NIL-terminated array of characters (i.e. a “C string”) to use as input delimiters between different tags.

[nullable]

Owner: GnuiTaggedEntry

Flags: Read / Write

Default value: NULL

The “filter-data” property

  “filter-data”              gpointer

Closure data for “filter-function” – use the “destroy” signal if later you want to free it.

[closure]

Owner: GnuiTaggedEntry

Flags: Read / Write

The “filter-function” property

  “filter-function”          gpointer

Function to use to determine if a tag is valid.

[nullable]

Owner: GnuiTaggedEntry

Flags: Read / Write

The “invalid” property

  “invalid”                  gboolean

Whether the tagged entry is in “invalid” state.

Owner: GnuiTaggedEntry

Flags: Read / Write

Default value: FALSE

The “match-data” property

  “match-data”               gpointer

Closure data for “match-function” – use the “destroy” signal if later you want to free it.

[closure]

Owner: GnuiTaggedEntry

Flags: Read / Write

The “match-function” property

  “match-function”           gpointer

Function to use to determine if two tags match.

[nullable]

Owner: GnuiTaggedEntry

Flags: Read / Write

The “modified” property

  “modified”                 gboolean

Whether the tagged entry has been modified.

Owner: GnuiTaggedEntry

Flags: Read / Write

Default value: FALSE

The “placeholder-text” property

  “placeholder-text”         char *

The text to be displayed when the tagged entry is empty.

[nullable]

Owner: GnuiTaggedEntry

Flags: Read / Write

Default value: NULL

The “sanitize-data” property

  “sanitize-data”            gpointer

Closure data for “sanitize-function” – use the “destroy” signal if later you want to free it.

[closure]

Owner: GnuiTaggedEntry

Flags: Read / Write

The “sanitize-function” property

  “sanitize-function”        gpointer

Function to use to sanitize (and allocate) each new tag.

[nullable]

Owner: GnuiTaggedEntry

Flags: Read / Write

The “sort-data” property

  “sort-data”                gpointer

Closure data for “sort-function” – use the “destroy” signal if later you want to free it.

[closure]

Owner: GnuiTaggedEntry

Flags: Read / Write

The “sort-function” property

  “sort-function”            gpointer

Function to use to sort the tag order.

[nullable]

Owner: GnuiTaggedEntry

Flags: Read / Write

The “tags” property

  “tags”                     GStrv

The current tags.

[nullable]

Owner: GnuiTaggedEntry

Flags: Read / Write

The “activate” signal

void
user_function (GnuiTaggedEntry *self,
               gpointer         user_data)

Signal emitted when a tagged entry is activated (usually by pressing ENTER)

GnuiTaggedEntrySignalHandlerActivate is the function type of reference for this signal, which takes parameters' constness into account.

Flags: Run First

The “invalid-changed” signal

void
user_function (GnuiTaggedEntry *self,
               gboolean         invalid,
               gpointer         user_data)

Signal emitted when the “invalid” property changes

GnuiTaggedEntrySignalHandlerInvalidChanged is the function type of reference for this signal, which takes parameters' constness into account.

Flags: Run First

The “modified-changed” signal

void
user_function (GnuiTaggedEntry *self,
               gboolean         modified,
               gpointer         user_data)

Signal emitted when the “modified” property changes

GnuiTaggedEntrySignalHandlerModifiedChanged is the function type of reference for this signal, which takes parameters' constness into account.

Flags: Run First

The “tag-added” signal

void
user_function (GnuiTaggedEntry *self,
               char            *tag,
               gpointer         user_data)

Signal emitted when a new tag is added to the tagged entry

GnuiTaggedEntrySignalHandlerTagAdded is the function type of reference for this signal, which takes parameters' constness into account.

Flags: Run First

The “tag-removed” signal

void
user_function (GnuiTaggedEntry *self,
               char            *tag,
               gpointer         user_data)

Signal emitted when a tag is removed from the tagged entry

GnuiTaggedEntrySignalHandlerTagRemoved is the function type of reference for this signal, which takes parameters' constness into account.

Flags: Run First