* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
/*
*/
+struct _GtkAdjustmentPrivate {
+ gdouble lower;
+ gdouble upper;
+ gdouble value;
+ gdouble step_increment;
+ gdouble page_increment;
+ gdouble page_size;
+};
+
enum
{
PROP_0,
* GtkAdjustment::changed:
* @adjustment: the object which received the signal.
*
- * Emitted when one or more of the #GtkAdjustment fields have been changed,
- * other than the value field.
+ * Emitted when one or more of the #GtkAdjustment properties have been
+ * changed, other than the #GtkAdjustment:value property.
*/
adjustment_signals[CHANGED] =
g_signal_new (I_("changed"),
* GtkAdjustment::value-changed:
* @adjustment: the object which received the signal.
*
- * Emitted when the #GtkAdjustment value field has been changed.
+ * Emitted when the #GtkAdjustment:value property has been changed.
*/
adjustment_signals[VALUE_CHANGED] =
g_signal_new (I_("value-changed"),
NULL, NULL,
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
+
+ g_type_class_add_private (class, sizeof (GtkAdjustmentPrivate));
}
static void
gtk_adjustment_init (GtkAdjustment *adjustment)
{
- adjustment->value = 0.0;
- adjustment->lower = 0.0;
- adjustment->upper = 0.0;
- adjustment->step_increment = 0.0;
- adjustment->page_increment = 0.0;
- adjustment->page_size = 0.0;
+ adjustment->priv = G_TYPE_INSTANCE_GET_PRIVATE (adjustment,
+ GTK_TYPE_ADJUSTMENT,
+ GtkAdjustmentPrivate);
}
static void
GParamSpec *pspec)
{
GtkAdjustment *adjustment = GTK_ADJUSTMENT (object);
+ GtkAdjustmentPrivate *priv = adjustment->priv;
switch (prop_id)
{
case PROP_VALUE:
- g_value_set_double (value, adjustment->value);
+ g_value_set_double (value, priv->value);
break;
case PROP_LOWER:
- g_value_set_double (value, adjustment->lower);
+ g_value_set_double (value, priv->lower);
break;
case PROP_UPPER:
- g_value_set_double (value, adjustment->upper);
+ g_value_set_double (value, priv->upper);
break;
case PROP_STEP_INCREMENT:
- g_value_set_double (value, adjustment->step_increment);
+ g_value_set_double (value, priv->step_increment);
break;
case PROP_PAGE_INCREMENT:
- g_value_set_double (value, adjustment->page_increment);
+ g_value_set_double (value, priv->page_increment);
break;
case PROP_PAGE_SIZE:
- g_value_set_double (value, adjustment->page_size);
+ g_value_set_double (value, priv->page_size);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
{
GtkAdjustment *adjustment = GTK_ADJUSTMENT (object);
gdouble double_value = g_value_get_double (value);
+ GtkAdjustmentPrivate *priv = adjustment->priv;
switch (prop_id)
{
gtk_adjustment_set_value (adjustment, double_value);
break;
case PROP_LOWER:
- adjustment->lower = double_value;
+ priv->lower = double_value;
break;
case PROP_UPPER:
- adjustment->upper = double_value;
+ priv->upper = double_value;
break;
case PROP_STEP_INCREMENT:
- adjustment->step_increment = double_value;
+ priv->step_increment = double_value;
break;
case PROP_PAGE_INCREMENT:
- adjustment->page_increment = double_value;
+ priv->page_increment = double_value;
break;
case PROP_PAGE_SIZE:
- adjustment->page_size = double_value;
+ priv->page_size = double_value;
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
{
g_return_val_if_fail (GTK_IS_ADJUSTMENT (adjustment), 0.0);
- return adjustment->value;
+ return adjustment->priv->value;
}
/**
* @value: the new value.
*
* Sets the #GtkAdjustment value. The value is clamped to lie between
- * #GtkAdjustment.lower and #GtkAdjustment.upper.
+ * #GtkAdjustment:lower and #GtkAdjustment:upper.
*
* Note that for adjustments which are used in a #GtkScrollbar, the effective
- * range of allowed values goes from #GtkAdjustment.lower to
- * #GtkAdjustment.upper - #GtkAdjustment.page_size.
+ * range of allowed values goes from #GtkAdjustment:lower to
+ * #GtkAdjustment:upper - #GtkAdjustment:page_size.
*/
void
gtk_adjustment_set_value (GtkAdjustment *adjustment,
gdouble value)
{
+ GtkAdjustmentPrivate *priv;
+
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
+ priv = adjustment->priv;
+
/* don't use CLAMP() so we don't end up below lower if upper - page_size
* is smaller than lower
*/
- value = MIN (value, adjustment->upper - adjustment->page_size);
- value = MAX (value, adjustment->lower);
+ value = MIN (value, priv->upper - priv->page_size);
+ value = MAX (value, priv->lower);
- if (value != adjustment->value)
+ if (value != priv->value)
{
- adjustment->value = value;
+ priv->value = value;
gtk_adjustment_value_changed (adjustment);
}
{
g_return_val_if_fail (GTK_IS_ADJUSTMENT (adjustment), 0.0);
- return adjustment->lower;
+ return adjustment->priv->lower;
}
/**
* Sets the minimum value of the adjustment.
*
* When setting multiple adjustment properties via their individual
- * setters, multiple "changed" signals will be emitted. However, since
- * the emission of the "changed" signal is tied to the emission of the
- * "GObject::notify" signals of the changed properties, it's possible
- * to compress the "changed" signals into one by calling
+ * setters, multiple #GtkAdjustment::changed signals will be emitted. However, since
+ * the emission of the #GtkAdjustment::changed signal is tied to the emission of the
+ * #GObject::notify signals of the changed properties, it's possible
+ * to compress the #GtkAdjustment::changed signals into one by calling
* g_object_freeze_notify() and g_object_thaw_notify() around the
* calls to the individual setters.
*
* Alternatively, using a single g_object_set() for all the properties
* to change, or using gtk_adjustment_configure() has the same effect
- * of compressing "changed" emissions.
+ * of compressing #GtkAdjustment::changed emissions.
*
* Since: 2.14
**/
{
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
- if (lower != adjustment->lower)
+ if (lower != adjustment->priv->lower)
g_object_set (adjustment, "lower", lower, NULL);
}
{
g_return_val_if_fail (GTK_IS_ADJUSTMENT (adjustment), 0.0);
- return adjustment->upper;
+ return adjustment->priv->upper;
}
/**
* property is nonzero.
*
* See gtk_adjustment_set_lower() about how to compress multiple
- * emissions of the "changed" signal when setting multiple adjustment
+ * emissions of the #GtkAdjustment::changed signal when setting multiple adjustment
* properties.
*
* Since: 2.14
{
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
- if (upper != adjustment->upper)
+ if (upper != adjustment->priv->upper)
g_object_set (adjustment, "upper", upper, NULL);
}
{
g_return_val_if_fail (GTK_IS_ADJUSTMENT (adjustment), 0.0);
- return adjustment->step_increment;
+ return adjustment->priv->step_increment;
}
/**
* Sets the step increment of the adjustment.
*
* See gtk_adjustment_set_lower() about how to compress multiple
- * emissions of the "changed" signal when setting multiple adjustment
+ * emissions of the #GtkAdjustment::changed signal when setting multiple adjustment
* properties.
*
* Since: 2.14
{
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
- if (step_increment != adjustment->step_increment)
+ if (step_increment != adjustment->priv->step_increment)
g_object_set (adjustment, "step-increment", step_increment, NULL);
}
{
g_return_val_if_fail (GTK_IS_ADJUSTMENT (adjustment), 0.0);
- return adjustment->page_increment;
+ return adjustment->priv->page_increment;
}
/**
* Sets the page increment of the adjustment.
*
* See gtk_adjustment_set_lower() about how to compress multiple
- * emissions of the "changed" signal when setting multiple adjustment
+ * emissions of the #GtkAdjustment::changed signal when setting multiple adjustment
* properties.
*
* Since: 2.14
{
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
- if (page_increment != adjustment->page_increment)
+ if (page_increment != adjustment->priv->page_increment)
g_object_set (adjustment, "page-increment", page_increment, NULL);
}
{
g_return_val_if_fail (GTK_IS_ADJUSTMENT (adjustment), 0.0);
- return adjustment->page_size;
+ return adjustment->priv->page_size;
}
/**
* Sets the page size of the adjustment.
*
* See gtk_adjustment_set_lower() about how to compress multiple
- * emissions of the "changed" signal when setting multiple adjustment
+ * emissions of the GtkAdjustment::changed signal when setting multiple adjustment
* properties.
*
* Since: 2.14
{
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
- if (page_size != adjustment->page_size)
+ if (page_size != adjustment->priv->page_size)
g_object_set (adjustment, "page-size", page_size, NULL);
}
*
* Sets all properties of the adjustment at once.
*
- * Use this function to avoid multiple emissions of the "changed"
+ * Use this function to avoid multiple emissions of the #GtkAdjustment::changed
* signal. See gtk_adjustment_set_lower() for an alternative way
- * of compressing multiple emissions of "changed" into one.
+ * of compressing multiple emissions of #GtkAdjustment::changed into one.
*
* Since: 2.14
**/
gdouble page_increment,
gdouble page_size)
{
+ GtkAdjustmentPrivate *priv;
gboolean value_changed = FALSE;
guint64 old_stamp = adjustment_changed_stamp;
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
+ priv = adjustment->priv;
+
g_object_freeze_notify (G_OBJECT (adjustment));
g_object_set (adjustment,
value = MIN (value, upper - page_size);
value = MAX (value, lower);
- if (value != adjustment->value)
+ if (value != priv->value)
{
/* set value manually to make sure "changed" is emitted with the
* new value in place and is emitted before "value-changed"
*/
- adjustment->value = value;
+ priv->value = value;
value_changed = TRUE;
}
*
* Emits a #GtkAdjustment::changed signal from the #GtkAdjustment.
* This is typically called by the owner of the #GtkAdjustment after it has
- * changed any of the #GtkAdjustment fields other than the value.
+ * changed any of the #GtkAdjustment properties other than the value.
*/
void
gtk_adjustment_changed (GtkAdjustment *adjustment)
*
* Emits a #GtkAdjustment::value_changed signal from the #GtkAdjustment.
* This is typically called by the owner of the #GtkAdjustment after it has
- * changed the #GtkAdjustment value field.
+ * changed the #GtkAdjustment:value property.
*/
void
gtk_adjustment_value_changed (GtkAdjustment *adjustment)
* @lower: the lower value.
* @upper: the upper value.
*
- * Updates the #GtkAdjustment #GtkAdjustment.value to ensure that the range
+ * Updates the #GtkAdjustment:value property to ensure that the range
* between @lower and @upper is in the current page (i.e. between
- * #GtkAdjustment.value and #GtkAdjustment.value + #GtkAdjustment.page_size).
+ * #GtkAdjustment:value and #GtkAdjustment:value + #GtkAdjustment:page_size).
* If the range is larger than the page size, then only the start of it will
* be in the current page.
* A #GtkAdjustment::changed signal will be emitted if the value is changed.
gdouble lower,
gdouble upper)
{
+ GtkAdjustmentPrivate *priv;
gboolean need_emission;
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
- lower = CLAMP (lower, adjustment->lower, adjustment->upper);
- upper = CLAMP (upper, adjustment->lower, adjustment->upper);
+ priv = adjustment->priv;
+
+ lower = CLAMP (lower, priv->lower, priv->upper);
+ upper = CLAMP (upper, priv->lower, priv->upper);
need_emission = FALSE;
- if (adjustment->value + adjustment->page_size < upper)
+ if (priv->value + priv->page_size < upper)
{
- adjustment->value = upper - adjustment->page_size;
+ priv->value = upper - priv->page_size;
need_emission = TRUE;
}
- if (adjustment->value > lower)
+ if (priv->value > lower)
{
- adjustment->value = lower;
+ priv->value = lower;
need_emission = TRUE;
}
if (need_emission)
gtk_adjustment_value_changed (adjustment);
}
+
+/**
+ * gtk_adjustment_get_minimum_increment:
+ * @adjustment: a #GtkAdjustment
+ *
+ * Gets the smaller of step increment and page increment.
+ *
+ * Returns: the minimum increment of @adjustment
+ *
+ * Since: 3.2
+ */
+gdouble
+gtk_adjustment_get_minimum_increment (GtkAdjustment *adjustment)
+{
+ GtkAdjustmentPrivate *priv;
+ gdouble minimum_increment;
+
+ g_return_val_if_fail (GTK_IS_ADJUSTMENT (adjustment), 0);
+
+ priv = adjustment->priv;
+
+ if (priv->step_increment != 0 && priv->page_increment != 0)
+ {
+ if (ABS (priv->step_increment) < ABS (priv->page_increment))
+ minimum_increment = priv->step_increment;
+ else
+ minimum_increment = priv->page_increment;
+ }
+ else if (priv->step_increment == 0 && priv->page_increment == 0)
+ {
+ minimum_increment = 0;
+ }
+ else if (priv->step_increment == 0)
+ {
+ minimum_increment = priv->page_increment;
+ }
+ else
+ {
+ minimum_increment = priv->step_increment;
+ }
+
+ return minimum_increment;
+}
+