Add initial support for Tahoe.

Author: lgarron

README.md

@@ -159,6 +159,9 @@ Options:
       --macOS <MACOS_VERSION>
           Version of the macOS folder icon, e.g. "14.2.1". Defaults to the version currently running
 
+      --empty-folder
+          Render the folder as empty
+
       --color-scheme <COLOR_SCHEME>
           Color scheme — auto matches the current system value
           

src/icon_conversion.rs

@@ -41,9 +41,9 @@ use crate::{
     },
     error::{FolderifyError, GeneralError},
     magick::{density, BlurDown, CommandArgs, CompositingOperation},
-    options::{Badge, ColorScheme, Options, SetIconUsing},
+    options::{Badge, ColorScheme, FolderStyle, Options, SetIconUsing},
     primitives::{Dimensions, Extent, Offset, RGBColor},
-    resources::{get_badge_icon, get_folder_icon},
+    resources::{get_badge_icon, get_folder_icon, IconInputs},
 };
 
 pub struct ScaledMaskInputs {
@@ -264,11 +264,6 @@ pub struct IconConversion {
     pub progress_bar: Option<ProgressBar>,
 }
 
-pub struct IconInputs {
-    pub color_scheme: ColorScheme,
-    pub resolution: IconResolution,
-}
-
 impl IconConversion {
     pub fn step_unincremented(&self, step_description: &str) {
         if let Some(progress_bar) = &self.progress_bar {
@@ -490,14 +485,14 @@ impl IconConversion {
         options: &Options,
         full_mask_path: &Path,
         output_path: &Path,
-        inputs: &IconInputs,
+        icon_inputs: &IconInputs,
     ) -> Result<(), FolderifyError> {
         // if options.verbose {
         //     println!("[Starting] {}", inputs.resolution);
         // }
 
-        let size = inputs.resolution.size();
-        let offset_y = inputs.resolution.offset_y();
+        let size = icon_inputs.resolution.size();
+        let offset_y = icon_inputs.resolution.offset_y();
 
         self.step_unincremented("Sizing mask");
         let sized_mask_path = self
@@ -515,11 +510,12 @@ impl IconConversion {
             .unwrap();
 
         // TODO
-        let template_icon = get_folder_icon(inputs.color_scheme, &inputs.resolution);
+        let template_icon = get_folder_icon(icon_inputs);
 
-        let fill_color = match inputs.color_scheme {
-            ColorScheme::Light => RGBColor::new(8, 134, 206),
-            ColorScheme::Dark => RGBColor::new(6, 111, 194),
+        let fill_color = match (icon_inputs.folder_style, icon_inputs.color_scheme) {
+            (FolderStyle::Tahoe, _) => RGBColor::new(74, 141, 172),
+            (_, ColorScheme::Light) => RGBColor::new(8, 134, 206),
+            (_, ColorScheme::Dark) => RGBColor::new(6, 111, 194),
         };
 
         let engraved = self.engrave(
@@ -539,20 +535,24 @@ impl IconConversion {
                 },
                 bottom_bezel: BezelInputs {
                     color: RGBColor::new(174, 225, 253),
-                    blur: inputs.resolution.bottom_bezel_blur_down(),
+                    blur: icon_inputs.resolution.bottom_bezel_blur_down(),
                     mask_operation: CompositingOperation::Dst_Out,
-                    opacity: inputs.resolution.bottom_bezel_alpha(),
+                    opacity: icon_inputs.resolution.bottom_bezel_alpha(),
                 },
             },
         );
         if let Some(badge) = options.badge {
-            self.badge_in_place(output_path, badge, &inputs.resolution)?;
+            self.badge_in_place(output_path, badge, &icon_inputs.resolution)?;
         };
 
         self.step("");
 
         if options.verbose {
-            println!("[{}] {}", options.mask_path.display(), inputs.resolution);
+            println!(
+                "[{}] {}",
+                options.mask_path.display(),
+                icon_inputs.resolution
+            );
         }
         engraved
     }

src/main.rs

@@ -1,11 +1,11 @@
 use std::thread::{self, JoinHandle};
 
 use command::{run_command, OPEN_COMMAND};
-use icon_conversion::{IconInputs, IconResolution, WorkingDir};
+use icon_conversion::{IconResolution, WorkingDir};
 use indicatif::MultiProgress;
 use magick::CommandArgs;
 
-use crate::{output_paths::PotentialOutputPaths, primitives::Dimensions};
+use crate::{output_paths::PotentialOutputPaths, primitives::Dimensions, resources::IconInputs};
 
 mod command;
 mod error;
@@ -22,8 +22,9 @@ fn main() {
     let potential_output_paths = PotentialOutputPaths::new(&options);
 
     println!(
-        "[{}] Using folder style: BigSur",
-        options.mask_path.display()
+        "[{}] Using folder style: {}",
+        options.mask_path.display(),
+        options.folder_style
     );
     println!(
         "[{}] Using color scheme: {}",
@@ -77,8 +78,10 @@ fn main() {
                     &full_mask_path,
                     &output_path,
                     &IconInputs {
+                        folder_style: options.folder_style,
                         color_scheme: options.color_scheme,
                         resolution,
+                        empty_folder: options.empty_folder,
                     },
                 )
                 .unwrap();

src/options.rs

@@ -3,6 +3,7 @@ use clap_complete::generator::generate;
 use clap_complete::{Generator, Shell};
 use std::io::stdout;
 use std::process::exit;
+use std::str::from_utf8;
 use std::{env::var, fmt::Display, path::PathBuf, process::Command};
 
 /// Generate a native-style macOS folder icon from a mask file.
@@ -47,6 +48,10 @@ struct FolderifyArgs {
     #[clap(long = "macOS", alias = "osx", short_alias = 'x', id = "MACOS_VERSION")]
     mac_os: Option<String>, // TODO: enum, default?
 
+    /// Render the folder as empty.
+    #[clap(long, default_value_t = false)]
+    empty_folder: bool,
+
     /// Color scheme — auto matches the current system value.
     #[clap(long, value_enum, default_value_t = ColorSchemeOrAuto::Auto)]
     color_scheme: ColorSchemeOrAuto,
@@ -136,6 +141,8 @@ pub struct Options {
     pub color_scheme: ColorScheme,
     pub no_trim: bool,
     pub target: Option<PathBuf>,
+    pub folder_style: FolderStyle,
+    pub empty_folder: bool,
     pub output_icns: Option<PathBuf>,
     pub output_iconset: Option<PathBuf>,
     pub set_icon_using: SetIconUsing,
@@ -150,17 +157,41 @@ fn completions_for_shell(cmd: &mut clap::Command, generator: impl Generator) {
     generate(generator, cmd, "folderify", &mut stdout());
 }
 
-fn known_mac_os_version(mac_os: &str) -> bool {
-    for major_version_string in ["15", "14", "13", "12", "11"] {
+fn is_major_macos_version_one_of(mac_os: &str, versions: &[&str]) -> bool {
+    for major_version_string in versions {
         if mac_os.starts_with(&format!("{}.", major_version_string))
-            || mac_os == major_version_string
+            || mac_os == *major_version_string
         {
             return true;
         }
     }
     false
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum FolderStyle {
+    BigSur,
+    Tahoe,
+}
+
+impl Display for FolderStyle {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            FolderStyle::BigSur => write!(f, "Big Sur"),
+            FolderStyle::Tahoe => write!(f, "Tahoe"),
+        }
+    }
+}
+
+impl FolderStyle {
+    pub fn dark_mode_and_light_mode_are_identical(&self) -> bool {
+        match self {
+            FolderStyle::BigSur => false,
+            FolderStyle::Tahoe => true,
+        }
+    }
+}
+
 pub fn get_options() -> Options {
     let mut command = FolderifyArgs::command();
 
@@ -178,8 +209,12 @@ pub fn get_options() -> Options {
         }
     };
 
-    if let Some(mac_os) = &args.mac_os {
-        let mac_os: &str = mac_os;
+    let folder_style = {
+        let mac_os: String = args
+            .mac_os
+            .map(|s| s.to_owned())
+            .unwrap_or_else(current_macOS_version);
+        let mac_os = mac_os.as_str();
         // macOS 11.0 reports itself as macOS 10.16 in some APIs. Someone might pass such a value on to `folderify`, so we can't just check for major version 10.
         // Instead, we denylist the versions that previously had different folder icons, so that we don't accidentally apply the Big Sur style when one of these versions was specified.
         if matches!(
@@ -199,10 +234,21 @@ pub fn get_options() -> Options {
             eprintln!("Error: OS X / macOS 10 was specified. This is no longer supported by folderify v3.\nTo generate these icons, please use folderify v2: https://github.com/lgarron/folderify/tree/main#os-x-macos-10");
             exit(1)
         }
-        if !known_mac_os_version(mac_os) {
-            eprintln!("Warning: Unknown macOS version specified. Assuming macOS 11 or later");
+        if is_major_macos_version_one_of(mac_os, &["15", "14", "13", "12", "11"]) {
+            FolderStyle::BigSur
+        } else if is_major_macos_version_one_of(
+            mac_os,
+            &["26"], // Note: macOS 16 through 25 do not exist.
+        ) {
+            eprintln!("Warning: macOS Tahoe is still in beta. The icon may not match the final macOS 26 release.");
+            FolderStyle::Tahoe
+        } else {
+            eprintln!(
+                "Warning: Unknown macOS version specified. Assuming Big Sur (macOS 11 through 15)."
+            );
+            FolderStyle::BigSur
         }
-    }
+    };
     let debug = var("FOLDERIFY_DEBUG") == Ok("1".into());
     let verbose = args.verbose || debug;
     let show_progress = !args.no_progress && !args.verbose;
@@ -213,9 +259,11 @@ pub fn get_options() -> Options {
     };
     Options {
         mask_path: mask,
-        color_scheme: map_color_scheme_auto(args.color_scheme),
+        color_scheme: map_color_scheme_auto(args.color_scheme, folder_style),
         no_trim: args.no_trim,
         target: args.target,
+        folder_style,
+        empty_folder: args.empty_folder,
         output_icns: args.output_icns,
         output_iconset: args.output_iconset,
         badge: args.badge,
@@ -227,7 +275,20 @@ pub fn get_options() -> Options {
     }
 }
 
-fn map_color_scheme_auto(color_scheme: ColorSchemeOrAuto) -> ColorScheme {
+fn map_color_scheme_auto(
+    color_scheme: ColorSchemeOrAuto,
+    folder_style: FolderStyle,
+) -> ColorScheme {
+    if folder_style.dark_mode_and_light_mode_are_identical() {
+        match color_scheme {
+            ColorSchemeOrAuto::Auto => {}
+            _ => {
+                eprintln!("Dark and light mode folder icons are identical for the folder style of this macOS version. Ignoring the `--color-scheme` argument.");
+            }
+        }
+        return ColorScheme::Light;
+    }
+
     match color_scheme {
         ColorSchemeOrAuto::Dark => return ColorScheme::Dark,
         ColorSchemeOrAuto::Light => return ColorScheme::Light,
@@ -251,3 +312,18 @@ fn map_color_scheme_auto(color_scheme: ColorSchemeOrAuto) -> ColorScheme {
         }
     }
 }
+
+const DEFAULT_MACOS_VERSION: &str = "15.0";
+
+#[allow(non_snake_case)]
+fn current_macOS_version() -> String {
+    let Ok(o) = Command::new("sw_vers").args(["-productVersion"]).output() else {
+        return DEFAULT_MACOS_VERSION.to_owned();
+    };
+
+    let Ok(stdout) = from_utf8(&o.stdout) else {
+        return DEFAULT_MACOS_VERSION.to_owned();
+    };
+
+    stdout.to_owned()
+}

src/resources.rs

@@ -4,19 +4,34 @@ use include_dir::{include_dir, Dir};
 
 use crate::{
     icon_conversion::IconResolution,
-    options::{Badge, ColorScheme},
+    options::{Badge, ColorScheme, FolderStyle},
 };
 
 static RESOURCES_DIR: Dir<'_> = include_dir!("$CARGO_MANIFEST_DIR/src/resources");
 
-pub fn get_folder_icon(color_scheme: ColorScheme, resolution: &IconResolution) -> &'static [u8] {
+pub struct IconInputs {
+    pub folder_style: FolderStyle,
+    pub color_scheme: ColorScheme,
+    pub resolution: IconResolution,
+    pub empty_folder: bool,
+}
+
+pub fn get_folder_icon(icon_inputs: &IconInputs) -> &'static [u8] {
     let mut path = PathBuf::new();
     path.push("folders");
-    path.push(match color_scheme {
-        ColorScheme::Light => "GenericFolderIcon.BigSur.iconset",
-        ColorScheme::Dark => "GenericFolderIcon.BigSur.dark.iconset",
-    });
-    path.push(resolution.icon_file());
+    path.push(
+        match (
+            icon_inputs.color_scheme,
+            icon_inputs.folder_style,
+            icon_inputs.empty_folder,
+        ) {
+            (ColorScheme::Light, FolderStyle::BigSur, _) => "GenericFolderIcon.BigSur.iconset",
+            (ColorScheme::Dark, FolderStyle::BigSur, _) => "GenericFolderIcon.BigSur.dark.iconset",
+            (_, FolderStyle::Tahoe, true) => "GenericFolderIcon.empty.Tahoe.iconset",
+            (_, FolderStyle::Tahoe, false) => "GenericFolderIcon.non-empty.Tahoe.iconset",
+        },
+    );
+    path.push(icon_inputs.resolution.icon_file());
     RESOURCES_DIR.get_file(&path).unwrap().contents()
 }