diff options
Diffstat (limited to 'printdialog.c')
| -rw-r--r-- | printdialog.c | 1353 |
1 files changed, 1353 insertions, 0 deletions
diff --git a/printdialog.c b/printdialog.c new file mode 100644 index 0000000..97cf4c9 --- /dev/null +++ b/printdialog.c @@ -0,0 +1,1353 @@ +/* + * $Xorg: printdialog.c,v 1.1 2004/05/12 02:05:54 gisburn Exp $ + * +Copyright 2004 Roland Mainz <roland.mainz@nrubsig.org> + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + * + */ + +/* Force ANSI C prototypes from X11 headers */ +#ifndef FUNCPROTO +#define FUNCPROTO 15 +#endif /* !FUNCPROTO */ + +#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 /* XKB */ + +#include "printdialog.h" +#include "printdialogprivates.h" +#include "print.h" + +#include <stdlib.h> +#include <ctype.h> +#include <stdio.h> + +/* Turn a NULL pointer string into an empty string */ +#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 /* DEBUG */ + +/* Local prototypes */ +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 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 /* XKB */ +} + +/* Center popup (on parent, not on screen - which would be a bad idea + * in the Xinerama case) */ +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; + + /* Do not update anything if we will be destroyed */ + if (pdw->core.being_destroyed) + return; + + if (pdp->printToFile == False) { + XtVaSetValues(pdp->main.printtoprinter, XtNstate, True, NULL); + XtVaSetValues(pdp->main.printtofile, XtNstate, False, NULL); + /* Disable the widgets which depend on print-to-file */ + 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); + /* Enable the widgets which depend on print-to-file */ + XtVaSetValues(pdp->main.filenamelabel, XtNsensitive, True, NULL); + XtVaSetValues(pdp->main.filename, XtNsensitive, True, NULL); + XtVaSetValues(pdp->main.selectfile, XtNsensitive, True, NULL); + } + + /* Update file name */ + XtVaSetValues(pdp->main.filename, XtNlabel, pdp->filename?pdp->filename:"-", NULL); + + /* General check whether we can print... */ + 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; + + /* Some extra checks for print-to-file */ + 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")); + + /* Set copy count (if the value is invalid beep and return to the user ) */ + 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; + } + + /* Fix me: We should set the number of _job_ copies here, not _doc_ copies */ + XpuSetDocumentCopies(pdp->pdpy, pdp->pcontext, c); + } + + /* Set paper size */ + 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); + + /* Set resolution */ + 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); + + /* Set orientation */ + 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); + + /* Set plex mode */ + 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); + + 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")); + + /* Check whether the input is a valid number - and in the case of invalid input reset the value */ + XtVaGetValues(pdp->setup.jobcopies, XtNstring, &string, NULL); + if (string) { + char *s; + int i; + Bool isValidNumber = True; + + /* First check for invalid characters... */ + for( s = string ; *s != '\0' ; s++ ) { + if (!isdigit(*s)) { + isValidNumber = False; + break; + } + } + + /* .. and the do a range check... */ + 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; + 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->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")); + + /* Close any outstanding connection first... */ + 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->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); + + 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); + } + + /* |XtDestroyWidget(pdp->setup.popup);| above will recursively destroy + * all children so we only have to reset the pointers here... */ + 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.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; + } + } + + /* Get flags which types of attributes can be modified */ + 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], 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; /* Terminate the list */ + + 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; /* FixMe: tray selection missing */ + + names[i] = NULL; /* Terminate the list */ + + return names; +} + +static +String *xpresolutionlist_to_widget_resolutionlist(XpuResolutionList reslist, int num_resolutions) +{ + int i; + String *names; + char *mem; + + /* Allocate a chunk of memory... */ + mem = malloc((sizeof(String *)+32) * (num_resolutions+2)); + + /* ... which has enougth space for the list pointers... */ + names = (String *)mem; + if (!names) + return NULL; + + /* ... and the numbers (assuming one number isn't longer than 32-1 chars) */ + mem += sizeof(String *) * (num_resolutions+2); + + for(i = 0 ; i < num_resolutions ; i++) { + sprintf(mem, "%d", (int)reslist[i].dpi); + names[i] = mem; + mem += strlen(mem) + 1; + } + + names[i] = NULL; /* Terminate the list */ + + 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; /* Terminate the list */ + + 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; /* Terminate the list */ + + 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))); + + /* Enable OK button */ + 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")); + + /* Copy current selection in printer list widget and open a printer connection */ + 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; + } + + /* Set printer name and description in main dialog */ + 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); + + /* Close any outstanding printer connection since user has selected + * a different printer */ + 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); + } + + /* |XtDestroyWidget(pdp->setup.popup);| above will recursively destroy + * all children so we only have to reset the pointers here... */ + pdp->selectPrinter.popup = NULL; + pdp->selectPrinter.form = NULL; + pdp->selectPrinter.list = NULL; + pdp->selectPrinter.popup = NULL; + pdp->selectPrinter.cancel = NULL; +} + +/* + * Function: + * createprintdialogchildren + * + * Parameters: + * w - print dialog widget + * + * Description: + * Creates the print dialog widgets. + * + * Note + * - + */ +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)) { + /* XprintUtils moves the default printer to the top */ + 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 + { + XtAppWarning(XtWidgetToApplicationContext(w), + "No Xprint servers could be found. " + "Check whether the XPSERVERLIST environment variable contains any valid Xprint server(s)."); + } + + 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); + /* + XtAddCallback(pdp->main.info, XtNcallback, printerInfoXtProc, 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++; + 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); + + /* Line: "File selection" */ + + 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); + + /* Line: Misc (Print destination toggles, copy-count etc.)*/ + 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); + + /* End-of-Inner-Form-Content */ + + 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); +} + +/* + * Class Methods + */ +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 *); + +/* + * Initialization + */ +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 = { + /* core */ + { + (WidgetClass)&formClassRec, /* superclass */ + "PrintDialog", /* class_name */ + sizeof(PrintDialogRec), /* widget_size */ + XawInitializeWidgetSet, /* class_initialize */ + NULL, /* class_part init */ + False, /* class_inited */ + XawPrintDialogInitialize, /* initialize */ + NULL, /* initialize_hook */ + XtInheritRealize, /* realize */ + NULL, /* actions */ + 0, /* num_actions */ + resources, /* resources */ + XtNumber(resources), /* num_resources */ + NULLQUARK, /* xrm_class */ + True, /* compress_motion */ + True, /* compress_exposure */ + True, /* compress_enterleave */ + False, /* visible_interest */ + XawPrintDialogDestroy, /* destroy */ + XtInheritResize, /* resize */ + XtInheritExpose, /* expose */ + XawPrintDialogSetValues, /* set_values */ + NULL, /* set_values_hook */ + XtInheritSetValuesAlmost, /* set_values_almost */ + XawPrintDialogGetValuesHook, /* get_values_hook */ + NULL, /* accept_focus */ + XtVersion, /* version */ + NULL, /* callback_private */ + NULL, /* tm_table */ + XtInheritQueryGeometry, /* query_geometry */ + XtInheritDisplayAccelerator, /* display_accelerator */ + NULL, /* extension */ + }, + /* composite */ + { + XtInheritGeometryManager, /* geometry_manager */ + XtInheritChangeManaged, /* change_managed */ + XtInheritInsertChild, /* insert_child */ + XtInheritDeleteChild, /* delete_child */ + NULL, /* extension */ + }, + /* constraint */ + { + NULL, /* subresourses */ + 0, /* subresource_count */ + sizeof(PrintDialogConstraintsRec), /* constraint_size */ + XawPrintDialogConstraintInitialize, /* initialize */ + NULL, /* destroy */ + NULL, /* set_values */ + NULL, /* extension */ + }, + /* form */ + { + XtInheritLayout, /* layout */ + }, + /* printdialog */ + { + NULL, /* extension */ + } +}; + +WidgetClass printDialogWidgetClass = (WidgetClass)&printdialogClassRec; + +/* + * Implementation + */ +/*ARGSUSED*/ +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); +} + +/*ARGSUSED*/ +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)) /* if not a button */ + return; /* then just use defaults */ + + 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 +/*ARGSUSED*/ +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; +} + +/* + * Function: + * XawPrintDialogGetValuesHook + * + * Parameters: + * w - Print Dialog Widget + * args - argument list + * num_args - number of args + * + * Description: + * This is a get values hook routine that gets the values in the dialog. + */ +static void +XawPrintDialogGetValuesHook(Widget w, ArgList args, Cardinal *num_args) +{ + /* NO-OP for now */ +} + +static void +XawPrintDialogDestroy(Widget w) +{ + PrintDialogWidget pdw = (PrintDialogWidget)w; + Log(("# XawPrintDialogDestroy: start.\n")); + + destroyPrintSetupDialog(pdw); + destroyPrinterSelectionDialog(pdw); + closePrinterConnection(pdw, True); + + Log(("# XawPrintDialogDestroy: done.\n")); +} + +/* + * Function: + * XawPrintDialogClosePrinterConnection + * + * Parameters: + * w - Print Dialog Widget + * closeDisplay - Boolean which decides whether |Display *| + * and |XPContext| should be disposed, too. + * + * Description: + * The print display connection is owned by the print dialog + * by default. + * If the application wishes to close the display connection + * to the print server, either to close it itself or force + * a disconnection for other reasons this function can be used. + * + * Notes + * 1. PUBLIC API + * 2. After this function returns all resources returned by the + * print dialog which are related to the status of the printer + * connection are stale. + */ +void +XawPrintDialogClosePrinterConnection(Widget w, Bool closeDisplay) +{ + closePrinterConnection((PrintDialogWidget)w, closeDisplay); +} + |