#ifndef FUNCPROTO
#define FUNCPROTO 15
#endif
#include <X11/StringDefs.h>
#include <X11/Intrinsic.h>
#include <X11/Shell.h>
#include <X11/Xaw/Form.h>
#include <X11/Xaw/Toggle.h>
#include <X11/Xaw/List.h>
#include <X11/Xaw/Command.h>
#include <X11/Xaw/AsciiText.h>
#include <X11/Xaw/Dialog.h>
#ifdef XKB
#include <X11/extensions/XKBbells.h>
#endif
#ifdef XEDIT
#include "xedit.h"
#endif
#include "printdialog.h"
#include "printdialogprivates.h"
#include "print.h"
#include <stdlib.h>
#include <ctype.h>
#include <stdio.h>
#define NULLSTR(x) (((x)!=NULL)?(x):(""))
#define Error(x) { printf x ; exit(EXIT_FAILURE); }
#define Assertion(expr, msg) { if (!(expr)) { Error msg } }
#ifdef DEBUG
# define Log(x) { if(True) printf x; }
#else
# define Log(x) { if(False) printf x; }
#endif
static void do_beep(PrintDialogWidget pdw);
static void center_popup(Widget parent, Widget popup);
static void updateWidgetStates(PrintDialogWidget pdw);
static void printSetupClose(PrintDialogWidget pdw);
static void printSetupOKXtProc(Widget w, XtPointer client_data, XtPointer callData);
static void printSetupCancelXtProc(Widget w, XtPointer client_data, XtPointer callData);
static void printSetupJobCopiesXtProc(Widget w, XtPointer client_data, XtPointer callData);
static void printDialogDestXtProc(Widget w, XtPointer client_data, XtPointer callData);
static void printSelectFileXtProc(Widget w, XtPointer client_data, XtPointer callData);
static void printOKXtProc(Widget w, XtPointer client_data, XtPointer callData);
static void printSetupXtProc(Widget w, XtPointer client_data, XtPointer callData);
static void printFileSelectedXtProc(Widget w, XtPointer client_data, XtPointer callData);
static void buildFileDialog(PrintDialogWidget pdw);
static void closePrinterConnection(PrintDialogWidget pdw, Bool closeDisplay);
static Bool openPrinterConnection(PrintDialogWidget pdw);
static void destroyPrintSetupDialog(PrintDialogWidget pdw);
static Widget buildPrintSetupDialog(PrintDialogWidget pdw);
static String *xpprinterlist_to_widget_printerlist(XPPrinterList printerlist, int num_printers);
static String *xppaperlist_to_widget_paperlist(XpuMediumSourceSizeList paperlist, int num_papers);
static String *xpresolutionlist_to_widget_resolutionlist(XpuResolutionList reslist, int num_resolutions);
static String *xporientationlist_to_widget_orientationlist(XpuOrientationList orientationlist, int num_orientations);
static String *xpplexlist_to_widget_plexlist(XpuPlexList plexlist, int num_plex);
static String *xpcolorspacelist_to_widget_colorspacelist(XpuColorspaceList colorspacelist, int num_colorspaces);
static void printerSelectionPrinterSelectedXtProc(Widget w, XtPointer client_data, XtPointer callData);
static void printSelectPrinterXtProc(Widget w, XtPointer client_data, XtPointer callData);
static void printerSelectionClose(PrintDialogWidget pdw);
static void printerSelectionOKXtProc(Widget w, XtPointer client_data, XtPointer callData);
static void printerSelectionCancelXtProc(Widget w, XtPointer client_data, XtPointer callData);
static Bool buildPrinterSelectionDialog(PrintDialogWidget pdw);
static void destroyPrinterSelectionDialog(PrintDialogWidget pdw);
static void createprintdialogchildren(Widget w);
static
void do_beep(PrintDialogWidget pdw)
{
Log(("*** Beep!\n"));
#ifdef XKB
XkbStdBell(XtDisplay((Widget)pdw), XtWindow((Widget)pdw), 0, XkbBI_MinorError);
#else
XBell(XtDisplay((Widget)pdw), 0);
#endif
}
static
void center_popup(Widget parent, Widget popup)
{
Dimension width,
height;
Position x,
y;
XtVaGetValues(parent,
XtNx, &x,
XtNy, &y,
NULL);
XtVaGetValues(popup,
XtNwidth, &width,
XtNheight, &height,
NULL);
x += (Position)width / 2;
y += (Position)height / 3;
XtVaSetValues(popup,
XtNx, x,
XtNy, y,
NULL);
}
static
void updateWidgetStates(PrintDialogWidget pdw)
{
PrintDialogPart *pdp = &pdw->printdialog;
if (pdw->core.being_destroyed)
return;
if (pdp->printToFile == False) {
XtVaSetValues(pdp->main.printtoprinter, XtNstate, True, NULL);
XtVaSetValues(pdp->main.printtofile, XtNstate, False, NULL);
XtVaSetValues(pdp->main.filenamelabel, XtNsensitive, False, NULL);
XtVaSetValues(pdp->main.filename, XtNsensitive, False, NULL);
XtVaSetValues(pdp->main.selectfile, XtNsensitive, False, NULL);
}
else
{
XtVaSetValues(pdp->main.printtoprinter, XtNstate, False, NULL);
XtVaSetValues(pdp->main.printtofile, XtNstate, True, NULL);
XtVaSetValues(pdp->main.filenamelabel, XtNsensitive, True, NULL);
XtVaSetValues(pdp->main.filename, XtNsensitive, True, NULL);
XtVaSetValues(pdp->main.selectfile, XtNsensitive, True, NULL);
}
XtVaSetValues(pdp->main.filename, XtNlabel, pdp->filename?pdp->filename:"-", NULL);
pdp->canPrint = True;
if (pdp->printer_name == NULL) {
pdp->canPrint = False;
}
else if (strlen(pdp->printer_name) == 0) {
pdp->canPrint = False;
}
pdp->canReallyPrint = pdp->canPrint;
if (pdp->printToFile) {
if (pdp->filename == NULL) {
pdp->canReallyPrint = False;
}
else if (strlen(pdp->filename) == 0) {
pdp->canReallyPrint = False;
}
}
XtVaSetValues(pdp->main.ok, XtNsensitive, pdp->canReallyPrint, NULL);
XtVaSetValues(pdp->main.setup, XtNsensitive, pdp->canPrint, NULL);
}
static void
printSetupClose(PrintDialogWidget pdw)
{
PrintDialogPart *pdp = &pdw->printdialog;
if (pdp->setup.popup) {
XtPopdown(pdp->setup.popup);
}
}
static void
printSetupOKXtProc(Widget w, XtPointer client_data, XtPointer callData)
{
PrintDialogWidget pdw = (PrintDialogWidget)client_data;
PrintDialogPart *pdp = &pdw->printdialog;
char *s;
XawListReturnStruct *lrs;
Log(("## printSetupOK: closing print setup!\n"));
XtVaGetValues(pdp->setup.jobcopies, XtNstring, &s, NULL);
if (s) {
int c = atoi(s);
if (c < 1 || c > 999) {
do_beep(pdw);
XtVaSetValues(pdp->setup.jobcopies, XtNstring, "1", NULL);
Log(("## printSetupOKXtProc: not a valid copy count value\n"));
return;
}
XpuSetDocumentCopies(pdp->pdpy, pdp->pcontext, c);
}
lrs = XawListShowCurrent(pdp->setup.paperlist);
if (lrs->list_index != XAW_LIST_NONE) {
Log(("selected paper is '%s'/'%d'\n", lrs->string, lrs->list_index));
Assertion(lrs->list_index < pdp->num_papers, (("Error: lrs->list_index < pdp->num_papers\n")));
XpuSetDocMediumSourceSize(pdp->pdpy, pdp->pcontext, &pdp->paperlist[lrs->list_index]);
}
XtFree((char *)lrs);
lrs = XawListShowCurrent(pdp->setup.resolutionlist);
if (lrs->list_index != XAW_LIST_NONE) {
Log(("selected resolution is '%s'/'%d'\n", lrs->string, lrs->list_index));
Assertion(lrs->list_index < pdp->num_resolutions, (("Error: lrs->list_index < pdp->num_resolutions\n")));
XpuSetDocResolution(pdp->pdpy, pdp->pcontext, &pdp->resolutionlist[lrs->list_index]);
}
XtFree((char *)lrs);
lrs = XawListShowCurrent(pdp->setup.orientationlist);
if (lrs->list_index != XAW_LIST_NONE) {
Log(("selected orientation is '%s'/'%d'\n", lrs->string, lrs->list_index));
Assertion(lrs->list_index < pdp->num_orientations, (("Error: lrs->list_index < pdp->num_orientations\n")));
XpuSetDocOrientation(pdp->pdpy, pdp->pcontext, &pdp->orientationlist[lrs->list_index]);
}
XtFree((char *)lrs);
lrs = XawListShowCurrent(pdp->setup.plexlist);
if (lrs->list_index != XAW_LIST_NONE) {
Log(("selected plex is '%s'/'%d'\n", lrs->string, lrs->list_index));
Assertion(lrs->list_index < pdp->num_plex, (("Error: lrs->list_index < pdp->num_plex\n")));
XpuSetDocPlex(pdp->pdpy, pdp->pcontext, &pdp->plexlist[lrs->list_index]);
}
XtFree((char *)lrs);
lrs = XawListShowCurrent(pdp->setup.colorspacelist);
if (lrs->list_index != XAW_LIST_NONE) {
Log(("selected colorspace is '%s'/'%d'\n", lrs->string, lrs->list_index));
Assertion(lrs->list_index < pdp->num_colorspaces, (("Error: lrs->list_index < pdp->num_colorspaces\n")));
pdp->selected_colorspace = &pdp->colorspacelist[lrs->list_index];
}
XtFree((char *)lrs);
printSetupClose(pdw);
}
static void
printSetupCancelXtProc(Widget w, XtPointer client_data, XtPointer callData)
{
PrintDialogWidget pdw = (PrintDialogWidget)client_data;
Log(("## printSetupCancel: closing print setup!\n"));
printSetupClose(pdw);
}
static void
printSetupJobCopiesXtProc(Widget w, XtPointer client_data, XtPointer callData)
{
PrintDialogWidget pdw = (PrintDialogWidget)client_data;
PrintDialogPart *pdp = &pdw->printdialog;
char *string = NULL;
Log(("## printSetupJobCopiesXtProc!\n"));
XtVaGetValues(pdp->setup.jobcopies, XtNstring, &string, NULL);
if (string) {
char *s;
int i;
Bool isValidNumber = True;
for( s = string ; *s != '\0' ; s++ ) {
if (!isdigit(*s)) {
isValidNumber = False;
break;
}
}
i = atoi(string);
if (i < 1 || i > 999) {
isValidNumber = False;
}
if (!isValidNumber) {
do_beep(pdw);
XtVaSetValues(pdp->setup.jobcopies, XtNstring, "1", NULL);
Log(("## printSetupJobCopiesXtProc: not a valid number\n"));
}
}
}
static void
printCancelXtProc(Widget w, XtPointer client_data, XtPointer callData)
{
PrintDialogWidget pdw = (PrintDialogWidget)client_data;
PrintDialogPart *pdp = &pdw->printdialog;
printSetupClose(pdw);
if (pdp->cancel_callback) {
Log(("printCancelXtProc: calling callback\n"));
XtCallCallbackList((Widget)pdw, pdp->cancel_callback, NULL);
}
}
static void
printDialogDestXtProc(Widget w, XtPointer client_data, XtPointer callData)
{
PrintDialogWidget pdw = (PrintDialogWidget)client_data;
PrintDialogPart *pdp = &pdw->printdialog;
if (w == pdp->main.printtoprinter) {
pdp->printToFile = False;
}
else if (w == pdp->main.printtofile) {
pdp->printToFile = True;
}
else
{
Log(("printDialogDestXtProc: ERROR: Unknown widget.\n"));
}
updateWidgetStates(pdw);
}
static void
printSelectFileXtProc(Widget w, XtPointer client_data, XtPointer callData)
{
PrintDialogWidget pdw = (PrintDialogWidget)client_data;
PrintDialogPart *pdp = &pdw->printdialog;
Log(("## printSelectFileXtProc!\n"));
if (!pdp->selectFile.shell) {
buildFileDialog(pdw);
}
center_popup((Widget)pdw, pdp->selectFile.shell);
XtPopup(pdp->selectFile.shell, XtGrabExclusive);
}
static void
printOKXtProc(Widget w, XtPointer client_data, XtPointer callData)
{
PrintDialogWidget pdw = (PrintDialogWidget)client_data;
PrintDialogPart *pdp = &pdw->printdialog;
Log(("## printing!\n"));
if (!pdp->pdpy) {
Log(("printOKXtProc: no printer connection, opening one....\n"));
openPrinterConnection(pdw);
if (!pdp->pdpy) {
Log(("printOKXtProc: still no printer connection - BAD (this should never happen).\n"));
do_beep(pdw);
return;
}
}
if (pdp->ok_callback) {
XawPrintDialogCallbackStruct pdcs;
Log(("printOKXtProc: calling callbacks...\n"));
memset(&pdcs, 0, sizeof(pdcs));
pdcs.pdpy = pdp->pdpy;
pdcs.pcontext = pdp->pcontext;
pdcs.printToFile = pdp->printToFile;
pdcs.printToFileName = (const char *)pdp->filename;
pdcs.colorspace = pdp->selected_colorspace;
XtCallCallbackList((Widget)pdw, pdp->ok_callback, &pdcs);
}
printSetupClose(pdw);
}
static void
printSetupXtProc(Widget w, XtPointer client_data, XtPointer callData)
{
PrintDialogWidget pdw = (PrintDialogWidget)client_data;
PrintDialogPart *pdp = &pdw->printdialog;
Log(("## setup!\n"));
if (!pdp->setup.popup) {
if (buildPrintSetupDialog(pdw) == NULL) {
Log(("printSetupXtProc: buildPrintSetupDialog failure.\n"));
return;
}
}
center_popup((Widget)pdw, pdp->setup.popup);
XtPopup(pdp->setup.popup, XtGrabExclusive);
}
static void
printFileSelectedXtProc(Widget w, XtPointer client_data, XtPointer callData)
{
PrintDialogWidget pdw = (PrintDialogWidget)client_data;
PrintDialogPart *pdp = &pdw->printdialog;
const char *filename;
Log(("printFileSelectedXtProc: User selected file.\n"));
filename = XawDialogGetValueString(pdp->selectFile.dialog);
if (pdp->filename)
free(pdp->filename);
pdp->filename = strdup(filename);
XtPopdown(pdp->selectFile.shell);
updateWidgetStates(pdw);
}
static
void buildFileDialog(PrintDialogWidget pdw)
{
PrintDialogPart *pdp = &pdw->printdialog;
int n;
Arg args[20];
pdp->selectFile.shell = XtCreatePopupShell("selectfile",
transientShellWidgetClass,
(Widget)pdw, NULL, 0);
n = 0;
XtSetArg(args[n], XtNvalue, pdp->filename?pdp->filename:""); n++;
pdp->selectFile.dialog = XtCreateManagedWidget("dialog", dialogWidgetClass,
pdp->selectFile.shell, args, n);
XawDialogAddButton(pdp->selectFile.dialog, "Accept", printFileSelectedXtProc, pdw);
XtRealizeWidget(pdp->selectFile.shell);
}
static
void closePrinterConnection(PrintDialogWidget pdw, Bool closeDisplay)
{
PrintDialogPart *pdp = &pdw->printdialog;
Log(("# closePrinterConnection\n"));
destroyPrintSetupDialog(pdw);
if (pdp->paperlist) {
XpuFreeMediumSourceSizeList(pdp->paperlist);
pdp->paperlist = NULL;
}
if (pdp->widget_paperlist) {
free(pdp->widget_paperlist);
pdp->widget_paperlist = NULL;
}
if (pdp->resolutionlist) {
XpuFreeResolutionList(pdp->resolutionlist);
pdp->resolutionlist = NULL;
}
if (pdp->widget_resolutionlist) {
free(pdp->widget_resolutionlist);
pdp->widget_resolutionlist = NULL;
}
if (pdp->orientationlist) {
XpuFreeOrientationList(pdp->orientationlist);
pdp->orientationlist = NULL;
}
if (pdp->widget_orientationlist) {
free(pdp->widget_orientationlist);
pdp->widget_orientationlist = NULL;
}
if (pdp->plexlist) {
XpuFreePlexList(pdp->plexlist);
pdp->plexlist = NULL;
}
if (pdp->widget_plexlist) {
free(pdp->widget_plexlist);
pdp->widget_plexlist = NULL;
}
if (pdp->colorspacelist) {
XpuFreeColorspaceList(pdp->colorspacelist);
pdp->colorspacelist = NULL;
}
if (pdp->widget_colorspacelist) {
free(pdp->widget_colorspacelist);
pdp->widget_colorspacelist = NULL;
}
pdp->selected_colorspace = NULL;
if (pdp->pdpy) {
if (closeDisplay) {
XpuClosePrinterDisplay(pdp->pdpy, pdp->pcontext);
}
pdp->pdpy = NULL;
pdp->pcontext = None;
}
updateWidgetStates(pdw);
}
static
Bool openPrinterConnection(PrintDialogWidget pdw)
{
PrintDialogPart *pdp = &pdw->printdialog;
Log(("# openPrinterConnection\n"));
closePrinterConnection(pdw, True);
if (!pdp->printer_name) {
Log(("# error: openPrinterConnection: No printer name.\n"));
return False;
}
if (XpuGetPrinter(pdp->printer_name, &pdp->pdpy, &pdp->pcontext) == False) {
Log(("openPrinterConnection: could not open printer.\n"));
return False;
}
pdp->paperlist = XpuGetMediumSourceSizeList(pdp->pdpy, pdp->pcontext, &pdp->num_papers);
pdp->resolutionlist = XpuGetResolutionList(pdp->pdpy, pdp->pcontext, &pdp->num_resolutions);
pdp->orientationlist = XpuGetOrientationList(pdp->pdpy, pdp->pcontext, &pdp->num_orientations);
pdp->plexlist = XpuGetPlexList(pdp->pdpy, pdp->pcontext, &pdp->num_plex);
pdp->colorspacelist = XpuGetColorspaceList(pdp->pdpy, pdp->pcontext, &pdp->num_colorspaces);
pdp->widget_paperlist = xppaperlist_to_widget_paperlist(pdp->paperlist, pdp->num_papers);
pdp->widget_resolutionlist = xpresolutionlist_to_widget_resolutionlist(pdp->resolutionlist, pdp->num_resolutions);
pdp->widget_orientationlist = xporientationlist_to_widget_orientationlist(pdp->orientationlist, pdp->num_orientations);
pdp->widget_plexlist = xpplexlist_to_widget_plexlist(pdp->plexlist, pdp->num_plex);
pdp->widget_colorspacelist = xpcolorspacelist_to_widget_colorspacelist(pdp->colorspacelist, pdp->num_colorspaces);
updateWidgetStates(pdw);
return True;
}
#undef DEFAULT_WIDTH
#define DEFAULT_WIDTH 120
#undef DEFAULT_INFOLABEL_WIDTH
#define DEFAULT_INFOLABEL_WIDTH 250
static
void destroyPrintSetupDialog(PrintDialogWidget pdw)
{
PrintDialogPart *pdp = &pdw->printdialog;
if (pdp->setup.popup) {
XtDestroyWidget(pdp->setup.popup);
}
pdp->setup.popup = NULL;
pdp->setup.form = NULL;
pdp->setup.paperlist = NULL;
pdp->setup.resolutionlist = NULL;
pdp->setup.orientationlist = NULL;
pdp->setup.plexlist = NULL;
pdp->setup.colorspacelist = NULL;
pdp->setup.ok = NULL;
pdp->setup.cancel = NULL;
}
static
Widget buildPrintSetupDialog(PrintDialogWidget pdw)
{
PrintDialogPart *pdp = &pdw->printdialog;
int n;
Arg args[20];
Widget listform;
XpuSupportedFlags jobflags,
docflags;
Bool canChangeJobCopies,
canChangePaperSize,
canChangeResolution,
canChangeOrientation,
canChangePlex;
if (!pdp->pdpy) {
Log(("buildPrintSetupDialog: no printer connection, opening one....\n"));
openPrinterConnection(pdw);
if (!pdp->pdpy) {
Log(("buildPrintSetupDialog: still no printer connection - BAD.\n"));
do_beep(pdw);
return NULL;
}
}
jobflags = XpuGetSupportedDocAttributes(pdp->pdpy, pdp->pcontext);
docflags = XpuGetSupportedDocAttributes(pdp->pdpy, pdp->pcontext);
canChangeJobCopies = (jobflags & XPUATTRIBUTESUPPORTED_COPY_COUNT) == XPUATTRIBUTESUPPORTED_COPY_COUNT;
canChangePaperSize = (docflags & XPUATTRIBUTESUPPORTED_DEFAULT_MEDIUM) == XPUATTRIBUTESUPPORTED_DEFAULT_MEDIUM;
canChangeResolution = (docflags & XPUATTRIBUTESUPPORTED_DEFAULT_PRINTER_RESOLUTION) == XPUATTRIBUTESUPPORTED_DEFAULT_PRINTER_RESOLUTION;
canChangeOrientation = (docflags & XPUATTRIBUTESUPPORTED_CONTENT_ORIENTATION) == XPUATTRIBUTESUPPORTED_CONTENT_ORIENTATION;
canChangePlex = (docflags & XPUATTRIBUTESUPPORTED_PLEX) == XPUATTRIBUTESUPPORTED_PLEX;
n = 0;
XtSetArg(args[n], XtNallowShellResize, True); n++;
pdp->setup.popup = XtCreatePopupShell("setup", transientShellWidgetClass, (Widget)pdw, args, n);
n = 0;
pdp->setup.form = XtCreateManagedWidget("form", formWidgetClass, pdp->setup.popup, args, n);
n = 0;
listform = XtCreateManagedWidget("list", formWidgetClass, pdp->setup.form, args, n);
n = 0;
XtSetArg(args[n], XtNresizable, True); n++;
XtSetArg(args[n], XtNforceColumns, True); n++;
XtSetArg(args[n], XtNdefaultColumns, 1); n++;
XtSetArg(args[n], XtNsensitive, canChangePaperSize); n++;
XtSetArg(args[n], XtNlist, pdp->widget_paperlist); n++;
XtSetArg(args[n], XtNwidth, DEFAULT_WIDTH); n++;
pdp->setup.paperlist = XtCreateManagedWidget("paperlist", listWidgetClass, listform, args, n);
n = 0;
XtSetArg(args[n], XtNresizable, True); n++;
XtSetArg(args[n], XtNforceColumns, True); n++;
XtSetArg(args[n], XtNdefaultColumns, 1); n++;
XtSetArg(args[n], XtNsensitive, canChangeResolution); n++;
XtSetArg(args[n], XtNlist, pdp->widget_resolutionlist); n++;
XtSetArg(args[n], XtNwidth, DEFAULT_WIDTH); n++;
pdp->setup.resolutionlist = XtCreateManagedWidget("resolutionlist", listWidgetClass, listform, args, n);
n = 0;
XtSetArg(args[n], XtNresizable, True); n++;
XtSetArg(args[n], XtNforceColumns, True); n++;
XtSetArg(args[n], XtNdefaultColumns, 1); n++;
XtSetArg(args[n], XtNsensitive, canChangeOrientation); n++;
XtSetArg(args[n], XtNlist, pdp->widget_orientationlist); n++;
XtSetArg(args[n], XtNwidth, DEFAULT_WIDTH); n++;
pdp->setup.orientationlist = XtCreateManagedWidget("orientationlist", listWidgetClass, listform, args, n);
n = 0;
XtSetArg(args[n], XtNresizable, True); n++;
XtSetArg(args[n], XtNforceColumns, True); n++;
XtSetArg(args[n], XtNdefaultColumns, 1); n++;
XtSetArg(args[n], XtNsensitive, canChangePlex); n++;
XtSetArg(args[n], XtNlist, pdp->widget_plexlist); n++;
XtSetArg(args[n], XtNwidth, DEFAULT_WIDTH); n++;
pdp->setup.plexlist = XtCreateManagedWidget("plexlist", listWidgetClass, listform, args, n);
n = 0;
XtSetArg(args[n], XtNresizable, True); n++;
XtSetArg(args[n], XtNforceColumns, True); n++;
XtSetArg(args[n], XtNdefaultColumns, 1); n++;
XtSetArg(args[n], XtNsensitive, True); n++;
XtSetArg(args[n], XtNlist, pdp->widget_colorspacelist); n++;
XtSetArg(args[n], XtNwidth, DEFAULT_WIDTH); n++;
pdp->setup.colorspacelist = XtCreateManagedWidget("colorspacelist", listWidgetClass, listform, args, n);
n = 0;
XtSetArg(args[n], XtNborderWidth, 0); n++;
XtSetArg(args[n], XtNresizable, False); n++;
XtSetArg(args[n], XtNjustify, XtJustifyRight); n++;
XtSetArg(args[n], XtNwidth, DEFAULT_WIDTH); n++;
XtSetArg(args[n], XtNsensitive, canChangeJobCopies); n++;
pdp->setup.jobcopieslabel = XtCreateManagedWidget("jobcopieslabel", labelWidgetClass, listform, args, n);
n = 0;
XtSetArg(args[n], XtNstring, "1"); n++;
XtSetArg(args[n], XtNresizable, True); n++;
XtSetArg(args[n], XtNeditType, XawtextEdit); n++;
XtSetArg(args[n], XtNsensitive, canChangeJobCopies); n++;
pdp->setup.jobcopies = XtCreateManagedWidget("jobcopies", asciiTextWidgetClass, listform, args, n);
XtAddCallback(pdp->setup.jobcopies, XtNpositionCallback, printSetupJobCopiesXtProc, pdw);
n = 0;
pdp->setup.ok = XtCreateManagedWidget("ok", commandWidgetClass, pdp->setup.form, args, n);
XtAddCallback(pdp->setup.ok, XtNcallback, printSetupOKXtProc, pdw);
n = 0;
pdp->setup.cancel = XtCreateManagedWidget("cancel", commandWidgetClass, pdp->setup.form, args, n);
XtAddCallback(pdp->setup.cancel, XtNcallback, printSetupCancelXtProc, pdw);
XtRealizeWidget(pdp->setup.popup);
return pdp->setup.popup;
}
#undef DEFAULT_WIDTH
#define DEFAULT_WIDTH 150
static
String *xpprinterlist_to_widget_printerlist(XPPrinterList printerlist, int num_printers)
{
int i;
String *names;
names = malloc(sizeof(String *) * (num_printers+1));
if(!names)
return NULL;
for(i = 0 ; i < num_printers ; i++)
names[i] = printerlist[i].name;
names[i] = NULL;
return names;
}
static
String *xppaperlist_to_widget_paperlist(XpuMediumSourceSizeList paperlist, int num_papers)
{
int i;
String *names;
names = malloc(sizeof(String *) * (num_papers+1));
if (!names)
return NULL;
for(i = 0 ; i < num_papers ; i++)
names[i] = (char *)paperlist[i].medium_name;
names[i] = NULL;
return names;
}
static
String *xpresolutionlist_to_widget_resolutionlist(XpuResolutionList reslist, int num_resolutions)
{
int i;
String *names;
names = malloc(sizeof(String *) * (num_resolutions+1));
if (!names)
return NULL;
for(i = 0 ; i < num_resolutions ; i++)
names[i] = (char *)reslist[i].name;
names[i] = NULL;
return names;
}
static
String *xporientationlist_to_widget_orientationlist(XpuOrientationList orientationlist, int num_orientations)
{
int i;
String *names;
names = malloc(sizeof(String *) * (num_orientations+1));
if (!names)
return NULL;
for(i = 0 ; i < num_orientations ; i++)
names[i] = (char *)orientationlist[i].orientation;
names[i] = NULL;
return names;
}
static
String *xpplexlist_to_widget_plexlist(XpuPlexList plexlist, int num_plex)
{
int i;
String *names;
names = malloc(sizeof(String *) * (num_plex+1));
if(!names)
return NULL;
for(i = 0 ; i < num_plex ; i++)
names[i] = (char *)plexlist[i].plex;
names[i] = NULL;
return names;
}
static
String *xpcolorspacelist_to_widget_colorspacelist(XpuColorspaceList colorspacelist, int num_colorspaces)
{
int i;
String *names;
names = malloc(sizeof(String *) * (num_colorspaces+1));
if(!names)
return NULL;
for(i = 0 ; i < num_colorspaces ; i++)
names[i] = (char *)colorspacelist[i].name;
names[i] = NULL;
return names;
}
static void
printerSelectionPrinterSelectedXtProc(Widget w, XtPointer client_data, XtPointer callData)
{
PrintDialogWidget pdw = (PrintDialogWidget)client_data;
PrintDialogPart *pdp = &pdw->printdialog;
XawListReturnStruct *lrs = (XawListReturnStruct *)callData;
int list_index;
Log(("## user selected a printer\n"));
list_index = lrs->list_index;
if (list_index == XAW_LIST_NONE) {
Log(("printerSelectionPrinterSelectedXtProc: Nothing selected.\n"));
return;
}
Log(("selected printer is '%d'/'%s'/'%s'\n",
list_index, lrs->string, NULLSTR(pdp->printerlist[list_index].name)));
XtVaSetValues(pdp->selectPrinter.ok, XtNsensitive, True, NULL);
}
static void
printSelectPrinterXtProc(Widget w, XtPointer client_data, XtPointer callData)
{
PrintDialogWidget pdw = (PrintDialogWidget)client_data;
PrintDialogPart *pdp = &pdw->printdialog;
Log(("## select printer!\n"));
if (!pdp->selectPrinter.popup) {
if (!buildPrinterSelectionDialog(pdw)) {
Log(("printSelectPrinterXtProc: buildPrinterSelectionDialog failure.\n"));
return;
}
}
center_popup((Widget)pdw, pdp->selectPrinter.popup);
XtPopup(pdp->selectPrinter.popup, XtGrabExclusive);
}
static void
printerSelectionClose(PrintDialogWidget pdw)
{
PrintDialogPart *pdp = &pdw->printdialog;
if (pdp->selectPrinter.popup) {
XtPopdown(pdp->selectPrinter.popup);
}
}
static void
printerSelectionOKXtProc(Widget w, XtPointer client_data, XtPointer callData)
{
PrintDialogWidget pdw = (PrintDialogWidget)client_data;
PrintDialogPart *pdp = &pdw->printdialog;
XawListReturnStruct *lrs;
int list_index;
Log(("## printerSelectionOKXtProc: closing printer selection!\n"));
lrs = XawListShowCurrent(pdp->selectPrinter.list);
if (!lrs) {
Log(("printerSelectionOKXtProc: |lrs|==NULL\n"));
return;
}
list_index = lrs->list_index;
if (lrs->list_index == XAW_LIST_NONE) {
Log(("printerSelectionOKXtProc: rs->list_index == XAW_LIST_NONE\n"));
XtFree((char *)lrs);
return;
}
XtVaSetValues(pdp->main.name, XtNlabel, NULLSTR(pdp->printerlist[list_index].name), NULL);
XtVaSetValues(pdp->main.desc, XtNlabel, NULLSTR(pdp->printerlist[list_index].desc), NULL);
if (pdp->printer_name)
free(pdp->printer_name);
pdp->printer_name = strdup(lrs->string);
closePrinterConnection(pdw, True);
printerSelectionClose(pdw);
XtFree((char *)lrs);
}
static void
printerSelectionCancelXtProc(Widget w, XtPointer client_data, XtPointer callData)
{
PrintDialogWidget pdw = (PrintDialogWidget)client_data;
Log(("## printerSelectionCancelXtProc: closing printer selection!\n"));
printerSelectionClose(pdw);
}
static
Bool buildPrinterSelectionDialog(PrintDialogWidget pdw)
{
PrintDialogPart *pdp = &pdw->printdialog;
int n;
Arg args[20];
n = 0;
XtSetArg(args[n], XtNallowShellResize, True); n++;
pdp->selectPrinter.popup = XtCreatePopupShell("printerselection", transientShellWidgetClass, (Widget)pdw, args, n);
n = 0;
pdp->selectPrinter.form = XtCreateManagedWidget("form", formWidgetClass, pdp->selectPrinter.popup, args, n);
n = 0;
XtSetArg(args[n], XtNresizable, True); n++;
XtSetArg(args[n], XtNforceColumns, True); n++;
XtSetArg(args[n], XtNdefaultColumns, 1); n++;
XtSetArg(args[n], XtNlist, pdp->widget_printerlist); n++;
XtSetArg(args[n], XtNwidth, DEFAULT_WIDTH); n++;
pdp->selectPrinter.list = XtCreateManagedWidget("list", listWidgetClass, pdp->selectPrinter.form, args, n);
XtAddCallback(pdp->selectPrinter.list, XtNcallback, printerSelectionPrinterSelectedXtProc, pdw);
n = 0;
XtSetArg(args[n], XtNsensitive, False); n++;
pdp->selectPrinter.ok = XtCreateManagedWidget("ok", commandWidgetClass, pdp->selectPrinter.form, args, n);
XtAddCallback(pdp->selectPrinter.ok, XtNcallback, printerSelectionOKXtProc, pdw);
n = 0;
pdp->selectPrinter.cancel = XtCreateManagedWidget("cancel", commandWidgetClass, pdp->selectPrinter.form, args, n);
XtAddCallback(pdp->selectPrinter.cancel, XtNcallback, printerSelectionCancelXtProc, pdw);
XtRealizeWidget(pdp->selectPrinter.popup);
return True;
}
static
void destroyPrinterSelectionDialog(PrintDialogWidget pdw)
{
PrintDialogPart *pdp = &pdw->printdialog;
if (pdp->selectPrinter.popup) {
XtDestroyWidget(pdp->selectPrinter.popup);
}
pdp->selectPrinter.popup = NULL;
pdp->selectPrinter.form = NULL;
pdp->selectPrinter.list = NULL;
pdp->selectPrinter.popup = NULL;
pdp->selectPrinter.cancel = NULL;
}
static void
createprintdialogchildren(Widget w)
{
int n;
Arg args[20];
PrintDialogWidget pdw = (PrintDialogWidget)w;
PrintDialogPart *pdp = &pdw->printdialog;
const char *default_printername = NULL,
*default_printerdesc = NULL;
Bool has_default_printer = False;
pdp->printerlist = XpuGetPrinterList(NULL, &pdp->num_printers);
pdp->widget_printerlist = xpprinterlist_to_widget_printerlist(pdp->printerlist, pdp->num_printers);
if (pdp->num_printers > 0) {
if (pdp->printerlist[0].name && strlen(pdp->printerlist[0].name)) {
default_printername = pdp->printerlist[0].name;
default_printerdesc = pdp->printerlist[0].desc;
pdp->printer_name = strdup(pdp->printerlist[0].name);
has_default_printer = True;
}
}
else
{
PrintMsg(("No Xprint servers could be found.\n"
"Check whether the XPSERVERLIST environment variable contains any valid Xprint server(s).\n"));
}
n = 0;
XtSetArg(args[n], XtNborderWidth, 0); n++;
pdp->main.form = XtCreateManagedWidget("main", formWidgetClass, (Widget)pdw, args, n);
n = 0;
pdp->main.innerform = XtCreateManagedWidget("innerform", formWidgetClass, pdp->main.form, args, n);
n = 0;
XtSetArg(args[n], XtNborderWidth, 0); n++;
XtSetArg(args[n], XtNresizable, False); n++;
XtSetArg(args[n], XtNjustify, XtJustifyRight); n++;
XtSetArg(args[n], XtNwidth, DEFAULT_WIDTH); n++;
pdp->main.desclabel = XtCreateManagedWidget("desclabel", labelWidgetClass, pdp->main.innerform, args, n);
n = 0;
XtSetArg(args[n], XtNborderWidth, 0); n++;
XtSetArg(args[n], XtNresizable, False); n++;
XtSetArg(args[n], XtNjustify, XtJustifyLeft); n++;
XtSetArg(args[n], XtNwidth, DEFAULT_INFOLABEL_WIDTH); n++;
XtSetArg(args[n], XtNlabel, default_printerdesc?default_printerdesc:"-"); n++;
pdp->main.desc = XtCreateManagedWidget("desc", labelWidgetClass, pdp->main.innerform, args, n);
n = 0;
XtSetArg(args[n], XtNsensitive, has_default_printer); n++;
pdp->main.info = XtCreateManagedWidget("info", commandWidgetClass, pdp->main.innerform, args, n);
n = 0;
XtSetArg(args[n], XtNborderWidth, 0); n++;
XtSetArg(args[n], XtNresizable, False); n++;
XtSetArg(args[n], XtNjustify, XtJustifyRight); n++;
XtSetArg(args[n], XtNwidth, DEFAULT_WIDTH); n++;
pdp->main.namelabel = XtCreateManagedWidget("namelabel", labelWidgetClass, pdp->main.innerform, args, n);
n = 0;
XtSetArg(args[n], XtNborderWidth, 0); n++;
XtSetArg(args[n], XtNresizable, False); n++;
XtSetArg(args[n], XtNjustify, XtJustifyLeft); n++;
XtSetArg(args[n], XtNlabel, default_printername?default_printername:"-"); n++;
XtSetArg(args[n], XtNwidth, DEFAULT_INFOLABEL_WIDTH); n++;
pdp->main.name = XtCreateManagedWidget("name", labelWidgetClass, pdp->main.innerform, args, n);
n = 0;
pdp->main.selectprinter = XtCreateManagedWidget("selectprinter", commandWidgetClass, pdp->main.innerform, args, n);
XtAddCallback(pdp->main.selectprinter, XtNcallback, printSelectPrinterXtProc, pdw);
n = 0;
XtSetArg(args[n], XtNborderWidth, 0); n++;
XtSetArg(args[n], XtNresizable, False); n++;
XtSetArg(args[n], XtNjustify, XtJustifyRight); n++;
XtSetArg(args[n], XtNwidth, DEFAULT_WIDTH); n++;
XtSetArg(args[n], XtNsensitive, False); n++;
pdp->main.filenamelabel = XtCreateManagedWidget("filenamelabel", labelWidgetClass, pdp->main.innerform, args, n);
n = 0;
XtSetArg(args[n], XtNborderWidth, 0); n++;
XtSetArg(args[n], XtNresizable, False); n++;
XtSetArg(args[n], XtNjustify, XtJustifyLeft); n++;
XtSetArg(args[n], XtNlabel, "-"); n++;
XtSetArg(args[n], XtNwidth, DEFAULT_INFOLABEL_WIDTH); n++;
XtSetArg(args[n], XtNsensitive, False); n++;
pdp->main.filename = XtCreateManagedWidget("filename", labelWidgetClass, pdp->main.innerform, args, n);
n = 0;
XtSetArg(args[n], XtNsensitive, False); n++;
pdp->main.selectfile = XtCreateManagedWidget("selectfile", commandWidgetClass, pdp->main.innerform, args, n);
XtAddCallback(pdp->main.selectfile, XtNcallback, printSelectFileXtProc, pdw);
n = 0;
XtSetArg(args[n], XtNstate, True); n++;
pdp->main.printtoprinter = XtCreateManagedWidget("printtoprinter", toggleWidgetClass, pdp->main.innerform, args, n);
XtAddCallback(pdp->main.printtoprinter, XtNcallback, printDialogDestXtProc, pdw);
n = 0;
XtSetArg(args[n], XtNstate, False); n++;
pdp->main.printtofile = XtCreateManagedWidget("printtofile", toggleWidgetClass, pdp->main.innerform, args, n);
XtAddCallback(pdp->main.printtofile, XtNcallback, printDialogDestXtProc, pdw);
n = 0;
XtSetArg(args[n], XtNsensitive, has_default_printer); n++;
pdp->main.ok = XtCreateManagedWidget("ok", commandWidgetClass, pdp->main.form, args, n);
XtAddCallback(pdp->main.ok, XtNcallback, printOKXtProc, pdw);
n = 0;
XtSetArg(args[n], XtNsensitive, has_default_printer); n++;
pdp->main.setup = XtCreateManagedWidget("setup", commandWidgetClass, pdp->main.form, args, n);
XtAddCallback(pdp->main.setup, XtNcallback, printSetupXtProc, pdw);
n = 0;
pdp->main.cancel = XtCreateManagedWidget("cancel", commandWidgetClass, pdp->main.form, args, n);
XtAddCallback(pdp->main.cancel, XtNcallback, printCancelXtProc, pdw);
}
static void XawPrintDialogConstraintInitialize(Widget, Widget, ArgList, Cardinal *);
static void XawPrintDialogGetValuesHook(Widget, ArgList, Cardinal*);
static void XawPrintDialogInitialize(Widget, Widget, ArgList, Cardinal*);
static void XawPrintDialogDestroy(Widget);
static Boolean XawPrintDialogSetValues(Widget, Widget, Widget, ArgList, Cardinal *);
static XtResource resources[] = {
{
XtNicon,
XtCIcon,
XtRBitmap,
sizeof(Pixmap),
XtOffsetOf(PrintDialogRec, printdialog.icon),
XtRImmediate,
0
},
{
XawNOkCallback, XtCCallback, XtRCallback,
sizeof(XtCallbackList), XtOffsetOf(PrintDialogRec, printdialog.ok_callback),
XtRImmediate, (XtPointer)NULL
},
{
XawNCancelCallback, XtCCallback, XtRCallback,
sizeof(XtCallbackList), XtOffsetOf(PrintDialogRec, printdialog.cancel_callback),
XtRImmediate, (XtPointer)NULL
},
};
PrintDialogClassRec printdialogClassRec = {
{
(WidgetClass)&formClassRec,
"PrintDialog",
sizeof(PrintDialogRec),
XawInitializeWidgetSet,
NULL,
False,
XawPrintDialogInitialize,
NULL,
XtInheritRealize,
NULL,
0,
resources,
XtNumber(resources),
NULLQUARK,
True,
True,
True,
False,
XawPrintDialogDestroy,
XtInheritResize,
XtInheritExpose,
XawPrintDialogSetValues,
NULL,
XtInheritSetValuesAlmost,
XawPrintDialogGetValuesHook,
NULL,
XtVersion,
NULL,
NULL,
XtInheritQueryGeometry,
XtInheritDisplayAccelerator,
NULL,
},
{
XtInheritGeometryManager,
XtInheritChangeManaged,
XtInheritInsertChild,
XtInheritDeleteChild,
NULL,
},
{
NULL,
0,
sizeof(PrintDialogConstraintsRec),
XawPrintDialogConstraintInitialize,
NULL,
NULL,
NULL,
},
{
XtInheritLayout,
},
{
NULL,
}
};
WidgetClass printDialogWidgetClass = (WidgetClass)&printdialogClassRec;
static void
XawPrintDialogInitialize(Widget request, Widget cnew, ArgList args, Cardinal *num_args)
{
PrintDialogWidget dw = (PrintDialogWidget)cnew;
Arg arglist[9];
Cardinal arg_cnt = 0;
XtSetArg(arglist[arg_cnt], XtNborderWidth, 0); arg_cnt++;
XtSetArg(arglist[arg_cnt], XtNleft, XtChainLeft); arg_cnt++;
if (dw->printdialog.icon != (Pixmap)0) {
XtSetArg(arglist[arg_cnt], XtNbitmap, dw->printdialog.icon); arg_cnt++;
XtSetArg(arglist[arg_cnt], XtNright, XtChainLeft); arg_cnt++;
dw->printdialog.iconW = XtCreateManagedWidget("icon", labelWidgetClass,
cnew, arglist, arg_cnt);
arg_cnt = 2;
XtSetArg(arglist[arg_cnt], XtNfromHoriz, dw->printdialog.iconW); arg_cnt++;
}
else {
dw->printdialog.iconW = NULL;
}
createprintdialogchildren((Widget)dw);
}
static void
XawPrintDialogConstraintInitialize(Widget request, Widget cnew,
ArgList args, Cardinal *num_args)
{
PrintDialogWidget dw = (PrintDialogWidget)cnew->core.parent;
PrintDialogConstraints constraint = (PrintDialogConstraints)cnew->core.constraints;
if (!XtIsSubclass(cnew, commandWidgetClass))
return;
constraint->form.left = constraint->form.right = XtChainLeft;
constraint->form.vert_base = dw->printdialog.main.form;
if (dw->composite.num_children > 1) {
WidgetList children = dw->composite.children;
Widget *childP;
for (childP = children + dw->composite.num_children - 1;
childP >= children; childP-- ) {
if (*childP == dw->printdialog.main.form)
break;
if (XtIsManaged(*childP) &&
XtIsSubclass(*childP, commandWidgetClass)) {
constraint->form.horiz_base = *childP;
break;
}
}
}
}
#define ICON 0
#define NUM_CHECKS 1
static Boolean
XawPrintDialogSetValues(Widget current, Widget request, Widget cnew,
ArgList in_args, Cardinal *in_num_args)
{
PrintDialogWidget w = (PrintDialogWidget)cnew;
PrintDialogWidget old = (PrintDialogWidget)current;
Arg args[5];
unsigned int i;
Bool checks[NUM_CHECKS];
for (i = 0; i < NUM_CHECKS; i++)
checks[i] = False;
for (i = 0; i < *in_num_args; i++) {
if (!strcmp(XtNicon, in_args[i].name))
checks[ICON] = True;
}
if (checks[ICON]) {
if (w->printdialog.icon != 0) {
XtSetArg(args[0], XtNbitmap, w->printdialog.icon);
if (old->printdialog.iconW != NULL) {
XtSetValues(old->printdialog.iconW, args, 1);
}
else {
XtSetArg(args[1], XtNborderWidth, 0);
XtSetArg(args[2], XtNleft, XtChainLeft);
XtSetArg(args[3], XtNright, XtChainLeft);
w->printdialog.iconW = XtCreateWidget("icon", labelWidgetClass,
cnew, args, 4);
XtManageChild(w->printdialog.iconW);
}
}
else if (old->printdialog.icon != 0) {
XtDestroyWidget(old->printdialog.iconW);
w->printdialog.iconW = NULL;
}
}
return True;
}
static void
XawPrintDialogGetValuesHook(Widget w, ArgList args, Cardinal *num_args)
{
}
static void
XawPrintDialogDestroy(Widget w)
{
PrintDialogWidget pdw = (PrintDialogWidget)w;
Log(("# XawPrintDialogDestroy: start.\n"));
destroyPrintSetupDialog(pdw);
destroyPrinterSelectionDialog(pdw);
closePrinterConnection(pdw, True);
Log(("# XawPrintDialogDestroy: done.\n"));
}
void
XawPrintDialogClosePrinterConnection(Widget w, Bool closeDisplay)
{
closePrinterConnection((PrintDialogWidget)w, closeDisplay);
}