static void dump(void)
{
int i;
DUMP_INT(MPIR_being_debugged);
DUMP_INT(MPIR_debug_state);
DUMP_INT(MPIR_partial_attach_ok);
DUMP_INT(MPIR_i_am_starter);
DUMP_INT(MPIR_forward_output);
DUMP_INT(MPIR_proctable_size);
fprintf(stderr, " MPIR_proctable:\n");
for (i = 0; i < MPIR_proctable_size; i++) {
fprintf(stderr,
" (i, host, exe, pid) = (%d, %s, %s, %d)\n",
i,
MPIR_proctable[i].host_name,
MPIR_proctable[i].executable_name,
MPIR_proctable[i].pid);
}
fprintf(stderr, "MPIR_executable_path: %s\n",
('\0' == MPIR_executable_path[0]) ?
"NULL" : (char*) MPIR_executable_path);
fprintf(stderr, "MPIR_server_arguments: %s\n",
('\0' == MPIR_server_arguments[0]) ?
"NULL" : (char*) MPIR_server_arguments);
}
void dump_item( IDispatchPtr dispatch, QXmlStreamWriter &stream )
{
TRACE(OutlookSyncPlugin) << "OutlookTodoSync::dump_item";
Q_ASSERT( dispatch );
Outlook::_TaskItemPtr item( dispatch );
Outlook::UserPropertiesPtr props = item->GetUserProperties();
Q_ASSERT(props);
PREPARE_MAPI(Task);
stream.writeStartElement("Task");
DUMP_STRING(Identifier,EntryID);
DUMP_STRING(Description,Subject);
QString high = "High";
QString low = "Low";
{
Outlook::UserPropertyPtr up = props->Find("Qtopia Priority");
if ( up ) {
QString priority = variant_to_qstring(up->GetValue());
if ( priority == "VeryHigh" && item->GetImportance() == Outlook::olImportanceHigh )
high = "VeryHigh";
if ( priority == "VeryLow" && item->GetImportance() == Outlook::olImportanceLow )
low = "VeryLow";
}
}
stream.writeStartElement("Priority");
DUMP_ENUM_V(Priority,Importance,Outlook::olImportanceHigh,high);
DUMP_ENUM(Priority,Importance,Outlook::olImportanceNormal,Normal);
DUMP_ENUM_V(Priority,Importance,Outlook::olImportanceLow,low);
stream.writeEndElement();
stream.writeStartElement("Status");
DUMP_ENUM(Status,Status,Outlook::olTaskNotStarted,NotStarted);
DUMP_ENUM(Status,Status,Outlook::olTaskInProgress,InProgress);
DUMP_ENUM(Status,Status,Outlook::olTaskComplete,Completed);
DUMP_ENUM(Status,Status,Outlook::olTaskWaiting,Waiting);
DUMP_ENUM(Status,Status,Outlook::olTaskDeferred,Deferred);
stream.writeEndElement();
DUMP_DATE(DueDate,DueDate);
DUMP_DATE(StartedDate,StartDate);
DUMP_DATE(CompletedDate,DateCompleted);
DUMP_INT(PercentCompleted,PercentComplete);
DUMP_MAPI(Notes,Body);
stream.writeStartElement("Categories");
foreach ( const QString &category, bstr_to_qstring(item->GetCategories()).split(", ") )
DUMP_EXPR(Category,category);
stream.writeEndElement();
stream.writeEndElement();
}
PUBLIC
void
Jdb_kern_info_cpu::dump_cp0_regs()
{
Mword val;
DUMP_CP0("EBase", read_c0_ebase(), val);
DUMP_INT("Ebase.CPUNum", (val & 0x3ff));
DUMP_CP0("EntryHi", read_c0_entryhi(), val);
DUMP_HEX("EntryHi.ASID", (val & 0xff));
DUMP_CP0("EPC", read_c0_epc(), val);
DUMP_CP0("Status", read_c0_status(), val);
DUMP_CP0("Cause", read_c0_cause(), val);
DUMP_CP0("PRId", read_c0_prid(), val);
DUMP_CP0("HWREna", read_c0_hwrena(), val);
DUMP_CP0("Config", read_c0_config(), val);
if (val & MIPS_CONF_M) {
DUMP_CP0("Config1", read_c0_config1(), val);
if (val & MIPS_CONF_M) {
DUMP_CP0("Config2", read_c0_config2(), val);
if (val & MIPS_CONF_M) {
DUMP_CP0("Config3", read_c0_config3(), val);
if (val & MIPS_CONF3_ULRI)
DUMP_CP0("UserLocal", read_c0_userlocal(), val);
}
}
}
if (cpu_has_vz)
DUMP_CP0("GuestCtl0", read_c0_guestctl0(), val);
if (cpu_has_guestctl0ext)
DUMP_CP0("GuestCtl0Ext", read_c0_guestctl0ext(), val);
if (cpu_has_vz)
DUMP_CP0("GTOffset", read_c0_gtoffset(), val);
if (cpu_has_guestctl1) {
DUMP_CP0("GuestCtl1", read_c0_guestctl1(), val);
DUMP_HEX("GuestCtl1.ID", (val & GUESTCTL1_ID));
}
if (cpu_has_guestctl2) {
DUMP_CP0("GuestCtl2", read_c0_guestctl2(), val);
DUMP_HEX("GuestCtl2.VIP", (val & GUESTCTL2_VIP));
}
}
static void dump(void)
{
int i;
DUMP_INT(MPIR_being_debugged);
DUMP_INT(MPIR_debug_gate);
DUMP_INT(MPIR_debug_state);
DUMP_INT(MPIR_acquired_pre_main);
DUMP_INT(MPIR_i_am_starter);
DUMP_INT(MPIR_proctable_size);
fprintf(stderr, " MPIR_proctable:\n");
for (i = 0; i < MPIR_proctable_size; i++) {
fprintf(stderr,
" (i, host, exe, pid) = (%d, %s, %s, %d)\n",
i,
MPIR_proctable[i].host_name,
MPIR_proctable[i].executable_name,
MPIR_proctable[i].pid);
}
}
void dump_item( const Outlook::_AppointmentItemPtr &item, QXmlStreamWriter &stream, bool dump_exception )
{
TRACE(OutlookSyncPlugin) << "OutlookDatebookSync::dump_item";
Outlook::OlRecurrenceState recstate = item->GetRecurrenceState();
if ( recstate == Outlook::olApptOccurrence ) {
WARNING() << "Cannot sync occurrences!";
return;
}
if ( (dump_exception && recstate != Outlook::olApptException) ||
(!dump_exception && recstate == Outlook::olApptException) ) {
WARNING() << "Found" << (recstate == Outlook::olApptException?"Exception":"non-Exception")
<< "when syncing" << (dump_exception?"Exceptions":"non-Exceptions");
return;
}
Outlook::UserPropertiesPtr props = item->GetUserProperties();
Q_ASSERT(props);
PREPARE_MAPI_DATEBOOK(Appointment, dump_exception);
stream.writeStartElement("Appointment");
DUMP_STRING(Identifier,EntryID);
DUMP_STRING(Description,Subject);
DUMP_STRING(Location,Location);
QString timezone;
{
Outlook::UserPropertyPtr up = props->Find("Qtopia Timezone");
if ( up ) {
timezone = variant_to_qstring(up->GetValue());
}
}
DUMP_EXPR(TimeZone,timezone);
stream.writeStartElement("When");
if ( item->GetAllDayEvent() ) {
DUMP_DATE(StartDate,Start);
// We can't just dump the end date because Outlook does it differently to Qtopia.
// Qtopia expects something like "starts 7/10/08, ends 7/10/08" but Outlook
// has given us "starts 7/10/08 00:00:00, ends 8/10/08 00:00:00".
// Simply remove one day from the end date to get something Qtopia won't barf over.
QDate dt = date_to_qdatetime(item->GetEnd()).date();
dt = dt.addDays(-1);
DUMP_EXPR(EndDate,escape(dateToString(dt)));
} else {
QDateTime dt = date_to_qdatetime(item->GetStart());
bool utc = !timezone.isEmpty();
if ( utc )
dt = dt.toUTC();
DUMP_EXPR(Start,escape(dateTimeToString(dt, utc)));
dt = date_to_qdatetime(item->GetEnd());
if ( utc )
dt = dt.toUTC();
DUMP_EXPR(End,escape(dateTimeToString(dt, utc)));
}
stream.writeEndElement();
stream.writeStartElement("Alarm");
if ( item->GetReminderSet() ) {
DUMP_EXPR(Type,item->GetReminderPlaySound()?"Audible":"Visible");
DUMP_INT(Delay,ReminderMinutesBeforeStart);
}
stream.writeEndElement();
if ( !dump_exception ) {
stream.writeStartElement("Repeat");
if ( recstate != Outlook::olApptNotRecurring && item->GetIsRecurring() ) {
Q_ASSERT(recstate == Outlook::olApptMaster);
Outlook::RecurrencePatternPtr recpat = item->GetRecurrencePattern();
Q_ASSERT(recpat);
Outlook::OlRecurrenceType rectype = recpat->GetRecurrenceType();
LOG() << "recpat->RecurrenceType" << rectype;
QString type;
if ( rectype == Outlook::olRecursDaily && !recpat->GetDayOfWeekMask() )
type = "Daily";
else if ( ( rectype == Outlook::olRecursDaily && recpat->GetDayOfWeekMask() ) || rectype == Outlook::olRecursWeekly )
type = "Weekly";
else if ( rectype == Outlook::olRecursMonthly )
type = "MonthlyDate";
else if ( ( rectype == Outlook::olRecursMonthNth || rectype == Outlook::olRecursYearNth ) && recpat->GetInstance() != 5 )
type = "MonthlyDay";
else if ( ( rectype == Outlook::olRecursMonthNth || rectype == Outlook::olRecursYearNth ) && recpat->GetInstance() == 5 )
type = "MonthlyEndDay";
else if ( rectype == Outlook::olRecursYearly )
type = "Yearly";
Q_ASSERT(!type.isEmpty());
LOG() << "Type" << type << "Instance" << recpat->GetInstance();
stream.writeStartElement("Type");
stream.writeCharacters(type);
stream.writeEndElement();
int frequency = recpat->GetInterval();
LOG() << "recpat->GetInterval" << frequency;
if ( rectype == Outlook::olRecursDaily && recpat->GetDayOfWeekMask() )
frequency = 1;
stream.writeStartElement("Frequency");
stream.writeCharacters(QString::number(frequency));
stream.writeEndElement();
stream.writeStartElement("Until");
if ( !recpat->GetNoEndDate() ) {
LOG() << "recpat->GetPatternEndDate" << date_to_qdatetime(recpat->GetPatternEndDate()).date();
stream.writeCharacters(dateToString(date_to_qdatetime(recpat->GetPatternEndDate()).date()));
}
stream.writeEndElement();
if ( type == "Weekly" || type == "MonthlyDay" || type == "MonthlyEndDay" ) {
stream.writeStartElement("WeekMask");
if ( recpat->GetDayOfWeekMask() ) {
int mask = recpat->GetDayOfWeekMask();
LOG() << "recpat->GetDayOfWeekMask" << mask;
QStringList list;
if ( mask & Outlook::olMonday )
list << "Monday";
if ( mask & Outlook::olTuesday )
list << "Tuesday";
if ( mask & Outlook::olWednesday )
list << "Wednesday";
if ( mask & Outlook::olThursday )
list << "Thursday";
if ( mask & Outlook::olFriday )
list << "Friday";
if ( mask & Outlook::olSaturday )
list << "Saturday";
if ( mask & Outlook::olSunday )
list << "Sunday";
stream.writeCharacters(list.join(" "));
} else {
LOG() << "recpat->GetDayOfWeekMask" << 0;
}
stream.writeEndElement();
}
Outlook::ExceptionsPtr exceptions = recpat->GetExceptions();
if ( exceptions ) {
int expcount = exceptions->GetCount();
for ( int i = 0; i < expcount; i++ ) {
stream.writeStartElement("Exception");
long item_to_get = i+1;
Outlook::ExceptionPtr exception = exceptions->Item(item_to_get);
Q_ASSERT(exception);
DUMP_DATE_ITEM(OriginalDate,OriginalDate,exception);
if ( !exception->GetDeleted() ) {
Outlook::_AppointmentItemPtr exceptionItem = exception->GetAppointmentItem();
dump_item( exceptionItem, stream, true );
}
stream.writeEndElement();
}
}
}
stream.writeEndElement();
}
DUMP_MAPI(Notes,Body);
stream.writeStartElement("Categories");
foreach ( const QString &category, bstr_to_qstring(item->GetCategories()).split(", ", QString::SkipEmptyParts) )
DUMP_EXPR(Category,category);
stream.writeEndElement();
stream.writeEndElement();
}
/** ---------------------------------------------------
* 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;
}
