From 313733b728093908e722391cbcdf7684bfa18bd2 Mon Sep 17 00:00:00 2001
From: Rob Greene <robgreene@gmail.com>
Date: Tue, 3 Nov 2020 10:51:12 -0600
Subject: [PATCH] now detecting and setting writeable flag based on how a
 resource was opened

---
 apple2Setup.go        |  2 +-
 base64a.go            |  2 +-
 cardBase.go           |  2 +-
 characterGenerator.go |  2 +-
 storage/diskette.go   |  6 ++++--
 storage/resources.go  | 28 +++++++++++++++++-----------
 6 files changed, 25 insertions(+), 17 deletions(-)

diff --git a/apple2Setup.go b/apple2Setup.go
index 1b1e2c6..9375dd2 100644
--- a/apple2Setup.go
+++ b/apple2Setup.go
@@ -72,7 +72,7 @@ const (
 
 // LoadRom loads a standard Apple2+ or 2e ROM
 func (a *Apple2) LoadRom(filename string) error {
-	data, err := storage.LoadResource(filename)
+	data, _, err := storage.LoadResource(filename)
 	if err != nil {
 		return err
 	}
diff --git a/base64a.go b/base64a.go
index be237fc..685ee7a 100644
--- a/base64a.go
+++ b/base64a.go
@@ -36,7 +36,7 @@ func loadBase64aRom(a *Apple2) error {
 
 	for i := 0; i < base64aRomChipCount; i++ {
 		filename := fmt.Sprintf("<internal>/BASE64A_%X.BIN", 0xd0+i*0x08)
-		data, err := storage.LoadResource(filename)
+		data, _, err := storage.LoadResource(filename)
 		if err != nil {
 			return err
 		}
diff --git a/cardBase.go b/cardBase.go
index 85b5054..4dd6842 100644
--- a/cardBase.go
+++ b/cardBase.go
@@ -39,7 +39,7 @@ func (c *cardBase) reset() {
 }
 
 func (c *cardBase) loadRomFromResource(resource string) {
-	data, err := storage.LoadResource(resource)
+	data, _, err := storage.LoadResource(resource)
 	if err != nil {
 		// The resource should be internal and never fail
 		panic(err)
diff --git a/characterGenerator.go b/characterGenerator.go
index c579456..1122803 100644
--- a/characterGenerator.go
+++ b/characterGenerator.go
@@ -45,7 +45,7 @@ func newCharacterGenerator(filename string, order charColumnMap) (*CharacterGene
 }
 
 func (cg *CharacterGenerator) load(filename string) error {
-	bytes, err := storage.LoadResource(filename)
+	bytes, _, err := storage.LoadResource(filename)
 	if err != nil {
 		return err
 	}
diff --git a/storage/diskette.go b/storage/diskette.go
index 5c40af7..30a9169 100644
--- a/storage/diskette.go
+++ b/storage/diskette.go
@@ -14,7 +14,7 @@ type Diskette interface {
 
 // IsDiskette returns true if the files looks like a 5 1/4 diskette
 func IsDiskette(filename string) bool {
-	data, err := LoadResource(filename)
+	data, _, err := LoadResource(filename)
 	if err != nil {
 		return false
 	}
@@ -24,7 +24,7 @@ func IsDiskette(filename string) bool {
 
 // LoadDiskette returns a Diskette by detecting the format
 func LoadDiskette(filename string) (Diskette, error) {
-	data, err := LoadResource(filename)
+	data, writeable, err := LoadResource(filename)
 	if err != nil {
 		return nil, err
 	}
@@ -32,12 +32,14 @@ func LoadDiskette(filename string) (Diskette, error) {
 	if isFileNib(data) {
 		var d diskette16sector
 		d.nib = newFileNib(data)
+		d.nib.supportsWrite = d.nib.supportsWrite && writeable
 		return &d, nil
 	}
 
 	if isFileDsk(data) {
 		var d diskette16sectorWritable
 		d.nib = newFileDsk(data, filename)
+		d.nib.supportsWrite = d.nib.supportsWrite && writeable
 		return &d, nil
 	}
 
diff --git a/storage/resources.go b/storage/resources.go
index 8bb0d4f..5cfb874 100644
--- a/storage/resources.go
+++ b/storage/resources.go
@@ -29,66 +29,72 @@ func isHTTPResource(filename string) bool {
 }
 
 // LoadResource loads in memory a file from the filesystem, http or embedded
-func LoadResource(filename string) ([]uint8, error) {
+func LoadResource(filename string) ([]uint8, bool, error) {
+	var writeable bool
 	var file io.Reader
 	if isInternalResource(filename) {
 		// load from embedded resource
 		resource := strings.TrimPrefix(filename, internalPrefix)
 		resourceFile, err := romdumps.Assets.Open(resource)
 		if err != nil {
-			return nil, err
+			return nil, false, err
 		}
 		defer resourceFile.Close()
 		file = resourceFile
+		writeable = false
 
 	} else if isHTTPResource(filename) {
 		response, err := http.Get(filename)
 		if err != nil {
-			return nil, err
+			return nil, false, err
 		}
 		defer response.Body.Close()
 		file = response.Body
+		writeable = false
 
 	} else {
 		diskFile, err := os.Open(filename)
 		if err != nil {
-			return nil, err
+			return nil, false, err
 		}
 		defer diskFile.Close()
 		file = diskFile
+		writeable = true
 	}
 
 	data, err := ioutil.ReadAll(file)
 	if err != nil {
-		return nil, err
+		return nil, false, err
 	}
 
 	contentType := http.DetectContentType(data)
 	if contentType == "application/x-gzip" {
+		writeable = false
 		gz, err := gzip.NewReader(bytes.NewReader(data))
 		if err != nil {
-			return nil, err
+			return nil, false, err
 		}
 		defer gz.Close()
 		data, err = ioutil.ReadAll(gz)
 		if err != nil {
-			return nil, err
+			return nil, false, err
 		}
 
 	} else if contentType == "application/zip" {
+		writeable = false
 		z, err := zip.NewReader(bytes.NewReader(data), int64(len(data)))
 		if err != nil {
-			return nil, err
+			return nil, false, err
 		}
 		for _, zf := range z.File {
 			f, err := zf.Open()
 			if err != nil {
-				return nil, err
+				return nil, false, err
 			}
 			defer f.Close()
 			bytes, err := ioutil.ReadAll(f)
 			if err != nil {
-				return nil, err
+				return nil, false, err
 			}
 			if isFileDsk(bytes) || isFileNib(bytes) || isFileWoz(bytes) {
 				data = bytes
@@ -97,5 +103,5 @@ func LoadResource(filename string) ([]uint8, error) {
 		}
 	}
 
-	return data, nil
+	return data, writeable, nil
 }