int callback(struct filetransfer *ft, enum ftstate ftst,
size_t bytessent, size_t bytestotal)
{
const double fraction = (double)bytessent / (double)bytestotal;
switch(ftst){
case FT_WAIT:
break; /* skip straight to return */
case FT_SENT:
case FT_RECEIVED:
{
char *stat;
if(ftst == FT_SENT)
stat = g_strdup_printf("Sent %s", ft_basename(ft));
else
stat = g_strdup_printf("Received %s", ft_basename(ft));
status("%s", stat);
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progressft), 1.0f);
transfers_add(listDone, ft_basename(ft), ft_fname(ft), ftst == FT_RECEIVED);
tray_balloon("Transfer complete", stat);
g_free(stat);
break;
}
case FT_BEGIN_SEND:
case FT_BEGIN_RECV:
cancelled = 0;
gstate = STATE_TRANSFER;
cmds();
/* fall */
case FT_RECEIVING:
case FT_SENDING:
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progressft), fraction);
status("%s: %ldK/%ldK (%2.2f%%)", ft_basename(ft),
(long)bytessent / 1024,
(long)bytestotal / 1024,
100.0f * fraction);
}
while(gtk_events_pending())
gtk_main_iteration();
return cancelled;
}
/*
The input file is a file that contains file full path for each line,like
/home/user/src/abc.c
/home/user/src/adf.c
/home/user/src/afe.c
/home/user/src/doom.c
/home/user/src/elf.c
/home/user/src/eep.c
/home/user/src/woman.c
/home/user/src/what.c
The matrix is a 2-D pointer array that contains file infor(name,path) according to a-z order,like
'a' abc.c--->adf.c--->afe.c--->NULL
|
'b' NULL
|
'c' NULL
|
'd' doom.c--->NULL
|
'e' elf.c--->eep.c--->NULL
|
'f' NULL
|
...
|
'w' woman.c--->what.c--->NULL
|
...
'z' NULL
*/
void matrix_get(char * file, /* in,input file path */
FILE_INFO_NODE ** matrix) /* out,matrix */
{
FILE * fd;
FILE_INFO_NODE * fin_temp;
FILE_INFO_NODE * fin_cursors[26];
unsigned int index;
int c;
if ((fd = fopen(file,"r")) == 0) {
fprintf(stderr,"Read file(%s) failed:%s\n",file,strerror(errno));
exit(0);
}
/* create header node */
CREATE_NODE(fin_temp);
/* go through file line by line and build a matrix to save sort node link */
while (fgets((char *)fin_temp->fpath, MAX_PATH_LEN, fd) != 0) {
strncpy(fin_temp->fname,ft_basename(fin_temp->fpath),MAX_NAME_LEN);
#if DEBUG_TRACE == 2
fprintf(stdout, "fname is %s",fin_temp->fname);
#endif
c = (int)fin_temp->fname[0];
index = tolower(c) - 'a';
if (index > 'z') { /* a source file beginning with a ? */
fprintf(stderr, "Unsupport file name:%s\n",fin_temp->fname);
continue;
}
if (matrix[index] == NULL) {
#if DEBUG_TRACE == 2
fprintf(stdout, "add header node at matrix[%d]=0x%p\n",index,matrix[index]);
#endif
matrix[index] = (FILE_INFO_NODE *)fin_temp;
fin_cursors[index] = (FILE_INFO_NODE *)fin_temp;
} else {
#if DEBUG_TRACE == 2
fprintf(stdout, "append node at matrix[%d]=0x%p,cursors[%d]=0x%p\n\n",index,matrix[index],index,fin_cursors[index]);
#endif
fin_cursors[index]->next = (FILE_INFO_NODE *)fin_temp;
fin_cursors[index] = (FILE_INFO_NODE *)fin_temp;
}
/* create new node... */
CREATE_NODE(fin_temp);
}
fclose(fd);
/*
#if DEBUG_TRACE == 1
matrix_dump(matrix);
#endif
*/
}
static void
write_header( FT_Error error_code )
{
FT_Face face;
const char* basename;
error = FTC_Manager_LookupFace( handle->cache_manager,
handle->scaler.face_id, &face );
if ( error )
PanicZ( "can't access font file" );
if ( !status.header )
{
basename = ft_basename( handle->current_font->filepathname );
switch ( error_code )
{
case FT_Err_Ok:
sprintf( status.header_buffer,
"%.50s %.50s (file `%.100s')", face->family_name,
face->style_name, basename );
break;
case FT_Err_Invalid_Pixel_Size:
sprintf( status.header_buffer, "Invalid pixel size (file `%.100s')",
basename );
break;
case FT_Err_Invalid_PPem:
sprintf( status.header_buffer, "Invalid ppem value (file `%.100s')",
basename );
break;
default:
sprintf( status.header_buffer, "File `%.100s': error 0x%04x", basename,
(FT_UShort)error_code );
break;
}
status.header = status.header_buffer;
}
grWriteCellString( display->bitmap, 0, 0,
status.header, display->fore_color );
sprintf( status.header_buffer, "at %g points, angle = %d",
status.ptsize / 64.0, status.angle );
grWriteCellString( display->bitmap, 0, CELLSTRING_HEIGHT,
status.header_buffer, display->fore_color );
grRefreshSurface( display->surface );
}
static void
parse_cmdline( int* argc,
char*** argv )
{
char* execname;
int option;
execname = ft_basename( (*argv)[0] );
while ( 1 )
{
option = getopt( *argc, *argv, "e:h:m:r:vw:" );
if ( option == -1 )
break;
switch ( option )
{
case 'e':
status.encoding = FTDemo_Make_Encoding_Tag( optarg );
break;
case 'h':
status.height = atoi( optarg );
if ( status.height < 1 )
usage( execname );
break;
case 'm':
if ( *argc < 3 )
usage( execname );
Text = optarg;
break;
case 'r':
status.res = atoi( optarg );
if ( status.res < 1 )
usage( execname );
break;
case 'v':
{
FT_Int major, minor, patch;
FT_Library_Version( handle->library, &major, &minor, &patch );
printf( "ftstring (FreeType) %d.%d", major, minor );
if ( patch )
printf( ".%d", patch );
printf( "\n" );
exit( 0 );
}
/* break; */
case 'w':
status.width = atoi( optarg );
if ( status.width < 1 )
usage( execname );
break;
default:
usage( execname );
break;
}
}
*argc -= optind;
*argv += optind;
if ( *argc <= 1 )
usage( execname );
status.ptsize = (int)( atof( *argv[0] ) * 64.0 );
if ( status.ptsize == 0 )
status.ptsize = 64;
(*argc)--;
(*argv)++;
}
int
main( int argc,
char* argv[] )
{
int i, file;
char filename[128 + 4];
char alt_filename[128 + 4];
char* execname;
int num_faces;
int option;
FT_Library library; /* the FreeType library */
FT_Face face; /* the font face */
execname = ft_basename( argv[0] );
while ( 1 )
{
option = getopt( argc, argv, "dl:nv" );
if ( option == -1 )
break;
switch ( option )
{
case 'd':
debug = 1;
break;
case 'l':
trace_level = atoi( optarg );
if ( trace_level < 1 || trace_level > 7 )
usage( execname );
break;
case 'n':
name_tables = 1;
break;
case 'v':
verbose = 1;
break;
default:
usage( execname );
break;
}
}
argc -= optind;
argv += optind;
if ( argc != 1 )
usage( execname );
#if FREETYPE_MAJOR == 2 && FREETYPE_MINOR == 0 && FREETYPE_PATCH <= 8
if ( debug )
{
# ifdef FT_DEBUG_LEVEL_TRACE
FT_SetTraceLevel( trace_any, (FT_Byte)trace_level );
# else
trace_level = 0;
# endif
}
#elif 0
/* "setenv/putenv" is not ANSI and I don't want to mess */
/* with this portability issue right now */
if ( debug )
{
char temp[32];
sprintf( temp, "any=%d", trace_level );
setenv( "FT2_DEBUG", temp );
}
#endif
file = 0;
/* Initialize engine */
error = FT_Init_FreeType( &library );
if ( error )
PanicZ( "Could not initialize FreeType library" );
filename[128] = '\0';
alt_filename[128] = '\0';
strncpy( filename, argv[file], 128 );
strncpy( alt_filename, argv[file], 128 );
/* try to load the file name as is, first */
error = FT_New_Face( library, argv[file], 0, &face );
if ( !error )
goto Success;
#ifndef macintosh
i = strlen( argv[file] );
while ( i > 0 && argv[file][i] != '\\' && argv[file][i] != '/' )
{
if ( argv[file][i] == '.' )
i = 0;
i--;
}
if ( i >= 0 )
{
strncpy( filename + strlen( filename ), ".ttf", 4 );
strncpy( alt_filename + strlen( alt_filename ), ".ttc", 4 );
}
#endif
/* Load face */
error = FT_New_Face( library, filename, 0, &face );
if ( error )
PanicZ( "Could not open face." );
Success:
num_faces = face->num_faces;
FT_Done_Face( face );
printf( "There %s %d %s in this file.\n",
num_faces == 1 ? (char *)"is" : (char *)"are",
num_faces,
num_faces == 1 ? (char *)"face" : (char *)"faces" );
for ( i = 0; i < num_faces; i++ )
{
error = FT_New_Face( library, filename, i, &face );
if ( error )
PanicZ( "Could not open face." );
printf( "\n----- Face number: %d -----\n\n", i );
Print_Name( face );
printf( "\n" );
Print_Type( face );
printf( " glyph count: %ld\n", face->num_glyphs );
if ( name_tables && FT_IS_SFNT( face ) )
{
printf( "\n" );
Print_Sfnt_Names( face );
}
if ( face->num_fixed_sizes )
{
printf( "\n" );
Print_Fixed( face );
}
if ( face->num_charmaps )
{
printf( "\n" );
Print_Charmaps( face );
}
FT_Done_Face( face );
}
FT_Done_FreeType( library );
exit( 0 ); /* for safety reasons */
return 0; /* never reached */
}
int
main( int argc, char** argv )
{
int i, orig_ptsize, file;
char filename[128 + 4];
char alt_filename[128 + 4];
char* execname;
int option;
int ptsize;
int num_Faces = 0;
int glyph_index = 0;
int load_flags = TTLOAD_DEFAULT;
int force_sbit = 0;
TT_Engine engine;
TT_Face face;
TT_Instance instance;
TT_Glyph glyph;
TT_Raster_Map map;
TT_Big_Glyph_Metrics metrics;
TT_Face_Properties properties;
TT_Instance_Metrics imetrics;
TT_EBLC eblc;
TT_SBit_Image* bitmap = NULL;
TT_Error error;
int res = 72;
#ifdef HAVE_LIBINTL_H
setlocale( LC_ALL, "" );
bindtextdomain( "freetype", LOCALEDIR );
textdomain( "freetype" );
#endif
execname = ft_basename( argv[0] );
while ( 1 )
{
option = ft_getopt( argc, argv, "c:r:i:B" );
if ( option == -1 )
break;
switch ( option )
{
case 'r':
res = atoi( ft_optarg );
if ( res < 1 )
usage( execname );
break;
case 'c':
num_Faces = atoi( ft_optarg );
if ( num_Faces < 0 )
usage( execname );
break;
case 'i':
glyph_index = atoi( ft_optarg );
if ( glyph_index < 0 )
usage( execname );
break;
case 'B':
force_sbit = 1;
break;
default:
usage( execname );
break;
}
}
argc -= ft_optind;
argv += ft_optind;
if ( argc <= 1 )
usage( execname );
if ( sscanf( argv[0], "%d", &orig_ptsize ) != 1 )
orig_ptsize = 64;
file = 1;
ptsize = orig_ptsize;
i = strlen( argv[file] );
while ( i > 0 && argv[file][i] != '\\' && argv[file][i] != '/' )
{
if ( argv[file][i] == '.' )
i = 0;
i--;
}
filename[128] = '\0';
alt_filename[128] = '\0';
strncpy( filename, argv[file], 128 );
strncpy( alt_filename, argv[file], 128 );
if ( i >= 0 )
{
strncpy( filename + strlen( filename ), ".ttf", 4 );
strncpy( alt_filename + strlen( alt_filename ), ".ttc", 4 );
}
/* Initialize engine */
error = TT_Init_FreeType( &engine );
if ( error )
{
fprintf( stderr, gettext( "Error while initializing engine.\n" ) );
goto Failure;
}
error = TT_Init_SBit_Extension( engine );
if ( error )
{
fprintf( stderr, gettext(
"Error while initializing embedded bitmap extension.\n" ) );
goto Failure;
}
/* Load face */
error = TT_Open_Face( engine, filename, &face );
if ( error == TT_Err_Could_Not_Open_File )
{
strcpy( filename, alt_filename );
error = TT_Open_Face( engine, alt_filename, &face );
}
if ( error == TT_Err_Could_Not_Open_File )
Panic( gettext( "Could not find or open %s.\n" ), filename );
if ( error )
{
fprintf( stderr, gettext( "Error while opening %s.\n" ),
filename );
goto Failure;
}
TT_Get_Face_Properties( face, &properties );
printf( gettext( "There are %d fonts in this collection.\n" ),
(int)(properties.num_Faces) );
if ( num_Faces >= properties.num_Faces )
Panic( gettext(
"There is no collection with index %d in this font file.\n" ),
num_Faces );
TT_Close_Face( face );
error = TT_Open_Collection( engine, filename, num_Faces, &face );
/* get face properties and eblc */
TT_Get_Face_Properties( face, &properties );
if ( force_sbit )
{
error = TT_Get_Face_Bitmaps( face, &eblc );
if ( error == TT_Err_Table_Missing )
Panic( gettext( "There is no embedded bitmap data in the font.\n" ) );
if ( error )
{
fprintf( stderr, gettext(
"Error while retrieving embedded bitmaps table.\n" ) );
goto Failure;
}
}
/* create glyph */
error = TT_New_Glyph( face, &glyph );
if ( error )
{
fprintf( stderr, gettext( "Could not create glyph container.\n" ) );
goto Failure;
}
/* create instance */
error = TT_New_Instance( face, &instance );
if ( error )
{
fprintf( stderr, gettext( "Could not create instance.\n" ) );
goto Failure;
}
error = TT_Set_Instance_Resolutions( instance, res, res );
if ( error )
{
fprintf( stderr, gettext( "Could not set device resolutions.\n" ) );
goto Failure;
}
error = TT_Set_Instance_CharSize( instance, ptsize*64 );
if ( error )
{
fprintf( stderr, gettext( "Could not reset instance.\n" ) );
goto Failure;
}
TT_Get_Instance_Metrics( instance, &imetrics );
printf( gettext( "Instance metrics: ppemX %d, ppemY %d\n" ),
imetrics.x_ppem,
imetrics.y_ppem );
if ( force_sbit )
{
error = TT_New_SBit_Image( &bitmap );
if ( error )
{
fprintf( stderr, gettext(
"Could not allocate glyph bitmap container.\n" ) );
goto Failure;
}
error = TT_Load_Glyph_Bitmap( face, instance, glyph_index, bitmap );
if ( error )
{
fprintf( stderr, gettext(
"Can't load bitmap for glyph %d.\n" ), glyph_index );
goto Failure;
}
Show_Metrics( bitmap->metrics, "SBit's metrics" );
printf( "SBit glyph:\n" );
Show_Single_Glyph( &bitmap->map );
}
else
{
TT_Load_Glyph( instance, glyph, glyph_index, load_flags );
TT_Get_Glyph_Big_Metrics( glyph, &metrics );
map.width = ( metrics.bbox.xMax - metrics.bbox.xMin ) / 64;
map.rows = ( metrics.bbox.yMax - metrics.bbox.yMin ) / 64;
map.cols = ( map.width + 7 ) / 8;
map.size = map.cols * map.rows;
map.bitmap = malloc( map.size );
map.flow = TT_Flow_Down;
memset( map.bitmap, 0, map.size );
error = TT_Get_Glyph_Bitmap( glyph, &map,
-metrics.bbox.xMin,
-metrics.bbox.yMin );
Show_Metrics( metrics, gettext( "Outline's metrics" ) );
printf( gettext( "Outline glyph\n" ) );
Show_Single_Glyph( &map );
}
free( map.bitmap );
if ( bitmap )
TT_Done_SBit_Image( bitmap );
TT_Done_Instance( instance );
TT_Done_Glyph( glyph );
TT_Done_FreeType( engine );
exit( EXIT_SUCCESS ); /* for safety reasons */
return 0; /* never reached */
Failure:
fprintf( stderr, " " );
fprintf( stderr, gettext( "FreeType error message: %s\n" ),
TT_ErrToString18( error ) );
exit( EXIT_FAILURE );
return 0; /* never reached */
}
int
main( int argc,
char** argv )
{
FT_Library library;
FT_Face face;
FT_GlyphSlot slot;
FT_Matrix matrix; /* transformation matrix */
FT_UInt glyph_index;
FT_Vector pen; /* untransformed origin */
FT_Error error;
char* filename;
char* text;
char* execname;
double angle;
int target_height;
int n, num_chars;
execname = ft_basename( argv[0] );
if ( argc != 3 )
usage( execname );
filename = argv[1]; /* first argument */
text = argv[2]; /* second argument */
num_chars = strlen( text );
angle = ( 5.0 / 360 ) * 3.14159 * 2; /* use 5 degrees */
target_height = HEIGHT;
error = FT_Init_FreeType( &library ); /* initialize library */
/* error handling omitted */
error = FT_New_Face( library, argv[1], 0, &face ); /* create face object */
/* error handling omitted */
/* use 50pt at 100dpi */
error = FT_Set_Char_Size( face, 50 * 64, 0,
100, 0 ); /* set character size */
/* error handling omitted */
slot = face->glyph;
/* set up matrix */
matrix.xx = (FT_Fixed)( cos( angle ) * 0x10000L );
matrix.xy = (FT_Fixed)(-sin( angle ) * 0x10000L );
matrix.yx = (FT_Fixed)( sin( angle ) * 0x10000L );
matrix.yy = (FT_Fixed)( cos( angle ) * 0x10000L );
/* the pen position in 26.6 cartesian space coordinates; */
/* start at (30,20) relative to the upper left corner */
pen.x = 30 * 64;
pen.y = ( target_height - 80 ) * 64;
for ( n = 0; n < num_chars; n++ )
{
/* set transformation */
FT_Set_Transform( face, &matrix, &pen );
/* load glyph image into the slot (erase previous one) */
error = FT_Load_Char( face, text[n], FT_LOAD_RENDER );
if ( error )
continue; /* ignore errors */
/* now, draw to our target surface (convert position) */
draw_bitmap( &slot->bitmap,
slot->bitmap_left,
target_height - slot->bitmap_top );
/* increment pen position */
pen.x += slot->advance.x;
pen.y += slot->advance.y;
}
show_image();
FT_Done_Face ( face );
FT_Done_FreeType( library );
return 0;
}
