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

Safety:
Cancellation point	No
Interrupt handler	No
Signal handler	No
Thread	Yes