GuppiSeq

Name

GuppiSeq -- 

Synopsis



#define     GUPPI_SEQ0                      (obj)
#define     GUPPI_IS_SEQ0                   (obj)
void        guppi_seq_size_hint             (GuppiSeq*,
                                             gsize expected_size);
void        guppi_seq_indices               (const GuppiSeq*,
                                             gint *min,
                                             gint *max);
#define     guppi_seq_bounds                (seq, a, b)
gint        guppi_seq_min_index             (const GuppiSeq*);
gint        guppi_seq_max_index             (const GuppiSeq*);
gsize       guppi_seq_size                  (const GuppiSeq*);
gsize       guppi_seq_count                 (const GuppiSeq*);
gboolean    guppi_seq_empty                 (const GuppiSeq*);
gboolean    guppi_seq_nonempty              (const GuppiSeq*);
gboolean    guppi_seq_absent                (const GuppiSeq*);
gboolean    guppi_seq_present               (const GuppiSeq*);
gboolean    guppi_seq_in_bounds             (const GuppiSeq*,
                                             gint);
gboolean    guppi_seq_contains_bounds       (const GuppiSeq*,
                                             const GuppiSeq*);
gboolean    guppi_seq_equal_bounds          (const GuppiSeq*,
                                             const GuppiSeq*);
void        guppi_seq_common_bounds         (const GuppiSeq*,
                                             const GuppiSeq*,
                                             gint*,
                                             gint*);
void        guppi_seq_shift_indices         (GuppiSeq*,
                                             gint);
void        guppi_seq_set_min_index         (GuppiSeq*,
                                             gint);
void        guppi_seq_set_max_index         (GuppiSeq*,
                                             gint);
gboolean    guppi_seq_validate              (const GuppiSeq*,
                                             const gchar *sbuf);
gboolean    guppi_seq_validate_with_feedback
                                            (const GuppiSeq*,
                                             const gchar *sbuf,
                                             gchar *ebuf,
                                             gsize elen);
gchar*      guppi_seq_get_string            (const GuppiSeq*,
                                             gint i);
void        guppi_seq_get_to_string         (const GuppiSeq*,
                                             gint i,
                                             gchar *sbuf,
                                             gsize sbuf_len);
void        guppi_seq_set_from_string       (GuppiSeq*,
                                             gint i,
                                             const gchar *sbuf);
void        guppi_seq_insert_from_string    (GuppiSeq*,
                                             gint i,
                                             const gchar *sbuf);
void        guppi_seq_prepend_from_string   (GuppiSeq*,
                                             const gchar *sbuf);
void        guppi_seq_append_from_string    (GuppiSeq*,
                                             const gchar *sbuf);
void        guppi_seq_delete                (GuppiSeq*,
                                             gint);
void        guppi_seq_delete_many           (GuppiSeq*,
                                             gint,
                                             gsize);
void        guppi_seq_delete_range          (GuppiSeq*,
                                             gint,
                                             gint);
void        guppi_seq_grow_to_include       (GuppiSeq*,
                                             gint i);
void        guppi_seq_grow_to_include_range (GuppiSeq*,
                                             gint i0,
                                             gint i1);
void        guppi_seq_grow_to_overlap       (GuppiSeq*,
                                             const GuppiSeq*);
gboolean    guppi_seq_has_missing           (GuppiSeq*);
gsize       guppi_seq_missing_count         (GuppiSeq*);
gboolean    guppi_seq_missing               (GuppiSeq*,
                                             gint);
gboolean    guppi_seq_available             (GuppiSeq*,
                                             gint);
void        guppi_seq_set_missing           (GuppiSeq*,
                                             gint);
void        guppi_seq_insert_missing        (GuppiSeq*,
                                             gint);
void        guppi_seq_prepend_missing       (GuppiSeq*);
void        guppi_seq_append_missing        (GuppiSeq*);
void        guppi_seq_changed_shift_indices (GuppiSeq*,
                                             gint,
                                             GuppiDataOp*);
void        guppi_seq_changed_set           (GuppiSeq*,
                                             gint,
                                             gint,
                                             GuppiDataOp*);
void        guppi_seq_changed_insert        (GuppiSeq*,
                                             gint,
                                             gsize,
                                             GuppiDataOp*);
void        guppi_seq_changed_delete        (GuppiSeq*,
                                             gint,
                                             gsize,
                                             GuppiDataOp*);

Object Hierarchy


  GtkObject
   +----GuppiData
         +----GuppiSeq

Signal Prototypes


"changed-shift-indices"
            void        user_function      (GuppiSeq *guppiseq,
                                            gint arg1,
                                            gpointer user_data);
"changed-set"
            void        user_function      (GuppiSeq *guppiseq,
                                            gint arg1,
                                            gint arg2,
                                            gpointer user_data);
"changed-insert"
            void        user_function      (GuppiSeq *guppiseq,
                                            gint arg1,
                                            guint arg2,
                                            gpointer user_data);
"changed-delete"
            void        user_function      (GuppiSeq *guppiseq,
                                            gint arg1,
                                            guint arg2,
                                            gpointer user_data);

Description

Details

GUPPI_SEQ0()

#define GUPPI_SEQ0(obj) ((obj) ? (GUPPI_SEQ(obj)) : NULL)

obj : 


GUPPI_IS_SEQ0()

#define GUPPI_IS_SEQ0(obj) (((obj) == NULL) || (GUPPI_IS_SEQ(obj)))

obj : 


guppi_seq_size_hint ()

void        guppi_seq_size_hint             (GuppiSeq*,
                                             gsize expected_size);

Param1 : 
expected_size : 


guppi_seq_indices ()

void        guppi_seq_indices               (const GuppiSeq*,
                                             gint *min,
                                             gint *max);

Param1 : 
min : 
max : 


guppi_seq_bounds()

#define guppi_seq_bounds(seq, a, b) (guppi_seq_indices((seq), (a), (b)))

seq : 
a : 
b : 


guppi_seq_min_index ()

gint        guppi_seq_min_index             (const GuppiSeq*);

Param1 : 
Returns : 


guppi_seq_max_index ()

gint        guppi_seq_max_index             (const GuppiSeq*);

Param1 : 
Returns : 


guppi_seq_size ()

gsize       guppi_seq_size                  (const GuppiSeq*);

Param1 : 
Returns : 


guppi_seq_count ()

gsize       guppi_seq_count                 (const GuppiSeq*);

Param1 : 
Returns : 


guppi_seq_empty ()

gboolean    guppi_seq_empty                 (const GuppiSeq*);

Param1 : 
Returns : 


guppi_seq_nonempty ()

gboolean    guppi_seq_nonempty              (const GuppiSeq*);

Param1 : 
Returns : 


guppi_seq_absent ()

gboolean    guppi_seq_absent                (const GuppiSeq*);

Param1 : 
Returns : 


guppi_seq_present ()

gboolean    guppi_seq_present               (const GuppiSeq*);

Param1 : 
Returns : 


guppi_seq_in_bounds ()

gboolean    guppi_seq_in_bounds             (const GuppiSeq*,
                                             gint);

Param1 : 
Param2 : 
Returns : 


guppi_seq_contains_bounds ()

gboolean    guppi_seq_contains_bounds       (const GuppiSeq*,
                                             const GuppiSeq*);

Param1 : 
Param2 : 
Returns : 


guppi_seq_equal_bounds ()

gboolean    guppi_seq_equal_bounds          (const GuppiSeq*,
                                             const GuppiSeq*);

Param1 : 
Param2 : 
Returns : 


guppi_seq_common_bounds ()

void        guppi_seq_common_bounds         (const GuppiSeq*,
                                             const GuppiSeq*,
                                             gint*,
                                             gint*);

Param1 : 
Param2 : 
Param3 : 
Param4 : 


guppi_seq_shift_indices ()

void        guppi_seq_shift_indices         (GuppiSeq*,
                                             gint);

Param1 : 
Param2 : 


guppi_seq_set_min_index ()

void        guppi_seq_set_min_index         (GuppiSeq*,
                                             gint);

Param1 : 
Param2 : 


guppi_seq_set_max_index ()

void        guppi_seq_set_max_index         (GuppiSeq*,
                                             gint);

Param1 : 
Param2 : 


guppi_seq_validate ()

gboolean    guppi_seq_validate              (const GuppiSeq*,
                                             const gchar *sbuf);

Param1 : 
sbuf : 
Returns : 


guppi_seq_validate_with_feedback ()

gboolean    guppi_seq_validate_with_feedback
                                            (const GuppiSeq*,
                                             const gchar *sbuf,
                                             gchar *ebuf,
                                             gsize elen);

Param1 : 
sbuf : 
ebuf : 
elen : 
Returns : 


guppi_seq_get_string ()

gchar*      guppi_seq_get_string            (const GuppiSeq*,
                                             gint i);

Param1 : 
i : 
Returns : 


guppi_seq_get_to_string ()

void        guppi_seq_get_to_string         (const GuppiSeq*,
                                             gint i,
                                             gchar *sbuf,
                                             gsize sbuf_len);

Param1 : 
i : 
sbuf : 
sbuf_len : 


guppi_seq_set_from_string ()

void        guppi_seq_set_from_string       (GuppiSeq*,
                                             gint i,
                                             const gchar *sbuf);

Param1 : 
i : 
sbuf : 


guppi_seq_insert_from_string ()

void        guppi_seq_insert_from_string    (GuppiSeq*,
                                             gint i,
                                             const gchar *sbuf);

Param1 : 
i : 
sbuf : 


guppi_seq_prepend_from_string ()

void        guppi_seq_prepend_from_string   (GuppiSeq*,
                                             const gchar *sbuf);

Param1 : 
sbuf : 


guppi_seq_append_from_string ()

void        guppi_seq_append_from_string    (GuppiSeq*,
                                             const gchar *sbuf);

Param1 : 
sbuf : 


guppi_seq_delete ()

void        guppi_seq_delete                (GuppiSeq*,
                                             gint);

Param1 : 
Param2 : 


guppi_seq_delete_many ()

void        guppi_seq_delete_many           (GuppiSeq*,
                                             gint,
                                             gsize);

Param1 : 
Param2 : 
Param3 : 


guppi_seq_delete_range ()

void        guppi_seq_delete_range          (GuppiSeq*,
                                             gint,
                                             gint);

Param1 : 
Param2 : 
Param3 : 


guppi_seq_grow_to_include ()

void        guppi_seq_grow_to_include       (GuppiSeq*,
                                             gint i);

Param1 : 
i : 


guppi_seq_grow_to_include_range ()

void        guppi_seq_grow_to_include_range (GuppiSeq*,
                                             gint i0,
                                             gint i1);

Param1 : 
i0 : 
i1 : 


guppi_seq_grow_to_overlap ()

void        guppi_seq_grow_to_overlap       (GuppiSeq*,
                                             const GuppiSeq*);

Param1 : 
Param2 : 


guppi_seq_has_missing ()

gboolean    guppi_seq_has_missing           (GuppiSeq*);

Param1 : 
Returns : 


guppi_seq_missing_count ()

gsize       guppi_seq_missing_count         (GuppiSeq*);

Param1 : 
Returns : 


guppi_seq_missing ()

gboolean    guppi_seq_missing               (GuppiSeq*,
                                             gint);

Param1 : 
Param2 : 
Returns : 


guppi_seq_available ()

gboolean    guppi_seq_available             (GuppiSeq*,
                                             gint);

Param1 : 
Param2 : 
Returns : 


guppi_seq_set_missing ()

void        guppi_seq_set_missing           (GuppiSeq*,
                                             gint);

Param1 : 
Param2 : 


guppi_seq_insert_missing ()

void        guppi_seq_insert_missing        (GuppiSeq*,
                                             gint);

Param1 : 
Param2 : 


guppi_seq_prepend_missing ()

void        guppi_seq_prepend_missing       (GuppiSeq*);

Param1 : 


guppi_seq_append_missing ()

void        guppi_seq_append_missing        (GuppiSeq*);

Param1 : 


guppi_seq_changed_shift_indices ()

void        guppi_seq_changed_shift_indices (GuppiSeq*,
                                             gint,
                                             GuppiDataOp*);

Param1 : 
Param2 : 
Param3 : 


guppi_seq_changed_set ()

void        guppi_seq_changed_set           (GuppiSeq*,
                                             gint,
                                             gint,
                                             GuppiDataOp*);

Param1 : 
Param2 : 
Param3 : 
Param4 : 


guppi_seq_changed_insert ()

void        guppi_seq_changed_insert        (GuppiSeq*,
                                             gint,
                                             gsize,
                                             GuppiDataOp*);

Param1 : 
Param2 : 
Param3 : 
Param4 : 


guppi_seq_changed_delete ()

void        guppi_seq_changed_delete        (GuppiSeq*,
                                             gint,
                                             gsize,
                                             GuppiDataOp*);

Param1 : 
Param2 : 
Param3 : 
Param4 : 

Signals

The "changed-shift-indices" signal

void        user_function                  (GuppiSeq *guppiseq,
                                            gint arg1,
                                            gpointer user_data);

guppiseq :the object which received the signal.
arg1 : 
user_data :user data set when the signal handler was connected.


The "changed-set" signal

void        user_function                  (GuppiSeq *guppiseq,
                                            gint arg1,
                                            gint arg2,
                                            gpointer user_data);

guppiseq :the object which received the signal.
arg1 : 
arg2 : 
user_data :user data set when the signal handler was connected.


The "changed-insert" signal

void        user_function                  (GuppiSeq *guppiseq,
                                            gint arg1,
                                            guint arg2,
                                            gpointer user_data);

guppiseq :the object which received the signal.
arg1 : 
arg2 : 
user_data :user data set when the signal handler was connected.


The "changed-delete" signal

void        user_function                  (GuppiSeq *guppiseq,
                                            gint arg1,
                                            guint arg2,
                                            gpointer user_data);

guppiseq :the object which received the signal.
arg1 : 
arg2 : 
user_data :user data set when the signal handler was connected.