gtkentry.c

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

		       gint         start_pos,
		       gint         end_pos)
{
  gtk_entry_queue_draw (GTK_ENTRY(editable));
}

static gchar *    
gtk_entry_get_chars      (GtkEditable   *editable,
			  gint           start_pos,
			  gint           end_pos)
{
  GtkEntry *entry;
  
  g_return_val_if_fail (editable != NULL, NULL);
  g_return_val_if_fail (GTK_IS_ENTRY (editable), NULL);

  entry = GTK_ENTRY (editable);

  if (end_pos < 0)
    end_pos = entry->text_length;

  start_pos = MIN(entry->text_length, start_pos);
  end_pos = MIN(entry->text_length, end_pos);

  if (start_pos <= end_pos)
    {
      guchar *mbstr;
      if (entry->use_wchar)
	{
	  GdkWChar ch;
	  if (end_pos >= entry->text_size)
	    gtk_entry_grow_text(entry);
	  ch = entry->text[end_pos];
	  entry->text[end_pos] = 0;
	  mbstr = gdk_wcstombs (entry->text + start_pos);
	  entry->text[end_pos] = ch;
	  return (gchar *)mbstr;
	}
      else
	{
	  gint i;
	  mbstr = g_new (gchar, end_pos - start_pos + 1);
	  for (i=0; i<end_pos-start_pos; i++)
	    mbstr[i] = entry->text[start_pos + i];
	  mbstr[i] = 0;
	  return (gchar *)mbstr;
	}
    }
  else
    return NULL;
}

static void 
gtk_entry_move_cursor (GtkEditable *editable,
		       gint         x,
		       gint         y)
{
  GtkEntry *entry;
  entry = GTK_ENTRY (editable);

  /* Horizontal motion */
  if ((gint)editable->current_pos < -x)
    editable->current_pos = 0;
  else if (editable->current_pos + x > entry->text_length)
    editable->current_pos = entry->text_length;
  else
    editable->current_pos += x;

  /* Ignore vertical motion */
}

static void
gtk_move_forward_character (GtkEntry *entry)
{
  gtk_entry_move_cursor (GTK_EDITABLE (entry), 1, 0);
}

static void
gtk_move_backward_character (GtkEntry *entry)
{
  gtk_entry_move_cursor (GTK_EDITABLE (entry), -1, 0);
}

static void 
gtk_entry_move_word (GtkEditable *editable,
		     gint         n)
{
  while (n-- > 0)
    gtk_move_forward_word (GTK_ENTRY (editable));
  while (n++ < 0)
    gtk_move_backward_word (GTK_ENTRY (editable));
}

static void
gtk_move_forward_word (GtkEntry *entry)
{
  GtkEditable *editable;
  GdkWChar *text;
  gint i;

  editable = GTK_EDITABLE (entry);

  /* Prevent any leak of information */
  if (!editable->visible)
    {
      editable->current_pos = entry->text_length;
      return;
    }

  if (entry->text && (editable->current_pos < entry->text_length))
    {
      text = entry->text;
      i = editable->current_pos;
	  
      if ((entry->use_wchar) ? (!gdk_iswalnum (text[i])) : (!isalnum (text[i])))
	for (; i < entry->text_length; i++)
	  {
	    if ((entry->use_wchar) ? gdk_iswalnum (text[i]) : isalnum (text[i]))
	      break;
	  }

      for (; i < entry->text_length; i++)
	{
	  if ((entry->use_wchar) ? (!gdk_iswalnum (text[i])) : (!isalnum (text[i])))
	    break;
	}

      editable->current_pos = i;
    }
}

static void
gtk_move_backward_word (GtkEntry *entry)
{
  GtkEditable *editable;
  GdkWChar *text;
  gint i;

  editable = GTK_EDITABLE (entry);

  /* Prevent any leak of information */
  if (!editable->visible)
    {
      editable->current_pos = 0;
      return;
    }

  if (entry->text && editable->current_pos > 0)
    {
      text = entry->text;
      i = editable->current_pos - 1;
      if ((entry->use_wchar) ? (!gdk_iswalnum (text[i])) : (!isalnum (text[i])))
	for (; i >= 0; i--)
	  {
	    if ((entry->use_wchar) ? gdk_iswalnum (text[i]) : isalnum (text[i]))
	      break;
	  }
      for (; i >= 0; i--)
	{
	  if ((entry->use_wchar) ? (!gdk_iswalnum (text[i])) : (!isalnum (text[i])))
	    {
	      i++;
	      break;
	    }
	}
	  
      if (i < 0)
	i = 0;
	  
      editable->current_pos = i;
    }
}

static void
gtk_entry_move_to_column (GtkEditable *editable, gint column)
{
  GtkEntry *entry;

  entry = GTK_ENTRY (editable);
  
  if (column < 0 || column > entry->text_length)
    editable->current_pos = entry->text_length;
  else
    editable->current_pos = column;
}

static void
gtk_move_beginning_of_line (GtkEntry *entry)
{
  gtk_entry_move_to_column (GTK_EDITABLE (entry), 0);
}

static void
gtk_move_end_of_line (GtkEntry *entry)
{
  gtk_entry_move_to_column (GTK_EDITABLE (entry), -1);
}

static void
gtk_entry_kill_char (GtkEditable *editable,
		     gint         direction)
{
  if (editable->selection_start_pos != editable->selection_end_pos)
    gtk_editable_delete_selection (editable);
  else
    {
      gint old_pos = editable->current_pos;
      if (direction >= 0)
	{
	  gtk_entry_move_cursor (editable, 1, 0);
	  gtk_editable_delete_text (editable, old_pos, editable->current_pos);
	}
      else
	{
	  gtk_entry_move_cursor (editable, -1, 0);
	  gtk_editable_delete_text (editable, editable->current_pos, old_pos);
	}
    }
}

static void
gtk_delete_forward_character (GtkEntry *entry)
{
  gtk_entry_kill_char (GTK_EDITABLE (entry), 1);
}

static void
gtk_delete_backward_character (GtkEntry *entry)
{
  gtk_entry_kill_char (GTK_EDITABLE (entry), -1);
}

static void
gtk_entry_kill_word (GtkEditable *editable,
		     gint         direction)
{
  if (editable->selection_start_pos != editable->selection_end_pos)
    gtk_editable_delete_selection (editable);
  else
    {
      gint old_pos = editable->current_pos;
      if (direction >= 0)
	{
	  gtk_entry_move_word (editable, 1);
	  gtk_editable_delete_text (editable, old_pos, editable->current_pos);
	}
      else
	{
	  gtk_entry_move_word (editable, -1);
	  gtk_editable_delete_text (editable, editable->current_pos, old_pos);
	}
    }
}

static void
gtk_delete_forward_word (GtkEntry *entry)
{
  gtk_entry_kill_word (GTK_EDITABLE (entry), 1);
}

static void
gtk_delete_backward_word (GtkEntry *entry)
{
  gtk_entry_kill_word (GTK_EDITABLE (entry), -1);
}

static void
gtk_entry_kill_line (GtkEditable *editable,
		     gint         direction)
{
  gint old_pos = editable->current_pos;
  if (direction >= 0)
    {
      gtk_entry_move_to_column (editable, -1);
      gtk_editable_delete_text (editable, old_pos, editable->current_pos);
    }
  else
    {
      gtk_entry_move_to_column (editable, 0);
      gtk_editable_delete_text (editable, editable->current_pos, old_pos);
    }
}

static void
gtk_delete_line (GtkEntry *entry)
{
  gtk_entry_move_to_column (GTK_EDITABLE (entry), 0);
  gtk_entry_kill_line (GTK_EDITABLE (entry), 1);
}

static void
gtk_delete_to_line_end (GtkEntry *entry)
{
  gtk_editable_delete_text (GTK_EDITABLE(entry), GTK_EDITABLE(entry)->current_pos, entry->text_length);
}

static void
gtk_select_word (GtkEntry *entry,
		 guint32   time)
{
  GtkEditable *editable;
  gint start_pos;
  gint end_pos;

  editable = GTK_EDITABLE (entry);

  gtk_move_backward_word (entry);
  start_pos = editable->current_pos;

  gtk_move_forward_word (entry);
  end_pos = editable->current_pos;

  editable->has_selection = TRUE;
  gtk_entry_set_selection (editable, start_pos, end_pos);
  gtk_editable_claim_selection (editable, start_pos != end_pos, time);
}

static void
gtk_select_line (GtkEntry *entry,
		 guint32   time)
{
  GtkEditable *editable;

  editable = GTK_EDITABLE (entry);

  editable->has_selection = TRUE;
  gtk_entry_set_selection (editable, 0, entry->text_length);
  gtk_editable_claim_selection (editable, entry->text_length != 0, time);

  editable->current_pos = editable->selection_end_pos;
}

static void 
gtk_entry_set_selection (GtkEditable       *editable,
			 gint               start,
			 gint               end)
{
  g_return_if_fail (editable != NULL);
  g_return_if_fail (GTK_IS_ENTRY (editable));

  if (end < 0)
    end = GTK_ENTRY (editable)->text_length;
  
  editable->selection_start_pos = start;
  editable->selection_end_pos = end;

  gtk_entry_queue_draw (GTK_ENTRY (editable));
}

void       
gtk_entry_select_region  (GtkEntry       *entry,
			  gint            start,
			  gint            end)
{
  gtk_editable_select_region (GTK_EDITABLE (entry), start, end);
}

void
gtk_entry_set_max_length (GtkEntry     *entry,
                          guint16       max)
{
  g_return_if_fail (entry != NULL);
  g_return_if_fail (GTK_IS_ENTRY (entry));

  if (max && entry->text_length > max)
  	gtk_editable_delete_text(GTK_EDITABLE(entry), max, -1);
  entry->text_max_length = max;
}

#ifdef USE_XIM
static void
gtk_entry_update_ic_attr (GtkWidget *widget)
{
  GtkEditable *editable = (GtkEditable *) widget;
  GdkICAttributesType mask = 0;

  if (editable->ic == NULL)
    return;

  gdk_ic_get_attr (editable->ic, editable->ic_attr,
		   GDK_IC_PREEDIT_FOREGROUND |
		   GDK_IC_PREEDIT_BACKGROUND |
		   GDK_IC_PREEDIT_FONTSET);

  if (editable->ic_attr->preedit_foreground.pixel != 
      widget->style->fg[GTK_STATE_NORMAL].pixel)
    {
      mask |= GDK_IC_PREEDIT_FOREGROUND;
      editable->ic_attr->preedit_foreground
	= widget->style->fg[GTK_STATE_NORMAL];
    }
  if (editable->ic_attr->preedit_background.pixel != 
      widget->style->base[GTK_STATE_NORMAL].pixel)
    {
      mask |= GDK_IC_PREEDIT_BACKGROUND;
      editable->ic_attr->preedit_background
	= widget->style->base[GTK_STATE_NORMAL];
    }
  if ((gdk_ic_get_style (editable->ic) & GDK_IM_PREEDIT_POSITION) && 
      widget->style->font != NULL &&
      widget->style->font->type == GDK_FONT_FONTSET &&
      !gdk_font_equal (editable->ic_attr->preedit_fontset,
		       widget->style->font))
    {
      mask |= GDK_IC_PREEDIT_FONTSET;
      editable->ic_attr->preedit_fontset = widget->style->font;
    }
  
  if (mask)
    gdk_ic_set_attr (editable->ic, editable->ic_attr, mask);
}
#endif /* USE_XIM */
    			  
static void 
gtk_entry_style_set	(GtkWidget      *widget,
			 GtkStyle       *previous_style)
{
  GtkEntry *entry;
  gint scroll_char;

  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_ENTRY (widget));

  if (previous_style && GTK_WIDGET_REALIZED (widget))
    {
      entry = GTK_ENTRY (widget);
  
      scroll_char = gtk_entry_find_position (entry, entry->scroll_offset);
      gtk_entry_recompute_offsets (GTK_ENTRY (widget));
      entry->scroll_offset = entry->char_offset[scroll_char];
      entry_adjust_scroll (entry);

      gdk_window_set_background (widget->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
      gdk_window_set_background (entry->text_area, &widget->style->base[GTK_WIDGET_STATE (widget)]);

#ifdef USE_XIM
      gtk_entry_update_ic_attr (widget);
#endif
    }
}

static void
gtk_entry_state_changed (GtkWidget      *widget,
			 GtkStateType    previous_state)
{
  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_ENTRY (widget));

  if (GTK_WIDGET_REALIZED (widget))
    {
      gdk_window_set_background (widget->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
      gdk_window_set_background (GTK_ENTRY (widget)->text_area, &widget->style->base[GTK_WIDGET_STATE (widget)]);

#ifdef USE_XIM
      gtk_entry_update_ic_attr (widget);
#endif
    }

  if (GTK_WIDGET_DRAWABLE (widget))
    gtk_widget_queue_clear(widget);
}