Winresource

https://docs.rs/winresource
Admin
A Rust crate that provides a simple generator for Windows resource (.rc) files, enabling compilation...
Tokens:16,790
Snippets:210
Trust Score:9.1
Update:2 months ago
Show doc for...
Tokens:
Raw
### Set UI Language Example

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=

Example of setting the user interface language for the resource file.

```rust
extern crate windows;
    extern crate winresource;
    # use std::io;
    fn main() {
      if std::env::var("CARGO_CFG_TARGET_OS").unwrap() == "windows" {
        let primary = windows::Win32::System::SystemServices::LANG_ENGLISH;
```

--------------------------------

### LoadIconW usage examples

Source: https://docs.rs/winresource/latest/winresource/struct.WindowsResource.html?search=

Examples for loading icons at runtime based on whether the name ID is an integer or a string.

```rust
LoadIconW(h_instance, PWSTR::from_raw(name_id_as_integer as _))
```

```rust
LoadIconW(h_instance, name_id_as_wide_c_str_as_ptr)
```

--------------------------------

### Setting Version Info Flags

Source: https://docs.rs/winresource/latest/winresource/enum.VersionInfo.html

Example of combining multiple file flags using bitwise OR when setting version information.

```rust
res.set_version_info(VersionInfo::FILEFLAGS, VersionInfo::VS_FF_DEBUG | VersionInfo::VS_FF_PRERELEASE);
```

--------------------------------

### Cargo Metadata Configuration

Source: https://docs.rs/winresource/latest/winresource/struct.WindowsResource.html?search=

Example of configuring Windows resource metadata within the Cargo.toml file.

```toml
#Cargo.toml
[package.metadata.winresource]
OriginalFilename = "testing.exe"
FileDescription = "⛄❤☕"
LegalCopyright = "Copyright © 2016"
```

--------------------------------

### Discover Windows SDK via Registry

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=std%3A%3Avec

Queries the Windows registry to locate installed Windows Kits and verify the existence of rc.exe.

```rust
fn get_sdk() -> io::Result<Vec<PathBuf>> {
    let output = process::Command::new("reg")
        .arg("query")
        .arg(r"HKLM\SOFTWARE\Microsoft\Windows Kits\Installed Roots")
        .arg("/reg:32")
        .output()?;

    if !output.status.success() {
        return Err(io::Error::other(format!(
            "Querying the registry failed with error message:\n{}",
            String::from_utf8(output.stderr).map_err(|e| io::Error::other(e.to_string()))?
        )));
    }

    let lines = String::from_utf8(output.stdout).map_err(|e| io::Error::other(e.to_string()))?;
    let mut kits: Vec<PathBuf> = Vec::new();
    let mut lines: Vec<&str> = lines.lines().collect();
    lines.reverse();
    for line in lines {
        if line.trim().starts_with("KitsRoot") {
            let kit: String = line
                .chars()
                .skip(line.find("REG_SZ").unwrap() + 6)
                .skip_while(|c| c.is_whitespace())
                .collect();

            let p = PathBuf::from(&kit);
            let rc = if cfg!(target_arch = "x86_64") {
                p.join(r"bin\x64\rc.exe")
            } else {
                p.join(r"bin\x86\rc.exe")
            };

            if rc.exists() {
                println!("{:?}", rc);
                kits.push(rc.parent().unwrap().to_owned());
            }

            if let Ok(bin) = p.join("bin").read_dir() {
                for e in bin.filter_map(|e| e.ok()) {
                    let p = if cfg!(target_arch = "x86_64") {
                        e.path().join(r"x64\rc.exe")
                    } else {
                        e.path().join(r"x86\rc.exe")
                    };
                    if p.exists() {
                        println!("{:?}", p);
```

--------------------------------

### Append custom RC content

Source: https://docs.rs/winresource/latest/winresource/struct.WindowsResource.html?search=

Example of appending a menu resource definition to the generated RC file.

```rust
extern crate winresource;
    let mut res = winresource::WindowsResource::new();
    res.append_rc_content(r##"sample MENU
{
    MENUITEM "&Soup", 100
    MENUITEM "S&alad", 101
    POPUP "&Entree"
    {
         MENUITEM "&Fish", 200
         MENUITEM "&Chicken", 201, CHECKED
         POPUP "&Beef"
         {
              MENUITEM "&Steak", 301
              MENUITEM "&Prime Rib", 302
         }
    }
    MENUITEM "&Dessert", 103
}"##);
```

--------------------------------

### Set embedded manifest

Source: https://docs.rs/winresource/latest/winresource/struct.WindowsResource.html?search=

Example of setting an embedded manifest to request administrator privileges, triggering a UAC dialog.

```rust
if std::env::var("CARGO_CFG_TARGET_OS").unwrap_or("".to_string()) == "windows" {
let mut res = winresource::WindowsResource::new();
res.set_manifest(r#"
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
<trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
    <security>
        <requestedPrivileges>
            <requestedExecutionLevel level="requireAdministrator" uiAccess="false" />
        </requestedPrivileges>
    </security>
</trustInfo>
</assembly>
"#);
}
```

--------------------------------

### WindowsResource::new()

Source: https://docs.rs/winresource/latest/index.html

Initializes a new WindowsResource instance, attempting to guess default values from Cargo's build environment variables.

```APIDOC
## WindowsResource::new()

### Description
Creates a new instance of WindowsResource. It attempts to automatically populate default values based on the current Cargo build environment.

### Signature
`pub fn new() -> WindowsResource`
```

--------------------------------

### Initialize WindowsResource

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Implementation of the new() method for WindowsResource, which populates fields using environment variables and optional TOML parsing.

```rust
pub fn new() -> Self {
        let mut props: BTreeMap<String, String> = BTreeMap::new();
        let mut ver: BTreeMap<VersionInfo, u64> = BTreeMap::new();

        props.insert(
            "FileVersion".to_string(),
            env::var("CARGO_PKG_VERSION").unwrap(),
        );
        props.insert(
            "ProductVersion".to_string(),
            env::var("CARGO_PKG_VERSION").unwrap(),
        );
        props.insert(
            "ProductName".to_string(),
            env::var("CARGO_PKG_NAME").unwrap(),
        );

        // Note: It is not a mistake that we use the package name as `FileDescription`.
        // Windows uses the `FileDescription` as the application name in tools and dialogs.
        props.insert(
            "FileDescription".to_string(),
            env::var("CARGO_PKG_NAME").unwrap(),
        );

        #[cfg(feature = "toml")]
        parse_cargo_toml(&mut props).unwrap();

        let mut version = 0_u64;
        version |= env::var("CARGO_PKG_VERSION_MAJOR")
            .unwrap()
            .parse()
            .unwrap_or(0)
            << 48;
        version |= env::var("CARGO_PKG_VERSION_MINOR")
            .unwrap()
            .parse()
            .unwrap_or(0)
            << 32;
        version |= env::var("CARGO_PKG_VERSION_PATCH")
            .unwrap()
            .parse()
            .unwrap_or(0)
            << 16;
        // version |= env::var("CARGO_PKG_VERSION_PRE").unwrap().parse().unwrap_or(0);
        ver.insert(VersionInfo::FILEVERSION, version);
        ver.insert(VersionInfo::PRODUCTVERSION, version);
        ver.insert(VersionInfo::FILEOS, 0x00040004);
        ver.insert(VersionInfo::FILETYPE, 1);
        ver.insert(VersionInfo::FILESUBTYPE, 0);
        ver.insert(VersionInfo::FILEFLAGSMASK, 0x3F);
        ver.insert(VersionInfo::FILEFLAGS, 0);

        let sdk = if cfg!(all(windows, target_env = "msvc")) {
            match get_sdk() {
                Ok(mut v) => v.pop().unwrap(),
                Err(_) => PathBuf::new(),
            }
        } else if cfg!(windows) {
            PathBuf::from("\")
        } else {
            PathBuf::from("/")
        };

```

--------------------------------

### Configure Windows Kit Include Path

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=

Sets the include path for the Windows 8.1 SDK.

```rust
974            r"C:\Program Files (x86)\Windows Kits\8.1\Include"
975        );
976    }
977}
```

--------------------------------

### Configure multiple icons

Source: https://docs.rs/winresource/latest/winresource/struct.WindowsResource.html?search=

Recommended approach for setting multiple icons, using 16-bit integer IDs and setting the application icon first.

```rust
res.set_icon("icon.ico") // This is application icon.
   .set_icon_with_id("icon2.icon", "2")
   .set_icon_with_id("icon3.icon", "3")
   // ...
```

--------------------------------

### Configure and compile Windows resources in build.rs

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=

Use this pattern within a build script to set resource properties like icons and version info before compiling. Ensure the target OS is Windows before executing.

```rust
if std::env::var("CARGO_CFG_TARGET_OS").unwrap() == "windows" {
    let mut res = winresource::WindowsResource::new();
    res.set_icon("test.ico")
#      .set_output_directory(".")
       .set("InternalName", "TEST.EXE")
       // manually set version 1.0.0.0
       .set_version_info(winresource::VersionInfo::PRODUCTVERSION, 0x0001000000000000);
    res.compile()?;
}
```

--------------------------------

### WindowsResource::compile()

Source: https://docs.rs/winresource/latest/index.html

Compiles the configured resource file and instructs Cargo to link the output.

```APIDOC
## WindowsResource::compile()

### Description
Compiles the Windows resource file (.rc) and directs Cargo to link the resulting output. This method is intended to be called within a build script.

### Signature
`pub fn compile(&self) -> io::Result<()>`
```

--------------------------------

### Configure Windows Resource Path

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html

Sets the include path for Windows resource compilation.

```rust
            r"C:\Program Files (x86)\Windows Kits\8.1\Include"
        );
    }
}
```

--------------------------------

### Configure Windows Resource Properties

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=

Sets string properties for the version information struct, such as FileVersion or CompanyName.

```rust
pub fn set(&mut self, name: &str, value: &str) -> &mut Self {
        self.properties.insert(name.to_string(), value.to_string());
        self
    }
```

--------------------------------

### Configure WindowsResource Toolchain and Properties

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=std%3A%3Avec

Initializes the WindowsResource struct with environment-aware toolchain paths for windres and ar, and default property values.

```rust
        let prefix = if let Ok(cross) = env::var("CROSS_COMPILE") {
            cross
        } else if env::var_os("HOST").unwrap() != env::var_os("TARGET").unwrap()
            && cfg!(not(all(windows, target_env = "msvc")))
        // use mingw32 under linux
        {
            match env::var("TARGET").unwrap().as_str() {
                "x86_64-pc-windows-msvc" | // use mingw32 under linux
                "x86_64-pc-windows-gnu" => "x86_64-w64-mingw32-",
                "i686-pc-windows-msvc" | // use mingw32 under linux
                "i686-pc-windows-gnu" => "i686-w64-mingw32-",
                "i586-pc-windows-msvc" | // use mingw32 under linux
                "i586-pc-windows-gnu" => "i586-w64-mingw32-",
                // MinGW supports ARM64 only with an LLVM-based toolchain
                // (x86 users might also be using LLVM, but we can't tell that from the Rust target...)
                "aarch64-pc-windows-gnu" => "llvm-",
                // *-gnullvm targets by definition use LLVM-based toolchains
                "x86_64-pc-windows-gnullvm"
                | "i686-pc-windows-gnullvm"
                | "aarch64-pc-windows-gnullvm" => "llvm-",
                // fail safe
                target => {
                    println!(
                        "cargo:warning=unknown Windows target {target} used for cross-compilation; \
                              invoking unprefixed windres"
                    );
                    ""
                }
            }
            .into()
        } else {
            "".into()
        };
        let windres_path = if let Ok(windres) = env::var("WINDRES") {
            windres
        } else {
            format!("{}windres", prefix)
        };
        let ar_path = if let Ok(ar) = env::var("AR") {
            ar
        } else {
            format!("{}ar", prefix)
        };

        WindowsResource {
            toolkit_path: sdk,
            properties: props,
            version_info: ver,
            rc_file: None,
            icons: Vec::new(),
            language: 0,
            manifest: None,
            manifest_file: None,
            output_directory: env::var("OUT_DIR").unwrap_or_else(|_| ".".to_string()),
            windres_path,
            ar_path,
            add_toolkit_include: false,
            append_rc_content: String::new(),
        }
    }
```

--------------------------------

### WindowsResource::set()

Source: https://docs.rs/winresource/latest/index.html

Sets a specific version info field.

```APIDOC
## WindowsResource::set()

### Description
Sets a specific key-value pair for the resource version information.

### Parameters
- **key** (&str) - Required - The field name (e.g., "InternalName").
- **value** (&str) - Required - The value to assign to the field.
```

--------------------------------

### Compiling Windows Resources in a Build Script

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=std%3A%3Avec

Use this pattern within a build.rs file to compile Windows resources. Ensure the target OS is Windows before executing the compilation.

```rust
if std::env::var("CARGO_CFG_TARGET_OS").unwrap() == "windows" {
    let mut res = winresource::WindowsResource::new();
    res.set_icon("test.ico")
#      .set_output_directory(".")
        .set("InternalName", "TEST.EXE")
        // manually set version 1.0.0.0
        .set_version_info(winresource::VersionInfo::PRODUCTVERSION, 0x0001000000000000);
    res.compile()?;
}
```

--------------------------------

### Determine Windows SDK Include Root

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=

Calculates the path to the Windows SDK Include directory based on the location of the rc.exe binary.

```rust
#[allow(dead_code)]
fn win_sdk_include_root(path: &Path) -> PathBuf {
    let mut tools_path = PathBuf::new();
    let mut iter = path.iter();
    while let Some(p) = iter.next() {
        if p == "bin" {
            let version = iter.next().unwrap();
            tools_path.push("Include");
            if version.to_string_lossy().starts_with("10.") {
                tools_path.push(version);
            }
            break;
        } else {
            tools_path.push(p);
        }
    }

    tools_path
}
```

--------------------------------

### compile

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=

Executes the resource compiler to generate and link the resource file.

```APIDOC
## pub fn compile(&self) -> io::Result<()>

### Description
Runs the resource compiler. This function generates a resource file from the current settings or uses an existing one, compiles it using the toolkit's compiler, and prints the necessary cargo instructions to link the resulting library.
```

--------------------------------

### Set Toolkit Path

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=std%3A%3Avec

Configures the path to the resource compiler toolkit, such as MinGW or the Windows SDK.

```rust
    pub fn set_toolkit_path(&mut self, path: &str) -> &mut Self {
        self.toolkit_path = PathBuf::from(path);
        self
    }
```

--------------------------------

### WindowsResource::set_version_info()

Source: https://docs.rs/winresource/latest/winresource/index.html?search=

Sets version information for the resource.

```APIDOC
## WindowsResource::set_version_info()

### Description
Sets specific version information fields using the VersionInfo enum.

### Signature
`pub fn set_version_info(&mut self, field: VersionInfo, value: u64) -> &mut Self`
```

--------------------------------

### set

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=

Sets string properties for the version information structure, such as FileVersion, CompanyName, or LegalCopyright.

```APIDOC
## pub fn set(&mut self, name: &str, value: &str) -> &mut Self

### Description
Sets a string property in the version info struct. Common fields include "FileVersion", "FileDescription", "ProductVersion", "ProductName", "OriginalFilename", "LegalCopyright", "LegalTrademark", "CompanyName", "Comments", and "InternalName".

### Parameters
- **name** (&str) - The key of the property to set.
- **value** (&str) - The value to assign to the property.
```

--------------------------------

### Unit Tests for Utilities

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=

Test cases for string escaping and SDK path resolution logic.

```rust
#[cfg(test)]
mod tests {
    use super::escape_string;
    use super::win_sdk_include_root;

    #[test]
    fn string_escaping() {
        assert_eq!(&escape_string(""), "");
        assert_eq!(&escape_string("foo"), "foo");
        assert_eq!(&escape_string(r#""Hello""#), r#"""Hello"""#);
        assert_eq!(
            &escape_string(r"C:\Program Files\Foobar"),
            r"C:\\Program Files\\Foobar"
        );
    }

    #[test]
    #[cfg_attr(not(target_os = "windows"), ignore)]
    fn toolkit_include_win10() {
        use std::path::Path;

        let res = win_sdk_include_root(Path::new(
            r"C:\Program Files (x86)\Windows Kits\10\bin\10.0.17763.0\x64\rc.exe",
        ));

        assert_eq!(
            res.as_os_str(),
            r"C:\Program Files (x86)\Windows Kits\10\Include\10.0.17763.0"
        );
    }

    #[test]
    #[cfg_attr(not(target_os = "windows"), ignore)]
    fn toolkit_include_win8() {
        use std::path::Path;

        let res = win_sdk_include_root(Path::new(
            r"C:\Program Files (x86)\Windows Kits\8.1\bin\x86\rc.exe",
        ));
        assert_eq!(
            res.as_os_str(),
```

--------------------------------

### Compile Windows Resource in build.rs

Source: https://docs.rs/winresource/latest/index.html

Use this snippet within a build script to conditionally compile a Windows resource file when targeting Windows.

```rust
if std::env::var("CARGO_CFG_TARGET_OS").unwrap() == "windows" {
    let mut res = winresource::WindowsResource::new();
    res.set_icon("test.ico")
       .set("InternalName", "TEST.EXE")
       // manually set version 1.0.0.0
       .set_version_info(winresource::VersionInfo::PRODUCTVERSION, 0x0001000000000000);
    res.compile()?;
}
```

--------------------------------

### Compile Resource File with MSVC Toolkit

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=std%3A%3Avec

Compiles a resource file using the MSVC rc.exe tool, handling path resolution and toolkit-specific include directories.

```rust
fn compile_with_toolkit_msvc(&self, input: &str, output_dir: &str) -> io::Result<()> {
        let rc_exe = if let Some(rc_path) = std::env::var_os("RC_PATH") {
            PathBuf::from(rc_path)
        } else if cfg!(unix) {
            PathBuf::from("llvm-rc")
        } else {
            let rc_exe = PathBuf::from(&self.toolkit_path).join("rc.exe");
            if !rc_exe.exists() {
                if cfg!(target_arch = "x86_64") {
                    PathBuf::from(&self.toolkit_path).join(r"bin\x64\rc.exe")
                } else {
                    PathBuf::from(&self.toolkit_path).join(r"bin\x86\rc.exe")
                }
            } else {
                rc_exe
            }
        };

        println!("Selected RC path: '{}'", rc_exe.display());
        let output = PathBuf::from(output_dir).join("resource.res");
        let input = PathBuf::from(input);
        let mut command = process::Command::new(&rc_exe);
        let command = command.arg(format!("/I{}", env::var("CARGO_MANIFEST_DIR").unwrap()));

        if self.add_toolkit_include {
            let root = win_sdk_include_root(&rc_exe);
            println!("Adding toolkit include: {}", root.display());
            command.arg(format!("/I{}", root.join("um").display()));
            command.arg(format!("/I{}", root.join("shared").display()));
        }

        command.arg(format!("/fo{}", output.display()));

        if cfg!(unix) {
            // Fix for https://github.com/llvm/llvm-project/issues/63426
            command.args(["/C", "65001"]);

            // Ensure paths starting with "/Users" on macOS are not interpreted as a /U option
            command.arg("--");
        }

        let status = command.arg(format!("{}", input.display())).output()?;

        println!(
            "RC Output:\n{}\n------",
            String::from_utf8_lossy(&status.stdout)
        );
        println!(
            "RC Error:\n{}\n------",
            String::from_utf8_lossy(&status.stderr)
        );
        if !status.status.success() {
            return Err(io::Error::other("Could not compile resource file"));
        }

        println!("cargo:rustc-link-arg={}", output.display());

        Ok(())
    }
```

--------------------------------

### Set Toolkit Path

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=

Configures the path for the GNU or MSVC toolkit. If left unset, it attempts to locate the path via the Windows registry.

```rust
pub fn set_toolkit_path(&mut self, path: &str) -> &mut Self {
        self.toolkit_path = PathBuf::from(path);
        self
    }
```

--------------------------------

### set_manifest

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=

Sets the application manifest content directly as a string.

```APIDOC
## set_manifest(manifest: &str) -> &mut Self

### Description
Sets the manifest content for the Windows resource. This will clear any previously set manifest file path.

### Parameters
- **manifest** (&str) - Required - The XML manifest content as a string.
```

--------------------------------

### compile

Source: https://docs.rs/winresource/latest/winresource/struct.WindowsResource.html?search=

Executes the resource compiler to generate the final resource file.

```APIDOC
## pub fn compile(&self) -> Result<()>

### Description
Runs the resource compiler using the current configuration. It also outputs the necessary cargo instructions for linking the compiled resource file.
```

--------------------------------

### Set UI Language

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=std%3A%3Avec

Sets the user interface language for the resource file.

```rust
    /// # Example
    ///
    /// ```no_run
    /// extern crate windows;
    /// extern crate winresource;
    /// # use std::io;
    /// fn main() {
    ///   if std::env::var("CARGO_CFG_TARGET_OS").unwrap() == "windows" {
    ///     let primary = windows::Win32::System::SystemServices::LANG_ENGLISH;
```

--------------------------------

### Parse Cargo.toml Metadata

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=

Reads the [package.metadata.winresource] section from Cargo.toml and populates a BTreeMap with the configuration values.

```rust
#[cfg(feature = "toml")]
fn parse_cargo_toml(props: &mut BTreeMap<String, String>) -> io::Result<()> {
    let cargo = Path::new(&env::var("CARGO_MANIFEST_DIR").unwrap()).join("Cargo.toml");
    let mut f = fs::File::open(cargo)?;
    let mut cargo_toml = String::new();
    f.read_to_string(&mut cargo_toml)?;
    if let Ok(ml) = cargo_toml.parse::<toml::Table>() {
        if let Some(pkg) = ml.get("package") {
            if let Some(pkg) = pkg.get("metadata") {
                if let Some(pkg) = pkg.get("winresource") {
                    if let Some(pkg) = pkg.as_table() {
                        for (k, v) in pkg {
                            // println!("{} {}", k ,v);
                            if let Some(v) = v.as_str() {
                                props.insert(k.clone(), v.to_string());
                            } else {
                                println!("cargo::warning=package.metadata.winresource.{} is not a string", k);
                            }
                        }
                    } else {
                        println!("cargo::warning=package.metadata.winresource is not a table");
                    }
                } else {
                    // It is optional to specify the `[package.metadata.winresource]` section in Cargo.toml; do nothing
                    // println!("cargo::warning=Section `[package.metadata.winresource]` not found in Cargo.toml");
                }
            } else {
                // It is optional to specify the `[package.metadata]` section in Cargo.toml; do nothing
                // println!("cargo::warning=Section `[package.metadata]` not found in Cargo.toml");
            }
        } else {
            // We expect that if `Cargo.toml` exists, it must contain a `[package]` section
            println!("cargo::warning=Section `[package]` not found in Cargo.toml");
        }
    } else {
        println!("cargo::warning=TOML parsing error in Cargo.toml")
    }
    Ok(())
}
```

--------------------------------

### set_manifest_file

Source: https://docs.rs/winresource/latest/winresource/struct.WindowsResource.html

Sets the manifest file by providing a path to an external file.

```APIDOC
## pub fn set_manifest_file(&mut self, file: &str) -> &mut Self

### Description
Sets the embedded manifest file using a filename; the file is included by the resource compiler.
```

--------------------------------

### add_toolkit_include

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=

Toggles the inclusion of toolkit headers.

```APIDOC
## add_toolkit_include(add: bool) -> &mut Self

### Description
Sets whether to include toolkit headers during resource compilation.

### Parameters
- **add** (bool) - Required - Boolean flag to enable or disable toolkit inclusion.
```

--------------------------------

### Set Language for Windows Resource

Source: https://docs.rs/winresource/latest/winresource/struct.WindowsResource.html?search=

Configures the user interface language for the resource file using language and sublanguage constants.

```rust
extern crate windows;
extern crate winresource;
fn main() {
  if std::env::var("CARGO_CFG_TARGET_OS").unwrap() == "windows" {
    let primary = windows::Win32::System::SystemServices::LANG_ENGLISH;
    let secondary = windows::Win32::System::SystemServices::SUBLANG_ENGLISH_US;
    let lang_id = ((secondary as u16) << 10) | (primary as u16);

    let mut res = winresource::WindowsResource::new();
    res.set_output_directory(".");
    res.set_language(lang_id);
    res.compile().unwrap();
  }
}
```

--------------------------------

### WindowsResource::set_toolkit_path

Source: https://docs.rs/winresource/latest/winresource/struct.WindowsResource.html?search=u32+-%3E+bool

Configures the path for the resource compiler toolkit (GNU or MSVC).

```APIDOC
## pub fn set_toolkit_path(&mut self, path: &str) -> &mut Self

### Description
Sets the correct path for the toolkit. For GNU, this is the directory containing windres.exe and ar.exe. For MSVC, this is the root directory of the Windows SDK or the specific bin directory.

### Parameters
- **path** (str) - The file system path to the toolkit.
```

--------------------------------

### WindowsResource Struct Definition

Source: https://docs.rs/winresource/latest/winresource/struct.WindowsResource.html?search=

The internal structure definition for WindowsResource.

```rust
pub struct WindowsResource { /* private fields */ }
```

--------------------------------

### WindowsResource::set()

Source: https://docs.rs/winresource/latest/winresource/index.html?search=

Sets a specific resource property value.

```APIDOC
## WindowsResource::set()

### Description
Sets a key-value pair for the resource file, such as 'InternalName'.

### Signature
`pub fn set(&mut self, key: &str, value: &str) -> &mut Self`
```

--------------------------------

### Set Version Info Properties

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=std%3A%3Avec

Updates the version information fields for the resource file, such as FileVersion or CompanyName.

```rust
    pub fn set(&mut self, name: &str, value: &str) -> &mut Self {
        self.properties.insert(name.to_string(), value.to_string());
        self
    }
```

--------------------------------

### WindowsResource::set_icon()

Source: https://docs.rs/winresource/latest/index.html

Sets the icon file path for the resource.

```APIDOC
## WindowsResource::set_icon()

### Description
Sets the path to the icon file to be included in the resource.

### Parameters
- **path** (AsRef<Path>) - Required - The path to the .ico file.
```

--------------------------------

### add_toolkit_include

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=u32+-%3E+bool

Configures whether to include the toolkit in the resource compilation.

```APIDOC
## add_toolkit_include(&mut self, add: bool) -> &mut Self

### Description
Sets whether the toolkit should be included during resource compilation.

### Parameters
- **add** (bool) - Boolean flag to enable or disable toolkit inclusion.
```

--------------------------------

### set_toolkit_path

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=

Configures the path to the Windows toolkit (MinGW or Windows SDK) used for resource compilation.

```APIDOC
## pub fn set_toolkit_path(&mut self, path: &str) -> &mut Self

### Description
Sets the path for the toolkit. For GNU, this is the directory containing windres.exe and ar.exe. For MSVC, this is the root or bin directory of the Windows SDK. If unset, the library attempts to look up the path in the Windows registry.

### Parameters
- **path** (&str) - The filesystem path to the toolkit directory.
```

--------------------------------

### WindowsResource::set_version_info

Source: https://docs.rs/winresource/latest/winresource/index.html

Sets a numeric version information field using the VersionInfo enum.

```APIDOC
## WindowsResource::set_version_info(field: winresource::VersionInfo, value: u64)

### Description
Sets a numeric version information field, such as PRODUCTVERSION, using the provided VersionInfo enum variant.

### Parameters
- **field** (winresource::VersionInfo) - Required - The version info field to set.
- **value** (u64) - Required - The numeric value for the version field.
```

--------------------------------

### set_icon

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=u32+-%3E+bool

Adds an icon with the default name ID '1'. The icon must be in .ico format.

```APIDOC
## fn set_icon(&mut self, path: &str) -> &mut Self

### Description
Adds an icon with the default name ID '1'. The path can be absolute or relative to the project root.

### Parameters
- **path** (&str) - Required - The file path to the .ico file.
```

--------------------------------

### set_ar_path

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=

Configures the path to the ar executable.

```APIDOC
## set_ar_path(path: &str) -> &mut Self

### Description
Sets the path to the ar executable.

### Parameters
- **path** (&str) - Required - The filesystem path to the ar executable.
```

--------------------------------

### set_toolkit_path

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html

Configures the path to the Windows toolkit (GNU or MSVC) used for resource compilation.

```APIDOC
## pub fn set_toolkit_path(&mut self, path: &str) -> &mut Self

### Description
Sets the directory path for the toolkit. For GNU, this is the directory containing windres.exe and ar.exe. For MSVC, this is the root or bin directory of the Windows SDK containing rc.exe. If left unset, the library attempts to locate the path via the Windows registry.

### Parameters
- **path** (&str) - The filesystem path to the toolkit directory.
```

--------------------------------

### set_manifest

Source: https://docs.rs/winresource/latest/winresource/struct.WindowsResource.html?search=

Embeds a manifest file into the resource configuration.

```APIDOC
## pub fn set_manifest(&mut self, manifest: &str) -> &mut Self

### Description
Sets the embedded manifest file content directly as a string.
```

--------------------------------

### write_resource_file

Source: https://docs.rs/winresource/latest/winresource/struct.WindowsResource.html

Writes the configured resource values to a file.

```APIDOC
## pub fn write_resource_file<P: AsRef<Path>>(&self, path: P) -> Result<()>

### Description
Writes a resource file with the currently set values to the specified path.
```

--------------------------------

### set_icon

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=

Adds an icon to the resource file with the default ID '1'.

```APIDOC
## pub fn set_icon(&mut self, path: &str) -> &mut Self

### Description
Adds an icon in .ico format to the resource file. This method assigns the icon the default name ID '1'.

### Parameters
- **path** (&str) - Required - The file path to the .ico file, either absolute or relative to the project root.
```

--------------------------------

### VersionInfo Constants

Source: https://docs.rs/winresource/latest/winresource/enum.VersionInfo.html?search=u32+-%3E+bool

Constants used with VersionInfo::FILEFLAGS to define file characteristics.

```APIDOC
## VersionInfo Constants

### Description
Constants representing VS_FF_* values from the Windows SDK, used to configure file flags.

### Constants
- **VS_FF_DEBUG** (u64): 0x01 - File contains debugging information.
- **VS_FF_PRERELEASE** (u64): 0x02 - File is a development version.
- **VS_FF_PATCHED** (u64): 0x04 - File has been modified.
- **VS_FF_PRIVATEBUILD** (u64): 0x08 - File was not built using standard procedures.
- **VS_FF_INFOINFERRED** (u64): 0x10 - Version structure was created dynamically.
- **VS_FF_SPECIALBUILD** (u64): 0x20 - File is a variation of the normal file.
```

--------------------------------

### set_version_info

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=

Sets a numeric property in the version information structure.

```APIDOC
## pub fn set_version_info(&mut self, field: VersionInfo, value: u64) -> &mut Self

### Description
Sets a specific numeric property within the version information struct.

### Parameters
- **field** (VersionInfo) - Required - The version info field to set.
- **value** (u64) - Required - The numeric value to assign to the field.
```

--------------------------------

### WindowsResource::set_language

Source: https://docs.rs/winresource/latest/winresource/struct.WindowsResource.html?search=u32+-%3E+bool

Sets the user interface language for the resource file.

```APIDOC
## pub fn set_language(&mut self, language: u16) -> &mut Self

### Description
Sets the user interface language of the file using a numeric language ID.

### Parameters
- **language** (u16) - The numeric language constant (e.g., 0x0409 for English US).
```

--------------------------------

### set_resource_file

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=

Sets a path to an existing resource file to be used instead of generating one.

```APIDOC
## set_resource_file(path: &str) -> &mut Self

### Description
Specifies an existing resource file to be passed to the compiler, bypassing the internal generation process.

### Parameters
- **path** (&str) - Required - The path to the existing resource file.
```

--------------------------------

### set_icon_with_id

Source: https://docs.rs/winresource/latest/winresource/struct.WindowsResource.html?search=

Adds an icon in .ico format with a specified name ID to the resource configuration.

```APIDOC
## pub fn set_icon_with_id(&mut self, path: &str, name_id: &str) -> &mut Self

### Description
Adds an icon with the specified name ID. The icon must be in .ico format, and the path can be absolute or relative to the project root.

### Parameters
- **path** (&str) - Required - Path to the .ico file.
- **name_id** (&str) - Required - The string representation of a 16-bit unsigned integer or a custom string identifier.
```

--------------------------------

### set_windres_path

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=

Configures the path to the windres executable.

```APIDOC
## set_windres_path(path: &str) -> &mut Self

### Description
Sets the path to the windres executable used for compiling resources.

### Parameters
- **path** (&str) - Required - The filesystem path to the windres executable.
```

--------------------------------

### set_language

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=

Sets the language for the resource file using a 16-bit language identifier.

```APIDOC
## pub fn set_language(&mut self, language: u16) -> &mut Self

### Description
Sets the language for the resource file. The language identifier is a 16-bit value typically composed of a primary language ID and a sublanguage ID.

### Parameters
- **language** (u16) - Required - The numeric language identifier.
```

--------------------------------

### set_output_directory

Source: https://docs.rs/winresource/latest/src/winresource/lib.rs.html?search=

Overrides the default output directory for the compiled resource files.

```APIDOC
## pub fn set_output_directory(&mut self, path: &str) -> &mut Self

### Description
Overrides the output directory. As a default, the library uses %OUT_DIR% set by cargo, but this method allows users to specify a custom path.

### Parameters
- **path** (&str) - Required - The directory path to use for output files.
```
Tokens:
Raw