Merge pull request #7 from CalebQ42/gtkUI

Settings, wine download and more!

app.go

@@ -5,8 +5,8 @@ import (
 	"os/exec"
 	"strings"
 
-	"github.com/nelsam/gxui"
-	"github.com/nelsam/gxui/math"
+	"github.com/gotk3/gotk3/gdk"
+	"github.com/gotk3/gotk3/gtk"
 )
 
 type app struct {
@@ -15,94 +15,35 @@ type app struct {
 	appimg []string
 	lin    []string
 	ex     []string
-	icon   gxui.Texture
+	icon   *gdk.Pixbuf
 	dir    string
 	ini    *os.File
 }
 
-type appExNode struct {
-	ap    app
-	exInd int
+func (a *app) getTreeIter(store *gtk.TreeStore) *gtk.TreeIter {
+	it := store.Append(nil)
+	store.SetValue(it, 0, a.icon)
+	store.SetValue(it, 1, a.name)
+	if len(a.ex) > 1 {
+		for _, v := range a.ex {
+			i := store.Append(it)
+			store.SetValue(i, 1, v)
+		}
+	}
+	return it
 }
 
-func (a *appExNode) launch() {
+func (a *app) launch() {
+	if len(a.ex) == 1 {
 		if wine {
 			var cmd *exec.Cmd
-		if !contains(a.ap.lin, a.ap.ex[a.exInd]) {
-			cmd = exec.Command("/bin/sh", "-c", "cd \""+a.ap.dir+"\"; wine \""+a.ap.ex[a.exInd]+"\"")
+			if !contains(a.lin, a.ex[0]) {
+				cmd = exec.Command("/bin/sh", "-c", "cd \""+a.dir+"\"; wine \""+a.ex[0]+"\"")
 			} else {
 				if comEnbld {
-				cmd = exec.Command("/bin/sh", "-c", ". PortableApps/LinuxPACom/common.sh || exit 1;cd \""+a.ap.dir+"\"; \"./"+a.ap.ex[a.exInd]+"\"")
+					cmd = exec.Command("/bin/sh", "-c", ". PortableApps/LinuxPACom/common.sh || exit 1;cd \""+a.dir+"\"; \"./"+a.ex[0]+"\"")
 				} else {
-				cmd = exec.Command("/bin/sh", "-c", "cd \""+a.ap.dir+"\"; \"./"+a.ap.ex[a.exInd]+"\"")
-			}
-		}
-		cmd.Stdout = os.Stdout
-		cmd.Stderr = os.Stderr
-		cmd.Start()
-	}
-	var cmd *exec.Cmd
-	if comEnbld {
-		cmd = exec.Command("/bin/sh", "-c", ". PortableApps/LinuxPACom/common.sh || exit 1;cd \""+a.ap.dir+"\"; \"./"+a.ap.ex[a.exInd]+"\"")
-	} else {
-		cmd = exec.Command("/bin/sh", "-c", "cd \""+a.ap.dir+"\"; \"./"+a.ap.ex[a.exInd]+"\"")
-	}
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	cmd.Start()
-}
-
-func (a *appExNode) Count() int {
-	return 0
-}
-
-func (a *appExNode) NodeAt(int) gxui.TreeNode {
-	return nil
-}
-
-func (a *appExNode) ItemIndex(gxui.AdapterItem) int {
-	return -1
-}
-
-func (a *appExNode) Item() gxui.AdapterItem {
-	if wine {
-		return a.ap.ex[a.exInd]
-	}
-	return a.ap.lin[a.exInd]
-}
-
-func (a *appExNode) Create(the gxui.Theme) gxui.Control {
-	box := the.CreateLinearLayout()
-	box.SetDirection(gxui.LeftToRight)
-	box.SetVerticalAlignment(gxui.AlignMiddle)
-	img := the.CreateImage()
-	img.SetTexture(a.ap.icon)
-	img.SetExplicitSize(math.Size{H: 32, W: 32})
-	lbl := the.CreateLabel()
-	lbl.SetText(a.ap.ex[a.exInd])
-	box.AddChild(img)
-	box.AddChild(lbl)
-	box.OnDoubleClick(func(gxui.MouseEvent) {
-		a.launch()
-	})
-	return box
-}
-
-type appNode struct {
-	ap app
-}
-
-func (a *appNode) launch() {
-	if len(a.ap.ex) == 1 {
-		if wine {
-			var cmd *exec.Cmd
-			if !contains(a.ap.lin, a.ap.ex[0]) {
-				cmd = exec.Command("/bin/sh", "-c", "cd \""+a.ap.dir+"\"; wine \""+a.ap.ex[0]+"\"")
-			} else {
-				if comEnbld {
-					cmd = exec.Command("/bin/sh", "-c", ". PortableApps/LinuxPACom/common.sh || exit 1;cd \""+a.ap.dir+"\"; \"./"+a.ap.ex[0]+"\"")
-				} else {
-					cmd = exec.Command("/bin/sh", "-c", "cd \""+a.ap.dir+"\"; \"./"+a.ap.ex[0]+"\"")
+					cmd = exec.Command("/bin/sh", "-c", "cd \""+a.dir+"\"; \"./"+a.ex[0]+"\"")
 				}
 			}
 			cmd.Stdout = os.Stdout
@@ -111,9 +52,9 @@ func (a *appNode) launch() {
 		} else {
 			var cmd *exec.Cmd
 			if comEnbld {
-				cmd = exec.Command("/bin/sh", "-c", ". PortableApps/LinuxPACom/common.sh || exit 1;cd \""+a.ap.dir+"\"; \"./"+a.ap.ex[0]+"\"")
+				cmd = exec.Command("/bin/sh", "-c", ". PortableApps/LinuxPACom/common.sh || exit 1;cd \""+a.dir+"\"; \"./"+a.ex[0]+"\"")
 			} else {
-				cmd = exec.Command("/bin/sh", "-c", "cd \""+a.ap.dir+"\"; \"./"+a.ap.ex[0]+"\"")
+				cmd = exec.Command("/bin/sh", "-c", "cd \""+a.dir+"\"; \"./"+a.ex[0]+"\"")
 			}
 			cmd.Stdout = os.Stdout
 			cmd.Stderr = os.Stderr
@@ -122,29 +63,29 @@ func (a *appNode) launch() {
 	} else {
 		if wine {
 			var cmd *exec.Cmd
-			if len(a.ap.lin) == 0 {
-				cmd = exec.Command("/bin/sh", "-c", "cd \""+a.ap.dir+"\"; wine \""+a.ap.ex[0]+"\"")
+			if len(a.lin) == 0 {
+				cmd = exec.Command("/bin/sh", "-c", "cd \""+a.dir+"\"; wine \""+a.ex[0]+"\"")
 			} else {
 				var ind int
-				for i, v := range a.ap.lin {
+				for i, v := range a.lin {
 					if strings.HasSuffix(v, ".sh") {
 						ind = i
 						break
 					}
 				}
 				if comEnbld {
-					cmd = exec.Command("/bin/sh", "-c", ". PortableApps/LinuxPACom/common.sh || exit 1;cd \""+a.ap.dir+"\"; \"./"+a.ap.lin[ind]+"\"")
+					cmd = exec.Command("/bin/sh", "-c", ". PortableApps/LinuxPACom/common.sh || exit 1;cd \""+a.dir+"\"; \"./"+a.lin[ind]+"\"")
 				} else {
-					cmd = exec.Command("/bin/sh", "-c", "cd \""+a.ap.dir+"\"; \"./"+a.ap.lin[ind]+"\"")
+					cmd = exec.Command("/bin/sh", "-c", "cd \""+a.dir+"\"; \"./"+a.lin[ind]+"\"")
 				}
 			}
 			cmd.Stdout = os.Stdout
 			cmd.Stderr = os.Stderr
 			cmd.Start()
 		} else {
-			if len(a.ap.lin) != 0 {
+			if len(a.lin) != 0 {
 				var ind int
-				for i, v := range a.ap.lin {
+				for i, v := range a.lin {
 					if strings.HasSuffix(v, ".sh") {
 						ind = i
 						break
@@ -152,9 +93,9 @@ func (a *appNode) launch() {
 				}
 				var cmd *exec.Cmd
 				if comEnbld {
-					cmd = exec.Command("/bin/sh", "-c", ". PortableApps/LinuxPACom/common.sh || exit 1;cd \""+a.ap.dir+"\"; \"./"+a.ap.lin[ind]+"\"")
+					cmd = exec.Command("/bin/sh", "-c", ". PortableApps/LinuxPACom/common.sh || exit 1;cd \""+a.dir+"\"; \"./"+a.lin[ind]+"\"")
 				} else {
-					cmd = exec.Command("/bin/sh", "-c", "cd \""+a.ap.dir+"\"; \"./"+a.ap.lin[ind]+"\"")
+					cmd = exec.Command("/bin/sh", "-c", "cd \""+a.dir+"\"; \"./"+a.lin[ind]+"\"")
 				}
 				cmd.Stdout = os.Stdout
 				cmd.Stderr = os.Stderr
@@ -164,109 +105,204 @@ func (a *appNode) launch() {
 	}
 }
 
-func (a *appNode) Count() int {
+func (a *app) launchSub(sub int) {
 	if wine {
-		if len(a.ap.ex) > 1 {
-			return len(a.ap.ex)
-		}
-		return 0
-	}
-	if len(a.ap.lin) > 1 {
-		return len(a.ap.lin)
-	}
-	return 0
-}
-
-func (a *appNode) NodeAt(i int) gxui.TreeNode {
-	return &appExNode{ap: a.ap, exInd: i}
-}
-
-func (a *appNode) ItemIndex(item gxui.AdapterItem) int {
-	if wine {
-		for i, v := range a.ap.ex {
-			if v == item {
-				return i
-			}
-		}
+		var cmd *exec.Cmd
+		if !contains(a.lin, a.ex[sub]) {
+			cmd = exec.Command("/bin/sh", "-c", "cd \""+a.dir+"\"; wine \""+a.ex[sub]+"\"")
 		} else {
-		for i, v := range a.ap.lin {
-			if v == item {
-				return i
-			}
-		}
-	}
-	return -1
-}
-
-func (a *appNode) Item() gxui.AdapterItem {
-	return a.ap.name
-}
-
-func (a *appNode) Create(the gxui.Theme) gxui.Control {
-	box := the.CreateLinearLayout()
-	box.SetDirection(gxui.LeftToRight)
-	box.SetPadding(math.CreateSpacing(2))
-	box.SetVerticalAlignment(gxui.AlignMiddle)
-	img := the.CreateImage()
-	if a.ap.icon != nil {
-		img.SetTexture(a.ap.icon)
-	}
-	img.SetExplicitSize(math.Size{H: 32, W: 32})
-	lbl := the.CreateLabel()
-	lbl.SetText(a.ap.name)
-	box.AddChild(img)
-	box.AddChild(lbl)
-	box.OnDoubleClick(func(gxui.MouseEvent) {
-		a.launch()
-	})
-	return box
-}
-
-type catAdap struct {
-	gxui.AdapterBase
-	cat string
-}
-
-func (a *catAdap) setCat(cat string) {
-	a.cat = cat
-	a.DataChanged(false)
-}
-
-func (a *catAdap) refresh() {
-	a.DataChanged(false)
-}
-
-func (a *catAdap) Count() int {
-	if wine {
-		return len(master[a.cat])
-	}
-	return len(linmaster[a.cat])
-}
-
-func (a *catAdap) NodeAt(i int) gxui.TreeNode {
-	if wine {
-		return &appNode{ap: master[a.cat][i]}
-	}
-	return &appNode{ap: linmaster[a.cat][i]}
-}
-
-func (a *catAdap) Size(gxui.Theme) math.Size {
-	return math.Size{H: 34, W: math.MaxSize.W}
-}
-
-func (a *catAdap) ItemIndex(item gxui.AdapterItem) int {
-	if wine {
-		for i, v := range master[a.cat] {
-			if v.name == item {
-				return i
-			}
-		}
+			if comEnbld {
+				cmd = exec.Command("/bin/sh", "-c", ". PortableApps/LinuxPACom/common.sh || exit 1;cd \""+a.dir+"\"; \"./"+a.ex[sub]+"\"")
 			} else {
-		for i, v := range linmaster[a.cat] {
-			if v.name == item {
-				return i
+				cmd = exec.Command("/bin/sh", "-c", "cd \""+a.dir+"\"; \"./"+a.ex[sub]+"\"")
 			}
 		}
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		cmd.Start()
 	}
-	return -1
+	var cmd *exec.Cmd
+	if comEnbld {
+		cmd = exec.Command("/bin/sh", "-c", ". PortableApps/LinuxPACom/common.sh || exit 1;cd \""+a.dir+"\"; \"./"+a.ex[sub]+"\"")
+	} else {
+		cmd = exec.Command("/bin/sh", "-c", "cd \""+a.dir+"\"; \"./"+a.ex[sub]+"\"")
 	}
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	cmd.Start()
+}
+
+// type appExNode struct {
+// 	ap    app
+// 	exInd int
+// }
+//
+// func (a *appExNode) launch() {
+// 	if wine {
+// 		var cmd *exec.Cmd
+// 		if !contains(a.ap.lin, a.ap.ex[a.exInd]) {
+// 			cmd = exec.Command("/bin/sh", "-c", "cd \""+a.ap.dir+"\"; wine \""+a.ap.ex[a.exInd]+"\"")
+// 		} else {
+// 			if comEnbld {
+// 				cmd = exec.Command("/bin/sh", "-c", ". PortableApps/LinuxPACom/common.sh || exit 1;cd \""+a.ap.dir+"\"; \"./"+a.ap.ex[a.exInd]+"\"")
+// 			} else {
+// 				cmd = exec.Command("/bin/sh", "-c", "cd \""+a.ap.dir+"\"; \"./"+a.ap.ex[a.exInd]+"\"")
+// 			}
+// 		}
+// 		cmd.Stdout = os.Stdout
+// 		cmd.Stderr = os.Stderr
+// 		cmd.Start()
+// 	}
+// 	var cmd *exec.Cmd
+// 	if comEnbld {
+// 		cmd = exec.Command("/bin/sh", "-c", ". PortableApps/LinuxPACom/common.sh || exit 1;cd \""+a.ap.dir+"\"; \"./"+a.ap.ex[a.exInd]+"\"")
+// 	} else {
+// 		cmd = exec.Command("/bin/sh", "-c", "cd \""+a.ap.dir+"\"; \"./"+a.ap.ex[a.exInd]+"\"")
+// 	}
+// 	cmd.Stdout = os.Stdout
+// 	cmd.Stderr = os.Stderr
+// 	cmd.Start()
+// }
+
+// func (a *appExNode) Count() int {
+// 	return 0
+// }
+//
+// func (a *appExNode) NodeAt(int) gxui.TreeNode {
+// 	return nil
+// }
+//
+// func (a *appExNode) ItemIndex(gxui.AdapterItem) int {
+// 	return -1
+// }
+//
+// func (a *appExNode) Item() gxui.AdapterItem {
+// 	if wine {
+// 		return a.ap.ex[a.exInd]
+// 	}
+// 	return a.ap.lin[a.exInd]
+// }
+//
+// func (a *appExNode) Create(the gxui.Theme) gxui.Control {
+// 	box := the.CreateLinearLayout()
+// 	box.SetDirection(gxui.LeftToRight)
+// 	box.SetVerticalAlignment(gxui.AlignMiddle)
+// 	img := the.CreateImage()
+// 	img.SetTexture(a.ap.icon)
+// 	img.SetExplicitSize(math.Size{H: 32, W: 32})
+// 	lbl := the.CreateLabel()
+// 	lbl.SetText(a.ap.ex[a.exInd])
+// 	box.AddChild(img)
+// 	box.AddChild(lbl)
+// 	box.OnDoubleClick(func(gxui.MouseEvent) {
+// 		a.launch()
+// 	})
+// 	return box
+// }
+
+// func (a *appNode) Count() int {
+// 	if wine {
+// 		if len(a.ex) > 1 {
+// 			return len(a.ap.ex)
+// 		}
+// 		return 0
+// 	}
+// 	if len(a.ap.lin) > 1 {
+// 		return len(a.ap.lin)
+// 	}
+// 	return 0
+// }
+//
+// func (a *appNode) NodeAt(i int) gxui.TreeNode {
+// 	return &appExNode{ap: a.ap, exInd: i}
+// }
+//
+// func (a *appNode) ItemIndex(item gxui.AdapterItem) int {
+// 	if wine {
+// 		for i, v := range a.ap.ex {
+// 			if v == item {
+// 				return i
+// 			}
+// 		}
+// 	} else {
+// 		for i, v := range a.ap.lin {
+// 			if v == item {
+// 				return i
+// 			}
+// 		}
+// 	}
+// 	return -1
+// }
+//
+// func (a *appNode) Item() gxui.AdapterItem {
+// 	return a.ap.name
+// }
+//
+// func (a *appNode) Create(the gxui.Theme) gxui.Control {
+// 	box := the.CreateLinearLayout()
+// 	box.SetDirection(gxui.LeftToRight)
+// 	box.SetPadding(math.CreateSpacing(2))
+// 	box.SetVerticalAlignment(gxui.AlignMiddle)
+// 	img := the.CreateImage()
+// 	if a.ap.icon != nil {
+// 		img.SetTexture(a.ap.icon)
+// 	}
+// 	img.SetExplicitSize(math.Size{H: 32, W: 32})
+// 	lbl := the.CreateLabel()
+// 	lbl.SetText(a.ap.name)
+// 	box.AddChild(img)
+// 	box.AddChild(lbl)
+// 	box.OnDoubleClick(func(gxui.MouseEvent) {
+// 		a.launch()
+// 	})
+// 	return box
+// }
+
+// type catAdap struct {
+// 	gxui.AdapterBase
+// 	cat string
+// }
+//
+// func (a *catAdap) setCat(cat string) {
+// 	a.cat = cat
+// 	a.DataChanged(false)
+// }
+//
+// func (a *catAdap) refresh() {
+// 	a.DataChanged(false)
+// }
+//
+// func (a *catAdap) Count() int {
+// 	if wine {
+// 		return len(master[a.cat])
+// 	}
+// 	return len(linmaster[a.cat])
+// }
+//
+// func (a *catAdap) NodeAt(i int) gxui.TreeNode {
+// 	if wine {
+// 		return &appNode{ap: master[a.cat][i]}
+// 	}
+// 	return &appNode{ap: linmaster[a.cat][i]}
+// }
+//
+// func (a *catAdap) Size(gxui.Theme) math.Size {
+// 	return math.Size{H: 34, W: math.MaxSize.W}
+// }
+//
+// func (a *catAdap) ItemIndex(item gxui.AdapterItem) int {
+// 	if wine {
+// 		for i, v := range master[a.cat] {
+// 			if v.name == item {
+// 				return i
+// 			}
+// 		}
+// 	} else {
+// 		for i, v := range linmaster[a.cat] {
+// 			if v.name == item {
+// 				return i
+// 			}
+// 		}
+// 	}
+// 	return -1
+// }

gxui/main.go

@@ -0,0 +1,82 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+
+	"github.com/nelsam/gxui"
+	"github.com/nelsam/gxui/drivers/gl"
+	"github.com/nelsam/gxui/themes/dark"
+	"github.com/nelsam/gxui/themes/light"
+)
+
+const (
+	version = "1.1.0.0"
+	defIni  = "[basic]\ntheme=dk"
+)
+
+var (
+	dr        gxui.Driver
+	th        gxui.Theme
+	master    map[string][]app
+	linmaster map[string][]app
+	cats      []string
+	lin       []string
+	wine      bool
+	comEnbld  bool
+	darkTheme = true
+)
+
+func main() {
+	updated := false
+	os.MkdirAll("PortableApps/LinuxPACom", 0777)
+	stat, err := versionDL()
+	if stat {
+		res := getVersionFileInfo()
+		if res != "Error!" {
+			stat, err = checkForUpdate(res)
+			if stat {
+				downloadUpdate(res)
+				updated = true
+			} else {
+				fmt.Println(err)
+			}
+		} else {
+			fmt.Println("Failed Version File Info")
+		}
+	} else {
+		fmt.Println(err)
+	}
+	if updated {
+		cmd := exec.Command("./LinuxPA")
+		cmd.Stdin = os.Stdin
+		cmd.Stdout = os.Stdout
+		cmd.Start()
+	} else {
+		master = make(map[string][]app)
+		linmaster = make(map[string][]app)
+		gl.StartDriver(appMain)
+	}
+}
+
+func appMain(dri gxui.Driver) {
+	dr = dri
+	setup()
+	if darkTheme {
+		th = dark.CreateTheme(dr)
+	} else {
+		th = light.CreateTheme(dr)
+	}
+	th = dark.CreateTheme(dr)
+	ui()
+}
+
+func contains(arr []string, str string) bool {
+	for _, v := range arr {
+		if v == str {
+			return true
+		}
+	}
+	return false
+}

gxui/setup.go

@@ -0,0 +1,208 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"image"
+	"image/draw"
+	_ "image/png"
+	"os"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/nelsam/gxui"
+)
+
+func setup() {
+	PortableAppsFold, err := os.Open("PortableApps")
+	if PAStat, _ := PortableAppsFold.Stat(); err != nil || !PAStat.IsDir() {
+		os.Mkdir("PortableApps", 0777)
+		PortableAppsFold, err = os.Open("PortableApps")
+		if err != nil {
+			panic("Can't find PortableApps folder and can't create one!")
+		}
+	}
+	if _, err = os.Open("PortableApps/LinuxPACom"); err != nil {
+		os.Mkdir("PortableApps/LinuxPACom", 0777)
+	}
+	fmt.Println(err)
+	_, err = os.Open("PortableApps/LinuxPACom/common.sh")
+	if err == nil {
+		comEnbld = true
+	}
+	fi, err := os.Open("PortableApps/LinuxPACom/Info.ini")
+	if err != nil {
+		fi, err = os.Create("PortableApps/LinuxPACom/Info.ini")
+		if err == nil {
+			wrt := bufio.NewWriter(fi)
+			wrt.WriteString(defIni)
+			wrt.Flush()
+		}
+	}
+	if err == nil {
+		rdr := bufio.NewReader(fi)
+		for err != nil {
+			ln, _, error := rdr.ReadLine()
+			err = error
+			str := string(ln)
+			if strings.HasPrefix(str, "theme=") {
+				str = strings.TrimPrefix(str, "theme=")
+				if str == "lt" {
+					darkTheme = false
+				}
+			}
+		}
+	}
+	PAFolds, _ := PortableAppsFold.Readdirnames(-1)
+	sort.Strings(PAFolds)
+	for _, v := range PAFolds {
+		fold, _ := os.Open("PortableApps/" + v)
+		if stat, _ := fold.Stat(); stat.IsDir() && stat.Name() != "PortableApps.com" && stat.Name() != "LinuxPACom" {
+			ap := processApp("PortableApps/" + v)
+			if !reflect.DeepEqual(ap, app{}) {
+				if _, ok := master[ap.cat]; !ok {
+					cats = append(cats, ap.cat)
+					sort.Strings(cats)
+				}
+				if len(ap.lin) != 0 {
+					if _, ok := linmaster[ap.cat]; !ok {
+						lin = append(lin, ap.cat)
+						sort.Strings(lin)
+					}
+				}
+				master[ap.cat] = append(master[ap.cat], ap)
+				if len(ap.lin) != 0 {
+					linmaster[ap.cat] = append(linmaster[ap.cat], ap)
+				}
+			}
+		}
+	}
+}
+
+func processApp(fold string) (out app) {
+	wd, _ := os.Getwd()
+	out.dir = wd + "/" + fold
+	out.ini = findInfo(fold)
+	if out.ini != nil {
+		out.name = getName(out.ini)
+		out.ini = findInfo(fold)
+		out.cat = getCat(out.ini)
+		out.ini = findInfo(fold)
+	}
+	if out.name == "" {
+		out.name = strings.TrimPrefix(fold, "PortableApps/")
+	}
+	if out.cat == "" {
+		out.cat = "Other"
+	}
+	out.icon = getIcon(fold)
+	folder, _ := os.Open(fold)
+	fis, _ := folder.Readdirnames(-1)
+	for _, v := range fis {
+		tmp, _ := os.Open(fold + "/" + v)
+		if stat, _ := tmp.Stat(); stat.IsDir() {
+			continue
+		}
+		if strings.HasSuffix(strings.ToLower(v), ".appimage") {
+			out.appimg = append(out.appimg, v)
+			out.ex = append(out.ex, v)
+			out.lin = append(out.lin, v)
+		} else if strings.HasSuffix(strings.ToLower(v), ".exe") {
+			out.ex = append(out.ex, v)
+		} else {
+			btys := make([]byte, 4)
+			rdr := bufio.NewReader(tmp)
+			rdr.Read(btys)
+			if (strings.Contains(strings.ToLower(string(btys)), "elf") && !strings.HasSuffix(strings.ToLower(v), ".so") && !strings.Contains(v, ".so.")) || strings.HasPrefix(strings.ToLower(string(btys)), "#!") {
+				out.ex = append(out.ex, v)
+				out.lin = append(out.lin, v)
+			}
+		}
+	}
+	if len(out.ex) == 0 {
+		return app{}
+	}
+	if len(out.lin) == 0 {
+		out.name += " (Wine)"
+	}
+	return
+}
+
+func getCat(ini *os.File) string {
+	rdr := bufio.NewReader(ini)
+	var ret string
+	for line, _, err := rdr.ReadLine(); err == nil; line, _, err = rdr.ReadLine() {
+		if strings.HasPrefix(string(line), "Category=") {
+			ret = strings.TrimPrefix(string(line), "Category=")
+			break
+		}
+	}
+	rdr.Reset(ini)
+	return ret
+}
+
+func getName(ini *os.File) string {
+	rdr := bufio.NewReader(ini)
+	var ret string
+	for line, _, err := rdr.ReadLine(); err == nil; line, _, err = rdr.ReadLine() {
+		if strings.HasPrefix(string(line), "Name=") {
+			ret = strings.TrimPrefix(string(line), "Name=")
+			break
+		}
+	}
+	rdr.Reset(ini)
+	return ret
+}
+
+func getIcon(fold string) gxui.Texture {
+	var pic *os.File
+	if folder, err := os.Open(fold + "/App/AppInfo"); err == nil {
+		fis, _ := folder.Readdir(-1)
+		var pics []string
+		for _, v := range fis {
+			if !v.IsDir() && strings.HasSuffix(strings.ToLower(v.Name()), ".png") && strings.HasPrefix(strings.ToLower(v.Name()), "appicon_") {
+				pics = append(pics, v.Name())
+			}
+		}
+		sort.Strings(pics)
+		if len(pics) > 1 {
+			var ind int
+			if !contains(pics, "appicon_32.png") {
+				ind = len(pics) - 1
+			} else {
+				ind = sort.SearchStrings(pics, "appicon_32.png")
+			}
+			pic, _ = os.Open(fold + "/App/AppInfo/" + pics[ind])
+		}
+	} else if fi, err := os.Open(fold + "/appicon.png"); err == nil {
+		pic = fi
+	} else {
+		return nil
+	}
+	img, _, err := image.Decode(pic)
+	if err != nil {
+		return nil
+	}
+	rgba := image.NewRGBA(img.Bounds())
+	draw.Draw(rgba, img.Bounds(), img, image.ZP, draw.Src)
+	ret := dr.CreateTexture(rgba, 1)
+	return ret
+}
+
+func findInfo(fold string) *os.File {
+	tmp, err := os.Open(fold + "/App/AppInfo")
+	if err == nil {
+		fis, _ := tmp.Readdirnames(-1)
+		for _, v := range fis {
+			if strings.ToLower(v) == "appinfo.ini" {
+				tmp, _ := os.Open(fold + "/App/AppInfo/" + v)
+				return tmp
+			}
+		}
+	}
+	if fi, err := os.Open(fold + "/appinfo.ini"); err == nil {
+		return fi
+	}
+	return nil
+}

gxui/ui.go

@@ -0,0 +1,66 @@
+package main
+
+import (
+	"os"
+	"os/exec"
+
+	"github.com/nelsam/gxui"
+)
+
+func ui() {
+	catListAdap := &StrList{}
+	appListAdap := &catAdap{}
+	catListAdap.SetStrings(lin)
+	win := th.CreateWindow(500, 500, "LinuxPA")
+	top := th.CreateLinearLayout()
+	top.SetDirection(gxui.BottomToTop)
+	splBox := th.CreateLinearLayout()
+	spl := th.CreateSplitterLayout()
+	spl.SetOrientation(gxui.Horizontal)
+	catList := th.CreateList()
+	catList.SetAdapter(catListAdap)
+	catList.OnSelectionChanged(func(it gxui.AdapterItem) {
+		appListAdap.setCat(it.(string))
+	})
+	appList := th.CreateTree()
+	appList.SetAdapter(appListAdap)
+	spl.AddChild(catList)
+	spl.AddChild(appList)
+	splBox.AddChild(spl)
+	butBox := th.CreateLinearLayout()
+	butBox.SetDirection(gxui.LeftToRight)
+	if _, err := exec.LookPath("wine"); err == nil {
+		wineBut := th.CreateButton()
+		wineBut.SetType(gxui.ToggleButton)
+		wineBut.SetChecked(wine)
+		wineBut.SetText("Show Windows Apps")
+		wineBut.OnClick(func(gxui.MouseEvent) {
+			wine = wineBut.IsChecked()
+			appListAdap.refresh()
+			if wineBut.IsChecked() {
+				catListAdap.SetStrings(cats)
+				wineBut.SetText("Hide Windows Apps")
+			} else {
+				catListAdap.SetStrings(lin)
+				wineBut.SetText("Show Windows Apps")
+			}
+		})
+		_, err := os.Open("Start.exe")
+		if err == nil {
+			pa := th.CreateButton()
+			pa.SetText("Open PortableApps Launcher")
+			pa.OnClick(func(gxui.MouseEvent) {
+				cmd := exec.Command("wine", "Start.exe")
+				cmd.Stdout = os.Stdout
+				cmd.Stderr = os.Stderr
+				cmd.Start()
+			})
+			butBox.AddChild(pa)
+		}
+		butBox.AddChild(wineBut)
+	}
+	top.AddChild(butBox)
+	top.AddChild(splBox)
+	win.AddChild(top)
+	win.OnClose(dr.Terminate)
+}

main.go

@@ -2,62 +2,52 @@ package main
 
 import (
 	"fmt"
+	"os"
 
-	"github.com/nelsam/gxui"
-	"github.com/nelsam/gxui/drivers/gl"
-	"github.com/nelsam/gxui/themes/dark"
-	"github.com/nelsam/gxui/themes/light"
+	"github.com/gotk3/gotk3/gtk"
 )
 
 const (
-	version = "0.1.1.1"
-	defIni  = "[basic]\ntheme=dk"
+	version = "2.0.1.0"
+	defIni  = ""
 )
 
 var (
-	dr        gxui.Driver
-	th        gxui.Theme
 	master    map[string][]app
 	linmaster map[string][]app
 	cats      []string
 	lin       []string
 	wine      bool
 	comEnbld  bool
-	darkTheme = true
+	wineAvail bool
+	showMsg   = true
 )
 
 func main() {
-	stat := versionDL()
-	if stat {
-		res := getVersionFileInfo()
-		if res != "Error!" {
-			stat = checkForUpdate(res)
-			if stat {
-				downloadUpdate(res)
-			} else {
-				fmt.Println("Failed DL")
-			}
-		} else {
-			fmt.Println("Failed Version File Info")
-		}
-	} else {
-		fmt.Println("Failed Version DL")
-	}
+	os.MkdirAll("PortableApps/LinuxPACom", 0777)
 	master = make(map[string][]app)
 	linmaster = make(map[string][]app)
-	gl.StartDriver(appMain)
+	uiStart()
 }
 
-func appMain(dri gxui.Driver) {
-	dr = dri
+func uiStart() {
+	gtk.Init(nil)
 	setup()
-	if darkTheme {
-		th = dark.CreateTheme(dr)
-	} else {
-		th = light.CreateTheme(dr)
+	win, err := gtk.WindowNew(gtk.WINDOW_TOPLEVEL)
+	if err != nil {
+		fmt.Println("Window not created", err)
 	}
-	th = dark.CreateTheme(dr)
-	ui()
+	win.SetTitle("LinuxPA")
+	win.Connect("destroy", func() {
+		gtk.MainQuit()
+	})
+	win.SetDefaultSize(500, 500)
+	win.SetPosition(gtk.WIN_POS_CENTER)
+	ui(win)
+	win.ShowAll()
+	win.Show()
+	update(win)
+	gtk.Main()
 }
 
 func contains(arr []string, str string) bool {

settings.go

@@ -0,0 +1,108 @@
+package main
+
+import (
+	"io/ioutil"
+	"os"
+
+	"github.com/gotk3/gotk3/gtk"
+)
+
+func settingsUI() {
+	win, _ := gtk.WindowNew(gtk.WINDOW_TOPLEVEL)
+	win.SetDefaultSize(600, 300)
+	win.SetPosition(gtk.WIN_POS_CENTER)
+	comTagTbl, _ := gtk.TextTagTableNew()
+	comBuf, _ := gtk.TextBufferNew(comTagTbl)
+	ntbk, _ := gtk.NotebookNew()
+	gnrl, _ := gtk.BoxNew(gtk.ORIENTATION_VERTICAL, 5)
+	gnrl.SetMarginStart(10)
+	gnrl.SetMarginEnd(10)
+	gnrl.SetMarginTop(10)
+	gnrl.SetMarginBottom(10)
+	dlWine, _ := gtk.ButtonNewWithLabel("Download Wine")
+	wineLbl, _ := gtk.LabelNew("PortableApps/LinuxPACom/Wine present")
+	gnrl.Add(wineLbl)
+	dlWine.Connect("clicked", func() {
+		cb := make(chan bool)
+		downloadWine(win, cb)
+		go func() {
+			v := <-cb
+			if v {
+				setupTxt(comBuf)
+				wineLbl.Show()
+			}
+		}()
+	})
+	if !comEnbld {
+		dlWine.SetSensitive(false)
+		dlWine.SetTooltipText("common.sh needed")
+	}
+	gnrl.Add(dlWine)
+	ntbk.AppendPage(gnrl, getLabel("General"))
+	com, _ := gtk.BoxNew(gtk.ORIENTATION_VERTICAL, 5)
+	com.SetMarginStart(10)
+	com.SetMarginEnd(10)
+	com.SetMarginTop(10)
+	com.SetMarginBottom(10)
+	comEdit, _ := gtk.TextViewNewWithBuffer(comBuf)
+	comEdit.SetVExpand(true)
+	comEdit.SetHExpand(true)
+	vScroll, _ := gtk.AdjustmentNew(0, 0, 0, 0, 0, 0)
+	hScroll, _ := gtk.AdjustmentNew(0, 0, 0, 0, 0, 0)
+	comScrl, _ := gtk.ScrolledWindowNew(hScroll, vScroll)
+	comScrl.Add(comEdit)
+	com.Add(comScrl)
+	svBox, _ := gtk.BoxNew(gtk.ORIENTATION_HORIZONTAL, 5)
+	sv, _ := gtk.ButtonNewWithLabel("Save")
+	sv.Connect("clicked", func() {
+		beg, end := comBuf.GetBounds()
+		txt, _ := comBuf.GetText(beg, end, true)
+		ioutil.WriteFile("PortableApps/LinuxPACom/common.sh", []byte(txt), 0777)
+	})
+	cnl, _ := gtk.ButtonNewWithLabel("Cancel")
+	cnl.Connect("clicked", func() {
+		setupTxt(comBuf)
+	})
+	svBox.Add(sv)
+	svBox.Add(cnl)
+	com.Add(svBox)
+	ntbk.AppendPage(com, getLabel("common.sh"))
+	win.Add(ntbk)
+	win.ShowAll()
+	if !comEnbld {
+		comScrl.Hide()
+		svBox.Hide()
+		mkCom, _ := gtk.ButtonNewWithLabel("Create common.sh")
+		mkCom.Connect("clicked", func() {
+			err := ioutil.WriteFile("PortableApps/LinuxPACom/common.sh", []byte("export HOME=$PWD/PortableApps/LinuxPACom/Home"), 0777)
+			if err == nil {
+				mkCom.Hide()
+				comScrl.Show()
+				svBox.Show()
+				setupTxt(comBuf)
+				comEnbld = true
+				dlWine.SetSensitive(true)
+				dlWine.SetTooltipText("")
+			}
+		})
+		mkCom.Show()
+		com.Add(mkCom)
+	} else {
+		setupTxt(comBuf)
+	}
+	if _, err := os.Open("PortableApps/LinuxPACom/Wine"); err != nil && os.IsNotExist(err) {
+		wineLbl.Hide()
+	}
+	win.Show()
+}
+
+func setupTxt(buf *gtk.TextBuffer) {
+	fil, _ := os.Open("PortableApps/LinuxPACom/common.sh")
+	btys, _ := ioutil.ReadAll(fil)
+	buf.SetText(string(btys))
+}
+
+func getLabel(name string) *gtk.Label {
+	lbl, _ := gtk.LabelNew(name)
+	return lbl
+}

setup.go

@@ -3,20 +3,25 @@ package main
 import (
 	"bufio"
 	"fmt"
-	"image"
-	"image/draw"
 	_ "image/png"
 	"os"
+	"os/exec"
 	"reflect"
 	"sort"
 	"strings"
 
-	"github.com/nelsam/gxui"
+	"github.com/gotk3/gotk3/gdk"
+	"github.com/gotk3/gotk3/gtk"
 )
 
-const ()
-
 func setup() {
+	if _, err := os.Open("PortableApps/LinuxPACom/Wine"); os.IsNotExist(err) {
+		if _, errd := exec.LookPath("wine"); errd == nil {
+			wineAvail = true
+		}
+	} else if err == nil {
+		wineAvail = true
+	}
 	PortableAppsFold, err := os.Open("PortableApps")
 	if PAStat, _ := PortableAppsFold.Stat(); err != nil || !PAStat.IsDir() {
 		os.Mkdir("PortableApps", 0777)
@@ -33,28 +38,9 @@ func setup() {
 	if err == nil {
 		comEnbld = true
 	}
-	fi, err := os.Open("PortableApps/LinuxPACom/Info.ini")
+	_, err = os.Open("PortableApps/LinuxPACom/Info.ini")
 	if err != nil {
-		fi, err = os.Create("PortableApps/LinuxPACom/Info.ini")
-		if err == nil {
-			wrt := bufio.NewWriter(fi)
-			wrt.WriteString(defIni)
-			wrt.Flush()
-		}
-	}
-	if err == nil {
-		rdr := bufio.NewReader(fi)
-		for err != nil {
-			ln, _, error := rdr.ReadLine()
-			err = error
-			str := string(ln)
-			if strings.HasPrefix(str, "theme=") {
-				str = strings.TrimPrefix(str, "theme=")
-				if str == "lt" {
-					darkTheme = false
-				}
-			}
-		}
+		os.Create("PortableApps/LinuxPACom/Info.ini")
 	}
 	PAFolds, _ := PortableAppsFold.Readdirnames(-1)
 	sort.Strings(PAFolds)
@@ -157,8 +143,8 @@ func getName(ini *os.File) string {
 	return ret
 }
 
-func getIcon(fold string) gxui.Texture {
-	var pic *os.File
+func getIcon(fold string) *gdk.Pixbuf {
+	var pic string
 	if folder, err := os.Open(fold + "/App/AppInfo"); err == nil {
 		fis, _ := folder.Readdir(-1)
 		var pics []string
@@ -175,21 +161,18 @@ func getIcon(fold string) gxui.Texture {
 			} else {
 				ind = sort.SearchStrings(pics, "appicon_32.png")
 			}
-			pic, _ = os.Open(fold + "/App/AppInfo/" + pics[ind])
+			pic = fold + "/App/AppInfo/" + pics[ind]
 		}
-	} else if fi, err := os.Open(fold + "/appicon.png"); err == nil {
-		pic = fi
+	} else if _, err := os.Open(fold + "/appicon.png"); err == nil {
+		pic = fold + "/appicon.png"
 	} else {
-		return nil
+		img, _ := gtk.ImageNewFromIconName("application-x-executable", gtk.ICON_SIZE_BUTTON)
+		buf, _ := img.GetPixbuf().ScaleSimple(32, 32, gdk.INTERP_BILINEAR)
+		return buf
 	}
-	img, _, err := image.Decode(pic)
-	if err != nil {
-		return nil
-	}
-	rgba := image.NewRGBA(img.Bounds())
-	draw.Draw(rgba, img.Bounds(), img, image.ZP, draw.Src)
-	ret := dr.CreateTexture(rgba, 1)
-	return ret
+	img, _ := gtk.ImageNewFromFile(pic)
+	buf, _ := img.GetPixbuf().ScaleSimple(32, 32, gdk.INTERP_BILINEAR)
+	return buf
 }
 
 func findInfo(fold string) *os.File {

ui.go

@@ -1,66 +1,136 @@
 package main
 
 import (
-	"os"
-	"os/exec"
+	"fmt"
 
-	"github.com/nelsam/gxui"
+	"github.com/gotk3/gotk3/glib"
+	"github.com/gotk3/gotk3/gtk"
 )
 
-func ui() {
-	catListAdap := &StrList{}
-	appListAdap := &catAdap{}
-	catListAdap.SetStrings(lin)
-	win := th.CreateWindow(500, 500, "LinuxPA")
-	top := th.CreateLinearLayout()
-	top.SetDirection(gxui.BottomToTop)
-	splBox := th.CreateLinearLayout()
-	spl := th.CreateSplitterLayout()
-	spl.SetOrientation(gxui.Horizontal)
-	catList := th.CreateList()
-	catList.SetAdapter(catListAdap)
-	catList.OnSelectionChanged(func(it gxui.AdapterItem) {
-		appListAdap.setCat(it.(string))
+func ui(win *gtk.Window) {
+	ls := getCatRows()
+	var treeApps []*gtk.TreeIter
+	header, _ := gtk.HeaderBarNew()
+	header.SetShowCloseButton(true)
+	header.SetTitle("LinuxPA")
+	header.SetSubtitle("PortableApps.com type launcher")
+	settings, _ := gtk.ButtonNewFromIconName("applications-system", gtk.ICON_SIZE_SMALL_TOOLBAR)
+	settings.Connect("clicked", func() {
+		settingsUI()
 	})
-	appList := th.CreateTree()
-	appList.SetAdapter(appListAdap)
-	spl.AddChild(catList)
-	spl.AddChild(appList)
-	splBox.AddChild(spl)
-	butBox := th.CreateLinearLayout()
-	butBox.SetDirection(gxui.LeftToRight)
-	if _, err := exec.LookPath("wine"); err == nil {
-		wineBut := th.CreateButton()
-		wineBut.SetType(gxui.ToggleButton)
-		wineBut.SetChecked(wine)
-		wineBut.SetText("Show Windows Apps")
-		wineBut.OnClick(func(gxui.MouseEvent) {
-			wine = wineBut.IsChecked()
-			appListAdap.refresh()
-			if wineBut.IsChecked() {
-				catListAdap.SetStrings(cats)
-				wineBut.SetText("Hide Windows Apps")
+	settings.SetTooltipText("Settings (Coming Soon!)")
+	header.PackStart(settings)
+	win.SetTitlebar(header)
+	topLvl, _ := gtk.BoxNew(gtk.ORIENTATION_VERTICAL, 0)
+	lrBox, _ := gtk.BoxNew(gtk.ORIENTATION_HORIZONTAL, 5)
+	catList, _ := gtk.ListBoxNew()
+	catList.SetActivateOnSingleClick(true)
+	store, _ := gtk.TreeStoreNew(glib.TYPE_OBJECT, glib.TYPE_STRING)
+	appsList, _ := gtk.TreeViewNewWithModel(store)
+	render, _ := gtk.CellRendererPixbufNew()
+	pixColumn, _ := gtk.TreeViewColumnNewWithAttribute("", render, "pixbuf", 0)
+	txtRender, _ := gtk.CellRendererTextNew()
+	txtColumn, _ := gtk.TreeViewColumnNewWithAttribute("", txtRender, "text", 1)
+	appsList.AppendColumn(pixColumn)
+	appsList.AppendColumn(txtColumn)
+	appsList.SetHeadersVisible(false)
+	catList.SetHExpand(true)
+	catList.SetVExpand(true)
+	appsList.SetHExpand(true)
+	appsList.SetVExpand(true)
+	vScrollCat, _ := gtk.AdjustmentNew(0, 0, 0, 0, 0, 0)
+	hScrollCat, _ := gtk.AdjustmentNew(0, 0, 0, 0, 0, 0)
+	vScrollApp, _ := gtk.AdjustmentNew(0, 0, 0, 0, 0, 0)
+	hScrollApp, _ := gtk.AdjustmentNew(0, 0, 0, 0, 0, 0)
+	catScrl, _ := gtk.ScrolledWindowNew(hScrollCat, vScrollCat)
+	catScrl.Add(catList)
+	catScrl.SetSizeRequest(170, 500)
+	appScrl, _ := gtk.ScrolledWindowNew(hScrollApp, vScrollApp)
+	appScrl.Add(appsList)
+	appScrl.SetSizeRequest(300, 500)
+	lrBox.Add(catScrl)
+	lrBox.Add(appScrl)
+	botBox, _ := gtk.BoxNew(gtk.ORIENTATION_HORIZONTAL, 2)
+	wineCheck, _ := gtk.CheckButtonNewWithLabel("Show Windows apps (Wine)")
+	if !wineAvail {
+		wineCheck.SetSensitive(false)
+		wineCheck.SetTooltipText("Download wine to run windows apps")
+	}
+	wineCheck.Connect("toggled", func() {
+		wine = wineCheck.GetActive()
+		for i := range ls {
+			catList.Remove(catList.GetRowAtIndex(i))
+		}
+		ls = getCatRows()
+		for _, v := range ls {
+			catList.Add(v)
+		}
+		catList.ShowAll()
+	})
+	botBox.Add(wineCheck)
+	topLvl.Add(lrBox)
+	topLvl.PackEnd(botBox, false, true, 0)
+	win.Add(topLvl)
+	for _, v := range ls {
+		catList.Prepend(v)
+	}
+	catList.Connect("row-selected", func() {
+		store.Clear()
+		if catList.GetSelectedRow().GetIndex() >= 0 {
+			treeApps = make([]*gtk.TreeIter, 0)
+			if wine {
+				apps := master[cats[catList.GetSelectedRow().GetIndex()]]
+				for _, v := range apps {
+					treeApps = append(treeApps, v.getTreeIter(store))
+				}
 			} else {
-				catListAdap.SetStrings(lin)
-				wineBut.SetText("Show Windows Apps")
+				apps := linmaster[lin[catList.GetSelectedRow().GetIndex()]]
+				for _, v := range apps {
+					treeApps = append(treeApps, v.getTreeIter(store))
+				}
+			}
 		}
 	})
-		_, err := os.Open("Start.exe")
-		if err == nil {
-			pa := th.CreateButton()
-			pa.SetText("Open PortableApps Launcher")
-			pa.OnClick(func(gxui.MouseEvent) {
-				cmd := exec.Command("wine", "Start.exe")
-				cmd.Stdout = os.Stdout
-				cmd.Stderr = os.Stderr
-				cmd.Start()
+	appsList.Connect("row-activated", func() {
+		selec, _ := appsList.GetSelection()
+		_, it, ok := selec.GetSelected()
+		if ok {
+			pth, _ := store.GetPath(it)
+			ind := pth.GetIndices()
+			if len(ind) == 1 {
+				if wine {
+					app := master[cats[catList.GetSelectedRow().GetIndex()]][ind[0]]
+					app.launch()
+				} else {
+					app := linmaster[lin[catList.GetSelectedRow().GetIndex()]][ind[0]]
+					app.launch()
+				}
+			} else if len(ind) == 2 {
+				if wine {
+					app := master[cats[catList.GetSelectedRow().GetIndex()]][ind[0]]
+					app.launchSub(ind[1])
+				} else {
+					app := linmaster[lin[catList.GetSelectedRow().GetIndex()]][ind[0]]
+					app.launchSub(ind[1])
+				}
+			}
+		}
 	})
-			butBox.AddChild(pa)
 }
-		butBox.AddChild(wineBut)
+
+func getCatRows() (out []*gtk.Label) {
+	if wine {
+		for _, v := range cats {
+			txt, _ := gtk.LabelNew(v)
+			out = append(out, txt)
+			fmt.Println(v)
 		}
-	top.AddChild(butBox)
-	top.AddChild(splBox)
-	win.AddChild(top)
-	win.OnClose(dr.Terminate)
+	} else {
+		for _, v := range lin {
+			txt, _ := gtk.LabelNew(v)
+			out = append(out, txt)
+			fmt.Println(v)
+		}
+	}
+	return
 }

update.go

@@ -6,8 +6,11 @@ import (
 	"io"
 	"net/http"
 	"os"
+	"os/exec"
 	"strconv"
 	"strings"
+
+	"github.com/gotk3/gotk3/gtk"
 )
 
 const (
@@ -19,15 +22,12 @@ const (
 //For some of the code
 
 //Returns if success
-func versionDL() bool {
-	versionFile, err := os.Open("PortableApps/LinuxPACom/Version")
+func versionDL() (bool, error) {
+	versionFile, err := os.Create("PortableApps/LinuxPACom/Version")
 	if err != nil {
-		versionFile, err = os.Create("PortableApps/LinuxPACom/Version")
-		if err != nil {
-			return false
+		return false, err
 	}
-	}
-	defer versionFile.Close()
+	versionFile.Chmod(0777)
 	check := http.Client{
 		CheckRedirect: func(r *http.Request, via []*http.Request) error {
 			r.URL.Opaque = r.URL.Path
@@ -35,15 +35,14 @@ func versionDL() bool {
 		},
 	}
 	response, err := check.Get(versionURL)
-	defer response.Body.Close()
 	if err != nil {
-		return false
+		return false, err
 	}
 	_, err = io.Copy(versionFile, response.Body)
 	if err != nil {
-		return false
+		return false, err
 	}
-	return true
+	return true, nil
 }
 
 func getVersionFileInfo() string {
@@ -56,7 +55,7 @@ func getVersionFileInfo() string {
 	return string(out)
 }
 
-func checkForUpdate(new string) bool {
+func checkForUpdate(new string) (bool, error) {
 	curSlice := strings.Split(version, ".")
 	newSlice := strings.Split(new, ".")
 	curNums := make([]int, 4)
@@ -69,26 +68,30 @@ func checkForUpdate(new string) bool {
 		num, err = strconv.Atoi(newSlice[i])
 		if err == nil {
 			newNums[i] = num
+		} else {
+			return false, err
 		}
 		if newNums[i] > curNums[i] {
-			return true
+			return true, nil
+		} else if curNums[i] > newNums[i] {
+			return false, nil
 		}
 	}
-	return false
+	return false, nil
 }
 
-func downloadUpdate(newVersion string) bool {
+func downloadUpdate(newVersion string) (bool, error) {
 	url := strings.Replace(downloadURL, "XXX", newVersion, -1)
 	err := os.Rename("LinuxPA", ".LinuxPA.old")
 	if err != nil {
-		fmt.Println(err)
-		return false
+		return false, err
 	}
 	fil, err := os.Create("LinuxPA")
+	fil.Chmod(0777)
 	defer fil.Close()
 	if err != nil {
 		os.Rename(".LinuxPA.old", "LinuxPA")
-		return false
+		return false, err
 	}
 	check := http.Client{
 		CheckRedirect: func(r *http.Request, via []*http.Request) error {
@@ -97,13 +100,57 @@ func downloadUpdate(newVersion string) bool {
 		},
 	}
 	re, err := check.Get(url)
-	defer re.Body.Close()
 	if err != nil {
-		return false
+		return false, err
 	}
+	defer re.Body.Close()
 	_, err = io.Copy(fil, re.Body)
 	if err != nil {
-		return false
+		return false, err
 	}
-	return true
+	return true, nil
+}
+
+func update(win *gtk.Window) {
+	updateWin, _ := gtk.WindowNew(gtk.WINDOW_POPUP)
+	updateWin.SetTransientFor(win)
+	topLvl, _ := gtk.BoxNew(gtk.ORIENTATION_VERTICAL, 5)
+	spin, _ := gtk.SpinnerNew()
+	spin.Start()
+	lbl, _ := gtk.LabelNew("Checking for updates")
+	topLvl.Add(spin)
+	topLvl.Add(lbl)
+	topLvl.SetMarginBottom(10)
+	topLvl.SetMarginEnd(10)
+	topLvl.SetMarginStart(10)
+	topLvl.SetMarginTop(10)
+	updateWin.SetPosition(gtk.WIN_POS_CENTER_ON_PARENT)
+	updateWin.Add(topLvl)
+	updateWin.ShowAll()
+	updateWin.Show()
+	go func(win, updateWin *gtk.Window) {
+		defer updateWin.Close()
+		stat, err := versionDL()
+		if stat {
+			res := getVersionFileInfo()
+			if res != "Error!" {
+				stat, err = checkForUpdate(res)
+				if stat {
+					lbl.SetText("Updating!")
+					downloadUpdate(res)
+					win.Close()
+					cmd := exec.Command("./LinuxPA")
+					cmd.Stdin = os.Stdin
+					cmd.Stdout = os.Stdout
+					cmd.Start()
+				} else {
+					fmt.Println(err)
+				}
+			} else {
+				fmt.Println("Failed Version File Info")
+			}
+		} else {
+			fmt.Println(err)
+		}
+	}(win, updateWin)
 }

wine.go

@@ -0,0 +1,101 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"strings"
+
+	"github.com/gotk3/gotk3/gtk"
+	"github.com/mholt/archiver"
+)
+
+const (
+	wineURL = "https://www.playonlinux.com/wine/binaries/linux-amd64/PlayOnLinux-wine-2.5-linux-amd64.pol"
+)
+
+func downloadWine(parent *gtk.Window, cb chan bool) {
+	win, _ := gtk.WindowNew(gtk.WINDOW_TOPLEVEL)
+	win.SetTransientFor(parent)
+	spin, _ := gtk.SpinnerNew()
+	spin.Start()
+	txt, _ := gtk.LabelNew("Downloading Wine")
+	box, _ := gtk.BoxNew(gtk.ORIENTATION_VERTICAL, 5)
+	box.SetMarginBottom(10)
+	box.SetMarginEnd(10)
+	box.SetMarginStart(10)
+	box.SetMarginTop(10)
+	box.Add(spin)
+	box.Add(txt)
+	win.Add(box)
+	win.SetPosition(gtk.WIN_POS_CENTER_ON_PARENT)
+	win.ShowAll()
+	win.Show()
+	go func(win *gtk.Window) {
+		defer win.Close()
+		wineTar, err := os.Create("PortableApps/LinuxPACom/wine2.5.tar.bz2")
+		if err != nil {
+			fmt.Println(err)
+			cb <- false
+			return
+		}
+		wineTar.Chmod(0777)
+		defer wineTar.Close()
+		check := http.Client{
+			CheckRedirect: func(r *http.Request, via []*http.Request) error {
+				r.URL.Opaque = r.URL.Path
+				return nil
+			},
+		}
+		resp, err := check.Get(wineURL)
+		if err != nil {
+			fmt.Println(err)
+			cb <- false
+			return
+		}
+		defer resp.Body.Close()
+		_, err = io.Copy(wineTar, resp.Body)
+		if err != nil {
+			fmt.Println(err)
+			cb <- false
+			return
+		}
+		txt.SetText("Extracting Wine")
+		os.RemoveAll("PortableApps/LinuxPACom/Wine")
+		err = archiver.TarBz2.Open("PortableApps/LinuxPACom/wine2.5.tar.bz2", "PortableApps/LinuxPACom/Wine")
+		if err != nil {
+			fmt.Println(err)
+			cb <- false
+			return
+		}
+		os.Remove("PortableApps/LinuxPACom/wine2.5.tar.bz2")
+		fil, err := os.Open("PortableApps/LinuxPACom/common.sh")
+		if err != nil {
+			fmt.Println(err)
+			cb <- false
+			return
+		}
+		tmp, err := ioutil.ReadAll(fil)
+		if err != nil {
+			fmt.Println(err)
+			cb <- false
+			return
+		}
+		fmt.Println("Hello")
+		if !strings.Contains(string(tmp), "export PATH=$PWD/PortableApps/LinuxPACom/Wine/wineversion/2.5/bin:$PATH") {
+			tmp = append(tmp, []byte("\nexport PATH=$PWD/PortableApps/LinuxPACom/Wine/wineversion/2.5/bin:$PATH")...)
+			ioutil.WriteFile("PortableApps/LinuxPACom/common.sh", tmp, 0777)
+			fmt.Println("Hello2")
+			if err != nil {
+				fmt.Println(err)
+				cb <- false
+				return
+			}
+		}
+		fmt.Println("HelloT")
+		cb <- true
+		return
+	}(win)
+}