int main(int argc, char *argv[])
{
errorCode tmp_err_code = UNEXPECTED_ERROR;
FILE *outfile = stdout; // Default is the standard output
char sourceFile[100];
EXIPSchema schema;
EXIPSchema* schemaPtr = NULL;
int argIndex = 1;
strcpy(sourceFile, "stdout");
if(argc >= 2)
{
if(strcmp(argv[argIndex], "-help") == 0)
{
printfHelp();
return 0;
}
else if(strstr(argv[argIndex], "-schema") != NULL)
{
// Schema enabled encoding is requested.
// All the xsd files should be passed as comma-separated list
char* xsdList = argv[argIndex] + 7;
parseSchema(xsdList, &schema);
schemaPtr = &schema;
argIndex++;
}
}
if(argIndex < argc)
{
strcpy(sourceFile, argv[argIndex]);
outfile = fopen(sourceFile, "wb" );
if(!outfile)
{
fprintf(stderr, "Unable to open file %s", sourceFile);
return 1;
}
}
tmp_err_code = encode(schemaPtr, outfile, writeFileOutputStream);
if(schemaPtr != NULL)
destroySchema(schemaPtr);
if(tmp_err_code != ERR_OK)
{
printf("\nError (code: %d) during encoding of: %s\n", tmp_err_code, sourceFile);
exit(1);
}
else
{
printf("\nSuccessful encoding in %s\n", sourceFile);
exit(1);
}
fclose(outfile);
}
int main(int argc, char *argv[])
{
errorCode tmp_err_code = UNEXPECTED_ERROR;
FILE *outfile;
char sourceFile[50];
EXIPSchema schema;
EXIPSchema* schemaPtr = NULL;
if(argc > 1)
{
if(strcmp(argv[1], "-help") == 0)
{
printfHelp();
return 0;
}
else if(strcmp(argv[1], "-schema") == 0)
{
FILE *schemaFile;
BinaryBuffer buffer[MAX_XSD_FILES_COUNT]; // up to 10 XSD files
char schemaFileName[50];
unsigned int schemaFilesCount = 0;
unsigned int i;
if(argc <= 3)
{
printfHelp();
return 0;
}
else
schemaFilesCount = argc - 3;
if(schemaFilesCount > MAX_XSD_FILES_COUNT)
{
fprintf(stderr, "Too many xsd files given as an input: %d", schemaFilesCount);
exit(1);
}
for(i = 0; i < schemaFilesCount; i++)
{
strcpy(schemaFileName, argv[2 + i]);
schemaFile = fopen(schemaFileName, "rb" );
if(!schemaFile)
{
fprintf(stderr, "Unable to open file %s", schemaFileName);
return 1;
}
else
{
//Get file length
fseek(schemaFile, 0, SEEK_END);
buffer[i].bufLen = ftell(schemaFile) + 1;
fseek(schemaFile, 0, SEEK_SET);
//Allocate memory
buffer[i].buf = (char *) malloc(buffer[i].bufLen);
if (!buffer[i].buf)
{
fprintf(stderr, "Memory allocation error!");
fclose(schemaFile);
return 1;
}
//Read file contents into buffer
fread(buffer[i].buf, buffer[i].bufLen, 1, schemaFile);
fclose(schemaFile);
buffer[i].bufContent = buffer[i].bufLen;
buffer[i].ioStrm.readWriteToStream = NULL;
buffer[i].ioStrm.stream = NULL;
}
}
tmp_err_code = generateSchemaInformedGrammars(buffer, schemaFilesCount, SCHEMA_FORMAT_XSD_EXI, &schema);
if(tmp_err_code != ERR_OK)
{
printf("\n Error occured: %d", tmp_err_code);
return 1;
}
schemaPtr = &schema;
for(i = 0; i < schemaFilesCount; i++)
{
free(buffer[i].buf);
}
}
strcpy(sourceFile, argv[argc - 1]);
outfile = fopen(sourceFile, "wb" );
if(!outfile)
{
fprintf(stderr, "Unable to open file %s", sourceFile);
return 1;
}
else
{
EXIStream testStrm;
String uri;
String ln;
QName qname = {&uri, &ln, NULL};
String chVal;
char buf[OUTPUT_BUFFER_SIZE];
BinaryBuffer buffer;
buffer.buf = buf;
buffer.bufLen = OUTPUT_BUFFER_SIZE;
buffer.bufContent = 0;
// Serialization steps:
// I: First initialize the header of the stream
serialize.initHeader(&testStrm);
// II: Set any options in the header, if different from the defaults
testStrm.header.has_cookie = TRUE;
testStrm.header.has_options = TRUE;
testStrm.header.opts.valueMaxLength = 300;
testStrm.header.opts.valuePartitionCapacity = 50;
SET_STRICT(testStrm.header.opts.enumOpt);
// III: Define an external stream for the output if any
buffer.ioStrm.readWriteToStream = writeFileOutputStream;
buffer.ioStrm.stream = outfile;
// IV: Initialize the stream
tmp_err_code = serialize.initStream(&testStrm, buffer, schemaPtr, SCHEMA_ID_ABSENT, NULL);
if(tmp_err_code != ERR_OK)
printError(tmp_err_code, &testStrm, outfile);
// V: Start building the stream step by step: header, document, element etc...
tmp_err_code += serialize.exiHeader(&testStrm);
tmp_err_code += serialize.startDocument(&testStrm);
qname.uri = &NS_STR;
qname.localName = &ELEM_MULT_TEST_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <MultipleXSDsTest>
qname.uri = &NS_STR;
qname.localName = &ELEM_ENCODE_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <EXIPEncoder>
// NOTE: attributes should come lexicographically sorted during serialization
qname.uri = &NS_EMPTY_STR;
qname.localName = &ATTR_BYTE_STR;
if(schemaPtr != NULL)
{
// schema mode
tmp_err_code += serialize.attribute(&testStrm, qname, VALUE_TYPE_SMALL_INTEGER); // testByte="
tmp_err_code += serialize.intData(&testStrm, 55);
}
else
{
// schema-less mode
tmp_err_code += serialize.attribute(&testStrm, qname, VALUE_TYPE_STRING); // testByte="
tmp_err_code += asciiToString("55", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
}
qname.localName = &ATTR_VERSION_STR;
tmp_err_code += serialize.attribute(&testStrm, qname, VALUE_TYPE_STRING); // version="
tmp_err_code += asciiToString("0.2", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
tmp_err_code += asciiToString("This is an example of serializing EXI streams using EXIP low level API", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
tmp_err_code += serialize.endElement(&testStrm); // </EXIPEncoder>
qname.uri = &NS_STR;
qname.localName = &ELEM_DESCR_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <description>
tmp_err_code += asciiToString("This is a test of processing XML schemes with multiple XSD files", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
tmp_err_code += serialize.endElement(&testStrm); // </description>
qname.uri = &NS_NESTED_STR;
qname.localName = &ELEM_TEST_SETUP_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <testSetup>
qname.uri = &NS_EMPTY_STR;
qname.localName = &ATTR_GOAL_STR;
tmp_err_code += serialize.attribute(&testStrm, qname, VALUE_TYPE_STRING); // goal="
tmp_err_code += asciiToString("Verify that the implementation works!", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
tmp_err_code += asciiToString("Simple test element with single attribute", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
tmp_err_code += serialize.endElement(&testStrm); // </testSetup>
qname.uri = &NS_STR;
qname.localName = &ELEM_TYPE_TEST_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <type-test>
if(schemaPtr != NULL)
{
// schema mode
qname.uri = &NS_EMPTY_STR;
qname.localName = &ATTR_ID_STR;
tmp_err_code += serialize.attribute(&testStrm, qname, VALUE_TYPE_INTEGER); // id="
tmp_err_code += serialize.intData(&testStrm, 1001);
}
else
{
// schema-less mode
qname.uri = &NS_EMPTY_STR;
qname.localName = &ATTR_ID_STR;
tmp_err_code += serialize.attribute(&testStrm, qname, VALUE_TYPE_STRING); // id="
tmp_err_code += asciiToString("1001", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
}
qname.uri = &NS_NESTED_STR;
qname.localName = &ELEM_BOOL_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <bool>
if(schemaPtr != NULL)
{
// schema mode
tmp_err_code += serialize.booleanData(&testStrm, TRUE);
}
else
{
// schema-less mode
tmp_err_code += asciiToString("true", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
}
tmp_err_code += serialize.endElement(&testStrm); // </bool>
tmp_err_code += serialize.endElement(&testStrm); // </type-test>
qname.uri = &NS_STR;
qname.localName = &ELEM_EXT_TYPES_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <extendedTypeTest>
qname.uri = &NS_EMPTY_STR;
qname.localName = &ELEM_BYTE_TYPES_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <byteTest>
if(schemaPtr != NULL)
{
// schema mode
tmp_err_code += serialize.intData(&testStrm, 11);
}
else
{
// schema-less mode
tmp_err_code += asciiToString("11", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
}
tmp_err_code += serialize.endElement(&testStrm); // </byteTest>
qname.uri = &NS_EMPTY_STR;
qname.localName = &ELEM_DATE_TYPES_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <dateTimeTest>
if(schemaPtr != NULL)
{
// schema mode
EXIPDateTime dt;
dt.presenceMask = 0;
dt.presenceMask = dt.presenceMask | YEAR_PRESENCE;
dt.presenceMask = dt.presenceMask | MON_PRESENCE;
dt.presenceMask = dt.presenceMask | MDAY_PRESENCE;
dt.presenceMask = dt.presenceMask | HOUR_PRESENCE;
dt.presenceMask = dt.presenceMask | MIN_PRESENCE;
dt.presenceMask = dt.presenceMask | SEC_PRESENCE;
dt.presenceMask = dt.presenceMask | FRACT_PRESENCE;
dt.dateTime.tm_year = 112; // 2012
dt.dateTime.tm_mon = 6; // July
dt.dateTime.tm_mday = 31;
dt.dateTime.tm_hour = 13;
dt.dateTime.tm_min = 33;
dt.dateTime.tm_sec = 55;
dt.fSecs.value = 839;
dt.fSecs.offset = 5;
tmp_err_code += serialize.dateTimeData(&testStrm, dt);
}
else
{
// schema-less mode
tmp_err_code += asciiToString("2012 Jul 31 13:33", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
}
tmp_err_code += serialize.endElement(&testStrm); // </dateTimeTest>
qname.uri = &NS_EMPTY_STR;
qname.localName = &ELEM_BIN_TYPES_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <binaryTest>
if(schemaPtr != NULL)
{
// schema mode
tmp_err_code += serialize.binaryData(&testStrm, SOME_BINARY_DATA, 10);
}
else
{
// schema-less mode
tmp_err_code += serialize.stringData(&testStrm, SOME_BINARY_DATA_BASE64);
}
tmp_err_code += serialize.endElement(&testStrm); // </binaryTest>
qname.uri = &NS_EMPTY_STR;
qname.localName = &ELEM_ENUM_TYPES_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <enumTest>
tmp_err_code += serialize.stringData(&testStrm, ENUM_DATA_4);
tmp_err_code += serialize.endElement(&testStrm); // </enumTest>
tmp_err_code += serialize.endElement(&testStrm); // </extendedTypeTest>
tmp_err_code += serialize.endElement(&testStrm); // </MultipleXSDsTest>
tmp_err_code += serialize.endDocument(&testStrm);
if(tmp_err_code != ERR_OK)
printError(tmp_err_code, &testStrm, outfile);
// VI: Free the memory allocated by the EXI stream object
tmp_err_code = serialize.closeEXIStream(&testStrm);
fclose(outfile);
if(schemaPtr != NULL)
destroySchema(schemaPtr);
}
}
else
{
printfHelp();
return 1;
}
return 0;
}
int main(int argc, char *argv[])
{
FILE *infile = stdin;
char sourceFileName[500];
EXIPSchema schema;
EXIPSchema* schemaPtr = NULL;
EXIOptions ops;
EXIOptions* opsPtr = NULL;
boolean outOfBandOpts = FALSE;
unsigned char outFlag = OUT_EXI; // Default output option
unsigned int argIndex = 1;
errorCode tmp_err_code = EXIP_UNEXPECTED_ERROR;
strcpy(sourceFileName, "stdin");
makeDefaultOpts(&ops);
struct timespec start, stopGrammar, stopGrAndInstance;
if(argc > 1)
{
if(strcmp(argv[argIndex], "-help") == 0)
{
printfHelp();
return 0;
}
else if(strcmp(argv[argIndex], "-exi") == 0)
{
outFlag = OUT_EXI;
if(argc == 2)
{
printfHelp();
return 0;
}
argIndex += 1;
}
else if(strcmp(argv[argIndex], "-xml") == 0)
{
outFlag = OUT_XML;
if(argc == 2)
{
printfHelp();
return 0;
}
argIndex += 1;
}
if(strstr(argv[argIndex], "-ops") != NULL)
{
char *mask = argv[argIndex] + 4;
outOfBandOpts = TRUE;
parseOpsMask(mask, &ops);
opsPtr = &ops;
argIndex += 1;
}
if(strstr(argv[argIndex], "-schema") != NULL)
{
char *xsdList = argv[argIndex] + 7;
if( clock_gettime( CLOCK_MONOTONIC, &start) == -1 ) {
perror( "clock gettime" );
exit( EXIT_FAILURE );
}
parseSchema(xsdList, &schema);
if( clock_gettime( CLOCK_MONOTONIC, &stopGrammar) == -1 ) {
perror( "clock gettime" );
exit( EXIT_FAILURE );
}
printf( "%ld ; ", ((long) (stopGrammar.tv_sec - start.tv_sec)*1000000000) + (long) (stopGrammar.tv_nsec - start.tv_nsec));
// printf( "SECONDS: %ld\n", (long) (stopGrammar.tv_sec - start.tv_sec));
// printf( "NANOSEC: %ld\n", (long) (stopGrammar.tv_nsec - start.tv_nsec));
schemaPtr = &schema;
argIndex += 1;
}
}
if(argIndex < argc)
{
strcpy(sourceFileName, argv[argIndex]);
infile = fopen(sourceFileName, "rb" );
if(!infile)
{
fprintf(stderr, "Unable to open file %s\n", sourceFileName);
exit(1);
}
}
tmp_err_code = decode(schemaPtr, outFlag, infile, outOfBandOpts, opsPtr, readFileInputStream);
if(schemaPtr != NULL)
destroySchema(schemaPtr);
fclose(infile);
if( clock_gettime( CLOCK_MONOTONIC, &stopGrAndInstance) == -1 ) {
perror( "clock gettime" );
exit( EXIT_FAILURE );
}
printf( "%ld", ((long) (stopGrAndInstance.tv_sec - start.tv_sec)*1000000000) + (long) (stopGrAndInstance.tv_nsec - start.tv_nsec));
// printf( "SECONDS: %ld\n", (long) (stopGrAndInstance.tv_sec - start.tv_sec));
// printf( "NANOSEC: %ld\n", (long) (stopGrAndInstance.tv_nsec - start.tv_nsec));
if(tmp_err_code != EXIP_OK)
{
printf("\nError (code: %d) during parsing of the EXI stream: %s\n", tmp_err_code, sourceFileName);
return 1;
}
else
{
// printf("\nSuccessful parsing of the EXI stream: %s\n", sourceFileName);
return 0;
}
}
int main(int argc, char* argv[])
{
int ret=0;
int fHandle;
psd_context * context=NULL;
ret = IsBigEndian();
if (!ret)
printf("we are using little endian, psd image file stream byte order is big endian! need convert\n");
else
printf("we are using big endian\n");
if (argc == 1)
{
printfHelp();
return 0;
}
if (!strcmp(argv[1],"psd2bmp"))
{
Psd2Bmp("..\\..\\pic\\tianye_all.psd","..\\..\\pic\\tianye_all.bmp");
Psd2Bmp("..\\..\\pic\\tianye_new.psd","..\\..\\pic\\tianye_new.jpg");
Psd2Png("..\\..\\pic\\tianye_all.psd","..\\..\\pic\\tianye_all.png");
}
else if (!strcmp(argv[1],"merge"))
{
MergeTwoPngFile("..\\..\\pic\\bg.png","..\\..\\pic\\tianye.png","..\\..\\pic\\merge.png",180);
}
else if (!strcmp(argv[1],"bmp2psd"))
{
//CreateDemoPsdFile("..\\..\\pic\\tianye_new.psd","..\\..\\pic\\tianye.png");
fHandle = PsdNewFile("..\\..\\pic\\tianye_1.psd","..\\..\\pic\\tianye.bmp");
printf("new one psd file, ret=%d\n",fHandle);
if (ret>=0)
{
ret = PsdNewLayer(fHandle,"..\\..\\pic\\ms12.png",0,0,1,200);
// ret = PsdNewLayer(fHandle,"..\\..\\pic\\ms12.png",200,200,2,200);
// PsdSetLayerDirection(fHandle,1,RIGHT90);
// PsdSetLayerDirection(fHandle,1,LEFT90);
//PsdSetLayerBrightness(fHandle,1,-0);
//PsdSetLayerContrast(fHandle,1,-50);
PsdSaveFile(fHandle);
PsdCloseFile(fHandle); //must close firstly before load again...
}
// Psd2Bmp("..\\..\\pic\\tianye_new.psd","..\\..\\pic\\tianye_new_tmp.bmp");
Psd2Png("..\\..\\pic\\tianye_1.psd","..\\..\\pic\\tianye_1_tmp.png");
//pngzoom("..\\..\\pic\\tianye_new_tmp.png",50);
}
else if (!strcmp(argv[1],"psd2psd"))
{
//fHandle = PsdLoadFile("..\\..\\pic\\tianye_1.psd"); //tianye_1.psd has two layers already
fHandle = PsdNewFile("..\\..\\pic\\tianye_1.psd","..\\..\\pic\\tianye.bmp");
if (fHandle>=0)
{
//ret = PsdNewLayer(fHandle,"..\\..\\pic\\ms12.png",200,200,2,200);
ret = PsdCreateLayer(fHandle,"..\\..\\pic\\ms12.png",200,200,100,200,2,200);
ret = PsdSaveFile(fHandle);
ret = PsdCloseFile(fHandle);
Psd2Png("..\\..\\pic\\tianye_1.psd","..\\..\\pic\\tianye_1.png");
}
else
{
printf("fail to load psd file. ret=%d\n",ret);
}
}
else if (!strcmp(argv[1],"bmp2bmp"))
{
ret = bmp2bmp("..\\..\\pic\\tianye.bmp","..\\..\\pic\\tianye_tmp.bmp");
if (ret>=0)
{
printf("bmp convert to bmp successfully!\n");
}
}
else if (!strcmp(argv[1],"jpg2bmp"))
{
//ret = jpg2bmp("..\\..\\pic\\testimg.jpg","..\\..\\pic\\testimg.bmp");
ret = jpg2bmp("..\\..\\pic\\puke.jpg","..\\..\\pic\\puke_tmp.bmp");
if (ret>=0)
{
printf("jpg convert to bmp successfully!\n");
}
}
else if (!strcmp(argv[1],"bmp2jpg"))
{
ret = bmp2jpg("..\\..\\pic\\tianye.bmp","..\\..\\pic\\tianye.jpg");
if (ret>=0)
{
printf("bmp convert to jpg successfully!\n");
}
}
else if (!strcmp(argv[1],"png2bmp"))
{
//ret = png2bmp("..\\..\\pic\\mxp.png","..\\..\\pic\\mxp_tmp.bmp");
ret = png2bmp("..\\..\\pic\\ms12.png","..\\..\\pic\\ms12_tmp.bmp");
// ret = png2bmp("..\\..\\pic\\lisa.png","..\\..\\pic\\lisa_tmp.bmp"); //can NOT load lisa.png into RAM
if (ret>=0)
{
printf("png convert to bmp successfully!\n");
}
}
else if (!strcmp(argv[1],"bmp2png"))
{
ret = bmp2png("..\\..\\pic\\Bliss.bmp","..\\..\\pic\\Bliss.png");
if (!ret)
{
printf("bmp convert to png successfully!\n");
}
}
else if (!strcmp(argv[1],"pngcrop"))
{
ret = bmp2png("..\\..\\pic\\Bliss.bmp","..\\..\\pic\\Bliss.png");
//ret = pngzoom("..\\..\\pic\\Bliss.png",100);
ret=pngcrop("..\\..\\pic\\Bliss.png",600,400);
}
else
;
return 0;
}
int main( int argc , char** argv )
{
int error = 0;
const char* save_policy = NULL,
* import_policy = NULL;
oySCOPE_e scope = oySCOPE_USER;
size_t size = 0;
char * xml = NULL;
char * import_policy_fn = NULL;
int current_policy = 0, list_policies = 0, list_paths = 0,
dump_policy = 0;
int long_help = 0,
internal_name = 0,
file_name = 0;
int verbose = 0;
#ifdef USE_GETTEXT
setlocale(LC_ALL,"");
#endif
oyExportStart_(EXPORT_CHECK_NO);
if(argc >= 2)
{
int pos = 1, i;
char *wrong_arg = 0;
DBG_PROG1_S("argc: %d\n", argc);
while(pos < argc)
{
switch(argv[pos][0])
{
case '-':
for(i = 1; i < strlen(argv[pos]); ++i)
switch (argv[pos][i])
{
case 'c': current_policy = 1; break;
case 'd': dump_policy = 1; break;
case 'e': internal_name = 1; break;
case 'f': file_name = 1; break;
case 'i': OY_PARSE_STRING_ARG(import_policy); break;
case 'l': list_policies = 1; break;
case 'p': list_paths = 1; break;
case 's': OY_PARSE_STRING_ARG(save_policy); break;
case 'v': if(verbose) oy_debug += 1; verbose = 1; break;
case '-':
if(i == 1)
{
if(OY_IS_ARG("help"))
{ long_help = 1; i=100; break; }
else if(OY_IS_ARG("path"))
{ list_paths = 1; i=100; break; }
else if(OY_IS_ARG("system-wide"))
{ scope = oySCOPE_SYSTEM; i=100; break; }
}
case 'h':
default:
printfHelp(argc, argv);
exit (0);
break;
}
break;
default:
printfHelp(argc, argv);
exit (0);
break;
}
if( wrong_arg )
{
fprintf(stderr, "%s %s\n", _("wrong argument to option:"), wrong_arg);
printfHelp(argc, argv);
exit(1);
}
++pos;
}
} else
{
printfHelp(argc, argv);
exit (0);
}
if(verbose)
fprintf( stderr, " Oyranos v%s\n",
oyNoEmptyName_m_(oyVersionString(1,0)));
/* check the default paths */
/*oyPathAdd( OY_PROFILE_PATH_USER_DEFAULT );*/
/* load the policy file into memory */
import_policy_fn = oyMakeFullFileDirName_(import_policy);
if(oyIsFile_(import_policy_fn))
{
xml = oyReadFileToMem_( oyMakeFullFileDirName_(import_policy), &size,
oyAllocateFunc_ );
oyDeAllocateFunc_( import_policy_fn );
}
/* parse and set policy */
if(xml)
{
oyReadXMLPolicy( oyGROUP_ALL, xml );
oyDeAllocateFunc_( xml );
}
else if ( import_policy )
{
error = oyPolicySet( import_policy, 0 );
if(error)
fprintf( stderr, "%s:%d could not read file: %s\n",__FILE__,__LINE__, import_policy);
return 1;
}
if(save_policy)
{
error = oyPolicySaveActual( oyGROUP_ALL, scope, save_policy );
if(!error)
fprintf( stdout, "%s \"%s\"\n",
_("installed new policy"), save_policy);
else
fprintf( stdout, "\"%s\" %s %d\n", save_policy,
_("installation of new policy file failed with error:"), error);
} else
if(current_policy || list_policies || list_paths)
{
const char ** names = NULL;
int count = 0, i, current = -1;
oyOptionChoicesGet( oyWIDGET_POLICY, &count, &names, ¤t );
if(list_policies)
for(i = 0; i < count; ++i)
{
if(file_name)
{
char * full_name = NULL;
error = oyPolicyFileNameGet_( names[i],
&full_name,
oyAllocateFunc_ );
if(error)
fprintf(stderr, "%s error: %d\n", names[i], error);
if(internal_name)
fprintf(stdout, "%s (%s)\n", names[i], full_name);
else
fprintf(stdout, "%s\n", full_name);
oyFree_m_( full_name );
} else
fprintf(stdout, "%s\n", names[i]);
}
if(current_policy)
{
fprintf( stderr, "%s\n", _("Currently active policy:"));
if(current >= 0 && file_name)
{
char * full_name = NULL;
error = oyPolicyFileNameGet_( names[current], &full_name,
oyAllocateFunc_ );
if(internal_name)
fprintf(stdout, "%s (%s)\n", names[current], full_name);
else
fprintf(stdout, "%s\n", full_name);
oyFree_m_( full_name );
} else
fprintf( stdout, "%s\n", current>=0?names[current]:"---");
}
if(list_paths)
{
char ** path_names = oyDataPathsGet_( &count, "color/settings",
oyALL, oySCOPE_USER_SYS,
oyAllocateFunc_ );
fprintf(stdout, "%s:\n", _("Policy search paths"));
for(i = 0; i < count; ++i)
fprintf(stdout, "%s\n", path_names[i]);
oyStringListRelease_(&path_names, count, oyDeAllocateFunc_);
}
} else
if(dump_policy)
{
size = 0;
xml = oyPolicyToXML( oyGROUP_ALL, 1, oyAllocateFunc_ );
DBG_PROG2_S("%s:%d new policy:\n\n",__FILE__,__LINE__);
fprintf(stdout, "%s\n", xml);
if(xml) oyDeAllocateFunc_( xml );
} else
if(long_help)
{
const char * opts[] = {"add_html_header","1",
"add_oyranos_title","1",
"add_oyranos_copyright","1",
NULL};
size = 0;
xml = oyDescriptionToHTML( oyGROUP_ALL, opts, oyAllocateFunc_ );
fprintf(stdout, "%s\n", xml);
if(xml) oyDeAllocateFunc_( xml );
}
oyFinish_( FINISH_IGNORE_I18N | FINISH_IGNORE_CACHES );
return error;
}
int main( int argc , char** argv )
{
int error = 0;
int flags = OY_NO_REPAIR,
list_tags = 0,
list_hash = 0,
tag_pos = -1,
remove_tag = 0,
dump_openicc_json = 0,
dump_chromaticities = 0,
verbose = 0;
const char * file_name = 0,
* profile_desc = 0,
* tag_name = 0,
* name_space = 0,
* json_name = 0,
* format = "openicc",
* profile_name = 0;
const char * prefixes[24] = {0}; int pn = 0;
const char * device_class = "unknown";
int read_stdin = 0;
oyProfile_s * p;
oyProfileTag_s * tag;
int simple = 0;
#ifdef USE_GETTEXT
setlocale(LC_ALL,"");
#endif
oyExportStart_(EXPORT_CHECK_NO);
if(argc >= 2)
{
int pos = 1;
unsigned i;
char *wrong_arg = 0;
DBG_PROG1_S("argc: %d\n", argc);
while(pos < argc)
{
switch(argv[pos][0])
{
case '-':
for(i = 1; pos < argc && i < strlen(argv[pos]); ++i)
switch (argv[pos][i])
{
case '2': flags |= OY_ICC_VERSION_2; break;
case '4': flags |= OY_ICC_VERSION_4; break;
case 'c': OY_PARSE_STRING_ARG(device_class); break;
case 'f': OY_PARSE_STRING_ARG(format); break;
case 'i': read_stdin = 1; break;
case 'j': OY_PARSE_STRING_ARG(json_name); break;
case 'l': list_tags = 1; break;
case 'm': list_hash = 1; break;
case 'n': OY_PARSE_STRING_ARG(tag_name); break;
case 'o': dump_openicc_json = 1; break;
case 'p': OY_PARSE_INT_ARG( tag_pos ); break;
case 'r': OY_PARSE_INT_ARG( tag_pos ); remove_tag = 1; break;
case 's': OY_PARSE_STRING_ARG(name_space);
if(name_space)
{
int n = pn - 1, found = 0;
while(n >= 0)
if(strcmp( prefixes[n--], name_space ) == 0)
found = 1;
if( !found )
prefixes[pn++] = name_space;
}
break;
case 'v': if(!verbose) verbose = 1; else oy_debug += 1; break;
case 'w': OY_PARSE_STRING_ARG(profile_name); break;
case 'h':
case '-':
if(i == 1)
{
if(OY_IS_ARG("ppmcie"))
{ dump_chromaticities = 1; i=100; break; }
else if(OY_IS_ARG("path"))
{ simple = 2; i=100; break;}
else if(OY_IS_ARG("short"))
{ simple = 1; i=100; break;}
} OY_FALLTHROUGH
default:
printfHelp(argc, argv);
exit (0);
break;
}
break;
default:
file_name = argv[pos];
break;
}
if( wrong_arg )
{
fprintf(stderr, "%s %s\n", _("wrong argument to option:"), wrong_arg);
printfHelp(argc, argv);
exit(1);
}
++pos;
}
} else
