/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
};
/* let's try to support a few of these */
PrinterName.class,
PrinterIsAcceptingJobs.class,
QueuedJobCount.class,
ColorSupported.class,
};
/* it turns out to be inconvenient to store the other categories
* separately because many attributes are in multiple categories.
*/
JobName.class,
RequestingUserName.class,
Copies.class,
Destination.class,
OrientationRequested.class,
PageRanges.class,
Media.class,
MediaPrintableArea.class,
Fidelity.class,
// We support collation on 2D printer jobs, even if the driver can't.
SheetCollate.class,
SunAlternateMedia.class,
Chromaticity.class
};
/*
* This table together with methods findWin32Media and
* findMatchingMediaSizeNameMM are declared public as these are also
* used in WPrinterJob.java.
*/
MediaSizeName.D, MediaSizeName.E,
};
};
// from wingdi.h
// media sizes with indices above dmPaperToPrintService' length
// Bit settings for getPrinterCapabilities which matches that
// of native getCapabilities in WPrinterJob.cpp
private int nCopies;
private int prnCaps;
private int[] defaultSettings;
private boolean gotTrays;
private boolean gotCopies;
private boolean mediaInitialized;
private boolean mpaListInitialized;
private boolean isInvalid;
throw new IllegalArgumentException("null printer name");
}
// initialize flags
mediaInitialized = false;
gotTrays = false;
gotCopies = false;
isInvalid = false;
prnCaps = 0;
}
public void invalidateService() {
isInvalid = true;
}
return printer;
}
}
return name;
}
if (msn instanceof Win32MediaSize) {
return winMedia.getDMPaper();
} else {
}
}
return DMPAPER_A2;
}
return DMPAPER_A6;
}
return DMPAPER_B6_JIS;
}
}
// If not found in predefined Windows ID, then we search through
// the returned IDs of the driver because they can define their own
// unique IDs.
initMedia();
}
}
}
return 0;
}
}
if(trays[i] instanceof Win32MediaTray) {
return win32Tray;
}
}
}
}
return Win32MediaTray.AUTO;
}
}
switch(dmIndex) {
/* matching media sizes with indices beyond
dmPaperToPrintService's length */
case DMPAPER_A2:
return MediaSizeName.ISO_A2;
case DMPAPER_A6:
return MediaSizeName.ISO_A6;
case DMPAPER_B6_JIS:
return MediaSizeName.JIS_B6;
default:
return null;
}
}
return false;
}
}
return true;
}
private synchronized void initMedia() {
if (mediaInitialized == true) {
return;
}
mediaInitialized = true;
return;
}
boolean added;
boolean queryFailure = false;
float[] prnArea;
// Get all mediaSizes supported by the printer.
// We convert media to ArrayList idList and pass this to the
// function for getting mediaSizes.
// This is to ensure that mediaSizes and media IDs have 1-1 correspondence.
// We remove from ID list any invalid mediaSize. Though this is rare,
// it happens in HP 4050 German driver.
}
// match Win ID with our predefined ID using table
// Verify that this standard size is the same size as that
// reported by the driver. This should be the case except when
// the driver is mis-using a standard windows paper ID.
{
}
}
// No match found, then we get the MediaSizeName out of the MediaSize
// This requires 1-1 correspondence, lengths must be checked.
}
// Add mediaName to the msnList
added = false;
}
/* The following block allows to add such media names to the list, whose sizes
* matched with media sizes predefined in JDK, while whose paper IDs did not,
* or whose sizes and paper IDs both did not match with any predefined in JDK.
*/
}
if (!added) {
} else {
}
}
}
}
}
// init mediaSizeNames
}
/*
* Gets a list of MediaPrintableAreas using a call to native function.
* msn is MediaSizeName used to get a specific printable area. If null,
* it will get all the supported MediPrintableAreas.
*/
{
if (mpaListInitialized == true) {
return mediaPrintables;
}
} else {
// get from cached mapping of MPAs
return mpaArr;
}
}
initMedia();
return null;
}
} else {
}
}
continue;
}
try {
prnArea[1],
prnArea[2],
prnArea[3],
}
catch (IllegalArgumentException e) {
}
} else {
// if getting MPA failed, we use MediaSize
try {
} catch (IllegalArgumentException e) {
}
}
}
} //mediaName != null
}
return null;
}
return null;
}
// by this time, we've already gotten the desired MPA
return mpaArr;
} else {
mpaListInitialized = true;
return mediaPrintables;
}
}
return mediaTrays;
}
return null;
}
/* first count how many valid bins there are so we can allocate
* an array of the correct size
*/
int nTray = 0;
}
int dmBin;
/* Some drivers in Win 7 don't have the same length for DC_BINS and
* DC_BINNAMES so there is no guarantee that lengths of mediaTr and
* winMediaTrayNames are equal. To avoid getting ArrayIndexOutOfBounds,
* we need to make sure we get the minimum of the two.
*/
if (dmBin > 0) {
// check for unsupported DMBINs and create new Win32MediaTray
} else {
}
}
// no else - For invalid ids, just ignore it because assigning a "default"
// value may result in duplicate trays.
}
mediaTrays = arr;
gotTrays = true;
return mediaTrays;
}
// Get diff of reverse dimensions
// EPSON Stylus COLOR 860 reverses envelope's width & height
return true;
} else {
return false;
}
}
if (predefMedia != null) {
if (predefMedia[k] == null) {
continue;
}
w, h)) {
return predefMedia[k].getMediaSizeName();
}
}
}
return null;
}
private MediaSize[] getMediaSizes(ArrayList idList, int[] media, ArrayList<String> dmPaperNameList) {
if (dmPaperNameList == null) {
}
return null;
}
// Make sure to validate wid & ht.
// HP LJ 4050 (german) causes IAE in Sonderformat paper, wid & ht
// returned is not constant.
//Remove corresponding ID from list
}
continue;
}
// Find matching media using dimensions.
// This call matches only with our own predefined sizes.
}
} else {
}
try {
} catch(IllegalArgumentException e) {
}
}
}
}
return arr2;
}
}
else {
return PrinterIsAcceptingJobs.ACCEPTING_JOBS;
}
}
if (isInvalid) {
return PrinterState.STOPPED;
} else {
return null;
}
}
if (isInvalid) {
return psr;
} else {
return null;
}
}
if (count != -1) {
return new QueuedJobCount(count);
}
else {
return new QueuedJobCount(0);
}
}
synchronized (this) {
if (gotCopies == false) {
gotCopies = true;
}
}
}
initMedia();
if (mediaSizeNames != null) {
return true;
}
}
}
return false;
}
if (mediaPrintables != null) {
return true;
}
}
}
return false;
}
return true;
}
}
}
return false;
}
private int getPrinterCapabilities() {
if (prnCaps == 0) {
}
return prnCaps;
}
}
return port;
}
/*
* NOTE: defaults indices must match those in WPrinterJob.cpp
*/
private int[] getDefaultPrinterSettings() {
if (defaultSettings == null) {
}
return defaultSettings;
}
} else {
for (int i=0; i<nRes; i++) {
try {
} catch (IllegalArgumentException e) {
}
}
}
}
return printRes;
}
if (supportedRes != null) {
return true;
}
}
}
return false;
}
}
return new Win32PrintJob(this);
}
return attrs;
}
} else {
new HashPrintServiceAttributeSet();
}
}
}
}
public void wakeNotifier() {
synchronized (this) {
}
}
}
listener) {
synchronized (this) {
return;
}
notifier = new ServiceNotifier(this);
}
}
}
public void removePrintServiceAttributeListener(
synchronized (this) {
return;
}
}
}
}
public <T extends PrintServiceAttribute> T
{
throw new NullPointerException("category");
}
throw new IllegalArgumentException("Not a PrintServiceAttribute");
}
if (category == ColorSupported.class) {
int caps = getPrinterCapabilities();
return (T)ColorSupported.SUPPORTED;
} else {
return (T)ColorSupported.NOT_SUPPORTED;
}
} else if (category == PrinterName.class) {
return (T)getPrinterName();
} else if (category == PrinterState.class) {
return (T)getPrinterState();
} else if (category == PrinterStateReasons.class) {
return (T)getPrinterStateReasons();
} else if (category == QueuedJobCount.class) {
return (T)getQueuedJobCount();
} else if (category == PrinterIsAcceptingJobs.class) {
return (T)getPrinterIsAcceptingJobs();
} else {
return null;
}
}
}
if (prnStateReasons != null) {
}
int caps = getPrinterCapabilities();
} else {
}
}
int caps = getPrinterCapabilities();
// doc flavors supported
// if PostScript is supported
} else {
}
return supportedDocFlavors;
}
/* To avoid a native query which may be time-consuming
* do not invoke native unless postscript support is being queried.
* Instead just check the ones we 'always' support
*/
if (isPostScriptFlavor(flavor)) {
} else {
}
return true;
}
}
return false;
}
}
int caps = getPrinterCapabilities();
}
int[] defaults = getDefaultPrinterSettings();
// Added check: if supported, we should be able to get the default.
}
}
}
}
public boolean
{
throw new NullPointerException("null category");
}
throw new IllegalArgumentException(category +
" is not an Attribute");
}
return true;
}
}
return false;
}
public Object
{
throw new NullPointerException("null category");
}
throw new IllegalArgumentException(category +
" is not an Attribute");
}
if (!isAttributeCategorySupported(category)) {
return null;
}
int[] defaults = getDefaultPrinterSettings();
// indices must match those in WPrinterJob.cpp
if (defCopies > 0) {
} else {
return new Copies(1);
}
} else if (category == Chromaticity.class) {
int caps = getPrinterCapabilities();
return Chromaticity.MONOCHROME;
} else {
return Chromaticity.COLOR;
}
} else if (category == OrientationRequested.class) {
if (defOrient == DMORIENT_LANDSCAPE) {
return OrientationRequested.LANDSCAPE;
} else {
return OrientationRequested.PORTRAIT;
}
} else if (category == PageRanges.class) {
}
return msn;
} else {
initMedia();
// if 'mediaSizeNames' is not null, idList and mediaSizes
// cannot be null but to be safe, add a check
}
}
return mediaSizeNames[0];
}
}
} else if (category == MediaPrintableArea.class) {
/* Verify defPaper */
}
try {
prnArea[1],
prnArea[2],
prnArea[3],
} catch (IllegalArgumentException e) {
}
return printableArea;
}
return null;
} else if (category == SunAlternateMedia.class) {
return null;
} else if (category == Destination.class) {
try {
} catch (SecurityException se) {
try {
} catch (URISyntaxException e) {
return null;
}
}
switch(defSides) {
case DMDUP_VERTICAL :
return Sides.TWO_SIDED_LONG_EDGE;
case DMDUP_HORIZONTAL :
return Sides.TWO_SIDED_SHORT_EDGE;
default :
}
} else if (category == PrinterResolution.class) {
int xRes = defQuality;
if (res > 0) {
}
}
else {
}
} else if (category == ColorSupported.class) {
int caps = getPrinterCapabilities();
return ColorSupported.SUPPORTED;
} else {
return ColorSupported.NOT_SUPPORTED;
}
} else if (category == PrintQuality.class) {
switch (defQuality) {
case DMRES_HIGH:
return PrintQuality.HIGH;
case DMRES_MEDIUM:
return PrintQuality.NORMAL;
default:
return PrintQuality.DRAFT;
}
}
} else if (category == RequestingUserName.class) {
try {
} catch (SecurityException se) {
}
} else if (category == SheetCollate.class) {
if (defCollate == DMCOLLATE_TRUE) {
return SheetCollate.COLLATED;
} else {
return SheetCollate.UNCOLLATED;
}
return Fidelity.FIDELITY_FALSE;
}
return null;
}
return true;
}
else {
return false;
}
}
return true;
}
else {
return false;
}
}
return true;
}
else {
return false;
}
}
public Object
{
throw new NullPointerException("null category");
}
throw new IllegalArgumentException(category +
" does not implement Attribute");
}
if (!isDocFlavorSupported(flavor)) {
throw new IllegalArgumentException(flavor +
" is an unsupported flavor");
// if postscript & category is already specified within the
// PostScript data we return null
(isPSDocAttr(category)))){
return null;
}
}
if (!isAttributeCategorySupported(category)) {
return null;
}
} else if (category == RequestingUserName.class) {
try {
} catch (SecurityException se) {
}
} else if (category == ColorSupported.class) {
int caps = getPrinterCapabilities();
return ColorSupported.SUPPORTED;
} else {
return ColorSupported.NOT_SUPPORTED;
}
} else if (category == Chromaticity.class) {
int caps = getPrinterCapabilities();
return (arr);
} else {
return (arr);
}
} else {
return null;
}
} else if (category == Destination.class) {
try {
} catch (SecurityException se) {
try {
} catch (URISyntaxException e) {
return null;
}
}
} else if (category == OrientationRequested.class) {
return arr;
} else {
return null;
}
(category == CopiesSupported.class)) {
synchronized (this) {
if (gotCopies == false) {
gotCopies = true;
}
}
initMedia();
if (mediaSizeNames != null) {
}
}
return arr;
} else if (category == MediaPrintableArea.class) {
// if getting printable area for a specific media size
if ((attributes != null) &&
((mediaName =
if (!(mediaName instanceof MediaSizeName)) {
// if an instance of MediaTray, fall thru returning
// all MediaPrintableAreas
}
}
return arr;
} else {
return null;
}
} else if (category == SunAlternateMedia.class) {
return new SunAlternateMedia(
} else if (category == PageRanges.class) {
return arr;
} else {
return null;
}
} else if (category == PrinterResolution.class) {
if (supportedRes == null) {
return null;
}
PrinterResolution []arr =
return arr;
return arr;
} else {
return null;
}
} else if (category == PrintQuality.class) {
return arr;
} else if (category == SheetCollate.class) {
return arr;
} else {
return null;
}
return arr;
} else {
return null;
}
}
throw new NullPointerException("null attribute");
}
if (!isDocFlavorSupported(flavor)) {
throw new IllegalArgumentException(flavor +
" is an unsupported flavor");
// if postscript & category is already specified within the PostScript data
// we return false
(isPSDocAttr(category)))) {
return false;
}
}
if (!isAttributeCategorySupported(category)) {
return false;
}
else if (category == Chromaticity.class) {
int caps = getPrinterCapabilities();
return true;
} else {
}
} else {
return false;
}
} else if (category == Destination.class) {
return true;
} else {
return false;
}
if (attr instanceof MediaSizeName) {
}
}
} else if (category == MediaPrintableArea.class) {
} else if (category == SunAlternateMedia.class) {
} else if (category == PageRanges.class ||
category == SheetCollate.class ||
return false;
}
} else if (category == PrinterResolution.class) {
if (attr instanceof PrinterResolution) {
}
} else if (category == OrientationRequested.class) {
return false;
}
} else if (category == ColorSupported.class) {
int caps = getPrinterCapabilities();
return false;
}
}
return true;
}
"is not supported");
}
if (attributes == null) {
return null;
}
try {
}
}
} catch (ClassCastException e) {
}
}
return null;
} else {
return unsupp;
}
}
return null;
}
return "Win32 Printer : " + getName();
}
return (obj == this ||
(obj instanceof Win32PrintService &&
}
public int hashCode() {
}
}
int paperSize);
}
private Win32MediaSize(int x) {
super(x);
}
}
if (nameIndex != -1) {
}
return null;
}
return predefMedia;
}
winEnumTable.add(this);
}
return (MediaSizeName[])super.getEnumValueTable();
}
static {
/* initialize predefMedia */
{
// cannot call getSuperEnumTable directly because of static context
}
}
}
}
int getDMPaper() {
return dmPaperID;
}
}
}
}