1#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
6#![allow(
7 clippy::approx_constant,
8 clippy::type_complexity,
9 clippy::unreadable_literal,
10 clippy::upper_case_acronyms
11)]
12#![cfg_attr(docsrs, feature(doc_cfg))]
13
14use gio_sys as gio;
15use glib_sys as glib;
16use gobject_sys as gobject;
17
18#[allow(unused_imports)]
19use libc::{
20 c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
21 intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE,
22};
23#[cfg(unix)]
24#[allow(unused_imports)]
25use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
26
27#[allow(unused_imports)]
28use glib::{gboolean, gconstpointer, gpointer, GType};
29
30pub type ArvPixelFormat = u32;
32
33pub type ArvAccessCheckPolicy = c_int;
35pub const ARV_ACCESS_CHECK_POLICY_DISABLE: ArvAccessCheckPolicy = 0;
36pub const ARV_ACCESS_CHECK_POLICY_ENABLE: ArvAccessCheckPolicy = 1;
37pub const ARV_ACCESS_CHECK_POLICY_DEFAULT: ArvAccessCheckPolicy = 0;
38
39pub type ArvAcquisitionMode = c_int;
40pub const ARV_ACQUISITION_MODE_CONTINUOUS: ArvAcquisitionMode = 0;
41pub const ARV_ACQUISITION_MODE_SINGLE_FRAME: ArvAcquisitionMode = 1;
42pub const ARV_ACQUISITION_MODE_MULTI_FRAME: ArvAcquisitionMode = 2;
43
44pub type ArvAuto = c_int;
45pub const ARV_AUTO_OFF: ArvAuto = 0;
46pub const ARV_AUTO_ONCE: ArvAuto = 1;
47pub const ARV_AUTO_CONTINUOUS: ArvAuto = 2;
48
49pub type ArvBufferPartDataType = c_int;
50pub const ARV_BUFFER_PART_DATA_TYPE_UNKNOWN: ArvBufferPartDataType = -1;
51pub const ARV_BUFFER_PART_DATA_TYPE_2D_IMAGE: ArvBufferPartDataType = 1;
52pub const ARV_BUFFER_PART_DATA_TYPE_2D_PLANE_BIPLANAR: ArvBufferPartDataType = 2;
53pub const ARV_BUFFER_PART_DATA_TYPE_2D_PLANE_TRIPLANAR: ArvBufferPartDataType = 3;
54pub const ARV_BUFFER_PART_DATA_TYPE_2D_PLANE_QUADPLANAR: ArvBufferPartDataType = 4;
55pub const ARV_BUFFER_PART_DATA_TYPE_3D_IMAGE: ArvBufferPartDataType = 5;
56pub const ARV_BUFFER_PART_DATA_TYPE_3D_PLANE_BIPLANAR: ArvBufferPartDataType = 6;
57pub const ARV_BUFFER_PART_DATA_TYPE_3D_PLANE_TRIPLANAR: ArvBufferPartDataType = 7;
58pub const ARV_BUFFER_PART_DATA_TYPE_3D_PLANE_QUADPLANAR: ArvBufferPartDataType = 8;
59pub const ARV_BUFFER_PART_DATA_TYPE_CONFIDENCE_MAP: ArvBufferPartDataType = 9;
60pub const ARV_BUFFER_PART_DATA_TYPE_CHUNK_DATA: ArvBufferPartDataType = 10;
61pub const ARV_BUFFER_PART_DATA_TYPE_JPEG: ArvBufferPartDataType = 11;
62pub const ARV_BUFFER_PART_DATA_TYPE_JPEG2000: ArvBufferPartDataType = 12;
63pub const ARV_BUFFER_PART_DATA_TYPE_DEVICE_SPECIFIC: ArvBufferPartDataType = 32768;
64
65pub type ArvBufferPayloadType = c_int;
66pub const ARV_BUFFER_PAYLOAD_TYPE_UNKNOWN: ArvBufferPayloadType = -1;
67pub const ARV_BUFFER_PAYLOAD_TYPE_NO_DATA: ArvBufferPayloadType = 0;
68pub const ARV_BUFFER_PAYLOAD_TYPE_IMAGE: ArvBufferPayloadType = 1;
69pub const ARV_BUFFER_PAYLOAD_TYPE_RAWDATA: ArvBufferPayloadType = 2;
70pub const ARV_BUFFER_PAYLOAD_TYPE_FILE: ArvBufferPayloadType = 3;
71pub const ARV_BUFFER_PAYLOAD_TYPE_CHUNK_DATA: ArvBufferPayloadType = 4;
72pub const ARV_BUFFER_PAYLOAD_TYPE_EXTENDED_CHUNK_DATA: ArvBufferPayloadType = 5;
73pub const ARV_BUFFER_PAYLOAD_TYPE_JPEG: ArvBufferPayloadType = 6;
74pub const ARV_BUFFER_PAYLOAD_TYPE_JPEG2000: ArvBufferPayloadType = 7;
75pub const ARV_BUFFER_PAYLOAD_TYPE_H264: ArvBufferPayloadType = 8;
76pub const ARV_BUFFER_PAYLOAD_TYPE_MULTIZONE_IMAGE: ArvBufferPayloadType = 9;
77pub const ARV_BUFFER_PAYLOAD_TYPE_MULTIPART: ArvBufferPayloadType = 10;
78pub const ARV_BUFFER_PAYLOAD_TYPE_GENDC_CONTAINER: ArvBufferPayloadType = 11;
79pub const ARV_BUFFER_PAYLOAD_TYPE_GENDC_COMPONENT_DATA: ArvBufferPayloadType = 12;
80
81pub type ArvBufferStatus = c_int;
82pub const ARV_BUFFER_STATUS_UNKNOWN: ArvBufferStatus = -1;
83pub const ARV_BUFFER_STATUS_SUCCESS: ArvBufferStatus = 0;
84pub const ARV_BUFFER_STATUS_CLEARED: ArvBufferStatus = 1;
85pub const ARV_BUFFER_STATUS_TIMEOUT: ArvBufferStatus = 2;
86pub const ARV_BUFFER_STATUS_MISSING_PACKETS: ArvBufferStatus = 3;
87pub const ARV_BUFFER_STATUS_WRONG_PACKET_ID: ArvBufferStatus = 4;
88pub const ARV_BUFFER_STATUS_SIZE_MISMATCH: ArvBufferStatus = 5;
89pub const ARV_BUFFER_STATUS_FILLING: ArvBufferStatus = 6;
90pub const ARV_BUFFER_STATUS_ABORTED: ArvBufferStatus = 7;
91pub const ARV_BUFFER_STATUS_PAYLOAD_NOT_SUPPORTED: ArvBufferStatus = 8;
92
93pub type ArvChunkParserError = c_int;
94pub const ARV_CHUNK_PARSER_ERROR_INVALID_FEATURE_TYPE: ArvChunkParserError = 0;
95pub const ARV_CHUNK_PARSER_ERROR_BUFFER_NOT_FOUND: ArvChunkParserError = 1;
96pub const ARV_CHUNK_PARSER_ERROR_CHUNK_NOT_FOUND: ArvChunkParserError = 2;
97
98pub type ArvComponentSelectionFlags = c_int;
99pub const ARV_COMPONENT_SELECTION_FLAGS_NONE: ArvComponentSelectionFlags = 0;
100pub const ARV_COMPONENT_SELECTION_FLAGS_ENABLE: ArvComponentSelectionFlags = 1;
101pub const ARV_COMPONENT_SELECTION_FLAGS_DISABLE: ArvComponentSelectionFlags = 2;
102pub const ARV_COMPONENT_SELECTION_FLAGS_EXCLUSIVE_ENABLE: ArvComponentSelectionFlags = 3;
103pub const ARV_COMPONENT_SELECTION_FLAGS_ENABLE_ALL: ArvComponentSelectionFlags = 4;
104
105pub type ArvDeviceError = c_int;
106pub const ARV_DEVICE_ERROR_WRONG_FEATURE: ArvDeviceError = 0;
107pub const ARV_DEVICE_ERROR_FEATURE_NOT_FOUND: ArvDeviceError = 1;
108pub const ARV_DEVICE_ERROR_NOT_CONNECTED: ArvDeviceError = 2;
109pub const ARV_DEVICE_ERROR_PROTOCOL_ERROR: ArvDeviceError = 3;
110pub const ARV_DEVICE_ERROR_TRANSFER_ERROR: ArvDeviceError = 4;
111pub const ARV_DEVICE_ERROR_TIMEOUT: ArvDeviceError = 5;
112pub const ARV_DEVICE_ERROR_NOT_FOUND: ArvDeviceError = 6;
113pub const ARV_DEVICE_ERROR_INVALID_PARAMETER: ArvDeviceError = 7;
114pub const ARV_DEVICE_ERROR_GENICAM_NOT_FOUND: ArvDeviceError = 8;
115pub const ARV_DEVICE_ERROR_NO_STREAM_CHANNEL: ArvDeviceError = 9;
116pub const ARV_DEVICE_ERROR_NOT_CONTROLLER: ArvDeviceError = 10;
117pub const ARV_DEVICE_ERROR_UNKNOWN: ArvDeviceError = 11;
118pub const ARV_DEVICE_ERROR_PROTOCOL_ERROR_NOT_IMPLEMENTED: ArvDeviceError = 12;
119pub const ARV_DEVICE_ERROR_PROTOCOL_ERROR_INVALID_PARAMETER: ArvDeviceError = 13;
120pub const ARV_DEVICE_ERROR_PROTOCOL_ERROR_INVALID_ADDRESS: ArvDeviceError = 14;
121pub const ARV_DEVICE_ERROR_PROTOCOL_ERROR_WRITE_PROTECT: ArvDeviceError = 15;
122pub const ARV_DEVICE_ERROR_PROTOCOL_ERROR_BAD_ALIGNMENT: ArvDeviceError = 16;
123pub const ARV_DEVICE_ERROR_PROTOCOL_ERROR_ACCESS_DENIED: ArvDeviceError = 17;
124pub const ARV_DEVICE_ERROR_PROTOCOL_ERROR_BUSY: ArvDeviceError = 18;
125
126pub type ArvDomNodeType = c_int;
127pub const ARV_DOM_NODE_TYPE_ELEMENT_NODE: ArvDomNodeType = 1;
128pub const ARV_DOM_NODE_TYPE_ATTRIBUTE_NODE: ArvDomNodeType = 2;
129pub const ARV_DOM_NODE_TYPE_TEXT_NODE: ArvDomNodeType = 3;
130pub const ARV_DOM_NODE_TYPE_CDATA_SECTION_NODE: ArvDomNodeType = 4;
131pub const ARV_DOM_NODE_TYPE_ENTITY_REFERENCE_NODE: ArvDomNodeType = 5;
132pub const ARV_DOM_NODE_TYPE_ENTITY_NODE: ArvDomNodeType = 6;
133pub const ARV_DOM_NODE_TYPE_PROCESSING_INSTRUCTION_NODE: ArvDomNodeType = 7;
134pub const ARV_DOM_NODE_TYPE_COMMENT_NODE: ArvDomNodeType = 8;
135pub const ARV_DOM_NODE_TYPE_DOCUMENT_NODE: ArvDomNodeType = 9;
136pub const ARV_DOM_NODE_TYPE_DOCUMENT_TYPE_NODE: ArvDomNodeType = 10;
137pub const ARV_DOM_NODE_TYPE_DOCUMENT_FRAGMENT_NODE: ArvDomNodeType = 11;
138pub const ARV_DOM_NODE_TYPE_NOTATION_NODE: ArvDomNodeType = 12;
139
140pub type ArvExposureMode = c_int;
141pub const ARV_EXPOSURE_MODE_OFF: ArvExposureMode = 0;
142pub const ARV_EXPOSURE_MODE_TIMED: ArvExposureMode = 1;
143pub const ARV_EXPOSURE_MODE_TRIGGER_WIDTH: ArvExposureMode = 2;
144pub const ARV_EXPOSURE_MODE_TRIGGER_CONTROLLED: ArvExposureMode = 3;
145
146pub type ArvGcAccessMode = c_int;
147pub const ARV_GC_ACCESS_MODE_UNDEFINED: ArvGcAccessMode = -1;
148pub const ARV_GC_ACCESS_MODE_RO: ArvGcAccessMode = 0;
149pub const ARV_GC_ACCESS_MODE_WO: ArvGcAccessMode = 1;
150pub const ARV_GC_ACCESS_MODE_RW: ArvGcAccessMode = 2;
151
152pub type ArvGcCachable = c_int;
153pub const ARV_GC_CACHABLE_UNDEFINED: ArvGcCachable = -1;
154pub const ARV_GC_CACHABLE_NO_CACHE: ArvGcCachable = 0;
155pub const ARV_GC_CACHABLE_WRITE_THROUGH: ArvGcCachable = 1;
156pub const ARV_GC_CACHABLE_WRITE_AROUND: ArvGcCachable = 2;
157
158pub type ArvGcDisplayNotation = c_int;
159pub const ARV_GC_DISPLAY_NOTATION_UNDEFINED: ArvGcDisplayNotation = -1;
160pub const ARV_GC_DISPLAY_NOTATION_AUTOMATIC: ArvGcDisplayNotation = 0;
161pub const ARV_GC_DISPLAY_NOTATION_FIXED: ArvGcDisplayNotation = 1;
162pub const ARV_GC_DISPLAY_NOTATION_SCIENTIFIC: ArvGcDisplayNotation = 2;
163
164pub type ArvGcError = c_int;
165pub const ARV_GC_ERROR_PROPERTY_NOT_DEFINED: ArvGcError = 0;
166pub const ARV_GC_ERROR_PVALUE_NOT_DEFINED: ArvGcError = 1;
167pub const ARV_GC_ERROR_INVALID_PVALUE: ArvGcError = 2;
168pub const ARV_GC_ERROR_EMPTY_ENUMERATION: ArvGcError = 3;
169pub const ARV_GC_ERROR_OUT_OF_RANGE: ArvGcError = 4;
170pub const ARV_GC_ERROR_NO_DEVICE_SET: ArvGcError = 5;
171pub const ARV_GC_ERROR_NO_EVENT_IMPLEMENTATION: ArvGcError = 6;
172pub const ARV_GC_ERROR_NODE_NOT_FOUND: ArvGcError = 7;
173pub const ARV_GC_ERROR_ENUM_ENTRY_NOT_FOUND: ArvGcError = 8;
174pub const ARV_GC_ERROR_INVALID_LENGTH: ArvGcError = 9;
175pub const ARV_GC_ERROR_READ_ONLY: ArvGcError = 10;
176pub const ARV_GC_ERROR_SET_FROM_STRING_UNDEFINED: ArvGcError = 11;
177pub const ARV_GC_ERROR_GET_AS_STRING_UNDEFINED: ArvGcError = 12;
178pub const ARV_GC_ERROR_INVALID_BIT_RANGE: ArvGcError = 13;
179pub const ARV_GC_ERROR_INVALID_SYNTAX: ArvGcError = 14;
180
181pub type ArvGcIsLinear = c_int;
182pub const ARV_GC_IS_LINEAR_UNDEFINED: ArvGcIsLinear = -1;
183pub const ARV_GC_IS_LINEAR_NO: ArvGcIsLinear = 0;
184pub const ARV_GC_IS_LINEAR_YES: ArvGcIsLinear = 1;
185
186pub type ArvGcNameSpace = c_int;
187pub const ARV_GC_NAME_SPACE_UNDEFINED: ArvGcNameSpace = -1;
188pub const ARV_GC_NAME_SPACE_STANDARD: ArvGcNameSpace = 0;
189pub const ARV_GC_NAME_SPACE_CUSTOM: ArvGcNameSpace = 1;
190
191pub type ArvGcPropertyNodeType = c_int;
192pub const ARV_GC_PROPERTY_NODE_TYPE_UNKNOWN: ArvGcPropertyNodeType = 0;
193pub const ARV_GC_PROPERTY_NODE_TYPE_VALUE: ArvGcPropertyNodeType = 1;
194pub const ARV_GC_PROPERTY_NODE_TYPE_ADDRESS: ArvGcPropertyNodeType = 2;
195pub const ARV_GC_PROPERTY_NODE_TYPE_DESCRIPTION: ArvGcPropertyNodeType = 3;
196pub const ARV_GC_PROPERTY_NODE_TYPE_VISIBILITY: ArvGcPropertyNodeType = 4;
197pub const ARV_GC_PROPERTY_NODE_TYPE_TOOLTIP: ArvGcPropertyNodeType = 5;
198pub const ARV_GC_PROPERTY_NODE_TYPE_DISPLAY_NAME: ArvGcPropertyNodeType = 6;
199pub const ARV_GC_PROPERTY_NODE_TYPE_MINIMUM: ArvGcPropertyNodeType = 7;
200pub const ARV_GC_PROPERTY_NODE_TYPE_MAXIMUM: ArvGcPropertyNodeType = 8;
201pub const ARV_GC_PROPERTY_NODE_TYPE_SLOPE: ArvGcPropertyNodeType = 9;
202pub const ARV_GC_PROPERTY_NODE_TYPE_INCREMENT: ArvGcPropertyNodeType = 10;
203pub const ARV_GC_PROPERTY_NODE_TYPE_IS_LINEAR: ArvGcPropertyNodeType = 11;
204pub const ARV_GC_PROPERTY_NODE_TYPE_REPRESENTATION: ArvGcPropertyNodeType = 12;
205pub const ARV_GC_PROPERTY_NODE_TYPE_DISPLAY_NOTATION: ArvGcPropertyNodeType = 13;
206pub const ARV_GC_PROPERTY_NODE_TYPE_DISPLAY_PRECISION: ArvGcPropertyNodeType = 14;
207pub const ARV_GC_PROPERTY_NODE_TYPE_UNIT: ArvGcPropertyNodeType = 15;
208pub const ARV_GC_PROPERTY_NODE_TYPE_ON_VALUE: ArvGcPropertyNodeType = 16;
209pub const ARV_GC_PROPERTY_NODE_TYPE_OFF_VALUE: ArvGcPropertyNodeType = 17;
210pub const ARV_GC_PROPERTY_NODE_TYPE_LENGTH: ArvGcPropertyNodeType = 18;
211pub const ARV_GC_PROPERTY_NODE_TYPE_FORMULA: ArvGcPropertyNodeType = 19;
212pub const ARV_GC_PROPERTY_NODE_TYPE_FORMULA_TO: ArvGcPropertyNodeType = 20;
213pub const ARV_GC_PROPERTY_NODE_TYPE_FORMULA_FROM: ArvGcPropertyNodeType = 21;
214pub const ARV_GC_PROPERTY_NODE_TYPE_EXPRESSION: ArvGcPropertyNodeType = 22;
215pub const ARV_GC_PROPERTY_NODE_TYPE_CONSTANT: ArvGcPropertyNodeType = 23;
216pub const ARV_GC_PROPERTY_NODE_TYPE_ACCESS_MODE: ArvGcPropertyNodeType = 24;
217pub const ARV_GC_PROPERTY_NODE_TYPE_IMPOSED_ACCESS_MODE: ArvGcPropertyNodeType = 25;
218pub const ARV_GC_PROPERTY_NODE_TYPE_CACHABLE: ArvGcPropertyNodeType = 26;
219pub const ARV_GC_PROPERTY_NODE_TYPE_POLLING_TIME: ArvGcPropertyNodeType = 27;
220pub const ARV_GC_PROPERTY_NODE_TYPE_ENDIANNESS: ArvGcPropertyNodeType = 28;
221pub const ARV_GC_PROPERTY_NODE_TYPE_SIGN: ArvGcPropertyNodeType = 29;
222pub const ARV_GC_PROPERTY_NODE_TYPE_LSB: ArvGcPropertyNodeType = 30;
223pub const ARV_GC_PROPERTY_NODE_TYPE_MSB: ArvGcPropertyNodeType = 31;
224pub const ARV_GC_PROPERTY_NODE_TYPE_BIT: ArvGcPropertyNodeType = 32;
225pub const ARV_GC_PROPERTY_NODE_TYPE_COMMAND_VALUE: ArvGcPropertyNodeType = 33;
226pub const ARV_GC_PROPERTY_NODE_TYPE_CHUNK_ID: ArvGcPropertyNodeType = 34;
227pub const ARV_GC_PROPERTY_NODE_TYPE_EVENT_ID: ArvGcPropertyNodeType = 35;
228pub const ARV_GC_PROPERTY_NODE_TYPE_VALUE_INDEXED: ArvGcPropertyNodeType = 36;
229pub const ARV_GC_PROPERTY_NODE_TYPE_VALUE_DEFAULT: ArvGcPropertyNodeType = 37;
230pub const ARV_GC_PROPERTY_NODE_TYPE_STREAMABLE: ArvGcPropertyNodeType = 38;
231pub const ARV_GC_PROPERTY_NODE_TYPE_IS_DEPRECATED: ArvGcPropertyNodeType = 39;
232pub const ARV_GC_PROPERTY_NODE_TYPE_P_UNKNONW: ArvGcPropertyNodeType = 1000;
233pub const ARV_GC_PROPERTY_NODE_TYPE_P_FEATURE: ArvGcPropertyNodeType = 1001;
234pub const ARV_GC_PROPERTY_NODE_TYPE_P_VALUE: ArvGcPropertyNodeType = 1002;
235pub const ARV_GC_PROPERTY_NODE_TYPE_P_ADDRESS: ArvGcPropertyNodeType = 1003;
236pub const ARV_GC_PROPERTY_NODE_TYPE_P_IS_IMPLEMENTED: ArvGcPropertyNodeType = 1004;
237pub const ARV_GC_PROPERTY_NODE_TYPE_P_IS_LOCKED: ArvGcPropertyNodeType = 1005;
238pub const ARV_GC_PROPERTY_NODE_TYPE_P_IS_AVAILABLE: ArvGcPropertyNodeType = 1006;
239pub const ARV_GC_PROPERTY_NODE_TYPE_P_SELECTED: ArvGcPropertyNodeType = 1007;
240pub const ARV_GC_PROPERTY_NODE_TYPE_P_MINIMUM: ArvGcPropertyNodeType = 1008;
241pub const ARV_GC_PROPERTY_NODE_TYPE_P_MAXIMUM: ArvGcPropertyNodeType = 1009;
242pub const ARV_GC_PROPERTY_NODE_TYPE_P_INCREMENT: ArvGcPropertyNodeType = 1010;
243pub const ARV_GC_PROPERTY_NODE_TYPE_P_INDEX: ArvGcPropertyNodeType = 1011;
244pub const ARV_GC_PROPERTY_NODE_TYPE_P_LENGTH: ArvGcPropertyNodeType = 1012;
245pub const ARV_GC_PROPERTY_NODE_TYPE_P_PORT: ArvGcPropertyNodeType = 1013;
246pub const ARV_GC_PROPERTY_NODE_TYPE_P_VARIABLE: ArvGcPropertyNodeType = 1014;
247pub const ARV_GC_PROPERTY_NODE_TYPE_P_INVALIDATOR: ArvGcPropertyNodeType = 1015;
248pub const ARV_GC_PROPERTY_NODE_TYPE_P_COMMAND_VALUE: ArvGcPropertyNodeType = 1016;
249pub const ARV_GC_PROPERTY_NODE_TYPE_P_VALUE_INDEXED: ArvGcPropertyNodeType = 1017;
250pub const ARV_GC_PROPERTY_NODE_TYPE_P_VALUE_DEFAULT: ArvGcPropertyNodeType = 1018;
251pub const ARV_GC_PROPERTY_NODE_TYPE_P_ALIAS: ArvGcPropertyNodeType = 1019;
252pub const ARV_GC_PROPERTY_NODE_TYPE_P_CAST_ALIAS: ArvGcPropertyNodeType = 1020;
253
254pub type ArvGcRepresentation = c_int;
255pub const ARV_GC_REPRESENTATION_UNDEFINED: ArvGcRepresentation = -1;
256pub const ARV_GC_REPRESENTATION_LINEAR: ArvGcRepresentation = 0;
257pub const ARV_GC_REPRESENTATION_LOGARITHMIC: ArvGcRepresentation = 1;
258pub const ARV_GC_REPRESENTATION_BOOLEAN: ArvGcRepresentation = 2;
259pub const ARV_GC_REPRESENTATION_PURE_NUMBER: ArvGcRepresentation = 3;
260pub const ARV_GC_REPRESENTATION_HEX_NUMBER: ArvGcRepresentation = 4;
261pub const ARV_GC_REPRESENTATION_IPV4_ADDRESS: ArvGcRepresentation = 5;
262pub const ARV_GC_REPRESENTATION_MAC_ADDRESS: ArvGcRepresentation = 6;
263
264pub type ArvGcSignedness = c_int;
265pub const ARV_GC_SIGNEDNESS_UNDEFINED: ArvGcSignedness = -1;
266pub const ARV_GC_SIGNEDNESS_SIGNED: ArvGcSignedness = 0;
267pub const ARV_GC_SIGNEDNESS_UNSIGNED: ArvGcSignedness = 1;
268
269pub type ArvGcStreamable = c_int;
270pub const ARV_GC_STREAMABLE_UNDEFINED: ArvGcStreamable = -1;
271pub const ARV_GC_STREAMABLE_NO: ArvGcStreamable = 0;
272pub const ARV_GC_STREAMABLE_YES: ArvGcStreamable = 1;
273
274pub type ArvGcVisibility = c_int;
275pub const ARV_GC_VISIBILITY_UNDEFINED: ArvGcVisibility = -1;
276pub const ARV_GC_VISIBILITY_INVISIBLE: ArvGcVisibility = 0;
277pub const ARV_GC_VISIBILITY_GURU: ArvGcVisibility = 1;
278pub const ARV_GC_VISIBILITY_EXPERT: ArvGcVisibility = 2;
279pub const ARV_GC_VISIBILITY_BEGINNER: ArvGcVisibility = 3;
280
281pub type ArvGvIpConfigurationMode = c_int;
282pub const ARV_GV_IP_CONFIGURATION_MODE_NONE: ArvGvIpConfigurationMode = 0;
283pub const ARV_GV_IP_CONFIGURATION_MODE_PERSISTENT_IP: ArvGvIpConfigurationMode = 1;
284pub const ARV_GV_IP_CONFIGURATION_MODE_DHCP: ArvGvIpConfigurationMode = 2;
285pub const ARV_GV_IP_CONFIGURATION_MODE_LLA: ArvGvIpConfigurationMode = 3;
286pub const ARV_GV_IP_CONFIGURATION_MODE_FORCE_IP: ArvGvIpConfigurationMode = 4;
287
288pub type ArvGvPacketSizeAdjustment = c_int;
289pub const ARV_GV_PACKET_SIZE_ADJUSTMENT_NEVER: ArvGvPacketSizeAdjustment = 0;
290pub const ARV_GV_PACKET_SIZE_ADJUSTMENT_ON_FAILURE_ONCE: ArvGvPacketSizeAdjustment = 1;
291pub const ARV_GV_PACKET_SIZE_ADJUSTMENT_ON_FAILURE: ArvGvPacketSizeAdjustment = 2;
292pub const ARV_GV_PACKET_SIZE_ADJUSTMENT_ONCE: ArvGvPacketSizeAdjustment = 3;
293pub const ARV_GV_PACKET_SIZE_ADJUSTMENT_ALWAYS: ArvGvPacketSizeAdjustment = 4;
294pub const ARV_GV_PACKET_SIZE_ADJUSTMENT_DEFAULT: ArvGvPacketSizeAdjustment = 1;
295
296pub type ArvGvStreamPacketResend = c_int;
297pub const ARV_GV_STREAM_PACKET_RESEND_NEVER: ArvGvStreamPacketResend = 0;
298pub const ARV_GV_STREAM_PACKET_RESEND_ALWAYS: ArvGvStreamPacketResend = 1;
299
300pub type ArvGvStreamSocketBuffer = c_int;
301pub const ARV_GV_STREAM_SOCKET_BUFFER_FIXED: ArvGvStreamSocketBuffer = 0;
302pub const ARV_GV_STREAM_SOCKET_BUFFER_AUTO: ArvGvStreamSocketBuffer = 1;
303
304pub type ArvRangeCheckPolicy = c_int;
305pub const ARV_RANGE_CHECK_POLICY_DISABLE: ArvRangeCheckPolicy = 0;
306pub const ARV_RANGE_CHECK_POLICY_ENABLE: ArvRangeCheckPolicy = 1;
307pub const ARV_RANGE_CHECK_POLICY_DEBUG: ArvRangeCheckPolicy = 2;
308pub const ARV_RANGE_CHECK_POLICY_DEFAULT: ArvRangeCheckPolicy = 0;
309
310pub type ArvRegisterCachePolicy = c_int;
311pub const ARV_REGISTER_CACHE_POLICY_DISABLE: ArvRegisterCachePolicy = 0;
312pub const ARV_REGISTER_CACHE_POLICY_ENABLE: ArvRegisterCachePolicy = 1;
313pub const ARV_REGISTER_CACHE_POLICY_DEBUG: ArvRegisterCachePolicy = 2;
314pub const ARV_REGISTER_CACHE_POLICY_DEFAULT: ArvRegisterCachePolicy = 0;
315
316pub type ArvStreamCallbackType = c_int;
317pub const ARV_STREAM_CALLBACK_TYPE_INIT: ArvStreamCallbackType = 0;
318pub const ARV_STREAM_CALLBACK_TYPE_EXIT: ArvStreamCallbackType = 1;
319pub const ARV_STREAM_CALLBACK_TYPE_START_BUFFER: ArvStreamCallbackType = 2;
320pub const ARV_STREAM_CALLBACK_TYPE_BUFFER_DONE: ArvStreamCallbackType = 3;
321
322pub type ArvUvUsbMode = c_int;
323pub const ARV_UV_USB_MODE_SYNC: ArvUvUsbMode = 0;
324pub const ARV_UV_USB_MODE_ASYNC: ArvUvUsbMode = 1;
325pub const ARV_UV_USB_MODE_DEFAULT: ArvUvUsbMode = 1;
326
327pub type ArvXmlSchemaError = c_int;
328pub const ARV_XML_SCHEMA_ERROR_INVALID_STRUCTURE: ArvXmlSchemaError = 0;
329
330pub const ARV_FAKE_CAMERA_ACQUISITION_FRAME_RATE_DEFAULT: c_double = 25.000000;
332pub const ARV_FAKE_CAMERA_BINNING_HORIZONTAL_DEFAULT: c_int = 1;
333pub const ARV_FAKE_CAMERA_BINNING_VERTICAL_DEFAULT: c_int = 1;
334pub const ARV_FAKE_CAMERA_EXPOSURE_TIME_US_DEFAULT: c_double = 10000.000000;
335pub const ARV_FAKE_CAMERA_HEIGHT_DEFAULT: c_int = 512;
336pub const ARV_FAKE_CAMERA_MEMORY_SIZE: c_int = 65536;
337pub const ARV_FAKE_CAMERA_REGISTER_ACQUISITION: c_int = 292;
338pub const ARV_FAKE_CAMERA_REGISTER_ACQUISITION_FRAME_PERIOD_US: c_int = 312;
339pub const ARV_FAKE_CAMERA_REGISTER_ACQUISITION_MODE: c_int = 300;
340pub const ARV_FAKE_CAMERA_REGISTER_ACQUISITION_START_OFFSET: c_int = 32;
341pub const ARV_FAKE_CAMERA_REGISTER_BINNING_HORIZONTAL: c_int = 264;
342pub const ARV_FAKE_CAMERA_REGISTER_BINNING_VERTICAL: c_int = 268;
343pub const ARV_FAKE_CAMERA_REGISTER_EXPOSURE_TIME_US: c_int = 288;
344pub const ARV_FAKE_CAMERA_REGISTER_FRAME_START_OFFSET: c_int = 0;
345pub const ARV_FAKE_CAMERA_REGISTER_GAIN_MODE: c_int = 276;
346pub const ARV_FAKE_CAMERA_REGISTER_GAIN_RAW: c_int = 272;
347pub const ARV_FAKE_CAMERA_REGISTER_HEIGHT: c_int = 260;
348pub const ARV_FAKE_CAMERA_REGISTER_PIXEL_FORMAT: c_int = 296;
349pub const ARV_FAKE_CAMERA_REGISTER_SENSOR_HEIGHT: c_int = 280;
350pub const ARV_FAKE_CAMERA_REGISTER_SENSOR_WIDTH: c_int = 284;
351pub const ARV_FAKE_CAMERA_REGISTER_TEST: c_int = 496;
352pub const ARV_FAKE_CAMERA_REGISTER_TRIGGER_ACTIVATION: c_int = 776;
353pub const ARV_FAKE_CAMERA_REGISTER_TRIGGER_MODE: c_int = 768;
354pub const ARV_FAKE_CAMERA_REGISTER_TRIGGER_SOFTWARE: c_int = 780;
355pub const ARV_FAKE_CAMERA_REGISTER_TRIGGER_SOURCE: c_int = 772;
356pub const ARV_FAKE_CAMERA_REGISTER_WIDTH: c_int = 256;
357pub const ARV_FAKE_CAMERA_REGISTER_X_OFFSET: c_int = 304;
358pub const ARV_FAKE_CAMERA_REGISTER_Y_OFFSET: c_int = 308;
359pub const ARV_FAKE_CAMERA_SENSOR_HEIGHT: c_int = 2048;
360pub const ARV_FAKE_CAMERA_SENSOR_WIDTH: c_int = 2048;
361pub const ARV_FAKE_CAMERA_TEST_REGISTER_DEFAULT: c_int = 305419896;
362pub const ARV_FAKE_CAMERA_WIDTH_DEFAULT: c_int = 512;
363pub const ARV_GV_FAKE_CAMERA_DEFAULT_INTERFACE: &[u8] = b"127.0.0.1\0";
364pub const ARV_GV_FAKE_CAMERA_DEFAULT_SERIAL_NUMBER: &[u8] = b"GV01\0";
365pub const ARV_PIXEL_FORMAT_BAYER_BG_10: ArvPixelFormat = 17825807;
366pub const ARV_PIXEL_FORMAT_BAYER_BG_10P: ArvPixelFormat = 17432658;
367pub const ARV_PIXEL_FORMAT_BAYER_BG_10_PACKED: ArvPixelFormat = 17563689;
368pub const ARV_PIXEL_FORMAT_BAYER_BG_12: ArvPixelFormat = 17825811;
369pub const ARV_PIXEL_FORMAT_BAYER_BG_12P: ArvPixelFormat = 17563731;
370pub const ARV_PIXEL_FORMAT_BAYER_BG_12_PACKED: ArvPixelFormat = 17563693;
371pub const ARV_PIXEL_FORMAT_BAYER_BG_16: ArvPixelFormat = 17825841;
372pub const ARV_PIXEL_FORMAT_BAYER_BG_8: ArvPixelFormat = 17301515;
373pub const ARV_PIXEL_FORMAT_BAYER_GB_10: ArvPixelFormat = 17825806;
374pub const ARV_PIXEL_FORMAT_BAYER_GB_10P: ArvPixelFormat = 17432660;
375pub const ARV_PIXEL_FORMAT_BAYER_GB_10_PACKED: ArvPixelFormat = 17563688;
376pub const ARV_PIXEL_FORMAT_BAYER_GB_12: ArvPixelFormat = 17825810;
377pub const ARV_PIXEL_FORMAT_BAYER_GB_12P: ArvPixelFormat = 17563733;
378pub const ARV_PIXEL_FORMAT_BAYER_GB_12_PACKED: ArvPixelFormat = 17563692;
379pub const ARV_PIXEL_FORMAT_BAYER_GB_16: ArvPixelFormat = 17825840;
380pub const ARV_PIXEL_FORMAT_BAYER_GB_8: ArvPixelFormat = 17301514;
381pub const ARV_PIXEL_FORMAT_BAYER_GR_10: ArvPixelFormat = 17825804;
382pub const ARV_PIXEL_FORMAT_BAYER_GR_10P: ArvPixelFormat = 17432662;
383pub const ARV_PIXEL_FORMAT_BAYER_GR_10_PACKED: ArvPixelFormat = 17563686;
384pub const ARV_PIXEL_FORMAT_BAYER_GR_12: ArvPixelFormat = 17825808;
385pub const ARV_PIXEL_FORMAT_BAYER_GR_12P: ArvPixelFormat = 17563735;
386pub const ARV_PIXEL_FORMAT_BAYER_GR_12_PACKED: ArvPixelFormat = 17563690;
387pub const ARV_PIXEL_FORMAT_BAYER_GR_16: ArvPixelFormat = 17825838;
388pub const ARV_PIXEL_FORMAT_BAYER_GR_8: ArvPixelFormat = 17301512;
389pub const ARV_PIXEL_FORMAT_BAYER_RG_10: ArvPixelFormat = 17825805;
390pub const ARV_PIXEL_FORMAT_BAYER_RG_10P: ArvPixelFormat = 17432664;
391pub const ARV_PIXEL_FORMAT_BAYER_RG_10_PACKED: ArvPixelFormat = 17563687;
392pub const ARV_PIXEL_FORMAT_BAYER_RG_12: ArvPixelFormat = 17825809;
393pub const ARV_PIXEL_FORMAT_BAYER_RG_12P: ArvPixelFormat = 17563737;
394pub const ARV_PIXEL_FORMAT_BAYER_RG_12_PACKED: ArvPixelFormat = 17563691;
395pub const ARV_PIXEL_FORMAT_BAYER_RG_16: ArvPixelFormat = 17825839;
396pub const ARV_PIXEL_FORMAT_BAYER_RG_8: ArvPixelFormat = 17301513;
397pub const ARV_PIXEL_FORMAT_BGRA_8_PACKED: ArvPixelFormat = 35651607;
398pub const ARV_PIXEL_FORMAT_BGR_10_PACKED: ArvPixelFormat = 36700185;
399pub const ARV_PIXEL_FORMAT_BGR_12_PACKED: ArvPixelFormat = 36700187;
400pub const ARV_PIXEL_FORMAT_BGR_8_PACKED: ArvPixelFormat = 35127317;
401pub const ARV_PIXEL_FORMAT_COORD3D_ABC_10P: ArvPixelFormat = 35520731;
402pub const ARV_PIXEL_FORMAT_COORD3D_ABC_10P_PLANAR: ArvPixelFormat = 35520732;
403pub const ARV_PIXEL_FORMAT_COORD3D_ABC_12P: ArvPixelFormat = 35913950;
404pub const ARV_PIXEL_FORMAT_COORD3D_ABC_12P_PLANAR: ArvPixelFormat = 35913951;
405pub const ARV_PIXEL_FORMAT_COORD3D_ABC_16: ArvPixelFormat = 36700345;
406pub const ARV_PIXEL_FORMAT_COORD3D_ABC_16_PLANAR: ArvPixelFormat = 36700346;
407pub const ARV_PIXEL_FORMAT_COORD3D_ABC_32F: ArvPixelFormat = 39846080;
408pub const ARV_PIXEL_FORMAT_COORD3D_ABC_32F_PLANAR: ArvPixelFormat = 39846081;
409pub const ARV_PIXEL_FORMAT_COORD3D_ABC_8: ArvPixelFormat = 35127474;
410pub const ARV_PIXEL_FORMAT_COORD3D_ABC_8_PLANAR: ArvPixelFormat = 35127475;
411pub const ARV_PIXEL_FORMAT_COORD3D_AC_10P: ArvPixelFormat = 34865392;
412pub const ARV_PIXEL_FORMAT_COORD3D_AC_10P_PLANAR: ArvPixelFormat = 34865393;
413pub const ARV_PIXEL_FORMAT_COORD3D_AC_12P: ArvPixelFormat = 35127538;
414pub const ARV_PIXEL_FORMAT_COORD3D_AC_12P_PLANAR: ArvPixelFormat = 35127539;
415pub const ARV_PIXEL_FORMAT_COORD3D_AC_16: ArvPixelFormat = 35651771;
416pub const ARV_PIXEL_FORMAT_COORD3D_AC_16_PLANAR: ArvPixelFormat = 35651772;
417pub const ARV_PIXEL_FORMAT_COORD3D_AC_32F: ArvPixelFormat = 37748930;
418pub const ARV_PIXEL_FORMAT_COORD3D_AC_32F_PLANAR: ArvPixelFormat = 37748931;
419pub const ARV_PIXEL_FORMAT_COORD3D_AC_8: ArvPixelFormat = 34603188;
420pub const ARV_PIXEL_FORMAT_COORD3D_AC_8_PLANAR: ArvPixelFormat = 34603189;
421pub const ARV_PIXEL_FORMAT_COORD3D_A_10P: ArvPixelFormat = 17432789;
422pub const ARV_PIXEL_FORMAT_COORD3D_A_12P: ArvPixelFormat = 17563864;
423pub const ARV_PIXEL_FORMAT_COORD3D_A_16: ArvPixelFormat = 17825974;
424pub const ARV_PIXEL_FORMAT_COORD3D_A_32F: ArvPixelFormat = 18874557;
425pub const ARV_PIXEL_FORMAT_COORD3D_A_8: ArvPixelFormat = 17301679;
426pub const ARV_PIXEL_FORMAT_COORD3D_B_10P: ArvPixelFormat = 17432790;
427pub const ARV_PIXEL_FORMAT_COORD3D_B_12P: ArvPixelFormat = 17563865;
428pub const ARV_PIXEL_FORMAT_COORD3D_B_16: ArvPixelFormat = 17825975;
429pub const ARV_PIXEL_FORMAT_COORD3D_B_32F: ArvPixelFormat = 18874558;
430pub const ARV_PIXEL_FORMAT_COORD3D_B_8: ArvPixelFormat = 17301680;
431pub const ARV_PIXEL_FORMAT_COORD3D_C_10P: ArvPixelFormat = 17432791;
432pub const ARV_PIXEL_FORMAT_COORD3D_C_12P: ArvPixelFormat = 17563866;
433pub const ARV_PIXEL_FORMAT_COORD3D_C_16: ArvPixelFormat = 17825976;
434pub const ARV_PIXEL_FORMAT_COORD3D_C_32F: ArvPixelFormat = 18874559;
435pub const ARV_PIXEL_FORMAT_COORD3D_C_8: ArvPixelFormat = 17301681;
436pub const ARV_PIXEL_FORMAT_CUSTOM_BAYER_BG_12_PACKED: ArvPixelFormat = 2165047300;
437pub const ARV_PIXEL_FORMAT_CUSTOM_BAYER_BG_16: ArvPixelFormat = 2165309449;
438pub const ARV_PIXEL_FORMAT_CUSTOM_BAYER_GB_12_PACKED: ArvPixelFormat = 2165047299;
439pub const ARV_PIXEL_FORMAT_CUSTOM_BAYER_GB_16: ArvPixelFormat = 2165309448;
440pub const ARV_PIXEL_FORMAT_CUSTOM_BAYER_GR_12_PACKED: ArvPixelFormat = 2165047297;
441pub const ARV_PIXEL_FORMAT_CUSTOM_BAYER_GR_16: ArvPixelFormat = 2165309446;
442pub const ARV_PIXEL_FORMAT_CUSTOM_BAYER_RG_12_PACKED: ArvPixelFormat = 2165047298;
443pub const ARV_PIXEL_FORMAT_CUSTOM_BAYER_RG_16: ArvPixelFormat = 2165309447;
444pub const ARV_PIXEL_FORMAT_CUSTOM_YUV_422_YUYV_PACKED: ArvPixelFormat = 2182086661;
445pub const ARV_PIXEL_FORMAT_DATA_16: ArvPixelFormat = 17826072;
446pub const ARV_PIXEL_FORMAT_DATA_16S: ArvPixelFormat = 17826073;
447pub const ARV_PIXEL_FORMAT_DATA_32: ArvPixelFormat = 18874650;
448pub const ARV_PIXEL_FORMAT_DATA_32F: ArvPixelFormat = 18874652;
449pub const ARV_PIXEL_FORMAT_DATA_32S: ArvPixelFormat = 18874651;
450pub const ARV_PIXEL_FORMAT_DATA_64: ArvPixelFormat = 20971805;
451pub const ARV_PIXEL_FORMAT_DATA_64F: ArvPixelFormat = 20971807;
452pub const ARV_PIXEL_FORMAT_DATA_64S: ArvPixelFormat = 20971806;
453pub const ARV_PIXEL_FORMAT_DATA_8: ArvPixelFormat = 17301782;
454pub const ARV_PIXEL_FORMAT_DATA_8S: ArvPixelFormat = 17301783;
455pub const ARV_PIXEL_FORMAT_MONO_10: ArvPixelFormat = 17825795;
456pub const ARV_PIXEL_FORMAT_MONO_10_PACKED: ArvPixelFormat = 17563652;
457pub const ARV_PIXEL_FORMAT_MONO_12: ArvPixelFormat = 17825797;
458pub const ARV_PIXEL_FORMAT_MONO_12_PACKED: ArvPixelFormat = 17563654;
459pub const ARV_PIXEL_FORMAT_MONO_14: ArvPixelFormat = 17825829;
460pub const ARV_PIXEL_FORMAT_MONO_16: ArvPixelFormat = 17825799;
461pub const ARV_PIXEL_FORMAT_MONO_8: ArvPixelFormat = 17301505;
462pub const ARV_PIXEL_FORMAT_MONO_8_SIGNED: ArvPixelFormat = 17301506;
463pub const ARV_PIXEL_FORMAT_RGBA_8_PACKED: ArvPixelFormat = 35651606;
464pub const ARV_PIXEL_FORMAT_RGB_10_PACKED: ArvPixelFormat = 36700184;
465pub const ARV_PIXEL_FORMAT_RGB_10_PLANAR: ArvPixelFormat = 36700194;
466pub const ARV_PIXEL_FORMAT_RGB_12_PACKED: ArvPixelFormat = 36700186;
467pub const ARV_PIXEL_FORMAT_RGB_12_PLANAR: ArvPixelFormat = 36700195;
468pub const ARV_PIXEL_FORMAT_RGB_16_PLANAR: ArvPixelFormat = 36700196;
469pub const ARV_PIXEL_FORMAT_RGB_8_PACKED: ArvPixelFormat = 35127316;
470pub const ARV_PIXEL_FORMAT_RGB_8_PLANAR: ArvPixelFormat = 35127329;
471pub const ARV_PIXEL_FORMAT_YUV_411_PACKED: ArvPixelFormat = 34340894;
472pub const ARV_PIXEL_FORMAT_YUV_422_PACKED: ArvPixelFormat = 34603039;
473pub const ARV_PIXEL_FORMAT_YUV_422_YUYV_PACKED: ArvPixelFormat = 34603058;
474pub const ARV_PIXEL_FORMAT_YUV_444_PACKED: ArvPixelFormat = 35127328;
475
476pub type ArvGvInterfaceFlags = c_uint;
478pub const ARV_GV_INTERFACE_FLAGS_ALLOW_BROADCAST_DISCOVERY_ACK: ArvGvInterfaceFlags = 1;
479
480pub type ArvGvStreamOption = c_uint;
481pub const ARV_GV_STREAM_OPTION_NONE: ArvGvStreamOption = 0;
482pub const ARV_GV_STREAM_OPTION_PACKET_SOCKET_DISABLED: ArvGvStreamOption = 1;
483
484pub type ArvDomDocumentCreateFunction = Option<unsafe extern "C" fn() -> *mut ArvDomDocument>;
486pub type ArvFakeCameraFillPattern =
487 Option<unsafe extern "C" fn(*mut ArvBuffer, *mut c_void, u32, u32, ArvPixelFormat)>;
488pub type ArvStreamCallback =
489 Option<unsafe extern "C" fn(*mut c_void, ArvStreamCallbackType, *mut ArvBuffer)>;
490
491#[derive(Copy, Clone)]
493#[repr(C)]
494pub struct ArvBufferClass {
495 pub parent_class: gobject::GObjectClass,
496}
497
498impl ::std::fmt::Debug for ArvBufferClass {
499 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
500 f.debug_struct(&format!("ArvBufferClass @ {self:p}"))
501 .field("parent_class", &self.parent_class)
502 .finish()
503 }
504}
505
506#[derive(Copy, Clone)]
507#[repr(C)]
508pub struct ArvCameraClass {
509 pub parent_class: gobject::GObjectClass,
510}
511
512impl ::std::fmt::Debug for ArvCameraClass {
513 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
514 f.debug_struct(&format!("ArvCameraClass @ {self:p}"))
515 .field("parent_class", &self.parent_class)
516 .finish()
517 }
518}
519
520#[derive(Copy, Clone)]
521#[repr(C)]
522pub struct ArvChunkParserClass {
523 pub parent_class: gobject::GObjectClass,
524}
525
526impl ::std::fmt::Debug for ArvChunkParserClass {
527 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
528 f.debug_struct(&format!("ArvChunkParserClass @ {self:p}"))
529 .field("parent_class", &self.parent_class)
530 .finish()
531 }
532}
533
534#[derive(Copy, Clone)]
535#[repr(C)]
536pub struct ArvDeviceClass {
537 pub parent_class: gobject::GObjectClass,
538 pub create_stream: Option<
539 unsafe extern "C" fn(
540 *mut ArvDevice,
541 ArvStreamCallback,
542 *mut c_void,
543 glib::GDestroyNotify,
544 *mut *mut glib::GError,
545 ) -> *mut ArvStream,
546 >,
547 pub get_genicam_xml: Option<unsafe extern "C" fn(*mut ArvDevice, *mut size_t) -> *const c_char>,
548 pub get_genicam: Option<unsafe extern "C" fn(*mut ArvDevice) -> *mut ArvGc>,
549 pub read_memory: Option<
550 unsafe extern "C" fn(
551 *mut ArvDevice,
552 u64,
553 u32,
554 *mut c_void,
555 *mut *mut glib::GError,
556 ) -> gboolean,
557 >,
558 pub write_memory: Option<
559 unsafe extern "C" fn(
560 *mut ArvDevice,
561 u64,
562 u32,
563 *mut c_void,
564 *mut *mut glib::GError,
565 ) -> gboolean,
566 >,
567 pub read_register:
568 Option<unsafe extern "C" fn(*mut ArvDevice, u64, u32, *mut *mut glib::GError) -> gboolean>,
569 pub write_register:
570 Option<unsafe extern "C" fn(*mut ArvDevice, u64, u32, *mut *mut glib::GError) -> gboolean>,
571 pub control_lost: Option<unsafe extern "C" fn(*mut ArvDevice)>,
572}
573
574impl ::std::fmt::Debug for ArvDeviceClass {
575 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
576 f.debug_struct(&format!("ArvDeviceClass @ {self:p}"))
577 .field("parent_class", &self.parent_class)
578 .field("create_stream", &self.create_stream)
579 .field("get_genicam_xml", &self.get_genicam_xml)
580 .field("get_genicam", &self.get_genicam)
581 .field("read_memory", &self.read_memory)
582 .field("write_memory", &self.write_memory)
583 .field("read_register", &self.read_register)
584 .field("write_register", &self.write_register)
585 .field("control_lost", &self.control_lost)
586 .finish()
587 }
588}
589
590#[derive(Copy, Clone)]
591#[repr(C)]
592pub struct ArvDomCharacterDataClass {
593 pub parent_class: ArvDomNodeClass,
594}
595
596impl ::std::fmt::Debug for ArvDomCharacterDataClass {
597 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
598 f.debug_struct(&format!("ArvDomCharacterDataClass @ {self:p}"))
599 .field("parent_class", &self.parent_class)
600 .finish()
601 }
602}
603
604#[derive(Copy, Clone)]
605#[repr(C)]
606pub struct ArvDomDocumentClass {
607 pub parent_class: ArvDomNodeClass,
608 pub get_document_element:
609 Option<unsafe extern "C" fn(*mut ArvDomDocument) -> *mut ArvDomElement>,
610 pub create_element:
611 Option<unsafe extern "C" fn(*mut ArvDomDocument, *const c_char) -> *mut ArvDomElement>,
612 pub create_text_node:
613 Option<unsafe extern "C" fn(*mut ArvDomDocument, *const c_char) -> *mut ArvDomText>,
614}
615
616impl ::std::fmt::Debug for ArvDomDocumentClass {
617 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
618 f.debug_struct(&format!("ArvDomDocumentClass @ {self:p}"))
619 .field("parent_class", &self.parent_class)
620 .field("get_document_element", &self.get_document_element)
621 .field("create_element", &self.create_element)
622 .field("create_text_node", &self.create_text_node)
623 .finish()
624 }
625}
626
627#[derive(Copy, Clone)]
628#[repr(C)]
629pub struct ArvDomDocumentFragmentClass {
630 pub parent_class: ArvDomNodeClass,
631}
632
633impl ::std::fmt::Debug for ArvDomDocumentFragmentClass {
634 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
635 f.debug_struct(&format!("ArvDomDocumentFragmentClass @ {self:p}"))
636 .field("parent_class", &self.parent_class)
637 .finish()
638 }
639}
640
641#[derive(Copy, Clone)]
642#[repr(C)]
643pub struct ArvDomElementClass {
644 pub parent_class: ArvDomNodeClass,
645 pub get_attribute:
646 Option<unsafe extern "C" fn(*mut ArvDomElement, *const c_char) -> *const c_char>,
647 pub set_attribute:
648 Option<unsafe extern "C" fn(*mut ArvDomElement, *const c_char, *const c_char)>,
649}
650
651impl ::std::fmt::Debug for ArvDomElementClass {
652 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
653 f.debug_struct(&format!("ArvDomElementClass @ {self:p}"))
654 .field("parent_class", &self.parent_class)
655 .field("get_attribute", &self.get_attribute)
656 .field("set_attribute", &self.set_attribute)
657 .finish()
658 }
659}
660
661#[derive(Copy, Clone)]
662#[repr(C)]
663pub struct ArvDomNamedNodeMapClass {
664 pub parent_class: gobject::GObjectClass,
665 pub get:
666 Option<unsafe extern "C" fn(*mut ArvDomNamedNodeMap, *const c_char) -> *mut ArvDomNode>,
667 pub set:
668 Option<unsafe extern "C" fn(*mut ArvDomNamedNodeMap, *mut ArvDomNode) -> *mut ArvDomNode>,
669 pub remove:
670 Option<unsafe extern "C" fn(*mut ArvDomNamedNodeMap, *const c_char) -> *mut ArvDomNode>,
671 pub get_item: Option<unsafe extern "C" fn(*mut ArvDomNamedNodeMap, c_uint) -> *mut ArvDomNode>,
672 pub get_length: Option<unsafe extern "C" fn(*mut ArvDomNamedNodeMap) -> c_uint>,
673}
674
675impl ::std::fmt::Debug for ArvDomNamedNodeMapClass {
676 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
677 f.debug_struct(&format!("ArvDomNamedNodeMapClass @ {self:p}"))
678 .field("parent_class", &self.parent_class)
679 .field("get", &self.get)
680 .field("set", &self.set)
681 .field("remove", &self.remove)
682 .field("get_item", &self.get_item)
683 .field("get_length", &self.get_length)
684 .finish()
685 }
686}
687
688#[derive(Copy, Clone)]
689#[repr(C)]
690pub struct ArvDomNodeChildListClass {
691 pub parent_class: ArvDomNodeListClass,
692}
693
694impl ::std::fmt::Debug for ArvDomNodeChildListClass {
695 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
696 f.debug_struct(&format!("ArvDomNodeChildListClass @ {self:p}"))
697 .field("parent_class", &self.parent_class)
698 .finish()
699 }
700}
701
702#[derive(Copy, Clone)]
703#[repr(C)]
704pub struct ArvDomNodeClass {
705 pub parent_class: gobject::GObjectClass,
706 pub get_node_name: Option<unsafe extern "C" fn(*mut ArvDomNode) -> *const c_char>,
707 pub get_node_value: Option<unsafe extern "C" fn(*mut ArvDomNode) -> *const c_char>,
708 pub set_node_value: Option<unsafe extern "C" fn(*mut ArvDomNode, *const c_char)>,
709 pub get_node_type: Option<unsafe extern "C" fn(*mut ArvDomNode) -> ArvDomNodeType>,
710 pub can_append_child:
711 Option<unsafe extern "C" fn(*mut ArvDomNode, *mut ArvDomNode) -> gboolean>,
712 pub post_new_child: Option<unsafe extern "C" fn(*mut ArvDomNode, *mut ArvDomNode)>,
713 pub pre_remove_child: Option<unsafe extern "C" fn(*mut ArvDomNode, *mut ArvDomNode)>,
714 pub changed: Option<unsafe extern "C" fn(*mut ArvDomNode)>,
715 pub child_changed: Option<unsafe extern "C" fn(*mut ArvDomNode, *mut ArvDomNode) -> gboolean>,
716}
717
718impl ::std::fmt::Debug for ArvDomNodeClass {
719 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
720 f.debug_struct(&format!("ArvDomNodeClass @ {self:p}"))
721 .field("parent_class", &self.parent_class)
722 .field("get_node_name", &self.get_node_name)
723 .field("get_node_value", &self.get_node_value)
724 .field("set_node_value", &self.set_node_value)
725 .field("get_node_type", &self.get_node_type)
726 .field("can_append_child", &self.can_append_child)
727 .field("post_new_child", &self.post_new_child)
728 .field("pre_remove_child", &self.pre_remove_child)
729 .field("changed", &self.changed)
730 .field("child_changed", &self.child_changed)
731 .finish()
732 }
733}
734
735#[derive(Copy, Clone)]
736#[repr(C)]
737pub struct ArvDomNodeListClass {
738 pub parent_class: gobject::GObjectClass,
739 pub get_item: Option<unsafe extern "C" fn(*mut ArvDomNodeList, c_uint) -> *mut ArvDomNode>,
740 pub get_length: Option<unsafe extern "C" fn(*mut ArvDomNodeList) -> c_uint>,
741}
742
743impl ::std::fmt::Debug for ArvDomNodeListClass {
744 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
745 f.debug_struct(&format!("ArvDomNodeListClass @ {self:p}"))
746 .field("parent_class", &self.parent_class)
747 .field("get_item", &self.get_item)
748 .field("get_length", &self.get_length)
749 .finish()
750 }
751}
752
753#[derive(Copy, Clone)]
754#[repr(C)]
755pub struct ArvDomTextClass {
756 pub parent_class: ArvDomCharacterDataClass,
757}
758
759impl ::std::fmt::Debug for ArvDomTextClass {
760 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
761 f.debug_struct(&format!("ArvDomTextClass @ {self:p}"))
762 .field("parent_class", &self.parent_class)
763 .finish()
764 }
765}
766
767#[derive(Copy, Clone)]
768#[repr(C)]
769pub struct ArvEvaluatorClass {
770 pub parent_class: gobject::GObjectClass,
771}
772
773impl ::std::fmt::Debug for ArvEvaluatorClass {
774 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
775 f.debug_struct(&format!("ArvEvaluatorClass @ {self:p}"))
776 .field("parent_class", &self.parent_class)
777 .finish()
778 }
779}
780
781#[derive(Copy, Clone)]
782#[repr(C)]
783pub struct ArvFakeCameraClass {
784 pub parent_class: gobject::GObjectClass,
785}
786
787impl ::std::fmt::Debug for ArvFakeCameraClass {
788 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
789 f.debug_struct(&format!("ArvFakeCameraClass @ {self:p}"))
790 .field("parent_class", &self.parent_class)
791 .finish()
792 }
793}
794
795#[derive(Copy, Clone)]
796#[repr(C)]
797pub struct ArvFakeDeviceClass {
798 pub parent_class: ArvDeviceClass,
799}
800
801impl ::std::fmt::Debug for ArvFakeDeviceClass {
802 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
803 f.debug_struct(&format!("ArvFakeDeviceClass @ {self:p}"))
804 .field("parent_class", &self.parent_class)
805 .finish()
806 }
807}
808
809#[derive(Copy, Clone)]
810#[repr(C)]
811pub struct ArvFakeInterfaceClass {
812 pub parent_class: ArvInterfaceClass,
813}
814
815impl ::std::fmt::Debug for ArvFakeInterfaceClass {
816 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
817 f.debug_struct(&format!("ArvFakeInterfaceClass @ {self:p}"))
818 .field("parent_class", &self.parent_class)
819 .finish()
820 }
821}
822
823#[derive(Copy, Clone)]
824#[repr(C)]
825pub struct ArvFakeStreamClass {
826 pub parent_class: ArvStreamClass,
827}
828
829impl ::std::fmt::Debug for ArvFakeStreamClass {
830 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
831 f.debug_struct(&format!("ArvFakeStreamClass @ {self:p}"))
832 .field("parent_class", &self.parent_class)
833 .finish()
834 }
835}
836
837#[derive(Copy, Clone)]
838#[repr(C)]
839pub struct ArvGcBooleanClass {
840 pub parent_class: ArvGcFeatureNodeClass,
841}
842
843impl ::std::fmt::Debug for ArvGcBooleanClass {
844 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
845 f.debug_struct(&format!("ArvGcBooleanClass @ {self:p}"))
846 .field("parent_class", &self.parent_class)
847 .finish()
848 }
849}
850
851#[derive(Copy, Clone)]
852#[repr(C)]
853pub struct ArvGcCategoryClass {
854 pub parent_class: ArvGcFeatureNodeClass,
855}
856
857impl ::std::fmt::Debug for ArvGcCategoryClass {
858 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
859 f.debug_struct(&format!("ArvGcCategoryClass @ {self:p}"))
860 .field("parent_class", &self.parent_class)
861 .finish()
862 }
863}
864
865#[derive(Copy, Clone)]
866#[repr(C)]
867pub struct ArvGcClass {
868 pub parent_class: ArvDomDocumentClass,
869}
870
871impl ::std::fmt::Debug for ArvGcClass {
872 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
873 f.debug_struct(&format!("ArvGcClass @ {self:p}"))
874 .field("parent_class", &self.parent_class)
875 .finish()
876 }
877}
878
879#[derive(Copy, Clone)]
880#[repr(C)]
881pub struct ArvGcCommandClass {
882 pub parent_class: ArvGcFeatureNodeClass,
883}
884
885impl ::std::fmt::Debug for ArvGcCommandClass {
886 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
887 f.debug_struct(&format!("ArvGcCommandClass @ {self:p}"))
888 .field("parent_class", &self.parent_class)
889 .finish()
890 }
891}
892
893#[derive(Copy, Clone)]
894#[repr(C)]
895pub struct ArvGcConverterClass {
896 pub parent_class: ArvGcFeatureNodeClass,
897}
898
899impl ::std::fmt::Debug for ArvGcConverterClass {
900 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
901 f.debug_struct(&format!("ArvGcConverterClass @ {self:p}"))
902 .field("parent_class", &self.parent_class)
903 .finish()
904 }
905}
906
907#[derive(Copy, Clone)]
908#[repr(C)]
909pub struct ArvGcConverterNodeClass {
910 pub parent_class: ArvGcConverterClass,
911}
912
913impl ::std::fmt::Debug for ArvGcConverterNodeClass {
914 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
915 f.debug_struct(&format!("ArvGcConverterNodeClass @ {self:p}"))
916 .field("parent_class", &self.parent_class)
917 .finish()
918 }
919}
920
921#[derive(Copy, Clone)]
922#[repr(C)]
923pub struct ArvGcEnumEntryClass {
924 pub parent_class: ArvGcFeatureNodeClass,
925}
926
927impl ::std::fmt::Debug for ArvGcEnumEntryClass {
928 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
929 f.debug_struct(&format!("ArvGcEnumEntryClass @ {self:p}"))
930 .field("parent_class", &self.parent_class)
931 .finish()
932 }
933}
934
935#[derive(Copy, Clone)]
936#[repr(C)]
937pub struct ArvGcEnumerationClass {
938 pub parent_class: ArvGcFeatureNodeClass,
939}
940
941impl ::std::fmt::Debug for ArvGcEnumerationClass {
942 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
943 f.debug_struct(&format!("ArvGcEnumerationClass @ {self:p}"))
944 .field("parent_class", &self.parent_class)
945 .finish()
946 }
947}
948
949#[derive(Copy, Clone)]
950#[repr(C)]
951pub struct ArvGcFeatureNodeClass {
952 pub parent_class: ArvGcNodeClass,
953 pub get_linked_feature:
954 Option<unsafe extern "C" fn(*mut ArvGcFeatureNode) -> *mut ArvGcFeatureNode>,
955 pub get_access_mode: Option<unsafe extern "C" fn(*mut ArvGcFeatureNode) -> ArvGcAccessMode>,
956 pub default_access_mode: ArvGcAccessMode,
957}
958
959impl ::std::fmt::Debug for ArvGcFeatureNodeClass {
960 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
961 f.debug_struct(&format!("ArvGcFeatureNodeClass @ {self:p}"))
962 .field("parent_class", &self.parent_class)
963 .field("get_linked_feature", &self.get_linked_feature)
964 .field("get_access_mode", &self.get_access_mode)
965 .field("default_access_mode", &self.default_access_mode)
966 .finish()
967 }
968}
969
970#[derive(Copy, Clone)]
971#[repr(C)]
972pub struct ArvGcFloatInterface {
973 pub parent: gobject::GTypeInterface,
974 pub get_value:
975 Option<unsafe extern "C" fn(*mut ArvGcFloat, *mut *mut glib::GError) -> c_double>,
976 pub set_value: Option<unsafe extern "C" fn(*mut ArvGcFloat, c_double, *mut *mut glib::GError)>,
977 pub get_min: Option<unsafe extern "C" fn(*mut ArvGcFloat, *mut *mut glib::GError) -> c_double>,
978 pub get_max: Option<unsafe extern "C" fn(*mut ArvGcFloat, *mut *mut glib::GError) -> c_double>,
979 pub get_inc: Option<unsafe extern "C" fn(*mut ArvGcFloat, *mut *mut glib::GError) -> c_double>,
980 pub get_representation: Option<unsafe extern "C" fn(*mut ArvGcFloat) -> ArvGcRepresentation>,
981 pub get_display_notation: Option<unsafe extern "C" fn(*mut ArvGcFloat) -> ArvGcDisplayNotation>,
982 pub get_display_precision: Option<unsafe extern "C" fn(*mut ArvGcFloat) -> i64>,
983 pub get_unit: Option<unsafe extern "C" fn(*mut ArvGcFloat) -> *const c_char>,
984 pub impose_min: Option<unsafe extern "C" fn(*mut ArvGcFloat, c_double, *mut *mut glib::GError)>,
985 pub impose_max: Option<unsafe extern "C" fn(*mut ArvGcFloat, c_double, *mut *mut glib::GError)>,
986}
987
988impl ::std::fmt::Debug for ArvGcFloatInterface {
989 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
990 f.debug_struct(&format!("ArvGcFloatInterface @ {self:p}"))
991 .field("parent", &self.parent)
992 .field("get_value", &self.get_value)
993 .field("set_value", &self.set_value)
994 .field("get_min", &self.get_min)
995 .field("get_max", &self.get_max)
996 .field("get_inc", &self.get_inc)
997 .field("get_representation", &self.get_representation)
998 .field("get_display_notation", &self.get_display_notation)
999 .field("get_display_precision", &self.get_display_precision)
1000 .field("get_unit", &self.get_unit)
1001 .field("impose_min", &self.impose_min)
1002 .field("impose_max", &self.impose_max)
1003 .finish()
1004 }
1005}
1006
1007#[derive(Copy, Clone)]
1008#[repr(C)]
1009pub struct ArvGcFloatNodeClass {
1010 pub parent_class: ArvGcFeatureNodeClass,
1011}
1012
1013impl ::std::fmt::Debug for ArvGcFloatNodeClass {
1014 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1015 f.debug_struct(&format!("ArvGcFloatNodeClass @ {self:p}"))
1016 .field("parent_class", &self.parent_class)
1017 .finish()
1018 }
1019}
1020
1021#[derive(Copy, Clone)]
1022#[repr(C)]
1023pub struct ArvGcFloatRegNodeClass {
1024 pub parent_class: ArvGcRegisterNodeClass,
1025}
1026
1027impl ::std::fmt::Debug for ArvGcFloatRegNodeClass {
1028 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1029 f.debug_struct(&format!("ArvGcFloatRegNodeClass @ {self:p}"))
1030 .field("parent_class", &self.parent_class)
1031 .finish()
1032 }
1033}
1034
1035#[derive(Copy, Clone)]
1036#[repr(C)]
1037pub struct ArvGcGroupNodeClass {
1038 pub parent_class: ArvGcFeatureNodeClass,
1039}
1040
1041impl ::std::fmt::Debug for ArvGcGroupNodeClass {
1042 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1043 f.debug_struct(&format!("ArvGcGroupNodeClass @ {self:p}"))
1044 .field("parent_class", &self.parent_class)
1045 .finish()
1046 }
1047}
1048
1049#[derive(Copy, Clone)]
1050#[repr(C)]
1051pub struct ArvGcIndexNodeClass {
1052 pub parent_class: ArvGcPropertyNodeClass,
1053}
1054
1055impl ::std::fmt::Debug for ArvGcIndexNodeClass {
1056 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1057 f.debug_struct(&format!("ArvGcIndexNodeClass @ {self:p}"))
1058 .field("parent_class", &self.parent_class)
1059 .finish()
1060 }
1061}
1062
1063#[derive(Copy, Clone)]
1064#[repr(C)]
1065pub struct ArvGcIntConverterNodeClass {
1066 pub parent_class: ArvGcConverterClass,
1067}
1068
1069impl ::std::fmt::Debug for ArvGcIntConverterNodeClass {
1070 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1071 f.debug_struct(&format!("ArvGcIntConverterNodeClass @ {self:p}"))
1072 .field("parent_class", &self.parent_class)
1073 .finish()
1074 }
1075}
1076
1077#[derive(Copy, Clone)]
1078#[repr(C)]
1079pub struct ArvGcIntRegNodeClass {
1080 pub parent_class: ArvGcRegisterNodeClass,
1081}
1082
1083impl ::std::fmt::Debug for ArvGcIntRegNodeClass {
1084 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1085 f.debug_struct(&format!("ArvGcIntRegNodeClass @ {self:p}"))
1086 .field("parent_class", &self.parent_class)
1087 .finish()
1088 }
1089}
1090
1091#[derive(Copy, Clone)]
1092#[repr(C)]
1093pub struct ArvGcIntSwissKnifeNodeClass {
1094 pub parent_class: ArvGcSwissKnifeClass,
1095}
1096
1097impl ::std::fmt::Debug for ArvGcIntSwissKnifeNodeClass {
1098 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1099 f.debug_struct(&format!("ArvGcIntSwissKnifeNodeClass @ {self:p}"))
1100 .field("parent_class", &self.parent_class)
1101 .finish()
1102 }
1103}
1104
1105#[derive(Copy, Clone)]
1106#[repr(C)]
1107pub struct ArvGcIntegerInterface {
1108 pub parent: gobject::GTypeInterface,
1109 pub get_value: Option<unsafe extern "C" fn(*mut ArvGcInteger, *mut *mut glib::GError) -> i64>,
1110 pub set_value: Option<unsafe extern "C" fn(*mut ArvGcInteger, i64, *mut *mut glib::GError)>,
1111 pub get_min: Option<unsafe extern "C" fn(*mut ArvGcInteger, *mut *mut glib::GError) -> i64>,
1112 pub get_max: Option<unsafe extern "C" fn(*mut ArvGcInteger, *mut *mut glib::GError) -> i64>,
1113 pub get_inc: Option<unsafe extern "C" fn(*mut ArvGcInteger, *mut *mut glib::GError) -> i64>,
1114 pub get_representation: Option<unsafe extern "C" fn(*mut ArvGcInteger) -> ArvGcRepresentation>,
1115 pub get_unit: Option<unsafe extern "C" fn(*mut ArvGcInteger) -> *const c_char>,
1116 pub impose_min: Option<unsafe extern "C" fn(*mut ArvGcInteger, i64, *mut *mut glib::GError)>,
1117 pub impose_max: Option<unsafe extern "C" fn(*mut ArvGcInteger, i64, *mut *mut glib::GError)>,
1118}
1119
1120impl ::std::fmt::Debug for ArvGcIntegerInterface {
1121 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1122 f.debug_struct(&format!("ArvGcIntegerInterface @ {self:p}"))
1123 .field("parent", &self.parent)
1124 .field("get_value", &self.get_value)
1125 .field("set_value", &self.set_value)
1126 .field("get_min", &self.get_min)
1127 .field("get_max", &self.get_max)
1128 .field("get_inc", &self.get_inc)
1129 .field("get_representation", &self.get_representation)
1130 .field("get_unit", &self.get_unit)
1131 .field("impose_min", &self.impose_min)
1132 .field("impose_max", &self.impose_max)
1133 .finish()
1134 }
1135}
1136
1137#[derive(Copy, Clone)]
1138#[repr(C)]
1139pub struct ArvGcIntegerNodeClass {
1140 pub parent_class: ArvGcFeatureNodeClass,
1141}
1142
1143impl ::std::fmt::Debug for ArvGcIntegerNodeClass {
1144 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1145 f.debug_struct(&format!("ArvGcIntegerNodeClass @ {self:p}"))
1146 .field("parent_class", &self.parent_class)
1147 .finish()
1148 }
1149}
1150
1151#[derive(Copy, Clone)]
1152#[repr(C)]
1153pub struct ArvGcInvalidatorNodeClass {
1154 pub parent_class: ArvGcPropertyNodeClass,
1155}
1156
1157impl ::std::fmt::Debug for ArvGcInvalidatorNodeClass {
1158 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1159 f.debug_struct(&format!("ArvGcInvalidatorNodeClass @ {self:p}"))
1160 .field("parent_class", &self.parent_class)
1161 .finish()
1162 }
1163}
1164
1165#[derive(Copy, Clone)]
1166#[repr(C)]
1167pub struct ArvGcMaskedIntRegNodeClass {
1168 pub parent_class: ArvGcRegisterNodeClass,
1169}
1170
1171impl ::std::fmt::Debug for ArvGcMaskedIntRegNodeClass {
1172 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1173 f.debug_struct(&format!("ArvGcMaskedIntRegNodeClass @ {self:p}"))
1174 .field("parent_class", &self.parent_class)
1175 .finish()
1176 }
1177}
1178
1179#[derive(Copy, Clone)]
1180#[repr(C)]
1181pub struct ArvGcNodeClass {
1182 pub parent_class: ArvDomElementClass,
1183}
1184
1185impl ::std::fmt::Debug for ArvGcNodeClass {
1186 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1187 f.debug_struct(&format!("ArvGcNodeClass @ {self:p}"))
1188 .field("parent_class", &self.parent_class)
1189 .finish()
1190 }
1191}
1192
1193#[derive(Copy, Clone)]
1194#[repr(C)]
1195pub struct ArvGcPortClass {
1196 pub parent_class: ArvGcFeatureNodeClass,
1197}
1198
1199impl ::std::fmt::Debug for ArvGcPortClass {
1200 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1201 f.debug_struct(&format!("ArvGcPortClass @ {self:p}"))
1202 .field("parent_class", &self.parent_class)
1203 .finish()
1204 }
1205}
1206
1207#[derive(Copy, Clone)]
1208#[repr(C)]
1209pub struct ArvGcPropertyNodeClass {
1210 pub parent_class: ArvGcNodeClass,
1211}
1212
1213impl ::std::fmt::Debug for ArvGcPropertyNodeClass {
1214 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1215 f.debug_struct(&format!("ArvGcPropertyNodeClass @ {self:p}"))
1216 .field("parent_class", &self.parent_class)
1217 .finish()
1218 }
1219}
1220
1221#[derive(Copy, Clone)]
1222#[repr(C)]
1223pub struct ArvGcRegisterDescriptionNodeClass {
1224 pub parent_class: ArvGcFeatureNodeClass,
1225}
1226
1227impl ::std::fmt::Debug for ArvGcRegisterDescriptionNodeClass {
1228 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1229 f.debug_struct(&format!("ArvGcRegisterDescriptionNodeClass @ {self:p}"))
1230 .field("parent_class", &self.parent_class)
1231 .finish()
1232 }
1233}
1234
1235#[derive(Copy, Clone)]
1236#[repr(C)]
1237pub struct ArvGcRegisterInterface {
1238 pub parent: gobject::GTypeInterface,
1239 pub get:
1240 Option<unsafe extern "C" fn(*mut ArvGcRegister, *mut c_void, u64, *mut *mut glib::GError)>,
1241 pub set:
1242 Option<unsafe extern "C" fn(*mut ArvGcRegister, *mut c_void, u64, *mut *mut glib::GError)>,
1243 pub get_address:
1244 Option<unsafe extern "C" fn(*mut ArvGcRegister, *mut *mut glib::GError) -> u64>,
1245 pub get_length: Option<unsafe extern "C" fn(*mut ArvGcRegister, *mut *mut glib::GError) -> u64>,
1246}
1247
1248impl ::std::fmt::Debug for ArvGcRegisterInterface {
1249 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1250 f.debug_struct(&format!("ArvGcRegisterInterface @ {self:p}"))
1251 .field("parent", &self.parent)
1252 .field("get", &self.get)
1253 .field("set", &self.set)
1254 .field("get_address", &self.get_address)
1255 .field("get_length", &self.get_length)
1256 .finish()
1257 }
1258}
1259
1260#[derive(Copy, Clone)]
1261#[repr(C)]
1262pub struct ArvGcRegisterNodeClass {
1263 pub parent_class: ArvGcFeatureNodeClass,
1264 pub default_cachable: ArvGcCachable,
1265}
1266
1267impl ::std::fmt::Debug for ArvGcRegisterNodeClass {
1268 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1269 f.debug_struct(&format!("ArvGcRegisterNodeClass @ {self:p}"))
1270 .field("parent_class", &self.parent_class)
1271 .field("default_cachable", &self.default_cachable)
1272 .finish()
1273 }
1274}
1275
1276#[derive(Copy, Clone)]
1277#[repr(C)]
1278pub struct ArvGcSelectorInterface {
1279 pub parent: gobject::GTypeInterface,
1280 pub get_selected_features:
1281 Option<unsafe extern "C" fn(*mut ArvGcSelector) -> *const glib::GSList>,
1282}
1283
1284impl ::std::fmt::Debug for ArvGcSelectorInterface {
1285 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1286 f.debug_struct(&format!("ArvGcSelectorInterface @ {self:p}"))
1287 .field("parent", &self.parent)
1288 .field("get_selected_features", &self.get_selected_features)
1289 .finish()
1290 }
1291}
1292
1293#[derive(Copy, Clone)]
1294#[repr(C)]
1295pub struct ArvGcStringInterface {
1296 pub parent: gobject::GTypeInterface,
1297 pub get_value:
1298 Option<unsafe extern "C" fn(*mut ArvGcString, *mut *mut glib::GError) -> *const c_char>,
1299 pub set_value:
1300 Option<unsafe extern "C" fn(*mut ArvGcString, *const c_char, *mut *mut glib::GError)>,
1301 pub get_max_length:
1302 Option<unsafe extern "C" fn(*mut ArvGcString, *mut *mut glib::GError) -> i64>,
1303}
1304
1305impl ::std::fmt::Debug for ArvGcStringInterface {
1306 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1307 f.debug_struct(&format!("ArvGcStringInterface @ {self:p}"))
1308 .field("parent", &self.parent)
1309 .field("get_value", &self.get_value)
1310 .field("set_value", &self.set_value)
1311 .field("get_max_length", &self.get_max_length)
1312 .finish()
1313 }
1314}
1315
1316#[derive(Copy, Clone)]
1317#[repr(C)]
1318pub struct ArvGcStringNodeClass {
1319 pub parent_class: ArvGcFeatureNodeClass,
1320}
1321
1322impl ::std::fmt::Debug for ArvGcStringNodeClass {
1323 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1324 f.debug_struct(&format!("ArvGcStringNodeClass @ {self:p}"))
1325 .field("parent_class", &self.parent_class)
1326 .finish()
1327 }
1328}
1329
1330#[derive(Copy, Clone)]
1331#[repr(C)]
1332pub struct ArvGcStringRegNodeClass {
1333 pub parent_class: ArvGcRegisterNodeClass,
1334}
1335
1336impl ::std::fmt::Debug for ArvGcStringRegNodeClass {
1337 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1338 f.debug_struct(&format!("ArvGcStringRegNodeClass @ {self:p}"))
1339 .field("parent_class", &self.parent_class)
1340 .finish()
1341 }
1342}
1343
1344#[derive(Copy, Clone)]
1345#[repr(C)]
1346pub struct ArvGcStructEntryNodeClass {
1347 pub parent_class: ArvGcFeatureNodeClass,
1348}
1349
1350impl ::std::fmt::Debug for ArvGcStructEntryNodeClass {
1351 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1352 f.debug_struct(&format!("ArvGcStructEntryNodeClass @ {self:p}"))
1353 .field("parent_class", &self.parent_class)
1354 .finish()
1355 }
1356}
1357
1358#[derive(Copy, Clone)]
1359#[repr(C)]
1360pub struct ArvGcStructRegNodeClass {
1361 pub parent_class: ArvGcRegisterNodeClass,
1362}
1363
1364impl ::std::fmt::Debug for ArvGcStructRegNodeClass {
1365 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1366 f.debug_struct(&format!("ArvGcStructRegNodeClass @ {self:p}"))
1367 .field("parent_class", &self.parent_class)
1368 .finish()
1369 }
1370}
1371
1372#[derive(Copy, Clone)]
1373#[repr(C)]
1374pub struct ArvGcSwissKnifeClass {
1375 pub parent_class: ArvGcFeatureNodeClass,
1376}
1377
1378impl ::std::fmt::Debug for ArvGcSwissKnifeClass {
1379 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1380 f.debug_struct(&format!("ArvGcSwissKnifeClass @ {self:p}"))
1381 .field("parent_class", &self.parent_class)
1382 .finish()
1383 }
1384}
1385
1386#[derive(Copy, Clone)]
1387#[repr(C)]
1388pub struct ArvGcSwissKnifeNodeClass {
1389 pub parent_class: ArvGcSwissKnifeClass,
1390}
1391
1392impl ::std::fmt::Debug for ArvGcSwissKnifeNodeClass {
1393 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1394 f.debug_struct(&format!("ArvGcSwissKnifeNodeClass @ {self:p}"))
1395 .field("parent_class", &self.parent_class)
1396 .finish()
1397 }
1398}
1399
1400#[derive(Copy, Clone)]
1401#[repr(C)]
1402pub struct ArvGcValueIndexedNodeClass {
1403 pub parent_class: ArvGcPropertyNodeClass,
1404}
1405
1406impl ::std::fmt::Debug for ArvGcValueIndexedNodeClass {
1407 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1408 f.debug_struct(&format!("ArvGcValueIndexedNodeClass @ {self:p}"))
1409 .field("parent_class", &self.parent_class)
1410 .finish()
1411 }
1412}
1413
1414#[derive(Copy, Clone)]
1415#[repr(C)]
1416pub struct ArvGvDeviceClass {
1417 pub parent_class: ArvDeviceClass,
1418}
1419
1420impl ::std::fmt::Debug for ArvGvDeviceClass {
1421 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1422 f.debug_struct(&format!("ArvGvDeviceClass @ {self:p}"))
1423 .field("parent_class", &self.parent_class)
1424 .finish()
1425 }
1426}
1427
1428#[derive(Copy, Clone)]
1429#[repr(C)]
1430pub struct ArvGvFakeCameraClass {
1431 pub parent_class: gobject::GObjectClass,
1432}
1433
1434impl ::std::fmt::Debug for ArvGvFakeCameraClass {
1435 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1436 f.debug_struct(&format!("ArvGvFakeCameraClass @ {self:p}"))
1437 .field("parent_class", &self.parent_class)
1438 .finish()
1439 }
1440}
1441
1442#[derive(Copy, Clone)]
1443#[repr(C)]
1444pub struct ArvGvInterfaceClass {
1445 pub parent_class: ArvInterfaceClass,
1446}
1447
1448impl ::std::fmt::Debug for ArvGvInterfaceClass {
1449 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1450 f.debug_struct(&format!("ArvGvInterfaceClass @ {self:p}"))
1451 .field("parent_class", &self.parent_class)
1452 .finish()
1453 }
1454}
1455
1456#[derive(Copy, Clone)]
1457#[repr(C)]
1458pub struct ArvGvStreamClass {
1459 pub parent_class: ArvStreamClass,
1460}
1461
1462impl ::std::fmt::Debug for ArvGvStreamClass {
1463 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1464 f.debug_struct(&format!("ArvGvStreamClass @ {self:p}"))
1465 .field("parent_class", &self.parent_class)
1466 .finish()
1467 }
1468}
1469
1470#[derive(Copy, Clone)]
1471#[repr(C)]
1472pub struct ArvInterfaceClass {
1473 pub parent_class: gobject::GObjectClass,
1474 pub update_device_list: Option<unsafe extern "C" fn(*mut ArvInterface, *mut glib::GArray)>,
1475 pub open_device: Option<
1476 unsafe extern "C" fn(
1477 *mut ArvInterface,
1478 *const c_char,
1479 *mut *mut glib::GError,
1480 ) -> *mut ArvDevice,
1481 >,
1482 pub protocol: *const c_char,
1483}
1484
1485impl ::std::fmt::Debug for ArvInterfaceClass {
1486 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1487 f.debug_struct(&format!("ArvInterfaceClass @ {self:p}"))
1488 .field("parent_class", &self.parent_class)
1489 .field("update_device_list", &self.update_device_list)
1490 .field("open_device", &self.open_device)
1491 .field("protocol", &self.protocol)
1492 .finish()
1493 }
1494}
1495
1496#[derive(Copy, Clone)]
1497#[repr(C)]
1498pub struct ArvStreamClass {
1499 pub parent_class: gobject::GObjectClass,
1500 pub start_thread: Option<unsafe extern "C" fn(*mut ArvStream)>,
1501 pub stop_thread: Option<unsafe extern "C" fn(*mut ArvStream)>,
1502 pub new_buffer: Option<unsafe extern "C" fn(*mut ArvStream)>,
1503}
1504
1505impl ::std::fmt::Debug for ArvStreamClass {
1506 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1507 f.debug_struct(&format!("ArvStreamClass @ {self:p}"))
1508 .field("parent_class", &self.parent_class)
1509 .field("start_thread", &self.start_thread)
1510 .field("stop_thread", &self.stop_thread)
1511 .field("new_buffer", &self.new_buffer)
1512 .finish()
1513 }
1514}
1515
1516#[derive(Copy, Clone)]
1517#[repr(C)]
1518pub struct ArvUvDeviceClass {
1519 pub parent_class: ArvDeviceClass,
1520}
1521
1522impl ::std::fmt::Debug for ArvUvDeviceClass {
1523 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1524 f.debug_struct(&format!("ArvUvDeviceClass @ {self:p}"))
1525 .field("parent_class", &self.parent_class)
1526 .finish()
1527 }
1528}
1529
1530#[derive(Copy, Clone)]
1531#[repr(C)]
1532pub struct ArvUvInterfaceClass {
1533 pub parent_class: ArvInterfaceClass,
1534}
1535
1536impl ::std::fmt::Debug for ArvUvInterfaceClass {
1537 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1538 f.debug_struct(&format!("ArvUvInterfaceClass @ {self:p}"))
1539 .field("parent_class", &self.parent_class)
1540 .finish()
1541 }
1542}
1543
1544#[derive(Copy, Clone)]
1545#[repr(C)]
1546pub struct ArvUvStreamClass {
1547 pub parent_class: ArvStreamClass,
1548}
1549
1550impl ::std::fmt::Debug for ArvUvStreamClass {
1551 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1552 f.debug_struct(&format!("ArvUvStreamClass @ {self:p}"))
1553 .field("parent_class", &self.parent_class)
1554 .finish()
1555 }
1556}
1557
1558#[derive(Copy, Clone)]
1559#[repr(C)]
1560pub struct ArvXmlSchemaClass {
1561 pub parent_class: gobject::GObjectClass,
1562}
1563
1564impl ::std::fmt::Debug for ArvXmlSchemaClass {
1565 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1566 f.debug_struct(&format!("ArvXmlSchemaClass @ {self:p}"))
1567 .field("parent_class", &self.parent_class)
1568 .finish()
1569 }
1570}
1571
1572#[repr(C)]
1573pub struct _ArvZip {
1574 _data: [u8; 0],
1575 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1576}
1577
1578pub type ArvZip = _ArvZip;
1579
1580#[repr(C)]
1581pub struct _ArvZipFile {
1582 _data: [u8; 0],
1583 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1584}
1585
1586pub type ArvZipFile = _ArvZipFile;
1587
1588#[repr(C)]
1590pub struct ArvBuffer {
1591 _data: [u8; 0],
1592 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1593}
1594
1595impl ::std::fmt::Debug for ArvBuffer {
1596 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1597 f.debug_struct(&format!("ArvBuffer @ {self:p}")).finish()
1598 }
1599}
1600
1601#[derive(Copy, Clone)]
1602#[repr(C)]
1603pub struct ArvCamera {
1604 pub parent_instance: gobject::GObject,
1605}
1606
1607impl ::std::fmt::Debug for ArvCamera {
1608 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1609 f.debug_struct(&format!("ArvCamera @ {self:p}"))
1610 .field("parent_instance", &self.parent_instance)
1611 .finish()
1612 }
1613}
1614
1615#[repr(C)]
1616pub struct ArvChunkParser {
1617 _data: [u8; 0],
1618 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1619}
1620
1621impl ::std::fmt::Debug for ArvChunkParser {
1622 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1623 f.debug_struct(&format!("ArvChunkParser @ {self:p}"))
1624 .finish()
1625 }
1626}
1627
1628#[derive(Copy, Clone)]
1629#[repr(C)]
1630pub struct ArvDevice {
1631 pub parent_instance: gobject::GObject,
1632}
1633
1634impl ::std::fmt::Debug for ArvDevice {
1635 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1636 f.debug_struct(&format!("ArvDevice @ {self:p}"))
1637 .field("parent_instance", &self.parent_instance)
1638 .finish()
1639 }
1640}
1641
1642#[derive(Copy, Clone)]
1643#[repr(C)]
1644pub struct ArvDomCharacterData {
1645 pub parent_instance: ArvDomNode,
1646}
1647
1648impl ::std::fmt::Debug for ArvDomCharacterData {
1649 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1650 f.debug_struct(&format!("ArvDomCharacterData @ {self:p}"))
1651 .field("parent_instance", &self.parent_instance)
1652 .finish()
1653 }
1654}
1655
1656#[derive(Copy, Clone)]
1657#[repr(C)]
1658pub struct ArvDomDocument {
1659 pub parent_instance: ArvDomNode,
1660}
1661
1662impl ::std::fmt::Debug for ArvDomDocument {
1663 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1664 f.debug_struct(&format!("ArvDomDocument @ {self:p}"))
1665 .field("parent_instance", &self.parent_instance)
1666 .finish()
1667 }
1668}
1669
1670#[derive(Copy, Clone)]
1671#[repr(C)]
1672pub struct ArvDomDocumentFragment {
1673 pub parent_instance: ArvDomNode,
1674}
1675
1676impl ::std::fmt::Debug for ArvDomDocumentFragment {
1677 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1678 f.debug_struct(&format!("ArvDomDocumentFragment @ {self:p}"))
1679 .field("parent_instance", &self.parent_instance)
1680 .finish()
1681 }
1682}
1683
1684#[derive(Copy, Clone)]
1685#[repr(C)]
1686pub struct ArvDomElement {
1687 pub parent_instance: ArvDomNode,
1688}
1689
1690impl ::std::fmt::Debug for ArvDomElement {
1691 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1692 f.debug_struct(&format!("ArvDomElement @ {self:p}"))
1693 .field("parent_instance", &self.parent_instance)
1694 .finish()
1695 }
1696}
1697
1698#[derive(Copy, Clone)]
1699#[repr(C)]
1700pub struct ArvDomNamedNodeMap {
1701 pub parent_instance: gobject::GObject,
1702}
1703
1704impl ::std::fmt::Debug for ArvDomNamedNodeMap {
1705 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1706 f.debug_struct(&format!("ArvDomNamedNodeMap @ {self:p}"))
1707 .field("parent_instance", &self.parent_instance)
1708 .finish()
1709 }
1710}
1711
1712#[derive(Copy, Clone)]
1713#[repr(C)]
1714pub struct ArvDomNode {
1715 pub parent_instance: gobject::GObject,
1716}
1717
1718impl ::std::fmt::Debug for ArvDomNode {
1719 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1720 f.debug_struct(&format!("ArvDomNode @ {self:p}"))
1721 .field("parent_instance", &self.parent_instance)
1722 .finish()
1723 }
1724}
1725
1726#[repr(C)]
1727pub struct ArvDomNodeChildList {
1728 _data: [u8; 0],
1729 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1730}
1731
1732impl ::std::fmt::Debug for ArvDomNodeChildList {
1733 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1734 f.debug_struct(&format!("ArvDomNodeChildList @ {self:p}"))
1735 .finish()
1736 }
1737}
1738
1739#[derive(Copy, Clone)]
1740#[repr(C)]
1741pub struct ArvDomNodeList {
1742 pub parent_instance: gobject::GObject,
1743}
1744
1745impl ::std::fmt::Debug for ArvDomNodeList {
1746 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1747 f.debug_struct(&format!("ArvDomNodeList @ {self:p}"))
1748 .field("parent_instance", &self.parent_instance)
1749 .finish()
1750 }
1751}
1752
1753#[derive(Copy, Clone)]
1754#[repr(C)]
1755pub struct ArvDomText {
1756 pub parent_instance: ArvDomCharacterData,
1757}
1758
1759impl ::std::fmt::Debug for ArvDomText {
1760 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1761 f.debug_struct(&format!("ArvDomText @ {self:p}"))
1762 .field("parent_instance", &self.parent_instance)
1763 .finish()
1764 }
1765}
1766
1767#[repr(C)]
1768pub struct ArvEvaluator {
1769 _data: [u8; 0],
1770 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1771}
1772
1773impl ::std::fmt::Debug for ArvEvaluator {
1774 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1775 f.debug_struct(&format!("ArvEvaluator @ {self:p}")).finish()
1776 }
1777}
1778
1779#[repr(C)]
1780pub struct ArvFakeCamera {
1781 _data: [u8; 0],
1782 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1783}
1784
1785impl ::std::fmt::Debug for ArvFakeCamera {
1786 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1787 f.debug_struct(&format!("ArvFakeCamera @ {self:p}"))
1788 .finish()
1789 }
1790}
1791
1792#[repr(C)]
1793pub struct ArvFakeDevice {
1794 _data: [u8; 0],
1795 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1796}
1797
1798impl ::std::fmt::Debug for ArvFakeDevice {
1799 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1800 f.debug_struct(&format!("ArvFakeDevice @ {self:p}"))
1801 .finish()
1802 }
1803}
1804
1805#[repr(C)]
1806pub struct ArvFakeInterface {
1807 _data: [u8; 0],
1808 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1809}
1810
1811impl ::std::fmt::Debug for ArvFakeInterface {
1812 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1813 f.debug_struct(&format!("ArvFakeInterface @ {self:p}"))
1814 .finish()
1815 }
1816}
1817
1818#[repr(C)]
1819pub struct ArvFakeStream {
1820 _data: [u8; 0],
1821 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1822}
1823
1824impl ::std::fmt::Debug for ArvFakeStream {
1825 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1826 f.debug_struct(&format!("ArvFakeStream @ {self:p}"))
1827 .finish()
1828 }
1829}
1830
1831#[repr(C)]
1832pub struct ArvGc {
1833 _data: [u8; 0],
1834 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1835}
1836
1837impl ::std::fmt::Debug for ArvGc {
1838 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1839 f.debug_struct(&format!("ArvGc @ {self:p}")).finish()
1840 }
1841}
1842
1843#[repr(C)]
1844pub struct ArvGcBoolean {
1845 _data: [u8; 0],
1846 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1847}
1848
1849impl ::std::fmt::Debug for ArvGcBoolean {
1850 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1851 f.debug_struct(&format!("ArvGcBoolean @ {self:p}")).finish()
1852 }
1853}
1854
1855#[repr(C)]
1856pub struct ArvGcCategory {
1857 _data: [u8; 0],
1858 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1859}
1860
1861impl ::std::fmt::Debug for ArvGcCategory {
1862 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1863 f.debug_struct(&format!("ArvGcCategory @ {self:p}"))
1864 .finish()
1865 }
1866}
1867
1868#[repr(C)]
1869pub struct ArvGcCommand {
1870 _data: [u8; 0],
1871 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1872}
1873
1874impl ::std::fmt::Debug for ArvGcCommand {
1875 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1876 f.debug_struct(&format!("ArvGcCommand @ {self:p}")).finish()
1877 }
1878}
1879
1880#[derive(Copy, Clone)]
1881#[repr(C)]
1882pub struct ArvGcConverter {
1883 pub parent_instance: ArvGcFeatureNode,
1884}
1885
1886impl ::std::fmt::Debug for ArvGcConverter {
1887 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1888 f.debug_struct(&format!("ArvGcConverter @ {self:p}"))
1889 .field("parent_instance", &self.parent_instance)
1890 .finish()
1891 }
1892}
1893
1894#[repr(C)]
1895pub struct ArvGcConverterNode {
1896 _data: [u8; 0],
1897 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1898}
1899
1900impl ::std::fmt::Debug for ArvGcConverterNode {
1901 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1902 f.debug_struct(&format!("ArvGcConverterNode @ {self:p}"))
1903 .finish()
1904 }
1905}
1906
1907#[repr(C)]
1908pub struct ArvGcEnumEntry {
1909 _data: [u8; 0],
1910 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1911}
1912
1913impl ::std::fmt::Debug for ArvGcEnumEntry {
1914 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1915 f.debug_struct(&format!("ArvGcEnumEntry @ {self:p}"))
1916 .finish()
1917 }
1918}
1919
1920#[repr(C)]
1921pub struct ArvGcEnumeration {
1922 _data: [u8; 0],
1923 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1924}
1925
1926impl ::std::fmt::Debug for ArvGcEnumeration {
1927 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1928 f.debug_struct(&format!("ArvGcEnumeration @ {self:p}"))
1929 .finish()
1930 }
1931}
1932
1933#[derive(Copy, Clone)]
1934#[repr(C)]
1935pub struct ArvGcFeatureNode {
1936 pub parent_instance: ArvGcNode,
1937}
1938
1939impl ::std::fmt::Debug for ArvGcFeatureNode {
1940 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1941 f.debug_struct(&format!("ArvGcFeatureNode @ {self:p}"))
1942 .field("parent_instance", &self.parent_instance)
1943 .finish()
1944 }
1945}
1946
1947#[repr(C)]
1948pub struct ArvGcFloatNode {
1949 _data: [u8; 0],
1950 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1951}
1952
1953impl ::std::fmt::Debug for ArvGcFloatNode {
1954 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1955 f.debug_struct(&format!("ArvGcFloatNode @ {self:p}"))
1956 .finish()
1957 }
1958}
1959
1960#[derive(Copy, Clone)]
1961#[repr(C)]
1962pub struct ArvGcFloatRegNode {
1963 pub parent_instance: ArvGcRegisterNode,
1964}
1965
1966impl ::std::fmt::Debug for ArvGcFloatRegNode {
1967 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1968 f.debug_struct(&format!("ArvGcFloatRegNode @ {self:p}"))
1969 .field("parent_instance", &self.parent_instance)
1970 .finish()
1971 }
1972}
1973
1974#[repr(C)]
1975pub struct ArvGcGroupNode {
1976 _data: [u8; 0],
1977 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1978}
1979
1980impl ::std::fmt::Debug for ArvGcGroupNode {
1981 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1982 f.debug_struct(&format!("ArvGcGroupNode @ {self:p}"))
1983 .finish()
1984 }
1985}
1986
1987#[repr(C)]
1988pub struct ArvGcIndexNode {
1989 _data: [u8; 0],
1990 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1991}
1992
1993impl ::std::fmt::Debug for ArvGcIndexNode {
1994 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1995 f.debug_struct(&format!("ArvGcIndexNode @ {self:p}"))
1996 .finish()
1997 }
1998}
1999
2000#[repr(C)]
2001pub struct ArvGcIntConverterNode {
2002 _data: [u8; 0],
2003 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2004}
2005
2006impl ::std::fmt::Debug for ArvGcIntConverterNode {
2007 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2008 f.debug_struct(&format!("ArvGcIntConverterNode @ {self:p}"))
2009 .finish()
2010 }
2011}
2012
2013#[derive(Copy, Clone)]
2014#[repr(C)]
2015pub struct ArvGcIntRegNode {
2016 pub parent_instance: ArvGcRegisterNode,
2017}
2018
2019impl ::std::fmt::Debug for ArvGcIntRegNode {
2020 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2021 f.debug_struct(&format!("ArvGcIntRegNode @ {self:p}"))
2022 .field("parent_instance", &self.parent_instance)
2023 .finish()
2024 }
2025}
2026
2027#[derive(Copy, Clone)]
2028#[repr(C)]
2029pub struct ArvGcIntSwissKnifeNode {
2030 pub parent_instance: ArvGcSwissKnife,
2031}
2032
2033impl ::std::fmt::Debug for ArvGcIntSwissKnifeNode {
2034 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2035 f.debug_struct(&format!("ArvGcIntSwissKnifeNode @ {self:p}"))
2036 .field("parent_instance", &self.parent_instance)
2037 .finish()
2038 }
2039}
2040
2041#[repr(C)]
2042pub struct ArvGcIntegerNode {
2043 _data: [u8; 0],
2044 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2045}
2046
2047impl ::std::fmt::Debug for ArvGcIntegerNode {
2048 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2049 f.debug_struct(&format!("ArvGcIntegerNode @ {self:p}"))
2050 .finish()
2051 }
2052}
2053
2054#[repr(C)]
2055pub struct ArvGcInvalidatorNode {
2056 _data: [u8; 0],
2057 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2058}
2059
2060impl ::std::fmt::Debug for ArvGcInvalidatorNode {
2061 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2062 f.debug_struct(&format!("ArvGcInvalidatorNode @ {self:p}"))
2063 .finish()
2064 }
2065}
2066
2067#[derive(Copy, Clone)]
2068#[repr(C)]
2069pub struct ArvGcMaskedIntRegNode {
2070 pub parent_instance: ArvGcRegisterNode,
2071}
2072
2073impl ::std::fmt::Debug for ArvGcMaskedIntRegNode {
2074 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2075 f.debug_struct(&format!("ArvGcMaskedIntRegNode @ {self:p}"))
2076 .field("parent_instance", &self.parent_instance)
2077 .finish()
2078 }
2079}
2080
2081#[derive(Copy, Clone)]
2082#[repr(C)]
2083pub struct ArvGcNode {
2084 pub parent_instance: ArvDomElement,
2085}
2086
2087impl ::std::fmt::Debug for ArvGcNode {
2088 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2089 f.debug_struct(&format!("ArvGcNode @ {self:p}"))
2090 .field("parent_instance", &self.parent_instance)
2091 .finish()
2092 }
2093}
2094
2095#[repr(C)]
2096pub struct ArvGcPort {
2097 _data: [u8; 0],
2098 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2099}
2100
2101impl ::std::fmt::Debug for ArvGcPort {
2102 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2103 f.debug_struct(&format!("ArvGcPort @ {self:p}")).finish()
2104 }
2105}
2106
2107#[derive(Copy, Clone)]
2108#[repr(C)]
2109pub struct ArvGcPropertyNode {
2110 pub parent_instance: ArvGcNode,
2111}
2112
2113impl ::std::fmt::Debug for ArvGcPropertyNode {
2114 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2115 f.debug_struct(&format!("ArvGcPropertyNode @ {self:p}"))
2116 .field("parent_instance", &self.parent_instance)
2117 .finish()
2118 }
2119}
2120
2121#[repr(C)]
2122pub struct ArvGcRegisterDescriptionNode {
2123 _data: [u8; 0],
2124 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2125}
2126
2127impl ::std::fmt::Debug for ArvGcRegisterDescriptionNode {
2128 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2129 f.debug_struct(&format!("ArvGcRegisterDescriptionNode @ {self:p}"))
2130 .finish()
2131 }
2132}
2133
2134#[derive(Copy, Clone)]
2135#[repr(C)]
2136pub struct ArvGcRegisterNode {
2137 pub parent_instance: ArvGcFeatureNode,
2138}
2139
2140impl ::std::fmt::Debug for ArvGcRegisterNode {
2141 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2142 f.debug_struct(&format!("ArvGcRegisterNode @ {self:p}"))
2143 .field("parent_instance", &self.parent_instance)
2144 .finish()
2145 }
2146}
2147
2148#[repr(C)]
2149pub struct ArvGcStringNode {
2150 _data: [u8; 0],
2151 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2152}
2153
2154impl ::std::fmt::Debug for ArvGcStringNode {
2155 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2156 f.debug_struct(&format!("ArvGcStringNode @ {self:p}"))
2157 .finish()
2158 }
2159}
2160
2161#[derive(Copy, Clone)]
2162#[repr(C)]
2163pub struct ArvGcStringRegNode {
2164 pub parent_instance: ArvGcRegisterNode,
2165}
2166
2167impl ::std::fmt::Debug for ArvGcStringRegNode {
2168 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2169 f.debug_struct(&format!("ArvGcStringRegNode @ {self:p}"))
2170 .field("parent_instance", &self.parent_instance)
2171 .finish()
2172 }
2173}
2174
2175#[repr(C)]
2176pub struct ArvGcStructEntryNode {
2177 _data: [u8; 0],
2178 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2179}
2180
2181impl ::std::fmt::Debug for ArvGcStructEntryNode {
2182 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2183 f.debug_struct(&format!("ArvGcStructEntryNode @ {self:p}"))
2184 .finish()
2185 }
2186}
2187
2188#[derive(Copy, Clone)]
2189#[repr(C)]
2190pub struct ArvGcStructRegNode {
2191 pub parent_instance: ArvGcRegisterNode,
2192}
2193
2194impl ::std::fmt::Debug for ArvGcStructRegNode {
2195 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2196 f.debug_struct(&format!("ArvGcStructRegNode @ {self:p}"))
2197 .field("parent_instance", &self.parent_instance)
2198 .finish()
2199 }
2200}
2201
2202#[derive(Copy, Clone)]
2203#[repr(C)]
2204pub struct ArvGcSwissKnife {
2205 pub parent_instance: ArvGcFeatureNode,
2206}
2207
2208impl ::std::fmt::Debug for ArvGcSwissKnife {
2209 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2210 f.debug_struct(&format!("ArvGcSwissKnife @ {self:p}"))
2211 .field("parent_instance", &self.parent_instance)
2212 .finish()
2213 }
2214}
2215
2216#[derive(Copy, Clone)]
2217#[repr(C)]
2218pub struct ArvGcSwissKnifeNode {
2219 pub parent_instance: ArvGcSwissKnife,
2220}
2221
2222impl ::std::fmt::Debug for ArvGcSwissKnifeNode {
2223 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2224 f.debug_struct(&format!("ArvGcSwissKnifeNode @ {self:p}"))
2225 .field("parent_instance", &self.parent_instance)
2226 .finish()
2227 }
2228}
2229
2230#[repr(C)]
2231pub struct ArvGcValueIndexedNode {
2232 _data: [u8; 0],
2233 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2234}
2235
2236impl ::std::fmt::Debug for ArvGcValueIndexedNode {
2237 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2238 f.debug_struct(&format!("ArvGcValueIndexedNode @ {self:p}"))
2239 .finish()
2240 }
2241}
2242
2243#[repr(C)]
2244pub struct ArvGvDevice {
2245 _data: [u8; 0],
2246 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2247}
2248
2249impl ::std::fmt::Debug for ArvGvDevice {
2250 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2251 f.debug_struct(&format!("ArvGvDevice @ {self:p}")).finish()
2252 }
2253}
2254
2255#[repr(C)]
2256pub struct ArvGvFakeCamera {
2257 _data: [u8; 0],
2258 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2259}
2260
2261impl ::std::fmt::Debug for ArvGvFakeCamera {
2262 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2263 f.debug_struct(&format!("ArvGvFakeCamera @ {self:p}"))
2264 .finish()
2265 }
2266}
2267
2268#[repr(C)]
2269pub struct ArvGvInterface {
2270 _data: [u8; 0],
2271 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2272}
2273
2274impl ::std::fmt::Debug for ArvGvInterface {
2275 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2276 f.debug_struct(&format!("ArvGvInterface @ {self:p}"))
2277 .finish()
2278 }
2279}
2280
2281#[repr(C)]
2282pub struct ArvGvStream {
2283 _data: [u8; 0],
2284 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2285}
2286
2287impl ::std::fmt::Debug for ArvGvStream {
2288 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2289 f.debug_struct(&format!("ArvGvStream @ {self:p}")).finish()
2290 }
2291}
2292
2293#[derive(Copy, Clone)]
2294#[repr(C)]
2295pub struct ArvInterface {
2296 pub parent_instance: gobject::GObject,
2297}
2298
2299impl ::std::fmt::Debug for ArvInterface {
2300 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2301 f.debug_struct(&format!("ArvInterface @ {self:p}"))
2302 .field("parent_instance", &self.parent_instance)
2303 .finish()
2304 }
2305}
2306
2307#[derive(Copy, Clone)]
2308#[repr(C)]
2309pub struct ArvStream {
2310 pub parent_instance: gobject::GObject,
2311}
2312
2313impl ::std::fmt::Debug for ArvStream {
2314 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2315 f.debug_struct(&format!("ArvStream @ {self:p}"))
2316 .field("parent_instance", &self.parent_instance)
2317 .finish()
2318 }
2319}
2320
2321#[repr(C)]
2322pub struct ArvUvDevice {
2323 _data: [u8; 0],
2324 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2325}
2326
2327impl ::std::fmt::Debug for ArvUvDevice {
2328 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2329 f.debug_struct(&format!("ArvUvDevice @ {self:p}")).finish()
2330 }
2331}
2332
2333#[repr(C)]
2334pub struct ArvUvInterface {
2335 _data: [u8; 0],
2336 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2337}
2338
2339impl ::std::fmt::Debug for ArvUvInterface {
2340 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2341 f.debug_struct(&format!("ArvUvInterface @ {self:p}"))
2342 .finish()
2343 }
2344}
2345
2346#[repr(C)]
2347pub struct ArvUvStream {
2348 _data: [u8; 0],
2349 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2350}
2351
2352impl ::std::fmt::Debug for ArvUvStream {
2353 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2354 f.debug_struct(&format!("ArvUvStream @ {self:p}")).finish()
2355 }
2356}
2357
2358#[repr(C)]
2359pub struct ArvXmlSchema {
2360 _data: [u8; 0],
2361 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2362}
2363
2364impl ::std::fmt::Debug for ArvXmlSchema {
2365 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2366 f.debug_struct(&format!("ArvXmlSchema @ {self:p}")).finish()
2367 }
2368}
2369
2370#[repr(C)]
2372pub struct ArvGcFloat {
2373 _data: [u8; 0],
2374 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2375}
2376
2377impl ::std::fmt::Debug for ArvGcFloat {
2378 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2379 write!(f, "ArvGcFloat @ {self:p}")
2380 }
2381}
2382
2383#[repr(C)]
2384pub struct ArvGcInteger {
2385 _data: [u8; 0],
2386 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2387}
2388
2389impl ::std::fmt::Debug for ArvGcInteger {
2390 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2391 write!(f, "ArvGcInteger @ {self:p}")
2392 }
2393}
2394
2395#[repr(C)]
2396pub struct ArvGcRegister {
2397 _data: [u8; 0],
2398 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2399}
2400
2401impl ::std::fmt::Debug for ArvGcRegister {
2402 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2403 write!(f, "ArvGcRegister @ {self:p}")
2404 }
2405}
2406
2407#[repr(C)]
2408pub struct ArvGcSelector {
2409 _data: [u8; 0],
2410 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2411}
2412
2413impl ::std::fmt::Debug for ArvGcSelector {
2414 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2415 write!(f, "ArvGcSelector @ {self:p}")
2416 }
2417}
2418
2419#[repr(C)]
2420pub struct ArvGcString {
2421 _data: [u8; 0],
2422 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
2423}
2424
2425impl ::std::fmt::Debug for ArvGcString {
2426 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2427 write!(f, "ArvGcString @ {self:p}")
2428 }
2429}
2430
2431#[link(name = "aravis-0.8")]
2432extern "C" {
2433
2434 #[cfg(feature = "v0_8_6")]
2438 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_6")))]
2439 pub fn arv_access_check_policy_get_type() -> GType;
2440
2441 pub fn arv_acquisition_mode_get_type() -> GType;
2445 pub fn arv_acquisition_mode_from_string(string: *const c_char) -> ArvAcquisitionMode;
2446 pub fn arv_acquisition_mode_to_string(value: ArvAcquisitionMode) -> *const c_char;
2447
2448 pub fn arv_auto_get_type() -> GType;
2452 pub fn arv_auto_from_string(string: *const c_char) -> ArvAuto;
2453 pub fn arv_auto_to_string(value: ArvAuto) -> *const c_char;
2454
2455 pub fn arv_buffer_part_data_type_get_type() -> GType;
2459
2460 pub fn arv_buffer_payload_type_get_type() -> GType;
2464
2465 pub fn arv_buffer_status_get_type() -> GType;
2469
2470 pub fn arv_chunk_parser_error_get_type() -> GType;
2474 pub fn arv_chunk_parser_error_quark() -> glib::GQuark;
2475
2476 pub fn arv_component_selection_flags_get_type() -> GType;
2480
2481 pub fn arv_device_error_get_type() -> GType;
2485 pub fn arv_device_error_quark() -> glib::GQuark;
2486
2487 pub fn arv_dom_node_type_get_type() -> GType;
2491
2492 pub fn arv_exposure_mode_get_type() -> GType;
2496 pub fn arv_exposure_mode_from_string(string: *const c_char) -> ArvExposureMode;
2497 pub fn arv_exposure_mode_to_string(value: ArvExposureMode) -> *const c_char;
2498
2499 pub fn arv_gc_access_mode_get_type() -> GType;
2503 pub fn arv_gc_access_mode_from_string(string: *const c_char) -> ArvGcAccessMode;
2504 pub fn arv_gc_access_mode_to_string(value: ArvGcAccessMode) -> *const c_char;
2505
2506 pub fn arv_gc_cachable_get_type() -> GType;
2510
2511 pub fn arv_gc_display_notation_get_type() -> GType;
2515
2516 pub fn arv_gc_error_get_type() -> GType;
2520 pub fn arv_gc_error_quark() -> glib::GQuark;
2521
2522 pub fn arv_gc_is_linear_get_type() -> GType;
2526
2527 pub fn arv_gc_name_space_get_type() -> GType;
2531
2532 pub fn arv_gc_property_node_type_get_type() -> GType;
2536
2537 pub fn arv_gc_representation_get_type() -> GType;
2541
2542 pub fn arv_gc_signedness_get_type() -> GType;
2546
2547 #[cfg(feature = "v0_8_8")]
2551 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_8")))]
2552 pub fn arv_gc_streamable_get_type() -> GType;
2553
2554 pub fn arv_gc_visibility_get_type() -> GType;
2558
2559 pub fn arv_gv_ip_configuration_mode_get_type() -> GType;
2563
2564 pub fn arv_gv_packet_size_adjustment_get_type() -> GType;
2568
2569 pub fn arv_gv_stream_packet_resend_get_type() -> GType;
2573
2574 pub fn arv_gv_stream_socket_buffer_get_type() -> GType;
2578
2579 #[cfg(feature = "v0_8_6")]
2583 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_6")))]
2584 pub fn arv_range_check_policy_get_type() -> GType;
2585
2586 pub fn arv_register_cache_policy_get_type() -> GType;
2590
2591 pub fn arv_stream_callback_type_get_type() -> GType;
2595
2596 pub fn arv_uv_usb_mode_get_type() -> GType;
2600
2601 pub fn arv_xml_schema_error_get_type() -> GType;
2605 pub fn arv_xml_schema_error_quark() -> glib::GQuark;
2606
2607 #[cfg(feature = "v0_8_23")]
2611 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_23")))]
2612 pub fn arv_gv_interface_flags_get_type() -> GType;
2613
2614 pub fn arv_gv_stream_option_get_type() -> GType;
2618
2619 pub fn arv_buffer_get_type() -> GType;
2623 pub fn arv_buffer_new(size: size_t, preallocated: *mut c_void) -> *mut ArvBuffer;
2624 pub fn arv_buffer_new_allocate(size: size_t) -> *mut ArvBuffer;
2625 pub fn arv_buffer_new_full(
2626 size: size_t,
2627 preallocated: *mut c_void,
2628 user_data: *mut c_void,
2629 user_data_destroy_func: glib::GDestroyNotify,
2630 ) -> *mut ArvBuffer;
2631 #[cfg(feature = "v0_8_25")]
2632 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_25")))]
2633 pub fn arv_buffer_find_component(buffer: *mut ArvBuffer, component_id: c_uint) -> c_int;
2634 pub fn arv_buffer_get_chunk_data(
2635 buffer: *mut ArvBuffer,
2636 chunk_id: u64,
2637 size: *mut size_t,
2638 ) -> *mut u8;
2639 pub fn arv_buffer_get_data(buffer: *mut ArvBuffer, size: *mut size_t) -> *mut u8;
2640 pub fn arv_buffer_get_frame_id(buffer: *mut ArvBuffer) -> u64;
2641 #[cfg(feature = "v0_8_31")]
2642 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_31")))]
2643 pub fn arv_buffer_get_gendc_data(buffer: *mut ArvBuffer, size: *mut size_t) -> *mut u8;
2644 #[cfg(feature = "v0_8_31")]
2645 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_31")))]
2646 pub fn arv_buffer_get_gendc_descriptor(buffer: *mut ArvBuffer, size: *mut size_t) -> *mut u8;
2647 #[cfg(feature = "v0_8_25")]
2648 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_25")))]
2649 pub fn arv_buffer_get_image_data(buffer: *mut ArvBuffer, size: *mut size_t) -> *mut u8;
2650 pub fn arv_buffer_get_image_height(buffer: *mut ArvBuffer) -> c_int;
2651 #[cfg(feature = "v0_8_23")]
2652 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_23")))]
2653 pub fn arv_buffer_get_image_padding(
2654 buffer: *mut ArvBuffer,
2655 x_padding: *mut c_int,
2656 y_padding: *mut c_int,
2657 );
2658 pub fn arv_buffer_get_image_pixel_format(buffer: *mut ArvBuffer) -> ArvPixelFormat;
2659 pub fn arv_buffer_get_image_region(
2660 buffer: *mut ArvBuffer,
2661 x: *mut c_int,
2662 y: *mut c_int,
2663 width: *mut c_int,
2664 height: *mut c_int,
2665 );
2666 pub fn arv_buffer_get_image_width(buffer: *mut ArvBuffer) -> c_int;
2667 pub fn arv_buffer_get_image_x(buffer: *mut ArvBuffer) -> c_int;
2668 pub fn arv_buffer_get_image_y(buffer: *mut ArvBuffer) -> c_int;
2669 #[cfg(feature = "v0_8_23")]
2670 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_23")))]
2671 pub fn arv_buffer_get_n_parts(buffer: *mut ArvBuffer) -> c_uint;
2672 #[cfg(feature = "v0_8_25")]
2673 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_25")))]
2674 pub fn arv_buffer_get_part_component_id(buffer: *mut ArvBuffer, part_id: c_uint) -> c_uint;
2675 #[cfg(feature = "v0_8_23")]
2676 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_23")))]
2677 pub fn arv_buffer_get_part_data(
2678 buffer: *mut ArvBuffer,
2679 part_id: c_uint,
2680 size: *mut size_t,
2681 ) -> *mut u8;
2682 #[cfg(feature = "v0_8_23")]
2683 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_23")))]
2684 pub fn arv_buffer_get_part_data_type(
2685 buffer: *mut ArvBuffer,
2686 part_id: c_uint,
2687 ) -> ArvBufferPartDataType;
2688 #[cfg(feature = "v0_8_23")]
2689 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_23")))]
2690 pub fn arv_buffer_get_part_height(buffer: *mut ArvBuffer, part_id: c_uint) -> c_int;
2691 #[cfg(feature = "v0_8_23")]
2692 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_23")))]
2693 pub fn arv_buffer_get_part_padding(
2694 buffer: *mut ArvBuffer,
2695 part_id: c_uint,
2696 x_padding: *mut c_int,
2697 y_padding: *mut c_int,
2698 );
2699 #[cfg(feature = "v0_8_23")]
2700 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_23")))]
2701 pub fn arv_buffer_get_part_pixel_format(
2702 buffer: *mut ArvBuffer,
2703 part_id: c_uint,
2704 ) -> ArvPixelFormat;
2705 #[cfg(feature = "v0_8_23")]
2706 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_23")))]
2707 pub fn arv_buffer_get_part_region(
2708 buffer: *mut ArvBuffer,
2709 part_id: c_uint,
2710 x: *mut c_int,
2711 y: *mut c_int,
2712 width: *mut c_int,
2713 height: *mut c_int,
2714 );
2715 #[cfg(feature = "v0_8_23")]
2716 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_23")))]
2717 pub fn arv_buffer_get_part_width(buffer: *mut ArvBuffer, part_id: c_uint) -> c_int;
2718 #[cfg(feature = "v0_8_23")]
2719 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_23")))]
2720 pub fn arv_buffer_get_part_x(buffer: *mut ArvBuffer, part_id: c_uint) -> c_int;
2721 #[cfg(feature = "v0_8_23")]
2722 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_23")))]
2723 pub fn arv_buffer_get_part_y(buffer: *mut ArvBuffer, part_id: c_uint) -> c_int;
2724 pub fn arv_buffer_get_payload_type(buffer: *mut ArvBuffer) -> ArvBufferPayloadType;
2725 pub fn arv_buffer_get_status(buffer: *mut ArvBuffer) -> ArvBufferStatus;
2726 pub fn arv_buffer_get_system_timestamp(buffer: *mut ArvBuffer) -> u64;
2727 pub fn arv_buffer_get_timestamp(buffer: *mut ArvBuffer) -> u64;
2728 pub fn arv_buffer_get_user_data(buffer: *mut ArvBuffer) -> *mut c_void;
2729 pub fn arv_buffer_has_chunks(buffer: *mut ArvBuffer) -> gboolean;
2730 #[cfg(feature = "v0_8_31")]
2731 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_31")))]
2732 pub fn arv_buffer_has_gendc(buffer: *mut ArvBuffer) -> gboolean;
2733 #[cfg(feature = "v0_8_3")]
2734 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_3")))]
2735 pub fn arv_buffer_set_frame_id(buffer: *mut ArvBuffer, frame_id: u64);
2736 pub fn arv_buffer_set_system_timestamp(buffer: *mut ArvBuffer, timestamp_ns: u64);
2737 pub fn arv_buffer_set_timestamp(buffer: *mut ArvBuffer, timestamp_ns: u64);
2738
2739 pub fn arv_camera_get_type() -> GType;
2743 pub fn arv_camera_new(name: *const c_char, error: *mut *mut glib::GError) -> *mut ArvCamera;
2744 #[cfg(feature = "v0_8_6")]
2745 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_6")))]
2746 pub fn arv_camera_new_with_device(
2747 device: *mut ArvDevice,
2748 error: *mut *mut glib::GError,
2749 ) -> *mut ArvCamera;
2750 pub fn arv_camera_abort_acquisition(camera: *mut ArvCamera, error: *mut *mut glib::GError);
2751 pub fn arv_camera_acquisition(
2752 camera: *mut ArvCamera,
2753 timeout: u64,
2754 error: *mut *mut glib::GError,
2755 ) -> *mut ArvBuffer;
2756 #[cfg(feature = "v0_8_8")]
2757 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_8")))]
2758 pub fn arv_camera_are_chunks_available(
2759 camera: *mut ArvCamera,
2760 error: *mut *mut glib::GError,
2761 ) -> gboolean;
2762 pub fn arv_camera_clear_triggers(camera: *mut ArvCamera, error: *mut *mut glib::GError);
2763 pub fn arv_camera_create_chunk_parser(camera: *mut ArvCamera) -> *mut ArvChunkParser;
2764 pub fn arv_camera_create_stream(
2765 camera: *mut ArvCamera,
2766 callback: ArvStreamCallback,
2767 user_data: *mut c_void,
2768 error: *mut *mut glib::GError,
2769 ) -> *mut ArvStream;
2770 #[cfg(feature = "v0_8_23")]
2771 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_23")))]
2772 pub fn arv_camera_create_stream_full(
2773 camera: *mut ArvCamera,
2774 callback: ArvStreamCallback,
2775 user_data: *mut c_void,
2776 destroy: glib::GDestroyNotify,
2777 error: *mut *mut glib::GError,
2778 ) -> *mut ArvStream;
2779 #[cfg(feature = "v0_8_27")]
2780 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_27")))]
2781 pub fn arv_camera_dup_available_black_levels(
2782 camera: *mut ArvCamera,
2783 n_selectors: *mut c_uint,
2784 error: *mut *mut glib::GError,
2785 ) -> *mut *const c_char;
2786 #[cfg(feature = "v0_8_23")]
2787 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_23")))]
2788 pub fn arv_camera_dup_available_components(
2789 camera: *mut ArvCamera,
2790 n_components: *mut c_uint,
2791 error: *mut *mut glib::GError,
2792 ) -> *mut *const c_char;
2793 pub fn arv_camera_dup_available_enumerations(
2794 camera: *mut ArvCamera,
2795 feature: *const c_char,
2796 n_values: *mut c_uint,
2797 error: *mut *mut glib::GError,
2798 ) -> *mut i64;
2799 pub fn arv_camera_dup_available_enumerations_as_display_names(
2800 camera: *mut ArvCamera,
2801 feature: *const c_char,
2802 n_values: *mut c_uint,
2803 error: *mut *mut glib::GError,
2804 ) -> *mut *const c_char;
2805 pub fn arv_camera_dup_available_enumerations_as_strings(
2806 camera: *mut ArvCamera,
2807 feature: *const c_char,
2808 n_values: *mut c_uint,
2809 error: *mut *mut glib::GError,
2810 ) -> *mut *const c_char;
2811 #[cfg(feature = "v0_8_27")]
2812 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_27")))]
2813 pub fn arv_camera_dup_available_gains(
2814 camera: *mut ArvCamera,
2815 n_selectors: *mut c_uint,
2816 error: *mut *mut glib::GError,
2817 ) -> *mut *const c_char;
2818 pub fn arv_camera_dup_available_pixel_formats(
2819 camera: *mut ArvCamera,
2820 n_pixel_formats: *mut c_uint,
2821 error: *mut *mut glib::GError,
2822 ) -> *mut i64;
2823 pub fn arv_camera_dup_available_pixel_formats_as_display_names(
2824 camera: *mut ArvCamera,
2825 n_pixel_formats: *mut c_uint,
2826 error: *mut *mut glib::GError,
2827 ) -> *mut *const c_char;
2828 pub fn arv_camera_dup_available_pixel_formats_as_strings(
2829 camera: *mut ArvCamera,
2830 n_pixel_formats: *mut c_uint,
2831 error: *mut *mut glib::GError,
2832 ) -> *mut *const c_char;
2833 pub fn arv_camera_dup_available_trigger_sources(
2834 camera: *mut ArvCamera,
2835 n_sources: *mut c_uint,
2836 error: *mut *mut glib::GError,
2837 ) -> *mut *const c_char;
2838 pub fn arv_camera_dup_available_triggers(
2839 camera: *mut ArvCamera,
2840 n_triggers: *mut c_uint,
2841 error: *mut *mut glib::GError,
2842 ) -> *mut *const c_char;
2843 #[cfg(feature = "v0_8_31")]
2844 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_31")))]
2845 pub fn arv_camera_dup_register(
2846 camera: *mut ArvCamera,
2847 feature: *const c_char,
2848 length: *mut u64,
2849 error: *mut *mut glib::GError,
2850 ) -> *mut c_void;
2851 pub fn arv_camera_execute_command(
2852 camera: *mut ArvCamera,
2853 feature: *const c_char,
2854 error: *mut *mut glib::GError,
2855 );
2856 pub fn arv_camera_get_acquisition_mode(
2857 camera: *mut ArvCamera,
2858 error: *mut *mut glib::GError,
2859 ) -> ArvAcquisitionMode;
2860 pub fn arv_camera_get_binning(
2861 camera: *mut ArvCamera,
2862 dx: *mut c_int,
2863 dy: *mut c_int,
2864 error: *mut *mut glib::GError,
2865 );
2866 #[cfg(feature = "v0_8_19")]
2867 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_19")))]
2868 pub fn arv_camera_get_black_level(
2869 camera: *mut ArvCamera,
2870 error: *mut *mut glib::GError,
2871 ) -> c_double;
2872 #[cfg(feature = "v0_8_19")]
2873 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_19")))]
2874 pub fn arv_camera_get_black_level_auto(
2875 camera: *mut ArvCamera,
2876 error: *mut *mut glib::GError,
2877 ) -> ArvAuto;
2878 #[cfg(feature = "v0_8_19")]
2879 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_19")))]
2880 pub fn arv_camera_get_black_level_bounds(
2881 camera: *mut ArvCamera,
2882 min: *mut c_double,
2883 max: *mut c_double,
2884 error: *mut *mut glib::GError,
2885 );
2886 pub fn arv_camera_get_boolean(
2887 camera: *mut ArvCamera,
2888 feature: *const c_char,
2889 error: *mut *mut glib::GError,
2890 ) -> gboolean;
2891 pub fn arv_camera_get_boolean_gi(
2892 camera: *mut ArvCamera,
2893 feature: *const c_char,
2894 value: *mut gboolean,
2895 error: *mut *mut glib::GError,
2896 );
2897 pub fn arv_camera_get_chunk_mode(
2898 camera: *mut ArvCamera,
2899 error: *mut *mut glib::GError,
2900 ) -> gboolean;
2901 pub fn arv_camera_get_chunk_state(
2902 camera: *mut ArvCamera,
2903 chunk: *const c_char,
2904 error: *mut *mut glib::GError,
2905 ) -> gboolean;
2906 pub fn arv_camera_get_device(camera: *mut ArvCamera) -> *mut ArvDevice;
2907 pub fn arv_camera_get_device_id(
2908 camera: *mut ArvCamera,
2909 error: *mut *mut glib::GError,
2910 ) -> *const c_char;
2911 #[cfg(feature = "v0_8_8")]
2912 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_8")))]
2913 pub fn arv_camera_get_device_serial_number(
2914 camera: *mut ArvCamera,
2915 error: *mut *mut glib::GError,
2916 ) -> *const c_char;
2917 pub fn arv_camera_get_exposure_time(
2918 camera: *mut ArvCamera,
2919 error: *mut *mut glib::GError,
2920 ) -> c_double;
2921 pub fn arv_camera_get_exposure_time_auto(
2922 camera: *mut ArvCamera,
2923 error: *mut *mut glib::GError,
2924 ) -> ArvAuto;
2925 pub fn arv_camera_get_exposure_time_bounds(
2926 camera: *mut ArvCamera,
2927 min: *mut c_double,
2928 max: *mut c_double,
2929 error: *mut *mut glib::GError,
2930 );
2931 #[cfg(feature = "v0_8_31")]
2932 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_31")))]
2933 pub fn arv_camera_get_exposure_time_representation(
2934 camera: *mut ArvCamera,
2935 ) -> ArvGcRepresentation;
2936 #[cfg(feature = "v0_8_31")]
2937 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_31")))]
2938 pub fn arv_camera_get_feature_representation(
2939 camera: *mut ArvCamera,
2940 feature: *const c_char,
2941 ) -> ArvGcRepresentation;
2942 pub fn arv_camera_get_float(
2943 camera: *mut ArvCamera,
2944 feature: *const c_char,
2945 error: *mut *mut glib::GError,
2946 ) -> c_double;
2947 pub fn arv_camera_get_float_bounds(
2948 camera: *mut ArvCamera,
2949 feature: *const c_char,
2950 min: *mut c_double,
2951 max: *mut c_double,
2952 error: *mut *mut glib::GError,
2953 );
2954 #[cfg(feature = "v0_8_16")]
2955 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_16")))]
2956 pub fn arv_camera_get_float_increment(
2957 camera: *mut ArvCamera,
2958 feature: *const c_char,
2959 error: *mut *mut glib::GError,
2960 ) -> c_double;
2961 pub fn arv_camera_get_frame_count(camera: *mut ArvCamera, error: *mut *mut glib::GError)
2962 -> i64;
2963 pub fn arv_camera_get_frame_count_bounds(
2964 camera: *mut ArvCamera,
2965 min: *mut i64,
2966 max: *mut i64,
2967 error: *mut *mut glib::GError,
2968 );
2969 pub fn arv_camera_get_frame_rate(
2970 camera: *mut ArvCamera,
2971 error: *mut *mut glib::GError,
2972 ) -> c_double;
2973 pub fn arv_camera_get_frame_rate_bounds(
2974 camera: *mut ArvCamera,
2975 min: *mut c_double,
2976 max: *mut c_double,
2977 error: *mut *mut glib::GError,
2978 );
2979 #[cfg(feature = "v0_8_31")]
2980 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_31")))]
2981 pub fn arv_camera_get_frame_rate_enable(
2982 camera: *mut ArvCamera,
2983 error: *mut *mut glib::GError,
2984 ) -> gboolean;
2985 pub fn arv_camera_get_gain(camera: *mut ArvCamera, error: *mut *mut glib::GError) -> c_double;
2986 pub fn arv_camera_get_gain_auto(
2987 camera: *mut ArvCamera,
2988 error: *mut *mut glib::GError,
2989 ) -> ArvAuto;
2990 pub fn arv_camera_get_gain_bounds(
2991 camera: *mut ArvCamera,
2992 min: *mut c_double,
2993 max: *mut c_double,
2994 error: *mut *mut glib::GError,
2995 );
2996 #[cfg(feature = "v0_8_31")]
2997 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_31")))]
2998 pub fn arv_camera_get_gain_representation(camera: *mut ArvCamera) -> ArvGcRepresentation;
2999 pub fn arv_camera_get_height_bounds(
3000 camera: *mut ArvCamera,
3001 min: *mut c_int,
3002 max: *mut c_int,
3003 error: *mut *mut glib::GError,
3004 );
3005 pub fn arv_camera_get_height_increment(
3006 camera: *mut ArvCamera,
3007 error: *mut *mut glib::GError,
3008 ) -> c_int;
3009 pub fn arv_camera_get_integer(
3010 camera: *mut ArvCamera,
3011 feature: *const c_char,
3012 error: *mut *mut glib::GError,
3013 ) -> i64;
3014 pub fn arv_camera_get_integer_bounds(
3015 camera: *mut ArvCamera,
3016 feature: *const c_char,
3017 min: *mut i64,
3018 max: *mut i64,
3019 error: *mut *mut glib::GError,
3020 );
3021 pub fn arv_camera_get_integer_increment(
3022 camera: *mut ArvCamera,
3023 feature: *const c_char,
3024 error: *mut *mut glib::GError,
3025 ) -> i64;
3026 pub fn arv_camera_get_model_name(
3027 camera: *mut ArvCamera,
3028 error: *mut *mut glib::GError,
3029 ) -> *const c_char;
3030 pub fn arv_camera_get_payload(camera: *mut ArvCamera, error: *mut *mut glib::GError) -> c_uint;
3031 pub fn arv_camera_get_pixel_format(
3032 camera: *mut ArvCamera,
3033 error: *mut *mut glib::GError,
3034 ) -> ArvPixelFormat;
3035 pub fn arv_camera_get_pixel_format_as_string(
3036 camera: *mut ArvCamera,
3037 error: *mut *mut glib::GError,
3038 ) -> *const c_char;
3039 pub fn arv_camera_get_region(
3040 camera: *mut ArvCamera,
3041 x: *mut c_int,
3042 y: *mut c_int,
3043 width: *mut c_int,
3044 height: *mut c_int,
3045 error: *mut *mut glib::GError,
3046 );
3047 pub fn arv_camera_get_sensor_size(
3048 camera: *mut ArvCamera,
3049 width: *mut c_int,
3050 height: *mut c_int,
3051 error: *mut *mut glib::GError,
3052 );
3053 pub fn arv_camera_get_string(
3054 camera: *mut ArvCamera,
3055 feature: *const c_char,
3056 error: *mut *mut glib::GError,
3057 ) -> *const c_char;
3058 pub fn arv_camera_get_trigger_source(
3059 camera: *mut ArvCamera,
3060 error: *mut *mut glib::GError,
3061 ) -> *const c_char;
3062 pub fn arv_camera_get_vendor_name(
3063 camera: *mut ArvCamera,
3064 error: *mut *mut glib::GError,
3065 ) -> *const c_char;
3066 pub fn arv_camera_get_width_bounds(
3067 camera: *mut ArvCamera,
3068 min: *mut c_int,
3069 max: *mut c_int,
3070 error: *mut *mut glib::GError,
3071 );
3072 pub fn arv_camera_get_width_increment(
3073 camera: *mut ArvCamera,
3074 error: *mut *mut glib::GError,
3075 ) -> c_int;
3076 pub fn arv_camera_get_x_binning_bounds(
3077 camera: *mut ArvCamera,
3078 min: *mut c_int,
3079 max: *mut c_int,
3080 error: *mut *mut glib::GError,
3081 );
3082 pub fn arv_camera_get_x_binning_increment(
3083 camera: *mut ArvCamera,
3084 error: *mut *mut glib::GError,
3085 ) -> c_int;
3086 pub fn arv_camera_get_x_offset_bounds(
3087 camera: *mut ArvCamera,
3088 min: *mut c_int,
3089 max: *mut c_int,
3090 error: *mut *mut glib::GError,
3091 );
3092 pub fn arv_camera_get_x_offset_increment(
3093 camera: *mut ArvCamera,
3094 error: *mut *mut glib::GError,
3095 ) -> c_int;
3096 pub fn arv_camera_get_y_binning_bounds(
3097 camera: *mut ArvCamera,
3098 min: *mut c_int,
3099 max: *mut c_int,
3100 error: *mut *mut glib::GError,
3101 );
3102 pub fn arv_camera_get_y_binning_increment(
3103 camera: *mut ArvCamera,
3104 error: *mut *mut glib::GError,
3105 ) -> c_int;
3106 pub fn arv_camera_get_y_offset_bounds(
3107 camera: *mut ArvCamera,
3108 min: *mut c_int,
3109 max: *mut c_int,
3110 error: *mut *mut glib::GError,
3111 );
3112 pub fn arv_camera_get_y_offset_increment(
3113 camera: *mut ArvCamera,
3114 error: *mut *mut glib::GError,
3115 ) -> c_int;
3116 pub fn arv_camera_gv_auto_packet_size(
3117 camera: *mut ArvCamera,
3118 error: *mut *mut glib::GError,
3119 ) -> c_uint;
3120 pub fn arv_camera_gv_get_current_stream_channel(
3121 camera: *mut ArvCamera,
3122 error: *mut *mut glib::GError,
3123 ) -> c_int;
3124 #[cfg(feature = "v0_8_22")]
3125 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_22")))]
3126 pub fn arv_camera_gv_get_ip_configuration_mode(
3127 camera: *mut ArvCamera,
3128 error: *mut *mut glib::GError,
3129 ) -> ArvGvIpConfigurationMode;
3130 #[cfg(feature = "v0_8_23")]
3131 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_23")))]
3132 pub fn arv_camera_gv_get_multipart(
3133 camera: *mut ArvCamera,
3134 error: *mut *mut glib::GError,
3135 ) -> gboolean;
3136 #[cfg(feature = "v0_8_25")]
3137 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_25")))]
3138 pub fn arv_camera_gv_get_n_network_interfaces(
3139 camera: *mut ArvCamera,
3140 error: *mut *mut glib::GError,
3141 ) -> c_int;
3142 pub fn arv_camera_gv_get_n_stream_channels(
3143 camera: *mut ArvCamera,
3144 error: *mut *mut glib::GError,
3145 ) -> c_int;
3146 pub fn arv_camera_gv_get_packet_delay(
3147 camera: *mut ArvCamera,
3148 error: *mut *mut glib::GError,
3149 ) -> i64;
3150 pub fn arv_camera_gv_get_packet_size(
3151 camera: *mut ArvCamera,
3152 error: *mut *mut glib::GError,
3153 ) -> c_uint;
3154 #[cfg(feature = "v0_8_22")]
3155 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_22")))]
3156 pub fn arv_camera_gv_get_persistent_ip(
3157 camera: *mut ArvCamera,
3158 ip: *mut *mut gio::GInetAddress,
3159 mask: *mut *mut gio::GInetAddressMask,
3160 gateway: *mut *mut gio::GInetAddress,
3161 error: *mut *mut glib::GError,
3162 );
3163 #[cfg(feature = "v0_8_23")]
3164 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_23")))]
3165 pub fn arv_camera_gv_is_multipart_supported(
3166 camera: *mut ArvCamera,
3167 error: *mut *mut glib::GError,
3168 ) -> gboolean;
3169 pub fn arv_camera_gv_select_stream_channel(
3170 camera: *mut ArvCamera,
3171 channel_id: c_int,
3172 error: *mut *mut glib::GError,
3173 );
3174 #[cfg(feature = "v0_8_22")]
3175 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_22")))]
3176 pub fn arv_camera_gv_set_ip_configuration_mode(
3177 camera: *mut ArvCamera,
3178 mode: ArvGvIpConfigurationMode,
3179 error: *mut *mut glib::GError,
3180 );
3181 #[cfg(feature = "v0_8_23")]
3182 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_23")))]
3183 pub fn arv_camera_gv_set_multipart(
3184 camera: *mut ArvCamera,
3185 enable: gboolean,
3186 error: *mut *mut glib::GError,
3187 );
3188 pub fn arv_camera_gv_set_packet_delay(
3189 camera: *mut ArvCamera,
3190 delay_ns: i64,
3191 error: *mut *mut glib::GError,
3192 );
3193 pub fn arv_camera_gv_set_packet_size(
3194 camera: *mut ArvCamera,
3195 packet_size: c_int,
3196 error: *mut *mut glib::GError,
3197 );
3198 #[cfg(feature = "v0_8_3")]
3199 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_3")))]
3200 pub fn arv_camera_gv_set_packet_size_adjustment(
3201 camera: *mut ArvCamera,
3202 adjustment: ArvGvPacketSizeAdjustment,
3203 );
3204 #[cfg(feature = "v0_8_22")]
3205 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_22")))]
3206 pub fn arv_camera_gv_set_persistent_ip(
3207 camera: *mut ArvCamera,
3208 ip: *mut gio::GInetAddress,
3209 mask: *mut gio::GInetAddressMask,
3210 gateway: *mut gio::GInetAddress,
3211 error: *mut *mut glib::GError,
3212 );
3213 #[cfg(feature = "v0_8_22")]
3214 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_22")))]
3215 pub fn arv_camera_gv_set_persistent_ip_from_string(
3216 camera: *mut ArvCamera,
3217 ip: *const c_char,
3218 mask: *const c_char,
3219 gateway: *const c_char,
3220 error: *mut *mut glib::GError,
3221 );
3222 pub fn arv_camera_gv_set_stream_options(camera: *mut ArvCamera, options: ArvGvStreamOption);
3223 pub fn arv_camera_is_binning_available(
3224 camera: *mut ArvCamera,
3225 error: *mut *mut glib::GError,
3226 ) -> gboolean;
3227 #[cfg(feature = "v0_8_19")]
3228 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_19")))]
3229 pub fn arv_camera_is_black_level_auto_available(
3230 camera: *mut ArvCamera,
3231 error: *mut *mut glib::GError,
3232 ) -> gboolean;
3233 #[cfg(feature = "v0_8_19")]
3234 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_19")))]
3235 pub fn arv_camera_is_black_level_available(
3236 camera: *mut ArvCamera,
3237 error: *mut *mut glib::GError,
3238 ) -> gboolean;
3239 #[cfg(feature = "v0_8_25")]
3240 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_25")))]
3241 pub fn arv_camera_is_component_available(
3242 camera: *mut ArvCamera,
3243 error: *mut *mut glib::GError,
3244 ) -> gboolean;
3245 #[cfg(feature = "v0_8_17")]
3246 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_17")))]
3247 pub fn arv_camera_is_enumeration_entry_available(
3248 camera: *mut ArvCamera,
3249 feature: *const c_char,
3250 entry: *const c_char,
3251 error: *mut *mut glib::GError,
3252 ) -> gboolean;
3253 pub fn arv_camera_is_exposure_auto_available(
3254 camera: *mut ArvCamera,
3255 error: *mut *mut glib::GError,
3256 ) -> gboolean;
3257 pub fn arv_camera_is_exposure_time_available(
3258 camera: *mut ArvCamera,
3259 error: *mut *mut glib::GError,
3260 ) -> gboolean;
3261 pub fn arv_camera_is_feature_available(
3262 camera: *mut ArvCamera,
3263 feature: *const c_char,
3264 error: *mut *mut glib::GError,
3265 ) -> gboolean;
3266 #[cfg(feature = "v0_8_23")]
3267 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_23")))]
3268 pub fn arv_camera_is_feature_implemented(
3269 camera: *mut ArvCamera,
3270 feature: *const c_char,
3271 error: *mut *mut glib::GError,
3272 ) -> gboolean;
3273 pub fn arv_camera_is_frame_rate_available(
3274 camera: *mut ArvCamera,
3275 error: *mut *mut glib::GError,
3276 ) -> gboolean;
3277 pub fn arv_camera_is_gain_auto_available(
3278 camera: *mut ArvCamera,
3279 error: *mut *mut glib::GError,
3280 ) -> gboolean;
3281 pub fn arv_camera_is_gain_available(
3282 camera: *mut ArvCamera,
3283 error: *mut *mut glib::GError,
3284 ) -> gboolean;
3285 pub fn arv_camera_is_gv_device(camera: *mut ArvCamera) -> gboolean;
3286 #[cfg(feature = "v0_8_22")]
3287 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_22")))]
3288 pub fn arv_camera_is_region_offset_available(
3289 camera: *mut ArvCamera,
3290 error: *mut *mut glib::GError,
3291 ) -> gboolean;
3292 #[cfg(feature = "v0_8_17")]
3293 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_17")))]
3294 pub fn arv_camera_is_software_trigger_supported(
3295 camera: *mut ArvCamera,
3296 error: *mut *mut glib::GError,
3297 ) -> gboolean;
3298 pub fn arv_camera_is_uv_device(camera: *mut ArvCamera) -> gboolean;
3299 #[cfg(feature = "v0_8_23")]
3300 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_23")))]
3301 pub fn arv_camera_select_and_enable_component(
3302 camera: *mut ArvCamera,
3303 component: *const c_char,
3304 disable_others: gboolean,
3305 error: *mut *mut glib::GError,
3306 );
3307 #[cfg(feature = "v0_8_27")]
3308 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_27")))]
3309 pub fn arv_camera_select_black_level(
3310 camera: *mut ArvCamera,
3311 selector: *const c_char,
3312 error: *mut *mut glib::GError,
3313 );
3314 #[cfg(feature = "v0_8_25")]
3315 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_25")))]
3316 pub fn arv_camera_select_component(
3317 camera: *mut ArvCamera,
3318 component: *const c_char,
3319 flags: ArvComponentSelectionFlags,
3320 component_id: *mut c_uint,
3321 error: *mut *mut glib::GError,
3322 ) -> gboolean;
3323 #[cfg(feature = "v0_8_27")]
3324 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_27")))]
3325 pub fn arv_camera_select_gain(
3326 camera: *mut ArvCamera,
3327 selector: *const c_char,
3328 error: *mut *mut glib::GError,
3329 );
3330 #[cfg(feature = "v0_8_22")]
3331 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_22")))]
3332 pub fn arv_camera_set_access_check_policy(camera: *mut ArvCamera, policy: ArvAccessCheckPolicy);
3333 pub fn arv_camera_set_acquisition_mode(
3334 camera: *mut ArvCamera,
3335 value: ArvAcquisitionMode,
3336 error: *mut *mut glib::GError,
3337 );
3338 pub fn arv_camera_set_binning(
3339 camera: *mut ArvCamera,
3340 dx: c_int,
3341 dy: c_int,
3342 error: *mut *mut glib::GError,
3343 );
3344 #[cfg(feature = "v0_8_19")]
3345 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_19")))]
3346 pub fn arv_camera_set_black_level(
3347 camera: *mut ArvCamera,
3348 blacklevel: c_double,
3349 error: *mut *mut glib::GError,
3350 );
3351 #[cfg(feature = "v0_8_19")]
3352 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_19")))]
3353 pub fn arv_camera_set_black_level_auto(
3354 camera: *mut ArvCamera,
3355 auto_mode: ArvAuto,
3356 error: *mut *mut glib::GError,
3357 );
3358 pub fn arv_camera_set_boolean(
3359 camera: *mut ArvCamera,
3360 feature: *const c_char,
3361 value: gboolean,
3362 error: *mut *mut glib::GError,
3363 );
3364 pub fn arv_camera_set_chunk_mode(
3365 camera: *mut ArvCamera,
3366 is_active: gboolean,
3367 error: *mut *mut glib::GError,
3368 );
3369 pub fn arv_camera_set_chunk_state(
3370 camera: *mut ArvCamera,
3371 chunk: *const c_char,
3372 is_enabled: gboolean,
3373 error: *mut *mut glib::GError,
3374 );
3375 pub fn arv_camera_set_chunks(
3376 camera: *mut ArvCamera,
3377 chunk_list: *const c_char,
3378 error: *mut *mut glib::GError,
3379 );
3380 pub fn arv_camera_set_exposure_mode(
3381 camera: *mut ArvCamera,
3382 mode: ArvExposureMode,
3383 error: *mut *mut glib::GError,
3384 );
3385 pub fn arv_camera_set_exposure_time(
3386 camera: *mut ArvCamera,
3387 exposure_time_us: c_double,
3388 error: *mut *mut glib::GError,
3389 );
3390 pub fn arv_camera_set_exposure_time_auto(
3391 camera: *mut ArvCamera,
3392 auto_mode: ArvAuto,
3393 error: *mut *mut glib::GError,
3394 );
3395 pub fn arv_camera_set_float(
3396 camera: *mut ArvCamera,
3397 feature: *const c_char,
3398 value: c_double,
3399 error: *mut *mut glib::GError,
3400 );
3401 pub fn arv_camera_set_frame_count(
3402 camera: *mut ArvCamera,
3403 frame_count: i64,
3404 error: *mut *mut glib::GError,
3405 );
3406 pub fn arv_camera_set_frame_rate(
3407 camera: *mut ArvCamera,
3408 frame_rate: c_double,
3409 error: *mut *mut glib::GError,
3410 );
3411 pub fn arv_camera_set_frame_rate_enable(
3412 camera: *mut ArvCamera,
3413 enable: gboolean,
3414 error: *mut *mut glib::GError,
3415 );
3416 pub fn arv_camera_set_gain(
3417 camera: *mut ArvCamera,
3418 gain: c_double,
3419 error: *mut *mut glib::GError,
3420 );
3421 pub fn arv_camera_set_gain_auto(
3422 camera: *mut ArvCamera,
3423 auto_mode: ArvAuto,
3424 error: *mut *mut glib::GError,
3425 );
3426 pub fn arv_camera_set_integer(
3427 camera: *mut ArvCamera,
3428 feature: *const c_char,
3429 value: i64,
3430 error: *mut *mut glib::GError,
3431 );
3432 pub fn arv_camera_set_pixel_format(
3433 camera: *mut ArvCamera,
3434 format: ArvPixelFormat,
3435 error: *mut *mut glib::GError,
3436 );
3437 pub fn arv_camera_set_pixel_format_from_string(
3438 camera: *mut ArvCamera,
3439 format: *const c_char,
3440 error: *mut *mut glib::GError,
3441 );
3442 #[cfg(feature = "v0_8_8")]
3443 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_8")))]
3444 pub fn arv_camera_set_range_check_policy(camera: *mut ArvCamera, policy: ArvRangeCheckPolicy);
3445 pub fn arv_camera_set_region(
3446 camera: *mut ArvCamera,
3447 x: c_int,
3448 y: c_int,
3449 width: c_int,
3450 height: c_int,
3451 error: *mut *mut glib::GError,
3452 );
3453 #[cfg(feature = "v0_8_31")]
3454 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_31")))]
3455 pub fn arv_camera_set_register(
3456 camera: *mut ArvCamera,
3457 feature: *const c_char,
3458 length: u64,
3459 value: *mut c_void,
3460 error: *mut *mut glib::GError,
3461 );
3462 #[cfg(feature = "v0_8_8")]
3463 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_8")))]
3464 pub fn arv_camera_set_register_cache_policy(
3465 camera: *mut ArvCamera,
3466 policy: ArvRegisterCachePolicy,
3467 );
3468 pub fn arv_camera_set_string(
3469 camera: *mut ArvCamera,
3470 feature: *const c_char,
3471 value: *const c_char,
3472 error: *mut *mut glib::GError,
3473 );
3474 pub fn arv_camera_set_trigger(
3475 camera: *mut ArvCamera,
3476 source: *const c_char,
3477 error: *mut *mut glib::GError,
3478 );
3479 pub fn arv_camera_set_trigger_source(
3480 camera: *mut ArvCamera,
3481 source: *const c_char,
3482 error: *mut *mut glib::GError,
3483 );
3484 pub fn arv_camera_software_trigger(camera: *mut ArvCamera, error: *mut *mut glib::GError);
3485 pub fn arv_camera_start_acquisition(camera: *mut ArvCamera, error: *mut *mut glib::GError);
3486 pub fn arv_camera_stop_acquisition(camera: *mut ArvCamera, error: *mut *mut glib::GError);
3487 pub fn arv_camera_uv_get_bandwidth(
3488 camera: *mut ArvCamera,
3489 error: *mut *mut glib::GError,
3490 ) -> c_uint;
3491 pub fn arv_camera_uv_get_bandwidth_bounds(
3492 camera: *mut ArvCamera,
3493 min: *mut c_uint,
3494 max: *mut c_uint,
3495 error: *mut *mut glib::GError,
3496 );
3497 pub fn arv_camera_uv_is_bandwidth_control_available(
3498 camera: *mut ArvCamera,
3499 error: *mut *mut glib::GError,
3500 ) -> gboolean;
3501 pub fn arv_camera_uv_set_bandwidth(
3502 camera: *mut ArvCamera,
3503 bandwidth: c_uint,
3504 error: *mut *mut glib::GError,
3505 );
3506 #[cfg(feature = "v0_8_17")]
3507 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_17")))]
3508 pub fn arv_camera_uv_set_usb_mode(camera: *mut ArvCamera, usb_mode: ArvUvUsbMode);
3509
3510 pub fn arv_chunk_parser_get_type() -> GType;
3514 pub fn arv_chunk_parser_new(xml: *const c_char, size: size_t) -> *mut ArvChunkParser;
3515 pub fn arv_chunk_parser_get_boolean_value(
3516 parser: *mut ArvChunkParser,
3517 buffer: *mut ArvBuffer,
3518 chunk: *const c_char,
3519 error: *mut *mut glib::GError,
3520 ) -> gboolean;
3521 pub fn arv_chunk_parser_get_float_value(
3522 parser: *mut ArvChunkParser,
3523 buffer: *mut ArvBuffer,
3524 chunk: *const c_char,
3525 error: *mut *mut glib::GError,
3526 ) -> c_double;
3527 pub fn arv_chunk_parser_get_integer_value(
3528 parser: *mut ArvChunkParser,
3529 buffer: *mut ArvBuffer,
3530 chunk: *const c_char,
3531 error: *mut *mut glib::GError,
3532 ) -> i64;
3533 pub fn arv_chunk_parser_get_string_value(
3534 parser: *mut ArvChunkParser,
3535 buffer: *mut ArvBuffer,
3536 chunk: *const c_char,
3537 error: *mut *mut glib::GError,
3538 ) -> *const c_char;
3539
3540 pub fn arv_device_get_type() -> GType;
3544 pub fn arv_device_create_chunk_parser(device: *mut ArvDevice) -> *mut ArvChunkParser;
3545 pub fn arv_device_create_stream(
3546 device: *mut ArvDevice,
3547 callback: ArvStreamCallback,
3548 user_data: *mut c_void,
3549 error: *mut *mut glib::GError,
3550 ) -> *mut ArvStream;
3551 #[cfg(feature = "v0_8_23")]
3552 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_23")))]
3553 pub fn arv_device_create_stream_full(
3554 device: *mut ArvDevice,
3555 callback: ArvStreamCallback,
3556 user_data: *mut c_void,
3557 destroy: glib::GDestroyNotify,
3558 error: *mut *mut glib::GError,
3559 ) -> *mut ArvStream;
3560 pub fn arv_device_dup_available_enumeration_feature_values(
3561 device: *mut ArvDevice,
3562 feature: *const c_char,
3563 n_values: *mut c_uint,
3564 error: *mut *mut glib::GError,
3565 ) -> *mut i64;
3566 pub fn arv_device_dup_available_enumeration_feature_values_as_display_names(
3567 device: *mut ArvDevice,
3568 feature: *const c_char,
3569 n_values: *mut c_uint,
3570 error: *mut *mut glib::GError,
3571 ) -> *mut *const c_char;
3572 pub fn arv_device_dup_available_enumeration_feature_values_as_strings(
3573 device: *mut ArvDevice,
3574 feature: *const c_char,
3575 n_values: *mut c_uint,
3576 error: *mut *mut glib::GError,
3577 ) -> *mut *const c_char;
3578 #[cfg(feature = "v0_8_31")]
3579 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_31")))]
3580 pub fn arv_device_dup_register_feature_value(
3581 device: *mut ArvDevice,
3582 feature: *const c_char,
3583 length: *mut u64,
3584 error: *mut *mut glib::GError,
3585 ) -> *mut c_void;
3586 pub fn arv_device_execute_command(
3587 device: *mut ArvDevice,
3588 feature: *const c_char,
3589 error: *mut *mut glib::GError,
3590 );
3591 pub fn arv_device_get_boolean_feature_value(
3592 device: *mut ArvDevice,
3593 feature: *const c_char,
3594 error: *mut *mut glib::GError,
3595 ) -> gboolean;
3596 pub fn arv_device_get_boolean_feature_value_gi(
3597 device: *mut ArvDevice,
3598 feature: *const c_char,
3599 value: *mut gboolean,
3600 error: *mut *mut glib::GError,
3601 );
3602 pub fn arv_device_get_feature(device: *mut ArvDevice, feature: *const c_char)
3603 -> *mut ArvGcNode;
3604 #[cfg(feature = "v0_8_22")]
3605 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_22")))]
3606 pub fn arv_device_get_feature_access_mode(
3607 device: *mut ArvDevice,
3608 feature: *const c_char,
3609 ) -> ArvGcAccessMode;
3610 #[cfg(feature = "v0_8_31")]
3611 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_31")))]
3612 pub fn arv_device_get_feature_representation(
3613 device: *mut ArvDevice,
3614 feature: *const c_char,
3615 ) -> ArvGcRepresentation;
3616 pub fn arv_device_get_float_feature_bounds(
3617 device: *mut ArvDevice,
3618 feature: *const c_char,
3619 min: *mut c_double,
3620 max: *mut c_double,
3621 error: *mut *mut glib::GError,
3622 );
3623 #[cfg(feature = "v0_8_16")]
3624 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_16")))]
3625 pub fn arv_device_get_float_feature_increment(
3626 device: *mut ArvDevice,
3627 feature: *const c_char,
3628 error: *mut *mut glib::GError,
3629 ) -> c_double;
3630 pub fn arv_device_get_float_feature_value(
3631 device: *mut ArvDevice,
3632 feature: *const c_char,
3633 error: *mut *mut glib::GError,
3634 ) -> c_double;
3635 pub fn arv_device_get_genicam(device: *mut ArvDevice) -> *mut ArvGc;
3636 pub fn arv_device_get_genicam_xml(device: *mut ArvDevice, size: *mut size_t) -> *const c_char;
3637 pub fn arv_device_get_integer_feature_bounds(
3638 device: *mut ArvDevice,
3639 feature: *const c_char,
3640 min: *mut i64,
3641 max: *mut i64,
3642 error: *mut *mut glib::GError,
3643 );
3644 pub fn arv_device_get_integer_feature_increment(
3645 device: *mut ArvDevice,
3646 feature: *const c_char,
3647 error: *mut *mut glib::GError,
3648 ) -> i64;
3649 pub fn arv_device_get_integer_feature_value(
3650 device: *mut ArvDevice,
3651 feature: *const c_char,
3652 error: *mut *mut glib::GError,
3653 ) -> i64;
3654 pub fn arv_device_get_string_feature_value(
3655 device: *mut ArvDevice,
3656 feature: *const c_char,
3657 error: *mut *mut glib::GError,
3658 ) -> *const c_char;
3659 #[cfg(feature = "v0_8_17")]
3660 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_17")))]
3661 pub fn arv_device_is_enumeration_entry_available(
3662 device: *mut ArvDevice,
3663 feature: *const c_char,
3664 entry: *const c_char,
3665 error: *mut *mut glib::GError,
3666 ) -> gboolean;
3667 pub fn arv_device_is_feature_available(
3668 device: *mut ArvDevice,
3669 feature: *const c_char,
3670 error: *mut *mut glib::GError,
3671 ) -> gboolean;
3672 #[cfg(feature = "v0_8_23")]
3673 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_23")))]
3674 pub fn arv_device_is_feature_implemented(
3675 device: *mut ArvDevice,
3676 feature: *const c_char,
3677 error: *mut *mut glib::GError,
3678 ) -> gboolean;
3679 pub fn arv_device_read_memory(
3680 device: *mut ArvDevice,
3681 address: u64,
3682 size: u32,
3683 buffer: *mut c_void,
3684 error: *mut *mut glib::GError,
3685 ) -> gboolean;
3686 pub fn arv_device_read_register(
3687 device: *mut ArvDevice,
3688 address: u64,
3689 value: *mut u32,
3690 error: *mut *mut glib::GError,
3691 ) -> gboolean;
3692 #[cfg(feature = "v0_8_22")]
3693 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_22")))]
3694 pub fn arv_device_set_access_check_policy(device: *mut ArvDevice, policy: ArvAccessCheckPolicy);
3695 pub fn arv_device_set_boolean_feature_value(
3696 device: *mut ArvDevice,
3697 feature: *const c_char,
3698 value: gboolean,
3699 error: *mut *mut glib::GError,
3700 );
3701 pub fn arv_device_set_features_from_string(
3702 device: *mut ArvDevice,
3703 string: *const c_char,
3704 error: *mut *mut glib::GError,
3705 ) -> gboolean;
3706 pub fn arv_device_set_float_feature_value(
3707 device: *mut ArvDevice,
3708 feature: *const c_char,
3709 value: c_double,
3710 error: *mut *mut glib::GError,
3711 );
3712 pub fn arv_device_set_integer_feature_value(
3713 device: *mut ArvDevice,
3714 feature: *const c_char,
3715 value: i64,
3716 error: *mut *mut glib::GError,
3717 );
3718 #[cfg(feature = "v0_8_6")]
3719 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_6")))]
3720 pub fn arv_device_set_range_check_policy(device: *mut ArvDevice, policy: ArvRangeCheckPolicy);
3721 pub fn arv_device_set_register_cache_policy(
3722 device: *mut ArvDevice,
3723 policy: ArvRegisterCachePolicy,
3724 );
3725 pub fn arv_device_set_register_feature_value(
3726 device: *mut ArvDevice,
3727 feature: *const c_char,
3728 length: u64,
3729 value: *mut c_void,
3730 error: *mut *mut glib::GError,
3731 );
3732 pub fn arv_device_set_string_feature_value(
3733 device: *mut ArvDevice,
3734 feature: *const c_char,
3735 value: *const c_char,
3736 error: *mut *mut glib::GError,
3737 );
3738 pub fn arv_device_write_memory(
3739 device: *mut ArvDevice,
3740 address: u64,
3741 size: u32,
3742 buffer: *mut c_void,
3743 error: *mut *mut glib::GError,
3744 ) -> gboolean;
3745 pub fn arv_device_write_register(
3746 device: *mut ArvDevice,
3747 address: u64,
3748 value: u32,
3749 error: *mut *mut glib::GError,
3750 ) -> gboolean;
3751
3752 pub fn arv_dom_character_data_get_type() -> GType;
3756 pub fn arv_dom_character_data_get_data(self_: *mut ArvDomCharacterData) -> *const c_char;
3757 pub fn arv_dom_character_data_set_data(self_: *mut ArvDomCharacterData, value: *const c_char);
3758
3759 pub fn arv_dom_document_get_type() -> GType;
3763 pub fn arv_dom_document_new_from_memory(
3764 buffer: *mut c_void,
3765 size: c_int,
3766 error: *mut *mut glib::GError,
3767 ) -> *mut ArvDomDocument;
3768 pub fn arv_dom_document_new_from_path(
3769 path: *const c_char,
3770 error: *mut *mut glib::GError,
3771 ) -> *mut ArvDomDocument;
3772 pub fn arv_dom_document_new_from_url(
3773 url: *const c_char,
3774 error: *mut *mut glib::GError,
3775 ) -> *mut ArvDomDocument;
3776 pub fn arv_dom_document_append_from_memory(
3777 document: *mut ArvDomDocument,
3778 node: *mut ArvDomNode,
3779 buffer: *mut c_void,
3780 size: c_int,
3781 error: *mut *mut glib::GError,
3782 );
3783 pub fn arv_dom_document_create_element(
3784 self_: *mut ArvDomDocument,
3785 tag_name: *const c_char,
3786 ) -> *mut ArvDomElement;
3787 pub fn arv_dom_document_create_text_node(
3788 self_: *mut ArvDomDocument,
3789 data: *const c_char,
3790 ) -> *mut ArvDomText;
3791 pub fn arv_dom_document_get_document_element(self_: *mut ArvDomDocument) -> *mut ArvDomElement;
3792 pub fn arv_dom_document_get_href_data(
3793 self_: *mut ArvDomDocument,
3794 href: *const c_char,
3795 size: *mut size_t,
3796 ) -> *mut c_void;
3797 pub fn arv_dom_document_get_url(self_: *mut ArvDomDocument) -> *const c_char;
3798 pub fn arv_dom_document_set_path(self_: *mut ArvDomDocument, path: *const c_char);
3799 pub fn arv_dom_document_set_url(self_: *mut ArvDomDocument, url: *const c_char);
3800
3801 pub fn arv_dom_document_fragment_get_type() -> GType;
3805 pub fn arv_dom_document_fragment_new() -> *mut ArvDomDocumentFragment;
3806
3807 pub fn arv_dom_element_get_type() -> GType;
3811 pub fn arv_dom_element_get_attribute(
3812 self_: *mut ArvDomElement,
3813 name: *const c_char,
3814 ) -> *const c_char;
3815 pub fn arv_dom_element_get_tag_name(self_: *mut ArvDomElement) -> *const c_char;
3816 pub fn arv_dom_element_set_attribute(
3817 self_: *mut ArvDomElement,
3818 name: *const c_char,
3819 attribute_value: *const c_char,
3820 );
3821
3822 pub fn arv_dom_named_node_map_get_type() -> GType;
3826 pub fn arv_dom_named_node_map_get_item(
3827 map: *mut ArvDomNamedNodeMap,
3828 index: c_uint,
3829 ) -> *mut ArvDomNode;
3830 pub fn arv_dom_named_node_map_get_length(map: *mut ArvDomNamedNodeMap) -> c_uint;
3831 pub fn arv_dom_named_node_map_get_named_item(
3832 map: *mut ArvDomNamedNodeMap,
3833 name: *const c_char,
3834 ) -> *mut ArvDomNode;
3835 pub fn arv_dom_named_node_map_remove_named_item(
3836 map: *mut ArvDomNamedNodeMap,
3837 name: *const c_char,
3838 ) -> *mut ArvDomNode;
3839 pub fn arv_dom_named_node_map_set_named_item(
3840 map: *mut ArvDomNamedNodeMap,
3841 item: *mut ArvDomNode,
3842 ) -> *mut ArvDomNode;
3843
3844 pub fn arv_dom_node_get_type() -> GType;
3848 pub fn arv_dom_node_append_child(
3849 self_: *mut ArvDomNode,
3850 new_child: *mut ArvDomNode,
3851 ) -> *mut ArvDomNode;
3852 pub fn arv_dom_node_changed(self_: *mut ArvDomNode);
3853 pub fn arv_dom_node_get_child_nodes(self_: *mut ArvDomNode) -> *mut ArvDomNodeList;
3854 pub fn arv_dom_node_get_first_child(self_: *mut ArvDomNode) -> *mut ArvDomNode;
3855 pub fn arv_dom_node_get_last_child(self_: *mut ArvDomNode) -> *mut ArvDomNode;
3856 pub fn arv_dom_node_get_next_sibling(self_: *mut ArvDomNode) -> *mut ArvDomNode;
3857 pub fn arv_dom_node_get_node_name(self_: *mut ArvDomNode) -> *const c_char;
3858 pub fn arv_dom_node_get_node_type(self_: *mut ArvDomNode) -> ArvDomNodeType;
3859 pub fn arv_dom_node_get_node_value(self_: *mut ArvDomNode) -> *const c_char;
3860 pub fn arv_dom_node_get_owner_document(self_: *mut ArvDomNode) -> *mut ArvDomDocument;
3861 pub fn arv_dom_node_get_parent_node(self_: *mut ArvDomNode) -> *mut ArvDomNode;
3862 pub fn arv_dom_node_get_previous_sibling(self_: *mut ArvDomNode) -> *mut ArvDomNode;
3863 pub fn arv_dom_node_has_child_nodes(self_: *mut ArvDomNode) -> gboolean;
3864 pub fn arv_dom_node_insert_before(
3865 self_: *mut ArvDomNode,
3866 new_child: *mut ArvDomNode,
3867 ref_child: *mut ArvDomNode,
3868 ) -> *mut ArvDomNode;
3869 pub fn arv_dom_node_remove_child(
3870 self_: *mut ArvDomNode,
3871 old_child: *mut ArvDomNode,
3872 ) -> *mut ArvDomNode;
3873 pub fn arv_dom_node_replace_child(
3874 self_: *mut ArvDomNode,
3875 new_child: *mut ArvDomNode,
3876 old_child: *mut ArvDomNode,
3877 ) -> *mut ArvDomNode;
3878 pub fn arv_dom_node_set_node_value(self_: *mut ArvDomNode, new_value: *const c_char);
3879
3880 pub fn arv_dom_node_child_list_get_type() -> GType;
3884 pub fn arv_dom_node_child_list_new(parent_node: *mut ArvDomNode) -> *mut ArvDomNodeList;
3885
3886 pub fn arv_dom_node_list_get_type() -> GType;
3890 pub fn arv_dom_node_list_get_item(list: *mut ArvDomNodeList, index: c_uint) -> *mut ArvDomNode;
3891 pub fn arv_dom_node_list_get_length(list: *mut ArvDomNodeList) -> c_uint;
3892
3893 pub fn arv_dom_text_get_type() -> GType;
3897 pub fn arv_dom_text_new(data: *const c_char) -> *mut ArvDomNode;
3898
3899 pub fn arv_evaluator_get_type() -> GType;
3903 pub fn arv_evaluator_new(expression: *const c_char) -> *mut ArvEvaluator;
3904 pub fn arv_evaluator_evaluate_as_double(
3905 evaluator: *mut ArvEvaluator,
3906 error: *mut *mut glib::GError,
3907 ) -> c_double;
3908 pub fn arv_evaluator_evaluate_as_int64(
3909 evaluator: *mut ArvEvaluator,
3910 error: *mut *mut glib::GError,
3911 ) -> i64;
3912 pub fn arv_evaluator_get_constant(
3913 evaluator: *mut ArvEvaluator,
3914 name: *const c_char,
3915 ) -> *const c_char;
3916 pub fn arv_evaluator_get_expression(evaluator: *mut ArvEvaluator) -> *const c_char;
3917 pub fn arv_evaluator_get_sub_expression(
3918 evaluator: *mut ArvEvaluator,
3919 name: *const c_char,
3920 ) -> *const c_char;
3921 pub fn arv_evaluator_set_constant(
3922 evaluator: *mut ArvEvaluator,
3923 name: *const c_char,
3924 constant: *const c_char,
3925 );
3926 pub fn arv_evaluator_set_double_variable(
3927 evaluator: *mut ArvEvaluator,
3928 name: *const c_char,
3929 v_double: c_double,
3930 );
3931 pub fn arv_evaluator_set_expression(evaluator: *mut ArvEvaluator, expression: *const c_char);
3932 pub fn arv_evaluator_set_int64_variable(
3933 evaluator: *mut ArvEvaluator,
3934 name: *const c_char,
3935 v_int64: i64,
3936 );
3937 pub fn arv_evaluator_set_sub_expression(
3938 evaluator: *mut ArvEvaluator,
3939 name: *const c_char,
3940 expression: *const c_char,
3941 );
3942
3943 pub fn arv_fake_camera_get_type() -> GType;
3947 pub fn arv_fake_camera_new(serial_number: *const c_char) -> *mut ArvFakeCamera;
3948 pub fn arv_fake_camera_new_full(
3949 serial_number: *const c_char,
3950 genicam_filename: *const c_char,
3951 ) -> *mut ArvFakeCamera;
3952 pub fn arv_fake_camera_check_and_acknowledge_software_trigger(
3953 camera: *mut ArvFakeCamera,
3954 ) -> gboolean;
3955 pub fn arv_fake_camera_fill_buffer(
3956 camera: *mut ArvFakeCamera,
3957 buffer: *mut ArvBuffer,
3958 packet_size: *mut u32,
3959 );
3960 pub fn arv_fake_camera_get_acquisition_status(camera: *mut ArvFakeCamera) -> u32;
3961 pub fn arv_fake_camera_get_control_channel_privilege(camera: *mut ArvFakeCamera) -> u32;
3962 pub fn arv_fake_camera_get_genicam_xml(
3963 camera: *mut ArvFakeCamera,
3964 size: *mut size_t,
3965 ) -> *const c_char;
3966 pub fn arv_fake_camera_get_genicam_xml_url(camera: *mut ArvFakeCamera) -> *const c_char;
3967 pub fn arv_fake_camera_get_heartbeat_timeout(camera: *mut ArvFakeCamera) -> u32;
3968 pub fn arv_fake_camera_get_payload(camera: *mut ArvFakeCamera) -> size_t;
3969 pub fn arv_fake_camera_get_sleep_time_for_next_frame(
3970 camera: *mut ArvFakeCamera,
3971 next_timestamp_us: *mut u64,
3972 ) -> u64;
3973 pub fn arv_fake_camera_get_stream_address(
3974 camera: *mut ArvFakeCamera,
3975 ) -> *mut gio::GSocketAddress;
3976 pub fn arv_fake_camera_is_in_free_running_mode(camera: *mut ArvFakeCamera) -> gboolean;
3977 pub fn arv_fake_camera_is_in_software_trigger_mode(camera: *mut ArvFakeCamera) -> gboolean;
3978 pub fn arv_fake_camera_read_memory(
3979 camera: *mut ArvFakeCamera,
3980 address: u32,
3981 size: u32,
3982 buffer: *mut c_void,
3983 ) -> gboolean;
3984 pub fn arv_fake_camera_read_register(
3985 camera: *mut ArvFakeCamera,
3986 address: u32,
3987 value: *mut u32,
3988 ) -> gboolean;
3989 pub fn arv_fake_camera_set_control_channel_privilege(
3990 camera: *mut ArvFakeCamera,
3991 privilege: u32,
3992 );
3993 pub fn arv_fake_camera_set_fill_pattern(
3994 camera: *mut ArvFakeCamera,
3995 fill_pattern_callback: ArvFakeCameraFillPattern,
3996 fill_pattern_data: *mut c_void,
3997 );
3998 pub fn arv_fake_camera_set_inet_address(
3999 camera: *mut ArvFakeCamera,
4000 address: *mut gio::GInetAddress,
4001 );
4002 pub fn arv_fake_camera_set_trigger_frequency(camera: *mut ArvFakeCamera, frequency: c_double);
4003 pub fn arv_fake_camera_wait_for_next_frame(camera: *mut ArvFakeCamera);
4004 pub fn arv_fake_camera_write_memory(
4005 camera: *mut ArvFakeCamera,
4006 address: u32,
4007 size: u32,
4008 buffer: *mut c_void,
4009 ) -> gboolean;
4010 pub fn arv_fake_camera_write_register(
4011 camera: *mut ArvFakeCamera,
4012 address: u32,
4013 value: u32,
4014 ) -> gboolean;
4015
4016 pub fn arv_fake_device_get_type() -> GType;
4020 pub fn arv_fake_device_new(
4021 serial_number: *const c_char,
4022 error: *mut *mut glib::GError,
4023 ) -> *mut ArvDevice;
4024 pub fn arv_fake_device_get_fake_camera(device: *mut ArvFakeDevice) -> *mut ArvFakeCamera;
4025
4026 pub fn arv_fake_interface_get_type() -> GType;
4030 pub fn arv_fake_interface_get_instance() -> *mut ArvInterface;
4031
4032 pub fn arv_fake_stream_get_type() -> GType;
4036
4037 pub fn arv_gc_get_type() -> GType;
4041 pub fn arv_gc_new(device: *mut ArvDevice, xml: *mut c_void, size: size_t) -> *mut ArvGc;
4042 pub fn arv_gc_p_value_indexed_node_new() -> *mut ArvGcNode;
4043 pub fn arv_gc_invalidator_has_changed(self_: *mut ArvGcInvalidatorNode) -> gboolean;
4044 #[cfg(feature = "v0_8_6")]
4045 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_6")))]
4046 pub fn arv_gc_get_access_check_policy(genicam: *mut ArvGc) -> ArvAccessCheckPolicy;
4047 pub fn arv_gc_get_buffer(genicam: *mut ArvGc) -> *mut ArvBuffer;
4048 pub fn arv_gc_get_device(genicam: *mut ArvGc) -> *mut ArvDevice;
4049 pub fn arv_gc_get_node(genicam: *mut ArvGc, name: *const c_char) -> *mut ArvGcNode;
4050 #[cfg(feature = "v0_8_6")]
4051 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_6")))]
4052 pub fn arv_gc_get_range_check_policy(genicam: *mut ArvGc) -> ArvRangeCheckPolicy;
4053 pub fn arv_gc_get_register_cache_policy(genicam: *mut ArvGc) -> ArvRegisterCachePolicy;
4054 pub fn arv_gc_register_feature_node(genicam: *mut ArvGc, node: *mut ArvGcFeatureNode);
4055 #[cfg(feature = "v0_8_6")]
4056 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_6")))]
4057 pub fn arv_gc_set_access_check_policy(genicam: *mut ArvGc, policy: ArvAccessCheckPolicy);
4058 pub fn arv_gc_set_buffer(genicam: *mut ArvGc, buffer: *mut ArvBuffer);
4059 pub fn arv_gc_set_default_node_data(genicam: *mut ArvGc, node_name: *const c_char, ...);
4060 #[cfg(feature = "v0_8_6")]
4061 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_6")))]
4062 pub fn arv_gc_set_range_check_policy(genicam: *mut ArvGc, policy: ArvRangeCheckPolicy);
4063 pub fn arv_gc_set_register_cache_policy(genicam: *mut ArvGc, policy: ArvRegisterCachePolicy);
4064
4065 pub fn arv_gc_boolean_get_type() -> GType;
4069 pub fn arv_gc_boolean_new() -> *mut ArvGcNode;
4070 pub fn arv_gc_boolean_get_value(
4071 gc_boolean: *mut ArvGcBoolean,
4072 error: *mut *mut glib::GError,
4073 ) -> gboolean;
4074 pub fn arv_gc_boolean_get_value_gi(
4075 gc_boolean: *mut ArvGcBoolean,
4076 value: *mut gboolean,
4077 error: *mut *mut glib::GError,
4078 );
4079 pub fn arv_gc_boolean_set_value(
4080 gc_boolean: *mut ArvGcBoolean,
4081 v_boolean: gboolean,
4082 error: *mut *mut glib::GError,
4083 );
4084
4085 pub fn arv_gc_category_get_type() -> GType;
4089 pub fn arv_gc_category_new() -> *mut ArvGcNode;
4090 pub fn arv_gc_category_get_features(category: *mut ArvGcCategory) -> *const glib::GSList;
4091
4092 pub fn arv_gc_command_get_type() -> GType;
4096 pub fn arv_gc_command_new() -> *mut ArvGcNode;
4097 pub fn arv_gc_command_execute(gc_command: *mut ArvGcCommand, error: *mut *mut glib::GError);
4098
4099 pub fn arv_gc_converter_get_type() -> GType;
4103
4104 pub fn arv_gc_converter_node_get_type() -> GType;
4108 pub fn arv_gc_converter_node_new() -> *mut ArvGcNode;
4109
4110 pub fn arv_gc_enum_entry_get_type() -> GType;
4114 pub fn arv_gc_enum_entry_new() -> *mut ArvGcNode;
4115 pub fn arv_gc_enum_entry_get_value(
4116 entry: *mut ArvGcEnumEntry,
4117 error: *mut *mut glib::GError,
4118 ) -> i64;
4119
4120 pub fn arv_gc_enumeration_get_type() -> GType;
4124 pub fn arv_gc_enumeration_new() -> *mut ArvGcNode;
4125 pub fn arv_gc_enumeration_dup_available_display_names(
4126 enumeration: *mut ArvGcEnumeration,
4127 n_values: *mut c_uint,
4128 error: *mut *mut glib::GError,
4129 ) -> *mut *const c_char;
4130 pub fn arv_gc_enumeration_dup_available_int_values(
4131 enumeration: *mut ArvGcEnumeration,
4132 n_values: *mut c_uint,
4133 error: *mut *mut glib::GError,
4134 ) -> *mut i64;
4135 pub fn arv_gc_enumeration_dup_available_string_values(
4136 enumeration: *mut ArvGcEnumeration,
4137 n_values: *mut c_uint,
4138 error: *mut *mut glib::GError,
4139 ) -> *mut *const c_char;
4140 pub fn arv_gc_enumeration_get_entries(
4141 enumeration: *mut ArvGcEnumeration,
4142 ) -> *const glib::GSList;
4143 pub fn arv_gc_enumeration_get_int_value(
4144 enumeration: *mut ArvGcEnumeration,
4145 error: *mut *mut glib::GError,
4146 ) -> i64;
4147 pub fn arv_gc_enumeration_get_string_value(
4148 enumeration: *mut ArvGcEnumeration,
4149 error: *mut *mut glib::GError,
4150 ) -> *const c_char;
4151 pub fn arv_gc_enumeration_set_int_value(
4152 enumeration: *mut ArvGcEnumeration,
4153 value: i64,
4154 error: *mut *mut glib::GError,
4155 ) -> gboolean;
4156 pub fn arv_gc_enumeration_set_string_value(
4157 enumeration: *mut ArvGcEnumeration,
4158 value: *const c_char,
4159 error: *mut *mut glib::GError,
4160 ) -> gboolean;
4161
4162 pub fn arv_gc_feature_node_get_type() -> GType;
4166 pub fn arv_gc_feature_node_get_actual_access_mode(
4167 gc_feature_node: *mut ArvGcFeatureNode,
4168 ) -> ArvGcAccessMode;
4169 pub fn arv_gc_feature_node_get_description(
4170 gc_feature_node: *mut ArvGcFeatureNode,
4171 ) -> *const c_char;
4172 pub fn arv_gc_feature_node_get_display_name(
4173 gc_feature_node: *mut ArvGcFeatureNode,
4174 ) -> *const c_char;
4175 pub fn arv_gc_feature_node_get_imposed_access_mode(
4176 gc_feature_node: *mut ArvGcFeatureNode,
4177 ) -> ArvGcAccessMode;
4178 pub fn arv_gc_feature_node_get_name(gc_feature_node: *mut ArvGcFeatureNode) -> *const c_char;
4179 pub fn arv_gc_feature_node_get_name_space(
4180 gc_feature_node: *mut ArvGcFeatureNode,
4181 ) -> ArvGcNameSpace;
4182 pub fn arv_gc_feature_node_get_tooltip(gc_feature_node: *mut ArvGcFeatureNode)
4183 -> *const c_char;
4184 pub fn arv_gc_feature_node_get_value_as_string(
4185 gc_feature_node: *mut ArvGcFeatureNode,
4186 error: *mut *mut glib::GError,
4187 ) -> *const c_char;
4188 pub fn arv_gc_feature_node_get_visibility(
4189 gc_feature_node: *mut ArvGcFeatureNode,
4190 ) -> ArvGcVisibility;
4191 pub fn arv_gc_feature_node_is_available(
4192 gc_feature_node: *mut ArvGcFeatureNode,
4193 error: *mut *mut glib::GError,
4194 ) -> gboolean;
4195 pub fn arv_gc_feature_node_is_implemented(
4196 gc_feature_node: *mut ArvGcFeatureNode,
4197 error: *mut *mut glib::GError,
4198 ) -> gboolean;
4199 pub fn arv_gc_feature_node_is_locked(
4200 gc_feature_node: *mut ArvGcFeatureNode,
4201 error: *mut *mut glib::GError,
4202 ) -> gboolean;
4203 pub fn arv_gc_feature_node_set_value_from_string(
4204 gc_feature_node: *mut ArvGcFeatureNode,
4205 string: *const c_char,
4206 error: *mut *mut glib::GError,
4207 );
4208
4209 pub fn arv_gc_float_node_get_type() -> GType;
4213 pub fn arv_gc_float_node_new() -> *mut ArvGcNode;
4214
4215 pub fn arv_gc_float_reg_node_get_type() -> GType;
4219 pub fn arv_gc_float_reg_node_new() -> *mut ArvGcNode;
4220
4221 pub fn arv_gc_group_node_get_type() -> GType;
4225 pub fn arv_gc_group_node_new() -> *mut ArvGcNode;
4226
4227 pub fn arv_gc_index_node_get_type() -> GType;
4231 pub fn arv_gc_index_node_new() -> *mut ArvGcNode;
4232 pub fn arv_gc_index_node_get_index(
4233 index_node: *mut ArvGcIndexNode,
4234 default_offset: i64,
4235 error: *mut *mut glib::GError,
4236 ) -> i64;
4237
4238 pub fn arv_gc_int_converter_node_get_type() -> GType;
4242 pub fn arv_gc_int_converter_node_new() -> *mut ArvGcNode;
4243
4244 pub fn arv_gc_int_reg_node_get_type() -> GType;
4248 pub fn arv_gc_int_reg_node_new() -> *mut ArvGcNode;
4249
4250 pub fn arv_gc_int_swiss_knife_node_get_type() -> GType;
4254 pub fn arv_gc_int_swiss_knife_node_new() -> *mut ArvGcNode;
4255
4256 pub fn arv_gc_integer_node_get_type() -> GType;
4260 pub fn arv_gc_integer_node_new() -> *mut ArvGcNode;
4261
4262 pub fn arv_gc_invalidator_node_get_type() -> GType;
4266 pub fn arv_gc_invalidator_node_new() -> *mut ArvGcNode;
4267
4268 pub fn arv_gc_masked_int_reg_node_get_type() -> GType;
4272 pub fn arv_gc_masked_int_reg_node_new() -> *mut ArvGcNode;
4273
4274 pub fn arv_gc_node_get_type() -> GType;
4278 pub fn arv_gc_node_get_genicam(gc_node: *mut ArvGcNode) -> *mut ArvGc;
4279
4280 pub fn arv_gc_port_get_type() -> GType;
4284 pub fn arv_gc_port_new() -> *mut ArvGcNode;
4285 pub fn arv_gc_port_read(
4286 port: *mut ArvGcPort,
4287 buffer: *mut c_void,
4288 address: u64,
4289 length: u64,
4290 error: *mut *mut glib::GError,
4291 );
4292 pub fn arv_gc_port_write(
4293 port: *mut ArvGcPort,
4294 buffer: *mut c_void,
4295 address: u64,
4296 length: u64,
4297 error: *mut *mut glib::GError,
4298 );
4299
4300 pub fn arv_gc_property_node_get_type() -> GType;
4304 pub fn arv_gc_property_node_new_access_mode() -> *mut ArvGcNode;
4305 pub fn arv_gc_property_node_new_address() -> *mut ArvGcNode;
4306 pub fn arv_gc_property_node_new_bit() -> *mut ArvGcNode;
4307 pub fn arv_gc_property_node_new_cachable() -> *mut ArvGcNode;
4308 pub fn arv_gc_property_node_new_chunk_id() -> *mut ArvGcNode;
4309 pub fn arv_gc_property_node_new_command_value() -> *mut ArvGcNode;
4310 pub fn arv_gc_property_node_new_constant() -> *mut ArvGcNode;
4311 pub fn arv_gc_property_node_new_description() -> *mut ArvGcNode;
4312 pub fn arv_gc_property_node_new_display_name() -> *mut ArvGcNode;
4313 pub fn arv_gc_property_node_new_display_notation() -> *mut ArvGcNode;
4314 pub fn arv_gc_property_node_new_display_precision() -> *mut ArvGcNode;
4315 pub fn arv_gc_property_node_new_endianness() -> *mut ArvGcNode;
4316 pub fn arv_gc_property_node_new_event_id() -> *mut ArvGcNode;
4317 pub fn arv_gc_property_node_new_expression() -> *mut ArvGcNode;
4318 pub fn arv_gc_property_node_new_formula() -> *mut ArvGcNode;
4319 pub fn arv_gc_property_node_new_formula_from() -> *mut ArvGcNode;
4320 pub fn arv_gc_property_node_new_formula_to() -> *mut ArvGcNode;
4321 pub fn arv_gc_property_node_new_imposed_access_mode() -> *mut ArvGcNode;
4322 pub fn arv_gc_property_node_new_increment() -> *mut ArvGcNode;
4323 pub fn arv_gc_property_node_new_is_deprecated() -> *mut ArvGcNode;
4324 pub fn arv_gc_property_node_new_is_linear() -> *mut ArvGcNode;
4325 pub fn arv_gc_property_node_new_length() -> *mut ArvGcNode;
4326 pub fn arv_gc_property_node_new_lsb() -> *mut ArvGcNode;
4327 pub fn arv_gc_property_node_new_maximum() -> *mut ArvGcNode;
4328 pub fn arv_gc_property_node_new_minimum() -> *mut ArvGcNode;
4329 pub fn arv_gc_property_node_new_msb() -> *mut ArvGcNode;
4330 pub fn arv_gc_property_node_new_off_value() -> *mut ArvGcNode;
4331 pub fn arv_gc_property_node_new_on_value() -> *mut ArvGcNode;
4332 pub fn arv_gc_property_node_new_p_address() -> *mut ArvGcNode;
4333 pub fn arv_gc_property_node_new_p_alias() -> *mut ArvGcNode;
4334 pub fn arv_gc_property_node_new_p_cast_alias() -> *mut ArvGcNode;
4335 pub fn arv_gc_property_node_new_p_command_value() -> *mut ArvGcNode;
4336 pub fn arv_gc_property_node_new_p_feature() -> *mut ArvGcNode;
4337 pub fn arv_gc_property_node_new_p_increment() -> *mut ArvGcNode;
4338 pub fn arv_gc_property_node_new_p_is_available() -> *mut ArvGcNode;
4339 pub fn arv_gc_property_node_new_p_is_implemented() -> *mut ArvGcNode;
4340 pub fn arv_gc_property_node_new_p_is_locked() -> *mut ArvGcNode;
4341 pub fn arv_gc_property_node_new_p_length() -> *mut ArvGcNode;
4342 pub fn arv_gc_property_node_new_p_maximum() -> *mut ArvGcNode;
4343 pub fn arv_gc_property_node_new_p_minimum() -> *mut ArvGcNode;
4344 pub fn arv_gc_property_node_new_p_port() -> *mut ArvGcNode;
4345 pub fn arv_gc_property_node_new_p_selected() -> *mut ArvGcNode;
4346 pub fn arv_gc_property_node_new_p_value() -> *mut ArvGcNode;
4347 pub fn arv_gc_property_node_new_p_value_default() -> *mut ArvGcNode;
4348 pub fn arv_gc_property_node_new_p_variable() -> *mut ArvGcNode;
4349 pub fn arv_gc_property_node_new_polling_time() -> *mut ArvGcNode;
4350 pub fn arv_gc_property_node_new_representation() -> *mut ArvGcNode;
4351 pub fn arv_gc_property_node_new_sign() -> *mut ArvGcNode;
4352 pub fn arv_gc_property_node_new_slope() -> *mut ArvGcNode;
4353 pub fn arv_gc_property_node_new_streamable() -> *mut ArvGcNode;
4354 pub fn arv_gc_property_node_new_tooltip() -> *mut ArvGcNode;
4355 pub fn arv_gc_property_node_new_unit() -> *mut ArvGcNode;
4356 pub fn arv_gc_property_node_new_value() -> *mut ArvGcNode;
4357 pub fn arv_gc_property_node_new_value_default() -> *mut ArvGcNode;
4358 pub fn arv_gc_property_node_new_visibility() -> *mut ArvGcNode;
4359 pub fn arv_gc_property_node_get_access_mode(
4360 self_: *mut ArvGcPropertyNode,
4361 default_value: ArvGcAccessMode,
4362 ) -> ArvGcAccessMode;
4363 pub fn arv_gc_property_node_get_cachable(
4364 self_: *mut ArvGcPropertyNode,
4365 default_value: ArvGcCachable,
4366 ) -> ArvGcCachable;
4367 pub fn arv_gc_property_node_get_display_notation(
4368 self_: *mut ArvGcPropertyNode,
4369 default_value: ArvGcDisplayNotation,
4370 ) -> ArvGcDisplayNotation;
4371 pub fn arv_gc_property_node_get_display_precision(
4372 self_: *mut ArvGcPropertyNode,
4373 default_value: i64,
4374 ) -> i64;
4375 pub fn arv_gc_property_node_get_double(
4376 node: *mut ArvGcPropertyNode,
4377 error: *mut *mut glib::GError,
4378 ) -> c_double;
4379 pub fn arv_gc_property_node_get_endianness(
4380 self_: *mut ArvGcPropertyNode,
4381 default_value: c_uint,
4382 ) -> c_uint;
4383 pub fn arv_gc_property_node_get_int64(
4384 node: *mut ArvGcPropertyNode,
4385 error: *mut *mut glib::GError,
4386 ) -> i64;
4387 pub fn arv_gc_property_node_get_linked_node(node: *mut ArvGcPropertyNode) -> *mut ArvGcNode;
4388 pub fn arv_gc_property_node_get_lsb(
4389 self_: *mut ArvGcPropertyNode,
4390 default_value: c_uint,
4391 ) -> c_uint;
4392 pub fn arv_gc_property_node_get_msb(
4393 self_: *mut ArvGcPropertyNode,
4394 default_value: c_uint,
4395 ) -> c_uint;
4396 pub fn arv_gc_property_node_get_name(node: *mut ArvGcPropertyNode) -> *const c_char;
4397 pub fn arv_gc_property_node_get_node_type(
4398 node: *mut ArvGcPropertyNode,
4399 ) -> ArvGcPropertyNodeType;
4400 pub fn arv_gc_property_node_get_representation(
4401 self_: *mut ArvGcPropertyNode,
4402 default_value: ArvGcRepresentation,
4403 ) -> ArvGcRepresentation;
4404 pub fn arv_gc_property_node_get_sign(
4405 self_: *mut ArvGcPropertyNode,
4406 default_value: ArvGcSignedness,
4407 ) -> ArvGcSignedness;
4408 #[cfg(feature = "v0_8_8")]
4409 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_8")))]
4410 pub fn arv_gc_property_node_get_streamable(
4411 self_: *mut ArvGcPropertyNode,
4412 default_value: ArvGcStreamable,
4413 ) -> ArvGcStreamable;
4414 pub fn arv_gc_property_node_get_string(
4415 node: *mut ArvGcPropertyNode,
4416 error: *mut *mut glib::GError,
4417 ) -> *const c_char;
4418 pub fn arv_gc_property_node_get_visibility(
4419 self_: *mut ArvGcPropertyNode,
4420 default_value: ArvGcVisibility,
4421 ) -> ArvGcVisibility;
4422 pub fn arv_gc_property_node_set_double(
4423 node: *mut ArvGcPropertyNode,
4424 v_double: c_double,
4425 error: *mut *mut glib::GError,
4426 );
4427 pub fn arv_gc_property_node_set_int64(
4428 node: *mut ArvGcPropertyNode,
4429 v_int64: i64,
4430 error: *mut *mut glib::GError,
4431 );
4432 pub fn arv_gc_property_node_set_string(
4433 node: *mut ArvGcPropertyNode,
4434 string: *const c_char,
4435 error: *mut *mut glib::GError,
4436 );
4437
4438 pub fn arv_gc_register_description_node_get_type() -> GType;
4442 pub fn arv_gc_register_description_node_new() -> *mut ArvGcNode;
4443 pub fn arv_gc_register_description_node_check_schema_version(
4444 node: *mut ArvGcRegisterDescriptionNode,
4445 required_major: c_uint,
4446 required_minor: c_uint,
4447 required_subminor: c_uint,
4448 ) -> gboolean;
4449 pub fn arv_gc_register_description_node_compare_schema_version(
4450 node: *mut ArvGcRegisterDescriptionNode,
4451 major: c_uint,
4452 minor: c_uint,
4453 subminor: c_uint,
4454 ) -> c_int;
4455 pub fn arv_gc_register_description_node_get_major_version(
4456 node: *mut ArvGcRegisterDescriptionNode,
4457 ) -> c_uint;
4458 pub fn arv_gc_register_description_node_get_minor_version(
4459 node: *mut ArvGcRegisterDescriptionNode,
4460 ) -> c_uint;
4461 pub fn arv_gc_register_description_node_get_model_name(
4462 node: *mut ArvGcRegisterDescriptionNode,
4463 ) -> *mut c_char;
4464 pub fn arv_gc_register_description_node_get_schema_major_version(
4465 node: *mut ArvGcRegisterDescriptionNode,
4466 ) -> c_uint;
4467 pub fn arv_gc_register_description_node_get_schema_minor_version(
4468 node: *mut ArvGcRegisterDescriptionNode,
4469 ) -> c_uint;
4470 pub fn arv_gc_register_description_node_get_schema_subminor_version(
4471 node: *mut ArvGcRegisterDescriptionNode,
4472 ) -> c_uint;
4473 pub fn arv_gc_register_description_node_get_subminor_version(
4474 node: *mut ArvGcRegisterDescriptionNode,
4475 ) -> c_uint;
4476 pub fn arv_gc_register_description_node_get_vendor_name(
4477 node: *mut ArvGcRegisterDescriptionNode,
4478 ) -> *mut c_char;
4479
4480 pub fn arv_gc_register_node_get_type() -> GType;
4484 pub fn arv_gc_register_node_new() -> *mut ArvGcNode;
4485
4486 pub fn arv_gc_string_node_get_type() -> GType;
4490 pub fn arv_gc_string_node_new() -> *mut ArvGcNode;
4491
4492 pub fn arv_gc_string_reg_node_get_type() -> GType;
4496 pub fn arv_gc_string_reg_node_new() -> *mut ArvGcNode;
4497
4498 pub fn arv_gc_struct_entry_node_get_type() -> GType;
4502 pub fn arv_gc_struct_entry_node_new() -> *mut ArvGcNode;
4503
4504 pub fn arv_gc_struct_reg_node_get_type() -> GType;
4508 pub fn arv_gc_struct_reg_node_new() -> *mut ArvGcNode;
4509
4510 pub fn arv_gc_swiss_knife_get_type() -> GType;
4514
4515 pub fn arv_gc_swiss_knife_node_get_type() -> GType;
4519 pub fn arv_gc_swiss_knife_node_new() -> *mut ArvGcNode;
4520
4521 pub fn arv_gc_value_indexed_node_get_type() -> GType;
4525 pub fn arv_gc_value_indexed_node_new() -> *mut ArvGcNode;
4526 pub fn arv_gc_value_indexed_node_get_index(
4527 value_indexed_node: *mut ArvGcValueIndexedNode,
4528 ) -> i64;
4529
4530 pub fn arv_gv_device_get_type() -> GType;
4534 pub fn arv_gv_device_new(
4535 interface_address: *mut gio::GInetAddress,
4536 device_address: *mut gio::GInetAddress,
4537 error: *mut *mut glib::GError,
4538 ) -> *mut ArvDevice;
4539 pub fn arv_gv_device_auto_packet_size(
4540 gv_device: *mut ArvGvDevice,
4541 error: *mut *mut glib::GError,
4542 ) -> c_uint;
4543 #[cfg(feature = "v0_8_22")]
4544 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_22")))]
4545 pub fn arv_gv_device_get_current_ip(
4546 gv_device: *mut ArvGvDevice,
4547 ip: *mut *mut gio::GInetAddress,
4548 mask: *mut *mut gio::GInetAddressMask,
4549 gateway: *mut *mut gio::GInetAddress,
4550 error: *mut *mut glib::GError,
4551 ) -> gboolean;
4552 pub fn arv_gv_device_get_device_address(device: *mut ArvGvDevice) -> *mut gio::GSocketAddress;
4553 pub fn arv_gv_device_get_interface_address(
4554 device: *mut ArvGvDevice,
4555 ) -> *mut gio::GSocketAddress;
4556 #[cfg(feature = "v0_8_22")]
4557 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_22")))]
4558 pub fn arv_gv_device_get_ip_configuration_mode(
4559 gv_device: *mut ArvGvDevice,
4560 error: *mut *mut glib::GError,
4561 ) -> ArvGvIpConfigurationMode;
4562 pub fn arv_gv_device_get_packet_size(
4563 gv_device: *mut ArvGvDevice,
4564 error: *mut *mut glib::GError,
4565 ) -> c_uint;
4566 #[cfg(feature = "v0_8_22")]
4567 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_22")))]
4568 pub fn arv_gv_device_get_persistent_ip(
4569 gv_device: *mut ArvGvDevice,
4570 ip: *mut *mut gio::GInetAddress,
4571 mask: *mut *mut gio::GInetAddressMask,
4572 gateway: *mut *mut gio::GInetAddress,
4573 error: *mut *mut glib::GError,
4574 ) -> gboolean;
4575 pub fn arv_gv_device_get_stream_options(gv_device: *mut ArvGvDevice) -> ArvGvStreamOption;
4576 pub fn arv_gv_device_get_timestamp_tick_frequency(
4577 gv_device: *mut ArvGvDevice,
4578 error: *mut *mut glib::GError,
4579 ) -> u64;
4580 pub fn arv_gv_device_is_controller(gv_device: *mut ArvGvDevice) -> gboolean;
4581 #[cfg(feature = "v0_8_3")]
4582 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_3")))]
4583 pub fn arv_gv_device_leave_control(
4584 gv_device: *mut ArvGvDevice,
4585 error: *mut *mut glib::GError,
4586 ) -> gboolean;
4587 #[cfg(feature = "v0_8_22")]
4588 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_22")))]
4589 pub fn arv_gv_device_set_ip_configuration_mode(
4590 gv_device: *mut ArvGvDevice,
4591 mode: ArvGvIpConfigurationMode,
4592 error: *mut *mut glib::GError,
4593 ) -> gboolean;
4594 pub fn arv_gv_device_set_packet_size(
4595 gv_device: *mut ArvGvDevice,
4596 packet_size: c_int,
4597 error: *mut *mut glib::GError,
4598 );
4599 #[cfg(feature = "v0_8_3")]
4600 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_3")))]
4601 pub fn arv_gv_device_set_packet_size_adjustment(
4602 gv_device: *mut ArvGvDevice,
4603 adjustment: ArvGvPacketSizeAdjustment,
4604 );
4605 #[cfg(feature = "v0_8_22")]
4606 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_22")))]
4607 pub fn arv_gv_device_set_persistent_ip(
4608 gv_device: *mut ArvGvDevice,
4609 ip: *mut gio::GInetAddress,
4610 mask: *mut gio::GInetAddressMask,
4611 gateway: *mut gio::GInetAddress,
4612 error: *mut *mut glib::GError,
4613 ) -> gboolean;
4614 #[cfg(feature = "v0_8_22")]
4615 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_22")))]
4616 pub fn arv_gv_device_set_persistent_ip_from_string(
4617 gv_device: *mut ArvGvDevice,
4618 ip: *const c_char,
4619 mask: *const c_char,
4620 gateway: *const c_char,
4621 error: *mut *mut glib::GError,
4622 ) -> gboolean;
4623 pub fn arv_gv_device_set_stream_options(
4624 gv_device: *mut ArvGvDevice,
4625 options: ArvGvStreamOption,
4626 );
4627 #[cfg(feature = "v0_8_3")]
4628 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_3")))]
4629 pub fn arv_gv_device_take_control(
4630 gv_device: *mut ArvGvDevice,
4631 error: *mut *mut glib::GError,
4632 ) -> gboolean;
4633
4634 pub fn arv_gv_fake_camera_get_type() -> GType;
4638 pub fn arv_gv_fake_camera_new(
4639 interface_name: *const c_char,
4640 serial_number: *const c_char,
4641 ) -> *mut ArvGvFakeCamera;
4642 pub fn arv_gv_fake_camera_new_full(
4643 interface_name: *const c_char,
4644 serial_number: *const c_char,
4645 genicam_filename: *const c_char,
4646 ) -> *mut ArvGvFakeCamera;
4647 pub fn arv_gv_fake_camera_get_fake_camera(
4648 gv_fake_camera: *mut ArvGvFakeCamera,
4649 ) -> *mut ArvFakeCamera;
4650 pub fn arv_gv_fake_camera_is_running(gv_fake_camera: *mut ArvGvFakeCamera) -> gboolean;
4651
4652 pub fn arv_gv_interface_get_type() -> GType;
4656 pub fn arv_gv_interface_get_instance() -> *mut ArvInterface;
4657
4658 pub fn arv_gv_stream_get_type() -> GType;
4662 pub fn arv_gv_stream_get_port(gv_stream: *mut ArvGvStream) -> u16;
4663 pub fn arv_gv_stream_get_statistics(
4664 gv_stream: *mut ArvGvStream,
4665 n_resent_packets: *mut u64,
4666 n_missing_packets: *mut u64,
4667 );
4668
4669 pub fn arv_interface_get_type() -> GType;
4673 pub fn arv_interface_get_device_address(
4674 iface: *mut ArvInterface,
4675 index: c_uint,
4676 ) -> *const c_char;
4677 pub fn arv_interface_get_device_id(iface: *mut ArvInterface, index: c_uint) -> *const c_char;
4678 #[cfg(feature = "v0_8_20")]
4679 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_20")))]
4680 pub fn arv_interface_get_device_manufacturer_info(
4681 iface: *mut ArvInterface,
4682 index: c_uint,
4683 ) -> *const c_char;
4684 pub fn arv_interface_get_device_model(iface: *mut ArvInterface, index: c_uint)
4685 -> *const c_char;
4686 pub fn arv_interface_get_device_physical_id(
4687 iface: *mut ArvInterface,
4688 index: c_uint,
4689 ) -> *const c_char;
4690 pub fn arv_interface_get_device_protocol(
4691 iface: *mut ArvInterface,
4692 index: c_uint,
4693 ) -> *const c_char;
4694 pub fn arv_interface_get_device_serial_nbr(
4695 iface: *mut ArvInterface,
4696 index: c_uint,
4697 ) -> *const c_char;
4698 pub fn arv_interface_get_device_vendor(
4699 iface: *mut ArvInterface,
4700 index: c_uint,
4701 ) -> *const c_char;
4702 pub fn arv_interface_get_n_devices(iface: *mut ArvInterface) -> c_uint;
4703 pub fn arv_interface_open_device(
4704 iface: *mut ArvInterface,
4705 device_id: *const c_char,
4706 error: *mut *mut glib::GError,
4707 ) -> *mut ArvDevice;
4708 pub fn arv_interface_update_device_list(iface: *mut ArvInterface);
4709
4710 pub fn arv_stream_get_type() -> GType;
4714 pub fn arv_stream_get_emit_signals(stream: *mut ArvStream) -> gboolean;
4715 #[cfg(feature = "v0_8_11")]
4716 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_11")))]
4717 pub fn arv_stream_get_info_double(stream: *mut ArvStream, id: c_uint) -> c_double;
4718 #[cfg(feature = "v0_8_11")]
4719 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_11")))]
4720 pub fn arv_stream_get_info_double_by_name(
4721 stream: *mut ArvStream,
4722 name: *const c_char,
4723 ) -> c_double;
4724 #[cfg(feature = "v0_8_11")]
4725 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_11")))]
4726 pub fn arv_stream_get_info_name(stream: *mut ArvStream, id: c_uint) -> *const c_char;
4727 #[cfg(feature = "v0_8_11")]
4728 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_11")))]
4729 pub fn arv_stream_get_info_type(stream: *mut ArvStream, id: c_uint) -> GType;
4730 #[cfg(feature = "v0_8_11")]
4731 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_11")))]
4732 pub fn arv_stream_get_info_uint64(stream: *mut ArvStream, id: c_uint) -> u64;
4733 #[cfg(feature = "v0_8_11")]
4734 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_11")))]
4735 pub fn arv_stream_get_info_uint64_by_name(stream: *mut ArvStream, name: *const c_char) -> u64;
4736 pub fn arv_stream_get_n_buffers(
4737 stream: *mut ArvStream,
4738 n_input_buffers: *mut c_int,
4739 n_output_buffers: *mut c_int,
4740 );
4741 #[cfg(feature = "v0_8_11")]
4742 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_11")))]
4743 pub fn arv_stream_get_n_infos(stream: *mut ArvStream) -> c_uint;
4744 pub fn arv_stream_get_statistics(
4745 stream: *mut ArvStream,
4746 n_completed_buffers: *mut u64,
4747 n_failures: *mut u64,
4748 n_underruns: *mut u64,
4749 );
4750 pub fn arv_stream_pop_buffer(stream: *mut ArvStream) -> *mut ArvBuffer;
4751 pub fn arv_stream_push_buffer(stream: *mut ArvStream, buffer: *mut ArvBuffer);
4752 pub fn arv_stream_set_emit_signals(stream: *mut ArvStream, emit_signals: gboolean);
4753 pub fn arv_stream_start_thread(stream: *mut ArvStream);
4754 pub fn arv_stream_stop_thread(stream: *mut ArvStream, delete_buffers: gboolean) -> c_uint;
4755 pub fn arv_stream_timeout_pop_buffer(stream: *mut ArvStream, timeout: u64) -> *mut ArvBuffer;
4756 pub fn arv_stream_try_pop_buffer(stream: *mut ArvStream) -> *mut ArvBuffer;
4757
4758 pub fn arv_uv_device_get_type() -> GType;
4762 pub fn arv_uv_device_new(
4763 vendor: *const c_char,
4764 product: *const c_char,
4765 serial_number: *const c_char,
4766 error: *mut *mut glib::GError,
4767 ) -> *mut ArvDevice;
4768 #[cfg(feature = "v0_8_17")]
4769 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_17")))]
4770 pub fn arv_uv_device_new_from_guid(
4771 guid: *const c_char,
4772 error: *mut *mut glib::GError,
4773 ) -> *mut ArvDevice;
4774 #[cfg(feature = "v0_8_17")]
4775 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_17")))]
4776 pub fn arv_uv_device_set_usb_mode(uv_device: *mut ArvUvDevice, usb_mode: ArvUvUsbMode);
4777
4778 pub fn arv_uv_interface_get_type() -> GType;
4782 pub fn arv_uv_interface_get_instance() -> *mut ArvInterface;
4783
4784 pub fn arv_uv_stream_get_type() -> GType;
4788
4789 pub fn arv_xml_schema_get_type() -> GType;
4793 pub fn arv_xml_schema_new_from_file(file: *mut gio::GFile) -> *mut ArvXmlSchema;
4794 pub fn arv_xml_schema_new_from_memory(buffer: *const c_char, size: size_t)
4795 -> *mut ArvXmlSchema;
4796 pub fn arv_xml_schema_new_from_path(path: *const c_char) -> *mut ArvXmlSchema;
4797 pub fn arv_xml_schema_validate(
4798 schema: *mut ArvXmlSchema,
4799 xml: *mut c_void,
4800 size: size_t,
4801 line: *mut c_int,
4802 column: *mut c_int,
4803 error: *mut *mut glib::GError,
4804 ) -> gboolean;
4805
4806 pub fn arv_gc_float_get_type() -> GType;
4810 pub fn arv_gc_float_get_display_notation(gc_float: *mut ArvGcFloat) -> ArvGcDisplayNotation;
4811 pub fn arv_gc_float_get_display_precision(gc_float: *mut ArvGcFloat) -> i64;
4812 pub fn arv_gc_float_get_inc(
4813 gc_float: *mut ArvGcFloat,
4814 error: *mut *mut glib::GError,
4815 ) -> c_double;
4816 pub fn arv_gc_float_get_max(
4817 gc_float: *mut ArvGcFloat,
4818 error: *mut *mut glib::GError,
4819 ) -> c_double;
4820 pub fn arv_gc_float_get_min(
4821 gc_float: *mut ArvGcFloat,
4822 error: *mut *mut glib::GError,
4823 ) -> c_double;
4824 pub fn arv_gc_float_get_representation(gc_float: *mut ArvGcFloat) -> ArvGcRepresentation;
4825 pub fn arv_gc_float_get_unit(gc_float: *mut ArvGcFloat) -> *const c_char;
4826 pub fn arv_gc_float_get_value(
4827 gc_float: *mut ArvGcFloat,
4828 error: *mut *mut glib::GError,
4829 ) -> c_double;
4830 pub fn arv_gc_float_impose_max(
4831 gc_float: *mut ArvGcFloat,
4832 maximum: c_double,
4833 error: *mut *mut glib::GError,
4834 );
4835 pub fn arv_gc_float_impose_min(
4836 gc_float: *mut ArvGcFloat,
4837 minimum: c_double,
4838 error: *mut *mut glib::GError,
4839 );
4840 pub fn arv_gc_float_set_value(
4841 gc_float: *mut ArvGcFloat,
4842 value: c_double,
4843 error: *mut *mut glib::GError,
4844 );
4845
4846 pub fn arv_gc_integer_get_type() -> GType;
4850 pub fn arv_gc_integer_get_inc(
4851 gc_integer: *mut ArvGcInteger,
4852 error: *mut *mut glib::GError,
4853 ) -> i64;
4854 pub fn arv_gc_integer_get_max(
4855 gc_integer: *mut ArvGcInteger,
4856 error: *mut *mut glib::GError,
4857 ) -> i64;
4858 pub fn arv_gc_integer_get_min(
4859 gc_integer: *mut ArvGcInteger,
4860 error: *mut *mut glib::GError,
4861 ) -> i64;
4862 pub fn arv_gc_integer_get_representation(gc_integer: *mut ArvGcInteger) -> ArvGcRepresentation;
4863 pub fn arv_gc_integer_get_unit(gc_integer: *mut ArvGcInteger) -> *const c_char;
4864 pub fn arv_gc_integer_get_value(
4865 gc_integer: *mut ArvGcInteger,
4866 error: *mut *mut glib::GError,
4867 ) -> i64;
4868 pub fn arv_gc_integer_impose_max(
4869 gc_integer: *mut ArvGcInteger,
4870 maximum: i64,
4871 error: *mut *mut glib::GError,
4872 );
4873 pub fn arv_gc_integer_impose_min(
4874 gc_integer: *mut ArvGcInteger,
4875 minimum: i64,
4876 error: *mut *mut glib::GError,
4877 );
4878 pub fn arv_gc_integer_set_value(
4879 gc_integer: *mut ArvGcInteger,
4880 value: i64,
4881 error: *mut *mut glib::GError,
4882 );
4883
4884 pub fn arv_gc_register_get_type() -> GType;
4888 #[cfg(feature = "v0_8_31")]
4889 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_31")))]
4890 pub fn arv_gc_register_dup(
4891 gc_register: *mut ArvGcRegister,
4892 length: *mut u64,
4893 error: *mut *mut glib::GError,
4894 ) -> *mut c_void;
4895 pub fn arv_gc_register_get(
4896 gc_register: *mut ArvGcRegister,
4897 buffer: *mut c_void,
4898 length: u64,
4899 error: *mut *mut glib::GError,
4900 );
4901 pub fn arv_gc_register_get_address(
4902 gc_register: *mut ArvGcRegister,
4903 error: *mut *mut glib::GError,
4904 ) -> u64;
4905 pub fn arv_gc_register_get_length(
4906 gc_register: *mut ArvGcRegister,
4907 error: *mut *mut glib::GError,
4908 ) -> u64;
4909 pub fn arv_gc_register_set(
4910 gc_register: *mut ArvGcRegister,
4911 buffer: *mut c_void,
4912 length: u64,
4913 error: *mut *mut glib::GError,
4914 );
4915
4916 pub fn arv_gc_selector_get_type() -> GType;
4920 pub fn arv_gc_selector_get_selected_features(
4921 gc_selector: *mut ArvGcSelector,
4922 ) -> *const glib::GSList;
4923 pub fn arv_gc_selector_is_selector(gc_selector: *mut ArvGcSelector) -> gboolean;
4924
4925 pub fn arv_gc_string_get_type() -> GType;
4929 pub fn arv_gc_string_get_max_length(
4930 gc_string: *mut ArvGcString,
4931 error: *mut *mut glib::GError,
4932 ) -> i64;
4933 pub fn arv_gc_string_get_value(
4934 gc_string: *mut ArvGcString,
4935 error: *mut *mut glib::GError,
4936 ) -> *const c_char;
4937 pub fn arv_gc_string_set_value(
4938 gc_string: *mut ArvGcString,
4939 value: *const c_char,
4940 error: *mut *mut glib::GError,
4941 );
4942
4943 #[cfg(feature = "v0_8_8")]
4947 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_8")))]
4948 pub fn arv_debug_enable(category_selection: *const c_char) -> gboolean;
4949 pub fn arv_disable_interface(interface_id: *const c_char);
4950 pub fn arv_dom_implementation_add_document_type(
4951 qualified_name: *const c_char,
4952 document_type: GType,
4953 );
4954 pub fn arv_dom_implementation_cleanup();
4955 pub fn arv_dom_implementation_create_document(
4956 namespace_uri: *const c_char,
4957 qualified_name: *const c_char,
4958 ) -> *mut ArvDomDocument;
4959 pub fn arv_enable_interface(interface_id: *const c_char);
4960 pub fn arv_get_device_address(index: c_uint) -> *const c_char;
4961 pub fn arv_get_device_id(index: c_uint) -> *const c_char;
4962 #[cfg(feature = "v0_8_20")]
4963 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_20")))]
4964 pub fn arv_get_device_manufacturer_info(index: c_uint) -> *const c_char;
4965 pub fn arv_get_device_model(index: c_uint) -> *const c_char;
4966 pub fn arv_get_device_physical_id(index: c_uint) -> *const c_char;
4967 pub fn arv_get_device_protocol(index: c_uint) -> *const c_char;
4968 pub fn arv_get_device_serial_nbr(index: c_uint) -> *const c_char;
4969 pub fn arv_get_device_vendor(index: c_uint) -> *const c_char;
4970 pub fn arv_get_interface_id(index: c_uint) -> *const c_char;
4971 pub fn arv_get_n_devices() -> c_uint;
4972 pub fn arv_get_n_interfaces() -> c_uint;
4973 pub fn arv_make_thread_high_priority(nice_level: c_int) -> gboolean;
4974 pub fn arv_make_thread_realtime(priority: c_int) -> gboolean;
4975 pub fn arv_open_device(
4976 device_id: *const c_char,
4977 error: *mut *mut glib::GError,
4978 ) -> *mut ArvDevice;
4979 pub fn arv_set_fake_camera_genicam_filename(filename: *const c_char);
4980 #[cfg(feature = "v0_8_23")]
4981 #[cfg_attr(docsrs, doc(cfg(feature = "v0_8_23")))]
4982 pub fn arv_set_interface_flags(interface_id: *const c_char, flags: c_int);
4983 pub fn arv_shutdown();
4984 pub fn arv_update_device_list();
4985
4986}