b_view_interval_new ()

BViewInterval *
b_view_interval_new (void);

b_view_interval_set ()

void
b_view_interval_set (BViewInterval *v,
                     double a,
                     double b);

Set a BViewInterval to have edges at a and b . If these are different from its previous edges, the "changed" signal will be emitted.

b_view_interval_range ()

void
b_view_interval_range (BViewInterval *v,
                       double *a,
                       double *b);

Get the edges a and b of a BViewInterval.

b_view_interval_get_vi_type ()

int
b_view_interval_get_vi_type (BViewInterval *v);

Gets the type of the BViewInterval, which could be for example VIEW_NORMAL if the view is linear, or VIEW_LOG if it is logarithmic.

b_view_interval_valid ()

gboolean
b_view_interval_valid (BViewInterval *v,
                       double x);

Check whether a number could possibly exist on a view interval. For example, only positive values are valid on a logarithmic view interval.

b_view_interval_conv ()

double
b_view_interval_conv (BViewInterval *v,
                      double x);

Convert a double-precision value to the view interval's coordinates

b_view_interval_unconv ()

double
b_view_interval_unconv (BViewInterval *v,
                        double x);

Convert a value from the ViewInterval's coordinates (0 to 1)

b_view_interval_conv_bulk ()

void
b_view_interval_conv_bulk (BViewInterval *v,
                           const double *in_data,
                           double *out_data,
                           gsize N);

Convert an array of double-precision values to the ViewInterval's coordinates.

b_view_interval_unconv_bulk ()

void
b_view_interval_unconv_bulk (BViewInterval *v,
                             const double *in_data,
                             double *out_data,
                             gsize N);

Convert an array from the ViewInterval's coordinates to data coordinates.

b_view_interval_rescale_around_point ()

void
b_view_interval_rescale_around_point (BViewInterval *v,
                                      double x,
                                      double s);

Scale v by factor s and center it around x .

b_view_interval_recenter_around_point ()

void
b_view_interval_recenter_around_point (BViewInterval *v,
                                       double x);

Center v around a new point x without changing its width.

b_view_interval_translate ()

void
b_view_interval_translate (BViewInterval *v,
                           double dx);

Move interval by dx without changing its width.

b_view_interval_grow_to ()

void
b_view_interval_grow_to (BViewInterval *v,
                         double a,
                         double b);

Increases the size of a BViewInterval to include values a and b .

b_view_interval_set_min_width ()

void
b_view_interval_set_min_width (BViewInterval *v,
                               double mw);

Set a BViewInterval's minimum width.

b_view_interval_set_bounds ()

void
b_view_interval_set_bounds (BViewInterval *v,
                            double a,
                            double b);

Set a BViewInterval to have bounds at a and b . These are the maximum and minimum values that its edges can take.

b_view_interval_clear_bounds ()

void
b_view_interval_clear_bounds (BViewInterval *v);

Reset a BViewInterval's bounds to the default values, -HUGE_VAL and HUGE_VAL.

b_view_interval_request_preferred_range ()

void
b_view_interval_request_preferred_range
                               (BViewInterval *v);

Causes the BViewInterval to emit a signal that will cause connected views to set the view interval to their preferred range.

b_view_interval_set_ignore_preferred_range ()

void
b_view_interval_set_ignore_preferred_range
                               (BViewInterval *v,
                                gboolean ignore);

Whether the BViewInterval should ignore connected views' preferred ranges.

b_view_interval_get_ignore_preferred_range ()

gboolean
b_view_interval_get_ignore_preferred_range
                               (BViewInterval *v);

Return whether the BViewInterval is ignoring connected views' preferred ranges.

b_view_interval_scale_linearly ()

void
b_view_interval_scale_linearly (BViewInterval *v);

Use a linear scale for v .

b_view_interval_scale_logarithmically ()

void
b_view_interval_scale_logarithmically (BViewInterval *v,
                                       double base);

Use a logarithmic scale for v , with base base . The base isn't currently used.

b_view_interval_is_logarithmic()

#define b_view_interval_is_logarithmic(v) (b_view_interval_get_vi_type(v) == VIEW_LOG)

BViewInterval

typedef struct _BViewInterval BViewInterval;

The “changed” signal

void
user_function (BViewInterval *bviewinterval,
               gpointer       user_data)

Flags: Run First

The “preferred-range-request” signal

void
user_function (BViewInterval *bviewinterval,
               gpointer       user_data)

Flags: Run First