forked from chromium/chromium
-
Notifications
You must be signed in to change notification settings - Fork 0
/
print_backend.h
199 lines (154 loc) · 6.18 KB
/
print_backend.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef PRINTING_BACKEND_PRINT_BACKEND_H_
#define PRINTING_BACKEND_PRINT_BACKEND_H_
#include <map>
#include <string>
#include <vector>
#include "base/memory/ref_counted.h"
#include "build/build_config.h"
#include "printing/print_job_constants.h"
#include "printing/printing_export.h"
#include "ui/gfx/geometry/size.h"
#if defined(OS_CHROMEOS)
#include "base/values.h"
#endif // defined(OS_CHROMEOS)
namespace base {
class DictionaryValue;
}
// This is the interface for platform-specific code for a print backend
namespace printing {
struct PRINTING_EXPORT PrinterBasicInfo {
PrinterBasicInfo();
PrinterBasicInfo(const PrinterBasicInfo& other);
~PrinterBasicInfo();
// The name of the printer as understood by OS.
std::string printer_name;
// The name of the printer as shown in Print Preview.
// For Windows SetGetDisplayNameFunction() can be used to set the setter of
// this field.
std::string display_name;
std::string printer_description;
int printer_status = 0;
int is_default = false;
std::map<std::string, std::string> options;
};
using PrinterList = std::vector<PrinterBasicInfo>;
#if defined(OS_CHROMEOS)
struct PRINTING_EXPORT AdvancedCapabilityValue {
AdvancedCapabilityValue();
AdvancedCapabilityValue(const AdvancedCapabilityValue& other);
~AdvancedCapabilityValue();
// IPP identifier of the value.
std::string name;
// Localized name for the value.
std::string display_name;
};
struct PRINTING_EXPORT AdvancedCapability {
AdvancedCapability();
AdvancedCapability(const AdvancedCapability& other);
~AdvancedCapability();
// IPP identifier of the attribute.
std::string name;
// Localized name for the attribute.
std::string display_name;
// Attribute type.
base::Value::Type type;
// Default value.
std::string default_value;
// Values for enumerated attributes.
std::vector<AdvancedCapabilityValue> values;
};
using AdvancedCapabilities = std::vector<AdvancedCapability>;
#endif // defined(OS_CHROMEOS)
struct PRINTING_EXPORT PrinterSemanticCapsAndDefaults {
PrinterSemanticCapsAndDefaults();
PrinterSemanticCapsAndDefaults(const PrinterSemanticCapsAndDefaults& other);
~PrinterSemanticCapsAndDefaults();
bool collate_capable = false;
bool collate_default = false;
bool copies_capable = false;
std::vector<DuplexMode> duplex_modes;
DuplexMode duplex_default = UNKNOWN_DUPLEX_MODE;
bool color_changeable = false;
bool color_default = false;
ColorModel color_model = UNKNOWN_COLOR_MODEL;
ColorModel bw_model = UNKNOWN_COLOR_MODEL;
struct Paper {
std::string display_name;
std::string vendor_id;
gfx::Size size_um;
};
using Papers = std::vector<Paper>;
Papers papers;
Paper default_paper;
std::vector<gfx::Size> dpis;
gfx::Size default_dpi;
#if defined(OS_CHROMEOS)
bool pin_supported = false;
AdvancedCapabilities advanced_capabilities;
#endif // defined(OS_CHROMEOS)
};
struct PRINTING_EXPORT PrinterCapsAndDefaults {
PrinterCapsAndDefaults();
PrinterCapsAndDefaults(const PrinterCapsAndDefaults& other);
~PrinterCapsAndDefaults();
std::string printer_capabilities;
std::string caps_mime_type;
std::string printer_defaults;
std::string defaults_mime_type;
};
// PrintBackend class will provide interface for different print backends
// (Windows, CUPS) to implement. User will call CreateInstance() to
// obtain available print backend.
// Please note, that PrintBackend is not platform specific, but rather
// print system specific. For example, CUPS is available on both Linux and Mac,
// but not available on ChromeOS, etc. This design allows us to add more
// functionality on some platforms, while reusing core (CUPS) functions.
class PRINTING_EXPORT PrintBackend
: public base::RefCountedThreadSafe<PrintBackend> {
public:
// Enumerates the list of installed local and network printers.
virtual bool EnumeratePrinters(PrinterList* printer_list) = 0;
// Gets the default printer name. Empty string if no default printer.
virtual std::string GetDefaultPrinterName() = 0;
// Gets the basic printer info for a specific printer. Implementations must
// check |printer_name| validity in the same way as IsValidPrinter().
virtual bool GetPrinterBasicInfo(const std::string& printer_name,
PrinterBasicInfo* printer_info) = 0;
// Gets the semantic capabilities and defaults for a specific printer.
// This is usually a lighter implementation than GetPrinterCapsAndDefaults().
// Implementations must check |printer_name| validity in the same way as
// IsValidPrinter().
// NOTE: on some old platforms (WinXP without XPS pack)
// GetPrinterCapsAndDefaults() will fail, while this function will succeed.
virtual bool GetPrinterSemanticCapsAndDefaults(
const std::string& printer_name,
PrinterSemanticCapsAndDefaults* printer_info) = 0;
#if !defined(OS_CHROMEOS)
// Gets the capabilities and defaults for a specific printer.
virtual bool GetPrinterCapsAndDefaults(
const std::string& printer_name,
PrinterCapsAndDefaults* printer_info) = 0;
#endif // !defined(OS_CHROMEOS)
// Gets the information about driver for a specific printer.
virtual std::string GetPrinterDriverInfo(const std::string& printer_name) = 0;
// Returns true if printer_name points to a valid printer.
virtual bool IsValidPrinter(const std::string& printer_name) = 0;
// Allocates a print backend. If |print_backend_settings| is nullptr, default
// settings will be used.
static scoped_refptr<PrintBackend> CreateInstance(
const base::DictionaryValue* print_backend_settings);
// Test method to override the print backend for testing. Caller should
// retain ownership.
static void SetPrintBackendForTesting(PrintBackend* print_backend);
protected:
friend class base::RefCountedThreadSafe<PrintBackend>;
virtual ~PrintBackend();
// Provide the actual backend for CreateInstance().
static scoped_refptr<PrintBackend> CreateInstanceImpl(
const base::DictionaryValue* print_backend_settings);
};
} // namespace printing
#endif // PRINTING_BACKEND_PRINT_BACKEND_H_