PfGetGlyphIndexCx()

Get a glyph index

Synopsis:

#include <font_api.h>
int PfGetGlyphIndexCx( struct _Pf_ctrl * context,
                       wchar_tglyph,
                       FontID * font,
                       uint32_t * pIndex );

Arguments:

context

A pointer to the font context to use, returned by PfAttachCx() or PfAttachDllCx().

glyph

A Unicode glyph value.

font

A pointer to a font ID, as returned by PfFindFontCx().

pIndex

A pointer to a uint32_t where the function can store the glyph index.

Library:

font

Description:

This function retrieves the glyph index for the provided font and glyph combination.

Returns:

0

Success

-1

An error occurred (errno is set).

Errors:

ESRCH

Unable to locate device.

EBADF

Connection has gone stale, or device error occurred.

ENETUNREACH

Bad message buffer.

ELIBACC

Unable to locate render plugin for specified font.

EINVAL

Failure to load resources for specified font.

EFAULT

Unable to locate suitable base font.

ERANGE

Unable to locate suitable base font for provided code point.

EINVAL

Render plugin is unable to satisfy request.

Examples:

#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <ctype.h>
#include <errno.h>
#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <dirent.h>

#include <photon/PhT.h>
#include <photon/PhProto.h>
#include <Pt.h>
#include <Ph.h>

#include <font_api.h>

FontName name;
uint16_t wc = 0x65;

int font_changed(PtWidget_t * widget, void * data, PtCallbackInfo_t * cbinfo)
{  snprintf(name, sizeof(name), "%s", cbinfo->cbdata);
   printf("%s\n", name);
   PtDamageWidget(data);
   return(Pt_CONTINUE);
}

void raw_draw(PtWidget_t *widget, PhTile_t *damage)
{  PhArea_t area;
   PhRect_t tsClip;
   PhPoint_t pos = { 10, 10 };
   FontQueryInfo info;
   wchar_t w;
   FontID * id;
   pf_metrics_t * metric;
   FontRender * render;

   PtSuperClassDraw( PtBasic, widget, damage );
   PtCalcCanvas(widget, &tsClip);
   PgDrawRect(&tsClip, Pg_DRAW_FILL);
   PtClipAdd(widget, &tsClip);
   tsClip.ul.x += 2;
   tsClip.ul.y += 10;

   PgSetTranslation (&tsClip.ul, Pg_RELATIVE);
   PgSetTextColor(Pg_BLACK);
   PgSetFont(name);

   if(PfQueryFontInfoCx(PfDefaultContext(), name, &info) == -1)
   {  fprintf(stderr, "NOTE : PfQueryFontInfoCx failed, errno %d.\n", errno);
      fprintf(stderr, "FAIL : Glyph capture.\n");
      exit(EXIT_FAILURE);
   }

   pos.y += -info.ascender;
   w = wc;

   if((id = PfDecomposeStemToIDCx(PfDefaultContext(), name)) != NULL)
   {  FontRender r;
      int size = 32000;
      char * bitmap = calloc(size, sizeof(char));

      if(PfGlyphCx(PfDefaultContext(), name, w, &r, bitmap, size, NULL) == -1)
      {  fprintf(stderr, "NOTE : PfGlyphCx failed, errno %d.\n", errno);
         fprintf(stderr, "FAIL : Glyph capture.\n");
         free(bitmap);
         exit(EXIT_FAILURE);
      }
      else
      {  pos.y -= r.offset.y;

         PgDrawText(&wc, sizeof(wc), &pos, Pg_TEXT_WIDECHAR);
      }

      free(bitmap);
      PfFreeFontCx(PfDefaultContext(), id);
   }
   else
   {  fprintf(stderr, "NOTE : PfDecomposeStemToIDCx failed, errno %d.\n", errno);
      fprintf(stderr, "FAIL : Glyph capture.\n");
      exit(EXIT_FAILURE);
   }

   tsClip.ul.x *= -1;
   tsClip.ul.y *= -1;
   PgSetTranslation (&tsClip.ul, Pg_RELATIVE);
   PtClipRemove();
}

int main(int argc, char *argv[])
{  PtArg_t tsArg[10];
   int i;
   PhDim_t dim = { 300, 300 };
   PtWidget_t * win, * raw, * fontsel;
   PhPoint_t pos = {0,0};
   PhRect_t canvas;
   int flags;
   uint32_t index;
   FontID * id;

   fprintf(stderr, "POINT : Glyph capture.\n");

   if(PtInit(NULL) == -1)
   {  fprintf(stderr, "NOTE : PtInit failed, no photon.\n");
      fprintf(stderr, "FAIL : Glyph Capture.\n");
      return(EXIT_FAILURE);
   }

   PgSetDrawBufferSize(0xFFFF);

   i = 0;
   PtSetArg(&tsArg[i++], Pt_ARG_DIM, &dim, 0L);
   PtSetArg(&tsArg[i++], Pt_ARG_WINDOW_TITLE, "Glyph Capture", 0L);
   PtSetArg(&tsArg[i++], Pt_ARG_FLAGS, Pt_GETS_FOCUS, Pt_GETS_FOCUS);

   if((win = PtCreateWidget(PtWindow, NULL, i, tsArg)) == NULL)
   {  fprintf(stderr, "NOTE : Unable to create window.\n");
      fprintf(stderr, "FAIL : Glyph Capture.\n");
      return(EXIT_FAILURE);
   }

   PtCalcCanvas(win, &canvas);

   i = 0;
   dim.w = canvas.lr.x - canvas.ul.x;
   dim.h = (canvas.lr.y / 2) - canvas.ul.y;
   PtSetArg(&tsArg[i++], Pt_ARG_DIM, &dim, 0L);
   PtSetArg(&tsArg[i++], Pt_ARG_RAW_DRAW_F, raw_draw, 0L);
   pos.x = 0;
   pos.y = dim.h;
   PtSetArg(&tsArg[i++], Pt_ARG_POS, &pos, 0L);
   PtSetArg(&tsArg[i++], Pt_ARG_FILL_COLOR, Pg_YELLOW, 0L);
   flags = Pt_RIGHT_ANCHORED_RIGHT | Pt_LEFT_ANCHORED_LEFT | Pt_TOP_ANCHORED_TOP
           | Pt_BOTTOM_ANCHORED_BOTTOM;
   PtSetArg(&tsArg[i++], Pt_ARG_ANCHOR_FLAGS, flags, flags);

   if((raw = PtCreateWidget(PtRaw, win, i, tsArg)) == NULL)
   {  fprintf(stderr, "NOTE : Unable to create raw canvas.\n");
      fprintf(stderr, "FAIL : Glyph Capture.\n");
      return(EXIT_FAILURE);
   }

   i = 0;
   dim.w = canvas.lr.x - canvas.ul.x;
   dim.h = (canvas.lr.y / 2) - canvas.ul.y;
   PtSetArg(&tsArg[i++], Pt_ARG_DIM, &dim, 0L);
   pos.x = 0;
   pos.y = 0;
   PtSetArg(&tsArg[i++], Pt_ARG_POS, &pos, 0L);
   flags = Pt_RIGHT_ANCHORED_RIGHT | Pt_LEFT_ANCHORED_LEFT | Pt_TOP_ANCHORED_TOP
           | Pt_BOTTOM_ANCHORED_BOTTOM;
   PtSetArg(&tsArg[i++], Pt_ARG_ANCHOR_FLAGS, flags, flags);
   PtSetArg(&tsArg[i++], Pt_ARG_FONT_FLAGS, 0L, Pt_FONTSEL_SAMPLE);

   if((fontsel = PtCreateWidget(PtFontSel, win, i, tsArg)) == NULL)
   {  fprintf(stderr, "NOTE : Unable to create fontsel.\n");
      fprintf(stderr, "FAIL : Glyph Capture.\n");
      return(EXIT_FAILURE);
   }

   PtAddCallback(fontsel, Pt_CB_FONT_MODIFY, font_changed, raw);

   id = PfFindFontCx(PfDefaultContext(), "TextFont", 0L, 9L);
   PfConvertFontIDCx(PfDefaultContext(), id, name);

   if(PfGetGlyphIndexCx(PfDefaultContext(), wc, id, &index) == -1)
   {  fprintf(stderr, "NOTE : Unable to fetch index, errno %d.\n", errno);
      fprintf(stderr, "FAIL : Glyph Capture.\n");
      return(EXIT_FAILURE);
   }
   else
     fprintf(stderr, "NOTE : index is %d\n", index);

   PtRealizeWidget(win);
   PtMainLoop();

   return(EXIT_SUCCESS);
}

Classification:

Photon

See also:

PfAttachCx(), PfAttachDllCx(), PfFindFontCx().

Fonts chapter of the Photon Programmer's Guide