Android examples for android.print:PageRange
compute Printed Pages using PageRange
/*/*from ww w . j av a2s .c o m*/ * Copyright (C) 2014 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ import android.print.PageRange; import android.print.PrintDocumentInfo; import java.util.Arrays; import java.util.Comparator; public class Main{ private static final PageRange[] ALL_PAGES_RANGE = new PageRange[] { PageRange.ALL_PAGES }; private static final Comparator<PageRange> sComparator = new Comparator<PageRange>() { @Override public int compare(PageRange lhs, PageRange rhs) { return lhs.getStart() - rhs.getStart(); } }; public static PageRange[] computePrintedPages( PageRange[] requestedPages, PageRange[] writtenPages, int pageCount) { // Adjust the print job pages based on what was requested and written. // The cases are ordered in the most expected to the least expected // with a special case first where the app does not know the page count // so we ask for all to be written. if (Arrays.equals(requestedPages, ALL_PAGES_RANGE) && pageCount == PrintDocumentInfo.PAGE_COUNT_UNKNOWN) { return ALL_PAGES_RANGE; } else if (Arrays.equals(writtenPages, requestedPages)) { // We got a document with exactly the pages we wanted. Hence, // the printer has to print all pages in the data. return ALL_PAGES_RANGE; } else if (Arrays.equals(writtenPages, ALL_PAGES_RANGE)) { // We requested specific pages but got all of them. Hence, // the printer has to print only the requested pages. return requestedPages; } else if (PageRangeUtils.contains(writtenPages, requestedPages, pageCount)) { // We requested specific pages and got more but not all pages. // Hence, we have to offset appropriately the printed pages to // be based off the start of the written ones instead of zero. // The written pages are always non-null and not empty. final int offset = -writtenPages[0].getStart(); PageRangeUtils.offset(requestedPages, offset); return requestedPages; } else if (Arrays.equals(requestedPages, ALL_PAGES_RANGE) && isAllPages(writtenPages, pageCount)) { // We requested all pages via the special constant and got all // of them as an explicit enumeration. Hence, the printer has // to print only the requested pages. return ALL_PAGES_RANGE; } return null; } /** * Gets whether page ranges contains a given page. * * @param pageRanges The page ranges. * @param pageIndex The page for which to check. * @return Whether the page is within the ranges. */ public static boolean contains(PageRange[] pageRanges, int pageIndex) { final int rangeCount = pageRanges.length; for (int i = 0; i < rangeCount; i++) { PageRange pageRange = pageRanges[i]; if (pageRange.contains(pageIndex)) { return true; } } return false; } /** * Checks whether one page range array contains another one. * * @param ourRanges The container page ranges. * @param otherRanges The contained page ranges. * @param pageCount The total number of pages. * @return Whether the container page ranges contains the contained ones. */ public static boolean contains(PageRange[] ourRanges, PageRange[] otherRanges, int pageCount) { if (ourRanges == null || otherRanges == null) { return false; } if (Arrays.equals(ourRanges, ALL_PAGES_RANGE)) { return true; } if (Arrays.equals(otherRanges, ALL_PAGES_RANGE)) { otherRanges[0] = new PageRange(0, pageCount - 1); } ourRanges = normalize(ourRanges); otherRanges = normalize(otherRanges); // Note that the code below relies on the ranges being normalized // which is they contain monotonically increasing non-intersecting // sub-ranges whose start is less that or equal to the end. int otherRangeIdx = 0; final int ourRangeCount = ourRanges.length; final int otherRangeCount = otherRanges.length; for (int ourRangeIdx = 0; ourRangeIdx < ourRangeCount; ourRangeIdx++) { PageRange ourRange = ourRanges[ourRangeIdx]; for (; otherRangeIdx < otherRangeCount; otherRangeIdx++) { PageRange otherRange = otherRanges[otherRangeIdx]; if (otherRange.getStart() > ourRange.getEnd()) { break; } if (otherRange.getStart() < ourRange.getStart() || otherRange.getEnd() > ourRange.getEnd()) { return false; } } } return (otherRangeIdx >= otherRangeCount); } /** * Offsets a the start and end of page ranges with the given value. * * @param pageRanges The page ranges to offset. * @param offset The offset value. */ public static void offset(PageRange[] pageRanges, int offset) { if (offset == 0) { return; } final int pageRangeCount = pageRanges.length; for (int i = 0; i < pageRangeCount; i++) { final int start = pageRanges[i].getStart() + offset; final int end = pageRanges[i].getEnd() + offset; pageRanges[i] = new PageRange(start, end); } } public static boolean isAllPages(PageRange[] pageRanges) { final int pageRangeCount = pageRanges.length; for (int i = 0; i < pageRangeCount; i++) { PageRange pageRange = pageRanges[i]; if (isAllPages(pageRange)) { return true; } } return false; } public static boolean isAllPages(PageRange pageRange) { return PageRange.ALL_PAGES.equals(pageRange); } public static boolean isAllPages(PageRange[] pageRanges, int pageCount) { final int pageRangeCount = pageRanges.length; for (int i = 0; i < pageRangeCount; i++) { PageRange pageRange = pageRanges[i]; if (isAllPages(pageRange, pageCount)) { return true; } } return false; } public static boolean isAllPages(PageRange pageRanges, int pageCount) { return pageRanges.getStart() == 0 && pageRanges.getEnd() == pageCount - 1; } /** * Normalizes a page range, which is the resulting page ranges are * non-overlapping with the start lesser than or equal to the end * and ordered in an ascending order. * * @param pageRanges The page ranges to normalize. * @return The normalized page ranges. */ public static PageRange[] normalize(PageRange[] pageRanges) { if (pageRanges == null) { return null; } final int oldRangeCount = pageRanges.length; if (oldRangeCount <= 1) { return pageRanges; } Arrays.sort(pageRanges, sComparator); int newRangeCount = 1; for (int i = 0; i < oldRangeCount - 1; i++) { PageRange currentRange = pageRanges[i]; PageRange nextRange = pageRanges[i + 1]; if (currentRange.getEnd() + 1 >= nextRange.getStart()) { pageRanges[i] = null; pageRanges[i + 1] = new PageRange(currentRange.getStart(), Math.max(currentRange.getEnd(), nextRange.getEnd())); } else { newRangeCount++; } } if (newRangeCount == oldRangeCount) { return pageRanges; } int normalRangeIndex = 0; PageRange[] normalRanges = new PageRange[newRangeCount]; for (int i = 0; i < oldRangeCount; i++) { PageRange normalRange = pageRanges[i]; if (normalRange != null) { normalRanges[normalRangeIndex] = normalRange; normalRangeIndex++; } } return normalRanges; } }