warp/apps/desktop/build/windows/mkico.go

//go:build ignore

// Command mkico writes the Windows icon: the small sizes from the brand
// favicon (the symbol's small cut, drawn for 16–48 px) and the large sizes
// from the app icon tile. Both inputs are .ico files whose images are PNGs.
//
//	go run build/windows/mkico.go -small favicon.ico -large tile.ico -out icon.ico
package main

import (
	"bytes"
	"encoding/binary"
	"flag"
	"fmt"
	"os"
	"sort"
)

type image struct {
	size int // pixels; 256 is stored as 0 in the directory
	data []byte
}

func main() {
	small := flag.String("small", "", ".ico with the images below -split px")
	large := flag.String("large", "", ".ico with the images from -split px up")
	split := flag.Int("split", 64, "the first size taken from -large")
	out := flag.String("out", "", "output .ico")
	flag.Parse()

	var images []image
	for _, in := range []struct {
		path string
		keep func(int) bool
	}{
		{*small, func(s int) bool { return s < *split }},
		{*large, func(s int) bool { return s >= *split }},
	} {
		all, err := read(in.path)
		if err != nil {
			fail(err)
		}
		for _, im := range all {
			if in.keep(im.size) {
				images = append(images, im)
			}
		}
	}
	sort.Slice(images, func(i, j int) bool { return images[i].size > images[j].size })
	if err := os.WriteFile(*out, write(images), 0o644); err != nil {
		fail(err)
	}
}

func read(path string) ([]image, error) {
	b, err := os.ReadFile(path)
	if err != nil {
		return nil, err
	}
	if len(b) < 6 || binary.LittleEndian.Uint16(b[2:]) != 1 {
		return nil, fmt.Errorf("%s: not an .ico file", path)
	}
	n := int(binary.LittleEndian.Uint16(b[4:]))
	var images []image
	for i := 0; i < n; i++ {
		e := b[6+16*i:]
		size := int(e[0])
		if size == 0 {
			size = 256
		}
		length := binary.LittleEndian.Uint32(e[8:])
		offset := binary.LittleEndian.Uint32(e[12:])
		data := b[offset : offset+length]
		if !bytes.HasPrefix(data, []byte("\x89PNG")) {
			return nil, fmt.Errorf("%s: the %d px image is not a PNG", path, size)
		}
		images = append(images, image{size, data})
	}
	return images, nil
}

func write(images []image) []byte {
	var b bytes.Buffer
	le := binary.LittleEndian
	binary.Write(&b, le, [3]uint16{0, 1, uint16(len(images))})
	offset := 6 + 16*len(images)
	for _, im := range images {
		dim := byte(im.size)
		if im.size >= 256 {
			dim = 0
		}
		binary.Write(&b, le, struct {
			W, H, Colors, Reserved byte
			Planes, BitCount       uint16
			Length, Offset         uint32
		}{dim, dim, 0, 0, 1, 32, uint32(len(im.data)), uint32(offset)})
		offset += len(im.data)
	}
	for _, im := range images {
		b.Write(im.data)
	}
	return b.Bytes()
}

func fail(err error) {
	fmt.Fprintln(os.Stderr, "mkico:", err)
	os.Exit(1)
}