Added more unit tests, enabled mouse support for input fields, and modified bulk loading of images.

Author: supercom32

constants/constants.go

@@ -118,6 +118,7 @@ const FrameStyleNormal = 0
 const FrameStyleRaised = 1
 const FrameStyleSunken = 2
 const CellTypeButton = 1
+const CellTypeTextInput = 2
 
 const VirtualFileSystemZip = 1
 const VirtualFileSystemRar = 2

debug.go

@@ -18,6 +18,17 @@ func dumpScreenToFile() {
 	dumpLayerToFile(commonResource.screenLayer)
 }
 
+/*
+DumpScreenToTerminal allows you to dump the current visible screen layer to the
+terminal. In addition, the following information should be noted:
+
+- This is a method just for internal testing and normally is not used unless
+required for debugging.
+*/
+func dumpScreenToTerminal() {
+	log.Println(commonResource.screenLayer.GetBasicAnsiStringAsBase64())
+}
+
 /*
 DumpLayerToFile allows you to dump a display layer to files on a disk. One
 file is a limited ansi representation of the screen layer. The other is
@@ -49,4 +60,4 @@ func printDebugLog(fileName string, textToPrint string) {
 	if _, err := f.WriteString(textToPrint + "\n"); err != nil {
 		log.Println(err)
 	}
-}
+}

debug_test.go

@@ -19,7 +19,7 @@ func TestPrintDebugLog(test *testing.T) {
 	assert.NoErrorf(test, err, "Failed to delete the file '%s': ", fileName)
 }
 
-func TestDumpScreenToFile(test *testing.T) {
+func TestDumpScreen(test *testing.T) {
 	commonResource.isDebugEnabled = true
 	layerAlias1 := "Layer1"
 	layerWidth := 100

image.go

@@ -73,7 +73,13 @@ and further loading will stop.
 func LoadImagesInBulk(assetList memory.AssetListType) error {
 	var err error
 	for _, currentAsset := range assetList.ImageList {
-		err = LoadImage(currentAsset.FileAlias, currentAsset.FileAlias)
+		err = LoadImage(currentAsset.FileName, currentAsset.FileAlias)
+		if err != nil {
+			return err
+		}
+	}
+	for _, currentAsset := range assetList.PreloadedImageList {
+		err = LoadPreRenderedImage(currentAsset.FileName, currentAsset.FileAlias, currentAsset.WidthInCharacters, currentAsset.HeightInCharacters, currentAsset.BlurSigma)
 		if err != nil {
 			return err
 		}
@@ -123,41 +129,6 @@ func LoadPreRenderedImage(imageFile string, imageAlias string, widthInCharacters
 	return err
 }
 
-/*
-LoadPreRenderedImagesInBulk allows you to load multiple pre-rendered images
-into memory at once. This is useful since it eliminates the need for error
-checking over each image as they are loaded. An example use of this method
-is as follows:
-
-	// Create a new asset list.
-	assetList := dosktop.NewAssetList()
-	// Add a pre-rendered image to our asset list, with a filename of
-	// 'MyImageFile', an image alias of 'MyImageAlias', a size in
-	// characters of 20x20, and a blur sigma of 0.5.
-	assetList.AddImage("MyImageFile", "MyImageAlias", 20, 20, 0.5)
-	// Load the list of images into memory.
-	err := dosktop.LoadImagesInBulk(assetList)
-
-In addition, the following information should be noted:
-
-- This method works by reading in the provided asset list and then calling
-'LoadPreRenderedImage' accordingly each time. For more information about the
-loading of images, please see 'LoadPreRenderedImage' for more details.
-
-- In the event an error occurs, it will be returned to the user immediately
-and further loading will stop.
-*/
-func LoadPreRenderedImagesInBulk(assetList memory.AssetListType) error {
-	var err error
-	for _, currentAsset := range assetList.PreloadedImageList {
-		err = LoadPreRenderedImage(currentAsset.FileAlias, currentAsset.FileAlias, currentAsset.WidthInCharacters, currentAsset.HeightInCharacters, currentAsset.BlurSigma)
-		if err != nil {
-			return err
-		}
-	}
-	return err
-}
-
 /*
 LoadBase64Image allows you to load a base64 encoded image into memory without
 performing any ansi conversions ahead of time. This takes up more memory for

image_test.go

@@ -481,8 +481,17 @@ func GetInput(layerAlias string, styleEntry memory.TuiStyleEntryType, xLocation
 		memory.KeyboardMemory.AddKeystrokeToKeyboardBuffer("end")
 	}
 	for currentKeyPressed != "enter" {
+		mouseXLocation, mouseYLocation, mouseButtonPressed, _ := memory.MouseMemory.GetMouseStatus()
+		mouseCellIdentifier := getCellIdByLayerAlias(layerAlias, mouseXLocation, mouseYLocation)
+		if mouseCellIdentifier != constants.NullCellId {
+			if mouseButtonPressed == 1 {
+				cursorPosition = mouseCellIdentifier
+				isScreenUpdateRequired = true
+			}
+		}
 		currentKeyPressed = Inkey()
 		if currentKeyPressed != "" {
+			// If character is pressed.
 			if len(currentKeyPressed) == 1 {
 				if len(inputString) < maxLengthAllowed {
 					inputString = inputString[:viewportPosition+cursorPosition] + currentKeyPressed + inputString[viewportPosition+cursorPosition:]
@@ -583,12 +592,12 @@ func GetInput(layerAlias string, styleEntry memory.TuiStyleEntryType, xLocation
 			}
 		}
 		if isScreenUpdateRequired {
-			drawInputString(layerEntry, styleEntry, xLocation, yLocation, width, 0, stringformat.GetFilledString(width, " "))
+			drawInputString(layerEntry, styleEntry, xLocation, yLocation, width, 0, false, stringformat.GetFilledString(width, " "))
 			if IsPasswordProtected {
 				passwordProtectedString := stringformat.GetFilledString(len(inputString), "*")
-				drawInputString(layerEntry, styleEntry, xLocation, yLocation, widthOfViewport, viewportPosition, passwordProtectedString)
+				drawInputString(layerEntry, styleEntry, xLocation, yLocation, widthOfViewport, viewportPosition, true, passwordProtectedString)
 			} else {
-				drawInputString(layerEntry, styleEntry, xLocation, yLocation, widthOfViewport, viewportPosition, inputString)
+				drawInputString(layerEntry, styleEntry, xLocation, yLocation, widthOfViewport, viewportPosition, true, inputString)
 			}
 			drawCursor(layerEntry, styleEntry, xLocation, yLocation, cursorPosition, false)
 			UpdateDisplay()
@@ -639,10 +648,11 @@ the text layer, then only the visible portion will be displayed.
 start. If the remainder of your string is too long for the specified width,
 then only the visible portion will be displayed.
 */
-func drawInputString(layerEntry *memory.LayerEntryType, styleEntry memory.TuiStyleEntryType, xLocation int, yLocation int, width int, stringPosition int, inputString string) {
+func drawInputString(layerEntry *memory.LayerEntryType, styleEntry memory.TuiStyleEntryType, xLocation int, yLocation int, width int, stringPosition int, isCellIdsRequired bool, inputString string) {
 	attributeEntry := memory.NewAttributeEntry()
 	attributeEntry.ForegroundColor = styleEntry.TextInputForegroundColor
 	attributeEntry.BackgroundColor = styleEntry.TextInputBackgroundColor
+	attributeEntry.CellType = constants.CellTypeTextInput
 	runeSlice := []rune(inputString)
 	var safeSubstring string
 	if stringPosition+width <= len(inputString) {
@@ -651,5 +661,12 @@ func drawInputString(layerEntry *memory.LayerEntryType, styleEntry memory.TuiSty
 		safeSubstring = string(runeSlice[stringPosition : stringPosition+len(inputString)-stringPosition])
 	}
 	arrayOfRunes := stringformat.GetRunesFromString(safeSubstring)
-	printLayer(layerEntry, attributeEntry, xLocation, yLocation, arrayOfRunes)
+	// Here we loop over each character to draw since we need to accommodate for unique
+	// cell IDs (if required for mouse location detection).
+	for currentRuneIndex := 0; currentRuneIndex < len(arrayOfRunes); currentRuneIndex ++ {
+		if isCellIdsRequired {
+			attributeEntry.CellId = currentRuneIndex
+		}
+		printLayer(layerEntry, attributeEntry, xLocation + currentRuneIndex, yLocation, []rune{arrayOfRunes[currentRuneIndex]})
+	}
 }

input_menu.go

@@ -0,0 +1,5 @@
+This is line 1
+This is line 2
+This is line 3
+This is line 4
+This is line 5

test_data/virtual_file_systems/text_file.txt

@@ -106,9 +106,8 @@ func getMD5Hash(text string) string {
 	return hex.EncodeToString(hash[:])
 }
 
-
 /*
-SetVirtualFileSystem allows you to specify a virtual file system to mount.
+mountVirtualFileSystem allows you to specify a virtual file system to mount.
 A virtual file system is a ZIP or RAR archive that contains all files in which
 you wish to access. This is useful since instead of distributing multiple
 files and folders with your application, you can simply package everything
@@ -139,7 +138,7 @@ see the method 'GetScrambledPassword' for details.
 error will be returned so that your application can handle this case
 appropriately.
 */
-func SetVirtualFileSystem(archivePath string, password string, scrambleKey string) error {
+func mountVirtualFileSystem(archivePath string, password string, scrambleKey string) error {
 	err := isArchiveFormatZip(archivePath)
 	if err == nil {
 		virtualFileSystemArchiveType = constants.VirtualFileSystemZip
@@ -160,6 +159,18 @@ func SetVirtualFileSystem(archivePath string, password string, scrambleKey strin
 	return err
 }
 
+/*
+UnmountVirtualFileSystem allows you to reset the virtual file system to an
+unmounted state. This is useful for when you want to access the physical
+file system directly.
+*/
+func UnmountVirtualFileSystem() {
+	virtualFileSystemArchiveType = 0
+	virtualFileSystemArchive = ""
+	virtualFileSystemPassword = ""
+	virtualFileSystemEncryptionKey = ""
+}
+
 /*
 isArchiveFormatZip allows you to detect if the provided archive is in ZIP
 format or not.
@@ -263,15 +274,14 @@ func getFileDataFromFileSystem(fileName string) ([]byte, error) {
 	var err error
 	if virtualFileSystemArchiveType == constants.VirtualFileSystemZip {
 		fileData, err = getFileDataFromZipArchive(fileName)
+		return fileData, err
 	} else if virtualFileSystemArchiveType == constants.VirtualFileSystemRar {
 		fileData, err = getFileDataFromRarArchive(fileName)
+		return fileData, err
 	}
+	fileData, err = getFileDataFromLocalFileSystem(fileName)
 	if err != nil {
-		archiveError := err
-		fileData, err = getFileDataFromLocalFileSystem(fileName)
-		if err != nil {
-			err = errors.New(fmt.Sprintf("Could not open the file '%s': %s, %s", fileName, archiveError.Error(), err.Error()))
-		}
+		err = errors.New(fmt.Sprintf("Could not open the file '%s': %s", fileName, err.Error()))
 	}
 	return fileData, err
 }

virtual_file_system.go

@@ -21,42 +21,53 @@ func TestGetUnscrambledPassword(test *testing.T) {
 	assert.Equalf(test, obtainedResult, expectedResult, "The unscrambled password did not match what was expected!")
 }
 
-func TestSetVirtualFileSystem(test *testing.T) {
+func TestMountVirtualFileSystem(test *testing.T) {
 	var expectedResult error
 	scrambledPassword := "TAFDRw=="
 	scrambleKey := "SampleScrambleKey"
 
 	// Verify valid statements.
-	obtainedResult := SetVirtualFileSystem(BASE_DIRECTORY + "valid.zip", scrambledPassword, scrambleKey)
+	obtainedResult := mountVirtualFileSystem(BASE_DIRECTORY + "valid.zip", scrambledPassword, scrambleKey)
 	assert.Equalf(test, obtainedResult, expectedResult, "Failed to open a valid ZIP filesystem!")
 	_, err := getImageFromFileSystem("myFolder-1/myFolder-2/sample3.png")
 	assert.NoErrorf(test, err, "Failed to obtain image data from ZIP file system.")
-	obtainedResult = SetVirtualFileSystem(BASE_DIRECTORY + "valid.rar", scrambledPassword, scrambleKey)
+	obtainedResult = mountVirtualFileSystem(BASE_DIRECTORY + "valid.rar", scrambledPassword, scrambleKey)
 	_, err = getImageFromFileSystem("myFolder-1/myFolder-2/sample3.png")
 	assert.NoErrorf(test, err, "Failed to obtain image data from RAR file system.")
 
 	// Verify invalid archive passwords generate errors.
 	scrambleKey = "SampleScrambleKey_BAD"
-	obtainedResult = SetVirtualFileSystem(BASE_DIRECTORY + "valid.zip", scrambledPassword, scrambleKey)
+	obtainedResult = mountVirtualFileSystem(BASE_DIRECTORY + "valid.zip", scrambledPassword, scrambleKey)
 	assert.Equalf(test, obtainedResult, expectedResult, "Failed to open a valid ZIP filesystem!")
 	_, err = getImageFromFileSystem("myFolder-1/myFolder-2/sample3.png")
 	assert.Errorf(test, err, "Expected an error retrieving a file from ZIP file system with a bad password.")
-	obtainedResult = SetVirtualFileSystem(BASE_DIRECTORY + "valid.rar", scrambledPassword, scrambleKey)
+	obtainedResult = mountVirtualFileSystem(BASE_DIRECTORY + "valid.rar", scrambledPassword, scrambleKey)
 	_, err = getImageFromFileSystem("myFolder-1/myFolder-2/sample3.png")
 	assert.Errorf(test, err, "Expected an error retrieving a file from RAR file system with a bad password.")
 
 	// Verify invalid file requests generate errors.
 	scrambleKey = "SampleScrambleKey"
-	obtainedResult = SetVirtualFileSystem(BASE_DIRECTORY + "valid.zip", scrambledPassword, scrambleKey)
+	obtainedResult = mountVirtualFileSystem(BASE_DIRECTORY + "valid.zip", scrambledPassword, scrambleKey)
 	assert.Equalf(test, obtainedResult, expectedResult, "Failed to open a valid ZIP filesystem!")
 	_, err = getImageFromFileSystem("myFolder-1/myFolder-2/sample3.png_BAD")
 	assert.Errorf(test, err, "Expected an error retrieving a file from ZIP file system that does not exist.")
-	obtainedResult = SetVirtualFileSystem(BASE_DIRECTORY + "valid.rar", scrambledPassword, scrambleKey)
+	obtainedResult = mountVirtualFileSystem(BASE_DIRECTORY + "valid.rar", scrambledPassword, scrambleKey)
 	_, err = getImageFromFileSystem("myFolder-1/myFolder-2/sample3.png_BAD")
 	assert.Errorf(test, err, "Expected an error retrieving a file from RAR file system that does not exist.")
 
 	// Verify invalid archives.
 	assert.Equalf(test, obtainedResult, expectedResult, "Failed to open a valid ZIP filesystem!")
-	obtainedResult = SetVirtualFileSystem(BASE_DIRECTORY + "invalid.zip", scrambledPassword, scrambleKey)
+	obtainedResult = mountVirtualFileSystem(BASE_DIRECTORY + "invalid.zip", scrambledPassword, scrambleKey)
 	assert.NotNil(test, obtainedResult, "Opening an invalid ZIP file was expected to fail when it didn't!")
+	UnmountVirtualFileSystem()
+}
+
+func TestGetFileDataFromLocalFileSystem(test *testing.T) {
+	_, err := getFileDataFromLocalFileSystem(BASE_DIRECTORY + "valid.rar")
+	assert.NoErrorf(test, err, "Did not expect an error reading a file that should exist!")
+}
+
+func TestGetTextFromFileSystem(test *testing.T) {
+	_, err := getTextFromFileSystem(BASE_DIRECTORY + "text_file.txt")
+	assert.NoErrorf(test, err, "Did not expect an error reading a text file that should exist!")
 }