| // Copyright 2014 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "components/printing/common/cloud_print_cdd_conversion.h" |
| |
| #include <stddef.h> |
| |
| #include <memory> |
| #include <utility> |
| |
| #include "base/check.h" |
| #include "base/memory/ptr_util.h" |
| #include "base/notreached.h" |
| #include "base/strings/string_number_conversions.h" |
| #include "base/values.h" |
| #include "build/build_config.h" |
| #include "components/cloud_devices/common/cloud_device_description.h" |
| #include "components/cloud_devices/common/printer_description.h" |
| #include "printing/backend/print_backend.h" |
| #include "printing/mojom/print.mojom.h" |
| |
| #if BUILDFLAG(IS_CHROMEOS) |
| #include "printing/printing_features.h" |
| #endif // BUILDFLAG(IS_CHROMEOS) |
| |
| namespace printer = cloud_devices::printer; |
| |
| namespace cloud_print { |
| |
| namespace { |
| |
| #if BUILDFLAG(IS_WIN) |
| constexpr char kIdPageOutputQuality[] = "page_output_quality"; |
| constexpr char kDisplayNamePageOutputQuality[] = "Page output quality"; |
| #endif // BUILDFLAG(IS_WIN) |
| |
| printer::DuplexType ToCloudDuplexType(printing::mojom::DuplexMode mode) { |
| switch (mode) { |
| case printing::mojom::DuplexMode::kSimplex: |
| return printer::DuplexType::NO_DUPLEX; |
| case printing::mojom::DuplexMode::kLongEdge: |
| return printer::DuplexType::LONG_EDGE; |
| case printing::mojom::DuplexMode::kShortEdge: |
| return printer::DuplexType::SHORT_EDGE; |
| default: |
| NOTREACHED(); |
| } |
| } |
| |
| #if BUILDFLAG(IS_CHROMEOS) |
| printer::TypedValueVendorCapability::ValueType ToCloudValueType( |
| printing::AdvancedCapability::Type type) { |
| switch (type) { |
| case printing::AdvancedCapability::Type::kBoolean: |
| return printer::TypedValueVendorCapability::ValueType::BOOLEAN; |
| case printing::AdvancedCapability::Type::kFloat: |
| return printer::TypedValueVendorCapability::ValueType::FLOAT; |
| case printing::AdvancedCapability::Type::kInteger: |
| return printer::TypedValueVendorCapability::ValueType::INTEGER; |
| case printing::AdvancedCapability::Type::kString: |
| return printer::TypedValueVendorCapability::ValueType::STRING; |
| default: |
| NOTREACHED(); |
| } |
| } |
| #endif // BUILDFLAG(IS_CHROMEOS) |
| |
| printer::Media ConvertPaperToMedia( |
| const printing::PrinterSemanticCapsAndDefaults::Paper& paper) { |
| if (paper.SupportsCustomSize()) { |
| return printer::MediaBuilder() |
| .WithCustomName(paper.display_name(), paper.vendor_id()) |
| .WithSizeAndDefaultPrintableArea(paper.size_um()) |
| .WithMaxHeight(paper.max_height_um()) |
| .Build(); |
| } |
| |
| gfx::Size paper_size = paper.size_um(); |
| gfx::Rect paper_printable_area = paper.printable_area_um(); |
| // When converting to Media, the size and printable area should have a larger |
| // height than width. |
| if (paper_size.width() > paper_size.height()) { |
| // When swapping the printable_area, we can't simply transpose the rect |
| // since the margins may not be the same on all sides. A visualization may |
| // help. Suppose we have a page with width of 127000 and height of 76200. |
| // Additionally, the left margin is 1000, right margin is 700, bottom margin |
| // is 500, and top margin is 200. |
| // |
| // +---------- 127000 ---------+ |
| // | 200 | |
| // 76200 +-----------+ | |
| // | | | | |
| // | 1000 | | 700 | |
| // | | | | |
| // | +-----------+ | |
| // | 500 | |
| // +---------------------------+ |
| // |
| // After swapping the page size and printable area (rotating 90 degrees |
| // clockwise), this should be the resulting sizes: |
| // |
| // +---- 76200 ---+ |
| // | | |
| // | 1000 | |
| // | 127000 |
| // | +-----+ | |
| // | | | | |
| // | | | | |
| // |500 | |200| |
| // | | | | |
| // | | | | |
| // | +-----+ | |
| // | | |
| // | 700 | |
| // +--------------+ |
| // |
| // Namely, the new x value for the printable area is: the old printable area |
| // y value. The new y value for the printable area is: (the old width) - |
| // (the old printable area width) - (the old printable areay x value). Note |
| // that if the top/bottom margins are equal and the left/right margins are |
| // equal, then a simple transpose does indeed work. |
| |
| // Rotate clockwise by 90 degrees. |
| int new_x = paper_printable_area.y(); |
| int new_y = paper_size.width() - paper_printable_area.width() - |
| paper_printable_area.x(); |
| paper_printable_area.SetRect(new_x, new_y, paper_printable_area.height(), |
| paper_printable_area.width()); |
| paper_size.SetSize(paper_size.height(), paper_size.width()); |
| } |
| return printer::MediaBuilder() |
| .WithSizeAndPrintableArea(paper_size, paper_printable_area) |
| .WithNameMaybeBasedOnSize(paper.display_name(), paper.vendor_id()) |
| .WithBorderlessVariant(paper.has_borderless_variant()) |
| .Build(); |
| } |
| |
| printer::MediaCapability GetMediaCapabilities( |
| const printing::PrinterSemanticCapsAndDefaults& semantic_info) { |
| printer::MediaCapability media_capabilities; |
| bool is_default_set = false; |
| |
| const printing::PrinterSemanticCapsAndDefaults::Paper& default_paper = |
| semantic_info.default_paper; |
| printer::Media default_media = |
| printer::MediaBuilder() |
| .WithSizeAndPrintableArea(default_paper.size_um(), |
| default_paper.printable_area_um()) |
| .WithNameMaybeBasedOnSize(default_paper.display_name(), |
| default_paper.vendor_id()) |
| .WithBorderlessVariant(default_paper.has_borderless_variant()) |
| .Build(); |
| |
| for (const auto& paper : semantic_info.papers) { |
| printer::Media new_media = ConvertPaperToMedia(paper); |
| if (!new_media.IsValid()) |
| continue; |
| |
| if (media_capabilities.Contains(new_media)) |
| continue; |
| |
| if (!default_media.IsValid()) |
| default_media = new_media; |
| media_capabilities.AddDefaultOption(new_media, new_media == default_media); |
| is_default_set = is_default_set || (new_media == default_media); |
| } |
| if (!is_default_set && default_media.IsValid()) |
| media_capabilities.AddDefaultOption(default_media, true); |
| |
| // Allow user defined paper sizes to be repeats of existing paper sizes. |
| // Do not allow user defined paper sizes to be the default, for now. |
| // TODO(thestig): Figure out the default paper policy here. |
| for (const auto& paper : semantic_info.user_defined_papers) { |
| printer::Media new_media = ConvertPaperToMedia(paper); |
| if (!new_media.IsValid()) |
| continue; |
| |
| media_capabilities.AddOption(new_media); |
| } |
| return media_capabilities; |
| } |
| |
| printer::MediaTypeCapability GetMediaTypeCapabilities( |
| const printing::PrinterSemanticCapsAndDefaults& semantic_info) { |
| printer::MediaTypeCapability media_type_capabilities; |
| |
| for (const auto& media_type : semantic_info.media_types) { |
| printer::MediaType new_media_type(media_type.vendor_id, |
| media_type.display_name); |
| if (!new_media_type.IsValid()) { |
| continue; |
| } |
| |
| if (media_type_capabilities.Contains(new_media_type)) { |
| continue; |
| } |
| |
| media_type_capabilities.AddDefaultOption( |
| new_media_type, |
| media_type.vendor_id == semantic_info.default_media_type.vendor_id); |
| } |
| |
| return media_type_capabilities; |
| } |
| |
| printer::DpiCapability GetDpiCapabilities( |
| const printing::PrinterSemanticCapsAndDefaults& semantic_info) { |
| printer::DpiCapability dpi_capabilities; |
| bool is_default_set = false; |
| |
| printer::Dpi default_dpi(semantic_info.default_dpi.width(), |
| semantic_info.default_dpi.height()); |
| for (const auto& dpi : semantic_info.dpis) { |
| printer::Dpi new_dpi(dpi.width(), dpi.height()); |
| if (!new_dpi.IsValid()) |
| continue; |
| |
| if (dpi_capabilities.Contains(new_dpi)) |
| continue; |
| |
| if (!default_dpi.IsValid()) |
| default_dpi = new_dpi; |
| dpi_capabilities.AddDefaultOption(new_dpi, new_dpi == default_dpi); |
| is_default_set = is_default_set || (new_dpi == default_dpi); |
| } |
| if (!is_default_set && default_dpi.IsValid()) |
| dpi_capabilities.AddDefaultOption(default_dpi, true); |
| |
| return dpi_capabilities; |
| } |
| |
| #if BUILDFLAG(IS_CHROMEOS) |
| printer::VendorCapabilities GetVendorCapabilities( |
| const printing::PrinterSemanticCapsAndDefaults& semantic_info) { |
| printer::VendorCapabilities vendor_capabilities; |
| for (const auto& capability : semantic_info.advanced_capabilities) { |
| std::string capability_name = capability.display_name.empty() |
| ? capability.name |
| : capability.display_name; |
| if (capability.values.empty()) { |
| vendor_capabilities.AddOption( |
| printer::VendorCapability(capability.name, capability_name, |
| printer::TypedValueVendorCapability( |
| ToCloudValueType(capability.type)))); |
| continue; |
| } |
| |
| printer::SelectVendorCapability select_capability; |
| for (const auto& value : capability.values) { |
| std::string localized_value = |
| value.display_name.empty() ? value.name : value.display_name; |
| select_capability.AddDefaultOption( |
| printer::SelectVendorCapabilityOption(value.name, localized_value), |
| value.name == capability.default_value); |
| } |
| vendor_capabilities.AddOption(printer::VendorCapability( |
| capability.name, capability_name, std::move(select_capability))); |
| } |
| |
| return vendor_capabilities; |
| } |
| |
| printer::FitToPageCapability GetFitToPageCapabilities( |
| const printing::PrinterSemanticCapsAndDefaults& semantic_info) { |
| auto ToFitToPageType = [](const printing::mojom::PrintScalingType& type) { |
| switch (type) { |
| case printing::mojom::PrintScalingType::kAuto: |
| return printer::FitToPageType::AUTO; |
| case printing::mojom::PrintScalingType::kAutoFit: |
| return printer::FitToPageType::AUTO_FIT; |
| case printing::mojom::PrintScalingType::kFit: |
| return printer::FitToPageType::FIT; |
| case printing::mojom::PrintScalingType::kFill: |
| return printer::FitToPageType::FILL; |
| case printing::mojom::PrintScalingType::kNone: |
| return printer::FitToPageType::NONE; |
| case printing::mojom::PrintScalingType::kUnknownPrintScalingType: |
| NOTREACHED(); |
| } |
| }; |
| |
| printer::FitToPageCapability fit_to_page; |
| for (const auto& value : semantic_info.print_scaling_types) { |
| if (value == printing::mojom::PrintScalingType::kUnknownPrintScalingType) { |
| continue; |
| } |
| fit_to_page.AddOption(ToFitToPageType(value)); |
| } |
| |
| if (semantic_info.print_scaling_type_default != |
| printing::mojom::PrintScalingType::kUnknownPrintScalingType) { |
| auto default_type = |
| ToFitToPageType(semantic_info.print_scaling_type_default); |
| // If default value is not among supported options, return empty options. |
| if (!fit_to_page.Contains(default_type)) { |
| return {}; |
| } |
| fit_to_page.AddDefaultOption(default_type, true); |
| } else if (!fit_to_page.empty()) { |
| fit_to_page.AddDefaultOption(fit_to_page[0], true); |
| } |
| |
| return fit_to_page; |
| } |
| |
| // Helper that verifies if the margins are unique and stores them to the |
| // supplied vector. |
| void StoreMarginsUnique(const printing::PaperMargins& margins_um, |
| std::vector<printer::Margins>& margins_storage) { |
| printer::Margins printer_margins( |
| margins_um.top_margin_um, margins_um.right_margin_um, |
| margins_um.bottom_margin_um, margins_um.left_margin_um); |
| if (!base::Contains(margins_storage, printer_margins)) { |
| margins_storage.emplace_back(std::move(printer_margins)); |
| } |
| } |
| |
| printer::MarginsCapability GetMarginsCapabilities( |
| const printing::PrinterSemanticCapsAndDefaults& semantic_info) { |
| std::optional<printer::Margins> default_margins = std::nullopt; |
| if (semantic_info.default_paper.supported_margins_um().has_value()) { |
| const auto& margins = |
| semantic_info.default_paper.supported_margins_um().value(); |
| default_margins = |
| printer::Margins(margins.top_margin_um, margins.right_margin_um, |
| margins.bottom_margin_um, margins.left_margin_um); |
| } |
| |
| // Populate the `all_papers` with all the available papers. |
| printing::PrinterSemanticCapsAndDefaults::Papers all_papers; |
| all_papers.reserve(semantic_info.papers.size() + |
| semantic_info.user_defined_papers.size()); |
| all_papers.insert(all_papers.end(), semantic_info.papers.begin(), |
| semantic_info.papers.end()); |
| all_papers.insert(all_papers.end(), semantic_info.user_defined_papers.begin(), |
| semantic_info.user_defined_papers.end()); |
| |
| // Stores all the available sets of margins from papers. This temporary |
| // container is used to avoid duplicates, which is then populated to the |
| // `margins_capabilites`. |
| std::vector<printer::Margins> available_margins_um; |
| for (const auto& paper : all_papers) { |
| if (!paper.supported_margins_um().has_value()) { |
| continue; |
| } |
| StoreMarginsUnique(paper.supported_margins_um().value(), |
| available_margins_um); |
| if (paper.has_borderless_variant()) { |
| StoreMarginsUnique(printing::PaperMargins(), available_margins_um); |
| } |
| } |
| |
| // Populate the `margins_capabilities` with the unique margins. |
| printer::MarginsCapability margins_capabilities; |
| bool default_margins_set = false; |
| for (const auto& margins : available_margins_um) { |
| if (!default_margins.has_value()) { |
| default_margins = margins; |
| } |
| margins_capabilities.AddDefaultOption(margins, default_margins == margins); |
| default_margins_set = default_margins_set || (default_margins == margins); |
| } |
| if (!default_margins_set && default_margins.has_value()) { |
| margins_capabilities.AddDefaultOption(default_margins.value(), true); |
| } |
| return margins_capabilities; |
| } |
| |
| #endif // BUILDFLAG(IS_CHROMEOS) |
| |
| #if BUILDFLAG(IS_WIN) |
| printer::SelectVendorCapability GetPageOutputQualityCapabilities( |
| const printing::PrinterSemanticCapsAndDefaults& semantic_info) { |
| printer::SelectVendorCapability page_output_quality_capabilities; |
| const std::optional<printing::PageOutputQuality>& page_output_quality = |
| semantic_info.page_output_quality; |
| for (const auto& attribute : page_output_quality->qualities) { |
| page_output_quality_capabilities.AddDefaultOption( |
| printer::SelectVendorCapabilityOption(attribute.name, |
| attribute.display_name), |
| attribute.name == page_output_quality->default_quality); |
| } |
| return page_output_quality_capabilities; |
| } |
| #endif // BUILDFLAG(IS_WIN) |
| |
| } // namespace |
| |
| base::Value PrinterSemanticCapsAndDefaultsToCdd( |
| const printing::PrinterSemanticCapsAndDefaults& semantic_info) { |
| cloud_devices::CloudDeviceDescription description; |
| |
| printer::ContentTypesCapability content_types; |
| content_types.AddOption("application/pdf"); |
| content_types.SaveTo(&description); |
| |
| if (semantic_info.collate_capable) { |
| printer::CollateCapability collate; |
| collate.set_default_value(semantic_info.collate_default); |
| collate.SaveTo(&description); |
| } |
| |
| printer::Copies copies_val; |
| copies_val.max_value = semantic_info.copies_max; |
| |
| printer::CopiesCapability copies_cap; |
| copies_cap.set_value(copies_val); |
| copies_cap.SaveTo(&description); |
| |
| if (semantic_info.duplex_modes.size() > 1) { |
| printer::DuplexCapability duplex; |
| for (printing::mojom::DuplexMode mode : semantic_info.duplex_modes) { |
| duplex.AddDefaultOption(ToCloudDuplexType(mode), |
| semantic_info.duplex_default == mode); |
| } |
| duplex.SaveTo(&description); |
| } |
| |
| printer::ColorCapability color; |
| if (semantic_info.color_default || semantic_info.color_changeable) { |
| printer::Color standard_color(printer::ColorType::STANDARD_COLOR); |
| standard_color.vendor_id = |
| base::NumberToString(static_cast<int>(semantic_info.color_model)); |
| color.AddDefaultOption(standard_color, semantic_info.color_default); |
| } |
| if (!semantic_info.color_default || semantic_info.color_changeable) { |
| printer::Color standard_monochrome(printer::ColorType::STANDARD_MONOCHROME); |
| standard_monochrome.vendor_id = |
| base::NumberToString(static_cast<int>(semantic_info.bw_model)); |
| color.AddDefaultOption(standard_monochrome, !semantic_info.color_default); |
| } |
| color.SaveTo(&description); |
| |
| if (!semantic_info.papers.empty()) { |
| printer::MediaCapability media = GetMediaCapabilities(semantic_info); |
| DCHECK(media.IsValid()); |
| media.SaveTo(&description); |
| } |
| |
| // Only create this capability if more than one media type is supported. |
| if (semantic_info.media_types.size() > 1) { |
| printer::MediaTypeCapability media_type = |
| GetMediaTypeCapabilities(semantic_info); |
| DCHECK(media_type.IsValid()); |
| media_type.SaveTo(&description); |
| } |
| |
| if (!semantic_info.dpis.empty()) { |
| printer::DpiCapability dpi = GetDpiCapabilities(semantic_info); |
| DCHECK(dpi.IsValid()); |
| dpi.SaveTo(&description); |
| } |
| |
| printer::OrientationCapability orientation; |
| orientation.AddDefaultOption(printer::OrientationType::PORTRAIT, true); |
| orientation.AddOption(printer::OrientationType::LANDSCAPE); |
| orientation.AddOption(printer::OrientationType::AUTO_ORIENTATION); |
| orientation.SaveTo(&description); |
| |
| #if BUILDFLAG(IS_CHROMEOS) |
| printer::PinCapability pin; |
| pin.set_value(semantic_info.pin_supported); |
| pin.SaveTo(&description); |
| |
| if (!semantic_info.advanced_capabilities.empty()) { |
| printer::VendorCapabilities vendor_capabilities = |
| GetVendorCapabilities(semantic_info); |
| vendor_capabilities.SaveTo(&description); |
| } |
| |
| if (base::FeatureList::IsEnabled( |
| printing::features::kApiPrintingMarginsAndScale)) { |
| if (!semantic_info.print_scaling_types.empty()) { |
| printer::FitToPageCapability fit_to_page = |
| GetFitToPageCapabilities(semantic_info); |
| if (fit_to_page.IsValid()) { |
| fit_to_page.SaveTo(&description); |
| } |
| } |
| |
| if (!semantic_info.papers.empty()) { |
| printer::MarginsCapability margins = |
| GetMarginsCapabilities(semantic_info); |
| if (margins.IsValid()) { |
| margins.SaveTo(&description); |
| } |
| } |
| } |
| #endif // BUILDFLAG(IS_CHROMEOS) |
| |
| #if BUILDFLAG(IS_WIN) |
| if (semantic_info.page_output_quality) { |
| printer::VendorCapabilities vendor_capabilities; |
| vendor_capabilities.AddOption(printer::VendorCapability( |
| kIdPageOutputQuality, kDisplayNamePageOutputQuality, |
| GetPageOutputQualityCapabilities(semantic_info))); |
| vendor_capabilities.SaveTo(&description); |
| } |
| #endif // BUILDFLAG(IS_WIN) |
| |
| return std::move(description).ToValue(); |
| } |
| |
| } // namespace cloud_print |
