void IntVisitor::visit(ASTFilterStep &n)
{
int_str.append("(");
int_str.append(int2string(AST_FILTERSTEP));
int_str.append(dumpCommonData(n.cd));
dumpASTNode(n.cont);
dumpASTNode(n.expr);
dumpASTNodesVector(n.preds);
DUMP_BOOL(n.isLast);
DUMP_BOOL(n.use_last);
DUMP_BOOL(n.use_pos);
int_str.append(")");
}
void IntVisitor::visit(ASTCommentConst &n)
{
int_str.append("(");
int_str.append(int2string(AST_COMMENTCONST));
int_str.append(dumpCommonData(n.cd));
dumpASTNode(n.expr);
DUMP_BOOL(n.deep_copy);
int_str.append(")");
}
void IntVisitor::visit(ASTXMLComm &n)
{
int_str.append("(");
int_str.append(int2string(AST_XMLCOMM));
int_str.append(dumpCommonData(n.cd));
DUMP_STR(*n.cont);
DUMP_BOOL(n.deep_copy);
int_str.append(")");
}
void IntVisitor::visit(ASTSpaceSeq &n)
{
int_str.append("(");
int_str.append(int2string(AST_SPACESEQ));
int_str.append(dumpCommonData(n.cd));
dumpASTNode(n.expr);
DUMP_BOOL(n.atomize);
int_str.append(")");
}
void IntVisitor::visit(ASTQuery &n)
{
int_str.append("(");
int_str.append(int2string(AST_QUERY));
int_str.append(dumpCommonData(n.cd));
dumpASTNode(n.query);
int_str.append(int2string(n.type));
DUMP_BOOL(n.is_trigger);
int_str.append(")");
}
void IntVisitor::visit(ASTBop &n)
{
int_str.append("(");
int_str.append(int2string(AST_BOP));
int_str.append(dumpCommonData(n.cd));
int_str.append(int2string(n.op));
dumpASTNode(n.lop);
dumpASTNode(n.rop);
DUMP_BOOL(n.doc_order);
int_str.append(")");
}
void IntVisitor::visit(ASTElem &n)
{
int_str.append("(");
int_str.append(int2string(AST_ELEM));
int_str.append(dumpCommonData(n.cd));
DUMP_STR(*n.pref);
DUMP_STR(*n.local);
dumpASTNodesVector(n.attrs);
dumpASTNodesVector(n.cont);
DUMP_BOOL(n.deep_copy);
int_str.append(")");
}
void IntVisitor::visit(ASTAttr &n)
{
int_str.append("(");
int_str.append(int2string(AST_ATTR));
int_str.append(dumpCommonData(n.cd));
DUMP_STR(*n.pref);
DUMP_STR(*n.local);
dumpASTNodesVector(n.cont);
DUMP_BOOL(n.deep_copy);
if (n.uri)
DUMP_STR(*n.uri);
int_str.append(")");
}
void IntVisitor::visit(ASTPIConst &n)
{
int_str.append("(");
int_str.append(int2string(AST_PICONST));
int_str.append(dumpCommonData(n.cd));
if (n.name)
dumpASTNode(n.name);
else
DUMP_STR(*n.ncname);
dumpASTNode(n.expr);
DUMP_BOOL(n.deep_copy);
int_str.append(")");
}
void IntVisitor::visit(ASTElemConst &n)
{
int_str.append("(");
int_str.append(int2string(AST_ELEMCONST));
int_str.append(dumpCommonData(n.cd));
if (n.name)
{
dumpASTNode(n.name);
}
else
{
DUMP_STR(*n.pref);
DUMP_STR(*n.local);
}
dumpASTNode(n.expr);
DUMP_BOOL(n.deep_copy);
int_str.append(")");
}
int main(int argc, char* argv[])
{
pthread_t termThread;
int isTermThreadStarted = 0;
int audioTrackIdx = -1;
int subtitleTrackIdx = -1;
uint32_t linuxDvbBufferSizeMB = 0;
char argvBuff[256];
memset(argvBuff, '\0', sizeof(argvBuff));
int commandRetVal = -1;
/* inform client that we can handle additional commands */
fprintf(stderr, "{\"EPLAYER3_EXTENDED\":{\"version\":%d}}\n", 51);
PlayFiles_t playbackFiles;
memset(&playbackFiles, 0x00, sizeof(playbackFiles));
if (0 != ParseParams(argc, argv, &playbackFiles, &audioTrackIdx, &subtitleTrackIdx, &linuxDvbBufferSizeMB))
{
printf("Usage: exteplayer3 filePath [-u user-agent] [-c cookies] [-h headers] [-p prio] [-a] [-d] [-w] [-l] [-s] [-i] [-t audioTrackId] [-9 subtitleTrackId] [-x separateAudioUri] plabackUri\n");
printf("[-b size] Linux DVB output buffer size in MB\n");
printf("[-a 0|1|2|3] AAC software decoding - 1 bit - AAC ADTS, 2 - bit AAC LATM\n");
printf("[-e] EAC3 software decoding\n");
printf("[-3] AC3 software decoding\n");
printf("[-d] DTS software decoding\n");
printf("[-m] MP3 software decoding\n");
printf("[-w] WMA1, WMA2, WMA/PRO software decoding\n");
printf("[-l] software decoder use LPCM for injection (otherwise wav PCM will be used)\n");
printf("[-s] software decoding as stereo [downmix]\n");
#ifdef HAVE_FLV2MPEG4_CONVERTER
printf("[-4 0|1] - disable/enable flv2mpeg4 converter\n");
#endif
printf("[-i] play in infinity loop\n");
printf("[-v] switch to live TS stream mode\n");
printf("[-n 0|1|2] rtmp force protocol implementation auto(0) native/ffmpeg(1) or librtmp(2)\n");
printf("[-o 0|1] set progressive download\n");
printf("[-p value] nice value\n");
printf("[-P value] select Program ID from multi-service stream\n");
printf("[-t id] audio track ID switched on at start\n");
printf("[-9 id] subtitle track ID switched on at start\n");
printf("[-h headers] set custom HTTP headers \"Name: value\\r\\nName: value\\r\\n\"\n");
printf("[-u user-agent] set custom http User-Agent header\n");
printf("[-c cookies] set cookies - not working at now, please use -h instead\n");
printf("[-x separateAudioUri]\n");
printf("[-0 idx] video MPEG-DASH representation index\n");
printf("[-1 idx] audio MPEG-DASH representation index\n");
printf("[-f ffopt=ffval] any other ffmpeg option\n");
printf("[-F path to additional file with moov atom data (used for mp4 playback in progressive download mode)\n");
printf("[-O moov atom offset in the original file (used for mp4 playback in progressive download mode)\n");
printf("[-S remote file size (used for mp4 playback in progressive download mode)\n");
exit(1);
}
g_player = malloc(sizeof(Context_t));
if(NULL == g_player)
{
printf("g_player allocate error\n");
exit(1);
}
pthread_mutex_init(&playbackStartMtx, NULL);
do
{
int flags = 0;
if (pipe(g_pfd) == -1)
break;
/* Make read and write ends of pipe nonblocking */
if ((flags = fcntl(g_pfd[0], F_GETFL)) == -1)
break;
/* Make read end nonblocking */
flags |= O_NONBLOCK;
if (fcntl(g_pfd[0], F_SETFL, flags) == -1)
break;
if ((flags = fcntl(g_pfd[1], F_GETFL)) == -1)
break;
/* Make write end nonblocking */
flags |= O_NONBLOCK;
if (fcntl(g_pfd[1], F_SETFL, flags) == -1)
break;
if(0 == pthread_create(&termThread, NULL, TermThreadFun, NULL))
isTermThreadStarted = 1;
} while(0);
g_player->playback = &PlaybackHandler;
g_player->output = &OutputHandler;
g_player->container = &ContainerHandler;
g_player->manager = &ManagerHandler;
// make sure to kill myself when parent dies
prctl(PR_SET_PDEATHSIG, SIGKILL);
SetBuffering();
//Registrating output devices
g_player->output->Command(g_player, OUTPUT_ADD, "audio");
g_player->output->Command(g_player, OUTPUT_ADD, "video");
g_player->output->Command(g_player, OUTPUT_ADD, "subtitle");
//Set LINUX DVB additional write buffer size
if (linuxDvbBufferSizeMB)
g_player->output->Command(g_player, OUTPUT_SET_BUFFER_SIZE, &linuxDvbBufferSizeMB);
g_player->manager->video->Command(g_player, MANAGER_REGISTER_UPDATED_TRACK_INFO, UpdateVideoTrack);
if (strncmp(playbackFiles.szFirstFile, "rtmp", 4) && strncmp(playbackFiles.szFirstFile, "ffrtmp", 4))
{
g_player->playback->noprobe = 1;
}
commandRetVal = g_player->playback->Command(g_player, PLAYBACK_OPEN, &playbackFiles);
fprintf(stderr, "{\"PLAYBACK_OPEN\":{\"OutputName\":\"%s\", \"file\":\"%s\", \"sts\":%d}}\n", g_player->output->Name, playbackFiles.szFirstFile, commandRetVal);
if(commandRetVal < 0)
{
if(NULL != g_player)
{
free(g_player);
}
return 10;
}
{
pthread_mutex_lock(&playbackStartMtx);
isPlaybackStarted = 1;
pthread_mutex_unlock(&playbackStartMtx);
commandRetVal = g_player->output->Command(g_player, OUTPUT_OPEN, NULL);
fprintf(stderr, "{\"OUTPUT_OPEN\":{\"sts\":%d}}\n", commandRetVal);
commandRetVal = g_player->playback->Command(g_player, PLAYBACK_PLAY, NULL);
fprintf(stderr, "{\"PLAYBACK_PLAY\":{\"sts\":%d}}\n", commandRetVal);
if (g_player->playback->isPlaying)
{
PlaybackDieNowRegisterCallback(TerminateWakeUp);
HandleTracks(g_player->manager->video, (PlaybackCmd_t)-1, "vc");
HandleTracks(g_player->manager->audio, (PlaybackCmd_t)-1, "al");
if (audioTrackIdx >= 0)
{
static char cmd[128] = ""; // static to not allocate on stack
sprintf(cmd, "ai%d\n", audioTrackIdx);
commandRetVal = HandleTracks(g_player->manager->audio, PLAYBACK_SWITCH_AUDIO, cmd);
}
HandleTracks(g_player->manager->audio, (PlaybackCmd_t)-1, "ac");
HandleTracks(g_player->manager->subtitle, (PlaybackCmd_t)-1, "sl");
if (subtitleTrackIdx >= 0)
{
static char cmd[128] = ""; // static to not allocate on stack
sprintf(cmd, "si%d\n", subtitleTrackIdx);
commandRetVal = HandleTracks(g_player->manager->subtitle, PLAYBACK_SWITCH_SUBTITLE, cmd);
}
HandleTracks(g_player->manager->subtitle, (PlaybackCmd_t)-1, "sc");
}
while(g_player->playback->isPlaying && 0 == PlaybackDieNow(0))
{
/* we made fgets non blocking */
if( NULL == fgets(argvBuff, sizeof(argvBuff)-1 , stdin) )
{
/* wait for data - max 1s */
kbhit();
continue;
}
if(0 == argvBuff[0])
{
continue;
}
switch(argvBuff[0])
{
case 'v':
{
HandleTracks(g_player->manager->video, (PlaybackCmd_t)-1, argvBuff);
break;
}
case 'a':
{
HandleTracks(g_player->manager->audio, PLAYBACK_SWITCH_AUDIO, argvBuff);
break;
}
case 's':
{
HandleTracks(g_player->manager->subtitle, PLAYBACK_SWITCH_SUBTITLE, argvBuff);
break;
}
case 'q':
{
commandRetVal = g_player->playback->Command(g_player, PLAYBACK_STOP, NULL);
fprintf(stderr, "{\"PLAYBACK_STOP\":{\"sts\":%d}}\n", commandRetVal);
break;
}
case 'c':
{
commandRetVal = g_player->playback->Command(g_player, PLAYBACK_CONTINUE, NULL);
fprintf(stderr, "{\"PLAYBACK_CONTINUE\":{\"sts\":%d}}\n", commandRetVal);
break;
}
case 'p':
{
commandRetVal = g_player->playback->Command(g_player, PLAYBACK_PAUSE, NULL);
fprintf(stderr, "{\"PLAYBACK_PAUSE\":{\"sts\":%d}}\n", commandRetVal);
break;
}
case 'm':
{
int speed = 0;
sscanf(argvBuff+1, "%d", &speed);
commandRetVal = g_player->playback->Command(g_player, PLAYBACK_SLOWMOTION, &speed);
fprintf(stderr, "{\"PLAYBACK_SLOWMOTION\":{\"speed\":%d, \"sts\":%d}}\n", speed, commandRetVal);
break;
}
case 'o':
{
int flags = 0;
if( 1 == sscanf(argvBuff+1, "%d", &flags) )
{
progressive_playback_set(flags);
fprintf(stderr, "{\"PROGRESSIVE_DOWNLOAD\":{\"flags\":%d, \"sts\":0}}\n", flags);
}
break;
}
case 'f':
{
int speed = 0;
sscanf(argvBuff+1, "%d", &speed);
commandRetVal = g_player->playback->Command(g_player, PLAYBACK_FASTFORWARD, &speed);
fprintf(stderr, "{\"PLAYBACK_FASTFORWARD\":{\"speed\":%d, \"sts\":%d}}\n", speed, commandRetVal);
break;
}
case 'b':
{
int speed = 0;
sscanf(argvBuff+1, "%d", &speed);
commandRetVal = g_player->playback->Command(g_player, PLAYBACK_FASTBACKWARD, &speed);
fprintf(stderr, "{\"PLAYBACK_FASTBACKWARD\":{\"speed\":%d, \"sts\":%d}}\n", speed, commandRetVal);
break;
}
case 'g':
{
int32_t gotoPos = 0;
int64_t length = 0;
int32_t lengthInt = 0;
int64_t sec = 0;
int8_t force = ('f' == argvBuff[1]) ? 1 : 0; // f - force, c - check
sscanf(argvBuff+2, "%d", &gotoPos);
if(0 <= gotoPos || force)
{
commandRetVal = g_player->playback->Command(g_player, PLAYBACK_LENGTH, (void*)&length);
fprintf(stderr, "{\"PLAYBACK_LENGTH\":{\"length\":%"PRId64", \"sts\":%d}}\n", length, commandRetVal);
lengthInt = (int32_t)length;
if(10 <= lengthInt || force)
{
sec = gotoPos;
if(!force && gotoPos >= lengthInt)
{
sec = lengthInt - 10;
}
commandRetVal = g_player->playback->Command(g_player, PLAYBACK_SEEK_ABS, (void*)&sec);
fprintf(stderr, "{\"PLAYBACK_SEEK_ABS\":{\"sec\":%"PRId64", \"sts\":%d}}\n", sec, commandRetVal);
}
}
break;
}
case 'k':
{
int32_t seek = 0;
int64_t length = 0;
int32_t lengthInt = 0;
int64_t sec = 0;
int64_t pts = 0;
int32_t CurrentSec = 0;
int8_t force = ('f' == argvBuff[1]) ? 1 : 0; // f - force, c - check
sscanf(argvBuff+2, "%d", &seek);
commandRetVal = g_player->playback->Command(g_player, PLAYBACK_PTS, &pts);
CurrentSec = (int32_t)(pts / 90000);
if (0 == commandRetVal)
{
fprintf(stderr, "{\"J\":{\"ms\":%"PRId64"}}\n", pts / 90);
}
if(0 == commandRetVal || force)
{
commandRetVal = g_player->playback->Command(g_player, PLAYBACK_LENGTH, (void*)&length);
fprintf(stderr, "{\"PLAYBACK_LENGTH\":{\"length\":%"PRId64", \"sts\":%d}}\n", length, commandRetVal);
lengthInt = (int32_t)length;
if(10 <= lengthInt || force )
{
int32_t ergSec = CurrentSec + seek;
if(!force && 0 > ergSec)
{
sec = CurrentSec * -1; // jump to start position
}
else if(!force && ergSec >= lengthInt)
{
sec = (lengthInt - CurrentSec) - 5;
if(0 < sec)
{
sec = 0; // no jump we are at the end
}
}
else
{
sec = seek;
}
}
commandRetVal = g_player->playback->Command(g_player, PLAYBACK_SEEK, (void*)&sec);
fprintf(stderr, "{\"PLAYBACK_SEEK\":{\"sec\":%"PRId64", \"sts\":%d}}\n", sec, commandRetVal);
}
break;
}
case 'l':
{
int64_t length = 0;
commandRetVal = g_player->playback->Command(g_player, PLAYBACK_LENGTH, (void*)&length);
fprintf(stderr, "{\"PLAYBACK_LENGTH\":{\"length\":%"PRId64", \"sts\":%d}}\n", length, commandRetVal);
break;
}
case 'j':
{
int64_t pts = 0;
commandRetVal = g_player->playback->Command(g_player, PLAYBACK_PTS, &pts);
if (0 == commandRetVal)
{
int64_t lastPts = 0;
commandRetVal = 1;
if (g_player->container && g_player->container->selectedContainer)
{
commandRetVal = g_player->container->selectedContainer->Command(g_player->container, CONTAINER_LAST_PTS, &lastPts);
}
if (0 == commandRetVal && lastPts != INVALID_PTS_VALUE)
{
fprintf(stderr, "{\"J\":{\"ms\":%"PRId64",\"lms\":%"PRId64"}}\n", pts / 90, lastPts / 90);
}
else
{
fprintf(stderr, "{\"J\":{\"ms\":%"PRId64"}}\n", pts / 90);
}
}
break;
}
case 'i':
{
PlaybackHandler_t *ptrP = g_player->playback;
if(ptrP)
{
fprintf(stderr, "{\"PLAYBACK_INFO\":{ \"isPlaying\":%s, \"isPaused\":%s, \"isForwarding\":%s, \"isSeeking\":%s, \"isCreationPhase\":%s,", \
DUMP_BOOL(ptrP->isPlaying), DUMP_BOOL(ptrP->isPaused), DUMP_BOOL(ptrP->isForwarding), DUMP_BOOL(ptrP->isSeeking), DUMP_BOOL(ptrP->isCreationPhase) );
fprintf(stderr, "\"BackWard\":%d, \"SlowMotion\":%d, \"Speed\":%d, \"AVSync\":%d,", ptrP->BackWard, ptrP->SlowMotion, ptrP->Speed, ptrP->AVSync);
fprintf(stderr, " \"isVideo\":%s, \"isAudio\":%s, \"isSubtitle\":%s, \"isDvbSubtitle\":%s, \"isTeletext\":%s, \"mayWriteToFramebuffer\":%s, \"abortRequested\":%s }}\n", \
DUMP_BOOL(ptrP->isVideo), DUMP_BOOL(ptrP->isAudio), DUMP_BOOL(0), DUMP_BOOL(0), DUMP_BOOL(0), DUMP_BOOL(0), DUMP_BOOL(ptrP->abortRequested) );
}
break;
}
case 'n':
{
uint8_t loop = 0;
if( '1' == argvBuff[1] || '0' == argvBuff[1] )
{
PlaybackHandler_t *ptrP = g_player->playback;
if(ptrP)
{
ptrP->isLoopMode = '1' == argvBuff[1] ? 1 : 0;
fprintf(stderr, "{\"N\":{ \"isLoop\":%s }}\n", DUMP_BOOL(ptrP->isLoopMode));
}
}
break;
}
default:
{
break;
}
}
}
g_player->output->Command(g_player, OUTPUT_CLOSE, NULL);
}
if(NULL != g_player)
{
free(g_player);
}
if (isTermThreadStarted && 1 == write(g_pfd[1], "x", 1))
{
pthread_join(termThread, NULL);
}
pthread_mutex_destroy(&playbackStartMtx);
close(g_pfd[0]);
close(g_pfd[1]);
exit(0);
}
/** ---------------------------------------------------
* See documentation in nsPrintOptionsImpl.h
* @update 1/12/01 rods
*/
nsresult
nsPrintOptions::WritePrefs(nsIPrintSettings *aPS, const nsAString& aPrinterName,
PRUint32 aFlags)
{
NS_ENSURE_ARG_POINTER(aPS);
NS_ENSURE_STATE(mPrefBranch);
nsIntMargin margin;
if (aFlags & nsIPrintSettings::kInitSaveMargins) {
if (NS_SUCCEEDED(aPS->GetMarginInTwips(margin))) {
WriteInchesFromTwipsPref(GetPrefName(kMarginTop, aPrinterName),
margin.top);
DUMP_INT(kWriteStr, kMarginTop, margin.top);
WriteInchesFromTwipsPref(GetPrefName(kMarginLeft, aPrinterName),
margin.left);
DUMP_INT(kWriteStr, kMarginLeft, margin.top);
WriteInchesFromTwipsPref(GetPrefName(kMarginBottom, aPrinterName),
margin.bottom);
DUMP_INT(kWriteStr, kMarginBottom, margin.top);
WriteInchesFromTwipsPref(GetPrefName(kMarginRight, aPrinterName),
margin.right);
DUMP_INT(kWriteStr, kMarginRight, margin.top);
}
}
nsIntMargin edge;
if (aFlags & nsIPrintSettings::kInitSaveEdges) {
if (NS_SUCCEEDED(aPS->GetEdgeInTwips(edge))) {
WriteInchesIntFromTwipsPref(GetPrefName(kEdgeTop, aPrinterName),
edge.top);
DUMP_INT(kWriteStr, kEdgeTop, edge.top);
WriteInchesIntFromTwipsPref(GetPrefName(kEdgeLeft, aPrinterName),
edge.left);
DUMP_INT(kWriteStr, kEdgeLeft, edge.top);
WriteInchesIntFromTwipsPref(GetPrefName(kEdgeBottom, aPrinterName),
edge.bottom);
DUMP_INT(kWriteStr, kEdgeBottom, edge.top);
WriteInchesIntFromTwipsPref(GetPrefName(kEdgeRight, aPrinterName),
edge.right);
DUMP_INT(kWriteStr, kEdgeRight, edge.top);
}
}
nsIntMargin unwriteableMargin;
if (aFlags & nsIPrintSettings::kInitSaveUnwriteableMargins) {
if (NS_SUCCEEDED(aPS->GetUnwriteableMarginInTwips(unwriteableMargin))) {
WriteInchesIntFromTwipsPref(GetPrefName(kUnwriteableMarginTop, aPrinterName),
unwriteableMargin.top);
DUMP_INT(kWriteStr, kUnwriteableMarginTop, unwriteableMargin.top);
WriteInchesIntFromTwipsPref(GetPrefName(kUnwriteableMarginLeft, aPrinterName),
unwriteableMargin.left);
DUMP_INT(kWriteStr, kUnwriteableMarginLeft, unwriteableMargin.top);
WriteInchesIntFromTwipsPref(GetPrefName(kUnwriteableMarginBottom, aPrinterName),
unwriteableMargin.bottom);
DUMP_INT(kWriteStr, kUnwriteableMarginBottom, unwriteableMargin.top);
WriteInchesIntFromTwipsPref(GetPrefName(kUnwriteableMarginRight, aPrinterName),
unwriteableMargin.right);
DUMP_INT(kWriteStr, kUnwriteableMarginRight, unwriteableMargin.top);
}
}
// Paper size prefs are saved as a group
if (aFlags & nsIPrintSettings::kInitSavePaperSize) {
PRInt16 sizeUnit, sizeType;
double width, height;
PRUnichar *name;
if (
NS_SUCCEEDED(aPS->GetPaperSizeUnit(&sizeUnit)) &&
NS_SUCCEEDED(aPS->GetPaperSizeType(&sizeType)) &&
NS_SUCCEEDED(aPS->GetPaperWidth(&width)) &&
NS_SUCCEEDED(aPS->GetPaperHeight(&height)) &&
NS_SUCCEEDED(aPS->GetPaperName(&name))
) {
DUMP_INT(kWriteStr, kPrintPaperSizeUnit, sizeUnit);
mPrefBranch->SetIntPref(GetPrefName(kPrintPaperSizeUnit, aPrinterName),
PRInt32(sizeUnit));
DUMP_INT(kWriteStr, kPrintPaperSizeType, sizeType);
mPrefBranch->SetIntPref(GetPrefName(kPrintPaperSizeType, aPrinterName),
PRInt32(sizeType));
DUMP_DBL(kWriteStr, kPrintPaperWidth, width);
WritePrefDouble(GetPrefName(kPrintPaperWidth, aPrinterName), width);
DUMP_DBL(kWriteStr, kPrintPaperHeight, height);
WritePrefDouble(GetPrefName(kPrintPaperHeight, aPrinterName), height);
DUMP_STR(kWriteStr, kPrintPaperName, name);
WritePrefString(name, GetPrefName(kPrintPaperName, aPrinterName));
}
}
PRBool b;
PRUnichar* uStr;
PRInt32 iVal;
PRInt16 iVal16;
double dbl;
if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
if (NS_SUCCEEDED(aPS->GetPrintOptions(nsIPrintSettings::kPrintEvenPages,
&b))) {
DUMP_BOOL(kWriteStr, kPrintEvenPages, b);
mPrefBranch->SetBoolPref(GetPrefName(kPrintEvenPages, aPrinterName),
b);
}
}
if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
if (NS_SUCCEEDED(aPS->GetPrintOptions(nsIPrintSettings::kPrintOddPages,
&b))) {
DUMP_BOOL(kWriteStr, kPrintOddPages, b);
mPrefBranch->SetBoolPref(GetPrefName(kPrintOddPages, aPrinterName),
b);
}
}
if (aFlags & nsIPrintSettings::kInitSaveHeaderLeft) {
if (NS_SUCCEEDED(aPS->GetHeaderStrLeft(&uStr))) {
DUMP_STR(kWriteStr, kPrintHeaderStrLeft, uStr);
WritePrefString(uStr, GetPrefName(kPrintHeaderStrLeft, aPrinterName));
}
}
if (aFlags & nsIPrintSettings::kInitSaveHeaderCenter) {
if (NS_SUCCEEDED(aPS->GetHeaderStrCenter(&uStr))) {
DUMP_STR(kWriteStr, kPrintHeaderStrCenter, uStr);
WritePrefString(uStr, GetPrefName(kPrintHeaderStrCenter, aPrinterName));
}
}
if (aFlags & nsIPrintSettings::kInitSaveHeaderRight) {
if (NS_SUCCEEDED(aPS->GetHeaderStrRight(&uStr))) {
DUMP_STR(kWriteStr, kPrintHeaderStrRight, uStr);
WritePrefString(uStr, GetPrefName(kPrintHeaderStrRight, aPrinterName));
}
}
if (aFlags & nsIPrintSettings::kInitSaveFooterLeft) {
if (NS_SUCCEEDED(aPS->GetFooterStrLeft(&uStr))) {
DUMP_STR(kWriteStr, kPrintFooterStrLeft, uStr);
WritePrefString(uStr, GetPrefName(kPrintFooterStrLeft, aPrinterName));
}
}
if (aFlags & nsIPrintSettings::kInitSaveFooterCenter) {
if (NS_SUCCEEDED(aPS->GetFooterStrCenter(&uStr))) {
DUMP_STR(kWriteStr, kPrintFooterStrCenter, uStr);
WritePrefString(uStr, GetPrefName(kPrintFooterStrCenter, aPrinterName));
}
}
if (aFlags & nsIPrintSettings::kInitSaveFooterRight) {
if (NS_SUCCEEDED(aPS->GetFooterStrRight(&uStr))) {
DUMP_STR(kWriteStr, kPrintFooterStrRight, uStr);
WritePrefString(uStr, GetPrefName(kPrintFooterStrRight, aPrinterName));
}
}
if (aFlags & nsIPrintSettings::kInitSaveBGColors) {
if (NS_SUCCEEDED(aPS->GetPrintBGColors(&b))) {
DUMP_BOOL(kWriteStr, kPrintBGColors, b);
mPrefBranch->SetBoolPref(GetPrefName(kPrintBGColors, aPrinterName), b);
}
}
if (aFlags & nsIPrintSettings::kInitSaveBGImages) {
if (NS_SUCCEEDED(aPS->GetPrintBGImages(&b))) {
DUMP_BOOL(kWriteStr, kPrintBGImages, b);
mPrefBranch->SetBoolPref(GetPrefName(kPrintBGImages, aPrinterName), b);
}
}
if (aFlags & nsIPrintSettings::kInitSaveReversed) {
if (NS_SUCCEEDED(aPS->GetPrintReversed(&b))) {
DUMP_BOOL(kWriteStr, kPrintReversed, b);
mPrefBranch->SetBoolPref(GetPrefName(kPrintReversed, aPrinterName), b);
}
}
if (aFlags & nsIPrintSettings::kInitSaveInColor) {
if (NS_SUCCEEDED(aPS->GetPrintInColor(&b))) {
DUMP_BOOL(kWriteStr, kPrintInColor, b);
mPrefBranch->SetBoolPref(GetPrefName(kPrintInColor, aPrinterName), b);
}
}
if (aFlags & nsIPrintSettings::kInitSavePlexName) {
if (NS_SUCCEEDED(aPS->GetPlexName(&uStr))) {
DUMP_STR(kWriteStr, kPrintPlexName, uStr);
WritePrefString(uStr, GetPrefName(kPrintPlexName, aPrinterName));
}
}
if (aFlags & nsIPrintSettings::kInitSavePaperData) {
if (NS_SUCCEEDED(aPS->GetPaperData(&iVal16))) {
DUMP_INT(kWriteStr, kPrintPaperData, iVal16);
mPrefBranch->SetIntPref(GetPrefName(kPrintPaperData, aPrinterName),
PRInt32(iVal16));
}
}
if (aFlags & nsIPrintSettings::kInitSaveColorspace) {
if (NS_SUCCEEDED(aPS->GetColorspace(&uStr))) {
DUMP_STR(kWriteStr, kPrintColorspace, uStr);
WritePrefString(uStr, GetPrefName(kPrintColorspace, aPrinterName));
}
}
if (aFlags & nsIPrintSettings::kInitSaveResolutionName) {
if (NS_SUCCEEDED(aPS->GetResolutionName(&uStr))) {
DUMP_STR(kWriteStr, kPrintResolutionName, uStr);
WritePrefString(uStr, GetPrefName(kPrintResolutionName, aPrinterName));
}
}
if (aFlags & nsIPrintSettings::kInitSaveDownloadFonts) {
if (NS_SUCCEEDED(aPS->GetDownloadFonts(&b))) {
DUMP_BOOL(kWriteStr, kPrintDownloadFonts, b);
mPrefBranch->SetBoolPref(GetPrefName(kPrintDownloadFonts, aPrinterName),
b);
}
}
if (aFlags & nsIPrintSettings::kInitSaveOrientation) {
if (NS_SUCCEEDED(aPS->GetOrientation(&iVal))) {
DUMP_INT(kWriteStr, kPrintOrientation, iVal);
mPrefBranch->SetIntPref(GetPrefName(kPrintOrientation, aPrinterName),
iVal);
}
}
if (aFlags & nsIPrintSettings::kInitSavePrintCommand) {
if (NS_SUCCEEDED(aPS->GetPrintCommand(&uStr))) {
DUMP_STR(kWriteStr, kPrintCommand, uStr);
WritePrefString(uStr, GetPrefName(kPrintCommand, aPrinterName));
}
}
// Only the general version of this pref is saved
if ((aFlags & nsIPrintSettings::kInitSavePrinterName)
&& aPrinterName.IsEmpty()) {
if (NS_SUCCEEDED(aPS->GetPrinterName(&uStr))) {
DUMP_STR(kWriteStr, kPrinterName, uStr);
WritePrefString(uStr, kPrinterName);
}
}
if (aFlags & nsIPrintSettings::kInitSavePrintToFile) {
if (NS_SUCCEEDED(aPS->GetPrintToFile(&b))) {
DUMP_BOOL(kWriteStr, kPrintToFile, b);
mPrefBranch->SetBoolPref(GetPrefName(kPrintToFile, aPrinterName), b);
}
}
if (aFlags & nsIPrintSettings::kInitSaveToFileName) {
if (NS_SUCCEEDED(aPS->GetToFileName(&uStr))) {
DUMP_STR(kWriteStr, kPrintToFileName, uStr);
WritePrefString(uStr, GetPrefName(kPrintToFileName, aPrinterName));
}
}
if (aFlags & nsIPrintSettings::kInitSavePageDelay) {
if (NS_SUCCEEDED(aPS->GetPrintPageDelay(&iVal))) {
DUMP_INT(kWriteStr, kPrintPageDelay, iVal);
mPrefBranch->SetIntPref(GetPrefName(kPrintPageDelay, aPrinterName), iVal);
}
}
if (aFlags & nsIPrintSettings::kInitSaveShrinkToFit) {
if (NS_SUCCEEDED(aPS->GetShrinkToFit(&b))) {
DUMP_BOOL(kWriteStr, kPrintShrinkToFit, b);
mPrefBranch->SetBoolPref(GetPrefName(kPrintShrinkToFit, aPrinterName), b);
}
}
if (aFlags & nsIPrintSettings::kInitSaveScaling) {
if (NS_SUCCEEDED(aPS->GetScaling(&dbl))) {
DUMP_DBL(kWriteStr, kPrintScaling, dbl);
WritePrefDouble(GetPrefName(kPrintScaling, aPrinterName), dbl);
}
}
// Not Writing Out:
// Number of Copies
return NS_OK;
}
/**
* This will either read in the generic prefs (not specific to a printer)
* or read the prefs in using the printer name to qualify.
* It is either "print.attr_name" or "print.printer_HPLasr5.attr_name"
*/
nsresult
nsPrintOptions::ReadPrefs(nsIPrintSettings* aPS, const nsAString& aPrinterName,
PRUint32 aFlags)
{
NS_ENSURE_STATE(mPrefBranch);
NS_ENSURE_ARG_POINTER(aPS);
if (aFlags & nsIPrintSettings::kInitSaveMargins) {
PRInt32 halfInch = NS_INCHES_TO_INT_TWIPS(0.5);
nsIntMargin margin(halfInch, halfInch, halfInch, halfInch);
ReadInchesToTwipsPref(GetPrefName(kMarginTop, aPrinterName), margin.top,
kMarginTop);
DUMP_INT(kReadStr, kMarginTop, margin.top);
ReadInchesToTwipsPref(GetPrefName(kMarginLeft, aPrinterName), margin.left,
kMarginLeft);
DUMP_INT(kReadStr, kMarginLeft, margin.left);
ReadInchesToTwipsPref(GetPrefName(kMarginBottom, aPrinterName),
margin.bottom, kMarginBottom);
DUMP_INT(kReadStr, kMarginBottom, margin.bottom);
ReadInchesToTwipsPref(GetPrefName(kMarginRight, aPrinterName), margin.right,
kMarginRight);
DUMP_INT(kReadStr, kMarginRight, margin.right);
aPS->SetMarginInTwips(margin);
}
if (aFlags & nsIPrintSettings::kInitSaveEdges) {
nsIntMargin margin(0,0,0,0);
ReadInchesIntToTwipsPref(GetPrefName(kEdgeTop, aPrinterName), margin.top,
kEdgeTop);
DUMP_INT(kReadStr, kEdgeTop, margin.top);
ReadInchesIntToTwipsPref(GetPrefName(kEdgeLeft, aPrinterName), margin.left,
kEdgeLeft);
DUMP_INT(kReadStr, kEdgeLeft, margin.left);
ReadInchesIntToTwipsPref(GetPrefName(kEdgeBottom, aPrinterName),
margin.bottom, kEdgeBottom);
DUMP_INT(kReadStr, kEdgeBottom, margin.bottom);
ReadInchesIntToTwipsPref(GetPrefName(kEdgeRight, aPrinterName), margin.right,
kEdgeRight);
DUMP_INT(kReadStr, kEdgeRight, margin.right);
aPS->SetEdgeInTwips(margin);
}
if (aFlags & nsIPrintSettings::kInitSaveUnwriteableMargins) {
nsIntMargin margin;
ReadInchesIntToTwipsPref(GetPrefName(kUnwriteableMarginTop, aPrinterName), margin.top,
kUnwriteableMarginTop);
DUMP_INT(kReadStr, kUnwriteableMarginTop, margin.top);
ReadInchesIntToTwipsPref(GetPrefName(kUnwriteableMarginLeft, aPrinterName), margin.left,
kUnwriteableMarginLeft);
DUMP_INT(kReadStr, kUnwriteableMarginLeft, margin.left);
ReadInchesIntToTwipsPref(GetPrefName(kUnwriteableMarginBottom, aPrinterName),
margin.bottom, kUnwriteableMarginBottom);
DUMP_INT(kReadStr, kUnwriteableMarginBottom, margin.bottom);
ReadInchesIntToTwipsPref(GetPrefName(kUnwriteableMarginRight, aPrinterName), margin.right,
kUnwriteableMarginRight);
DUMP_INT(kReadStr, kUnwriteableMarginRight, margin.right);
aPS->SetUnwriteableMarginInTwips(margin);
}
PRBool b;
nsAutoString str;
PRInt32 iVal;
double dbl;
#define GETBOOLPREF(_prefname, _retval) \
NS_SUCCEEDED( \
mPrefBranch->GetBoolPref( \
GetPrefName(_prefname, aPrinterName), _retval \
) \
)
#define GETSTRPREF(_prefname, _retval) \
NS_SUCCEEDED( \
ReadPrefString( \
GetPrefName(_prefname, aPrinterName), _retval \
) \
)
#define GETINTPREF(_prefname, _retval) \
NS_SUCCEEDED( \
mPrefBranch->GetIntPref( \
GetPrefName(_prefname, aPrinterName), _retval \
) \
)
#define GETDBLPREF(_prefname, _retval) \
NS_SUCCEEDED( \
ReadPrefDouble( \
GetPrefName(_prefname, aPrinterName), _retval \
) \
)
// Paper size prefs are read as a group
if (aFlags & nsIPrintSettings::kInitSavePaperSize) {
PRInt32 sizeUnit, sizeType;
double width, height;
PRBool success = GETINTPREF(kPrintPaperSizeUnit, &sizeUnit)
&& GETINTPREF(kPrintPaperSizeType, &sizeType)
&& GETDBLPREF(kPrintPaperWidth, width)
&& GETDBLPREF(kPrintPaperHeight, height)
&& GETSTRPREF(kPrintPaperName, str);
// Bug 315687: Sanity check paper size to avoid paper size values in
// mm when the size unit flag is inches. The value 100 is arbitrary
// and can be changed.
if (success) {
success = (sizeUnit != nsIPrintSettings::kPaperSizeInches)
|| (width < 100.0)
|| (height < 100.0);
}
if (success) {
aPS->SetPaperSizeUnit(sizeUnit);
DUMP_INT(kReadStr, kPrintPaperSizeUnit, sizeUnit);
aPS->SetPaperSizeType(sizeType);
DUMP_INT(kReadStr, kPrintPaperSizeType, sizeType);
aPS->SetPaperWidth(width);
DUMP_DBL(kReadStr, kPrintPaperWidth, width);
aPS->SetPaperHeight(height);
DUMP_DBL(kReadStr, kPrintPaperHeight, height);
aPS->SetPaperName(str.get());
DUMP_STR(kReadStr, kPrintPaperName, str.get());
}
}
if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
if (GETBOOLPREF(kPrintEvenPages, &b)) {
aPS->SetPrintOptions(nsIPrintSettings::kPrintEvenPages, b);
DUMP_BOOL(kReadStr, kPrintEvenPages, b);
}
}
if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
if (GETBOOLPREF(kPrintOddPages, &b)) {
aPS->SetPrintOptions(nsIPrintSettings::kPrintOddPages, b);
DUMP_BOOL(kReadStr, kPrintOddPages, b);
}
}
if (aFlags & nsIPrintSettings::kInitSaveHeaderLeft) {
if (GETSTRPREF(kPrintHeaderStrLeft, str)) {
aPS->SetHeaderStrLeft(str.get());
DUMP_STR(kReadStr, kPrintHeaderStrLeft, str.get());
}
}
if (aFlags & nsIPrintSettings::kInitSaveHeaderCenter) {
if (GETSTRPREF(kPrintHeaderStrCenter, str)) {
aPS->SetHeaderStrCenter(str.get());
DUMP_STR(kReadStr, kPrintHeaderStrCenter, str.get());
}
}
if (aFlags & nsIPrintSettings::kInitSaveHeaderRight) {
if (GETSTRPREF(kPrintHeaderStrRight, str)) {
aPS->SetHeaderStrRight(str.get());
DUMP_STR(kReadStr, kPrintHeaderStrRight, str.get());
}
}
if (aFlags & nsIPrintSettings::kInitSaveFooterLeft) {
if (GETSTRPREF(kPrintFooterStrLeft, str)) {
aPS->SetFooterStrLeft(str.get());
DUMP_STR(kReadStr, kPrintFooterStrLeft, str.get());
}
}
if (aFlags & nsIPrintSettings::kInitSaveFooterCenter) {
if (GETSTRPREF(kPrintFooterStrCenter, str)) {
aPS->SetFooterStrCenter(str.get());
DUMP_STR(kReadStr, kPrintFooterStrCenter, str.get());
}
}
if (aFlags & nsIPrintSettings::kInitSaveFooterRight) {
if (GETSTRPREF(kPrintFooterStrRight, str)) {
aPS->SetFooterStrRight(str.get());
DUMP_STR(kReadStr, kPrintFooterStrRight, str.get());
}
}
if (aFlags & nsIPrintSettings::kInitSaveBGColors) {
if (GETBOOLPREF(kPrintBGColors, &b)) {
aPS->SetPrintBGColors(b);
DUMP_BOOL(kReadStr, kPrintBGColors, b);
}
}
if (aFlags & nsIPrintSettings::kInitSaveBGImages) {
if (GETBOOLPREF(kPrintBGImages, &b)) {
aPS->SetPrintBGImages(b);
DUMP_BOOL(kReadStr, kPrintBGImages, b);
}
}
if (aFlags & nsIPrintSettings::kInitSaveReversed) {
if (GETBOOLPREF(kPrintReversed, &b)) {
aPS->SetPrintReversed(b);
DUMP_BOOL(kReadStr, kPrintReversed, b);
}
}
if (aFlags & nsIPrintSettings::kInitSaveInColor) {
if (GETBOOLPREF(kPrintInColor, &b)) {
aPS->SetPrintInColor(b);
DUMP_BOOL(kReadStr, kPrintInColor, b);
}
}
if (aFlags & nsIPrintSettings::kInitSavePlexName) {
if (GETSTRPREF(kPrintPlexName, str)) {
aPS->SetPlexName(str.get());
DUMP_STR(kReadStr, kPrintPlexName, str.get());
}
}
if (aFlags & nsIPrintSettings::kInitSavePaperData) {
if (GETINTPREF(kPrintPaperData, &iVal)) {
aPS->SetPaperData(iVal);
DUMP_INT(kReadStr, kPrintPaperData, iVal);
}
}
if (aFlags & nsIPrintSettings::kInitSaveColorspace) {
if (GETSTRPREF(kPrintColorspace, str)) {
aPS->SetColorspace(str.get());
DUMP_STR(kReadStr, kPrintColorspace, str.get());
}
}
if (aFlags & nsIPrintSettings::kInitSaveResolutionName) {
if (GETSTRPREF(kPrintResolutionName, str)) {
aPS->SetResolutionName(str.get());
DUMP_STR(kReadStr, kPrintResolutionName, str.get());
}
}
if (aFlags & nsIPrintSettings::kInitSaveDownloadFonts) {
if (GETBOOLPREF(kPrintDownloadFonts, &b)) {
aPS->SetDownloadFonts(b);
DUMP_BOOL(kReadStr, kPrintDownloadFonts, b);
}
}
if (aFlags & nsIPrintSettings::kInitSaveOrientation) {
if (GETINTPREF(kPrintOrientation, &iVal)) {
aPS->SetOrientation(iVal);
DUMP_INT(kReadStr, kPrintOrientation, iVal);
}
}
if (aFlags & nsIPrintSettings::kInitSavePrintCommand) {
if (GETSTRPREF(kPrintCommand, str)) {
aPS->SetPrintCommand(str.get());
DUMP_STR(kReadStr, kPrintCommand, str.get());
}
}
if (aFlags & nsIPrintSettings::kInitSavePrintToFile) {
if (GETBOOLPREF(kPrintToFile, &b)) {
aPS->SetPrintToFile(b);
DUMP_BOOL(kReadStr, kPrintToFile, b);
}
}
if (aFlags & nsIPrintSettings::kInitSaveToFileName) {
if (GETSTRPREF(kPrintToFileName, str)) {
aPS->SetToFileName(str.get());
DUMP_STR(kReadStr, kPrintToFileName, str.get());
}
}
if (aFlags & nsIPrintSettings::kInitSavePageDelay) {
if (GETINTPREF(kPrintPageDelay, &iVal)) {
aPS->SetPrintPageDelay(iVal);
DUMP_INT(kReadStr, kPrintPageDelay, iVal);
}
}
if (aFlags & nsIPrintSettings::kInitSaveShrinkToFit) {
if (GETBOOLPREF(kPrintShrinkToFit, &b)) {
aPS->SetShrinkToFit(b);
DUMP_BOOL(kReadStr, kPrintShrinkToFit, b);
}
}
if (aFlags & nsIPrintSettings::kInitSaveScaling) {
if (GETDBLPREF(kPrintScaling, dbl)) {
aPS->SetScaling(dbl);
DUMP_DBL(kReadStr, kPrintScaling, dbl);
}
}
// Not Reading In:
// Number of Copies
return NS_OK;
}
