Apabila kita menggunakan komputer setiap hari, kita selalunya perlu membuka beberapa program yang biasa digunakan. Program ini akan memaparkan ikon tertentu pada antara muka kami supaya kami dapat mengenal pasti dan mencarinya dengan cepat. Tetapi dalam beberapa kes, kami mungkin ingin menukar ikon program ini, seperti menjadikannya lebih konsisten dengan pilihan atau tema peribadi kami.
Dalam artikel ini, kami akan memberi tumpuan kepada cara menggunakan golang dan beberapa perpustakaan sistem untuk menukar ikon program. Kami akan menggunakan Windows sebagai persekitaran demonstrasi kami.
Mula-mula, mari kita gariskan langkah asas yang perlu kita ambil:
Seterusnya, kita akan membincangkan cara melengkapkan langkah ini satu demi satu.
Langkah satu: Buka fail sumber dan cari sumber ikon
Dalam golang, kita boleh menggunakan fungsi dalam pustaka sistem "syscall" untuk membuka dan membaca fail. Untuk melakukan ini, kita perlu menentukan beberapa pembolehubah yang diperlukan:
package main
import (
"os"
"syscall"
"unsafe"
)
var (
kernel32DLL = syscall.MustLoadDLL("kernel32.dll")
BeginUpdateResourceProc = kernel32DLL.MustFindProc("BeginUpdateResourceW")
UpdateResourceProc = kernel32DLL.MustFindProc("UpdateResourceW")
EndUpdateResourceProc = kernel32DLL.MustFindProc("EndUpdateResourceW")
)Kami menggunakan beberapa fungsi dalam Windows API di sini, iaitu "BeginUpdateResourceW", "UpdateResourceW" dan "EndUpdateResourceW". Fungsi ini boleh membantu kami mengendalikan sumber dalam fail sumber program.
Seterusnya, kita perlu membuka fail sumber program yang ingin kita ubah (boleh menjadi fail .exe atau .dll) dan mencari sumber ikonnya. Di sini kami menggunakan fungsi yang dipanggil "findIconIndex" untuk melintasi fail sumber program dan mencari nombor indeks di mana sumber ikonnya berada.
func findIconIndex(exePath string) (int, error) {
exeFile, err := os.OpenFile(exePath, os.O_RDWR, 0666)
defer exeFile.Close()
if err != nil {
return 0, err
}
exeStat, err := exeFile.Stat()
if err != nil {
return 0, err
}
exeSize := exeStat.Size()
// DOS header
dosHeader := new(image.DosHeader)
err = binary.Read(exeFile, binary.LittleEndian, dosHeader)
if err != nil {
return 0, err
}
exeFile.Seek(int64(dosHeader.Lfanew), 0)
// File header and optional header
fileHeader := new(image.FileHeader)
err = binary.Read(exeFile, binary.LittleEndian, fileHeader)
if err != nil {
return 0, err
}
extHeader := make([]byte, fileHeader.SizeOfOptionalHeader-2)
exeFile.Read(extHeader)
// Section headers
sections := make([]image.SectionHeader, fileHeader.NumberOfSections)
err = binary.Read(exeFile, binary.LittleEndian, sections)
if err != nil {
return 0, err
}
// Find icon resource
for _, section := range sections {
if section.Name == ".rsrc" {
exeFile.Seek(int64(section.Offset), 0)
resourceHeader := new(resourceHeader)
err = binary.Read(exeFile, binary.LittleEndian, resourceHeader)
if err != nil {
return 0, err
}
stack := []resourceDirectoryEntry{resourceDirectoryEntry{uint32(resourceHeader.RootID), int64(resourceHeader.OffsetToDirectory)}}
for len(stack) > 0 {
currentEntry := stack[len(stack)-1]
stack = stack[:len(stack)-1]
exeFile.Seek(currentEntry.offset, 0)
directoryHeader := new(resourceDirectoryHeader)
err = binary.Read(exeFile, binary.LittleEndian, directoryHeader)
if err != nil {
return 0, err
}
entries := make([]resourceDirectoryEntry, directoryHeader.NumNamedEntries+directoryHeader.NumIDEntries)
for i := range entries {
err = binary.Read(exeFile, binary.LittleEndian, &entries[i])
if err != nil {
return 0, err
}
if entries[i].nameIsString {
nameBytes := make([]byte, entries[i].nameOffset&0x7FFFFFFF)
exeFile.Read(nameBytes)
entries[i].name = syscall.UTF16ToString(nameBytes)
}
}
for _, entry := range entries {
if entry.ID&^0xFFFF == rtIcon {
return int(entry.ID & 0xFFFF), nil
} else if entry.name == "ICON" {
stack = append(stack, resourceDirectoryEntry{entry.ID, int64(entry.offset)})
} else if entry.name == "#0" && entry.ID&^0xFFFF == rtGroupIcon {
groupIconDirHeader := new(resourceGroupIconDirectoryHeader)
exeFile.Seek(int64(entry.offset), 0)
err = binary.Read(exeFile, binary.LittleEndian, groupIconDirHeader)
if err != nil {
return 0, err
}
var largestIcon resourceGroupIconDirectoryEntry
for i := 0; i < int(groupIconDirHeader.Count); i++ {
groupIconDirEntry := new(resourceGroupIconDirectoryEntry)
err = binary.Read(exeFile, binary.LittleEndian, groupIconDirEntry)
if err != nil {
return 0, err
}
if groupIconDirEntry.Width > largestIcon.Width || groupIconDirEntry.Height > largestIcon.Height {
largestIcon = *groupIconDirEntry
}
}
return int(largestIcon.ID), nil
} else if entry.name == "ICONGROUP" {
stack = append(stack, resourceDirectoryEntry{entry.ID, int64(entry.offset)})
} else if entry.name == "MAINICON" {
stack = append(stack, resourceDirectoryEntry{entry.ID, int64(entry.offset)})
} else {
stack = append(stack, resourceDirectoryEntry{entry.ID, int64(entry.offset)})
}
}
}
return 0, fmt.Errorf("Icon not found")
}
}
return 0, fmt.Errorf("Resource not found")
}Fungsi ini berulang melalui setiap bahagian (.rsrc) dalam fail sumber program dan mencari indeks sumber ikon. Biasanya, pengindeksan bergantung pada saiz dan format sumber ikon. Kami boleh memutuskan mengikut budi bicara kami sendiri indeks sumber ikon yang akan ditukar dalam fail sumber.
Langkah 2: Tambahkan sumber ikon baharu pada fail sumber
Untuk menambah sumber ikon baharu pada fail sumber program, kita perlu menyimpannya dalam format fail ICO terlebih dahulu. Kita boleh menggunakan perpustakaan imej dalam golang untuk mencipta fail ICO.
package main
import (
"image"
"image/draw"
"image/png"
"os"
)
func writeIcoFile(icon image.Image, filename string) error {
file, err := os.Create(filename)
if err != nil {
return err
}
defer file.Close()
// Create icon file header
iconSize := icon.Bounds().Size()
fileHeader := new(resourceIconFileHeader)
fileHeader.Reserved = 0
fileHeader.Type = 1
fileHeader.Count = 1
// Create icon directory entry
dirEntry := new(resourceIconDirectoryEntry)
dirEntry.Width = uint8(iconSize.X)
dirEntry.Height = uint8(iconSize.Y)
dirEntry.Colors = 0
dirEntry.Reserved = 0
dirEntry.Plane = 1
dirEntry.BitCount = 32
dirEntry.SizeInBytes = uint32(40 + 4*iconSize.X*iconSize.Y)
dirEntry.Offset = 22
// Create bitmap info header and color mask for bitmap graphics
colorMask := [12]byte{0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00}
infoHeader := new(bitmapInfoHeader)
infoHeader.Size = 40
infoHeader.Width = int32(iconSize.X)
infoHeader.Height = int32(2 * iconSize.Y)
infoHeader.Planes = 1
infoHeader.BitCount = 32
infoHeader.Compression = 0
infoHeader.SizeImage = uint32(4 * iconSize.X * iconSize.Y)
infoHeader.XPelsPerMeter = 0
infoHeader.YPelsPerMeter = 0
infoHeader.ClrUsed = 0
infoHeader.ClrImportant = 0
// Write icon file header, directory entry, bitmap info header and color mask
binary.Write(file, binary.LittleEndian, fileHeader)
binary.Write(file, binary.LittleEndian, dirEntry)
binary.Write(file, binary.LittleEndian, infoHeader)
binary.Write(file, binary.LittleEndian, colorMask)
// Write bitmap graphics
rgba := image.NewRGBA(image.Rect(0, 0, iconSize.X, 2*iconSize.Y))
draw.Draw(rgba, rgba.Bounds(), image.Black, image.ZP, draw.Src)
draw.Draw(rgba, image.Rect(0, 0, iconSize.X, iconSize.Y), icon, image.ZP, draw.Over)
draw.Draw(rgba, image.Rect(0, iconSize.Y, iconSize.X, 2*iconSize.Y), image.Transparent, image.ZP, draw.Src)
err = png.Encode(file, rgba)
if err != nil {
return err
}
return nil
}Fungsi ini mencipta pengepala fail ICO dan melampirkan sumber ikon padanya. Pengepala fail ICO mengandungi maklumat yang diperlukan tentang sumber ikon dalam fail ICO.
Seterusnya, kami menulisnya ke dalam fail sumber. Kita perlu menggunakan fungsi "BeginUpdateResource", "UpdateResource" dan "EndUpdateResource" dalam API Windows untuk melakukan ini.
func updateIcon(exePath, icoPath string, iconIndex int) error {
exeFile, err := os.OpenFile(exePath, os.O_RDWR, 0666)
defer exeFile.Close()
if err != nil {
return err
}
icoFile, err := os.Open(icoPath)
defer icoFile.Close()
if err != nil {
return err
}
// Read ICO file and prepare icon directory entry
icoData, err := ioutil.ReadAll(icoFile)
if err != nil {
return err
}
dirEntry := new(resourceIconDirectoryEntry)
dirEntry.Width = 0
dirEntry.Height = 0
dirEntry.Colors = 0
dirEntry.Reserved = 0
dirEntry.Plane = 1
dirEntry.BitCount = 0
dirEntry.SizeInBytes = uint32(len(icoData))
dirEntry.Offset = 22
// Find update handle
exeHandle, err := syscall.CreateFile(syscall.StringToUTF16Ptr(exePath), syscall.GENERIC_READ|syscall.GENERIC_WRITE, 0, nil, syscall.OPEN_EXISTING, syscall.FILE_ATTRIBUTE_NORMAL, 0)
if err != nil {
return err
}
defer syscall.CloseHandle(exeHandle)
updateHandle, _, err := BeginUpdateResourceProc.Call(uintptr(exeHandle), 0)
defer syscall.CloseHandle(syscall.Handle(updateHandle))
if updateHandle == 0 {
return fmt.Errorf("BeginUpdateResourceW failed")
}
// Write resource to update handle
success, _, err := UpdateResourceProc.Call(uintptr(updateHandle), uintptr(rtIcon), uintptr(iconIndex), 0, uintptr(unsafe.Pointer(&icoData[0])), uintptr(len(icoData)))
if success == 0 {
return fmt.Errorf("UpdateResourceW failed")
}
// Write updated icon directory entry
success, _, err = UpdateResourceProc.Call(uintptr(updateHandle), uintptr(rtGroupIcon), uintptr(MAKEINTRESOURCE(iconIndex)), 0, uintptr(unsafe.Pointer(dirEntry)), uintptr(unsafe.Sizeof(*dirEntry)))
if success == 0 {
return fmt.Errorf("UpdateResourceW failed")
}
// Commit update handle
success, _, err = EndUpdateResourceProc.Call(updateHandle, 0)
if success == 0 {
return fmt.Errorf("EndUpdateResourceW failed")
}
return nil
}Langkah 3: Tukar fail .manifest program
Kita perlu menukar fail .manifest program supaya ia boleh mengakses sumber ikon baharu. Untuk melakukan ini, kita perlu menambah yang berikut pada fail .manifest:
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0"> <assemblyIdentity type="win32" name="MyApplication" version="1.0.0.0" processorArchitecture="x86" /> <icon type="group">MyIconResourceIndex</icon> </assembly>
Ini akan memberikan nombor indeks sumber ikon kepada program supaya ia boleh menggunakan sumber ikon baharu. Kita boleh menggunakan perpustakaan os dalam golang untuk menukar fail .manifest.
func updateManifest(manifestPath string, iconIndex int) error {
manifestData, err := ioutil.ReadFile(manifestPath)
if err != nil {
return err
}
updatedManifest := strings.Replace(string(manifestData), "</assembly>", " <icon type="group">"+strconv.Itoa(iconIndex)+"</icon>
</assembly>", 1)
err = ioutil.WriteFile(manifestPath, []byte(updatedManifest), 0666)
if err != nil {
return err
}
return nil
}Kini, kami tahu cara menggunakan golang dan perpustakaan sistem untuk menukar ikon program. Dengan menggabungkan langkah-langkah ini, kami membina ciri yang lengkap. Berikut ialah kod contoh:
package main
import (
"encoding/binary"
"encoding/hex"
"fmt"
"image"
"image/png"
"io/ioutil"
"os"
"strconv"
"strings"
"syscall"
"unsafe"
)
const (
rtIcon = 14
rtGroupIcon = rtIcon + 11
LOAD_LIBRARY_AS_IMAGE_RESOURCE = 0x00000020
)
// Resource header
type resourceHeader struct {
RootID uint16
RootType uint16
RootName [16]uint16
RootDataSize uint32
RootDataVer uint32
RootDate uint32
RootRMLow uint16
RootRMHigh uint16
RootLangID uint16
RootDataVerOS uint32
}
// Resource directory header
type resourceDirectoryHeader struct {
Characteristics uint32
TimeDateStamp uint32
VersionMajor uint16
VersionMinor uint16
NumNamedEntries uint16
NumIDEntries uint16
}
// Resource directory entry
type resourceDirectoryEntry struct {
nameIsString bool
ID uint32
offset uint32
nameOffset uint32
name string
}
// Resource icon file header
type resourceIconFileHeader struct {
Reserved uint16
Type uint16
Count uint16
}
// Resource icon directory entry
type resourceIconDirectoryEntry struct {
Width uint8
Height uint8
Colors uint8
Reserved uint8
Plane uint16
BitCount uint16
SizeInBytes uint32
Offset uint32
}
// Resource group icon directory header
type resourceGroupIconDirectoryHeader struct {
Width uint16
Height uint16
ColorCount uint16
Reserved uint16
Planes uint16
BitCount uint16
Count uint32
}
// Resource group icon directory entry
type resourceGroupIconDirectoryEntry struct {
Width uint8
Height uint8
ColorCount uint8
Reserved uint8
Planes uint16
BitCount uint16
BytesInRes uint32
ID uint16
}
// Bitmap header
type bitmapInfoHeader struct {
Size uint32
Width int32
Height int32
Planes uint16
BitCount uint16
Compression uint32
SizeImage uint32
XPelsPerMeter int32
YPelsPerMeter int32
ClrUsed uint32
ClrImportant uint32
}
var (
kernel32DLL = syscall.MustLoadDLL("kernel32.dll")
user32DLL = syscall.MustLoadDLL("user32.dll")
autoDetectEncodingProc = kernel32DLL.MustFindProc("AutoDetectEncoding")
BeginUpdateResourceProc = kernel32DLL.MustFindProc("BeginUpdateResourceW")
LoadImageProc = user32DLL.MustFindProc("LoadImageW")
ResourceNotFound = fmt.Errorf("Resource not found")
NoIconFound = fmt.Errorf("Icon not found")
)
func main() {
exePath := "path/to/program.exe"
icoPath := "path/to/newicon.png"
manifestPath := "path/to/program.exe.manifest"
iconIndex, err := findIconIndex(exePath)Atas ialah kandungan terperinci Pengubahsuaian ikon program Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
Bagaimana untuk mengikat data dalam senarai lungsur
Apakah yang perlu saya lakukan jika akaun QQ saya dicuri?
Apa itu dompet Bitcoin
Bagaimana untuk memuat turun video dari Douyin
Cara membuat html dengan webstorm
Penggunaan biasa Array.slice
Bagaimana untuk mendaftar nama domain laman web kekal
Harga USDT hari ini
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
