JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GdkTextLayout_indexToPos
  (JNIEnv *env, jobject self, jint idx, jdoubleArray javaPos)
{
  struct textlayout *tl;
  PangoRectangle pangoPos;
  jdouble *nativePos;

  gdk_threads_enter ();
  g_assert(self != NULL);
  g_assert(javaPos != NULL);

  tl = (struct textlayout *)NSA_GET_TEXT_LAYOUT_PTR (env, self);
  g_assert(tl != NULL);
  g_assert(tl->pango_layout != NULL);
  
  g_assert((*env)->GetArrayLength (env, javaPos) == 4);

  nativePos = (*env)->GetDoubleArrayElements (env, javaPos, NULL);    

  pango_layout_index_to_pos (tl->pango_layout, idx, &pangoPos);

  nativePos[0] = (jdouble) pangoPos.x;
  nativePos[1] = (jdouble) pangoPos.y;
  nativePos[2] = (jdouble) pangoPos.width;
  nativePos[3] = (jdouble) pangoPos.height;

  (*env)->ReleaseDoubleArrayElements (env, javaPos, nativePos, 0);
  gdk_threads_leave ();  
}
Ejemplo n.º 2
0
/**
 * Find the position in a string where an x coordinate falls.
 *
 * \param[in] fstyle style for this text
 * \param[in] string UTF-8 string to measure
 * \param[in] length length of string, in bytes
 * \param[in] x coordinate to search for
 * \param[out] char_offset updated to offset in string of actual_x, [0..length]
 * \param[out] actual_x updated to x coordinate of character closest to x
 * \return NSERROR_OK and char_offset and actual_x updated or appropriate
 *          error code on faliure
 */
static nserror
nsfont_position_in_string(const plot_font_style_t *fstyle,
			  const char *string,
			  size_t length,
			  int x,
			  size_t *char_offset,
			  int *actual_x)
{
	int index;
	PangoFontDescription *desc;
	PangoRectangle pos;

	nsfont_pango_check();

	desc = nsfont_style_to_description(fstyle);
	pango_layout_set_font_description(nsfont_pango_layout, desc);
	pango_font_description_free(desc);

	pango_layout_set_text(nsfont_pango_layout, string, length);

	if (pango_layout_xy_to_index(nsfont_pango_layout,
				     x * PANGO_SCALE, 
				     0, &index, 0) == FALSE) {
		index = length;
	}

	pango_layout_index_to_pos(nsfont_pango_layout, index, &pos);

	*char_offset = index;
	*actual_x = PANGO_PIXELS(pos.x);

	return NSERROR_OK;
}
Ejemplo n.º 3
0
Archivo: gailscale.c Proyecto: BYC/gtk
static void
gail_scale_get_character_extents (AtkText      *text,
				  gint         offset,
		                  gint         *x,
                    		  gint 	       *y,
                                  gint 	       *width,
                                  gint 	       *height,
			          AtkCoordType coords)
{
  GtkWidget *widget;
  GtkScale *scale;
  PangoRectangle char_rect;
  PangoLayout *layout;
  gint index, x_layout, y_layout;
  const gchar *scale_text;
 
  widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));

  if (widget == NULL)
    /* State is defunct */
    return;

  scale = GTK_SCALE (widget);
  layout = gtk_scale_get_layout (scale);
  if (!layout)
    return;
  scale_text = pango_layout_get_text (layout);
  if (!scale_text)
    return;
  index = g_utf8_offset_to_pointer (scale_text, offset) - scale_text;
  gtk_scale_get_layout_offsets (scale, &x_layout, &y_layout);
  pango_layout_index_to_pos (layout, index, &char_rect);
  gail_misc_get_extents_from_pango_rectangle (widget, &char_rect, 
                    x_layout, y_layout, x, y, width, height, coords);
} 
Ejemplo n.º 4
0
static void
gail_expander_get_character_extents (AtkText      *text,
				     gint         offset,
		                     gint         *x,
                    		     gint 	*y,
                                     gint 	*width,
                                     gint 	*height,
			             AtkCoordType coords)
{
  GtkWidget *widget;
  GtkWidget *label;
  PangoRectangle char_rect;
  gint index, x_layout, y_layout;
  const gchar *label_text;
 
  widget = GTK_ACCESSIBLE (text)->widget;

  if (widget == NULL)
    /* State is defunct */
    return;

  label = gtk_expander_get_label_widget (GTK_EXPANDER (widget));
  if (!GTK_IS_LABEL(label))
    return;
  
  gtk_label_get_layout_offsets (GTK_LABEL (label), &x_layout, &y_layout);
  label_text = gtk_label_get_text (GTK_LABEL (label));
  index = g_utf8_offset_to_pointer (label_text, offset) - label_text;
  pango_layout_index_to_pos (gtk_label_get_layout (GTK_LABEL (label)), index, &char_rect);
  
  gail_misc_get_extents_from_pango_rectangle (label, &char_rect, 
                    x_layout, y_layout, x, y, width, height, coords);
} 
int unicodeGetXRanges(char *utf8, int utf8Length, int *resultPtr, int resultLength) {
	int w, h, offsetX, offsetY;
	int count, ch, i, j;
	PangoRectangle rect;

	count = unicodeLength(utf8, utf8Length);
	if (resultLength < (2 * count)) return -1;

	if (cachedLayout == NULL) {
		cairo_surface_t *surface = cairo_image_surface_create(CAIRO_FORMAT_A8, 1, 1);
		cairo_t *cr = cairo_create(surface);
		cachedLayout = pango_cairo_create_layout(cr);
	}

	computeLayout(cachedLayout, utf8, utf8Length, &w, &h, &offsetX, &offsetY, NULL);

	i = j = 0;
	while ((i < utf8Length) && (j < (resultLength - 1))) {
		pango_layout_index_to_pos(cachedLayout, i, &rect);
		ch = utf8[i];
		if ((ch & 0xE0) == 0xC0) i += 2;
		else if ((ch & 0xF0) == 0xE0) i += 3;
		else if ((ch & 0xF8) == 0xF0) i += 4;
		else i += 1;
		resultPtr[j] = PANGO_PIXELS(rect.x);
		resultPtr[j + 1] = PANGO_PIXELS(rect.x + rect.width);
		j += 2;
	}

	return count;
}
Ejemplo n.º 6
0
static VALUE
rg_index_to_pos(VALUE self, VALUE index)
{
    PangoRectangle pos;
    pango_layout_index_to_pos(_SELF(self), NUM2INT(index), &pos);
    return BOXED2RVAL(&pos, PANGO_TYPE_RECTANGLE);
}
Ejemplo n.º 7
0
static void
gail_notebook_page_get_character_extents (AtkText      *text,
				          gint         offset,
		                          gint         *x,
                    		          gint         *y,
                                          gint 	       *width,
                                          gint 	       *height,
			                  AtkCoordType coords)
{
  GtkWidget *label;
  GailNotebookPage *notebook_page;
  PangoRectangle char_rect;
  gint index, x_layout, y_layout;
  const gchar *label_text;
 
  notebook_page = GAIL_NOTEBOOK_PAGE (text);
  label = get_label_from_notebook_page (notebook_page);

  if (!GTK_IS_LABEL(label))
    return;
  
  gtk_label_get_layout_offsets (GTK_LABEL (label), &x_layout, &y_layout);
  label_text = gtk_label_get_text (GTK_LABEL (label));
  index = g_utf8_offset_to_pointer (label_text, offset) - label_text;
  pango_layout_index_to_pos (gtk_label_get_layout (GTK_LABEL (label)), index, &char_rect);
  
  gail_misc_get_extents_from_pango_rectangle (label, &char_rect, 
                    x_layout, y_layout, x, y, width, height, coords);
} 
Ejemplo n.º 8
0
/* Given a paragraph and offset in that paragraph, find the
 * bounding rectangle for the character at the offset.
 */ 
void
char_bounds (Paragraph *para, int index, int width, PangoRectangle *rect)
{
  GList *para_list;
  
  int height = 0;
  
  para_list = paragraphs;
  while (para_list)
    {
      Paragraph *cur_para = para_list->data;
      
      if (cur_para == para)
	{
	  PangoRectangle pos;

	  pango_layout_index_to_pos (cur_para->layout, index, &pos);

	  rect->x = PANGO_PIXELS (MIN (pos.x, pos.x + pos.width));
	  rect->width = PANGO_PIXELS (ABS (pos.width));
	  rect->y = height + PANGO_PIXELS (pos.y);
	  rect->height = PANGO_PIXELS (pos.height);
	}
      
      height += cur_para->height;
      para_list = para_list->next;
    }
}
Ejemplo n.º 9
0
static void      
gail_text_cell_get_character_extents (AtkText          *text,
                                      gint             offset,
                                      gint             *x,
                                      gint             *y,
                                      gint             *width,
                                      gint             *height,
                                      AtkCoordType     coords)
{
  GailRendererCell *gail_renderer; 
  GtkCellRendererText *gtk_renderer;
  GdkRectangle rendered_rect;
  GtkWidget *widget;
  AtkObject *parent;
  PangoRectangle char_rect;
  PangoLayout *layout;
  gint x_offset, y_offset, index, cell_height, cell_width;

  if (!GAIL_TEXT_CELL (text)->cell_text)
    {
      *x = *y = *height = *width = 0;
      return;
    }
  if (offset < 0 || offset >= GAIL_TEXT_CELL (text)->cell_length)
    {
      *x = *y = *height = *width = 0;
      return;
    }
  gail_renderer = GAIL_RENDERER_CELL (text);
  gtk_renderer = GTK_CELL_RENDERER_TEXT (gail_renderer->renderer);
  /*
   * Thus would be inconsistent with the cache
   */
  gail_return_if_fail (gtk_renderer->text);

  parent = atk_object_get_parent (ATK_OBJECT (text));
  if (GAIL_IS_CONTAINER_CELL (parent))
    parent = atk_object_get_parent (parent);
  widget = GTK_ACCESSIBLE (parent)->widget;
  g_return_if_fail (GAIL_IS_CELL_PARENT (parent));
  gail_cell_parent_get_cell_area (GAIL_CELL_PARENT (parent), GAIL_CELL (text),
                                  &rendered_rect);

  gtk_cell_renderer_get_size (GTK_CELL_RENDERER (gtk_renderer), widget,
    &rendered_rect, &x_offset, &y_offset, &cell_width, &cell_height);
  layout = create_pango_layout (gtk_renderer, widget);

  index = g_utf8_offset_to_pointer (gtk_renderer->text,
    offset) - gtk_renderer->text;
  pango_layout_index_to_pos (layout, index, &char_rect); 

  gail_misc_get_extents_from_pango_rectangle (widget,
      &char_rect,
      x_offset + rendered_rect.x + gail_renderer->renderer->xpad,
      y_offset + rendered_rect.y + gail_renderer->renderer->ypad,
      x, y, width, height, coords);
  g_object_unref (layout);
  return;
} 
Ejemplo n.º 10
0
vector<XojPdfRectangle> TextView::findText(Text* t, string& search)
{
	cairo_surface_t* surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 1, 1);
	cairo_t* cr = cairo_create(surface);

	PangoLayout* layout = initPango(cr, t);
	string str = t->getText();
	pango_layout_set_text(layout, str.c_str(), str.length());


	string text = t->getText();

	string srch = StringUtils::toLowerCase(search);

	vector<XojPdfRectangle> list;

	int pos = -1;
	do
	{
		pos = StringUtils::toLowerCase(text).find(srch, pos + 1);
		if (pos != -1)
		{
			XojPdfRectangle mark;
			PangoRectangle rect = { 0 };
			pango_layout_index_to_pos(layout, pos, &rect);
			mark.x1 = ((double) rect.x) / PANGO_SCALE + t->getX();
			mark.y1 = ((double) rect.y) / PANGO_SCALE + t->getY();

			pango_layout_index_to_pos(layout, pos + srch.length(), &rect);
			mark.x2 = ((double) rect.x + rect.width) / PANGO_SCALE + t->getX();
			mark.y2 = ((double) rect.y + rect.height) / PANGO_SCALE + t->getY();

			list.push_back(mark);
		}
	}
	while (pos != -1);

	g_object_unref(layout);
	cairo_surface_destroy(surface);
	cairo_destroy(cr);

	return list;
}
Ejemplo n.º 11
0
GList * TextView::findText(Text * t, const char * search) {
	cairo_surface_t * surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 1, 1);
	cairo_t * cr = cairo_create(surface);

	GList * list = NULL;

	PangoLayout * layout = initPango(cr, t);
	String str = t->getText();
	pango_layout_set_text(layout, str.c_str(), str.size());

	int pos = -1;

	String text = t->getText();

	String srch = search;

	do {
		pos = text.indexOfCaseInsensitiv(srch, pos + 1);
		if (pos != -1) {
			XojPopplerRectangle * mark = new XojPopplerRectangle();
			PangoRectangle rect = { 0 };
			pango_layout_index_to_pos(layout, pos, &rect);
			mark->x1 = ((double) rect.x) / PANGO_SCALE + t->getX();
			mark->y1 = ((double) rect.y) / PANGO_SCALE + t->getY();

			pango_layout_index_to_pos(layout, pos + srch.length(), &rect);
			mark->x2 = ((double) rect.x + rect.width) / PANGO_SCALE + t->getX();
			mark->y2 = ((double) rect.y + rect.height) / PANGO_SCALE + t->getY();

			list = g_list_append(list, mark);
		}
	} while (pos != -1);

	g_object_unref(layout);
	cairo_surface_destroy(surface);
	cairo_destroy(cr);

	return list;
}
Ejemplo n.º 12
0
static void
gtk_label_accessible_get_character_extents (AtkText      *text,
                                            gint          offset,
                                            gint         *x,
                                            gint         *y,
                                            gint         *width,
                                            gint         *height,
                                            AtkCoordType  coords)
{
  GtkWidget *widget;
  GtkLabel *label;
  PangoRectangle char_rect;
  const gchar *label_text;
  gint index, x_layout, y_layout;
  GdkWindow *window;
  gint x_window, y_window;

  widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
  if (widget == NULL)
    return;

  label = GTK_LABEL (widget);

  gtk_label_get_layout_offsets (label, &x_layout, &y_layout);
  label_text = gtk_label_get_text (label);
  index = g_utf8_offset_to_pointer (label_text, offset) - label_text;
  pango_layout_index_to_pos (gtk_label_get_layout (label), index, &char_rect);
  pango_extents_to_pixels (&char_rect, NULL);

  window = gtk_widget_get_window (widget);
  gdk_window_get_origin (window, &x_window, &y_window);

  *x = x_window + x_layout + char_rect.x;
  *y = x_window + y_layout + char_rect.y;
  *width = char_rect.width;
  *height = char_rect.height;

  if (coords == ATK_XY_WINDOW)
    {
      window = gdk_window_get_toplevel (window);
      gdk_window_get_origin (window, &x_window, &y_window);

      *x -= x_window;
      *y -= y_window;
    }
}
Ejemplo n.º 13
0
static void
gtk_icon_view_item_accessible_get_character_extents (AtkText      *text,
                                                     gint         offset,
                                                     gint         *x,
                                                     gint         *y,
                                                     gint         *width,
                                                     gint         *height,
                                                     AtkCoordType coord_type)
{
  GtkIconViewItemAccessible *item;
#if 0
  GtkIconView *icon_view;
  PangoRectangle char_rect;
  const gchar *item_text;
  gint index;
#endif

  item = GTK_ICON_VIEW_ITEM_ACCESSIBLE (text);

  if (!GTK_IS_ICON_VIEW (item->widget))
    return;

  if (atk_state_set_contains_state (item->state_set, ATK_STATE_DEFUNCT))
    return;

#if 0
  icon_view = GTK_ICON_VIEW (item->widget);
      /* FIXME we probably have to use GailTextCell to salvage this */
  gtk_icon_view_update_item_text (icon_view, item->item);
  item_text = pango_layout_get_text (icon_view->priv->layout);
  index = g_utf8_offset_to_pointer (item_text, offset) - item_text;
  pango_layout_index_to_pos (icon_view->priv->layout, index, &char_rect);

  atk_component_get_position (ATK_COMPONENT (text), x, y, coord_type);
  *x += item->item->layout_x - item->item->x + char_rect.x / PANGO_SCALE;
  /* Look at gtk_icon_view_paint_item() to see where the text is. */
  *x -=  ((item->item->width - item->item->layout_width) / 2) + (MAX (item->item->pixbuf_width, icon_view->priv->item_width) - item->item->width) / 2,
  *y += item->item->layout_y - item->item->y + char_rect.y / PANGO_SCALE;
  *width = char_rect.width / PANGO_SCALE;
  *height = char_rect.height / PANGO_SCALE;
#endif
}
Ejemplo n.º 14
0
void
gimp_text_tool_editor_get_cursor_rect (GimpTextTool   *text_tool,
                                       gboolean        overwrite,
                                       PangoRectangle *cursor_rect)
{
  GtkTextBuffer *buffer = GTK_TEXT_BUFFER (text_tool->buffer);
  PangoLayout   *layout;
  gint           offset_x;
  gint           offset_y;
  GtkTextIter    cursor;
  gint           cursor_index;

  g_return_if_fail (GIMP_IS_TEXT_TOOL (text_tool));
  g_return_if_fail (cursor_rect != NULL);

  gtk_text_buffer_get_iter_at_mark (buffer, &cursor,
                                    gtk_text_buffer_get_insert (buffer));
  cursor_index = gimp_text_buffer_get_iter_index (text_tool->buffer, &cursor,
                                                  TRUE);

  gimp_text_tool_ensure_layout (text_tool);

  layout = gimp_text_layout_get_pango_layout (text_tool->layout);

  gimp_text_layout_get_offsets (text_tool->layout, &offset_x, &offset_y);

  if (overwrite)
    pango_layout_index_to_pos (layout, cursor_index, cursor_rect);
  else
    pango_layout_get_cursor_pos (layout, cursor_index, cursor_rect, NULL);

  gimp_text_layout_transform_rect (text_tool->layout, cursor_rect);

  cursor_rect->x      = PANGO_PIXELS (cursor_rect->x) + offset_x;
  cursor_rect->y      = PANGO_PIXELS (cursor_rect->y) + offset_y;
  cursor_rect->width  = PANGO_PIXELS (cursor_rect->width);
  cursor_rect->height = PANGO_PIXELS (cursor_rect->height);
}
Ejemplo n.º 15
0
GpStatus
pango_MeasureCharacterRanges (GpGraphics *graphics, GDIPCONST WCHAR *stringUnicode, int length, GDIPCONST GpFont *font,
	GDIPCONST GpRectF *layoutRect, GDIPCONST GpStringFormat *format, int regionCount, GpRegion **regions)
{
	PangoLayout *layout;
	GpStatus status = Ok;
	int i, j;
	GpRectF boundingBox;

	cairo_save (graphics->ct);

	layout = gdip_pango_setup_layout (graphics, stringUnicode, length, font, layoutRect, &boundingBox, format, NULL);
	if (!layout) {
		cairo_restore (graphics->ct);
		return OutOfMemory;
	}

	/* Create a region for every char range */
	for (i = 0; i < format->charRangeCount; i++) {
		int start, end;
		CharacterRange range = format->charRanges [i];

		GdipSetEmpty (regions [i]);

		if (range.Length > 0)
			start = range.First;
		else
			start = range.First + range.Length;

		end = start + range.Length;

		/* sanity check on charRange. negative lengths are allowed */
		if (range.First < 0) {
			status = InvalidParameter;
			goto cleanup;
		}

		if ((start < 0) || (end > length)) {
			status = InvalidParameter;
			goto cleanup;
		}

		/* calculate the initial UTF-8 index */
		int idxUtf8 = utf8_length_for_ucs2_string (stringUnicode, 0, start);

		/* calculate the regions */
		for (j = start; j < end; j++) {
			PangoRectangle box;
			GpRectF charRect;

			pango_layout_index_to_pos (layout, idxUtf8, &box);
			charRect.X = (float)box.x / PANGO_SCALE;
			charRect.Y = (float)box.y / PANGO_SCALE;
			charRect.Width = (float)box.width / PANGO_SCALE;
			charRect.Height = (float)box.height / PANGO_SCALE;
			/* Normalize values (width/height can be negative) */
			if (charRect.Width < 0) {
				charRect.Width = -charRect.Width;
				charRect.X -= charRect.Width;
			}
			if (charRect.Height < 0) {
				charRect.Height = -charRect.Height;
				charRect.Y -= charRect.Height;
			}
// g_warning ("[%d] [%d : %d-%d] %c [x %g y %g w %g h %g]", i, j, start, end, (char)stringUnicode[j], charRect.X, charRect.Y, charRect.Width, charRect.Height);
			status = GdipCombineRegionRect (regions [i], &charRect, CombineModeUnion);
			if (status != Ok)
				break;

			// update the UTF-8 index
			idxUtf8 += utf8_length_for_ucs2_string (stringUnicode, j, 1);
		}
		if (status != Ok)
			break;
	}

cleanup:
	cairo_restore (graphics->ct);
	return status;
}
Ejemplo n.º 16
0
static void
gtk_text_cell_accessible_get_character_extents (AtkText      *text,
                                                gint          offset,
                                                gint         *x,
                                                gint         *y,
                                                gint         *width,
                                                gint         *height,
                                                AtkCoordType  coords)
{
  GtkRendererCellAccessible *gail_renderer;
  GtkRequisition min_size;
  GtkCellRendererText *gtk_renderer;
  GdkRectangle rendered_rect;
  GtkWidget *widget;
  AtkObject *parent;
  PangoRectangle char_rect;
  PangoLayout *layout;
  gchar *renderer_text;
  gfloat xalign, yalign;
  gint x_offset, y_offset, index;
  gint xpad, ypad;
  gint x_window, y_window, x_toplevel, y_toplevel;

  if (!GTK_TEXT_CELL_ACCESSIBLE (text)->cell_text)
    {
      *x = *y = *height = *width = 0;
      return;
    }
  if (offset < 0 || offset >= GTK_TEXT_CELL_ACCESSIBLE (text)->cell_length)
    {
      *x = *y = *height = *width = 0;
      return;
    }
  gail_renderer = GTK_RENDERER_CELL_ACCESSIBLE (text);
  gtk_renderer = GTK_CELL_RENDERER_TEXT (gail_renderer->renderer);

  g_object_get (gtk_renderer, "text", &renderer_text, NULL);
  if (text == NULL)
    {
      g_free (renderer_text);
      return;
    }

  parent = atk_object_get_parent (ATK_OBJECT (text));
  if (GTK_IS_CONTAINER_CELL_ACCESSIBLE (parent))
    parent = atk_object_get_parent (parent);
  widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (parent));
  g_return_if_fail (GTK_IS_CELL_ACCESSIBLE_PARENT (parent));
  _gtk_cell_accessible_parent_get_cell_area (GTK_CELL_ACCESSIBLE_PARENT (parent),
                                             GTK_CELL_ACCESSIBLE (text),
                                             &rendered_rect);

  gtk_cell_renderer_get_preferred_size (GTK_CELL_RENDERER (gtk_renderer),
                                        widget,
                                        &min_size, NULL);

  gtk_cell_renderer_get_alignment (GTK_CELL_RENDERER (gtk_renderer), &xalign, &yalign);
  if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
    xalign = 1.0 - xalign;
  x_offset = MAX (0, xalign * (rendered_rect.width - min_size.width));
  y_offset = MAX (0, yalign * (rendered_rect.height - min_size.height));

  layout = create_pango_layout (GTK_TEXT_CELL_ACCESSIBLE (text));

  index = g_utf8_offset_to_pointer (renderer_text, offset) - renderer_text;
  pango_layout_index_to_pos (layout, index, &char_rect);

  gtk_cell_renderer_get_padding (gail_renderer->renderer, &xpad, &ypad);

  get_origins (widget, &x_window, &y_window, &x_toplevel, &y_toplevel);

  *x = (char_rect.x / PANGO_SCALE) + x_offset + rendered_rect.x + xpad + x_window;
  *y = (char_rect.y / PANGO_SCALE) + y_offset + rendered_rect.y + ypad + y_window;
  *height = char_rect.height / PANGO_SCALE;
  *width = char_rect.width / PANGO_SCALE;

  if (coords == ATK_XY_WINDOW)
    {
      *x -= x_toplevel;
      *y -= y_toplevel;
    }
  else if (coords != ATK_XY_SCREEN)
    {
      *x = 0;
      *y = 0;
      *height = 0;
      *width = 0;
    }

  g_free (renderer_text);
  g_object_unref (layout);
}
Ejemplo n.º 17
0
/* Redraw the contents of the lcd display. 
 * note: start BORDER pixels down and to the right.
 * TODO: we could be smart and only redraw what has changed. 
 * This does this work correctly with varriable sized fonts.
 */
void drawStackLCD(){
   int i;
   int curPos;
   int strt, stop;
   GdkGC *drawgc;
#ifdef USE_PANGO
   PangoRectangle rect;
   int pango_pos;
#endif

   /* draw the stack */
   for(i=0; i<lcdHeight; i++){

      /* draw the first unhighlighted section of the line */
      strt = 0;
      if(dataSelected == DATA_SELECTED && i>=hiY1 && i<=hiY2){
         stop = hiX1;
         if(stop > lcdWidth) stop = lcdWidth;
      } else {
         stop = lcdWidth;
      }
      if(stop-strt){
#ifdef USE_PANGO
         pango_layout_index_to_pos(pango_layout, strt, &rect);
         pango_pos = rect.x / PANGO_SCALE;
         gdk_window_clear_area(lcdDA->window, 
            pango_pos + BORDER, i*fontH + BORDER,
            2*fontW*(stop-strt), fontH);
         pango_layout_set_text(pango_layout,  &lcdText[i][strt], stop-strt);
         gdk_draw_layout(lcdDA->window, lcdGC,
            pango_pos + BORDER + SHIFT, i*fontH + BORDER,
	    pango_layout);
#else
         gdk_window_clear_area(lcdDA->window, 
            strt*fontW + BORDER, i*fontH + BORDER,
            fontW*(stop-strt), fontH);
         gdk_draw_text(lcdDA->window, lcdFont, lcdGC,
            strt*fontW + BORDER, (i+1)*fontH - fontD + BORDER,
            &lcdText[i][strt], stop-strt);
#endif
      }

      /* draw the highlighted section of the line */
      if(dataSelected == DATA_SELECTED && i>=hiY1 && i<=hiY2){
	 strt = hiX1;
         if(strt > lcdWidth) strt = lcdWidth;
	 stop = hiX2+1;
         if(stop > lcdWidth) stop = lcdWidth;
         if(stop-strt){            
#ifdef USE_PANGO
            pango_layout_index_to_pos(pango_layout, strt, &rect);
            pango_pos = rect.x / PANGO_SCALE;
            gdk_window_clear_area(lcdDA->window, 
               pango_pos + BORDER, i*fontH + BORDER,
               2*fontW*(stop-strt), fontH);
            gdk_draw_rectangle(lcdDA->window, lcdGC, TRUE,
               pango_pos + BORDER + SHIFT, i*fontH + BORDER,
               fontW*(stop-strt), fontH);
            pango_layout_set_text(pango_layout,  &lcdText[i][strt], stop-strt);
            gdk_draw_layout(lcdDA->window, lcdHighlightGC,
               strt*fontW + BORDER + SHIFT, i*fontH + BORDER,
	       pango_layout);
#else
            gdk_draw_rectangle(lcdDA->window, lcdGC, TRUE,
               strt*fontW + BORDER, i*fontH + BORDER,
               fontW*(stop-strt), fontH);
	    gdk_draw_text(lcdDA->window, lcdFont, lcdHighlightGC,
	       strt*fontW + BORDER, (i+1)*fontH - fontD + BORDER,
	       &lcdText[i][strt], stop-strt);
#endif
         }
      }

      /* draw the last unhighlighted section of the line */
      stop = lcdWidth;
      if(dataSelected == DATA_SELECTED && i>=hiY1 && i<=hiY2){
         strt = hiX2+1;
         if(strt > lcdWidth) strt = lcdWidth;
      } else {
         strt = lcdWidth;
      }
      if(stop-strt){
#ifdef USE_PANGO
         pango_layout_index_to_pos(pango_layout, strt, &rect);
         pango_pos = rect.x / PANGO_SCALE;
         gdk_window_clear_area(lcdDA->window, 
            pango_pos + BORDER, i*fontH + BORDER,
            2*fontW*(stop-strt), fontH);
         pango_layout_set_text(pango_layout,  &lcdText[i][strt], stop-strt);
         gdk_draw_layout(lcdDA->window, lcdGC,
            pango_pos + BORDER + SHIFT, i*fontH + BORDER,
	    pango_layout);
#else
	 gdk_window_clear_area(lcdDA->window, 
	    strt*fontW + BORDER, i*fontH + BORDER,
	    fontW*(stop-strt), fontH);
         gdk_draw_text(lcdDA->window, lcdFont, lcdGC,
            strt*fontW + BORDER, (i+1)*fontH - fontD + BORDER,
            &lcdText[i][strt], stop-strt);
#endif
      }
   }

   /* draw the cursor */
   if(isEditingEditor()){
      curPos = cursorPosEditor();
      if(curPos > lcdWidth){
         curPos = lcdWidth;
      }
      if(dataSelected == DATA_SELECTED &&
	 curPos>=hiX1 && curPos<=hiX2 && 
         lcdHeight-1>=hiY1 && lcdHeight-1<=hiY2)
      {
         drawgc = lcdHighlightGC;
      } else {
	 drawgc = lcdGC;
      }

      /* hack: draw a white line to erase any old cursor
         in position 0. XDrawImageString dosen't cover this
         up like it does with an old cursor in any other position */
      if(!(dataSelected == DATA_SELECTED && 
         0==hiX1 && lcdHeight-1>=hiY1 && lcdHeight-1<=hiY2))
      {
         gdk_draw_line(lcdDA->window, lcdHighlightGC,
            BORDER + SHIFT, (lcdHeight-1) * fontH + BORDER,
            BORDER + SHIFT, lcdHeight * fontH - 1 + BORDER);
      }

      /* draw the cursor */
#ifdef USE_PANGO
      pango_layout_index_to_pos(pango_layout, curPos, &rect);
      pango_pos = rect.x / PANGO_SCALE + SHIFT + BORDER;
      gdk_draw_line(lcdDA->window, drawgc,
         pango_pos, (lcdHeight-1) * fontH + BORDER,
         pango_pos, lcdHeight * fontH - 1 + BORDER);
      /* Flush GDK display, seems to be needed in certain environments */
      gdk_flush();
   } else {
      pango_layout_index_to_pos(pango_layout, strt, &rect);
      pango_pos = rect.x / PANGO_SCALE + SHIFT + BORDER;
      if (pango_pos > lcdDA->allocation.width - BORDER && lcdWidth > 6) {
	 lcdWidth -= 1;
         clearLCDwindow();
         calcStackLCD();
         drawStackLCD();
      }
   }
#else
      gdk_draw_line(lcdDA->window, drawgc,
         fontW * curPos + SHIFT + BORDER, (lcdHeight-1) * fontH + BORDER,
         fontW * curPos + SHIFT + BORDER, lcdHeight * fontH - 1 + BORDER);
   }