├── .github └── workflows │ └── ci.yml ├── .gitignore ├── COPYRIGHT ├── Cargo.toml ├── LICENSE-APACHE ├── LICENSE-MIT ├── Makefile.in ├── README.md ├── configure ├── etc ├── bindgen.sh └── bindings.h └── src ├── freetype.rs ├── lib.rs └── tt_os2.rs /.github/workflows/ci.yml: -------------------------------------------------------------------------------- 1 | name: CI 2 | 3 | on: 4 | push: 5 | branches: 6 | - main 7 | pull_request: 8 | 9 | jobs: 10 | rust: 11 | strategy: 12 | matrix: 13 | toolchain: [stable, beta, nightly] 14 | name: Rust 15 | runs-on: ubuntu-22.04 16 | steps: 17 | - uses: actions/checkout@v4 18 | - uses: dtolnay/rust-toolchain@master 19 | with: 20 | profile: minimal 21 | override: true 22 | toolchain: ${{ matrix.toolchain }} 23 | - run: cargo build 24 | - run: cargo test 25 | 26 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *.dummy 2 | *.rlib 3 | *.so 4 | Makefile 5 | /doc 6 | /target 7 | /Cargo.lock 8 | -------------------------------------------------------------------------------- /COPYRIGHT: -------------------------------------------------------------------------------- 1 | Licensed under the Apache License, Version 2.0 or the MIT license 3 | , at your 4 | option. All files in the project carrying such notice may not be 5 | copied, modified, or distributed except according to those terms. 6 | -------------------------------------------------------------------------------- /Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "freetype" 3 | version = "0.7.2" 4 | authors = ["The Servo Project Developers"] 5 | description = "Bindings for FreeType used by Servo." 6 | documentation = "https://docs.rs/freetype" 7 | repository = "https://github.com/servo/rust-freetype" 8 | license = "MIT OR Apache-2.0" 9 | 10 | [lib] 11 | name = "freetype" 12 | crate-type = ["rlib"] 13 | 14 | [dependencies] 15 | freetype-sys = { version = "0.20.1", optional = true } 16 | libc = "0.2" 17 | 18 | [features] 19 | default = ["freetype-sys"] 20 | -------------------------------------------------------------------------------- /LICENSE-APACHE: -------------------------------------------------------------------------------- 1 | Apache License 2 | Version 2.0, January 2004 3 | http://www.apache.org/licenses/ 4 | 5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 6 | 7 | 1. Definitions. 8 | 9 | "License" shall mean the terms and conditions for use, reproduction, 10 | and distribution as defined by Sections 1 through 9 of this document. 11 | 12 | "Licensor" shall mean the copyright owner or entity authorized by 13 | the copyright owner that is granting the License. 14 | 15 | "Legal Entity" shall mean the union of the acting entity and all 16 | other entities that control, are controlled by, or are under common 17 | control with that entity. For the purposes of this definition, 18 | "control" means (i) the power, direct or indirect, to cause the 19 | direction or management of such entity, whether by contract or 20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the 21 | outstanding shares, or (iii) beneficial ownership of such entity. 22 | 23 | "You" (or "Your") shall mean an individual or Legal Entity 24 | exercising permissions granted by this License. 25 | 26 | "Source" form shall mean the preferred form for making modifications, 27 | including but not limited to software source code, documentation 28 | source, and configuration files. 29 | 30 | "Object" form shall mean any form resulting from mechanical 31 | transformation or translation of a Source form, including but 32 | not limited to compiled object code, generated documentation, 33 | and conversions to other media types. 34 | 35 | "Work" shall mean the work of authorship, whether in Source or 36 | Object form, made available under the License, as indicated by a 37 | copyright notice that is included in or attached to the work 38 | (an example is provided in the Appendix below). 39 | 40 | "Derivative Works" shall mean any work, whether in Source or Object 41 | form, that is based on (or derived from) the Work and for which the 42 | editorial revisions, annotations, elaborations, or other modifications 43 | represent, as a whole, an original work of authorship. For the purposes 44 | of this License, Derivative Works shall not include works that remain 45 | separable from, or merely link (or bind by name) to the interfaces of, 46 | the Work and Derivative Works thereof. 47 | 48 | "Contribution" shall mean any work of authorship, including 49 | the original version of the Work and any modifications or additions 50 | to that Work or Derivative Works thereof, that is intentionally 51 | submitted to Licensor for inclusion in the Work by the copyright owner 52 | or by an individual or Legal Entity authorized to submit on behalf of 53 | the copyright owner. For the purposes of this definition, "submitted" 54 | means any form of electronic, verbal, or written communication sent 55 | to the Licensor or its representatives, including but not limited to 56 | communication on electronic mailing lists, source code control systems, 57 | and issue tracking systems that are managed by, or on behalf of, the 58 | Licensor for the purpose of discussing and improving the Work, but 59 | excluding communication that is conspicuously marked or otherwise 60 | designated in writing by the copyright owner as "Not a Contribution." 61 | 62 | "Contributor" shall mean Licensor and any individual or Legal Entity 63 | on behalf of whom a Contribution has been received by Licensor and 64 | subsequently incorporated within the Work. 65 | 66 | 2. Grant of Copyright License. Subject to the terms and conditions of 67 | this License, each Contributor hereby grants to You a perpetual, 68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 69 | copyright license to reproduce, prepare Derivative Works of, 70 | publicly display, publicly perform, sublicense, and distribute the 71 | Work and such Derivative Works in Source or Object form. 72 | 73 | 3. Grant of Patent License. Subject to the terms and conditions of 74 | this License, each Contributor hereby grants to You a perpetual, 75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 76 | (except as stated in this section) patent license to make, have made, 77 | use, offer to sell, sell, import, and otherwise transfer the Work, 78 | where such license applies only to those patent claims licensable 79 | by such Contributor that are necessarily infringed by their 80 | Contribution(s) alone or by combination of their Contribution(s) 81 | with the Work to which such Contribution(s) was submitted. If You 82 | institute patent litigation against any entity (including a 83 | cross-claim or counterclaim in a lawsuit) alleging that the Work 84 | or a Contribution incorporated within the Work constitutes direct 85 | or contributory patent infringement, then any patent licenses 86 | granted to You under this License for that Work shall terminate 87 | as of the date such litigation is filed. 88 | 89 | 4. Redistribution. You may reproduce and distribute copies of the 90 | Work or Derivative Works thereof in any medium, with or without 91 | modifications, and in Source or Object form, provided that You 92 | meet the following conditions: 93 | 94 | (a) You must give any other recipients of the Work or 95 | Derivative Works a copy of this License; and 96 | 97 | (b) You must cause any modified files to carry prominent notices 98 | stating that You changed the files; and 99 | 100 | (c) You must retain, in the Source form of any Derivative Works 101 | that You distribute, all copyright, patent, trademark, and 102 | attribution notices from the Source form of the Work, 103 | excluding those notices that do not pertain to any part of 104 | the Derivative Works; and 105 | 106 | (d) If the Work includes a "NOTICE" text file as part of its 107 | distribution, then any Derivative Works that You distribute must 108 | include a readable copy of the attribution notices contained 109 | within such NOTICE file, excluding those notices that do not 110 | pertain to any part of the Derivative Works, in at least one 111 | of the following places: within a NOTICE text file distributed 112 | as part of the Derivative Works; within the Source form or 113 | documentation, if provided along with the Derivative Works; or, 114 | within a display generated by the Derivative Works, if and 115 | wherever such third-party notices normally appear. The contents 116 | of the NOTICE file are for informational purposes only and 117 | do not modify the License. You may add Your own attribution 118 | notices within Derivative Works that You distribute, alongside 119 | or as an addendum to the NOTICE text from the Work, provided 120 | that such additional attribution notices cannot be construed 121 | as modifying the License. 122 | 123 | You may add Your own copyright statement to Your modifications and 124 | may provide additional or different license terms and conditions 125 | for use, reproduction, or distribution of Your modifications, or 126 | for any such Derivative Works as a whole, provided Your use, 127 | reproduction, and distribution of the Work otherwise complies with 128 | the conditions stated in this License. 129 | 130 | 5. Submission of Contributions. Unless You explicitly state otherwise, 131 | any Contribution intentionally submitted for inclusion in the Work 132 | by You to the Licensor shall be under the terms and conditions of 133 | this License, without any additional terms or conditions. 134 | Notwithstanding the above, nothing herein shall supersede or modify 135 | the terms of any separate license agreement you may have executed 136 | with Licensor regarding such Contributions. 137 | 138 | 6. Trademarks. This License does not grant permission to use the trade 139 | names, trademarks, service marks, or product names of the Licensor, 140 | except as required for reasonable and customary use in describing the 141 | origin of the Work and reproducing the content of the NOTICE file. 142 | 143 | 7. Disclaimer of Warranty. Unless required by applicable law or 144 | agreed to in writing, Licensor provides the Work (and each 145 | Contributor provides its Contributions) on an "AS IS" BASIS, 146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 147 | implied, including, without limitation, any warranties or conditions 148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A 149 | PARTICULAR PURPOSE. You are solely responsible for determining the 150 | appropriateness of using or redistributing the Work and assume any 151 | risks associated with Your exercise of permissions under this License. 152 | 153 | 8. Limitation of Liability. In no event and under no legal theory, 154 | whether in tort (including negligence), contract, or otherwise, 155 | unless required by applicable law (such as deliberate and grossly 156 | negligent acts) or agreed to in writing, shall any Contributor be 157 | liable to You for damages, including any direct, indirect, special, 158 | incidental, or consequential damages of any character arising as a 159 | result of this License or out of the use or inability to use the 160 | Work (including but not limited to damages for loss of goodwill, 161 | work stoppage, computer failure or malfunction, or any and all 162 | other commercial damages or losses), even if such Contributor 163 | has been advised of the possibility of such damages. 164 | 165 | 9. Accepting Warranty or Additional Liability. While redistributing 166 | the Work or Derivative Works thereof, You may choose to offer, 167 | and charge a fee for, acceptance of support, warranty, indemnity, 168 | or other liability obligations and/or rights consistent with this 169 | License. However, in accepting such obligations, You may act only 170 | on Your own behalf and on Your sole responsibility, not on behalf 171 | of any other Contributor, and only if You agree to indemnify, 172 | defend, and hold each Contributor harmless for any liability 173 | incurred by, or claims asserted against, such Contributor by reason 174 | of your accepting any such warranty or additional liability. 175 | 176 | END OF TERMS AND CONDITIONS 177 | 178 | APPENDIX: How to apply the Apache License to your work. 179 | 180 | To apply the Apache License to your work, attach the following 181 | boilerplate notice, with the fields enclosed by brackets "[]" 182 | replaced with your own identifying information. (Don't include 183 | the brackets!) The text should be enclosed in the appropriate 184 | comment syntax for the file format. We also recommend that a 185 | file or class name and description of purpose be included on the 186 | same "printed page" as the copyright notice for easier 187 | identification within third-party archives. 188 | 189 | Copyright [yyyy] [name of copyright owner] 190 | 191 | Licensed under the Apache License, Version 2.0 (the "License"); 192 | you may not use this file except in compliance with the License. 193 | You may obtain a copy of the License at 194 | 195 | http://www.apache.org/licenses/LICENSE-2.0 196 | 197 | Unless required by applicable law or agreed to in writing, software 198 | distributed under the License is distributed on an "AS IS" BASIS, 199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 200 | See the License for the specific language governing permissions and 201 | limitations under the License. 202 | -------------------------------------------------------------------------------- /LICENSE-MIT: -------------------------------------------------------------------------------- 1 | Copyright (c) 2012-2013 Mozilla Foundation 2 | 3 | Permission is hereby granted, free of charge, to any 4 | person obtaining a copy of this software and associated 5 | documentation files (the "Software"), to deal in the 6 | Software without restriction, including without 7 | limitation the rights to use, copy, modify, merge, 8 | publish, distribute, sublicense, and/or sell copies of 9 | the Software, and to permit persons to whom the Software 10 | is furnished to do so, subject to the following 11 | conditions: 12 | 13 | The above copyright notice and this permission notice 14 | shall be included in all copies or substantial portions 15 | of the Software. 16 | 17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF 18 | ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED 19 | TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 20 | PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT 21 | SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 22 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 23 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR 24 | IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 25 | DEALINGS IN THE SOFTWARE. 26 | -------------------------------------------------------------------------------- /Makefile.in: -------------------------------------------------------------------------------- 1 | VPATH=%VPATH% 2 | 3 | RUSTC ?= rustc 4 | RUSTFLAGS ?= 5 | EXT_DEPS ?= 6 | RUSTDOC ?= rustdoc 7 | RUSTDOC_FLAGS ?= 8 | RUSTDOC_TARGET ?= doc 9 | 10 | ifeq ($(CFG_OSTYPE),linux-androideabi) 11 | RUSTFLAGS += -L./../../android/libfreetype2/.libs 12 | endif 13 | 14 | RUST_SRC=$(shell find $(VPATH)/src -type f -name '*.rs') 15 | 16 | .PHONY: all clean 17 | all: libfreetype-servo.dummy 18 | 19 | libfreetype-servo.dummy: src/lib.rs $(RUST_SRC) $(EXT_DEPS) 20 | $(RUSTC) $(RUSTFLAGS) $< --out-dir . -C extra-filename=-servo 21 | touch $@ 22 | 23 | freetype-test: src/lib.rs $(RUST_SRC) 24 | $(RUSTC) $(RUSTFLAGS) $< -o $@ --test 25 | 26 | check: freetype-test 27 | ./freetype-test 28 | 29 | .PHONY: doc 30 | doc: $(RUSTDOC_TARGET)/freetype/index.html 31 | 32 | $(RUSTDOC_TARGET)/freetype/index.html: src/lib.rs $(RUST_SRC) $(EXT_DEPS) 33 | $(RUSTDOC) $(RUSTDOC_FLAGS) $< -o $(RUSTDOC_TARGET) 34 | 35 | clean: 36 | rm -f *.o *.a *.so *.dylib *.rlib *.dll *.dummy *-test 37 | 38 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # rust-freetype 2 | 3 | [Documentation](https://docs.rs/freetype) 4 | -------------------------------------------------------------------------------- /configure: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | SRCDIR="$(cd $(dirname $0) && pwd)" 4 | sed "s#%VPATH%#${SRCDIR}#" ${SRCDIR}/Makefile.in > Makefile 5 | 6 | -------------------------------------------------------------------------------- /etc/bindgen.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | cd "$(dirname $0)" 4 | 5 | # We replace the FT_ integer types of known widths, since we can do better. 6 | # 7 | # We blacklist FT_Error and import our own in order to have convenience methods 8 | # on it instead of being a plain integer. 9 | "${BINDGEN}" bindings.h -o ../src/freetype.rs \ 10 | --blacklist-type "FT_(Int16|UInt16|Int32|UInt32|Int16|Int64|UInt64)" \ 11 | --raw-line "pub type FT_Int16 = i16;" \ 12 | --raw-line "pub type FT_UInt16 = u16;" \ 13 | --raw-line "pub type FT_Int32 = i32;" \ 14 | --raw-line "pub type FT_UInt32 = u32;" \ 15 | --raw-line "pub type FT_Int64= i64;" \ 16 | --raw-line "pub type FT_UInt64= u64;" \ 17 | --blacklist-type "FT_Error" \ 18 | --raw-line "pub use FT_Error;" \ 19 | --generate=functions,types,vars \ 20 | --whitelist-function="FT_.*" \ 21 | --whitelist-type="FT_.*" \ 22 | --whitelist-var="FT_.*" \ 23 | -- -I/usr/include/freetype2 24 | -------------------------------------------------------------------------------- /etc/bindings.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | -------------------------------------------------------------------------------- /src/freetype.rs: -------------------------------------------------------------------------------- 1 | /* automatically generated by rust-bindgen */ 2 | 3 | pub type FT_Int16 = i16; 4 | pub type FT_UInt16 = u16; 5 | pub type FT_Int32 = i32; 6 | pub type FT_UInt32 = u32; 7 | pub type FT_Int64= i64; 8 | pub type FT_UInt64= u64; 9 | pub use FT_Error; 10 | 11 | #[repr(C)] 12 | pub struct __BindgenUnionField(::std::marker::PhantomData); 13 | impl __BindgenUnionField { 14 | #[inline] 15 | pub fn new() -> Self { __BindgenUnionField(::std::marker::PhantomData) } 16 | #[inline] 17 | pub unsafe fn as_ref(&self) -> &T { ::std::mem::transmute(self) } 18 | #[inline] 19 | pub unsafe fn as_mut(&mut self) -> &mut T { ::std::mem::transmute(self) } 20 | } 21 | impl ::std::default::Default for __BindgenUnionField { 22 | #[inline] 23 | fn default() -> Self { Self::new() } 24 | } 25 | impl ::std::clone::Clone for __BindgenUnionField { 26 | #[inline] 27 | fn clone(&self) -> Self { Self::new() } 28 | } 29 | impl ::std::marker::Copy for __BindgenUnionField { } 30 | impl ::std::fmt::Debug for __BindgenUnionField { 31 | fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 32 | fmt.write_str("__BindgenUnionField") 33 | } 34 | } 35 | pub const FT_RENDER_POOL_SIZE: ::std::os::raw::c_uint = 16384; 36 | pub const FT_MAX_MODULES: ::std::os::raw::c_uint = 32; 37 | pub const FT_OUTLINE_NONE: ::std::os::raw::c_uint = 0; 38 | pub const FT_OUTLINE_OWNER: ::std::os::raw::c_uint = 1; 39 | pub const FT_OUTLINE_EVEN_ODD_FILL: ::std::os::raw::c_uint = 2; 40 | pub const FT_OUTLINE_REVERSE_FILL: ::std::os::raw::c_uint = 4; 41 | pub const FT_OUTLINE_IGNORE_DROPOUTS: ::std::os::raw::c_uint = 8; 42 | pub const FT_OUTLINE_SMART_DROPOUTS: ::std::os::raw::c_uint = 16; 43 | pub const FT_OUTLINE_INCLUDE_STUBS: ::std::os::raw::c_uint = 32; 44 | pub const FT_OUTLINE_HIGH_PRECISION: ::std::os::raw::c_uint = 256; 45 | pub const FT_OUTLINE_SINGLE_PASS: ::std::os::raw::c_uint = 512; 46 | pub const FT_CURVE_TAG_ON: ::std::os::raw::c_uint = 1; 47 | pub const FT_CURVE_TAG_CONIC: ::std::os::raw::c_uint = 0; 48 | pub const FT_CURVE_TAG_CUBIC: ::std::os::raw::c_uint = 2; 49 | pub const FT_CURVE_TAG_HAS_SCANMODE: ::std::os::raw::c_uint = 4; 50 | pub const FT_CURVE_TAG_TOUCH_X: ::std::os::raw::c_uint = 8; 51 | pub const FT_CURVE_TAG_TOUCH_Y: ::std::os::raw::c_uint = 16; 52 | pub const FT_CURVE_TAG_TOUCH_BOTH: ::std::os::raw::c_uint = 24; 53 | pub const FT_Curve_Tag_On: ::std::os::raw::c_uint = 1; 54 | pub const FT_Curve_Tag_Conic: ::std::os::raw::c_uint = 0; 55 | pub const FT_Curve_Tag_Cubic: ::std::os::raw::c_uint = 2; 56 | pub const FT_Curve_Tag_Touch_X: ::std::os::raw::c_uint = 8; 57 | pub const FT_Curve_Tag_Touch_Y: ::std::os::raw::c_uint = 16; 58 | pub const FT_RASTER_FLAG_DEFAULT: ::std::os::raw::c_uint = 0; 59 | pub const FT_RASTER_FLAG_AA: ::std::os::raw::c_uint = 1; 60 | pub const FT_RASTER_FLAG_DIRECT: ::std::os::raw::c_uint = 2; 61 | pub const FT_RASTER_FLAG_CLIP: ::std::os::raw::c_uint = 4; 62 | pub const FT_ERR_BASE: ::std::os::raw::c_uint = 0; 63 | pub const FT_FACE_FLAG_SCALABLE: ::std::os::raw::c_uint = 1; 64 | pub const FT_FACE_FLAG_FIXED_SIZES: ::std::os::raw::c_uint = 2; 65 | pub const FT_FACE_FLAG_FIXED_WIDTH: ::std::os::raw::c_uint = 4; 66 | pub const FT_FACE_FLAG_SFNT: ::std::os::raw::c_uint = 8; 67 | pub const FT_FACE_FLAG_HORIZONTAL: ::std::os::raw::c_uint = 16; 68 | pub const FT_FACE_FLAG_VERTICAL: ::std::os::raw::c_uint = 32; 69 | pub const FT_FACE_FLAG_KERNING: ::std::os::raw::c_uint = 64; 70 | pub const FT_FACE_FLAG_FAST_GLYPHS: ::std::os::raw::c_uint = 128; 71 | pub const FT_FACE_FLAG_MULTIPLE_MASTERS: ::std::os::raw::c_uint = 256; 72 | pub const FT_FACE_FLAG_GLYPH_NAMES: ::std::os::raw::c_uint = 512; 73 | pub const FT_FACE_FLAG_EXTERNAL_STREAM: ::std::os::raw::c_uint = 1024; 74 | pub const FT_FACE_FLAG_HINTER: ::std::os::raw::c_uint = 2048; 75 | pub const FT_FACE_FLAG_CID_KEYED: ::std::os::raw::c_uint = 4096; 76 | pub const FT_FACE_FLAG_TRICKY: ::std::os::raw::c_uint = 8192; 77 | pub const FT_FACE_FLAG_COLOR: ::std::os::raw::c_uint = 16384; 78 | pub const FT_STYLE_FLAG_ITALIC: ::std::os::raw::c_uint = 1; 79 | pub const FT_STYLE_FLAG_BOLD: ::std::os::raw::c_uint = 2; 80 | pub const FT_OPEN_MEMORY: ::std::os::raw::c_uint = 1; 81 | pub const FT_OPEN_STREAM: ::std::os::raw::c_uint = 2; 82 | pub const FT_OPEN_PATHNAME: ::std::os::raw::c_uint = 4; 83 | pub const FT_OPEN_DRIVER: ::std::os::raw::c_uint = 8; 84 | pub const FT_OPEN_PARAMS: ::std::os::raw::c_uint = 16; 85 | pub const FT_LOAD_DEFAULT: ::std::os::raw::c_uint = 0; 86 | pub const FT_LOAD_NO_SCALE: ::std::os::raw::c_uint = 1; 87 | pub const FT_LOAD_NO_HINTING: ::std::os::raw::c_uint = 2; 88 | pub const FT_LOAD_RENDER: ::std::os::raw::c_uint = 4; 89 | pub const FT_LOAD_NO_BITMAP: ::std::os::raw::c_uint = 8; 90 | pub const FT_LOAD_VERTICAL_LAYOUT: ::std::os::raw::c_uint = 16; 91 | pub const FT_LOAD_FORCE_AUTOHINT: ::std::os::raw::c_uint = 32; 92 | pub const FT_LOAD_CROP_BITMAP: ::std::os::raw::c_uint = 64; 93 | pub const FT_LOAD_PEDANTIC: ::std::os::raw::c_uint = 128; 94 | pub const FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH: ::std::os::raw::c_uint = 512; 95 | pub const FT_LOAD_NO_RECURSE: ::std::os::raw::c_uint = 1024; 96 | pub const FT_LOAD_IGNORE_TRANSFORM: ::std::os::raw::c_uint = 2048; 97 | pub const FT_LOAD_MONOCHROME: ::std::os::raw::c_uint = 4096; 98 | pub const FT_LOAD_LINEAR_DESIGN: ::std::os::raw::c_uint = 8192; 99 | pub const FT_LOAD_NO_AUTOHINT: ::std::os::raw::c_uint = 32768; 100 | pub const FT_LOAD_COLOR: ::std::os::raw::c_uint = 1048576; 101 | pub const FT_LOAD_COMPUTE_METRICS: ::std::os::raw::c_uint = 2097152; 102 | pub const FT_LOAD_ADVANCE_ONLY: ::std::os::raw::c_uint = 256; 103 | pub const FT_LOAD_SBITS_ONLY: ::std::os::raw::c_uint = 16384; 104 | pub const FT_SUBGLYPH_FLAG_ARGS_ARE_WORDS: ::std::os::raw::c_uint = 1; 105 | pub const FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES: ::std::os::raw::c_uint = 2; 106 | pub const FT_SUBGLYPH_FLAG_ROUND_XY_TO_GRID: ::std::os::raw::c_uint = 4; 107 | pub const FT_SUBGLYPH_FLAG_SCALE: ::std::os::raw::c_uint = 8; 108 | pub const FT_SUBGLYPH_FLAG_XY_SCALE: ::std::os::raw::c_uint = 64; 109 | pub const FT_SUBGLYPH_FLAG_2X2: ::std::os::raw::c_uint = 128; 110 | pub const FT_SUBGLYPH_FLAG_USE_MY_METRICS: ::std::os::raw::c_uint = 512; 111 | pub const FT_FSTYPE_INSTALLABLE_EMBEDDING: ::std::os::raw::c_uint = 0; 112 | pub const FT_FSTYPE_RESTRICTED_LICENSE_EMBEDDING: ::std::os::raw::c_uint = 2; 113 | pub const FT_FSTYPE_PREVIEW_AND_PRINT_EMBEDDING: ::std::os::raw::c_uint = 4; 114 | pub const FT_FSTYPE_EDITABLE_EMBEDDING: ::std::os::raw::c_uint = 8; 115 | pub const FT_FSTYPE_NO_SUBSETTING: ::std::os::raw::c_uint = 256; 116 | pub const FT_FSTYPE_BITMAP_EMBEDDING_ONLY: ::std::os::raw::c_uint = 512; 117 | pub const FT_MODULE_FONT_DRIVER: ::std::os::raw::c_uint = 1; 118 | pub const FT_MODULE_RENDERER: ::std::os::raw::c_uint = 2; 119 | pub const FT_MODULE_HINTER: ::std::os::raw::c_uint = 4; 120 | pub const FT_MODULE_STYLER: ::std::os::raw::c_uint = 8; 121 | pub const FT_MODULE_DRIVER_SCALABLE: ::std::os::raw::c_uint = 256; 122 | pub const FT_MODULE_DRIVER_NO_OUTLINES: ::std::os::raw::c_uint = 512; 123 | pub const FT_MODULE_DRIVER_HAS_HINTER: ::std::os::raw::c_uint = 1024; 124 | pub const FT_MODULE_DRIVER_HINTS_LIGHTLY: ::std::os::raw::c_uint = 2048; 125 | pub type FT_Fast = ::std::os::raw::c_int; 126 | pub type FT_UFast = ::std::os::raw::c_uint; 127 | #[repr(C)] 128 | #[derive(Debug, Copy)] 129 | pub struct FT_MemoryRec_ { 130 | pub user: *mut ::std::os::raw::c_void, 131 | pub alloc: FT_Alloc_Func, 132 | pub free: FT_Free_Func, 133 | pub realloc: FT_Realloc_Func, 134 | } 135 | #[test] 136 | fn bindgen_test_layout_FT_MemoryRec_() { 137 | assert_eq!(::std::mem::size_of::() , 32usize , concat ! ( 138 | "Size of: " , stringify ! ( FT_MemoryRec_ ) )); 139 | assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( 140 | "Alignment of " , stringify ! ( FT_MemoryRec_ ) )); 141 | assert_eq! (unsafe { 142 | & ( * ( 0 as * const FT_MemoryRec_ ) ) . user as * const _ as 143 | usize } , 0usize , concat ! ( 144 | "Alignment of field: " , stringify ! ( FT_MemoryRec_ ) , "::" 145 | , stringify ! ( user ) )); 146 | assert_eq! (unsafe { 147 | & ( * ( 0 as * const FT_MemoryRec_ ) ) . alloc as * const _ as 148 | usize } , 8usize , concat ! ( 149 | "Alignment of field: " , stringify ! ( FT_MemoryRec_ ) , "::" 150 | , stringify ! ( alloc ) )); 151 | assert_eq! (unsafe { 152 | & ( * ( 0 as * const FT_MemoryRec_ ) ) . free as * const _ as 153 | usize } , 16usize , concat ! ( 154 | "Alignment of field: " , stringify ! ( FT_MemoryRec_ ) , "::" 155 | , stringify ! ( free ) )); 156 | assert_eq! (unsafe { 157 | & ( * ( 0 as * const FT_MemoryRec_ ) ) . realloc as * const _ 158 | as usize } , 24usize , concat ! ( 159 | "Alignment of field: " , stringify ! ( FT_MemoryRec_ ) , "::" 160 | , stringify ! ( realloc ) )); 161 | } 162 | impl Clone for FT_MemoryRec_ { 163 | fn clone(&self) -> Self { *self } 164 | } 165 | pub type FT_Memory = *mut FT_MemoryRec_; 166 | pub type FT_Alloc_Func = 167 | ::std::option::Option *mut ::std::os::raw::c_void>; 170 | pub type FT_Free_Func = 171 | ::std::option::Option; 174 | pub type FT_Realloc_Func = 175 | ::std::option::Option *mut ::std::os::raw::c_void>; 183 | #[repr(C)] 184 | #[derive(Debug, Copy)] 185 | pub struct FT_StreamRec_ { 186 | pub base: *mut ::std::os::raw::c_uchar, 187 | pub size: ::std::os::raw::c_ulong, 188 | pub pos: ::std::os::raw::c_ulong, 189 | pub descriptor: FT_StreamDesc, 190 | pub pathname: FT_StreamDesc, 191 | pub read: FT_Stream_IoFunc, 192 | pub close: FT_Stream_CloseFunc, 193 | pub memory: FT_Memory, 194 | pub cursor: *mut ::std::os::raw::c_uchar, 195 | pub limit: *mut ::std::os::raw::c_uchar, 196 | } 197 | #[test] 198 | fn bindgen_test_layout_FT_StreamRec_() { 199 | assert_eq!(::std::mem::size_of::() , 80usize , concat ! ( 200 | "Size of: " , stringify ! ( FT_StreamRec_ ) )); 201 | assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( 202 | "Alignment of " , stringify ! ( FT_StreamRec_ ) )); 203 | assert_eq! (unsafe { 204 | & ( * ( 0 as * const FT_StreamRec_ ) ) . base as * const _ as 205 | usize } , 0usize , concat ! ( 206 | "Alignment of field: " , stringify ! ( FT_StreamRec_ ) , "::" 207 | , stringify ! ( base ) )); 208 | assert_eq! (unsafe { 209 | & ( * ( 0 as * const FT_StreamRec_ ) ) . size as * const _ as 210 | usize } , 8usize , concat ! ( 211 | "Alignment of field: " , stringify ! ( FT_StreamRec_ ) , "::" 212 | , stringify ! ( size ) )); 213 | assert_eq! (unsafe { 214 | & ( * ( 0 as * const FT_StreamRec_ ) ) . pos as * const _ as 215 | usize } , 16usize , concat ! ( 216 | "Alignment of field: " , stringify ! ( FT_StreamRec_ ) , "::" 217 | , stringify ! ( pos ) )); 218 | assert_eq! (unsafe { 219 | & ( * ( 0 as * const FT_StreamRec_ ) ) . descriptor as * const 220 | _ as usize } , 24usize , concat ! ( 221 | "Alignment of field: " , stringify ! ( FT_StreamRec_ ) , "::" 222 | , stringify ! ( descriptor ) )); 223 | assert_eq! (unsafe { 224 | & ( * ( 0 as * const FT_StreamRec_ ) ) . pathname as * const _ 225 | as usize } , 32usize , concat ! ( 226 | "Alignment of field: " , stringify ! ( FT_StreamRec_ ) , "::" 227 | , stringify ! ( pathname ) )); 228 | assert_eq! (unsafe { 229 | & ( * ( 0 as * const FT_StreamRec_ ) ) . read as * const _ as 230 | usize } , 40usize , concat ! ( 231 | "Alignment of field: " , stringify ! ( FT_StreamRec_ ) , "::" 232 | , stringify ! ( read ) )); 233 | assert_eq! (unsafe { 234 | & ( * ( 0 as * const FT_StreamRec_ ) ) . close as * const _ as 235 | usize } , 48usize , concat ! ( 236 | "Alignment of field: " , stringify ! ( FT_StreamRec_ ) , "::" 237 | , stringify ! ( close ) )); 238 | assert_eq! (unsafe { 239 | & ( * ( 0 as * const FT_StreamRec_ ) ) . memory as * const _ 240 | as usize } , 56usize , concat ! ( 241 | "Alignment of field: " , stringify ! ( FT_StreamRec_ ) , "::" 242 | , stringify ! ( memory ) )); 243 | assert_eq! (unsafe { 244 | & ( * ( 0 as * const FT_StreamRec_ ) ) . cursor as * const _ 245 | as usize } , 64usize , concat ! ( 246 | "Alignment of field: " , stringify ! ( FT_StreamRec_ ) , "::" 247 | , stringify ! ( cursor ) )); 248 | assert_eq! (unsafe { 249 | & ( * ( 0 as * const FT_StreamRec_ ) ) . limit as * const _ as 250 | usize } , 72usize , concat ! ( 251 | "Alignment of field: " , stringify ! ( FT_StreamRec_ ) , "::" 252 | , stringify ! ( limit ) )); 253 | } 254 | impl Clone for FT_StreamRec_ { 255 | fn clone(&self) -> Self { *self } 256 | } 257 | pub type FT_Stream = *mut FT_StreamRec_; 258 | #[repr(C)] 259 | #[derive(Debug, Copy)] 260 | pub struct FT_StreamDesc_ { 261 | pub value: __BindgenUnionField<::std::os::raw::c_long>, 262 | pub pointer: __BindgenUnionField<*mut ::std::os::raw::c_void>, 263 | pub bindgen_union_field: u64, 264 | } 265 | #[test] 266 | fn bindgen_test_layout_FT_StreamDesc_() { 267 | assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( 268 | "Size of: " , stringify ! ( FT_StreamDesc_ ) )); 269 | assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( 270 | "Alignment of " , stringify ! ( FT_StreamDesc_ ) )); 271 | assert_eq! (unsafe { 272 | & ( * ( 0 as * const FT_StreamDesc_ ) ) . value as * const _ 273 | as usize } , 0usize , concat ! ( 274 | "Alignment of field: " , stringify ! ( FT_StreamDesc_ ) , "::" 275 | , stringify ! ( value ) )); 276 | assert_eq! (unsafe { 277 | & ( * ( 0 as * const FT_StreamDesc_ ) ) . pointer as * const _ 278 | as usize } , 0usize , concat ! ( 279 | "Alignment of field: " , stringify ! ( FT_StreamDesc_ ) , "::" 280 | , stringify ! ( pointer ) )); 281 | } 282 | impl Clone for FT_StreamDesc_ { 283 | fn clone(&self) -> Self { *self } 284 | } 285 | pub type FT_StreamDesc = FT_StreamDesc_; 286 | pub type FT_Stream_IoFunc = 287 | ::std::option::Option ::std::os::raw::c_ulong>; 294 | pub type FT_Stream_CloseFunc = 295 | ::std::option::Option; 296 | pub type FT_StreamRec = FT_StreamRec_; 297 | pub type FT_Pos = ::std::os::raw::c_long; 298 | #[repr(C)] 299 | #[derive(Debug, Copy)] 300 | pub struct FT_Vector_ { 301 | pub x: FT_Pos, 302 | pub y: FT_Pos, 303 | } 304 | #[test] 305 | fn bindgen_test_layout_FT_Vector_() { 306 | assert_eq!(::std::mem::size_of::() , 16usize , concat ! ( 307 | "Size of: " , stringify ! ( FT_Vector_ ) )); 308 | assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( 309 | "Alignment of " , stringify ! ( FT_Vector_ ) )); 310 | assert_eq! (unsafe { 311 | & ( * ( 0 as * const FT_Vector_ ) ) . x as * const _ as usize 312 | } , 0usize , concat ! ( 313 | "Alignment of field: " , stringify ! ( FT_Vector_ ) , "::" , 314 | stringify ! ( x ) )); 315 | assert_eq! (unsafe { 316 | & ( * ( 0 as * const FT_Vector_ ) ) . y as * const _ as usize 317 | } , 8usize , concat ! ( 318 | "Alignment of field: " , stringify ! ( FT_Vector_ ) , "::" , 319 | stringify ! ( y ) )); 320 | } 321 | impl Clone for FT_Vector_ { 322 | fn clone(&self) -> Self { *self } 323 | } 324 | pub type FT_Vector = FT_Vector_; 325 | #[repr(C)] 326 | #[derive(Debug, Copy)] 327 | pub struct FT_BBox_ { 328 | pub xMin: FT_Pos, 329 | pub yMin: FT_Pos, 330 | pub xMax: FT_Pos, 331 | pub yMax: FT_Pos, 332 | } 333 | #[test] 334 | fn bindgen_test_layout_FT_BBox_() { 335 | assert_eq!(::std::mem::size_of::() , 32usize , concat ! ( 336 | "Size of: " , stringify ! ( FT_BBox_ ) )); 337 | assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( 338 | "Alignment of " , stringify ! ( FT_BBox_ ) )); 339 | assert_eq! (unsafe { 340 | & ( * ( 0 as * const FT_BBox_ ) ) . xMin as * const _ as usize 341 | } , 0usize , concat ! ( 342 | "Alignment of field: " , stringify ! ( FT_BBox_ ) , "::" , 343 | stringify ! ( xMin ) )); 344 | assert_eq! (unsafe { 345 | & ( * ( 0 as * const FT_BBox_ ) ) . yMin as * const _ as usize 346 | } , 8usize , concat ! ( 347 | "Alignment of field: " , stringify ! ( FT_BBox_ ) , "::" , 348 | stringify ! ( yMin ) )); 349 | assert_eq! (unsafe { 350 | & ( * ( 0 as * const FT_BBox_ ) ) . xMax as * const _ as usize 351 | } , 16usize , concat ! ( 352 | "Alignment of field: " , stringify ! ( FT_BBox_ ) , "::" , 353 | stringify ! ( xMax ) )); 354 | assert_eq! (unsafe { 355 | & ( * ( 0 as * const FT_BBox_ ) ) . yMax as * const _ as usize 356 | } , 24usize , concat ! ( 357 | "Alignment of field: " , stringify ! ( FT_BBox_ ) , "::" , 358 | stringify ! ( yMax ) )); 359 | } 360 | impl Clone for FT_BBox_ { 361 | fn clone(&self) -> Self { *self } 362 | } 363 | pub type FT_BBox = FT_BBox_; 364 | #[repr(u32)] 365 | #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] 366 | pub enum FT_Pixel_Mode_ { 367 | FT_PIXEL_MODE_NONE = 0, 368 | FT_PIXEL_MODE_MONO = 1, 369 | FT_PIXEL_MODE_GRAY = 2, 370 | FT_PIXEL_MODE_GRAY2 = 3, 371 | FT_PIXEL_MODE_GRAY4 = 4, 372 | FT_PIXEL_MODE_LCD = 5, 373 | FT_PIXEL_MODE_LCD_V = 6, 374 | FT_PIXEL_MODE_BGRA = 7, 375 | FT_PIXEL_MODE_MAX = 8, 376 | } 377 | pub use self::FT_Pixel_Mode_ as FT_Pixel_Mode; 378 | #[repr(C)] 379 | #[derive(Debug, Copy)] 380 | pub struct FT_Bitmap_ { 381 | pub rows: ::std::os::raw::c_uint, 382 | pub width: ::std::os::raw::c_uint, 383 | pub pitch: ::std::os::raw::c_int, 384 | pub buffer: *mut ::std::os::raw::c_uchar, 385 | pub num_grays: ::std::os::raw::c_ushort, 386 | pub pixel_mode: ::std::os::raw::c_uchar, 387 | pub palette_mode: ::std::os::raw::c_uchar, 388 | pub palette: *mut ::std::os::raw::c_void, 389 | } 390 | #[test] 391 | fn bindgen_test_layout_FT_Bitmap_() { 392 | assert_eq!(::std::mem::size_of::() , 40usize , concat ! ( 393 | "Size of: " , stringify ! ( FT_Bitmap_ ) )); 394 | assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( 395 | "Alignment of " , stringify ! ( FT_Bitmap_ ) )); 396 | assert_eq! (unsafe { 397 | & ( * ( 0 as * const FT_Bitmap_ ) ) . rows as * const _ as 398 | usize } , 0usize , concat ! ( 399 | "Alignment of field: " , stringify ! ( FT_Bitmap_ ) , "::" , 400 | stringify ! ( rows ) )); 401 | assert_eq! (unsafe { 402 | & ( * ( 0 as * const FT_Bitmap_ ) ) . width as * const _ as 403 | usize } , 4usize , concat ! ( 404 | "Alignment of field: " , stringify ! ( FT_Bitmap_ ) , "::" , 405 | stringify ! ( width ) )); 406 | assert_eq! (unsafe { 407 | & ( * ( 0 as * const FT_Bitmap_ ) ) . pitch as * const _ as 408 | usize } , 8usize , concat ! ( 409 | "Alignment of field: " , stringify ! ( FT_Bitmap_ ) , "::" , 410 | stringify ! ( pitch ) )); 411 | assert_eq! (unsafe { 412 | & ( * ( 0 as * const FT_Bitmap_ ) ) . buffer as * const _ as 413 | usize } , 16usize , concat ! ( 414 | "Alignment of field: " , stringify ! ( FT_Bitmap_ ) , "::" , 415 | stringify ! ( buffer ) )); 416 | assert_eq! (unsafe { 417 | & ( * ( 0 as * const FT_Bitmap_ ) ) . num_grays as * const _ 418 | as usize } , 24usize , concat ! ( 419 | "Alignment of field: " , stringify ! ( FT_Bitmap_ ) , "::" , 420 | stringify ! ( num_grays ) )); 421 | assert_eq! (unsafe { 422 | & ( * ( 0 as * const FT_Bitmap_ ) ) . pixel_mode as * const _ 423 | as usize } , 26usize , concat ! ( 424 | "Alignment of field: " , stringify ! ( FT_Bitmap_ ) , "::" , 425 | stringify ! ( pixel_mode ) )); 426 | assert_eq! (unsafe { 427 | & ( * ( 0 as * const FT_Bitmap_ ) ) . palette_mode as * const 428 | _ as usize } , 27usize , concat ! ( 429 | "Alignment of field: " , stringify ! ( FT_Bitmap_ ) , "::" , 430 | stringify ! ( palette_mode ) )); 431 | assert_eq! (unsafe { 432 | & ( * ( 0 as * const FT_Bitmap_ ) ) . palette as * const _ as 433 | usize } , 32usize , concat ! ( 434 | "Alignment of field: " , stringify ! ( FT_Bitmap_ ) , "::" , 435 | stringify ! ( palette ) )); 436 | } 437 | impl Clone for FT_Bitmap_ { 438 | fn clone(&self) -> Self { *self } 439 | } 440 | pub type FT_Bitmap = FT_Bitmap_; 441 | #[repr(C)] 442 | #[derive(Debug, Copy)] 443 | pub struct FT_Outline_ { 444 | pub n_contours: ::std::os::raw::c_short, 445 | pub n_points: ::std::os::raw::c_short, 446 | pub points: *mut FT_Vector, 447 | pub tags: *mut ::std::os::raw::c_char, 448 | pub contours: *mut ::std::os::raw::c_short, 449 | pub flags: ::std::os::raw::c_int, 450 | } 451 | #[test] 452 | fn bindgen_test_layout_FT_Outline_() { 453 | assert_eq!(::std::mem::size_of::() , 40usize , concat ! ( 454 | "Size of: " , stringify ! ( FT_Outline_ ) )); 455 | assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( 456 | "Alignment of " , stringify ! ( FT_Outline_ ) )); 457 | assert_eq! (unsafe { 458 | & ( * ( 0 as * const FT_Outline_ ) ) . n_contours as * const _ 459 | as usize } , 0usize , concat ! ( 460 | "Alignment of field: " , stringify ! ( FT_Outline_ ) , "::" , 461 | stringify ! ( n_contours ) )); 462 | assert_eq! (unsafe { 463 | & ( * ( 0 as * const FT_Outline_ ) ) . n_points as * const _ 464 | as usize } , 2usize , concat ! ( 465 | "Alignment of field: " , stringify ! ( FT_Outline_ ) , "::" , 466 | stringify ! ( n_points ) )); 467 | assert_eq! (unsafe { 468 | & ( * ( 0 as * const FT_Outline_ ) ) . points as * const _ as 469 | usize } , 8usize , concat ! ( 470 | "Alignment of field: " , stringify ! ( FT_Outline_ ) , "::" , 471 | stringify ! ( points ) )); 472 | assert_eq! (unsafe { 473 | & ( * ( 0 as * const FT_Outline_ ) ) . tags as * const _ as 474 | usize } , 16usize , concat ! ( 475 | "Alignment of field: " , stringify ! ( FT_Outline_ ) , "::" , 476 | stringify ! ( tags ) )); 477 | assert_eq! (unsafe { 478 | & ( * ( 0 as * const FT_Outline_ ) ) . contours as * const _ 479 | as usize } , 24usize , concat ! ( 480 | "Alignment of field: " , stringify ! ( FT_Outline_ ) , "::" , 481 | stringify ! ( contours ) )); 482 | assert_eq! (unsafe { 483 | & ( * ( 0 as * const FT_Outline_ ) ) . flags as * const _ as 484 | usize } , 32usize , concat ! ( 485 | "Alignment of field: " , stringify ! ( FT_Outline_ ) , "::" , 486 | stringify ! ( flags ) )); 487 | } 488 | impl Clone for FT_Outline_ { 489 | fn clone(&self) -> Self { *self } 490 | } 491 | pub type FT_Outline = FT_Outline_; 492 | pub type FT_Outline_MoveToFunc = 493 | ::std::option::Option ::std::os::raw::c_int>; 497 | pub type FT_Outline_LineToFunc = 498 | ::std::option::Option ::std::os::raw::c_int>; 502 | pub type FT_Outline_ConicToFunc = 503 | ::std::option::Option ::std::os::raw::c_int>; 508 | pub type FT_Outline_CubicToFunc = 509 | ::std::option::Option ::std::os::raw::c_int>; 515 | #[repr(C)] 516 | #[derive(Debug, Copy)] 517 | pub struct FT_Outline_Funcs_ { 518 | pub move_to: FT_Outline_MoveToFunc, 519 | pub line_to: FT_Outline_LineToFunc, 520 | pub conic_to: FT_Outline_ConicToFunc, 521 | pub cubic_to: FT_Outline_CubicToFunc, 522 | pub shift: ::std::os::raw::c_int, 523 | pub delta: FT_Pos, 524 | } 525 | #[test] 526 | fn bindgen_test_layout_FT_Outline_Funcs_() { 527 | assert_eq!(::std::mem::size_of::() , 48usize , concat ! 528 | ( "Size of: " , stringify ! ( FT_Outline_Funcs_ ) )); 529 | assert_eq! (::std::mem::align_of::() , 8usize , concat 530 | ! ( "Alignment of " , stringify ! ( FT_Outline_Funcs_ ) )); 531 | assert_eq! (unsafe { 532 | & ( * ( 0 as * const FT_Outline_Funcs_ ) ) . move_to as * 533 | const _ as usize } , 0usize , concat ! ( 534 | "Alignment of field: " , stringify ! ( FT_Outline_Funcs_ ) , 535 | "::" , stringify ! ( move_to ) )); 536 | assert_eq! (unsafe { 537 | & ( * ( 0 as * const FT_Outline_Funcs_ ) ) . line_to as * 538 | const _ as usize } , 8usize , concat ! ( 539 | "Alignment of field: " , stringify ! ( FT_Outline_Funcs_ ) , 540 | "::" , stringify ! ( line_to ) )); 541 | assert_eq! (unsafe { 542 | & ( * ( 0 as * const FT_Outline_Funcs_ ) ) . conic_to as * 543 | const _ as usize } , 16usize , concat ! ( 544 | "Alignment of field: " , stringify ! ( FT_Outline_Funcs_ ) , 545 | "::" , stringify ! ( conic_to ) )); 546 | assert_eq! (unsafe { 547 | & ( * ( 0 as * const FT_Outline_Funcs_ ) ) . cubic_to as * 548 | const _ as usize } , 24usize , concat ! ( 549 | "Alignment of field: " , stringify ! ( FT_Outline_Funcs_ ) , 550 | "::" , stringify ! ( cubic_to ) )); 551 | assert_eq! (unsafe { 552 | & ( * ( 0 as * const FT_Outline_Funcs_ ) ) . shift as * const 553 | _ as usize } , 32usize , concat ! ( 554 | "Alignment of field: " , stringify ! ( FT_Outline_Funcs_ ) , 555 | "::" , stringify ! ( shift ) )); 556 | assert_eq! (unsafe { 557 | & ( * ( 0 as * const FT_Outline_Funcs_ ) ) . delta as * const 558 | _ as usize } , 40usize , concat ! ( 559 | "Alignment of field: " , stringify ! ( FT_Outline_Funcs_ ) , 560 | "::" , stringify ! ( delta ) )); 561 | } 562 | impl Clone for FT_Outline_Funcs_ { 563 | fn clone(&self) -> Self { *self } 564 | } 565 | pub type FT_Outline_Funcs = FT_Outline_Funcs_; 566 | #[repr(u32)] 567 | #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] 568 | pub enum FT_Glyph_Format_ { 569 | FT_GLYPH_FORMAT_NONE = 0, 570 | FT_GLYPH_FORMAT_COMPOSITE = 1668246896, 571 | FT_GLYPH_FORMAT_BITMAP = 1651078259, 572 | FT_GLYPH_FORMAT_OUTLINE = 1869968492, 573 | FT_GLYPH_FORMAT_PLOTTER = 1886154612, 574 | } 575 | pub use self::FT_Glyph_Format_ as FT_Glyph_Format; 576 | #[repr(C)] 577 | #[derive(Debug, Copy, Clone)] 578 | pub struct FT_RasterRec_ { 579 | _unused: [u8; 0], 580 | } 581 | pub type FT_Raster = *mut FT_RasterRec_; 582 | #[repr(C)] 583 | #[derive(Debug, Copy)] 584 | pub struct FT_Span_ { 585 | pub x: ::std::os::raw::c_short, 586 | pub len: ::std::os::raw::c_ushort, 587 | pub coverage: ::std::os::raw::c_uchar, 588 | } 589 | #[test] 590 | fn bindgen_test_layout_FT_Span_() { 591 | assert_eq!(::std::mem::size_of::() , 6usize , concat ! ( 592 | "Size of: " , stringify ! ( FT_Span_ ) )); 593 | assert_eq! (::std::mem::align_of::() , 2usize , concat ! ( 594 | "Alignment of " , stringify ! ( FT_Span_ ) )); 595 | assert_eq! (unsafe { 596 | & ( * ( 0 as * const FT_Span_ ) ) . x as * const _ as usize } 597 | , 0usize , concat ! ( 598 | "Alignment of field: " , stringify ! ( FT_Span_ ) , "::" , 599 | stringify ! ( x ) )); 600 | assert_eq! (unsafe { 601 | & ( * ( 0 as * const FT_Span_ ) ) . len as * const _ as usize 602 | } , 2usize , concat ! ( 603 | "Alignment of field: " , stringify ! ( FT_Span_ ) , "::" , 604 | stringify ! ( len ) )); 605 | assert_eq! (unsafe { 606 | & ( * ( 0 as * const FT_Span_ ) ) . coverage as * const _ as 607 | usize } , 4usize , concat ! ( 608 | "Alignment of field: " , stringify ! ( FT_Span_ ) , "::" , 609 | stringify ! ( coverage ) )); 610 | } 611 | impl Clone for FT_Span_ { 612 | fn clone(&self) -> Self { *self } 613 | } 614 | pub type FT_Span = FT_Span_; 615 | pub type FT_SpanFunc = 616 | ::std::option::Option; 621 | pub type FT_Raster_BitTest_Func = 622 | ::std::option::Option ::std::os::raw::c_int>; 627 | pub type FT_Raster_BitSet_Func = 628 | ::std::option::Option; 632 | #[repr(C)] 633 | #[derive(Debug, Copy)] 634 | pub struct FT_Raster_Params_ { 635 | pub target: *const FT_Bitmap, 636 | pub source: *const ::std::os::raw::c_void, 637 | pub flags: ::std::os::raw::c_int, 638 | pub gray_spans: FT_SpanFunc, 639 | pub black_spans: FT_SpanFunc, 640 | pub bit_test: FT_Raster_BitTest_Func, 641 | pub bit_set: FT_Raster_BitSet_Func, 642 | pub user: *mut ::std::os::raw::c_void, 643 | pub clip_box: FT_BBox, 644 | } 645 | #[test] 646 | fn bindgen_test_layout_FT_Raster_Params_() { 647 | assert_eq!(::std::mem::size_of::() , 96usize , concat ! 648 | ( "Size of: " , stringify ! ( FT_Raster_Params_ ) )); 649 | assert_eq! (::std::mem::align_of::() , 8usize , concat 650 | ! ( "Alignment of " , stringify ! ( FT_Raster_Params_ ) )); 651 | assert_eq! (unsafe { 652 | & ( * ( 0 as * const FT_Raster_Params_ ) ) . target as * const 653 | _ as usize } , 0usize , concat ! ( 654 | "Alignment of field: " , stringify ! ( FT_Raster_Params_ ) , 655 | "::" , stringify ! ( target ) )); 656 | assert_eq! (unsafe { 657 | & ( * ( 0 as * const FT_Raster_Params_ ) ) . source as * const 658 | _ as usize } , 8usize , concat ! ( 659 | "Alignment of field: " , stringify ! ( FT_Raster_Params_ ) , 660 | "::" , stringify ! ( source ) )); 661 | assert_eq! (unsafe { 662 | & ( * ( 0 as * const FT_Raster_Params_ ) ) . flags as * const 663 | _ as usize } , 16usize , concat ! ( 664 | "Alignment of field: " , stringify ! ( FT_Raster_Params_ ) , 665 | "::" , stringify ! ( flags ) )); 666 | assert_eq! (unsafe { 667 | & ( * ( 0 as * const FT_Raster_Params_ ) ) . gray_spans as * 668 | const _ as usize } , 24usize , concat ! ( 669 | "Alignment of field: " , stringify ! ( FT_Raster_Params_ ) , 670 | "::" , stringify ! ( gray_spans ) )); 671 | assert_eq! (unsafe { 672 | & ( * ( 0 as * const FT_Raster_Params_ ) ) . black_spans as * 673 | const _ as usize } , 32usize , concat ! ( 674 | "Alignment of field: " , stringify ! ( FT_Raster_Params_ ) , 675 | "::" , stringify ! ( black_spans ) )); 676 | assert_eq! (unsafe { 677 | & ( * ( 0 as * const FT_Raster_Params_ ) ) . bit_test as * 678 | const _ as usize } , 40usize , concat ! ( 679 | "Alignment of field: " , stringify ! ( FT_Raster_Params_ ) , 680 | "::" , stringify ! ( bit_test ) )); 681 | assert_eq! (unsafe { 682 | & ( * ( 0 as * const FT_Raster_Params_ ) ) . bit_set as * 683 | const _ as usize } , 48usize , concat ! ( 684 | "Alignment of field: " , stringify ! ( FT_Raster_Params_ ) , 685 | "::" , stringify ! ( bit_set ) )); 686 | assert_eq! (unsafe { 687 | & ( * ( 0 as * const FT_Raster_Params_ ) ) . user as * const _ 688 | as usize } , 56usize , concat ! ( 689 | "Alignment of field: " , stringify ! ( FT_Raster_Params_ ) , 690 | "::" , stringify ! ( user ) )); 691 | assert_eq! (unsafe { 692 | & ( * ( 0 as * const FT_Raster_Params_ ) ) . clip_box as * 693 | const _ as usize } , 64usize , concat ! ( 694 | "Alignment of field: " , stringify ! ( FT_Raster_Params_ ) , 695 | "::" , stringify ! ( clip_box ) )); 696 | } 697 | impl Clone for FT_Raster_Params_ { 698 | fn clone(&self) -> Self { *self } 699 | } 700 | pub type FT_Raster_Params = FT_Raster_Params_; 701 | pub type FT_Raster_NewFunc = 702 | ::std::option::Option ::std::os::raw::c_int>; 706 | pub type FT_Raster_DoneFunc = 707 | ::std::option::Option; 708 | pub type FT_Raster_ResetFunc = 709 | ::std::option::Option; 714 | pub type FT_Raster_SetModeFunc = 715 | ::std::option::Option ::std::os::raw::c_int>; 720 | pub type FT_Raster_RenderFunc = 721 | ::std::option::Option ::std::os::raw::c_int>; 725 | #[repr(C)] 726 | #[derive(Debug, Copy)] 727 | pub struct FT_Raster_Funcs_ { 728 | pub glyph_format: FT_Glyph_Format, 729 | pub raster_new: FT_Raster_NewFunc, 730 | pub raster_reset: FT_Raster_ResetFunc, 731 | pub raster_set_mode: FT_Raster_SetModeFunc, 732 | pub raster_render: FT_Raster_RenderFunc, 733 | pub raster_done: FT_Raster_DoneFunc, 734 | } 735 | #[test] 736 | fn bindgen_test_layout_FT_Raster_Funcs_() { 737 | assert_eq!(::std::mem::size_of::() , 48usize , concat ! 738 | ( "Size of: " , stringify ! ( FT_Raster_Funcs_ ) )); 739 | assert_eq! (::std::mem::align_of::() , 8usize , concat ! 740 | ( "Alignment of " , stringify ! ( FT_Raster_Funcs_ ) )); 741 | assert_eq! (unsafe { 742 | & ( * ( 0 as * const FT_Raster_Funcs_ ) ) . glyph_format as * 743 | const _ as usize } , 0usize , concat ! ( 744 | "Alignment of field: " , stringify ! ( FT_Raster_Funcs_ ) , 745 | "::" , stringify ! ( glyph_format ) )); 746 | assert_eq! (unsafe { 747 | & ( * ( 0 as * const FT_Raster_Funcs_ ) ) . raster_new as * 748 | const _ as usize } , 8usize , concat ! ( 749 | "Alignment of field: " , stringify ! ( FT_Raster_Funcs_ ) , 750 | "::" , stringify ! ( raster_new ) )); 751 | assert_eq! (unsafe { 752 | & ( * ( 0 as * const FT_Raster_Funcs_ ) ) . raster_reset as * 753 | const _ as usize } , 16usize , concat ! ( 754 | "Alignment of field: " , stringify ! ( FT_Raster_Funcs_ ) , 755 | "::" , stringify ! ( raster_reset ) )); 756 | assert_eq! (unsafe { 757 | & ( * ( 0 as * const FT_Raster_Funcs_ ) ) . raster_set_mode as 758 | * const _ as usize } , 24usize , concat ! ( 759 | "Alignment of field: " , stringify ! ( FT_Raster_Funcs_ ) , 760 | "::" , stringify ! ( raster_set_mode ) )); 761 | assert_eq! (unsafe { 762 | & ( * ( 0 as * const FT_Raster_Funcs_ ) ) . raster_render as * 763 | const _ as usize } , 32usize , concat ! ( 764 | "Alignment of field: " , stringify ! ( FT_Raster_Funcs_ ) , 765 | "::" , stringify ! ( raster_render ) )); 766 | assert_eq! (unsafe { 767 | & ( * ( 0 as * const FT_Raster_Funcs_ ) ) . raster_done as * 768 | const _ as usize } , 40usize , concat ! ( 769 | "Alignment of field: " , stringify ! ( FT_Raster_Funcs_ ) , 770 | "::" , stringify ! ( raster_done ) )); 771 | } 772 | impl Clone for FT_Raster_Funcs_ { 773 | fn clone(&self) -> Self { *self } 774 | } 775 | pub type FT_Raster_Funcs = FT_Raster_Funcs_; 776 | pub type FT_Bool = ::std::os::raw::c_uchar; 777 | pub type FT_FWord = ::std::os::raw::c_short; 778 | pub type FT_UFWord = ::std::os::raw::c_ushort; 779 | pub type FT_Char = ::std::os::raw::c_schar; 780 | pub type FT_Byte = ::std::os::raw::c_uchar; 781 | pub type FT_Bytes = *const FT_Byte; 782 | pub type FT_Tag = FT_UInt32; 783 | pub type FT_String = ::std::os::raw::c_char; 784 | pub type FT_Short = ::std::os::raw::c_short; 785 | pub type FT_UShort = ::std::os::raw::c_ushort; 786 | pub type FT_Int = ::std::os::raw::c_int; 787 | pub type FT_UInt = ::std::os::raw::c_uint; 788 | pub type FT_Long = ::std::os::raw::c_long; 789 | pub type FT_ULong = ::std::os::raw::c_ulong; 790 | pub type FT_F2Dot14 = ::std::os::raw::c_short; 791 | pub type FT_F26Dot6 = ::std::os::raw::c_long; 792 | pub type FT_Fixed = ::std::os::raw::c_long; 793 | pub type FT_Pointer = *mut ::std::os::raw::c_void; 794 | pub type FT_Offset = usize; 795 | pub type FT_PtrDist = isize; 796 | #[repr(C)] 797 | #[derive(Debug, Copy)] 798 | pub struct FT_UnitVector_ { 799 | pub x: FT_F2Dot14, 800 | pub y: FT_F2Dot14, 801 | } 802 | #[test] 803 | fn bindgen_test_layout_FT_UnitVector_() { 804 | assert_eq!(::std::mem::size_of::() , 4usize , concat ! ( 805 | "Size of: " , stringify ! ( FT_UnitVector_ ) )); 806 | assert_eq! (::std::mem::align_of::() , 2usize , concat ! ( 807 | "Alignment of " , stringify ! ( FT_UnitVector_ ) )); 808 | assert_eq! (unsafe { 809 | & ( * ( 0 as * const FT_UnitVector_ ) ) . x as * const _ as 810 | usize } , 0usize , concat ! ( 811 | "Alignment of field: " , stringify ! ( FT_UnitVector_ ) , "::" 812 | , stringify ! ( x ) )); 813 | assert_eq! (unsafe { 814 | & ( * ( 0 as * const FT_UnitVector_ ) ) . y as * const _ as 815 | usize } , 2usize , concat ! ( 816 | "Alignment of field: " , stringify ! ( FT_UnitVector_ ) , "::" 817 | , stringify ! ( y ) )); 818 | } 819 | impl Clone for FT_UnitVector_ { 820 | fn clone(&self) -> Self { *self } 821 | } 822 | pub type FT_UnitVector = FT_UnitVector_; 823 | #[repr(C)] 824 | #[derive(Debug, Copy)] 825 | pub struct FT_Matrix_ { 826 | pub xx: FT_Fixed, 827 | pub xy: FT_Fixed, 828 | pub yx: FT_Fixed, 829 | pub yy: FT_Fixed, 830 | } 831 | #[test] 832 | fn bindgen_test_layout_FT_Matrix_() { 833 | assert_eq!(::std::mem::size_of::() , 32usize , concat ! ( 834 | "Size of: " , stringify ! ( FT_Matrix_ ) )); 835 | assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( 836 | "Alignment of " , stringify ! ( FT_Matrix_ ) )); 837 | assert_eq! (unsafe { 838 | & ( * ( 0 as * const FT_Matrix_ ) ) . xx as * const _ as usize 839 | } , 0usize , concat ! ( 840 | "Alignment of field: " , stringify ! ( FT_Matrix_ ) , "::" , 841 | stringify ! ( xx ) )); 842 | assert_eq! (unsafe { 843 | & ( * ( 0 as * const FT_Matrix_ ) ) . xy as * const _ as usize 844 | } , 8usize , concat ! ( 845 | "Alignment of field: " , stringify ! ( FT_Matrix_ ) , "::" , 846 | stringify ! ( xy ) )); 847 | assert_eq! (unsafe { 848 | & ( * ( 0 as * const FT_Matrix_ ) ) . yx as * const _ as usize 849 | } , 16usize , concat ! ( 850 | "Alignment of field: " , stringify ! ( FT_Matrix_ ) , "::" , 851 | stringify ! ( yx ) )); 852 | assert_eq! (unsafe { 853 | & ( * ( 0 as * const FT_Matrix_ ) ) . yy as * const _ as usize 854 | } , 24usize , concat ! ( 855 | "Alignment of field: " , stringify ! ( FT_Matrix_ ) , "::" , 856 | stringify ! ( yy ) )); 857 | } 858 | impl Clone for FT_Matrix_ { 859 | fn clone(&self) -> Self { *self } 860 | } 861 | pub type FT_Matrix = FT_Matrix_; 862 | #[repr(C)] 863 | #[derive(Debug, Copy)] 864 | pub struct FT_Data_ { 865 | pub pointer: *const FT_Byte, 866 | pub length: FT_Int, 867 | } 868 | #[test] 869 | fn bindgen_test_layout_FT_Data_() { 870 | assert_eq!(::std::mem::size_of::() , 16usize , concat ! ( 871 | "Size of: " , stringify ! ( FT_Data_ ) )); 872 | assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( 873 | "Alignment of " , stringify ! ( FT_Data_ ) )); 874 | assert_eq! (unsafe { 875 | & ( * ( 0 as * const FT_Data_ ) ) . pointer as * const _ as 876 | usize } , 0usize , concat ! ( 877 | "Alignment of field: " , stringify ! ( FT_Data_ ) , "::" , 878 | stringify ! ( pointer ) )); 879 | assert_eq! (unsafe { 880 | & ( * ( 0 as * const FT_Data_ ) ) . length as * const _ as 881 | usize } , 8usize , concat ! ( 882 | "Alignment of field: " , stringify ! ( FT_Data_ ) , "::" , 883 | stringify ! ( length ) )); 884 | } 885 | impl Clone for FT_Data_ { 886 | fn clone(&self) -> Self { *self } 887 | } 888 | pub type FT_Data = FT_Data_; 889 | pub type FT_Generic_Finalizer = 890 | ::std::option::Option; 892 | #[repr(C)] 893 | #[derive(Debug, Copy)] 894 | pub struct FT_Generic_ { 895 | pub data: *mut ::std::os::raw::c_void, 896 | pub finalizer: FT_Generic_Finalizer, 897 | } 898 | #[test] 899 | fn bindgen_test_layout_FT_Generic_() { 900 | assert_eq!(::std::mem::size_of::() , 16usize , concat ! ( 901 | "Size of: " , stringify ! ( FT_Generic_ ) )); 902 | assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( 903 | "Alignment of " , stringify ! ( FT_Generic_ ) )); 904 | assert_eq! (unsafe { 905 | & ( * ( 0 as * const FT_Generic_ ) ) . data as * const _ as 906 | usize } , 0usize , concat ! ( 907 | "Alignment of field: " , stringify ! ( FT_Generic_ ) , "::" , 908 | stringify ! ( data ) )); 909 | assert_eq! (unsafe { 910 | & ( * ( 0 as * const FT_Generic_ ) ) . finalizer as * const _ 911 | as usize } , 8usize , concat ! ( 912 | "Alignment of field: " , stringify ! ( FT_Generic_ ) , "::" , 913 | stringify ! ( finalizer ) )); 914 | } 915 | impl Clone for FT_Generic_ { 916 | fn clone(&self) -> Self { *self } 917 | } 918 | pub type FT_Generic = FT_Generic_; 919 | #[repr(C)] 920 | #[derive(Debug, Copy)] 921 | pub struct FT_ListNodeRec_ { 922 | pub prev: FT_ListNode, 923 | pub next: FT_ListNode, 924 | pub data: *mut ::std::os::raw::c_void, 925 | } 926 | #[test] 927 | fn bindgen_test_layout_FT_ListNodeRec_() { 928 | assert_eq!(::std::mem::size_of::() , 24usize , concat ! ( 929 | "Size of: " , stringify ! ( FT_ListNodeRec_ ) )); 930 | assert_eq! (::std::mem::align_of::() , 8usize , concat ! 931 | ( "Alignment of " , stringify ! ( FT_ListNodeRec_ ) )); 932 | assert_eq! (unsafe { 933 | & ( * ( 0 as * const FT_ListNodeRec_ ) ) . prev as * const _ 934 | as usize } , 0usize , concat ! ( 935 | "Alignment of field: " , stringify ! ( FT_ListNodeRec_ ) , 936 | "::" , stringify ! ( prev ) )); 937 | assert_eq! (unsafe { 938 | & ( * ( 0 as * const FT_ListNodeRec_ ) ) . next as * const _ 939 | as usize } , 8usize , concat ! ( 940 | "Alignment of field: " , stringify ! ( FT_ListNodeRec_ ) , 941 | "::" , stringify ! ( next ) )); 942 | assert_eq! (unsafe { 943 | & ( * ( 0 as * const FT_ListNodeRec_ ) ) . data as * const _ 944 | as usize } , 16usize , concat ! ( 945 | "Alignment of field: " , stringify ! ( FT_ListNodeRec_ ) , 946 | "::" , stringify ! ( data ) )); 947 | } 948 | impl Clone for FT_ListNodeRec_ { 949 | fn clone(&self) -> Self { *self } 950 | } 951 | pub type FT_ListNode = *mut FT_ListNodeRec_; 952 | #[repr(C)] 953 | #[derive(Debug, Copy)] 954 | pub struct FT_ListRec_ { 955 | pub head: FT_ListNode, 956 | pub tail: FT_ListNode, 957 | } 958 | #[test] 959 | fn bindgen_test_layout_FT_ListRec_() { 960 | assert_eq!(::std::mem::size_of::() , 16usize , concat ! ( 961 | "Size of: " , stringify ! ( FT_ListRec_ ) )); 962 | assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( 963 | "Alignment of " , stringify ! ( FT_ListRec_ ) )); 964 | assert_eq! (unsafe { 965 | & ( * ( 0 as * const FT_ListRec_ ) ) . head as * const _ as 966 | usize } , 0usize , concat ! ( 967 | "Alignment of field: " , stringify ! ( FT_ListRec_ ) , "::" , 968 | stringify ! ( head ) )); 969 | assert_eq! (unsafe { 970 | & ( * ( 0 as * const FT_ListRec_ ) ) . tail as * const _ as 971 | usize } , 8usize , concat ! ( 972 | "Alignment of field: " , stringify ! ( FT_ListRec_ ) , "::" , 973 | stringify ! ( tail ) )); 974 | } 975 | impl Clone for FT_ListRec_ { 976 | fn clone(&self) -> Self { *self } 977 | } 978 | pub type FT_List = *mut FT_ListRec_; 979 | pub type FT_ListNodeRec = FT_ListNodeRec_; 980 | pub type FT_ListRec = FT_ListRec_; 981 | pub const FT_Mod_Err_Base: _bindgen_ty_1 = _bindgen_ty_1::FT_Mod_Err_Base; 982 | pub const FT_Mod_Err_Autofit: _bindgen_ty_1 = _bindgen_ty_1::FT_Mod_Err_Base; 983 | pub const FT_Mod_Err_BDF: _bindgen_ty_1 = _bindgen_ty_1::FT_Mod_Err_Base; 984 | pub const FT_Mod_Err_Bzip2: _bindgen_ty_1 = _bindgen_ty_1::FT_Mod_Err_Base; 985 | pub const FT_Mod_Err_Cache: _bindgen_ty_1 = _bindgen_ty_1::FT_Mod_Err_Base; 986 | pub const FT_Mod_Err_CFF: _bindgen_ty_1 = _bindgen_ty_1::FT_Mod_Err_Base; 987 | pub const FT_Mod_Err_CID: _bindgen_ty_1 = _bindgen_ty_1::FT_Mod_Err_Base; 988 | pub const FT_Mod_Err_Gzip: _bindgen_ty_1 = _bindgen_ty_1::FT_Mod_Err_Base; 989 | pub const FT_Mod_Err_LZW: _bindgen_ty_1 = _bindgen_ty_1::FT_Mod_Err_Base; 990 | pub const FT_Mod_Err_OTvalid: _bindgen_ty_1 = _bindgen_ty_1::FT_Mod_Err_Base; 991 | pub const FT_Mod_Err_PCF: _bindgen_ty_1 = _bindgen_ty_1::FT_Mod_Err_Base; 992 | pub const FT_Mod_Err_PFR: _bindgen_ty_1 = _bindgen_ty_1::FT_Mod_Err_Base; 993 | pub const FT_Mod_Err_PSaux: _bindgen_ty_1 = _bindgen_ty_1::FT_Mod_Err_Base; 994 | pub const FT_Mod_Err_PShinter: _bindgen_ty_1 = _bindgen_ty_1::FT_Mod_Err_Base; 995 | pub const FT_Mod_Err_PSnames: _bindgen_ty_1 = _bindgen_ty_1::FT_Mod_Err_Base; 996 | pub const FT_Mod_Err_Raster: _bindgen_ty_1 = _bindgen_ty_1::FT_Mod_Err_Base; 997 | pub const FT_Mod_Err_SFNT: _bindgen_ty_1 = _bindgen_ty_1::FT_Mod_Err_Base; 998 | pub const FT_Mod_Err_Smooth: _bindgen_ty_1 = _bindgen_ty_1::FT_Mod_Err_Base; 999 | pub const FT_Mod_Err_TrueType: _bindgen_ty_1 = _bindgen_ty_1::FT_Mod_Err_Base; 1000 | pub const FT_Mod_Err_Type1: _bindgen_ty_1 = _bindgen_ty_1::FT_Mod_Err_Base; 1001 | pub const FT_Mod_Err_Type42: _bindgen_ty_1 = _bindgen_ty_1::FT_Mod_Err_Base; 1002 | pub const FT_Mod_Err_Winfonts: _bindgen_ty_1 = _bindgen_ty_1::FT_Mod_Err_Base; 1003 | pub const FT_Mod_Err_GXvalid: _bindgen_ty_1 = _bindgen_ty_1::FT_Mod_Err_Base; 1004 | pub const FT_Mod_Err_Max: _bindgen_ty_1 = _bindgen_ty_1::FT_Mod_Err_Max; 1005 | #[repr(u32)] 1006 | #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] 1007 | pub enum _bindgen_ty_1 { FT_Mod_Err_Base = 0, FT_Mod_Err_Max = 1, } 1008 | pub const FT_Err_Ok: _bindgen_ty_2 = _bindgen_ty_2::FT_Err_Ok; 1009 | pub const FT_Err_Cannot_Open_Resource: _bindgen_ty_2 = 1010 | _bindgen_ty_2::FT_Err_Cannot_Open_Resource; 1011 | pub const FT_Err_Unknown_File_Format: _bindgen_ty_2 = 1012 | _bindgen_ty_2::FT_Err_Unknown_File_Format; 1013 | pub const FT_Err_Invalid_File_Format: _bindgen_ty_2 = 1014 | _bindgen_ty_2::FT_Err_Invalid_File_Format; 1015 | pub const FT_Err_Invalid_Version: _bindgen_ty_2 = 1016 | _bindgen_ty_2::FT_Err_Invalid_Version; 1017 | pub const FT_Err_Lower_Module_Version: _bindgen_ty_2 = 1018 | _bindgen_ty_2::FT_Err_Lower_Module_Version; 1019 | pub const FT_Err_Invalid_Argument: _bindgen_ty_2 = 1020 | _bindgen_ty_2::FT_Err_Invalid_Argument; 1021 | pub const FT_Err_Unimplemented_Feature: _bindgen_ty_2 = 1022 | _bindgen_ty_2::FT_Err_Unimplemented_Feature; 1023 | pub const FT_Err_Invalid_Table: _bindgen_ty_2 = 1024 | _bindgen_ty_2::FT_Err_Invalid_Table; 1025 | pub const FT_Err_Invalid_Offset: _bindgen_ty_2 = 1026 | _bindgen_ty_2::FT_Err_Invalid_Offset; 1027 | pub const FT_Err_Array_Too_Large: _bindgen_ty_2 = 1028 | _bindgen_ty_2::FT_Err_Array_Too_Large; 1029 | pub const FT_Err_Missing_Module: _bindgen_ty_2 = 1030 | _bindgen_ty_2::FT_Err_Missing_Module; 1031 | pub const FT_Err_Missing_Property: _bindgen_ty_2 = 1032 | _bindgen_ty_2::FT_Err_Missing_Property; 1033 | pub const FT_Err_Invalid_Glyph_Index: _bindgen_ty_2 = 1034 | _bindgen_ty_2::FT_Err_Invalid_Glyph_Index; 1035 | pub const FT_Err_Invalid_Character_Code: _bindgen_ty_2 = 1036 | _bindgen_ty_2::FT_Err_Invalid_Character_Code; 1037 | pub const FT_Err_Invalid_Glyph_Format: _bindgen_ty_2 = 1038 | _bindgen_ty_2::FT_Err_Invalid_Glyph_Format; 1039 | pub const FT_Err_Cannot_Render_Glyph: _bindgen_ty_2 = 1040 | _bindgen_ty_2::FT_Err_Cannot_Render_Glyph; 1041 | pub const FT_Err_Invalid_Outline: _bindgen_ty_2 = 1042 | _bindgen_ty_2::FT_Err_Invalid_Outline; 1043 | pub const FT_Err_Invalid_Composite: _bindgen_ty_2 = 1044 | _bindgen_ty_2::FT_Err_Invalid_Composite; 1045 | pub const FT_Err_Too_Many_Hints: _bindgen_ty_2 = 1046 | _bindgen_ty_2::FT_Err_Too_Many_Hints; 1047 | pub const FT_Err_Invalid_Pixel_Size: _bindgen_ty_2 = 1048 | _bindgen_ty_2::FT_Err_Invalid_Pixel_Size; 1049 | pub const FT_Err_Invalid_Handle: _bindgen_ty_2 = 1050 | _bindgen_ty_2::FT_Err_Invalid_Handle; 1051 | pub const FT_Err_Invalid_Library_Handle: _bindgen_ty_2 = 1052 | _bindgen_ty_2::FT_Err_Invalid_Library_Handle; 1053 | pub const FT_Err_Invalid_Driver_Handle: _bindgen_ty_2 = 1054 | _bindgen_ty_2::FT_Err_Invalid_Driver_Handle; 1055 | pub const FT_Err_Invalid_Face_Handle: _bindgen_ty_2 = 1056 | _bindgen_ty_2::FT_Err_Invalid_Face_Handle; 1057 | pub const FT_Err_Invalid_Size_Handle: _bindgen_ty_2 = 1058 | _bindgen_ty_2::FT_Err_Invalid_Size_Handle; 1059 | pub const FT_Err_Invalid_Slot_Handle: _bindgen_ty_2 = 1060 | _bindgen_ty_2::FT_Err_Invalid_Slot_Handle; 1061 | pub const FT_Err_Invalid_CharMap_Handle: _bindgen_ty_2 = 1062 | _bindgen_ty_2::FT_Err_Invalid_CharMap_Handle; 1063 | pub const FT_Err_Invalid_Cache_Handle: _bindgen_ty_2 = 1064 | _bindgen_ty_2::FT_Err_Invalid_Cache_Handle; 1065 | pub const FT_Err_Invalid_Stream_Handle: _bindgen_ty_2 = 1066 | _bindgen_ty_2::FT_Err_Invalid_Stream_Handle; 1067 | pub const FT_Err_Too_Many_Drivers: _bindgen_ty_2 = 1068 | _bindgen_ty_2::FT_Err_Too_Many_Drivers; 1069 | pub const FT_Err_Too_Many_Extensions: _bindgen_ty_2 = 1070 | _bindgen_ty_2::FT_Err_Too_Many_Extensions; 1071 | pub const FT_Err_Out_Of_Memory: _bindgen_ty_2 = 1072 | _bindgen_ty_2::FT_Err_Out_Of_Memory; 1073 | pub const FT_Err_Unlisted_Object: _bindgen_ty_2 = 1074 | _bindgen_ty_2::FT_Err_Unlisted_Object; 1075 | pub const FT_Err_Cannot_Open_Stream: _bindgen_ty_2 = 1076 | _bindgen_ty_2::FT_Err_Cannot_Open_Stream; 1077 | pub const FT_Err_Invalid_Stream_Seek: _bindgen_ty_2 = 1078 | _bindgen_ty_2::FT_Err_Invalid_Stream_Seek; 1079 | pub const FT_Err_Invalid_Stream_Skip: _bindgen_ty_2 = 1080 | _bindgen_ty_2::FT_Err_Invalid_Stream_Skip; 1081 | pub const FT_Err_Invalid_Stream_Read: _bindgen_ty_2 = 1082 | _bindgen_ty_2::FT_Err_Invalid_Stream_Read; 1083 | pub const FT_Err_Invalid_Stream_Operation: _bindgen_ty_2 = 1084 | _bindgen_ty_2::FT_Err_Invalid_Stream_Operation; 1085 | pub const FT_Err_Invalid_Frame_Operation: _bindgen_ty_2 = 1086 | _bindgen_ty_2::FT_Err_Invalid_Frame_Operation; 1087 | pub const FT_Err_Nested_Frame_Access: _bindgen_ty_2 = 1088 | _bindgen_ty_2::FT_Err_Nested_Frame_Access; 1089 | pub const FT_Err_Invalid_Frame_Read: _bindgen_ty_2 = 1090 | _bindgen_ty_2::FT_Err_Invalid_Frame_Read; 1091 | pub const FT_Err_Raster_Uninitialized: _bindgen_ty_2 = 1092 | _bindgen_ty_2::FT_Err_Raster_Uninitialized; 1093 | pub const FT_Err_Raster_Corrupted: _bindgen_ty_2 = 1094 | _bindgen_ty_2::FT_Err_Raster_Corrupted; 1095 | pub const FT_Err_Raster_Overflow: _bindgen_ty_2 = 1096 | _bindgen_ty_2::FT_Err_Raster_Overflow; 1097 | pub const FT_Err_Raster_Negative_Height: _bindgen_ty_2 = 1098 | _bindgen_ty_2::FT_Err_Raster_Negative_Height; 1099 | pub const FT_Err_Too_Many_Caches: _bindgen_ty_2 = 1100 | _bindgen_ty_2::FT_Err_Too_Many_Caches; 1101 | pub const FT_Err_Invalid_Opcode: _bindgen_ty_2 = 1102 | _bindgen_ty_2::FT_Err_Invalid_Opcode; 1103 | pub const FT_Err_Too_Few_Arguments: _bindgen_ty_2 = 1104 | _bindgen_ty_2::FT_Err_Too_Few_Arguments; 1105 | pub const FT_Err_Stack_Overflow: _bindgen_ty_2 = 1106 | _bindgen_ty_2::FT_Err_Stack_Overflow; 1107 | pub const FT_Err_Code_Overflow: _bindgen_ty_2 = 1108 | _bindgen_ty_2::FT_Err_Code_Overflow; 1109 | pub const FT_Err_Bad_Argument: _bindgen_ty_2 = 1110 | _bindgen_ty_2::FT_Err_Bad_Argument; 1111 | pub const FT_Err_Divide_By_Zero: _bindgen_ty_2 = 1112 | _bindgen_ty_2::FT_Err_Divide_By_Zero; 1113 | pub const FT_Err_Invalid_Reference: _bindgen_ty_2 = 1114 | _bindgen_ty_2::FT_Err_Invalid_Reference; 1115 | pub const FT_Err_Debug_OpCode: _bindgen_ty_2 = 1116 | _bindgen_ty_2::FT_Err_Debug_OpCode; 1117 | pub const FT_Err_ENDF_In_Exec_Stream: _bindgen_ty_2 = 1118 | _bindgen_ty_2::FT_Err_ENDF_In_Exec_Stream; 1119 | pub const FT_Err_Nested_DEFS: _bindgen_ty_2 = 1120 | _bindgen_ty_2::FT_Err_Nested_DEFS; 1121 | pub const FT_Err_Invalid_CodeRange: _bindgen_ty_2 = 1122 | _bindgen_ty_2::FT_Err_Invalid_CodeRange; 1123 | pub const FT_Err_Execution_Too_Long: _bindgen_ty_2 = 1124 | _bindgen_ty_2::FT_Err_Execution_Too_Long; 1125 | pub const FT_Err_Too_Many_Function_Defs: _bindgen_ty_2 = 1126 | _bindgen_ty_2::FT_Err_Too_Many_Function_Defs; 1127 | pub const FT_Err_Too_Many_Instruction_Defs: _bindgen_ty_2 = 1128 | _bindgen_ty_2::FT_Err_Too_Many_Instruction_Defs; 1129 | pub const FT_Err_Table_Missing: _bindgen_ty_2 = 1130 | _bindgen_ty_2::FT_Err_Table_Missing; 1131 | pub const FT_Err_Horiz_Header_Missing: _bindgen_ty_2 = 1132 | _bindgen_ty_2::FT_Err_Horiz_Header_Missing; 1133 | pub const FT_Err_Locations_Missing: _bindgen_ty_2 = 1134 | _bindgen_ty_2::FT_Err_Locations_Missing; 1135 | pub const FT_Err_Name_Table_Missing: _bindgen_ty_2 = 1136 | _bindgen_ty_2::FT_Err_Name_Table_Missing; 1137 | pub const FT_Err_CMap_Table_Missing: _bindgen_ty_2 = 1138 | _bindgen_ty_2::FT_Err_CMap_Table_Missing; 1139 | pub const FT_Err_Hmtx_Table_Missing: _bindgen_ty_2 = 1140 | _bindgen_ty_2::FT_Err_Hmtx_Table_Missing; 1141 | pub const FT_Err_Post_Table_Missing: _bindgen_ty_2 = 1142 | _bindgen_ty_2::FT_Err_Post_Table_Missing; 1143 | pub const FT_Err_Invalid_Horiz_Metrics: _bindgen_ty_2 = 1144 | _bindgen_ty_2::FT_Err_Invalid_Horiz_Metrics; 1145 | pub const FT_Err_Invalid_CharMap_Format: _bindgen_ty_2 = 1146 | _bindgen_ty_2::FT_Err_Invalid_CharMap_Format; 1147 | pub const FT_Err_Invalid_PPem: _bindgen_ty_2 = 1148 | _bindgen_ty_2::FT_Err_Invalid_PPem; 1149 | pub const FT_Err_Invalid_Vert_Metrics: _bindgen_ty_2 = 1150 | _bindgen_ty_2::FT_Err_Invalid_Vert_Metrics; 1151 | pub const FT_Err_Could_Not_Find_Context: _bindgen_ty_2 = 1152 | _bindgen_ty_2::FT_Err_Could_Not_Find_Context; 1153 | pub const FT_Err_Invalid_Post_Table_Format: _bindgen_ty_2 = 1154 | _bindgen_ty_2::FT_Err_Invalid_Post_Table_Format; 1155 | pub const FT_Err_Invalid_Post_Table: _bindgen_ty_2 = 1156 | _bindgen_ty_2::FT_Err_Invalid_Post_Table; 1157 | pub const FT_Err_Syntax_Error: _bindgen_ty_2 = 1158 | _bindgen_ty_2::FT_Err_Syntax_Error; 1159 | pub const FT_Err_Stack_Underflow: _bindgen_ty_2 = 1160 | _bindgen_ty_2::FT_Err_Stack_Underflow; 1161 | pub const FT_Err_Ignore: _bindgen_ty_2 = _bindgen_ty_2::FT_Err_Ignore; 1162 | pub const FT_Err_No_Unicode_Glyph_Name: _bindgen_ty_2 = 1163 | _bindgen_ty_2::FT_Err_No_Unicode_Glyph_Name; 1164 | pub const FT_Err_Glyph_Too_Big: _bindgen_ty_2 = 1165 | _bindgen_ty_2::FT_Err_Glyph_Too_Big; 1166 | pub const FT_Err_Missing_Startfont_Field: _bindgen_ty_2 = 1167 | _bindgen_ty_2::FT_Err_Missing_Startfont_Field; 1168 | pub const FT_Err_Missing_Font_Field: _bindgen_ty_2 = 1169 | _bindgen_ty_2::FT_Err_Missing_Font_Field; 1170 | pub const FT_Err_Missing_Size_Field: _bindgen_ty_2 = 1171 | _bindgen_ty_2::FT_Err_Missing_Size_Field; 1172 | pub const FT_Err_Missing_Fontboundingbox_Field: _bindgen_ty_2 = 1173 | _bindgen_ty_2::FT_Err_Missing_Fontboundingbox_Field; 1174 | pub const FT_Err_Missing_Chars_Field: _bindgen_ty_2 = 1175 | _bindgen_ty_2::FT_Err_Missing_Chars_Field; 1176 | pub const FT_Err_Missing_Startchar_Field: _bindgen_ty_2 = 1177 | _bindgen_ty_2::FT_Err_Missing_Startchar_Field; 1178 | pub const FT_Err_Missing_Encoding_Field: _bindgen_ty_2 = 1179 | _bindgen_ty_2::FT_Err_Missing_Encoding_Field; 1180 | pub const FT_Err_Missing_Bbx_Field: _bindgen_ty_2 = 1181 | _bindgen_ty_2::FT_Err_Missing_Bbx_Field; 1182 | pub const FT_Err_Bbx_Too_Big: _bindgen_ty_2 = 1183 | _bindgen_ty_2::FT_Err_Bbx_Too_Big; 1184 | pub const FT_Err_Corrupted_Font_Header: _bindgen_ty_2 = 1185 | _bindgen_ty_2::FT_Err_Corrupted_Font_Header; 1186 | pub const FT_Err_Corrupted_Font_Glyphs: _bindgen_ty_2 = 1187 | _bindgen_ty_2::FT_Err_Corrupted_Font_Glyphs; 1188 | pub const FT_Err_Max: _bindgen_ty_2 = _bindgen_ty_2::FT_Err_Max; 1189 | #[repr(u32)] 1190 | #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] 1191 | pub enum _bindgen_ty_2 { 1192 | FT_Err_Ok = 0, 1193 | FT_Err_Cannot_Open_Resource = 1, 1194 | FT_Err_Unknown_File_Format = 2, 1195 | FT_Err_Invalid_File_Format = 3, 1196 | FT_Err_Invalid_Version = 4, 1197 | FT_Err_Lower_Module_Version = 5, 1198 | FT_Err_Invalid_Argument = 6, 1199 | FT_Err_Unimplemented_Feature = 7, 1200 | FT_Err_Invalid_Table = 8, 1201 | FT_Err_Invalid_Offset = 9, 1202 | FT_Err_Array_Too_Large = 10, 1203 | FT_Err_Missing_Module = 11, 1204 | FT_Err_Missing_Property = 12, 1205 | FT_Err_Invalid_Glyph_Index = 16, 1206 | FT_Err_Invalid_Character_Code = 17, 1207 | FT_Err_Invalid_Glyph_Format = 18, 1208 | FT_Err_Cannot_Render_Glyph = 19, 1209 | FT_Err_Invalid_Outline = 20, 1210 | FT_Err_Invalid_Composite = 21, 1211 | FT_Err_Too_Many_Hints = 22, 1212 | FT_Err_Invalid_Pixel_Size = 23, 1213 | FT_Err_Invalid_Handle = 32, 1214 | FT_Err_Invalid_Library_Handle = 33, 1215 | FT_Err_Invalid_Driver_Handle = 34, 1216 | FT_Err_Invalid_Face_Handle = 35, 1217 | FT_Err_Invalid_Size_Handle = 36, 1218 | FT_Err_Invalid_Slot_Handle = 37, 1219 | FT_Err_Invalid_CharMap_Handle = 38, 1220 | FT_Err_Invalid_Cache_Handle = 39, 1221 | FT_Err_Invalid_Stream_Handle = 40, 1222 | FT_Err_Too_Many_Drivers = 48, 1223 | FT_Err_Too_Many_Extensions = 49, 1224 | FT_Err_Out_Of_Memory = 64, 1225 | FT_Err_Unlisted_Object = 65, 1226 | FT_Err_Cannot_Open_Stream = 81, 1227 | FT_Err_Invalid_Stream_Seek = 82, 1228 | FT_Err_Invalid_Stream_Skip = 83, 1229 | FT_Err_Invalid_Stream_Read = 84, 1230 | FT_Err_Invalid_Stream_Operation = 85, 1231 | FT_Err_Invalid_Frame_Operation = 86, 1232 | FT_Err_Nested_Frame_Access = 87, 1233 | FT_Err_Invalid_Frame_Read = 88, 1234 | FT_Err_Raster_Uninitialized = 96, 1235 | FT_Err_Raster_Corrupted = 97, 1236 | FT_Err_Raster_Overflow = 98, 1237 | FT_Err_Raster_Negative_Height = 99, 1238 | FT_Err_Too_Many_Caches = 112, 1239 | FT_Err_Invalid_Opcode = 128, 1240 | FT_Err_Too_Few_Arguments = 129, 1241 | FT_Err_Stack_Overflow = 130, 1242 | FT_Err_Code_Overflow = 131, 1243 | FT_Err_Bad_Argument = 132, 1244 | FT_Err_Divide_By_Zero = 133, 1245 | FT_Err_Invalid_Reference = 134, 1246 | FT_Err_Debug_OpCode = 135, 1247 | FT_Err_ENDF_In_Exec_Stream = 136, 1248 | FT_Err_Nested_DEFS = 137, 1249 | FT_Err_Invalid_CodeRange = 138, 1250 | FT_Err_Execution_Too_Long = 139, 1251 | FT_Err_Too_Many_Function_Defs = 140, 1252 | FT_Err_Too_Many_Instruction_Defs = 141, 1253 | FT_Err_Table_Missing = 142, 1254 | FT_Err_Horiz_Header_Missing = 143, 1255 | FT_Err_Locations_Missing = 144, 1256 | FT_Err_Name_Table_Missing = 145, 1257 | FT_Err_CMap_Table_Missing = 146, 1258 | FT_Err_Hmtx_Table_Missing = 147, 1259 | FT_Err_Post_Table_Missing = 148, 1260 | FT_Err_Invalid_Horiz_Metrics = 149, 1261 | FT_Err_Invalid_CharMap_Format = 150, 1262 | FT_Err_Invalid_PPem = 151, 1263 | FT_Err_Invalid_Vert_Metrics = 152, 1264 | FT_Err_Could_Not_Find_Context = 153, 1265 | FT_Err_Invalid_Post_Table_Format = 154, 1266 | FT_Err_Invalid_Post_Table = 155, 1267 | FT_Err_Syntax_Error = 160, 1268 | FT_Err_Stack_Underflow = 161, 1269 | FT_Err_Ignore = 162, 1270 | FT_Err_No_Unicode_Glyph_Name = 163, 1271 | FT_Err_Glyph_Too_Big = 164, 1272 | FT_Err_Missing_Startfont_Field = 176, 1273 | FT_Err_Missing_Font_Field = 177, 1274 | FT_Err_Missing_Size_Field = 178, 1275 | FT_Err_Missing_Fontboundingbox_Field = 179, 1276 | FT_Err_Missing_Chars_Field = 180, 1277 | FT_Err_Missing_Startchar_Field = 181, 1278 | FT_Err_Missing_Encoding_Field = 182, 1279 | FT_Err_Missing_Bbx_Field = 183, 1280 | FT_Err_Bbx_Too_Big = 184, 1281 | FT_Err_Corrupted_Font_Header = 185, 1282 | FT_Err_Corrupted_Font_Glyphs = 186, 1283 | FT_Err_Max = 187, 1284 | } 1285 | #[repr(C)] 1286 | #[derive(Debug, Copy)] 1287 | pub struct FT_Glyph_Metrics_ { 1288 | pub width: FT_Pos, 1289 | pub height: FT_Pos, 1290 | pub horiBearingX: FT_Pos, 1291 | pub horiBearingY: FT_Pos, 1292 | pub horiAdvance: FT_Pos, 1293 | pub vertBearingX: FT_Pos, 1294 | pub vertBearingY: FT_Pos, 1295 | pub vertAdvance: FT_Pos, 1296 | } 1297 | #[test] 1298 | fn bindgen_test_layout_FT_Glyph_Metrics_() { 1299 | assert_eq!(::std::mem::size_of::() , 64usize , concat ! 1300 | ( "Size of: " , stringify ! ( FT_Glyph_Metrics_ ) )); 1301 | assert_eq! (::std::mem::align_of::() , 8usize , concat 1302 | ! ( "Alignment of " , stringify ! ( FT_Glyph_Metrics_ ) )); 1303 | assert_eq! (unsafe { 1304 | & ( * ( 0 as * const FT_Glyph_Metrics_ ) ) . width as * const 1305 | _ as usize } , 0usize , concat ! ( 1306 | "Alignment of field: " , stringify ! ( FT_Glyph_Metrics_ ) , 1307 | "::" , stringify ! ( width ) )); 1308 | assert_eq! (unsafe { 1309 | & ( * ( 0 as * const FT_Glyph_Metrics_ ) ) . height as * const 1310 | _ as usize } , 8usize , concat ! ( 1311 | "Alignment of field: " , stringify ! ( FT_Glyph_Metrics_ ) , 1312 | "::" , stringify ! ( height ) )); 1313 | assert_eq! (unsafe { 1314 | & ( * ( 0 as * const FT_Glyph_Metrics_ ) ) . horiBearingX as * 1315 | const _ as usize } , 16usize , concat ! ( 1316 | "Alignment of field: " , stringify ! ( FT_Glyph_Metrics_ ) , 1317 | "::" , stringify ! ( horiBearingX ) )); 1318 | assert_eq! (unsafe { 1319 | & ( * ( 0 as * const FT_Glyph_Metrics_ ) ) . horiBearingY as * 1320 | const _ as usize } , 24usize , concat ! ( 1321 | "Alignment of field: " , stringify ! ( FT_Glyph_Metrics_ ) , 1322 | "::" , stringify ! ( horiBearingY ) )); 1323 | assert_eq! (unsafe { 1324 | & ( * ( 0 as * const FT_Glyph_Metrics_ ) ) . horiAdvance as * 1325 | const _ as usize } , 32usize , concat ! ( 1326 | "Alignment of field: " , stringify ! ( FT_Glyph_Metrics_ ) , 1327 | "::" , stringify ! ( horiAdvance ) )); 1328 | assert_eq! (unsafe { 1329 | & ( * ( 0 as * const FT_Glyph_Metrics_ ) ) . vertBearingX as * 1330 | const _ as usize } , 40usize , concat ! ( 1331 | "Alignment of field: " , stringify ! ( FT_Glyph_Metrics_ ) , 1332 | "::" , stringify ! ( vertBearingX ) )); 1333 | assert_eq! (unsafe { 1334 | & ( * ( 0 as * const FT_Glyph_Metrics_ ) ) . vertBearingY as * 1335 | const _ as usize } , 48usize , concat ! ( 1336 | "Alignment of field: " , stringify ! ( FT_Glyph_Metrics_ ) , 1337 | "::" , stringify ! ( vertBearingY ) )); 1338 | assert_eq! (unsafe { 1339 | & ( * ( 0 as * const FT_Glyph_Metrics_ ) ) . vertAdvance as * 1340 | const _ as usize } , 56usize , concat ! ( 1341 | "Alignment of field: " , stringify ! ( FT_Glyph_Metrics_ ) , 1342 | "::" , stringify ! ( vertAdvance ) )); 1343 | } 1344 | impl Clone for FT_Glyph_Metrics_ { 1345 | fn clone(&self) -> Self { *self } 1346 | } 1347 | pub type FT_Glyph_Metrics = FT_Glyph_Metrics_; 1348 | #[repr(C)] 1349 | #[derive(Debug, Copy)] 1350 | pub struct FT_Bitmap_Size_ { 1351 | pub height: FT_Short, 1352 | pub width: FT_Short, 1353 | pub size: FT_Pos, 1354 | pub x_ppem: FT_Pos, 1355 | pub y_ppem: FT_Pos, 1356 | } 1357 | #[test] 1358 | fn bindgen_test_layout_FT_Bitmap_Size_() { 1359 | assert_eq!(::std::mem::size_of::() , 32usize , concat ! ( 1360 | "Size of: " , stringify ! ( FT_Bitmap_Size_ ) )); 1361 | assert_eq! (::std::mem::align_of::() , 8usize , concat ! 1362 | ( "Alignment of " , stringify ! ( FT_Bitmap_Size_ ) )); 1363 | assert_eq! (unsafe { 1364 | & ( * ( 0 as * const FT_Bitmap_Size_ ) ) . height as * const _ 1365 | as usize } , 0usize , concat ! ( 1366 | "Alignment of field: " , stringify ! ( FT_Bitmap_Size_ ) , 1367 | "::" , stringify ! ( height ) )); 1368 | assert_eq! (unsafe { 1369 | & ( * ( 0 as * const FT_Bitmap_Size_ ) ) . width as * const _ 1370 | as usize } , 2usize , concat ! ( 1371 | "Alignment of field: " , stringify ! ( FT_Bitmap_Size_ ) , 1372 | "::" , stringify ! ( width ) )); 1373 | assert_eq! (unsafe { 1374 | & ( * ( 0 as * const FT_Bitmap_Size_ ) ) . size as * const _ 1375 | as usize } , 8usize , concat ! ( 1376 | "Alignment of field: " , stringify ! ( FT_Bitmap_Size_ ) , 1377 | "::" , stringify ! ( size ) )); 1378 | assert_eq! (unsafe { 1379 | & ( * ( 0 as * const FT_Bitmap_Size_ ) ) . x_ppem as * const _ 1380 | as usize } , 16usize , concat ! ( 1381 | "Alignment of field: " , stringify ! ( FT_Bitmap_Size_ ) , 1382 | "::" , stringify ! ( x_ppem ) )); 1383 | assert_eq! (unsafe { 1384 | & ( * ( 0 as * const FT_Bitmap_Size_ ) ) . y_ppem as * const _ 1385 | as usize } , 24usize , concat ! ( 1386 | "Alignment of field: " , stringify ! ( FT_Bitmap_Size_ ) , 1387 | "::" , stringify ! ( y_ppem ) )); 1388 | } 1389 | impl Clone for FT_Bitmap_Size_ { 1390 | fn clone(&self) -> Self { *self } 1391 | } 1392 | pub type FT_Bitmap_Size = FT_Bitmap_Size_; 1393 | #[repr(C)] 1394 | #[derive(Debug, Copy, Clone)] 1395 | pub struct FT_LibraryRec_ { 1396 | _unused: [u8; 0], 1397 | } 1398 | pub type FT_Library = *mut FT_LibraryRec_; 1399 | #[repr(C)] 1400 | #[derive(Debug, Copy, Clone)] 1401 | pub struct FT_ModuleRec_ { 1402 | _unused: [u8; 0], 1403 | } 1404 | pub type FT_Module = *mut FT_ModuleRec_; 1405 | #[repr(C)] 1406 | #[derive(Debug, Copy, Clone)] 1407 | pub struct FT_DriverRec_ { 1408 | _unused: [u8; 0], 1409 | } 1410 | pub type FT_Driver = *mut FT_DriverRec_; 1411 | #[repr(C)] 1412 | #[derive(Debug, Copy, Clone)] 1413 | pub struct FT_RendererRec_ { 1414 | _unused: [u8; 0], 1415 | } 1416 | pub type FT_Renderer = *mut FT_RendererRec_; 1417 | #[repr(C)] 1418 | #[derive(Debug, Copy)] 1419 | pub struct FT_FaceRec_ { 1420 | pub num_faces: FT_Long, 1421 | pub face_index: FT_Long, 1422 | pub face_flags: FT_Long, 1423 | pub style_flags: FT_Long, 1424 | pub num_glyphs: FT_Long, 1425 | pub family_name: *mut FT_String, 1426 | pub style_name: *mut FT_String, 1427 | pub num_fixed_sizes: FT_Int, 1428 | pub available_sizes: *mut FT_Bitmap_Size, 1429 | pub num_charmaps: FT_Int, 1430 | pub charmaps: *mut FT_CharMap, 1431 | pub generic: FT_Generic, 1432 | pub bbox: FT_BBox, 1433 | pub units_per_EM: FT_UShort, 1434 | pub ascender: FT_Short, 1435 | pub descender: FT_Short, 1436 | pub height: FT_Short, 1437 | pub max_advance_width: FT_Short, 1438 | pub max_advance_height: FT_Short, 1439 | pub underline_position: FT_Short, 1440 | pub underline_thickness: FT_Short, 1441 | pub glyph: FT_GlyphSlot, 1442 | pub size: FT_Size, 1443 | pub charmap: FT_CharMap, 1444 | pub driver: FT_Driver, 1445 | pub memory: FT_Memory, 1446 | pub stream: FT_Stream, 1447 | pub sizes_list: FT_ListRec, 1448 | pub autohint: FT_Generic, 1449 | pub extensions: *mut ::std::os::raw::c_void, 1450 | pub internal: FT_Face_Internal, 1451 | } 1452 | #[test] 1453 | fn bindgen_test_layout_FT_FaceRec_() { 1454 | assert_eq!(::std::mem::size_of::() , 248usize , concat ! ( 1455 | "Size of: " , stringify ! ( FT_FaceRec_ ) )); 1456 | assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( 1457 | "Alignment of " , stringify ! ( FT_FaceRec_ ) )); 1458 | assert_eq! (unsafe { 1459 | & ( * ( 0 as * const FT_FaceRec_ ) ) . num_faces as * const _ 1460 | as usize } , 0usize , concat ! ( 1461 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1462 | stringify ! ( num_faces ) )); 1463 | assert_eq! (unsafe { 1464 | & ( * ( 0 as * const FT_FaceRec_ ) ) . face_index as * const _ 1465 | as usize } , 8usize , concat ! ( 1466 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1467 | stringify ! ( face_index ) )); 1468 | assert_eq! (unsafe { 1469 | & ( * ( 0 as * const FT_FaceRec_ ) ) . face_flags as * const _ 1470 | as usize } , 16usize , concat ! ( 1471 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1472 | stringify ! ( face_flags ) )); 1473 | assert_eq! (unsafe { 1474 | & ( * ( 0 as * const FT_FaceRec_ ) ) . style_flags as * const 1475 | _ as usize } , 24usize , concat ! ( 1476 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1477 | stringify ! ( style_flags ) )); 1478 | assert_eq! (unsafe { 1479 | & ( * ( 0 as * const FT_FaceRec_ ) ) . num_glyphs as * const _ 1480 | as usize } , 32usize , concat ! ( 1481 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1482 | stringify ! ( num_glyphs ) )); 1483 | assert_eq! (unsafe { 1484 | & ( * ( 0 as * const FT_FaceRec_ ) ) . family_name as * const 1485 | _ as usize } , 40usize , concat ! ( 1486 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1487 | stringify ! ( family_name ) )); 1488 | assert_eq! (unsafe { 1489 | & ( * ( 0 as * const FT_FaceRec_ ) ) . style_name as * const _ 1490 | as usize } , 48usize , concat ! ( 1491 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1492 | stringify ! ( style_name ) )); 1493 | assert_eq! (unsafe { 1494 | & ( * ( 0 as * const FT_FaceRec_ ) ) . num_fixed_sizes as * 1495 | const _ as usize } , 56usize , concat ! ( 1496 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1497 | stringify ! ( num_fixed_sizes ) )); 1498 | assert_eq! (unsafe { 1499 | & ( * ( 0 as * const FT_FaceRec_ ) ) . available_sizes as * 1500 | const _ as usize } , 64usize , concat ! ( 1501 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1502 | stringify ! ( available_sizes ) )); 1503 | assert_eq! (unsafe { 1504 | & ( * ( 0 as * const FT_FaceRec_ ) ) . num_charmaps as * const 1505 | _ as usize } , 72usize , concat ! ( 1506 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1507 | stringify ! ( num_charmaps ) )); 1508 | assert_eq! (unsafe { 1509 | & ( * ( 0 as * const FT_FaceRec_ ) ) . charmaps as * const _ 1510 | as usize } , 80usize , concat ! ( 1511 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1512 | stringify ! ( charmaps ) )); 1513 | assert_eq! (unsafe { 1514 | & ( * ( 0 as * const FT_FaceRec_ ) ) . generic as * const _ as 1515 | usize } , 88usize , concat ! ( 1516 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1517 | stringify ! ( generic ) )); 1518 | assert_eq! (unsafe { 1519 | & ( * ( 0 as * const FT_FaceRec_ ) ) . bbox as * const _ as 1520 | usize } , 104usize , concat ! ( 1521 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1522 | stringify ! ( bbox ) )); 1523 | assert_eq! (unsafe { 1524 | & ( * ( 0 as * const FT_FaceRec_ ) ) . units_per_EM as * const 1525 | _ as usize } , 136usize , concat ! ( 1526 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1527 | stringify ! ( units_per_EM ) )); 1528 | assert_eq! (unsafe { 1529 | & ( * ( 0 as * const FT_FaceRec_ ) ) . ascender as * const _ 1530 | as usize } , 138usize , concat ! ( 1531 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1532 | stringify ! ( ascender ) )); 1533 | assert_eq! (unsafe { 1534 | & ( * ( 0 as * const FT_FaceRec_ ) ) . descender as * const _ 1535 | as usize } , 140usize , concat ! ( 1536 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1537 | stringify ! ( descender ) )); 1538 | assert_eq! (unsafe { 1539 | & ( * ( 0 as * const FT_FaceRec_ ) ) . height as * const _ as 1540 | usize } , 142usize , concat ! ( 1541 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1542 | stringify ! ( height ) )); 1543 | assert_eq! (unsafe { 1544 | & ( * ( 0 as * const FT_FaceRec_ ) ) . max_advance_width as * 1545 | const _ as usize } , 144usize , concat ! ( 1546 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1547 | stringify ! ( max_advance_width ) )); 1548 | assert_eq! (unsafe { 1549 | & ( * ( 0 as * const FT_FaceRec_ ) ) . max_advance_height as * 1550 | const _ as usize } , 146usize , concat ! ( 1551 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1552 | stringify ! ( max_advance_height ) )); 1553 | assert_eq! (unsafe { 1554 | & ( * ( 0 as * const FT_FaceRec_ ) ) . underline_position as * 1555 | const _ as usize } , 148usize , concat ! ( 1556 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1557 | stringify ! ( underline_position ) )); 1558 | assert_eq! (unsafe { 1559 | & ( * ( 0 as * const FT_FaceRec_ ) ) . underline_thickness as 1560 | * const _ as usize } , 150usize , concat ! ( 1561 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1562 | stringify ! ( underline_thickness ) )); 1563 | assert_eq! (unsafe { 1564 | & ( * ( 0 as * const FT_FaceRec_ ) ) . glyph as * const _ as 1565 | usize } , 152usize , concat ! ( 1566 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1567 | stringify ! ( glyph ) )); 1568 | assert_eq! (unsafe { 1569 | & ( * ( 0 as * const FT_FaceRec_ ) ) . size as * const _ as 1570 | usize } , 160usize , concat ! ( 1571 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1572 | stringify ! ( size ) )); 1573 | assert_eq! (unsafe { 1574 | & ( * ( 0 as * const FT_FaceRec_ ) ) . charmap as * const _ as 1575 | usize } , 168usize , concat ! ( 1576 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1577 | stringify ! ( charmap ) )); 1578 | assert_eq! (unsafe { 1579 | & ( * ( 0 as * const FT_FaceRec_ ) ) . driver as * const _ as 1580 | usize } , 176usize , concat ! ( 1581 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1582 | stringify ! ( driver ) )); 1583 | assert_eq! (unsafe { 1584 | & ( * ( 0 as * const FT_FaceRec_ ) ) . memory as * const _ as 1585 | usize } , 184usize , concat ! ( 1586 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1587 | stringify ! ( memory ) )); 1588 | assert_eq! (unsafe { 1589 | & ( * ( 0 as * const FT_FaceRec_ ) ) . stream as * const _ as 1590 | usize } , 192usize , concat ! ( 1591 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1592 | stringify ! ( stream ) )); 1593 | assert_eq! (unsafe { 1594 | & ( * ( 0 as * const FT_FaceRec_ ) ) . sizes_list as * const _ 1595 | as usize } , 200usize , concat ! ( 1596 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1597 | stringify ! ( sizes_list ) )); 1598 | assert_eq! (unsafe { 1599 | & ( * ( 0 as * const FT_FaceRec_ ) ) . autohint as * const _ 1600 | as usize } , 216usize , concat ! ( 1601 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1602 | stringify ! ( autohint ) )); 1603 | assert_eq! (unsafe { 1604 | & ( * ( 0 as * const FT_FaceRec_ ) ) . extensions as * const _ 1605 | as usize } , 232usize , concat ! ( 1606 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1607 | stringify ! ( extensions ) )); 1608 | assert_eq! (unsafe { 1609 | & ( * ( 0 as * const FT_FaceRec_ ) ) . internal as * const _ 1610 | as usize } , 240usize , concat ! ( 1611 | "Alignment of field: " , stringify ! ( FT_FaceRec_ ) , "::" , 1612 | stringify ! ( internal ) )); 1613 | } 1614 | impl Clone for FT_FaceRec_ { 1615 | fn clone(&self) -> Self { *self } 1616 | } 1617 | pub type FT_Face = *mut FT_FaceRec_; 1618 | #[repr(C)] 1619 | #[derive(Debug, Copy)] 1620 | pub struct FT_SizeRec_ { 1621 | pub face: FT_Face, 1622 | pub generic: FT_Generic, 1623 | pub metrics: FT_Size_Metrics, 1624 | pub internal: FT_Size_Internal, 1625 | } 1626 | #[test] 1627 | fn bindgen_test_layout_FT_SizeRec_() { 1628 | assert_eq!(::std::mem::size_of::() , 88usize , concat ! ( 1629 | "Size of: " , stringify ! ( FT_SizeRec_ ) )); 1630 | assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( 1631 | "Alignment of " , stringify ! ( FT_SizeRec_ ) )); 1632 | assert_eq! (unsafe { 1633 | & ( * ( 0 as * const FT_SizeRec_ ) ) . face as * const _ as 1634 | usize } , 0usize , concat ! ( 1635 | "Alignment of field: " , stringify ! ( FT_SizeRec_ ) , "::" , 1636 | stringify ! ( face ) )); 1637 | assert_eq! (unsafe { 1638 | & ( * ( 0 as * const FT_SizeRec_ ) ) . generic as * const _ as 1639 | usize } , 8usize , concat ! ( 1640 | "Alignment of field: " , stringify ! ( FT_SizeRec_ ) , "::" , 1641 | stringify ! ( generic ) )); 1642 | assert_eq! (unsafe { 1643 | & ( * ( 0 as * const FT_SizeRec_ ) ) . metrics as * const _ as 1644 | usize } , 24usize , concat ! ( 1645 | "Alignment of field: " , stringify ! ( FT_SizeRec_ ) , "::" , 1646 | stringify ! ( metrics ) )); 1647 | assert_eq! (unsafe { 1648 | & ( * ( 0 as * const FT_SizeRec_ ) ) . internal as * const _ 1649 | as usize } , 80usize , concat ! ( 1650 | "Alignment of field: " , stringify ! ( FT_SizeRec_ ) , "::" , 1651 | stringify ! ( internal ) )); 1652 | } 1653 | impl Clone for FT_SizeRec_ { 1654 | fn clone(&self) -> Self { *self } 1655 | } 1656 | pub type FT_Size = *mut FT_SizeRec_; 1657 | #[repr(C)] 1658 | #[derive(Debug, Copy)] 1659 | pub struct FT_GlyphSlotRec_ { 1660 | pub library: FT_Library, 1661 | pub face: FT_Face, 1662 | pub next: FT_GlyphSlot, 1663 | pub reserved: FT_UInt, 1664 | pub generic: FT_Generic, 1665 | pub metrics: FT_Glyph_Metrics, 1666 | pub linearHoriAdvance: FT_Fixed, 1667 | pub linearVertAdvance: FT_Fixed, 1668 | pub advance: FT_Vector, 1669 | pub format: FT_Glyph_Format, 1670 | pub bitmap: FT_Bitmap, 1671 | pub bitmap_left: FT_Int, 1672 | pub bitmap_top: FT_Int, 1673 | pub outline: FT_Outline, 1674 | pub num_subglyphs: FT_UInt, 1675 | pub subglyphs: FT_SubGlyph, 1676 | pub control_data: *mut ::std::os::raw::c_void, 1677 | pub control_len: ::std::os::raw::c_long, 1678 | pub lsb_delta: FT_Pos, 1679 | pub rsb_delta: FT_Pos, 1680 | pub other: *mut ::std::os::raw::c_void, 1681 | pub internal: FT_Slot_Internal, 1682 | } 1683 | #[test] 1684 | fn bindgen_test_layout_FT_GlyphSlotRec_() { 1685 | assert_eq!(::std::mem::size_of::() , 304usize , concat ! 1686 | ( "Size of: " , stringify ! ( FT_GlyphSlotRec_ ) )); 1687 | assert_eq! (::std::mem::align_of::() , 8usize , concat ! 1688 | ( "Alignment of " , stringify ! ( FT_GlyphSlotRec_ ) )); 1689 | assert_eq! (unsafe { 1690 | & ( * ( 0 as * const FT_GlyphSlotRec_ ) ) . library as * const 1691 | _ as usize } , 0usize , concat ! ( 1692 | "Alignment of field: " , stringify ! ( FT_GlyphSlotRec_ ) , 1693 | "::" , stringify ! ( library ) )); 1694 | assert_eq! (unsafe { 1695 | & ( * ( 0 as * const FT_GlyphSlotRec_ ) ) . face as * const _ 1696 | as usize } , 8usize , concat ! ( 1697 | "Alignment of field: " , stringify ! ( FT_GlyphSlotRec_ ) , 1698 | "::" , stringify ! ( face ) )); 1699 | assert_eq! (unsafe { 1700 | & ( * ( 0 as * const FT_GlyphSlotRec_ ) ) . next as * const _ 1701 | as usize } , 16usize , concat ! ( 1702 | "Alignment of field: " , stringify ! ( FT_GlyphSlotRec_ ) , 1703 | "::" , stringify ! ( next ) )); 1704 | assert_eq! (unsafe { 1705 | & ( * ( 0 as * const FT_GlyphSlotRec_ ) ) . reserved as * 1706 | const _ as usize } , 24usize , concat ! ( 1707 | "Alignment of field: " , stringify ! ( FT_GlyphSlotRec_ ) , 1708 | "::" , stringify ! ( reserved ) )); 1709 | assert_eq! (unsafe { 1710 | & ( * ( 0 as * const FT_GlyphSlotRec_ ) ) . generic as * const 1711 | _ as usize } , 32usize , concat ! ( 1712 | "Alignment of field: " , stringify ! ( FT_GlyphSlotRec_ ) , 1713 | "::" , stringify ! ( generic ) )); 1714 | assert_eq! (unsafe { 1715 | & ( * ( 0 as * const FT_GlyphSlotRec_ ) ) . metrics as * const 1716 | _ as usize } , 48usize , concat ! ( 1717 | "Alignment of field: " , stringify ! ( FT_GlyphSlotRec_ ) , 1718 | "::" , stringify ! ( metrics ) )); 1719 | assert_eq! (unsafe { 1720 | & ( * ( 0 as * const FT_GlyphSlotRec_ ) ) . linearHoriAdvance 1721 | as * const _ as usize } , 112usize , concat ! ( 1722 | "Alignment of field: " , stringify ! ( FT_GlyphSlotRec_ ) , 1723 | "::" , stringify ! ( linearHoriAdvance ) )); 1724 | assert_eq! (unsafe { 1725 | & ( * ( 0 as * const FT_GlyphSlotRec_ ) ) . linearVertAdvance 1726 | as * const _ as usize } , 120usize , concat ! ( 1727 | "Alignment of field: " , stringify ! ( FT_GlyphSlotRec_ ) , 1728 | "::" , stringify ! ( linearVertAdvance ) )); 1729 | assert_eq! (unsafe { 1730 | & ( * ( 0 as * const FT_GlyphSlotRec_ ) ) . advance as * const 1731 | _ as usize } , 128usize , concat ! ( 1732 | "Alignment of field: " , stringify ! ( FT_GlyphSlotRec_ ) , 1733 | "::" , stringify ! ( advance ) )); 1734 | assert_eq! (unsafe { 1735 | & ( * ( 0 as * const FT_GlyphSlotRec_ ) ) . format as * const 1736 | _ as usize } , 144usize , concat ! ( 1737 | "Alignment of field: " , stringify ! ( FT_GlyphSlotRec_ ) , 1738 | "::" , stringify ! ( format ) )); 1739 | assert_eq! (unsafe { 1740 | & ( * ( 0 as * const FT_GlyphSlotRec_ ) ) . bitmap as * const 1741 | _ as usize } , 152usize , concat ! ( 1742 | "Alignment of field: " , stringify ! ( FT_GlyphSlotRec_ ) , 1743 | "::" , stringify ! ( bitmap ) )); 1744 | assert_eq! (unsafe { 1745 | & ( * ( 0 as * const FT_GlyphSlotRec_ ) ) . bitmap_left as * 1746 | const _ as usize } , 192usize , concat ! ( 1747 | "Alignment of field: " , stringify ! ( FT_GlyphSlotRec_ ) , 1748 | "::" , stringify ! ( bitmap_left ) )); 1749 | assert_eq! (unsafe { 1750 | & ( * ( 0 as * const FT_GlyphSlotRec_ ) ) . bitmap_top as * 1751 | const _ as usize } , 196usize , concat ! ( 1752 | "Alignment of field: " , stringify ! ( FT_GlyphSlotRec_ ) , 1753 | "::" , stringify ! ( bitmap_top ) )); 1754 | assert_eq! (unsafe { 1755 | & ( * ( 0 as * const FT_GlyphSlotRec_ ) ) . outline as * const 1756 | _ as usize } , 200usize , concat ! ( 1757 | "Alignment of field: " , stringify ! ( FT_GlyphSlotRec_ ) , 1758 | "::" , stringify ! ( outline ) )); 1759 | assert_eq! (unsafe { 1760 | & ( * ( 0 as * const FT_GlyphSlotRec_ ) ) . num_subglyphs as * 1761 | const _ as usize } , 240usize , concat ! ( 1762 | "Alignment of field: " , stringify ! ( FT_GlyphSlotRec_ ) , 1763 | "::" , stringify ! ( num_subglyphs ) )); 1764 | assert_eq! (unsafe { 1765 | & ( * ( 0 as * const FT_GlyphSlotRec_ ) ) . subglyphs as * 1766 | const _ as usize } , 248usize , concat ! ( 1767 | "Alignment of field: " , stringify ! ( FT_GlyphSlotRec_ ) , 1768 | "::" , stringify ! ( subglyphs ) )); 1769 | assert_eq! (unsafe { 1770 | & ( * ( 0 as * const FT_GlyphSlotRec_ ) ) . control_data as * 1771 | const _ as usize } , 256usize , concat ! ( 1772 | "Alignment of field: " , stringify ! ( FT_GlyphSlotRec_ ) , 1773 | "::" , stringify ! ( control_data ) )); 1774 | assert_eq! (unsafe { 1775 | & ( * ( 0 as * const FT_GlyphSlotRec_ ) ) . control_len as * 1776 | const _ as usize } , 264usize , concat ! ( 1777 | "Alignment of field: " , stringify ! ( FT_GlyphSlotRec_ ) , 1778 | "::" , stringify ! ( control_len ) )); 1779 | assert_eq! (unsafe { 1780 | & ( * ( 0 as * const FT_GlyphSlotRec_ ) ) . lsb_delta as * 1781 | const _ as usize } , 272usize , concat ! ( 1782 | "Alignment of field: " , stringify ! ( FT_GlyphSlotRec_ ) , 1783 | "::" , stringify ! ( lsb_delta ) )); 1784 | assert_eq! (unsafe { 1785 | & ( * ( 0 as * const FT_GlyphSlotRec_ ) ) . rsb_delta as * 1786 | const _ as usize } , 280usize , concat ! ( 1787 | "Alignment of field: " , stringify ! ( FT_GlyphSlotRec_ ) , 1788 | "::" , stringify ! ( rsb_delta ) )); 1789 | assert_eq! (unsafe { 1790 | & ( * ( 0 as * const FT_GlyphSlotRec_ ) ) . other as * const _ 1791 | as usize } , 288usize , concat ! ( 1792 | "Alignment of field: " , stringify ! ( FT_GlyphSlotRec_ ) , 1793 | "::" , stringify ! ( other ) )); 1794 | assert_eq! (unsafe { 1795 | & ( * ( 0 as * const FT_GlyphSlotRec_ ) ) . internal as * 1796 | const _ as usize } , 296usize , concat ! ( 1797 | "Alignment of field: " , stringify ! ( FT_GlyphSlotRec_ ) , 1798 | "::" , stringify ! ( internal ) )); 1799 | } 1800 | impl Clone for FT_GlyphSlotRec_ { 1801 | fn clone(&self) -> Self { *self } 1802 | } 1803 | pub type FT_GlyphSlot = *mut FT_GlyphSlotRec_; 1804 | #[repr(C)] 1805 | #[derive(Debug, Copy)] 1806 | pub struct FT_CharMapRec_ { 1807 | pub face: FT_Face, 1808 | pub encoding: FT_Encoding, 1809 | pub platform_id: FT_UShort, 1810 | pub encoding_id: FT_UShort, 1811 | } 1812 | #[test] 1813 | fn bindgen_test_layout_FT_CharMapRec_() { 1814 | assert_eq!(::std::mem::size_of::() , 16usize , concat ! ( 1815 | "Size of: " , stringify ! ( FT_CharMapRec_ ) )); 1816 | assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( 1817 | "Alignment of " , stringify ! ( FT_CharMapRec_ ) )); 1818 | assert_eq! (unsafe { 1819 | & ( * ( 0 as * const FT_CharMapRec_ ) ) . face as * const _ as 1820 | usize } , 0usize , concat ! ( 1821 | "Alignment of field: " , stringify ! ( FT_CharMapRec_ ) , "::" 1822 | , stringify ! ( face ) )); 1823 | assert_eq! (unsafe { 1824 | & ( * ( 0 as * const FT_CharMapRec_ ) ) . encoding as * const 1825 | _ as usize } , 8usize , concat ! ( 1826 | "Alignment of field: " , stringify ! ( FT_CharMapRec_ ) , "::" 1827 | , stringify ! ( encoding ) )); 1828 | assert_eq! (unsafe { 1829 | & ( * ( 0 as * const FT_CharMapRec_ ) ) . platform_id as * 1830 | const _ as usize } , 12usize , concat ! ( 1831 | "Alignment of field: " , stringify ! ( FT_CharMapRec_ ) , "::" 1832 | , stringify ! ( platform_id ) )); 1833 | assert_eq! (unsafe { 1834 | & ( * ( 0 as * const FT_CharMapRec_ ) ) . encoding_id as * 1835 | const _ as usize } , 14usize , concat ! ( 1836 | "Alignment of field: " , stringify ! ( FT_CharMapRec_ ) , "::" 1837 | , stringify ! ( encoding_id ) )); 1838 | } 1839 | impl Clone for FT_CharMapRec_ { 1840 | fn clone(&self) -> Self { *self } 1841 | } 1842 | pub type FT_CharMap = *mut FT_CharMapRec_; 1843 | pub const FT_Encoding__FT_ENCODING_MS_SJIS: FT_Encoding_ = 1844 | FT_Encoding_::FT_ENCODING_SJIS; 1845 | pub const FT_Encoding__FT_ENCODING_MS_GB2312: FT_Encoding_ = 1846 | FT_Encoding_::FT_ENCODING_GB2312; 1847 | pub const FT_Encoding__FT_ENCODING_MS_BIG5: FT_Encoding_ = 1848 | FT_Encoding_::FT_ENCODING_BIG5; 1849 | pub const FT_Encoding__FT_ENCODING_MS_WANSUNG: FT_Encoding_ = 1850 | FT_Encoding_::FT_ENCODING_WANSUNG; 1851 | pub const FT_Encoding__FT_ENCODING_MS_JOHAB: FT_Encoding_ = 1852 | FT_Encoding_::FT_ENCODING_JOHAB; 1853 | #[repr(u32)] 1854 | #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] 1855 | pub enum FT_Encoding_ { 1856 | FT_ENCODING_NONE = 0, 1857 | FT_ENCODING_MS_SYMBOL = 1937337698, 1858 | FT_ENCODING_UNICODE = 1970170211, 1859 | FT_ENCODING_SJIS = 1936353651, 1860 | FT_ENCODING_GB2312 = 1734484000, 1861 | FT_ENCODING_BIG5 = 1651074869, 1862 | FT_ENCODING_WANSUNG = 2002873971, 1863 | FT_ENCODING_JOHAB = 1785686113, 1864 | FT_ENCODING_ADOBE_STANDARD = 1094995778, 1865 | FT_ENCODING_ADOBE_EXPERT = 1094992453, 1866 | FT_ENCODING_ADOBE_CUSTOM = 1094992451, 1867 | FT_ENCODING_ADOBE_LATIN_1 = 1818326065, 1868 | FT_ENCODING_OLD_LATIN_2 = 1818326066, 1869 | FT_ENCODING_APPLE_ROMAN = 1634889070, 1870 | } 1871 | pub use self::FT_Encoding_ as FT_Encoding; 1872 | pub type FT_CharMapRec = FT_CharMapRec_; 1873 | #[repr(C)] 1874 | #[derive(Debug, Copy, Clone)] 1875 | pub struct FT_Face_InternalRec_ { 1876 | _unused: [u8; 0], 1877 | } 1878 | pub type FT_Face_Internal = *mut FT_Face_InternalRec_; 1879 | pub type FT_FaceRec = FT_FaceRec_; 1880 | #[repr(C)] 1881 | #[derive(Debug, Copy, Clone)] 1882 | pub struct FT_Size_InternalRec_ { 1883 | _unused: [u8; 0], 1884 | } 1885 | pub type FT_Size_Internal = *mut FT_Size_InternalRec_; 1886 | #[repr(C)] 1887 | #[derive(Debug, Copy)] 1888 | pub struct FT_Size_Metrics_ { 1889 | pub x_ppem: FT_UShort, 1890 | pub y_ppem: FT_UShort, 1891 | pub x_scale: FT_Fixed, 1892 | pub y_scale: FT_Fixed, 1893 | pub ascender: FT_Pos, 1894 | pub descender: FT_Pos, 1895 | pub height: FT_Pos, 1896 | pub max_advance: FT_Pos, 1897 | } 1898 | #[test] 1899 | fn bindgen_test_layout_FT_Size_Metrics_() { 1900 | assert_eq!(::std::mem::size_of::() , 56usize , concat ! 1901 | ( "Size of: " , stringify ! ( FT_Size_Metrics_ ) )); 1902 | assert_eq! (::std::mem::align_of::() , 8usize , concat ! 1903 | ( "Alignment of " , stringify ! ( FT_Size_Metrics_ ) )); 1904 | assert_eq! (unsafe { 1905 | & ( * ( 0 as * const FT_Size_Metrics_ ) ) . x_ppem as * const 1906 | _ as usize } , 0usize , concat ! ( 1907 | "Alignment of field: " , stringify ! ( FT_Size_Metrics_ ) , 1908 | "::" , stringify ! ( x_ppem ) )); 1909 | assert_eq! (unsafe { 1910 | & ( * ( 0 as * const FT_Size_Metrics_ ) ) . y_ppem as * const 1911 | _ as usize } , 2usize , concat ! ( 1912 | "Alignment of field: " , stringify ! ( FT_Size_Metrics_ ) , 1913 | "::" , stringify ! ( y_ppem ) )); 1914 | assert_eq! (unsafe { 1915 | & ( * ( 0 as * const FT_Size_Metrics_ ) ) . x_scale as * const 1916 | _ as usize } , 8usize , concat ! ( 1917 | "Alignment of field: " , stringify ! ( FT_Size_Metrics_ ) , 1918 | "::" , stringify ! ( x_scale ) )); 1919 | assert_eq! (unsafe { 1920 | & ( * ( 0 as * const FT_Size_Metrics_ ) ) . y_scale as * const 1921 | _ as usize } , 16usize , concat ! ( 1922 | "Alignment of field: " , stringify ! ( FT_Size_Metrics_ ) , 1923 | "::" , stringify ! ( y_scale ) )); 1924 | assert_eq! (unsafe { 1925 | & ( * ( 0 as * const FT_Size_Metrics_ ) ) . ascender as * 1926 | const _ as usize } , 24usize , concat ! ( 1927 | "Alignment of field: " , stringify ! ( FT_Size_Metrics_ ) , 1928 | "::" , stringify ! ( ascender ) )); 1929 | assert_eq! (unsafe { 1930 | & ( * ( 0 as * const FT_Size_Metrics_ ) ) . descender as * 1931 | const _ as usize } , 32usize , concat ! ( 1932 | "Alignment of field: " , stringify ! ( FT_Size_Metrics_ ) , 1933 | "::" , stringify ! ( descender ) )); 1934 | assert_eq! (unsafe { 1935 | & ( * ( 0 as * const FT_Size_Metrics_ ) ) . height as * const 1936 | _ as usize } , 40usize , concat ! ( 1937 | "Alignment of field: " , stringify ! ( FT_Size_Metrics_ ) , 1938 | "::" , stringify ! ( height ) )); 1939 | assert_eq! (unsafe { 1940 | & ( * ( 0 as * const FT_Size_Metrics_ ) ) . max_advance as * 1941 | const _ as usize } , 48usize , concat ! ( 1942 | "Alignment of field: " , stringify ! ( FT_Size_Metrics_ ) , 1943 | "::" , stringify ! ( max_advance ) )); 1944 | } 1945 | impl Clone for FT_Size_Metrics_ { 1946 | fn clone(&self) -> Self { *self } 1947 | } 1948 | pub type FT_Size_Metrics = FT_Size_Metrics_; 1949 | pub type FT_SizeRec = FT_SizeRec_; 1950 | #[repr(C)] 1951 | #[derive(Debug, Copy, Clone)] 1952 | pub struct FT_SubGlyphRec_ { 1953 | _unused: [u8; 0], 1954 | } 1955 | pub type FT_SubGlyph = *mut FT_SubGlyphRec_; 1956 | #[repr(C)] 1957 | #[derive(Debug, Copy, Clone)] 1958 | pub struct FT_Slot_InternalRec_ { 1959 | _unused: [u8; 0], 1960 | } 1961 | pub type FT_Slot_Internal = *mut FT_Slot_InternalRec_; 1962 | pub type FT_GlyphSlotRec = FT_GlyphSlotRec_; 1963 | extern "C" { 1964 | pub fn FT_Init_FreeType(alibrary: *mut FT_Library) -> FT_Error; 1965 | } 1966 | extern "C" { 1967 | pub fn FT_Done_FreeType(library: FT_Library) -> FT_Error; 1968 | } 1969 | #[repr(C)] 1970 | #[derive(Debug, Copy)] 1971 | pub struct FT_Parameter_ { 1972 | pub tag: FT_ULong, 1973 | pub data: FT_Pointer, 1974 | } 1975 | #[test] 1976 | fn bindgen_test_layout_FT_Parameter_() { 1977 | assert_eq!(::std::mem::size_of::() , 16usize , concat ! ( 1978 | "Size of: " , stringify ! ( FT_Parameter_ ) )); 1979 | assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( 1980 | "Alignment of " , stringify ! ( FT_Parameter_ ) )); 1981 | assert_eq! (unsafe { 1982 | & ( * ( 0 as * const FT_Parameter_ ) ) . tag as * const _ as 1983 | usize } , 0usize , concat ! ( 1984 | "Alignment of field: " , stringify ! ( FT_Parameter_ ) , "::" 1985 | , stringify ! ( tag ) )); 1986 | assert_eq! (unsafe { 1987 | & ( * ( 0 as * const FT_Parameter_ ) ) . data as * const _ as 1988 | usize } , 8usize , concat ! ( 1989 | "Alignment of field: " , stringify ! ( FT_Parameter_ ) , "::" 1990 | , stringify ! ( data ) )); 1991 | } 1992 | impl Clone for FT_Parameter_ { 1993 | fn clone(&self) -> Self { *self } 1994 | } 1995 | pub type FT_Parameter = FT_Parameter_; 1996 | #[repr(C)] 1997 | #[derive(Debug, Copy)] 1998 | pub struct FT_Open_Args_ { 1999 | pub flags: FT_UInt, 2000 | pub memory_base: *const FT_Byte, 2001 | pub memory_size: FT_Long, 2002 | pub pathname: *mut FT_String, 2003 | pub stream: FT_Stream, 2004 | pub driver: FT_Module, 2005 | pub num_params: FT_Int, 2006 | pub params: *mut FT_Parameter, 2007 | } 2008 | #[test] 2009 | fn bindgen_test_layout_FT_Open_Args_() { 2010 | assert_eq!(::std::mem::size_of::() , 64usize , concat ! ( 2011 | "Size of: " , stringify ! ( FT_Open_Args_ ) )); 2012 | assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( 2013 | "Alignment of " , stringify ! ( FT_Open_Args_ ) )); 2014 | assert_eq! (unsafe { 2015 | & ( * ( 0 as * const FT_Open_Args_ ) ) . flags as * const _ as 2016 | usize } , 0usize , concat ! ( 2017 | "Alignment of field: " , stringify ! ( FT_Open_Args_ ) , "::" 2018 | , stringify ! ( flags ) )); 2019 | assert_eq! (unsafe { 2020 | & ( * ( 0 as * const FT_Open_Args_ ) ) . memory_base as * 2021 | const _ as usize } , 8usize , concat ! ( 2022 | "Alignment of field: " , stringify ! ( FT_Open_Args_ ) , "::" 2023 | , stringify ! ( memory_base ) )); 2024 | assert_eq! (unsafe { 2025 | & ( * ( 0 as * const FT_Open_Args_ ) ) . memory_size as * 2026 | const _ as usize } , 16usize , concat ! ( 2027 | "Alignment of field: " , stringify ! ( FT_Open_Args_ ) , "::" 2028 | , stringify ! ( memory_size ) )); 2029 | assert_eq! (unsafe { 2030 | & ( * ( 0 as * const FT_Open_Args_ ) ) . pathname as * const _ 2031 | as usize } , 24usize , concat ! ( 2032 | "Alignment of field: " , stringify ! ( FT_Open_Args_ ) , "::" 2033 | , stringify ! ( pathname ) )); 2034 | assert_eq! (unsafe { 2035 | & ( * ( 0 as * const FT_Open_Args_ ) ) . stream as * const _ 2036 | as usize } , 32usize , concat ! ( 2037 | "Alignment of field: " , stringify ! ( FT_Open_Args_ ) , "::" 2038 | , stringify ! ( stream ) )); 2039 | assert_eq! (unsafe { 2040 | & ( * ( 0 as * const FT_Open_Args_ ) ) . driver as * const _ 2041 | as usize } , 40usize , concat ! ( 2042 | "Alignment of field: " , stringify ! ( FT_Open_Args_ ) , "::" 2043 | , stringify ! ( driver ) )); 2044 | assert_eq! (unsafe { 2045 | & ( * ( 0 as * const FT_Open_Args_ ) ) . num_params as * const 2046 | _ as usize } , 48usize , concat ! ( 2047 | "Alignment of field: " , stringify ! ( FT_Open_Args_ ) , "::" 2048 | , stringify ! ( num_params ) )); 2049 | assert_eq! (unsafe { 2050 | & ( * ( 0 as * const FT_Open_Args_ ) ) . params as * const _ 2051 | as usize } , 56usize , concat ! ( 2052 | "Alignment of field: " , stringify ! ( FT_Open_Args_ ) , "::" 2053 | , stringify ! ( params ) )); 2054 | } 2055 | impl Clone for FT_Open_Args_ { 2056 | fn clone(&self) -> Self { *self } 2057 | } 2058 | pub type FT_Open_Args = FT_Open_Args_; 2059 | extern "C" { 2060 | pub fn FT_New_Face(library: FT_Library, 2061 | filepathname: *const ::std::os::raw::c_char, 2062 | face_index: FT_Long, aface: *mut FT_Face) -> FT_Error; 2063 | } 2064 | extern "C" { 2065 | pub fn FT_New_Memory_Face(library: FT_Library, file_base: *const FT_Byte, 2066 | file_size: FT_Long, face_index: FT_Long, 2067 | aface: *mut FT_Face) -> FT_Error; 2068 | } 2069 | extern "C" { 2070 | pub fn FT_Open_Face(library: FT_Library, args: *const FT_Open_Args, 2071 | face_index: FT_Long, aface: *mut FT_Face) -> FT_Error; 2072 | } 2073 | extern "C" { 2074 | pub fn FT_Attach_File(face: FT_Face, 2075 | filepathname: *const ::std::os::raw::c_char) 2076 | -> FT_Error; 2077 | } 2078 | extern "C" { 2079 | pub fn FT_Attach_Stream(face: FT_Face, parameters: *mut FT_Open_Args) 2080 | -> FT_Error; 2081 | } 2082 | extern "C" { 2083 | pub fn FT_Reference_Face(face: FT_Face) -> FT_Error; 2084 | } 2085 | extern "C" { 2086 | pub fn FT_Done_Face(face: FT_Face) -> FT_Error; 2087 | } 2088 | extern "C" { 2089 | pub fn FT_Select_Size(face: FT_Face, strike_index: FT_Int) -> FT_Error; 2090 | } 2091 | #[repr(u32)] 2092 | #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] 2093 | pub enum FT_Size_Request_Type_ { 2094 | FT_SIZE_REQUEST_TYPE_NOMINAL = 0, 2095 | FT_SIZE_REQUEST_TYPE_REAL_DIM = 1, 2096 | FT_SIZE_REQUEST_TYPE_BBOX = 2, 2097 | FT_SIZE_REQUEST_TYPE_CELL = 3, 2098 | FT_SIZE_REQUEST_TYPE_SCALES = 4, 2099 | FT_SIZE_REQUEST_TYPE_MAX = 5, 2100 | } 2101 | pub use self::FT_Size_Request_Type_ as FT_Size_Request_Type; 2102 | #[repr(C)] 2103 | #[derive(Debug, Copy)] 2104 | pub struct FT_Size_RequestRec_ { 2105 | pub type_: FT_Size_Request_Type, 2106 | pub width: FT_Long, 2107 | pub height: FT_Long, 2108 | pub horiResolution: FT_UInt, 2109 | pub vertResolution: FT_UInt, 2110 | } 2111 | #[test] 2112 | fn bindgen_test_layout_FT_Size_RequestRec_() { 2113 | assert_eq!(::std::mem::size_of::() , 32usize , concat 2114 | ! ( "Size of: " , stringify ! ( FT_Size_RequestRec_ ) )); 2115 | assert_eq! (::std::mem::align_of::() , 8usize , 2116 | concat ! ( 2117 | "Alignment of " , stringify ! ( FT_Size_RequestRec_ ) )); 2118 | assert_eq! (unsafe { 2119 | & ( * ( 0 as * const FT_Size_RequestRec_ ) ) . type_ as * 2120 | const _ as usize } , 0usize , concat ! ( 2121 | "Alignment of field: " , stringify ! ( FT_Size_RequestRec_ ) , 2122 | "::" , stringify ! ( type_ ) )); 2123 | assert_eq! (unsafe { 2124 | & ( * ( 0 as * const FT_Size_RequestRec_ ) ) . width as * 2125 | const _ as usize } , 8usize , concat ! ( 2126 | "Alignment of field: " , stringify ! ( FT_Size_RequestRec_ ) , 2127 | "::" , stringify ! ( width ) )); 2128 | assert_eq! (unsafe { 2129 | & ( * ( 0 as * const FT_Size_RequestRec_ ) ) . height as * 2130 | const _ as usize } , 16usize , concat ! ( 2131 | "Alignment of field: " , stringify ! ( FT_Size_RequestRec_ ) , 2132 | "::" , stringify ! ( height ) )); 2133 | assert_eq! (unsafe { 2134 | & ( * ( 0 as * const FT_Size_RequestRec_ ) ) . horiResolution 2135 | as * const _ as usize } , 24usize , concat ! ( 2136 | "Alignment of field: " , stringify ! ( FT_Size_RequestRec_ ) , 2137 | "::" , stringify ! ( horiResolution ) )); 2138 | assert_eq! (unsafe { 2139 | & ( * ( 0 as * const FT_Size_RequestRec_ ) ) . vertResolution 2140 | as * const _ as usize } , 28usize , concat ! ( 2141 | "Alignment of field: " , stringify ! ( FT_Size_RequestRec_ ) , 2142 | "::" , stringify ! ( vertResolution ) )); 2143 | } 2144 | impl Clone for FT_Size_RequestRec_ { 2145 | fn clone(&self) -> Self { *self } 2146 | } 2147 | pub type FT_Size_RequestRec = FT_Size_RequestRec_; 2148 | pub type FT_Size_Request = *mut FT_Size_RequestRec_; 2149 | extern "C" { 2150 | pub fn FT_Request_Size(face: FT_Face, req: FT_Size_Request) -> FT_Error; 2151 | } 2152 | extern "C" { 2153 | pub fn FT_Set_Char_Size(face: FT_Face, char_width: FT_F26Dot6, 2154 | char_height: FT_F26Dot6, horz_resolution: FT_UInt, 2155 | vert_resolution: FT_UInt) -> FT_Error; 2156 | } 2157 | extern "C" { 2158 | pub fn FT_Set_Pixel_Sizes(face: FT_Face, pixel_width: FT_UInt, 2159 | pixel_height: FT_UInt) -> FT_Error; 2160 | } 2161 | extern "C" { 2162 | pub fn FT_Load_Glyph(face: FT_Face, glyph_index: FT_UInt, 2163 | load_flags: FT_Int32) -> FT_Error; 2164 | } 2165 | extern "C" { 2166 | pub fn FT_Load_Char(face: FT_Face, char_code: FT_ULong, 2167 | load_flags: FT_Int32) -> FT_Error; 2168 | } 2169 | extern "C" { 2170 | pub fn FT_Set_Transform(face: FT_Face, matrix: *mut FT_Matrix, 2171 | delta: *mut FT_Vector); 2172 | } 2173 | #[repr(u32)] 2174 | #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] 2175 | pub enum FT_Render_Mode_ { 2176 | FT_RENDER_MODE_NORMAL = 0, 2177 | FT_RENDER_MODE_LIGHT = 1, 2178 | FT_RENDER_MODE_MONO = 2, 2179 | FT_RENDER_MODE_LCD = 3, 2180 | FT_RENDER_MODE_LCD_V = 4, 2181 | FT_RENDER_MODE_MAX = 5, 2182 | } 2183 | pub use self::FT_Render_Mode_ as FT_Render_Mode; 2184 | extern "C" { 2185 | pub fn FT_Render_Glyph(slot: FT_GlyphSlot, render_mode: FT_Render_Mode) 2186 | -> FT_Error; 2187 | } 2188 | #[repr(u32)] 2189 | #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] 2190 | pub enum FT_Kerning_Mode_ { 2191 | FT_KERNING_DEFAULT = 0, 2192 | FT_KERNING_UNFITTED = 1, 2193 | FT_KERNING_UNSCALED = 2, 2194 | } 2195 | pub use self::FT_Kerning_Mode_ as FT_Kerning_Mode; 2196 | extern "C" { 2197 | pub fn FT_Get_Kerning(face: FT_Face, left_glyph: FT_UInt, 2198 | right_glyph: FT_UInt, kern_mode: FT_UInt, 2199 | akerning: *mut FT_Vector) -> FT_Error; 2200 | } 2201 | extern "C" { 2202 | pub fn FT_Get_Track_Kerning(face: FT_Face, point_size: FT_Fixed, 2203 | degree: FT_Int, akerning: *mut FT_Fixed) 2204 | -> FT_Error; 2205 | } 2206 | extern "C" { 2207 | pub fn FT_Get_Glyph_Name(face: FT_Face, glyph_index: FT_UInt, 2208 | buffer: FT_Pointer, buffer_max: FT_UInt) 2209 | -> FT_Error; 2210 | } 2211 | extern "C" { 2212 | pub fn FT_Get_Postscript_Name(face: FT_Face) 2213 | -> *const ::std::os::raw::c_char; 2214 | } 2215 | extern "C" { 2216 | pub fn FT_Select_Charmap(face: FT_Face, encoding: FT_Encoding) 2217 | -> FT_Error; 2218 | } 2219 | extern "C" { 2220 | pub fn FT_Set_Charmap(face: FT_Face, charmap: FT_CharMap) -> FT_Error; 2221 | } 2222 | extern "C" { 2223 | pub fn FT_Get_Charmap_Index(charmap: FT_CharMap) -> FT_Int; 2224 | } 2225 | extern "C" { 2226 | pub fn FT_Get_Char_Index(face: FT_Face, charcode: FT_ULong) -> FT_UInt; 2227 | } 2228 | extern "C" { 2229 | pub fn FT_Get_First_Char(face: FT_Face, agindex: *mut FT_UInt) 2230 | -> FT_ULong; 2231 | } 2232 | extern "C" { 2233 | pub fn FT_Get_Next_Char(face: FT_Face, char_code: FT_ULong, 2234 | agindex: *mut FT_UInt) -> FT_ULong; 2235 | } 2236 | extern "C" { 2237 | pub fn FT_Get_Name_Index(face: FT_Face, glyph_name: *mut FT_String) 2238 | -> FT_UInt; 2239 | } 2240 | extern "C" { 2241 | pub fn FT_Get_SubGlyph_Info(glyph: FT_GlyphSlot, sub_index: FT_UInt, 2242 | p_index: *mut FT_Int, p_flags: *mut FT_UInt, 2243 | p_arg1: *mut FT_Int, p_arg2: *mut FT_Int, 2244 | p_transform: *mut FT_Matrix) -> FT_Error; 2245 | } 2246 | extern "C" { 2247 | pub fn FT_Get_FSType_Flags(face: FT_Face) -> FT_UShort; 2248 | } 2249 | extern "C" { 2250 | pub fn FT_Face_GetCharVariantIndex(face: FT_Face, charcode: FT_ULong, 2251 | variantSelector: FT_ULong) -> FT_UInt; 2252 | } 2253 | extern "C" { 2254 | pub fn FT_Face_GetCharVariantIsDefault(face: FT_Face, charcode: FT_ULong, 2255 | variantSelector: FT_ULong) 2256 | -> FT_Int; 2257 | } 2258 | extern "C" { 2259 | pub fn FT_Face_GetVariantSelectors(face: FT_Face) -> *mut FT_UInt32; 2260 | } 2261 | extern "C" { 2262 | pub fn FT_Face_GetVariantsOfChar(face: FT_Face, charcode: FT_ULong) 2263 | -> *mut FT_UInt32; 2264 | } 2265 | extern "C" { 2266 | pub fn FT_Face_GetCharsOfVariant(face: FT_Face, variantSelector: FT_ULong) 2267 | -> *mut FT_UInt32; 2268 | } 2269 | extern "C" { 2270 | pub fn FT_MulDiv(a: FT_Long, b: FT_Long, c: FT_Long) -> FT_Long; 2271 | } 2272 | extern "C" { 2273 | pub fn FT_MulFix(a: FT_Long, b: FT_Long) -> FT_Long; 2274 | } 2275 | extern "C" { 2276 | pub fn FT_DivFix(a: FT_Long, b: FT_Long) -> FT_Long; 2277 | } 2278 | extern "C" { 2279 | pub fn FT_RoundFix(a: FT_Fixed) -> FT_Fixed; 2280 | } 2281 | extern "C" { 2282 | pub fn FT_CeilFix(a: FT_Fixed) -> FT_Fixed; 2283 | } 2284 | extern "C" { 2285 | pub fn FT_FloorFix(a: FT_Fixed) -> FT_Fixed; 2286 | } 2287 | extern "C" { 2288 | pub fn FT_Vector_Transform(vec: *mut FT_Vector, matrix: *const FT_Matrix); 2289 | } 2290 | extern "C" { 2291 | pub fn FT_Library_Version(library: FT_Library, amajor: *mut FT_Int, 2292 | aminor: *mut FT_Int, apatch: *mut FT_Int); 2293 | } 2294 | extern "C" { 2295 | pub fn FT_Face_CheckTrueTypePatents(face: FT_Face) -> FT_Bool; 2296 | } 2297 | extern "C" { 2298 | pub fn FT_Face_SetUnpatentedHinting(face: FT_Face, value: FT_Bool) 2299 | -> FT_Bool; 2300 | } 2301 | #[repr(u32)] 2302 | #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] 2303 | pub enum FT_LcdFilter_ { 2304 | FT_LCD_FILTER_NONE = 0, 2305 | FT_LCD_FILTER_DEFAULT = 1, 2306 | FT_LCD_FILTER_LIGHT = 2, 2307 | FT_LCD_FILTER_LEGACY1 = 3, 2308 | FT_LCD_FILTER_LEGACY = 16, 2309 | FT_LCD_FILTER_MAX = 17, 2310 | } 2311 | pub use self::FT_LcdFilter_ as FT_LcdFilter; 2312 | extern "C" { 2313 | pub fn FT_Library_SetLcdFilter(library: FT_Library, filter: FT_LcdFilter) 2314 | -> FT_Error; 2315 | } 2316 | extern "C" { 2317 | pub fn FT_Library_SetLcdFilterWeights(library: FT_Library, 2318 | weights: 2319 | *mut ::std::os::raw::c_uchar) 2320 | -> FT_Error; 2321 | } 2322 | #[repr(u32)] 2323 | #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] 2324 | pub enum FT_Sfnt_Tag_ { 2325 | FT_SFNT_HEAD = 0, 2326 | FT_SFNT_MAXP = 1, 2327 | FT_SFNT_OS2 = 2, 2328 | FT_SFNT_HHEA = 3, 2329 | FT_SFNT_VHEA = 4, 2330 | FT_SFNT_POST = 5, 2331 | FT_SFNT_PCLT = 6, 2332 | FT_SFNT_MAX = 7, 2333 | } 2334 | pub use self::FT_Sfnt_Tag_ as FT_Sfnt_Tag; 2335 | extern "C" { 2336 | pub fn FT_Get_Sfnt_Table(face: FT_Face, tag: FT_Sfnt_Tag) 2337 | -> *mut ::std::os::raw::c_void; 2338 | } 2339 | extern "C" { 2340 | pub fn FT_Load_Sfnt_Table(face: FT_Face, tag: FT_ULong, offset: FT_Long, 2341 | buffer: *mut FT_Byte, length: *mut FT_ULong) 2342 | -> FT_Error; 2343 | } 2344 | extern "C" { 2345 | pub fn FT_Sfnt_Table_Info(face: FT_Face, table_index: FT_UInt, 2346 | tag: *mut FT_ULong, length: *mut FT_ULong) 2347 | -> FT_Error; 2348 | } 2349 | extern "C" { 2350 | pub fn FT_Get_CMap_Language_ID(charmap: FT_CharMap) -> FT_ULong; 2351 | } 2352 | extern "C" { 2353 | pub fn FT_Get_CMap_Format(charmap: FT_CharMap) -> FT_Long; 2354 | } 2355 | pub type FT_Module_Interface = FT_Pointer; 2356 | pub type FT_Module_Constructor = 2357 | ::std::option::Option FT_Error>; 2359 | pub type FT_Module_Destructor = 2360 | ::std::option::Option; 2361 | pub type FT_Module_Requester = 2362 | ::std::option::Option FT_Module_Interface>; 2366 | #[repr(C)] 2367 | #[derive(Debug, Copy)] 2368 | pub struct FT_Module_Class_ { 2369 | pub module_flags: FT_ULong, 2370 | pub module_size: FT_Long, 2371 | pub module_name: *const FT_String, 2372 | pub module_version: FT_Fixed, 2373 | pub module_requires: FT_Fixed, 2374 | pub module_interface: *const ::std::os::raw::c_void, 2375 | pub module_init: FT_Module_Constructor, 2376 | pub module_done: FT_Module_Destructor, 2377 | pub get_interface: FT_Module_Requester, 2378 | } 2379 | #[test] 2380 | fn bindgen_test_layout_FT_Module_Class_() { 2381 | assert_eq!(::std::mem::size_of::() , 72usize , concat ! 2382 | ( "Size of: " , stringify ! ( FT_Module_Class_ ) )); 2383 | assert_eq! (::std::mem::align_of::() , 8usize , concat ! 2384 | ( "Alignment of " , stringify ! ( FT_Module_Class_ ) )); 2385 | assert_eq! (unsafe { 2386 | & ( * ( 0 as * const FT_Module_Class_ ) ) . module_flags as * 2387 | const _ as usize } , 0usize , concat ! ( 2388 | "Alignment of field: " , stringify ! ( FT_Module_Class_ ) , 2389 | "::" , stringify ! ( module_flags ) )); 2390 | assert_eq! (unsafe { 2391 | & ( * ( 0 as * const FT_Module_Class_ ) ) . module_size as * 2392 | const _ as usize } , 8usize , concat ! ( 2393 | "Alignment of field: " , stringify ! ( FT_Module_Class_ ) , 2394 | "::" , stringify ! ( module_size ) )); 2395 | assert_eq! (unsafe { 2396 | & ( * ( 0 as * const FT_Module_Class_ ) ) . module_name as * 2397 | const _ as usize } , 16usize , concat ! ( 2398 | "Alignment of field: " , stringify ! ( FT_Module_Class_ ) , 2399 | "::" , stringify ! ( module_name ) )); 2400 | assert_eq! (unsafe { 2401 | & ( * ( 0 as * const FT_Module_Class_ ) ) . module_version as 2402 | * const _ as usize } , 24usize , concat ! ( 2403 | "Alignment of field: " , stringify ! ( FT_Module_Class_ ) , 2404 | "::" , stringify ! ( module_version ) )); 2405 | assert_eq! (unsafe { 2406 | & ( * ( 0 as * const FT_Module_Class_ ) ) . module_requires as 2407 | * const _ as usize } , 32usize , concat ! ( 2408 | "Alignment of field: " , stringify ! ( FT_Module_Class_ ) , 2409 | "::" , stringify ! ( module_requires ) )); 2410 | assert_eq! (unsafe { 2411 | & ( * ( 0 as * const FT_Module_Class_ ) ) . module_interface 2412 | as * const _ as usize } , 40usize , concat ! ( 2413 | "Alignment of field: " , stringify ! ( FT_Module_Class_ ) , 2414 | "::" , stringify ! ( module_interface ) )); 2415 | assert_eq! (unsafe { 2416 | & ( * ( 0 as * const FT_Module_Class_ ) ) . module_init as * 2417 | const _ as usize } , 48usize , concat ! ( 2418 | "Alignment of field: " , stringify ! ( FT_Module_Class_ ) , 2419 | "::" , stringify ! ( module_init ) )); 2420 | assert_eq! (unsafe { 2421 | & ( * ( 0 as * const FT_Module_Class_ ) ) . module_done as * 2422 | const _ as usize } , 56usize , concat ! ( 2423 | "Alignment of field: " , stringify ! ( FT_Module_Class_ ) , 2424 | "::" , stringify ! ( module_done ) )); 2425 | assert_eq! (unsafe { 2426 | & ( * ( 0 as * const FT_Module_Class_ ) ) . get_interface as * 2427 | const _ as usize } , 64usize , concat ! ( 2428 | "Alignment of field: " , stringify ! ( FT_Module_Class_ ) , 2429 | "::" , stringify ! ( get_interface ) )); 2430 | } 2431 | impl Clone for FT_Module_Class_ { 2432 | fn clone(&self) -> Self { *self } 2433 | } 2434 | pub type FT_Module_Class = FT_Module_Class_; 2435 | extern "C" { 2436 | pub fn FT_Add_Module(library: FT_Library, clazz: *const FT_Module_Class) 2437 | -> FT_Error; 2438 | } 2439 | extern "C" { 2440 | pub fn FT_Get_Module(library: FT_Library, 2441 | module_name: *const ::std::os::raw::c_char) 2442 | -> FT_Module; 2443 | } 2444 | extern "C" { 2445 | pub fn FT_Remove_Module(library: FT_Library, module: FT_Module) 2446 | -> FT_Error; 2447 | } 2448 | extern "C" { 2449 | pub fn FT_Property_Set(library: FT_Library, module_name: *const FT_String, 2450 | property_name: *const FT_String, 2451 | value: *const ::std::os::raw::c_void) -> FT_Error; 2452 | } 2453 | extern "C" { 2454 | pub fn FT_Property_Get(library: FT_Library, module_name: *const FT_String, 2455 | property_name: *const FT_String, 2456 | value: *mut ::std::os::raw::c_void) -> FT_Error; 2457 | } 2458 | extern "C" { 2459 | pub fn FT_Reference_Library(library: FT_Library) -> FT_Error; 2460 | } 2461 | extern "C" { 2462 | pub fn FT_New_Library(memory: FT_Memory, alibrary: *mut FT_Library) 2463 | -> FT_Error; 2464 | } 2465 | extern "C" { 2466 | pub fn FT_Done_Library(library: FT_Library) -> FT_Error; 2467 | } 2468 | pub type FT_DebugHook_Func = 2469 | ::std::option::Option; 2471 | extern "C" { 2472 | pub fn FT_Set_Debug_Hook(library: FT_Library, hook_index: FT_UInt, 2473 | debug_hook: FT_DebugHook_Func); 2474 | } 2475 | extern "C" { 2476 | pub fn FT_Add_Default_Modules(library: FT_Library); 2477 | } 2478 | #[repr(u32)] 2479 | #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] 2480 | pub enum FT_TrueTypeEngineType_ { 2481 | FT_TRUETYPE_ENGINE_TYPE_NONE = 0, 2482 | FT_TRUETYPE_ENGINE_TYPE_UNPATENTED = 1, 2483 | FT_TRUETYPE_ENGINE_TYPE_PATENTED = 2, 2484 | } 2485 | pub use self::FT_TrueTypeEngineType_ as FT_TrueTypeEngineType; 2486 | extern "C" { 2487 | pub fn FT_Get_TrueType_Engine_Type(library: FT_Library) 2488 | -> FT_TrueTypeEngineType; 2489 | } 2490 | extern "C" { 2491 | pub fn FT_Outline_Decompose(outline: *mut FT_Outline, 2492 | func_interface: *const FT_Outline_Funcs, 2493 | user: *mut ::std::os::raw::c_void) 2494 | -> FT_Error; 2495 | } 2496 | extern "C" { 2497 | pub fn FT_Outline_New(library: FT_Library, numPoints: FT_UInt, 2498 | numContours: FT_Int, anoutline: *mut FT_Outline) 2499 | -> FT_Error; 2500 | } 2501 | extern "C" { 2502 | pub fn FT_Outline_Done(library: FT_Library, outline: *mut FT_Outline) 2503 | -> FT_Error; 2504 | } 2505 | extern "C" { 2506 | pub fn FT_Outline_Check(outline: *mut FT_Outline) -> FT_Error; 2507 | } 2508 | extern "C" { 2509 | pub fn FT_Outline_Get_CBox(outline: *const FT_Outline, 2510 | acbox: *mut FT_BBox); 2511 | } 2512 | extern "C" { 2513 | pub fn FT_Outline_Translate(outline: *const FT_Outline, xOffset: FT_Pos, 2514 | yOffset: FT_Pos); 2515 | } 2516 | extern "C" { 2517 | pub fn FT_Outline_Copy(source: *const FT_Outline, target: *mut FT_Outline) 2518 | -> FT_Error; 2519 | } 2520 | extern "C" { 2521 | pub fn FT_Outline_Transform(outline: *const FT_Outline, 2522 | matrix: *const FT_Matrix); 2523 | } 2524 | extern "C" { 2525 | pub fn FT_Outline_Embolden(outline: *mut FT_Outline, strength: FT_Pos) 2526 | -> FT_Error; 2527 | } 2528 | extern "C" { 2529 | pub fn FT_Outline_EmboldenXY(outline: *mut FT_Outline, xstrength: FT_Pos, 2530 | ystrength: FT_Pos) -> FT_Error; 2531 | } 2532 | extern "C" { 2533 | pub fn FT_Outline_Reverse(outline: *mut FT_Outline); 2534 | } 2535 | extern "C" { 2536 | pub fn FT_Outline_Get_Bitmap(library: FT_Library, 2537 | outline: *mut FT_Outline, 2538 | abitmap: *const FT_Bitmap) -> FT_Error; 2539 | } 2540 | extern "C" { 2541 | pub fn FT_Outline_Render(library: FT_Library, outline: *mut FT_Outline, 2542 | params: *mut FT_Raster_Params) -> FT_Error; 2543 | } 2544 | pub const FT_Orientation__FT_ORIENTATION_FILL_RIGHT: FT_Orientation_ = 2545 | FT_Orientation_::FT_ORIENTATION_TRUETYPE; 2546 | pub const FT_Orientation__FT_ORIENTATION_FILL_LEFT: FT_Orientation_ = 2547 | FT_Orientation_::FT_ORIENTATION_POSTSCRIPT; 2548 | #[repr(u32)] 2549 | #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] 2550 | pub enum FT_Orientation_ { 2551 | FT_ORIENTATION_TRUETYPE = 0, 2552 | FT_ORIENTATION_POSTSCRIPT = 1, 2553 | FT_ORIENTATION_NONE = 2, 2554 | } 2555 | pub use self::FT_Orientation_ as FT_Orientation; 2556 | extern "C" { 2557 | pub fn FT_Outline_Get_Orientation(outline: *mut FT_Outline) 2558 | -> FT_Orientation; 2559 | } 2560 | -------------------------------------------------------------------------------- /src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright 2013 The Servo Project Developers. See the COPYRIGHT 2 | // file at the top-level directory of this distribution. 3 | // 4 | // Licensed under the Apache License, Version 2.0 or the MIT license 6 | // , at your 7 | // option. This file may not be copied, modified, or distributed 8 | // except according to those terms. 9 | 10 | #![crate_name = "freetype"] 11 | #![crate_type = "lib"] 12 | #![crate_type = "dylib"] 13 | #![crate_type = "rlib"] 14 | 15 | #![allow(non_snake_case)] 16 | #![allow(non_camel_case_types)] 17 | #![allow(non_upper_case_globals)] 18 | 19 | #[cfg(feature = "freetype-sys")] 20 | extern crate freetype_sys; 21 | extern crate libc; 22 | 23 | pub type FT_Error = ::std::os::raw::c_int; 24 | 25 | #[inline] 26 | pub fn succeeded(error: FT_Error) -> bool { 27 | error == freetype::FT_Err_Ok as FT_Error 28 | } 29 | 30 | #[deny(improper_ctypes)] 31 | pub mod freetype; 32 | pub mod tt_os2; 33 | -------------------------------------------------------------------------------- /src/tt_os2.rs: -------------------------------------------------------------------------------- 1 | // Copyright 2013 The Servo Project Developers. See the COPYRIGHT 2 | // file at the top-level directory of this distribution. 3 | // 4 | // Licensed under the Apache License, Version 2.0 or the MIT license 6 | // , at your 7 | // option. This file may not be copied, modified, or distributed 8 | // except according to those terms. 9 | 10 | use freetype::{FT_Char, FT_UShort, FT_Short, FT_ULong, FT_Byte}; 11 | 12 | #[repr(C)] 13 | pub struct TT_OS2 { 14 | pub version: FT_UShort, 15 | pub xAvgCharWidth: FT_Short, 16 | pub usWeightClass: FT_UShort, 17 | pub usWidthClass: FT_UShort, 18 | pub fsType: FT_Short, 19 | pub ySubscriptXSize: FT_Short, 20 | pub ySubscriptYSize: FT_Short, 21 | pub ySubscriptXOffset: FT_Short, 22 | pub ySubscriptYOffset: FT_Short, 23 | pub ySuperscriptXSize: FT_Short, 24 | pub ySuperscriptYSize: FT_Short, 25 | pub ySuperscriptXOffset: FT_Short, 26 | pub ySuperscriptYOffset: FT_Short, 27 | pub yStrikeoutSize: FT_Short, 28 | pub yStrikeoutPosition: FT_Short, 29 | pub sFamilyClass: FT_Short, 30 | 31 | pub panose: [FT_Byte; 10], 32 | 33 | pub ulUnicodeRange1: FT_ULong, /* Bits 0-31 */ 34 | pub ulUnicodeRange2: FT_ULong, /* Bits 32-63 */ 35 | pub ulUnicodeRange3: FT_ULong, /* Bits 64-95 */ 36 | pub ulUnicodeRange4: FT_ULong, /* Bits 96-127 */ 37 | 38 | pub achVendID: [FT_Char; 4], 39 | 40 | pub fsSelection: FT_UShort, 41 | pub usFirstCharIndex: FT_UShort, 42 | pub usLastCharIndex: FT_UShort, 43 | pub sTypoAscender: FT_Short, 44 | pub sTypoDescender: FT_Short, 45 | pub sTypoLineGap: FT_Short, 46 | pub usWinAscent: FT_UShort, 47 | pub usWinDescent: FT_UShort, 48 | 49 | /* only version 1 tables */ 50 | 51 | pub ulCodePageRange1: FT_ULong, /* Bits 0-31 */ 52 | pub ulCodePageRange2: FT_ULong, /* Bits 32-63 */ 53 | 54 | /* only version 2 tables */ 55 | 56 | pub sxHeight: FT_Short, 57 | pub sCapHeight: FT_Short, 58 | pub usDefaultChar: FT_UShort, 59 | pub usBreakChar: FT_UShort, 60 | pub usMaxContext: FT_UShort, 61 | } 62 | --------------------------------------------------------------------------------