gtkhscale.c

gtk是linux一款强大的夸平台的图形化开发工具

                               x, y, width, height);
}

static void
gtk_hscale_size_request (GtkWidget      *widget,
                         GtkRequisition *requisition)
{
  GtkScale *scale;
  gint value_width;
  
  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_HSCALE (widget));
  g_return_if_fail (requisition != NULL);
  
  scale = GTK_SCALE (widget);
  
  requisition->width = (SCALE_CLASS (scale)->slider_length +
                        widget->style->klass->xthickness) * 2;
  requisition->height = (RANGE_CLASS (scale)->slider_width +
                         widget->style->klass->ythickness * 2);
  
  if (scale->draw_value)
    {
      value_width = gtk_scale_get_value_width (scale);
      
      if ((scale->value_pos == GTK_POS_LEFT) ||
          (scale->value_pos == GTK_POS_RIGHT))
        {
          requisition->width += value_width + SCALE_CLASS (scale)->value_spacing;
          if (requisition->height < (widget->style->font->ascent + widget->style->font->descent))
            requisition->height = widget->style->font->ascent + widget->style->font->descent;
        }
      else if ((scale->value_pos == GTK_POS_TOP) ||
               (scale->value_pos == GTK_POS_BOTTOM))
        {
          if (requisition->width < value_width)
            requisition->width = value_width;
          requisition->height += widget->style->font->ascent + widget->style->font->descent;
        }
    }
}

static void
gtk_hscale_size_allocate (GtkWidget     *widget,
                          GtkAllocation *allocation)
{
  GtkRange *range;
  GtkScale *scale;
  gint width, height;
  gint x, y;
  
  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_HSCALE (widget));
  g_return_if_fail (allocation != NULL);
  
  widget->allocation = *allocation;
  if (GTK_WIDGET_REALIZED (widget))
    {
      range = GTK_RANGE (widget);
      scale = GTK_SCALE (widget);
      
      gtk_hscale_pos_trough (GTK_HSCALE (widget), &x, &y, &width, &height);
      
      gdk_window_move_resize (range->trough, 
                              x + widget->allocation.x, 
                              y + widget->allocation.y, width, height);
      gtk_range_slider_update (GTK_RANGE (widget));
    }
}

static void
gtk_hscale_pos_trough (GtkHScale *hscale,
                       gint      *x,
                       gint      *y,
                       gint      *w,
                       gint      *h)
{
  GtkWidget *widget;
  GtkScale *scale;
  
  g_return_if_fail (hscale != NULL);
  g_return_if_fail (GTK_IS_HSCALE (hscale));
  g_return_if_fail ((x != NULL) && (y != NULL) && (w != NULL) && (h != NULL));
  
  widget = GTK_WIDGET (hscale);
  scale = GTK_SCALE (hscale);
  
  *w = widget->allocation.width;
  *h = (RANGE_CLASS (scale)->slider_width +
        widget->style->klass->ythickness * 2);
  
  if (scale->draw_value)
    {
      *x = 0;
      *y = 0;
      
      switch (scale->value_pos)
        {
        case GTK_POS_LEFT:
          *x += gtk_scale_get_value_width (scale) + SCALE_CLASS (scale)->value_spacing;
          *y = (widget->allocation.height - *h) / 2;
          *w -= *x;
          break;
        case GTK_POS_RIGHT:
          *w -= gtk_scale_get_value_width (scale) + SCALE_CLASS (scale)->value_spacing;
          *y = (widget->allocation.height - *h) / 2;
          break;
        case GTK_POS_TOP:
          *y = (widget->style->font->ascent + widget->style->font->descent +
                (widget->allocation.height - widget->requisition.height) / 2);
          break;
        case GTK_POS_BOTTOM:
          *y = (widget->allocation.height - widget->requisition.height) / 2;
          break;
        }
    }
  else
    {
      *x = 0;
      *y = (widget->allocation.height - *h) / 2;
    }
  *x += 1;
  *w -= 2;
}

static void
gtk_hscale_pos_background (GtkHScale *hscale,
                           gint      *x,
                           gint      *y,
                           gint      *w,
                           gint      *h)
{
  GtkWidget *widget;
  GtkScale *scale;
  
  gint tx, ty, twidth, theight;
  
  g_return_if_fail (hscale != NULL);
  g_return_if_fail (GTK_IS_HSCALE (hscale));
  g_return_if_fail ((x != NULL) && (y != NULL) && (w != NULL) && (h != NULL));
  
  gtk_hscale_pos_trough (hscale, &tx, &ty, &twidth, &theight);
  
  widget = GTK_WIDGET (hscale);
  scale = GTK_SCALE (hscale);
  
  *x = widget->allocation.x;
  *y = widget->allocation.y;
  *w = widget->allocation.width;
  *h = widget->allocation.height;
  
  switch (scale->value_pos)
    {
    case GTK_POS_LEFT:
      *w -= twidth;
      break;
    case GTK_POS_RIGHT:
      *x += twidth;
      *w -= twidth;
      break;
    case GTK_POS_TOP:
      *h -= theight;
      break;
    case GTK_POS_BOTTOM:
      *y += theight;
      *h -= theight;
      break;
    }
}

static void
gtk_hscale_draw_slider (GtkRange *range)
{
  GtkStateType state_type;
  
  g_return_if_fail (range != NULL);
  g_return_if_fail (GTK_IS_HSCALE (range));
  
  if (range->slider)
    {
      if ((range->in_child == RANGE_CLASS (range)->slider) ||
          (range->click_child == RANGE_CLASS (range)->slider))
        state_type = GTK_STATE_PRELIGHT;
      else
        state_type = GTK_STATE_NORMAL;
      
      gtk_paint_slider (GTK_WIDGET (range)->style, range->slider, state_type, 
			GTK_SHADOW_OUT,
			NULL, GTK_WIDGET (range), "hscale",
			0, 0, -1, -1, 
			GTK_ORIENTATION_HORIZONTAL); 
    }
}

static void
gtk_hscale_draw_value (GtkScale *scale)
{
  GtkStateType state_type;
  GtkWidget *widget;
  gchar buffer[32];
  gint text_width;
  gint width, height;
  gint x, y;
  
  g_return_if_fail (scale != NULL);
  g_return_if_fail (GTK_IS_HSCALE (scale));
  
  widget = GTK_WIDGET (scale);
  
  if (scale->draw_value)
    {
      sprintf (buffer, "%0.*f", GTK_RANGE (scale)->digits, GTK_RANGE (scale)->adjustment->value);
      text_width = gdk_string_measure (GTK_WIDGET (scale)->style->font, buffer);
      
      switch (scale->value_pos)
        {
        case GTK_POS_LEFT:
          gdk_window_get_position (GTK_RANGE (scale)->trough, &x, &y);
          gdk_window_get_size (GTK_RANGE (scale)->trough, &width, &height);
          
          x -= SCALE_CLASS (scale)->value_spacing + text_width;
          y += ((height -
                 (GTK_WIDGET (scale)->style->font->ascent +
                  GTK_WIDGET (scale)->style->font->descent)) / 2 +
                GTK_WIDGET (scale)->style->font->ascent);
          break;
        case GTK_POS_RIGHT:
          gdk_window_get_position (GTK_RANGE (scale)->trough, &x, &y);
          gdk_window_get_size (GTK_RANGE (scale)->trough, &width, &height);
          
          x += width + SCALE_CLASS (scale)->value_spacing;
          y += ((height -
                 (GTK_WIDGET (scale)->style->font->ascent +
                  GTK_WIDGET (scale)->style->font->descent)) / 2 +
                GTK_WIDGET (scale)->style->font->ascent);
          break;
        case GTK_POS_TOP:
          gdk_window_get_position (GTK_RANGE (scale)->slider, &x, NULL);
          gdk_window_get_position (GTK_RANGE (scale)->trough, NULL, &y);
          gdk_window_get_size (GTK_RANGE (scale)->slider, &width, NULL);
          gdk_window_get_size (GTK_RANGE (scale)->trough, NULL, &height);
          
          x += widget->allocation.x + (width - text_width) / 2;
	  x = CLAMP (x, widget->allocation.x,
		     widget->allocation.x + widget->allocation.width - text_width);
          y -= GTK_WIDGET (scale)->style->font->descent;
          break;
        case GTK_POS_BOTTOM:
          gdk_window_get_position (GTK_RANGE (scale)->slider, &x, NULL);
          gdk_window_get_position (GTK_RANGE (scale)->trough, NULL, &y);
          gdk_window_get_size (GTK_RANGE (scale)->slider, &width, NULL);
          gdk_window_get_size (GTK_RANGE (scale)->trough, NULL, &height);
          
          x += widget->allocation.x + (width - text_width) / 2;
	  x = CLAMP (x, widget->allocation.x,
		     widget->allocation.x + widget->allocation.width - text_width);
          y += height + GTK_WIDGET (scale)->style->font->ascent;
          break;
        }
      
      state_type = GTK_STATE_NORMAL;
      if (!GTK_WIDGET_IS_SENSITIVE (scale))
        state_type = GTK_STATE_INSENSITIVE;
      
      gtk_paint_string (GTK_WIDGET (scale)->style,
                        GTK_WIDGET (scale)->window,
                        state_type, 
                        NULL, GTK_WIDGET (scale), "hscale", 
                        x, y, buffer);
    }
}

static gint
gtk_hscale_trough_keys (GtkRange *range,
			GdkEventKey *key,
			GtkScrollType *scroll,
			GtkTroughType *pos)
{
  gint return_val = FALSE;
  switch (key->keyval)
    {
    case GDK_Left:
      return_val = TRUE;
      if (key->state & GDK_CONTROL_MASK)
        *scroll = GTK_SCROLL_PAGE_BACKWARD;
      else
        *scroll = GTK_SCROLL_STEP_BACKWARD;
      break;
    case GDK_Right:
      return_val = TRUE;
      if (key->state & GDK_CONTROL_MASK)
        *scroll = GTK_SCROLL_PAGE_FORWARD;
      else
        *scroll = GTK_SCROLL_STEP_FORWARD;
      break;
    case GDK_Home:
      return_val = TRUE;
      *pos = GTK_TROUGH_START;
      break;
    case GDK_End:
      return_val = TRUE;
      *pos = GTK_TROUGH_END;
      break;
    }
  return return_val;
}