clockworkpi/LauncherGoDev
1
0
Fork 0
mirror of https://github.com/clockworkpi/LauncherGoDev.git synced 2026-09-04 04:24:35 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

go fmt ./...

Browse Source
This commit is contained in:
cuu
2021-10-11 13:55:54 +08:00
parent 0fe6399441
commit 7382cc40b1
88 changed files with 10028 additions and 10478 deletions
Download Patch File Download Diff File Expand all files Collapse all files

345
Menu/GameShell/10_Settings/About/about.go
View File

@@ -4,22 +4,20 @@ import (
"fmt" "fmt"
"strconv" "strconv"
"strings"
"os/exec" "os/exec"
"strings"
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/surface" "github.com/cuu/gogame/color"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/surface"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
) )
type InfoPageListItem struct{ type InfoPageListItem struct {
UI.Widget UI.Widget
Labels map[string]UI.LabelInterface Labels map[string]UI.LabelInterface
Icons map[string]UI.IconItemInterface Icons map[string]UI.IconItemInterface
@@ -27,17 +25,17 @@ type InfoPageListItem struct{
Parent UI.PageInterface Parent UI.PageInterface
Flag string Flag string
} }
func NewInfoPageListItem() *InfoPageListItem { func NewInfoPageListItem() *InfoPageListItem {
i := &InfoPageListItem{} i := &InfoPageListItem{}
i.Labels = make(map[string]UI.LabelInterface) i.Labels = make(map[string]UI.LabelInterface)
i.Icons = make( map[string]UI.IconItemInterface) i.Icons = make(map[string]UI.IconItemInterface)
i.Fonts = make(map[string]*ttf.Font) i.Fonts = make(map[string]*ttf.Font)
i.Height = 20 i.Height = 20
i.Width = 0 i.Width = 0
return i return i
} }
@@ -46,58 +44,57 @@ func (self *InfoPageListItem) Init(text string) {
l := UI.NewLabel() l := UI.NewLabel()
l.PosX = 10 l.PosX = 10
l.SetCanvasHWND(self.Parent.GetCanvasHWND()) l.SetCanvasHWND(self.Parent.GetCanvasHWND())
l.Init(text,self.Fonts["normal"],nil) l.Init(text, self.Fonts["normal"], nil)
self.Labels["Text"] = l self.Labels["Text"] = l
} }
func (self *InfoPageListItem) SetSmallText( text string) { func (self *InfoPageListItem) SetSmallText(text string) {
l := UI.NewMultiLabel() l := UI.NewMultiLabel()
l.SetCanvasHWND(self.Parent.GetCanvasHWND()) l.SetCanvasHWND(self.Parent.GetCanvasHWND())
l.Init(text,self.Fonts["small"],nil) l.Init(text, self.Fonts["small"], nil)
self.Labels["Small"] = l self.Labels["Small"] = l
_,h_ := self.Labels["Small"].Size() _, h_ := self.Labels["Small"].Size()
if h_>= self.Height { if h_ >= self.Height {
self.Height = h_ + 10 self.Height = h_ + 10
} }
} }
func (self *InfoPageListItem) Draw() { func (self *InfoPageListItem) Draw() {
x_,_ := self.Labels["Text"].Coord() x_, _ := self.Labels["Text"].Coord()
self.Labels["Text"].NewCoord(x_,self.PosY) self.Labels["Text"].NewCoord(x_, self.PosY)
self.Labels["Text"].Draw() self.Labels["Text"].Draw()
if _, ok := self.Labels["Small"]; ok { if _, ok := self.Labels["Small"]; ok {
w_,_ := self.Labels["Text"].Size() w_, _ := self.Labels["Text"].Size()
self.Labels["Small"].NewCoord(w_+16,self.PosY) self.Labels["Small"].NewCoord(w_+16, self.PosY)
self.Labels["Small"].Draw() self.Labels["Small"].Draw()
} }
} }
type AboutPage struct { type AboutPage struct {
UI.Page UI.Page
AList map[string]map[string]string AList map[string]map[string]string
ListFontObj *ttf.Font ListFontObj *ttf.Font
Scrolled int Scrolled int
BGwidth int BGwidth int
BGheight int BGheight int
DrawOnce bool DrawOnce bool
Scroller *UI.ListScroller Scroller *UI.ListScroller
MyList []*InfoPageListItem MyList []*InfoPageListItem
Icons map[string]UI.IconItemInterface Icons map[string]UI.IconItemInterface
} }
func NewAboutPage() *AboutPage { func NewAboutPage() *AboutPage {
p := &AboutPage{} p := &AboutPage{}
p.FootMsg = [5]string{"Nav","","","Back",""} p.FootMsg = [5]string{"Nav", "", "", "Back", ""}
p.AList = make(map[string]map[string]string) p.AList = make(map[string]map[string]string)
@@ -105,13 +102,13 @@ func NewAboutPage() *AboutPage {
p.BGheight = 300 p.BGheight = 300
p.DrawOnce = false p.DrawOnce = false
p.MyList = make([]*InfoPageListItem,0) p.MyList = make([]*InfoPageListItem, 0)
p.ListFontObj = UI.Fonts["varela13"] p.ListFontObj = UI.Fonts["varela13"]
p.Index = 0 p.Index = 0
p.Icons = make(map[string]UI.IconItemInterface) p.Icons = make(map[string]UI.IconItemInterface)
return p return p
} }
@@ -122,7 +119,7 @@ func (self *AboutPage) Uname() {
out["key"] = "uname" out["key"] = "uname"
out["label"] = "Kernel:" out["label"] = "Kernel:"
out_bytes, err := exec.Command("uname","-srmo").Output() out_bytes, err := exec.Command("uname", "-srmo").Output()
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
out["value"] = "" out["value"] = ""
@@ -130,144 +127,142 @@ func (self *AboutPage) Uname() {
out_str := strings.Trim(string(out_bytes), "\t\n") out_str := strings.Trim(string(out_bytes), "\t\n")
out["value"]= out_str out["value"] = out_str
self.AList["uname"] = out self.AList["uname"] = out
} }
func (self *AboutPage) CpuMhz() { func (self *AboutPage) CpuMhz() {
lines, err := UI.ReadLines("/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq") lines, err := UI.ReadLines("/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq")
UI.ShowErr(err)
mhz ,err := strconv.ParseInt(lines[0], 10, 64)
UI.ShowErr(err) UI.ShowErr(err)
mhz_float := float64(mhz)/1000.0
out := make(map[string]string) mhz, err := strconv.ParseInt(lines[0], 10, 64)
out["key"] = "cpuscalemhz" UI.ShowErr(err)
out["label"]="CPU Mhz:" mhz_float := float64(mhz) / 1000.0
out["value"] = strconv.FormatFloat(mhz_float, 'f', 2, 64)
self.AList["cpuscalemhz"] = out out := make(map[string]string)
out["key"] = "cpuscalemhz"
out["label"] = "CPU Mhz:"
out["value"] = strconv.FormatFloat(mhz_float, 'f', 2, 64)
self.AList["cpuscalemhz"] = out
} }
func (self *AboutPage) CpuInfo() { func (self *AboutPage) CpuInfo() {
last_processor := 0 last_processor := 0
if UI.FileExists("/proc/cpuinfo") == false { if UI.FileExists("/proc/cpuinfo") == false {
return return
} }
cpuinfos,err := UI.ReadLines("/proc/cpuinfo") cpuinfos, err := UI.ReadLines("/proc/cpuinfo")
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
for _,v := range cpuinfos { for _, v := range cpuinfos {
if strings.HasPrefix(v,"processor") { if strings.HasPrefix(v, "processor") {
parts := strings.Split(v,":") parts := strings.Split(v, ":")
if cur_processor_number,err := strconv.Atoi(strings.Trim(parts[1],"\r\n ")); err == nil { if cur_processor_number, err := strconv.Atoi(strings.Trim(parts[1], "\r\n ")); err == nil {
if cur_processor_number > last_processor { if cur_processor_number > last_processor {
last_processor = cur_processor_number last_processor = cur_processor_number
} }
}else { } else {
fmt.Println(err) fmt.Println(err)
} }
} }
if strings.HasPrefix(v, "model name") {
parts := strings.Split(v, ":")
processor := make(map[string]string)
processor["key"] = "processor"
processor["label"] = "Processor:"
processor["value"] = strings.Trim(parts[1], "\r\n ")
self.AList["processor"] = processor
}
if strings.HasPrefix(v,"model name") { if strings.HasPrefix(v, "cpu MHz") {
parts := strings.Split(v,":") parts := strings.Split(v, ":")
processor := make(map[string]string) cpumhz := make(map[string]string)
processor["key"] = "processor" cpumhz["key"] = "cpumhz"
processor["label"] = "Processor:" cpumhz["label"] = "CPU MHz:"
processor["value"] = strings.Trim(parts[1],"\r\n ") cpumhz["value"] = strings.Trim(parts[1], "\r\n ")
self.AList["processor"] = processor self.AList["cpumhz"] = cpumhz
} }
if strings.HasPrefix(v,"cpu MHz") { if strings.HasPrefix(v, "cpu cores") {
parts := strings.Split(v,":") parts := strings.Split(v, ":")
cpumhz := make(map[string]string) cpucores := make(map[string]string)
cpumhz["key"] = "cpumhz" cpucores["key"] = "cpucores"
cpumhz["label"] = "CPU MHz:" cpucores["label"] = "CPU cores:"
cpumhz["value"] = strings.Trim(parts[1],"\r\n ") cpucores["value"] = strings.Trim(parts[1], "\r\n ")
self.AList["cpumhz"] = cpumhz self.AList["cpucores"] = cpucores
} }
if strings.HasPrefix(v,"cpu cores") { if strings.HasPrefix(v, "Features") {
parts := strings.Split(v,":") parts := strings.Split(v, ":")
cpucores := make(map[string]string) f_ := make(map[string]string)
cpucores["key"] = "cpucores" f_["key"] = "features"
cpucores["label"] = "CPU cores:" f_["label"] = "Features:"
cpucores["value"] = strings.Trim(parts[1],"\r\n ") f_["value"] = strings.Trim(parts[1], "\r\n ")
self.AList["cpucores"] = cpucores self.AList["features"] = f_
} }
if strings.HasPrefix(v,"Features") { if strings.HasPrefix(v, "flags") {
parts := strings.Split(v,":") parts := strings.Split(v, ":")
f_ := make(map[string]string) flags := make(map[string]string)
f_["key"] = "features" flags["key"] = "flags"
f_["label"] = "Features:" flags["label"] = "Flags:"
f_["value"] = strings.Trim(parts[1],"\r\n ") flags["value"] = strings.TrimSpace(parts[1])
self.AList["features"] = f_ self.AList["flags"] = flags
} }
}
if strings.HasPrefix(v,"flags") { if last_processor > 0 {
parts := strings.Split(v,":") arm_cores := make(map[string]string)
flags := make(map[string]string) arm_cores["key"] = "armcores"
flags["key"] = "flags" arm_cores["label"] = "CPU cores:"
flags["label"] = "Flags:" arm_cores["value"] = strconv.Itoa(last_processor + 1)
flags["value"] = strings.TrimSpace(parts[1])
self.AList["flags"] = flags
}
}
if last_processor > 0 { self.AList["armcores"] = arm_cores
arm_cores := make(map[string]string) }
arm_cores["key"]= "armcores"
arm_cores["label"] = "CPU cores:"
arm_cores["value"] = strconv.Itoa(last_processor + 1)
self.AList["armcores"] = arm_cores
}
} }
func (self *AboutPage) MemInfo() { func (self *AboutPage) MemInfo() {
lines, err := UI.ReadLines("/proc/meminfo") lines, err := UI.ReadLines("/proc/meminfo")
UI.ShowErr(err) UI.ShowErr(err)
for _,line := range lines { for _, line := range lines {
if strings.HasPrefix(line,"MemTotal") { if strings.HasPrefix(line, "MemTotal") {
parts := strings.Split(line,":") parts := strings.Split(line, ":")
kb := strings.Replace(parts[1],"KB","",-1) kb := strings.Replace(parts[1], "KB", "", -1)
kb = strings.Replace(kb,"kB","",-1) kb = strings.Replace(kb, "kB", "", -1)
kb = strings.TrimSpace(kb) kb = strings.TrimSpace(kb)
kb_int,_ := strconv.ParseInt(kb,10,64) kb_int, _ := strconv.ParseInt(kb, 10, 64)
kb_float := float64(kb_int)/1000.0 kb_float := float64(kb_int) / 1000.0
memory := make(map[string]string) memory := make(map[string]string)
memory["key"] = "memory" memory["key"] = "memory"
memory["label"] = "Memory:" memory["label"] = "Memory:"
memory["value"] = strconv.FormatFloat(kb_float,'f',2,64) + " MB" memory["value"] = strconv.FormatFloat(kb_float, 'f', 2, 64) + " MB"
self.AList["memory"] = memory self.AList["memory"] = memory
break break
} }
} }
} }
func (self *AboutPage) GenList() { func (self *AboutPage) GenList() {
self.MyList = nil self.MyList = nil
self.MyList = make([]*InfoPageListItem,0) self.MyList = make([]*InfoPageListItem, 0)
start_x := 0 start_x := 0
start_y := 10 start_y := 10
last_height := 0 last_height := 0
for _,u := range ( []string{"processor","armcores","cpuscalemhz","features","memory","uname"} ) { for _, u := range []string{"processor", "armcores", "cpuscalemhz", "features", "memory", "uname"} {
if val, ok := self.AList[u]; ok { if val, ok := self.AList[u]; ok {
li := NewInfoPageListItem() li := NewInfoPageListItem()
li.Parent = self li.Parent = self
@@ -277,48 +272,46 @@ func (self *AboutPage) GenList() {
li.Fonts["normal"] = self.ListFontObj li.Fonts["normal"] = self.ListFontObj
li.Fonts["small"] = UI.Fonts["varela12"] li.Fonts["small"] = UI.Fonts["varela12"]
if self.AList[u]["label"] != "" { if self.AList[u]["label"] != "" {
li.Init( self.AList[u]["label"] ) li.Init(self.AList[u]["label"])
}else { } else {
li.Init( self.AList[u]["key"]) li.Init(self.AList[u]["key"])
} }
li.Flag = val["key"] li.Flag = val["key"]
li.SetSmallText(val["value"]) li.SetSmallText(val["value"])
last_height += li.Height last_height += li.Height
self.MyList = append(self.MyList,li) self.MyList = append(self.MyList, li)
} }
} }
} }
func (self *AboutPage) Init() { func (self *AboutPage) Init() {
if self.Screen != nil { if self.Screen != nil {
if self.Screen.CanvasHWND != nil && self.CanvasHWND == nil { if self.Screen.CanvasHWND != nil && self.CanvasHWND == nil {
self.HWND = self.Screen.CanvasHWND self.HWND = self.Screen.CanvasHWND
self.CanvasHWND = surface.Surface(self.Screen.Width,self.BGheight) self.CanvasHWND = surface.Surface(self.Screen.Width, self.BGheight)
} }
self.PosX = self.Index * self.Screen.Width self.PosX = self.Index * self.Screen.Width
self.Width = self.Screen.Width self.Width = self.Screen.Width
self.Height = self.Screen.Height self.Height = self.Screen.Height
bgpng := UI.NewIconItem() bgpng := UI.NewIconItem()
bgpng.ImgSurf = UI.MyIconPool.GetImgSurf("about_bg") bgpng.ImgSurf = UI.MyIconPool.GetImgSurf("about_bg")
bgpng.MyType = UI.ICON_TYPES["STAT"] bgpng.MyType = UI.ICON_TYPES["STAT"]
bgpng.Parent = self bgpng.Parent = self
bgpng.Adjust(0,0,self.BGwidth,self.BGheight,0) bgpng.Adjust(0, 0, self.BGwidth, self.BGheight, 0)
self.Icons["bg"] = bgpng
self.Icons["bg"] = bgpng
self.CpuInfo() self.CpuInfo()
self.MemInfo() self.MemInfo()
self.CpuMhz() self.CpuMhz()
self.Uname() self.Uname()
self.GenList() self.GenList()
@@ -336,7 +329,7 @@ func (self *AboutPage) Init() {
func (self *AboutPage) ScrollDown() { func (self *AboutPage) ScrollDown() {
dis := 10 dis := 10
if UI.Abs(self.Scrolled) < ( self.BGheight - self.Height)/2 + 50 { if UI.Abs(self.Scrolled) < (self.BGheight-self.Height)/2+50 {
self.PosY -= dis self.PosY -= dis
self.Scrolled -= dis self.Scrolled -= dis
} }
@@ -352,7 +345,7 @@ func (self *AboutPage) ScrollUp() {
func (self *AboutPage) OnLoadCb() { func (self *AboutPage) OnLoadCb() {
self.Scrolled = 0 self.Scrolled = 0
self.PosY = 0 self.PosY = 0
self.DrawOnce = false self.DrawOnce = false
} }
@@ -362,8 +355,7 @@ func (self *AboutPage) OnReturnBackCb() {
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
func (self *AboutPage) KeyDown(ev *event.Event) {
func (self *AboutPage) KeyDown( ev *event.Event) {
if ev.Data["Key"] == UI.CurKeys["A"] || ev.Data["Key"] == UI.CurKeys["Menu"] { if ev.Data["Key"] == UI.CurKeys["A"] || ev.Data["Key"] == UI.CurKeys["Menu"] {
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
self.Screen.Draw() self.Screen.Draw()
@@ -384,16 +376,15 @@ func (self *AboutPage) KeyDown( ev *event.Event) {
} }
func (self *AboutPage) Draw() { func (self *AboutPage) Draw() {
if self.DrawOnce == false { if self.DrawOnce == false {
self.ClearCanvas() self.ClearCanvas()
self.Icons["bg"].NewCoord(self.Width/2, self.Height/2 + (self.BGheight - UI.Height)/2 + self.Screen.TitleBar.Height) self.Icons["bg"].NewCoord(self.Width/2, self.Height/2+(self.BGheight-UI.Height)/2+self.Screen.TitleBar.Height)
self.Icons["bg"].Draw() self.Icons["bg"].Draw()
for _,v := range self.MyList { for _, v := range self.MyList {
v.Draw() v.Draw()
} }
@@ -401,33 +392,31 @@ func (self *AboutPage) Draw() {
} }
if self.HWND != nil { if self.HWND != nil {
surface.Fill(self.HWND, &color.Color{255,255,255,255}) surface.Fill(self.HWND, &color.Color{255, 255, 255, 255})
rect_ := rect.Rect(self.PosX,self.PosY,self.Width,self.Height) rect_ := rect.Rect(self.PosX, self.PosY, self.Width, self.Height)
surface.Blit(self.HWND,self.CanvasHWND,&rect_, nil) surface.Blit(self.HWND, self.CanvasHWND, &rect_, nil)
self.Scroller.UpdateSize(self.BGheight,UI.Abs(self.Scrolled)*3) self.Scroller.UpdateSize(self.BGheight, UI.Abs(self.Scrolled)*3)
self.Scroller.Draw() self.Scroller.Draw()
} }
} }
/******************************************************************************/ /******************************************************************************/
type AboutPlugin struct { type AboutPlugin struct {
UI.Plugin UI.Plugin
Page UI.PageInterface Page UI.PageInterface
} }
func (self *AboutPlugin) Init(main_screen *UI.MainScreen) {
func (self *AboutPlugin) Init( main_screen *UI.MainScreen ) {
self.Page = NewAboutPage() self.Page = NewAboutPage()
self.Page.SetScreen( main_screen) self.Page.SetScreen(main_screen)
self.Page.SetName("About") self.Page.SetName("About")
self.Page.Init() self.Page.Init()
} }
func (self *AboutPlugin) Run( main_screen *UI.MainScreen ) { func (self *AboutPlugin) Run(main_screen *UI.MainScreen) {
if main_screen != nil { if main_screen != nil {
main_screen.PushPage(self.Page) main_screen.PushPage(self.Page)
main_screen.Draw() main_screen.Draw()
@@ -436,11 +425,3 @@ func (self *AboutPlugin) Run( main_screen *UI.MainScreen ) {
} }
var APIOBJ AboutPlugin var APIOBJ AboutPlugin

287
Menu/GameShell/10_Settings/Airplane/airplane_page.go
View File

@@ -1,170 +1,164 @@
package Airplane package Airplane
import ( import (
//"fmt" //"fmt"
//"io/ioutil" //"io/ioutil"
//"path/filepath" //"path/filepath"
"strings" "strings"
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
//"github.com/cuu/gogame/draw"
//"github.com/cuu/gogame/draw"
"github.com/cuu/gogame/rect"
"github.com/cuu/gogame/surface"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect"
"github.com/cuu/gogame/surface"
"github.com/cuu/gogame/time" "github.com/cuu/gogame/time"
//"github.com/clockworkpi/LauncherGoDev/sysgo" //"github.com/clockworkpi/LauncherGoDev/sysgo"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
) )
type AirplanePage struct { type AirplanePage struct {
UI.Page UI.Page
ListFontObj *ttf.Font ListFontObj *ttf.Font
BGwidth int BGwidth int
BGheight int BGheight int
Scrolled int Scrolled int
Scroller *UI.ListScroller Scroller *UI.ListScroller
airwire_y int //0 airwire_y int //0
dialog_index int//0 dialog_index int //0
Icons map[string]UI.IconItemInterface
Icons map[string]UI.IconItemInterface
} }
func NewAirplanePage() *AirplanePage { func NewAirplanePage() *AirplanePage {
p := &AirplanePage{} p := &AirplanePage{}
p.PageIconMargin = 20 p.PageIconMargin = 20
p.SelectedIconTopOffset = 20 p.SelectedIconTopOffset = 20
p.EasingDur = 10 p.EasingDur = 10
p.Align = UI.ALIGN["SLeft"] p.Align = UI.ALIGN["SLeft"]
p.ListFontObj = UI.MyLangManager.TrFont("varela13") p.ListFontObj = UI.MyLangManager.TrFont("varela13")
p.FootMsg = [5]string{ "Nav","Rescue","","Back","Toggle"} p.FootMsg = [5]string{"Nav", "Rescue", "", "Back", "Toggle"}
p.BGwidth = UI.Width p.BGwidth = UI.Width
p.BGheight = UI.Height-24-20 p.BGheight = UI.Height - 24 - 20
p.Icons = make( map[string]UI.IconItemInterface ) p.Icons = make(map[string]UI.IconItemInterface)
return p return p
} }
func (self *AirplanePage) GenList() { func (self *AirplanePage) GenList() {
self.MyList = nil self.MyList = nil
} }
func (self *AirplanePage) Init() { func (self *AirplanePage) Init() {
if self.Screen != nil { if self.Screen != nil {
if self.Screen.CanvasHWND != nil && self.CanvasHWND == nil { if self.Screen.CanvasHWND != nil && self.CanvasHWND == nil {
self.HWND = self.Screen.CanvasHWND self.HWND = self.Screen.CanvasHWND
self.CanvasHWND = surface.Surface(self.Screen.Width,self.Screen.Height) self.CanvasHWND = surface.Surface(self.Screen.Width, self.Screen.Height)
} }
} }
self.PosX = self.Index*self.Screen.Width self.PosX = self.Index * self.Screen.Width
self.Width = self.Screen.Width self.Width = self.Screen.Width
self.Height = self.Screen.Height self.Height = self.Screen.Height
airwire := UI.NewIconItem()
airwire.ImgSurf = UI.MyIconPool.GetImgSurf("airwire")
airwire.MyType = UI.ICON_TYPES["STAT"]
airwire.Parent = self
airwire.Adjust(0, 0, 5, 43, 0)
self.Icons["airwire"] = airwire
airwire := UI.NewIconItem() GS := UI.NewIconItem()
airwire.ImgSurf = UI.MyIconPool.GetImgSurf("airwire") GS.ImgSurf = UI.MyIconPool.GetImgSurf("GS")
airwire.MyType = UI.ICON_TYPES["STAT"] GS.MyType = UI.ICON_TYPES["STAT"]
airwire.Parent = self GS.Parent = self
airwire.Adjust(0,0,5,43,0) GS.Adjust(0, 0, 72, 95, 0)
self.Icons["airwire"] = airwire self.Icons["GS"] = GS
GS := UI.NewIconItem() DialogBoxs := UI.NewMultiIconItem()
GS.ImgSurf = UI.MyIconPool.GetImgSurf("GS") DialogBoxs.ImgSurf = UI.MyIconPool.GetImgSurf("DialogBoxs")
GS.MyType = UI.ICON_TYPES["STAT"] DialogBoxs.MyType = UI.ICON_TYPES["STAT"]
GS.Parent = self DialogBoxs.Parent = self
GS.Adjust(0,0,72,95,0) DialogBoxs.IconWidth = 134
self.Icons["GS"] = GS DialogBoxs.IconHeight = 93
DialogBoxs.Adjust(0, 0, 134, 372, 0)
self.Icons["DialogBoxs"] = DialogBoxs
DialogBoxs := UI.NewMultiIconItem() self.GenList()
DialogBoxs.ImgSurf = UI.MyIconPool.GetImgSurf("DialogBoxs")
DialogBoxs.MyType = UI.ICON_TYPES["STAT"]
DialogBoxs.Parent = self
DialogBoxs.IconWidth = 134
DialogBoxs.IconHeight = 93
DialogBoxs.Adjust(0,0,134,372,0)
self.Icons["DialogBoxs"] = DialogBoxs
self.GenList() self.Scroller = UI.NewListScroller()
self.Scroller.Parent = self
self.Scroller = UI.NewListScroller() self.Scroller.PosX = self.Width - 10
self.Scroller.Parent = self self.Scroller.PosY = 2
self.Scroller.PosX = self.Width - 10 self.Scroller.Init()
self.Scroller.PosY = 2 self.Scroller.SetCanvasHWND(self.HWND)
self.Scroller.Init()
self.Scroller.SetCanvasHWND(self.HWND)
} }
func (self *AirplanePage) ScrollUp() { func (self *AirplanePage) ScrollUp() {
dis := 10 dis := 10
if self.PosY < 0 { if self.PosY < 0 {
self.PosY += dis self.PosY += dis
self.Scrolled += dis self.Scrolled += dis
} }
} }
func (self *AirplanePage) ScrollDown() { func (self *AirplanePage) ScrollDown() {
dis := 10 dis := 10
if UI.Abs(self.Scrolled) < (self.BGheight - self.Height) / 2 + 0 { if UI.Abs(self.Scrolled) < (self.BGheight-self.Height)/2+0 {
self.PosY -= dis self.PosY -= dis
self.Scrolled -=dis self.Scrolled -= dis
} }
} }
func (self *AirplanePage) ToggleModeAni() { func (self *AirplanePage) ToggleModeAni() {
out := UI.System("sudo rfkill list | grep yes | cut -d \" \" -f3") out := UI.System("sudo rfkill list | grep yes | cut -d \" \" -f3")
if strings.Contains(out,"yes") { if strings.Contains(out, "yes") {
data := self.EasingData(0,43) data := self.EasingData(0, 43)
for _,v := range data { for _, v := range data {
self.airwire_y -= v self.airwire_y -= v
self.dialog_index = 2 self.dialog_index = 2
time.BlockDelay(40) time.BlockDelay(40)
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
UI.System("sudo rfkill unblock all") UI.System("sudo rfkill unblock all")
self.Screen.TitleBar.InAirPlaneMode = false self.Screen.TitleBar.InAirPlaneMode = false
}else { } else {
data := self.EasingData(0,43) data := self.EasingData(0, 43)
for i, j := 0, len(data)-1; i < j; i, j = i+1, j-1 { // reverse data for i, j := 0, len(data)-1; i < j; i, j = i+1, j-1 { // reverse data
data[i], data[j] = data[j], data[i] data[i], data[j] = data[j], data[i]
} }
for _,v := range data { for _, v := range data {
self.airwire_y += v self.airwire_y += v
self.dialog_index = 3 self.dialog_index = 3
time.BlockDelay(40) time.BlockDelay(40)
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
UI.System("sudo rfkill block all") UI.System("sudo rfkill block all")
self.Screen.TitleBar.InAirPlaneMode = true self.Screen.TitleBar.InAirPlaneMode = true
} }
} }
func (self *AirplanePage) ToggleMode() { func (self *AirplanePage) ToggleMode() {
@@ -173,28 +167,28 @@ func (self *AirplanePage) ToggleMode() {
func (self *AirplanePage) UnBlockAll() { func (self *AirplanePage) UnBlockAll() {
self.Screen.MsgBox.SetText("TurningOn") self.Screen.MsgBox.SetText("TurningOn")
self.Screen.MsgBox.Draw() self.Screen.MsgBox.Draw()
UI.System("sudo rfkill unblock all") UI.System("sudo rfkill unblock all")
self.Screen.TitleBar.InAirPlaneMode = false self.Screen.TitleBar.InAirPlaneMode = false
} }
func (self *AirplanePage) OnLoadCb() { func (self *AirplanePage) OnLoadCb() {
self.Scrolled = 0 self.Scrolled = 0
self.PosY = 0 self.PosY = 0
//self.DrawOnce = false //self.DrawOnce = false
out := UI.System("sudo rfkill list | grep yes | cut -d \" \" -f3") out := UI.System("sudo rfkill list | grep yes | cut -d \" \" -f3")
if strings.Contains(out,"yes") { if strings.Contains(out, "yes") {
self.Screen.TitleBar.InAirPlaneMode = true self.Screen.TitleBar.InAirPlaneMode = true
self.airwire_y = 50+43 self.airwire_y = 50 + 43
self.dialog_index = 1 self.dialog_index = 1
}else { } else {
self.dialog_index = 0 self.dialog_index = 0
self.airwire_y = 50 self.airwire_y = 50
self.Screen.TitleBar.InAirPlaneMode = false self.Screen.TitleBar.InAirPlaneMode = false
} }
} }
func (self *AirplanePage) KeyDown(ev *event.Event) { func (self *AirplanePage) KeyDown(ev *event.Event) {
@@ -205,38 +199,37 @@ func (self *AirplanePage) KeyDown(ev *event.Event) {
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["B"] { if ev.Data["Key"] == UI.CurKeys["B"] {
self.ToggleModeAni() self.ToggleModeAni()
} }
if ev.Data["Key"] == UI.CurKeys["X"] { if ev.Data["Key"] == UI.CurKeys["X"] {
self.UnBlockAll() self.UnBlockAll()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
time.BlockDelay(1000) time.BlockDelay(1000)
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
} }
func (self *AirplanePage) Draw() { func (self *AirplanePage) Draw() {
self.ClearCanvas() self.ClearCanvas()
self.Icons["DialogBoxs"].NewCoord(145,23) self.Icons["DialogBoxs"].NewCoord(145, 23)
self.Icons["airwire"].NewCoord(80,self.airwire_y) self.Icons["airwire"].NewCoord(80, self.airwire_y)
self.Icons["DialogBoxs"].SetIconIndex(self.dialog_index) self.Icons["DialogBoxs"].SetIconIndex(self.dialog_index)
self.Icons["DialogBoxs"].DrawTopLeft() self.Icons["DialogBoxs"].DrawTopLeft()
self.Icons["airwire"].Draw() self.Icons["airwire"].Draw()
self.Icons["GS"].NewCoord(98,118) self.Icons["GS"].NewCoord(98, 118)
self.Icons["GS"].Draw() self.Icons["GS"].Draw()
if self.HWND != nil { if self.HWND != nil {
surface.Fill(self.HWND, &color.Color{255,255,255,255}) surface.Fill(self.HWND, &color.Color{255, 255, 255, 255})
rect_ := rect.Rect(self.PosX,self.PosY,self.Width,self.Height) rect_ := rect.Rect(self.PosX, self.PosY, self.Width, self.Height)
surface.Blit(self.HWND,self.CanvasHWND,&rect_,nil) surface.Blit(self.HWND, self.CanvasHWND, &rect_, nil)
} }
} }

27
Menu/GameShell/10_Settings/Airplane/plugin_init.go
View File

@@ -1,14 +1,14 @@
package Airplane package Airplane
import ( import (
/* /*
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/surface" "github.com/cuu/gogame/surface"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
*/ */
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
//"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS" //"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS"
) )
@@ -16,21 +16,20 @@ import (
/******************************************************************************/ /******************************************************************************/
type AirplanePlugin struct { type AirplanePlugin struct {
UI.Plugin UI.Plugin
AirplanePage *AirplanePage AirplanePage *AirplanePage
} }
func (self *AirplanePlugin) Init(main_screen *UI.MainScreen) {
func (self *AirplanePlugin) Init( main_screen *UI.MainScreen ) {
self.AirplanePage = NewAirplanePage() self.AirplanePage = NewAirplanePage()
self.AirplanePage.SetScreen( main_screen) self.AirplanePage.SetScreen(main_screen)
self.AirplanePage.SetName("Airplane") self.AirplanePage.SetName("Airplane")
self.AirplanePage.Init() self.AirplanePage.Init()
} }
func (self *AirplanePlugin) Run( main_screen *UI.MainScreen ) { func (self *AirplanePlugin) Run(main_screen *UI.MainScreen) {
if main_screen != nil { if main_screen != nil {
main_screen.PushCurPage() main_screen.PushCurPage()
main_screen.SetCurPage(self.AirplanePage) main_screen.SetCurPage(self.AirplanePage)
main_screen.Draw() main_screen.Draw()
main_screen.SwapAndShow() main_screen.SwapAndShow()
} }

205
Menu/GameShell/10_Settings/Bluetooth/ble_agent_pair_page.go
View File

@@ -1,156 +1,155 @@
package Bluetooth package Bluetooth
import ( import (
"fmt" "fmt"
//"os" //"os"
//"log" //"log"
//"strings" //"strings"
//"github.com/fatih/structs" //"github.com/fatih/structs"
/* /*
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/draw" "github.com/cuu/gogame/draw"
"github.com/cuu/gogame/surface" "github.com/cuu/gogame/surface"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
"github.com/cuu/gogame/font" "github.com/cuu/gogame/font"
*/ */
"github.com/cuu/gogame/time" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/time"
//"github.com/godbus/dbus" //"github.com/godbus/dbus"
//"github.com/muka/go-bluetooth/api" //"github.com/muka/go-bluetooth/api"
//"github.com/muka/go-bluetooth/bluez" //"github.com/muka/go-bluetooth/bluez"
//"github.com/muka/go-bluetooth/bluez/profile" //"github.com/muka/go-bluetooth/bluez/profile"
"github.com/muka/go-bluetooth/bluez/profile/device" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/muka/go-bluetooth/bluez/profile/device"
) )
type BleAgentPairPage struct { type BleAgentPairPage struct {
UI.Page UI.Page
Pin string Pin string
Pass string Pass string
DevObj *device.Device1 DevObj *device.Device1
Leader *BluetoothPlugin Leader *BluetoothPlugin
} }
func NewBleAgentPairPage() *BleAgentPairPage { func NewBleAgentPairPage() *BleAgentPairPage {
p := &BleAgentPairPage{} p := &BleAgentPairPage{}
p.PageIconMargin = 20 p.PageIconMargin = 20
p.SelectedIconTopOffset = 20 p.SelectedIconTopOffset = 20
p.EasingDur = 10 p.EasingDur = 10
p.Align = UI.ALIGN["SLeft"] p.Align = UI.ALIGN["SLeft"]
p.FootMsg = [5]string{"Nav.","","","Back",""} p.FootMsg = [5]string{"Nav.", "", "", "Back", ""}
return p return p
} }
func (self *BleAgentPairPage) Init() { func (self *BleAgentPairPage) Init() {
self.PosX = self.Index * self.Screen.Width self.PosX = self.Index * self.Screen.Width
self.Width = self.Screen.Width self.Width = self.Screen.Width
self.Height = self.Screen.Height self.Height = self.Screen.Height
self.CanvasHWND = self.Screen.CanvasHWND self.CanvasHWND = self.Screen.CanvasHWND
} }
func (self *BleAgentPairPage) ShowPinCode(device string,pincode string) { func (self *BleAgentPairPage) ShowPinCode(device string, pincode string) {
fmt.Println( fmt.Sprintf("ShowPinCode %s %d" ,device,pincode)) fmt.Println(fmt.Sprintf("ShowPinCode %s %d", device, pincode))
if self.Screen.CurPage() != self { if self.Screen.CurPage() != self {
self.Screen.PushPage(self) self.Screen.PushPage(self)
self.ClearCanvas() self.ClearCanvas()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
self.Pin = pincode self.Pin = pincode
txt := self.Pin txt := self.Pin
if len(self.Pin) > 0 { if len(self.Pin) > 0 {
txt = fmt.Sprintf("Pin code: %s",self.Pin) txt = fmt.Sprintf("Pin code: %s", self.Pin)
} }
self.Screen.MsgBox.SetText(txt) self.Screen.MsgBox.SetText(txt)
self.Screen.MsgBox.Draw() self.Screen.MsgBox.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
func (self *BleAgentPairPage) ShowPassKey(device string,passkey uint32,entered uint16) { func (self *BleAgentPairPage) ShowPassKey(device string, passkey uint32, entered uint16) {
fmt.Println(fmt.Sprintf("ShowPassKey %06d %d",passkey,entered) ) fmt.Println(fmt.Sprintf("ShowPassKey %06d %d", passkey, entered))
if self.Screen.CurPage() != self { if self.Screen.CurPage() != self {
self.Screen.PushPage(self) self.Screen.PushPage(self)
self.ClearCanvas() self.ClearCanvas()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
self.Pass = fmt.Sprintf("%06d",passkey) self.Pass = fmt.Sprintf("%06d", passkey)
txt := self.Pass txt := self.Pass
if len(self.Pass) > 0 { if len(self.Pass) > 0 {
txt = fmt.Sprintf("Pair code: %s",self.Pass) txt = fmt.Sprintf("Pair code: %s", self.Pass)
} }
self.Screen.MsgBox.SetText(txt) self.Screen.MsgBox.SetText(txt)
self.Screen.MsgBox.Draw() self.Screen.MsgBox.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
func (self *BleAgentPairPage) PairOKCb() { func (self *BleAgentPairPage) PairOKCb() {
self.ClearCanvas() self.ClearCanvas()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
self.Screen.MsgBox.SetText("Device paired") self.Screen.MsgBox.SetText("Device paired")
self.Screen.MsgBox.Draw() self.Screen.MsgBox.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
time.BlockDelay(1500) time.BlockDelay(1500)
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
self.Screen.FootBar.ResetNavText() self.Screen.FootBar.ResetNavText()
} }
func (self *BleAgentPairPage) PairErrorCb( err_msg string) { func (self *BleAgentPairPage) PairErrorCb(err_msg string) {
self.ClearCanvas() self.ClearCanvas()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
self.Screen.MsgBox.SetText(err_msg) self.Screen.MsgBox.SetText(err_msg)
self.Screen.MsgBox.Draw() self.Screen.MsgBox.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
time.BlockDelay(1500) time.BlockDelay(1500)
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
self.Screen.FootBar.ResetNavText() self.Screen.FootBar.ResetNavText()
} }
func (self *BleAgentPairPage) KeyDown(ev *event.Event) { func (self *BleAgentPairPage) KeyDown(ev *event.Event) {
if ev.Data["Key"] == UI.CurKeys["A"] || ev.Data["Key"] == UI.CurKeys["Menu"] { if ev.Data["Key"] == UI.CurKeys["A"] || ev.Data["Key"] == UI.CurKeys["Menu"] {
if self.DevObj != nil { if self.DevObj != nil {
err := self.DevObj.CancelPairing() err := self.DevObj.CancelPairing()
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
} }
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
} }
func (self *BleAgentPairPage) Draw() { func (self *BleAgentPairPage) Draw() {
// DoNothing // DoNothing
} }

1173
Menu/GameShell/10_Settings/Bluetooth/bluetooth_page.go
View File

File diff suppressed because it is too large Load Diff

149
Menu/GameShell/10_Settings/Bluetooth/net_item.go
View File

@@ -1,55 +1,54 @@
package Bluetooth package Bluetooth
import ( import (
//"fmt" //"fmt"
//bleapi "github.com/muka/go-bluetooth/api" //bleapi "github.com/muka/go-bluetooth/api"
//"github.com/muka/go-bluetooth/bluez/profile" //"github.com/muka/go-bluetooth/bluez/profile"
"github.com/muka/go-bluetooth/bluez/profile/device" "github.com/muka/go-bluetooth/bluez/profile/device"
"github.com/veandco/go-sdl2/ttf"
"github.com/veandco/go-sdl2/sdl" "github.com/veandco/go-sdl2/sdl"
"github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/color"
"github.com/cuu/gogame/surface" "github.com/cuu/gogame/draw"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/draw" "github.com/cuu/gogame/surface"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
) )
var NetItemDefaultHeight = 30 var NetItemDefaultHeight = 30
type NetItemMultiIcon struct { type NetItemMultiIcon struct {
UI.MultiIconItem UI.MultiIconItem
CanvasHWND *sdl.Surface // self._Parent._CanvasHWND CanvasHWND *sdl.Surface // self._Parent._CanvasHWND
Parent UI.WidgetInterface // Parent UI.WidgetInterface //
} }
func NewNetItemMultiIcon() *NetItemMultiIcon{ func NewNetItemMultiIcon() *NetItemMultiIcon {
p := &NetItemMultiIcon{} p := &NetItemMultiIcon{}
p.IconIndex = 0 p.IconIndex = 0
p.IconWidth = 18 p.IconWidth = 18
p.IconHeight = 18 p.IconHeight = 18
p.Width = 18 p.Width = 18
p.Height = 18 p.Height = 18
return p return p
} }
func (self *NetItemMultiIcon) Draw() { func (self *NetItemMultiIcon) Draw() {
_,h_ := self.Parent.Size() _, h_ := self.Parent.Size()
dest_rect := rect.Rect(self.PosX,self.PosY+(h_-self.Height)/2, self.Width,self.Height) dest_rect := rect.Rect(self.PosX, self.PosY+(h_-self.Height)/2, self.Width, self.Height)
area_rect := rect.Rect(0,self.IconIndex*self.IconHeight,self.IconWidth,self.IconHeight) area_rect := rect.Rect(0, self.IconIndex*self.IconHeight, self.IconWidth, self.IconHeight)
surface.Blit(self.CanvasHWND,self.ImgSurf,&dest_rect,&area_rect) surface.Blit(self.CanvasHWND, self.ImgSurf, &dest_rect, &area_rect)
} }
type NetItemIcon struct { type NetItemIcon struct {
UI.IconItem UI.IconItem
CanvasHWND *sdl.Surface CanvasHWND *sdl.Surface
Parent UI.WidgetInterface Parent UI.WidgetInterface
} }
func NewNetItemIcon() *NetItemIcon { func NewNetItemIcon() *NetItemIcon {
@@ -60,76 +59,72 @@ func NewNetItemIcon() *NetItemIcon {
} }
func (self *NetItemIcon) Draw() { func (self *NetItemIcon) Draw() {
_,h_ := self.Parent.Size() _, h_ := self.Parent.Size()
dest_rect := rect.Rect(self.PosX,self.PosY+(h_-self.Height)/2,self.Width,self.Height) dest_rect := rect.Rect(self.PosX, self.PosY+(h_-self.Height)/2, self.Width, self.Height)
surface.Blit(self.CanvasHWND,self.ImgSurf,&dest_rect,nil) surface.Blit(self.CanvasHWND, self.ImgSurf, &dest_rect, nil)
} }
type NetItem struct { type NetItem struct {
UI.Widget UI.Widget
Channel string //'10' Channel string //'10'
Stren string //19% Stren string //19%
Icons map[string]UI.IconItemInterface Icons map[string]UI.IconItemInterface
Labels map[string]UI.LabelInterface Labels map[string]UI.LabelInterface
IsActive bool IsActive bool
FontObj *ttf.Font FontObj *ttf.Font
RSSI int // 0 RSSI int // 0
MacAddr string // MacAddr string //
Parent *BluetoothPage Parent *BluetoothPage
Path string ///org/bluez/hci0/dev_34_88_5D_97_FF_26 Path string ///org/bluez/hci0/dev_34_88_5D_97_FF_26
Props *device.Device1Properties Props *device.Device1Properties
Device *device.Device1 Device *device.Device1
} }
func NewNetItem() *NetItem { func NewNetItem() *NetItem {
p:= &NetItem{} p := &NetItem{}
p.Height = NetItemDefaultHeight p.Height = NetItemDefaultHeight
p.Labels = make(map[string]UI.LabelInterface) p.Labels = make(map[string]UI.LabelInterface)
p.Icons = make( map[string]UI.IconItemInterface) p.Icons = make(map[string]UI.IconItemInterface)
return p return p
} }
func (self *NetItem) SetActive(act bool) { func (self *NetItem) SetActive(act bool) {
self.IsActive = act self.IsActive = act
} }
func (self *NetItem) Init(_label string) {
func (self *NetItem) Init( _label string) { self.MacAddr = self.Props.Address
self.SetActive(self.Props.Connected)
self.MacAddr = self.Props.Address name_label := UI.NewLabel()
self.SetActive(self.Props.Connected) name_label.PosX = 12
name_label.CanvasHWND = self.Parent.CanvasHWND
name_label := UI.NewLabel() mac_addr := self.MacAddr
name_label.PosX = 12 if len(self.Props.Name) > 3 {
mac_addr = self.Props.Name
}
name_label.CanvasHWND = self.Parent.CanvasHWND self.RSSI = int(self.Props.RSSI)
mac_addr := self.MacAddr name_label.Init(mac_addr, self.FontObj, nil)
if len(self.Props.Name) > 3 {
mac_addr = self.Props.Name
}
self.RSSI = int(self.Props.RSSI) self.Labels["mac_addr"] = name_label
name_label.Init(mac_addr,self.FontObj,nil) done_icon := NewNetItemIcon()
self.Labels["mac_addr"] = name_label
done_icon := NewNetItemIcon()
done_icon.ImgSurf = UI.MyIconPool.GetImgSurf("done") done_icon.ImgSurf = UI.MyIconPool.GetImgSurf("done")
done_icon.CanvasHWND = self.Parent.GetCanvasHWND() done_icon.CanvasHWND = self.Parent.GetCanvasHWND()
done_icon.Parent = self done_icon.Parent = self
@@ -140,31 +135,31 @@ func (self *NetItem) Init( _label string) {
func (self *NetItem) Connect() { func (self *NetItem) Connect() {
if self.Device != nil { if self.Device != nil {
self.Device.Connect() self.Device.Connect()
} }
} }
func (self *NetItem) GetLinkObj() UI.PluginInterface { func (self *NetItem) GetLinkObj() UI.PluginInterface {
return nil return nil
} }
func (self *NetItem) Draw() { func (self *NetItem) Draw() {
for k,v := range self.Labels { for k, v := range self.Labels {
x,_ := v.Coord() x, _ := v.Coord()
_,h := v.Size() _, h := v.Size()
self.Labels[k].NewCoord(x, self.PosY+(self.Height - h)/2) self.Labels[k].NewCoord(x, self.PosY+(self.Height-h)/2)
self.Labels[k].Draw() self.Labels[k].Draw()
} }
if self.IsActive { if self.IsActive {
self.Icons["done"].NewCoord(UI.Width-22, self.PosY) self.Icons["done"].NewCoord(UI.Width-22, self.PosY)
self.Icons["done"].Draw() self.Icons["done"].Draw()
} }
draw.Line(self.Parent.CanvasHWND,&color.Color{169,169,169,255}, draw.Line(self.Parent.CanvasHWND, &color.Color{169, 169, 169, 255},
self.PosX,self.PosY+self.Height-1, self.PosX, self.PosY+self.Height-1,
self.PosX+self.Width,self.PosY+self.Height-1, self.PosX+self.Width, self.PosY+self.Height-1,
1) 1)
} }

178
Menu/GameShell/10_Settings/Bluetooth/plugin_init.go
View File

@@ -1,133 +1,129 @@
package Bluetooth package Bluetooth
import ( import (
"fmt" "fmt"
//"log" //"log"
//"os" //"os"
//"time" //"time"
"github.com/godbus/dbus/v5" "github.com/godbus/dbus/v5"
//"github.com/muka/go-bluetooth/api" //"github.com/muka/go-bluetooth/api"
"github.com/muka/go-bluetooth/hw" "github.com/muka/go-bluetooth/hw"
//"github.com/muka/go-bluetooth/bluez/profile" //"github.com/muka/go-bluetooth/bluez/profile"
"github.com/muka/go-bluetooth/bluez/profile/agent" "github.com/muka/go-bluetooth/bluez/profile/agent"
//"github.com/muka/go-bluetooth/bluez/profile/adapter" //"github.com/muka/go-bluetooth/bluez/profile/adapter"
/* /*
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/surface" "github.com/cuu/gogame/surface"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
*/ */
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
log "github.com/sirupsen/logrus" log "github.com/sirupsen/logrus"
) )
/******************************************************************************/ /******************************************************************************/
type BluetoothPlugin struct { type BluetoothPlugin struct {
UI.Plugin UI.Plugin
BluetoothPage *BluetoothPage BluetoothPage *BluetoothPage
PairPage *BleAgentPairPage PairPage *BleAgentPairPage
} }
const ( const (
adapterID = "hci0" adapterID = "hci0"
BUS_NAME = "org.bluez" BUS_NAME = "org.bluez"
AGENT_INTERFACE = "org.bluez.Agent1" AGENT_INTERFACE = "org.bluez.Agent1"
) )
func (self *BluetoothPlugin) InitAgent() { func (self *BluetoothPlugin) InitAgent() {
conn, err := dbus.SystemBus() conn, err := dbus.SystemBus()
if err != nil { if err != nil {
return return
} }
ag := agent.NewSimpleAgent() ag := agent.NewSimpleAgent()
err = agent.ExposeAgent(conn, ag, agent.CapKeyboardDisplay, true) err = agent.ExposeAgent(conn, ag, agent.CapKeyboardDisplay, true)
if err != nil { if err != nil {
fmt.Println( fmt.Errorf("SimpleAgent: %s", err) ) fmt.Println(fmt.Errorf("SimpleAgent: %s", err))
return return
} }
} }
func (self *BluetoothPlugin) Init( main_screen *UI.MainScreen ) { func (self *BluetoothPlugin) Init(main_screen *UI.MainScreen) {
log.Println("Reset bluetooth device") log.Println("Reset bluetooth device")
btmgmt := hw.NewBtMgmt(adapterID) btmgmt := hw.NewBtMgmt(adapterID)
btmgmt.SetPowered(true) btmgmt.SetPowered(true)
self.BluetoothPage = NewBluetoothPage() self.BluetoothPage = NewBluetoothPage()
self.BluetoothPage.SetScreen( main_screen) self.BluetoothPage.SetScreen(main_screen)
self.BluetoothPage.SetName("Bluetooth") self.BluetoothPage.SetName("Bluetooth")
self.BluetoothPage.Leader = self self.BluetoothPage.Leader = self
self.BluetoothPage.Init() self.BluetoothPage.Init()
self.PairPage = NewBleAgentPairPage() self.PairPage = NewBleAgentPairPage()
self.PairPage.SetScreen( main_screen) self.PairPage.SetScreen(main_screen)
self.PairPage.SetName("Bluetooth pair") self.PairPage.SetName("Bluetooth pair")
self.PairPage.Leader = self self.PairPage.Leader = self
self.PairPage.Init() self.PairPage.Init()
self.InitAgent() self.InitAgent()
/* /*
a, err := adapter.GetAdapter(adapterID) a, err := adapter.GetAdapter(adapterID)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
discovery, cancel, err := api.Discover(a, nil) discovery, cancel, err := api.Discover(a, nil)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
} }
defer cancel() defer cancel()
wait := make(chan error) wait := make(chan error)
go func() { go func() {
for dev := range discovery { for dev := range discovery {
if dev == nil { if dev == nil {
return return
} }
wait <- nil wait <- nil
} }
}() }()
go func() { go func() {
sleep := 5 sleep := 5
time.Sleep(time.Duration(sleep) * time.Second) time.Sleep(time.Duration(sleep) * time.Second)
log.Debugf("Discovery timeout exceeded (%ds)", sleep) log.Debugf("Discovery timeout exceeded (%ds)", sleep)
wait <- nil wait <- nil
}() }()
err = <-wait
if err != nil {
fmt.Println(err)
}
*/
//self.BluetoothPage.RefreshDevices()
//self.BluetoothPage.GenNetworkList()
err = <-wait
if err != nil {
fmt.Println(err)
}
*/
//self.BluetoothPage.RefreshDevices()
//self.BluetoothPage.GenNetworkList()
} }
func (self *BluetoothPlugin) Run( main_screen *UI.MainScreen ) { func (self *BluetoothPlugin) Run(main_screen *UI.MainScreen) {
if main_screen != nil { if main_screen != nil {
main_screen.PushCurPage() main_screen.PushCurPage()
main_screen.SetCurPage(self.BluetoothPage) main_screen.SetCurPage(self.BluetoothPage)
main_screen.Draw() main_screen.Draw()
main_screen.SwapAndShow() main_screen.SwapAndShow()
} }
} }
var APIOBJ BluetoothPlugin var APIOBJ BluetoothPlugin

325
Menu/GameShell/10_Settings/Brightness/brightness_page.go
View File

@@ -1,97 +1,97 @@
package Brightness package Brightness
import( import (
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"strconv" "strconv"
"github.com/veandco/go-sdl2/sdl" "github.com/veandco/go-sdl2/sdl"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/draw"
"github.com/cuu/gogame/draw" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/surface" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/surface"
"github.com/clockworkpi/LauncherGoDev/sysgo" "github.com/clockworkpi/LauncherGoDev/sysgo"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
) )
type OnChangeCB_T func(int) type OnChangeCB_T func(int)
type SliderIcon struct { type SliderIcon struct {
UI.IconItem UI.IconItem
Parent *BSlider Parent *BSlider
} }
func NewSliderIcon() *SliderIcon { func NewSliderIcon() *SliderIcon {
p := &SliderIcon{} p := &SliderIcon{}
p.MyType = UI.ICON_TYPES["EXE"] p.MyType = UI.ICON_TYPES["EXE"]
p.Align = UI.ALIGN["VCenter"] p.Align = UI.ALIGN["VCenter"]
return p return p
} }
func (self *SliderIcon) Draw() { func (self *SliderIcon) Draw() {
if self.Parent == nil { if self.Parent == nil {
fmt.Println("Error: SliderIcon Draw Parent nil") fmt.Println("Error: SliderIcon Draw Parent nil")
return return
} }
parent_x,parent_y := self.Parent.Coord() parent_x, parent_y := self.Parent.Coord()
if self.Label != nil { if self.Label != nil {
// lab_x,lab_y := self.Label.Coord() // lab_x,lab_y := self.Label.Coord()
lab_w,lab_h:= self.Label.Size() lab_w, lab_h := self.Label.Size()
if self.Align == UI.ALIGN["VCenter"] { if self.Align == UI.ALIGN["VCenter"] {
// fmt.Println("IconItem Draw VCenter:",lab_w,lab_h,self.Label.GetText()) // fmt.Println("IconItem Draw VCenter:",lab_w,lab_h,self.Label.GetText())
self.Label.NewCoord( self.PosX - lab_w/2 + parent_x, self.PosY + self.Height/2+6+parent_y) self.Label.NewCoord(self.PosX-lab_w/2+parent_x, self.PosY+self.Height/2+6+parent_y)
}else if self.Align == UI.ALIGN["HLeft"] { } else if self.Align == UI.ALIGN["HLeft"] {
self.Label.NewCoord( self.PosX + self.Width/2+3+parent_x, self.PosY - lab_h/2 + parent_y) self.Label.NewCoord(self.PosX+self.Width/2+3+parent_x, self.PosY-lab_h/2+parent_y)
} }
self.Label.Draw() self.Label.Draw()
} }
if self.ImgSurf != nil { if self.ImgSurf != nil {
surface.Blit(self.Parent.GetCanvasHWND(), self.ImgSurf,draw.MidRect(self.PosX + parent_x, self.PosY + parent_y, surface.Blit(self.Parent.GetCanvasHWND(), self.ImgSurf, draw.MidRect(self.PosX+parent_x, self.PosY+parent_y,
self.Width,self.Height, UI.Width, UI.Height),nil) self.Width, self.Height, UI.Width, UI.Height), nil)
} }
} }
type SliderMultiIcon struct { type SliderMultiIcon struct {
UI.MultiIconItem UI.MultiIconItem
Parent *BSlider Parent *BSlider
} }
func NewSliderMultiIcon() *SliderMultiIcon { func NewSliderMultiIcon() *SliderMultiIcon {
p := &SliderMultiIcon{} p := &SliderMultiIcon{}
p.MyType = UI.ICON_TYPES["EXE"] p.MyType = UI.ICON_TYPES["EXE"]
p.Align = UI.ALIGN["VCenter"] p.Align = UI.ALIGN["VCenter"]
p.IconIndex = 0 p.IconIndex = 0
p.IconWidth = 18 p.IconWidth = 18
p.IconHeight = 18 p.IconHeight = 18
return p return p
} }
func (self *SliderMultiIcon) Draw() { func (self *SliderMultiIcon) Draw() {
if self.Parent == nil { if self.Parent == nil {
fmt.Println("Error: SliderMultiIcon Draw Parent nil") fmt.Println("Error: SliderMultiIcon Draw Parent nil")
return return
} }
parent_x,parent_y := self.Parent.Coord() parent_x, parent_y := self.Parent.Coord()
if self.Label != nil { if self.Label != nil {
// lab_x,lab_y := self.Label.Coord() // lab_x,lab_y := self.Label.Coord()
lab_w,lab_h:= self.Label.Size() lab_w, lab_h := self.Label.Size()
if self.Align == UI.ALIGN["VCenter"] { if self.Align == UI.ALIGN["VCenter"] {
self.Label.NewCoord( self.PosX - lab_w/2 + parent_x, self.PosY + self.Height/2+6 + parent_y) self.Label.NewCoord(self.PosX-lab_w/2+parent_x, self.PosY+self.Height/2+6+parent_y)
}else if self.Align == UI.ALIGN["HLeft"] { } else if self.Align == UI.ALIGN["HLeft"] {
self.Label.NewCoord( self.PosX + self.Width/2+3 + parent_x, self.PosY - lab_h/2 + parent_y ) self.Label.NewCoord(self.PosX+self.Width/2+3+parent_x, self.PosY-lab_h/2+parent_y)
} }
self.Label.Draw() self.Label.Draw()
@@ -99,198 +99,196 @@ func (self *SliderMultiIcon) Draw() {
if self.ImgSurf != nil { if self.ImgSurf != nil {
portion := rect.Rect(0,self.IconIndex*self.IconHeight,self.IconWidth,self.IconHeight) portion := rect.Rect(0, self.IconIndex*self.IconHeight, self.IconWidth, self.IconHeight)
surface.Blit(self.Parent.GetCanvasHWND(), surface.Blit(self.Parent.GetCanvasHWND(),
self.ImgSurf,draw.MidRect(self.PosX + parent_x, self.PosY + parent_y, self.ImgSurf, draw.MidRect(self.PosX+parent_x, self.PosY+parent_y,
self.Width,self.Height, UI.Width, UI.Height),&portion) self.Width, self.Height, UI.Width, UI.Height), &portion)
} }
} }
type BSlider struct { type BSlider struct {
UI.Slider UI.Slider
BGpng *SliderIcon BGpng *SliderIcon
BGwidth int BGwidth int
BGheight int BGheight int
//NeedleSurf //NeedleSurf
Scale *SliderMultiIcon Scale *SliderMultiIcon
Parent *BrightnessPage Parent *BrightnessPage
OnChangeCB OnChangeCB_T
OnChangeCB OnChangeCB_T
} }
func NewBSlider() *BSlider { func NewBSlider() *BSlider {
p := &BSlider{} p := &BSlider{}
p.Range = [2]int{0,255} p.Range = [2]int{0, 255}
p.Value = 0 p.Value = 0
p.BGwidth = 179 p.BGwidth = 179
p.BGheight = 153 p.BGheight = 153
return p return p
} }
func (self *BSlider) GetCanvasHWND() *sdl.Surface { func (self *BSlider) GetCanvasHWND() *sdl.Surface {
return self.CanvasHWND return self.CanvasHWND
} }
func (self *BSlider) Init() { func (self *BSlider) Init() {
self.Width = self.Parent.Width self.Width = self.Parent.Width
self.Height = self.Parent.Height self.Height = self.Parent.Height
self.BGpng = NewSliderIcon() self.BGpng = NewSliderIcon()
self.BGpng.ImgSurf = UI.MyIconPool.GetImgSurf("light") self.BGpng.ImgSurf = UI.MyIconPool.GetImgSurf("light")
self.BGpng.MyType = UI.ICON_TYPES["STAT"] self.BGpng.MyType = UI.ICON_TYPES["STAT"]
self.BGpng.Parent = self self.BGpng.Parent = self
self.BGpng.Adjust(0,0,self.BGwidth,self.BGheight,0) self.BGpng.Adjust(0, 0, self.BGwidth, self.BGheight, 0)
self.Scale = NewSliderMultiIcon() self.Scale = NewSliderMultiIcon()
self.Scale.MyType = UI.ICON_TYPES["STAT"] self.Scale.MyType = UI.ICON_TYPES["STAT"]
self.Scale.Parent = self self.Scale.Parent = self
self.Scale.ImgSurf = UI.MyIconPool.GetImgSurf("scale") self.Scale.ImgSurf = UI.MyIconPool.GetImgSurf("scale")
self.Scale.IconWidth = 82 self.Scale.IconWidth = 82
self.Scale.IconHeight = 63 self.Scale.IconHeight = 63
self.Scale.Adjust(0,0,82,63,0) self.Scale.Adjust(0, 0, 82, 63, 0)
} }
func (self *BSlider) SetValue( brt int) { func (self *BSlider) SetValue(brt int) {
self.Value = brt self.Value = brt
} }
func (self *BSlider) Further() { func (self *BSlider) Further() {
self.Value += 1 self.Value += 1
if self.Value > 9 { if self.Value > 9 {
self.Value = 9 self.Value = 9
} }
if self.OnChangeCB != nil { if self.OnChangeCB != nil {
self.OnChangeCB(self.Value) self.OnChangeCB(self.Value)
} }
} }
func (self *BSlider) StepBack() { func (self *BSlider) StepBack() {
self.Value -= 1 self.Value -= 1
if self.Value < 0 { if self.Value < 0 {
self.Value = 0 self.Value = 0
} }
if self.OnChangeCB != nil { if self.OnChangeCB != nil {
self.OnChangeCB(self.Value) self.OnChangeCB(self.Value)
} }
} }
func (self *BSlider) Draw() { func (self *BSlider) Draw() {
self.BGpng.NewCoord(self.Width/2,self.Height/2+11) self.BGpng.NewCoord(self.Width/2, self.Height/2+11)
self.BGpng.Draw() self.BGpng.Draw()
self.Scale.NewCoord(self.Width/2,self.Height/2) self.Scale.NewCoord(self.Width/2, self.Height/2)
icon_idx := self.Value-1 icon_idx := self.Value - 1
if icon_idx <0 { if icon_idx < 0 {
icon_idx = 0 icon_idx = 0
} }
self.Scale.IconIndex = icon_idx self.Scale.IconIndex = icon_idx
self.Scale.Draw() self.Scale.Draw()
} }
type BrightnessPage struct { type BrightnessPage struct {
UI.Page UI.Page
MySlider *BSlider MySlider *BSlider
} }
func NewBrightnessPage() *BrightnessPage { func NewBrightnessPage() *BrightnessPage {
p:= &BrightnessPage{} p := &BrightnessPage{}
p.PageIconMargin = 20 p.PageIconMargin = 20
p.SelectedIconTopOffset = 20 p.SelectedIconTopOffset = 20
p.EasingDur = 10 p.EasingDur = 10
p.Align = UI.ALIGN["SLeft"] p.Align = UI.ALIGN["SLeft"]
p.FootMsg = [5]string{"Nav","","","Back","Enter"} p.FootMsg = [5]string{"Nav", "", "", "Back", "Enter"}
return p return p
} }
func (self *BrightnessPage) Init() { func (self *BrightnessPage) Init() {
self.CanvasHWND = self.Screen.CanvasHWND self.CanvasHWND = self.Screen.CanvasHWND
self.Width = self.Screen.Width self.Width = self.Screen.Width
self.Height = self.Screen.Height self.Height = self.Screen.Height
self.MySlider = NewBSlider() self.MySlider = NewBSlider()
self.MySlider.Parent = self self.MySlider.Parent = self
self.MySlider.SetCanvasHWND(self.CanvasHWND) self.MySlider.SetCanvasHWND(self.CanvasHWND)
self.MySlider.OnChangeCB = self.WhenSliderDrag self.MySlider.OnChangeCB = self.WhenSliderDrag
self.MySlider.Init() self.MySlider.Init()
brt := self.ReadBackLight() brt := self.ReadBackLight()
self.MySlider.SetValue(brt)
self.MySlider.SetValue(brt)
} }
func (self *BrightnessPage) ReadBackLight() int { func (self *BrightnessPage) ReadBackLight() int {
if UI.FileExists(sysgo.BackLight) == false { if UI.FileExists(sysgo.BackLight) == false {
return 0 return 0
} }
lines,err := UI.ReadLines(sysgo.BackLight) lines, err := UI.ReadLines(sysgo.BackLight)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return 0 return 0
} }
for _,v := range lines { for _, v := range lines {
n,e := strconv.Atoi(v) n, e := strconv.Atoi(v)
if e == nil { if e == nil {
return n return n
}else { } else {
fmt.Println(e) fmt.Println(e)
return 0 return 0
} }
break break
} }
return 0 return 0
} }
func (self *BrightnessPage) OnLoadCb() { func (self *BrightnessPage) OnLoadCb() {
brt := self.ReadBackLight() brt := self.ReadBackLight()
self.MySlider.SetValue(brt) self.MySlider.SetValue(brt)
} }
func (self *BrightnessPage) SetBackLight( newbrt int){ func (self *BrightnessPage) SetBackLight(newbrt int) {
newbrt_str := fmt.Sprintf("%d",newbrt) newbrt_str := fmt.Sprintf("%d", newbrt)
if UI.FileExists(sysgo.BackLight) { if UI.FileExists(sysgo.BackLight) {
err:= ioutil.WriteFile(sysgo.BackLight,[]byte(newbrt_str),0644) err := ioutil.WriteFile(sysgo.BackLight, []byte(newbrt_str), 0644)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
} }
}else{ } else {
fmt.Println(sysgo.BackLight, " file not existed") fmt.Println(sysgo.BackLight, " file not existed")
} }
} }
func (self *BrightnessPage) WhenSliderDrag( val int) { func (self *BrightnessPage) WhenSliderDrag(val int) {
self.SetBackLight(val) self.SetBackLight(val)
} }
func (self *BrightnessPage) KeyDown(ev *event.Event) { func (self *BrightnessPage) KeyDown(ev *event.Event) {
@@ -300,23 +298,22 @@ func (self *BrightnessPage) KeyDown(ev *event.Event) {
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["Right"] { if ev.Data["Key"] == UI.CurKeys["Right"] {
self.MySlider.Further() self.MySlider.Further()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["Left"] { if ev.Data["Key"] == UI.CurKeys["Left"] {
self.MySlider.StepBack() self.MySlider.StepBack()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
} }
func (self *BrightnessPage) Draw() { func (self *BrightnessPage) Draw() {
self.ClearCanvas() self.ClearCanvas()
self.MySlider.Draw() self.MySlider.Draw()
} }

27
Menu/GameShell/10_Settings/Brightness/plugin_init.go
View File

@@ -4,14 +4,14 @@ package Brightness
* sysgo.BackLight * sysgo.BackLight
*/ */
import ( import (
/* /*
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/surface" "github.com/cuu/gogame/surface"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
*/ */
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
//"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS" //"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS"
) )
@@ -19,21 +19,20 @@ import (
/******************************************************************************/ /******************************************************************************/
type BrightnessPlugin struct { type BrightnessPlugin struct {
UI.Plugin UI.Plugin
BrightnessPage *BrightnessPage BrightnessPage *BrightnessPage
} }
func (self *BrightnessPlugin) Init(main_screen *UI.MainScreen) {
func (self *BrightnessPlugin) Init( main_screen *UI.MainScreen ) {
self.BrightnessPage = NewBrightnessPage() self.BrightnessPage = NewBrightnessPage()
self.BrightnessPage.SetScreen( main_screen) self.BrightnessPage.SetScreen(main_screen)
self.BrightnessPage.SetName("Brightness") self.BrightnessPage.SetName("Brightness")
self.BrightnessPage.Init() self.BrightnessPage.Init()
} }
func (self *BrightnessPlugin) Run( main_screen *UI.MainScreen ) { func (self *BrightnessPlugin) Run(main_screen *UI.MainScreen) {
if main_screen != nil { if main_screen != nil {
main_screen.PushCurPage() main_screen.PushCurPage()
main_screen.SetCurPage(self.BrightnessPage) main_screen.SetCurPage(self.BrightnessPage)
main_screen.Draw() main_screen.Draw()
main_screen.SwapAndShow() main_screen.SwapAndShow()
} }

447
Menu/GameShell/10_Settings/ButtonsLayout/buttons_layout_page.go
View File

@@ -1,112 +1,109 @@
package ButtonsLayout package ButtonsLayout
import ( import (
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"os/exec" "os/exec"
//"path/filepath" //"path/filepath"
"strings" "strings"
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
//"github.com/cuu/gogame/draw"
//"github.com/cuu/gogame/draw"
"github.com/cuu/gogame/rect"
"github.com/cuu/gogame/surface"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect"
"github.com/cuu/gogame/surface"
//"github.com/cuu/gogame/time" //"github.com/cuu/gogame/time"
//"github.com/clockworkpi/LauncherGoDev/sysgo" //"github.com/clockworkpi/LauncherGoDev/sysgo"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
) )
type UpdateConfirmPage struct { type UpdateConfirmPage struct {
UI.ConfirmPage UI.ConfirmPage
RetroArchConf string RetroArchConf string
LayoutMode string
LayoutMode string
} }
func NewUpdateConfirmPage() *UpdateConfirmPage { func NewUpdateConfirmPage() *UpdateConfirmPage {
p := &UpdateConfirmPage{} p := &UpdateConfirmPage{}
p.ListFont = UI.MyLangManager.TrFont("veramono20") p.ListFont = UI.MyLangManager.TrFont("veramono20")
p.FootMsg = [5]string{"Nav","","","Cancel","Yes"} p.FootMsg = [5]string{"Nav", "", "", "Cancel", "Yes"}
p.ConfirmText = "Apply to RetroArch?" p.ConfirmText = "Apply to RetroArch?"
p.RetroArchConf = "/home/cpi/.config/retroarch/retroarch.cfg" p.RetroArchConf = "/home/cpi/.config/retroarch/retroarch.cfg"
p.LayoutMode = "Unknown" p.LayoutMode = "Unknown"
return p return p
} }
func (self *UpdateConfirmPage) ModifyRetroArchConf( keys []string ) string { func (self *UpdateConfirmPage) ModifyRetroArchConf(keys []string) string {
if UI.FileExists(self.RetroArchConf) { if UI.FileExists(self.RetroArchConf) {
confarr,err := UI.ReadLines(self.RetroArchConf) confarr, err := UI.ReadLines(self.RetroArchConf)
var bka = false var bka = false
var bkb = false var bkb = false
var bkx = false var bkx = false
var bky = false var bky = false
if err == nil { if err == nil {
for i,ln := range confarr { for i, ln := range confarr {
parts := strings.Split(ln,"=") parts := strings.Split(ln, "=")
if len(parts) < 1 { if len(parts) < 1 {
fmt.Println("retroarch.cfg cannot parse.") fmt.Println("retroarch.cfg cannot parse.")
return "retroarch.cfg cannot parse." return "retroarch.cfg cannot parse."
} }
lnk := strings.Trim(parts[0],"\r\n ") lnk := strings.Trim(parts[0], "\r\n ")
if lnk == "input_player1_a" { if lnk == "input_player1_a" {
confarr[i] = "input_player1_a = \"" + keys[0] + "\"\n" confarr[i] = "input_player1_a = \"" + keys[0] + "\"\n"
bka=true bka = true
} }
if lnk == "input_player1_b" { if lnk == "input_player1_b" {
confarr[i] = "input_player1_b = \"" + keys[1] + "\"\n" confarr[i] = "input_player1_b = \"" + keys[1] + "\"\n"
bkb = true bkb = true
} }
if lnk == "input_player1_x" { if lnk == "input_player1_x" {
confarr[i] = "input_player1_x = \"" + keys[2] + "\"\n" confarr[i] = "input_player1_x = \"" + keys[2] + "\"\n"
bkx = true bkx = true
} }
if lnk == "input_player1_y" { if lnk == "input_player1_y" {
confarr[i] = "input_player1_y = \"" + keys[3] + "\"\n" confarr[i] = "input_player1_y = \"" + keys[3] + "\"\n"
bky = true bky = true
} }
} }
if bka == false || bkb == false || bkx == false || bky == false { if bka == false || bkb == false || bkx == false || bky == false {
fmt.Println("retroarch.cfg validation error.") fmt.Println("retroarch.cfg validation error.")
return "retroarch.cfg validation error." return "retroarch.cfg validation error."
} }
} }
err = UI.WriteLines(confarr,self.RetroArchConf) err = UI.WriteLines(confarr, self.RetroArchConf)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return "retroarch.cfg cannot write." return "retroarch.cfg cannot write."
} }
} }
fmt.Println( "Completed! Your RA keymap: " + strings.ToUpper(self.LayoutMode) ) fmt.Println("Completed! Your RA keymap: " + strings.ToUpper(self.LayoutMode))
return "Completed! Your RA keymap: " + strings.ToUpper(self.LayoutMode) return "Completed! Your RA keymap: " + strings.ToUpper(self.LayoutMode)
} }
func (self *UpdateConfirmPage) finalizeWithDialog(msg string) { func (self *UpdateConfirmPage) finalizeWithDialog(msg string) {
self.Screen.MsgBox.SetText(msg) self.Screen.MsgBox.SetText(msg)
self.Screen.MsgBox.Draw() self.Screen.MsgBox.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
return return
} }
func (self *UpdateConfirmPage) KeyDown(ev *event.Event) { func (self *UpdateConfirmPage) KeyDown(ev *event.Event) {
@@ -117,225 +114,217 @@ func (self *UpdateConfirmPage) KeyDown(ev *event.Event) {
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["B"] { if ev.Data["Key"] == UI.CurKeys["B"] {
keymap := []string{"j","k","u","i"} keymap := []string{"j", "k", "u", "i"}
if self.LayoutMode == "xbox" { if self.LayoutMode == "xbox" {
keymap = []string{"j","k","u","i"} keymap = []string{"j", "k", "u", "i"}
}else if self.LayoutMode == "snes" { } else if self.LayoutMode == "snes" {
keymap = []string{ "k","j","i","u" } keymap = []string{"k", "j", "i", "u"}
}else { } else {
self.finalizeWithDialog("Internal error.") self.finalizeWithDialog("Internal error.")
return return
} }
fmt.Println( "mode: ",self.LayoutMode) fmt.Println("mode: ", self.LayoutMode)
if UI.IsAFile(self.RetroArchConf) == false { if UI.IsAFile(self.RetroArchConf) == false {
self.finalizeWithDialog("retroarch.cfg was not found.") self.finalizeWithDialog("retroarch.cfg was not found.")
return return
} }
cpCmd := exec.Command("cp", "-rf", self.RetroArchConf,self.RetroArchConf+".blbak") cpCmd := exec.Command("cp", "-rf", self.RetroArchConf, self.RetroArchConf+".blbak")
err := cpCmd.Run() err := cpCmd.Run()
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
self.finalizeWithDialog("Cannot create .blbak") self.finalizeWithDialog("Cannot create .blbak")
return return
} }
self.finalizeWithDialog(self.ModifyRetroArchConf(keymap)) self.finalizeWithDialog(self.ModifyRetroArchConf(keymap))
return return
} }
} }
func (self *UpdateConfirmPage) OnReturnBackCb() { func (self *UpdateConfirmPage) OnReturnBackCb() {
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
func (self *UpdateConfirmPage) Draw() { func (self *UpdateConfirmPage) Draw() {
self.ClearCanvas() self.ClearCanvas()
self.DrawBG() self.DrawBG()
for _,v := range self.MyList { for _, v := range self.MyList {
v.Draw() v.Draw()
} }
self.Reset() self.Reset()
} }
type ButtonsLayoutPage struct { type ButtonsLayoutPage struct {
UI.Page
ListFontObj *ttf.Font
BGwidth int
BGheight int
UI.Page DrawOnce bool
ListFontObj *ttf.Font Scrolled int
BGwidth int Scroller *UI.ListScroller
BGheight int ConfirmPage *UpdateConfirmPage
DrawOnce bool dialog_index int
Scrolled int Icons map[string]UI.IconItemInterface
Scroller *UI.ListScroller
ConfirmPage *UpdateConfirmPage
dialog_index int ConfigFilename string
Icons map[string]UI.IconItemInterface
ConfigFilename string
} }
func NewButtonsLayoutPage() *ButtonsLayoutPage { func NewButtonsLayoutPage() *ButtonsLayoutPage {
p := &ButtonsLayoutPage{} p := &ButtonsLayoutPage{}
p.PageIconMargin = 20 p.PageIconMargin = 20
p.SelectedIconTopOffset = 20 p.SelectedIconTopOffset = 20
p.EasingDur = 10 p.EasingDur = 10
p.Align = UI.ALIGN["SLeft"] p.Align = UI.ALIGN["SLeft"]
p.FootMsg = [5]string{"Nav","UpdateRetroArch","","Back","Toggle"} p.FootMsg = [5]string{"Nav", "UpdateRetroArch", "", "Back", "Toggle"}
p.Icons = make( map[string]UI.IconItemInterface ) p.Icons = make(map[string]UI.IconItemInterface)
p.BGwidth = UI.Width p.BGwidth = UI.Width
p.BGheight = UI.Height - 24 -20 p.BGheight = UI.Height - 24 - 20
p.ConfigFilename = "sysgo/.buttonslayout" p.ConfigFilename = "sysgo/.buttonslayout"
return p return p
} }
func (self *ButtonsLayoutPage) Init() { func (self *ButtonsLayoutPage) Init() {
if self.Screen != nil { if self.Screen != nil {
if self.Screen.CanvasHWND != nil && self.CanvasHWND == nil { if self.Screen.CanvasHWND != nil && self.CanvasHWND == nil {
self.HWND = self.Screen.CanvasHWND self.HWND = self.Screen.CanvasHWND
self.CanvasHWND = surface.Surface(self.Screen.Width,self.Screen.Height) self.CanvasHWND = surface.Surface(self.Screen.Width, self.Screen.Height)
} }
} }
self.PosX = self.Index*self.Screen.Width self.PosX = self.Index * self.Screen.Width
self.Width = self.Screen.Width self.Width = self.Screen.Width
self.Height = self.Screen.Height self.Height = self.Screen.Height
DialogBoxs := UI.NewMultiIconItem()
DialogBoxs.ImgSurf = UI.MyIconPool.GetImgSurf("buttonslayout")
DialogBoxs.MyType = UI.ICON_TYPES["STAT"]
DialogBoxs.Parent = self
DialogBoxs.IconWidth = 300
DialogBoxs.IconHeight = 150
DialogBoxs.Adjust(0, 0, 134, 372, 0)
self.Icons["DialogBoxs"] = DialogBoxs
DialogBoxs := UI.NewMultiIconItem() self.Scroller = UI.NewListScroller()
DialogBoxs.ImgSurf = UI.MyIconPool.GetImgSurf("buttonslayout") self.Scroller.Parent = self
DialogBoxs.MyType = UI.ICON_TYPES["STAT"] self.Scroller.PosX = self.Width - 10
DialogBoxs.Parent = self self.Scroller.PosY = 2
DialogBoxs.IconWidth = 300 self.Scroller.Init()
DialogBoxs.IconHeight = 150 self.Scroller.SetCanvasHWND(self.HWND)
DialogBoxs.Adjust(0,0,134,372,0)
self.Icons["DialogBoxs"] = DialogBoxs
self.Scroller = UI.NewListScroller() self.ConfirmPage = NewUpdateConfirmPage()
self.Scroller.Parent = self self.ConfirmPage.LayoutMode = self.GetButtonsLayoutMode()
self.Scroller.PosX = self.Width - 10 self.ConfirmPage.Screen = self.Screen
self.Scroller.PosY = 2 self.ConfirmPage.Name = "Overwrite RA conf"
self.Scroller.Init() self.ConfirmPage.Init()
self.Scroller.SetCanvasHWND(self.HWND)
self.ConfirmPage = NewUpdateConfirmPage()
self.ConfirmPage.LayoutMode = self.GetButtonsLayoutMode()
self.ConfirmPage.Screen = self.Screen
self.ConfirmPage.Name = "Overwrite RA conf"
self.ConfirmPage.Init()
} }
func (self *ButtonsLayoutPage) ScrollUp() { func (self *ButtonsLayoutPage) ScrollUp() {
dis := 10 dis := 10
if self.PosY < 0 { if self.PosY < 0 {
self.PosY += dis self.PosY += dis
self.Scrolled += dis self.Scrolled += dis
} }
} }
func (self *ButtonsLayoutPage) ScrollDown() { func (self *ButtonsLayoutPage) ScrollDown() {
dis := 10 dis := 10
if UI.Abs(self.Scrolled) < (self.BGheight - self.Height) / 2 + 0 { if UI.Abs(self.Scrolled) < (self.BGheight-self.Height)/2+0 {
self.PosY -= dis self.PosY -= dis
self.Scrolled -=dis self.Scrolled -= dis
} }
} }
func (self *ButtonsLayoutPage) GetButtonsLayoutMode() string { func (self *ButtonsLayoutPage) GetButtonsLayoutMode() string {
lm := "xbox" lm := "xbox"
lm_bytes,err := ioutil.ReadFile(self.ConfigFilename) lm_bytes, err := ioutil.ReadFile(self.ConfigFilename)
if err == nil { if err == nil {
for _,v := range []string{"xbox","snes"} { for _, v := range []string{"xbox", "snes"} {
if v == string(lm_bytes) { if v == string(lm_bytes) {
lm = string(lm_bytes) lm = string(lm_bytes)
break break
} }
} }
} }
return lm return lm
} }
func (self *ButtonsLayoutPage) ToggleMode() { func (self *ButtonsLayoutPage) ToggleMode() {
if self.GetButtonsLayoutMode() == "xbox" {
d := []byte("snes")
err := ioutil.WriteFile(self.ConfigFilename, d, 0644)
if err != nil {
fmt.Println(err)
}
if self.GetButtonsLayoutMode() == "xbox" { self.dialog_index = 1
d := []byte("snes") self.Screen.Draw()
err := ioutil.WriteFile(self.ConfigFilename,d,0644) self.Screen.SwapAndShow()
if err != nil {
fmt.Println(err)
}
self.dialog_index = 1 } else {
self.Screen.Draw() d := []byte("xbox")
self.Screen.SwapAndShow() err := ioutil.WriteFile(self.ConfigFilename, d, 0644)
if err != nil {
fmt.Println(err)
}
}else { self.dialog_index = 0
d := []byte("xbox") self.Screen.Draw()
err := ioutil.WriteFile(self.ConfigFilename,d,0644) self.Screen.SwapAndShow()
if err != nil {
fmt.Println(err)
}
self.dialog_index = 0 }
self.Screen.Draw()
self.Screen.SwapAndShow()
}
} }
func (self *ButtonsLayoutPage) OnLoadCb() { func (self *ButtonsLayoutPage) OnLoadCb() {
self.Scrolled = 0 self.Scrolled = 0
self.PosY = 0 self.PosY = 0
self.DrawOnce = false self.DrawOnce = false
if self.GetButtonsLayoutMode() == "xbox" {
if self.GetButtonsLayoutMode() == "xbox" { self.dialog_index = 0
self.dialog_index = 0 } else {
}else { self.dialog_index = 1
self.dialog_index = 1 }
}
} }
func (self *ButtonsLayoutPage) OnReturnBackCb() { func (self *ButtonsLayoutPage) OnReturnBackCb() {
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
func (self *ButtonsLayoutPage) KeyDown(ev *event.Event) { func (self *ButtonsLayoutPage) KeyDown(ev *event.Event) {
if ev.Data["Key"] == UI.CurKeys["A"] || ev.Data["Key"] == UI.CurKeys["Menu"] { if ev.Data["Key"] == UI.CurKeys["A"] || ev.Data["Key"] == UI.CurKeys["Menu"] {
@@ -344,33 +333,31 @@ func (self *ButtonsLayoutPage) KeyDown(ev *event.Event) {
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["B"] { if ev.Data["Key"] == UI.CurKeys["B"] {
self.ToggleMode() self.ToggleMode()
} }
if ev.Data["Key"] == UI.CurKeys["X"] { if ev.Data["Key"] == UI.CurKeys["X"] {
self.ConfirmPage.LayoutMode = self.GetButtonsLayoutMode() self.ConfirmPage.LayoutMode = self.GetButtonsLayoutMode()
self.Screen.PushPage(self.ConfirmPage) self.Screen.PushPage(self.ConfirmPage)
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
} }
func (self *ButtonsLayoutPage) Draw() { func (self *ButtonsLayoutPage) Draw() {
self.ClearCanvas() self.ClearCanvas()
self.Icons["DialogBoxs"].NewCoord(0,30) self.Icons["DialogBoxs"].NewCoord(0, 30)
self.Icons["DialogBoxs"].SetIconIndex(self.dialog_index) self.Icons["DialogBoxs"].SetIconIndex(self.dialog_index)
self.Icons["DialogBoxs"].DrawTopLeft() self.Icons["DialogBoxs"].DrawTopLeft()
if self.HWND != nil { if self.HWND != nil {
surface.Fill(self.HWND, &color.Color{255,255,255,255}) surface.Fill(self.HWND, &color.Color{255, 255, 255, 255})
rect_ := rect.Rect(self.PosX,self.PosY,self.Width,self.Height) rect_ := rect.Rect(self.PosX, self.PosY, self.Width, self.Height)
surface.Blit(self.HWND,self.CanvasHWND,&rect_,nil) surface.Blit(self.HWND, self.CanvasHWND, &rect_, nil)
} }
} }

27
Menu/GameShell/10_Settings/ButtonsLayout/plugin_init.go
View File

@@ -1,14 +1,14 @@
package ButtonsLayout package ButtonsLayout
import ( import (
/* /*
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/surface" "github.com/cuu/gogame/surface"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
*/ */
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
//"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS" //"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS"
) )
@@ -16,21 +16,20 @@ import (
/******************************************************************************/ /******************************************************************************/
type ButtonsLayoutPlugin struct { type ButtonsLayoutPlugin struct {
UI.Plugin UI.Plugin
ButtonsLayoutPage *ButtonsLayoutPage ButtonsLayoutPage *ButtonsLayoutPage
} }
func (self *ButtonsLayoutPlugin) Init(main_screen *UI.MainScreen) {
func (self *ButtonsLayoutPlugin) Init( main_screen *UI.MainScreen ) {
self.ButtonsLayoutPage = NewButtonsLayoutPage() self.ButtonsLayoutPage = NewButtonsLayoutPage()
self.ButtonsLayoutPage.SetScreen( main_screen) self.ButtonsLayoutPage.SetScreen(main_screen)
self.ButtonsLayoutPage.SetName("Buttons Layout") self.ButtonsLayoutPage.SetName("Buttons Layout")
self.ButtonsLayoutPage.Init() self.ButtonsLayoutPage.Init()
} }
func (self *ButtonsLayoutPlugin) Run( main_screen *UI.MainScreen ) { func (self *ButtonsLayoutPlugin) Run(main_screen *UI.MainScreen) {
if main_screen != nil { if main_screen != nil {
main_screen.PushCurPage() main_screen.PushCurPage()
main_screen.SetCurPage(self.ButtonsLayoutPage) main_screen.SetCurPage(self.ButtonsLayoutPage)
main_screen.Draw() main_screen.Draw()
main_screen.SwapAndShow() main_screen.SwapAndShow()
} }

556
Menu/GameShell/10_Settings/GateWay/gateway_page.go
View File

@@ -1,343 +1,334 @@
package GateWay package GateWay
import ( import (
"fmt" "fmt"
//"io/ioutil" //"io/ioutil"
//"path/filepath" //"path/filepath"
"strings" "github.com/veandco/go-sdl2/ttf"
"strconv" "runtime"
"runtime" "strconv"
"github.com/veandco/go-sdl2/ttf" "strings"
//"github.com/mitchellh/go-homedir" //"github.com/mitchellh/go-homedir"
"github.com/cuu/gogame/draw" "github.com/clockworkpi/LauncherGoDev/sysgo"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
"github.com/cuu/gogame/color"
"github.com/cuu/gogame/draw"
"github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/surface" "github.com/cuu/gogame/surface"
"github.com/cuu/gogame/color"
"github.com/cuu/gogame/event"
"github.com/cuu/gogame/time" "github.com/cuu/gogame/time"
"github.com/clockworkpi/LauncherGoDev/sysgo"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
) )
type ListPageSelector struct { type ListPageSelector struct {
UI.InfoPageSelector UI.InfoPageSelector
} }
func NewListPageSelector() *ListPageSelector { func NewListPageSelector() *ListPageSelector {
p := &ListPageSelector{} p := &ListPageSelector{}
p.Width = UI.Width p.Width = UI.Width
p.BackgroundColor = &color.Color{131,199,219,255} //SkinManager().GiveColor('Front') p.BackgroundColor = &color.Color{131, 199, 219, 255} //SkinManager().GiveColor('Front')
return p return p
} }
func (self *ListPageSelector) Draw() { func (self *ListPageSelector) Draw() {
idx := self.Parent.GetPsIndex() idx := self.Parent.GetPsIndex()
mylist := self.Parent.GetMyList() mylist := self.Parent.GetMyList()
if idx < len(mylist) { if idx < len(mylist) {
x,y := mylist[idx].Coord() x, y := mylist[idx].Coord()
_,h := mylist[idx].Size() _, h := mylist[idx].Size()
self.PosX = x+2 self.PosX = x + 2
self.PosY = y+1 self.PosY = y + 1
self.Height = h-3 self.Height = h - 3
canvas_ := self.Parent.GetCanvasHWND() canvas_ := self.Parent.GetCanvasHWND()
rect_ := rect.Rect(self.PosX,self.PosY,self.Width-4, self.Height) rect_ := rect.Rect(self.PosX, self.PosY, self.Width-4, self.Height)
draw.AARoundRect(canvas_,&rect_,self.BackgroundColor,4,0,self.BackgroundColor) draw.AARoundRect(canvas_, &rect_, self.BackgroundColor, 4, 0, self.BackgroundColor)
} }
} }
type PageListItem struct { type PageListItem struct {
UI.InfoPageListItem UI.InfoPageListItem
Active bool Active bool
Value string Value string
} }
func NewPageListItem() *PageListItem { func NewPageListItem() *PageListItem {
p := &PageListItem{} p := &PageListItem{}
p.Height = UI.DefaultInfoPageListItemHeight p.Height = UI.DefaultInfoPageListItemHeight
p.ReadOnly = false p.ReadOnly = false
p.Labels = make(map[string]UI.LabelInterface) p.Labels = make(map[string]UI.LabelInterface)
p.Icons = make( map[string]UI.IconItemInterface) p.Icons = make(map[string]UI.IconItemInterface)
p.Fonts = make(map[string]*ttf.Font) p.Fonts = make(map[string]*ttf.Font)
return p return p
} }
func (self *PageListItem) Draw() { func (self *PageListItem) Draw() {
x,_ := self.Labels["Text"].Coord() x, _ := self.Labels["Text"].Coord()
w,h := self.Labels["Text"].Size() w, h := self.Labels["Text"].Size()
self.Labels["Text"].NewCoord( x, self.PosY + (self.Height - h)/2 ) self.Labels["Text"].NewCoord(x, self.PosY+(self.Height-h)/2)
if self.Active == true {
self.Parent.(*GateWayPage).Icons["done"].NewCoord(self.Parent.(*GateWayPage).Width-30, self.PosY+5)
self.Parent.(*GateWayPage).Icons["done"].Draw()
}
if self.Active == true { self.Labels["Text"].SetBold(self.Active)
self.Parent.(*GateWayPage).Icons["done"].NewCoord(self.Parent.(*GateWayPage).Width-30,self.PosY+5) self.Labels["Text"].Draw()
self.Parent.(*GateWayPage).Icons["done"].Draw()
}
self.Labels["Text"].SetBold(self.Active) if _, ok := self.Labels["Small"]; ok {
self.Labels["Text"].Draw() x, _ = self.Labels["Small"].Coord()
w, h = self.Labels["Small"].Size()
self.Labels["Small"].NewCoord(self.Width-w-10, self.PosY+(self.Height-h)/2)
self.Labels["Small"].Draw()
}
if _, ok := self.Labels["Small"]; ok { canvas_ := self.Parent.GetCanvasHWND()
x,_ = self.Labels["Small"].Coord() draw.Line(canvas_, &color.Color{169, 169, 169, 255},
w,h = self.Labels["Small"].Size() self.PosX, self.PosY+self.Height-1,
self.PosX+self.Width, self.PosY+self.Height-1, 1)
self.Labels["Small"].NewCoord( self.Width - w - 10 , self.PosY + (self.Height - h)/2 )
self.Labels["Small"].Draw()
}
canvas_ := self.Parent.GetCanvasHWND()
draw.Line(canvas_, &color.Color{169,169,169,255},
self.PosX, self.PosY+self.Height -1,
self.PosX + self.Width, self.PosY+self.Height -1 ,1)
} }
type GateWayPage struct { type GateWayPage struct {
UI.Page UI.Page
ListFont *ttf.Font ListFont *ttf.Font
BGwidth int BGwidth int
BGheight int BGheight int
DrawOnce bool DrawOnce bool
Scroller *UI.ListScroller Scroller *UI.ListScroller
Icons map[string]UI.IconItemInterface Icons map[string]UI.IconItemInterface
} }
func NewGateWayPage() *GateWayPage { func NewGateWayPage() *GateWayPage {
p := &GateWayPage{} p := &GateWayPage{}
p.ListFont = UI.Fonts["notosanscjk15"] p.ListFont = UI.Fonts["notosanscjk15"]
p.FootMsg = [5]string{"Nav","","Clear All","Back","Select"} p.FootMsg = [5]string{"Nav", "", "Clear All", "Back", "Select"}
p.BGwidth = UI.Width p.BGwidth = UI.Width
p.BGheight = UI.Height - 24 - 20 p.BGheight = UI.Height - 24 - 20
p.Icons = make(map[string]UI.IconItemInterface) p.Icons = make(map[string]UI.IconItemInterface)
return p return p
} }
func (self *GateWayPage) GenList() { func (self *GateWayPage) GenList() {
self.MyList = nil self.MyList = nil
start_x := 0 start_x := 0
start_y := 0 start_y := 0
last_height := 0 last_height := 0
var drivers = [][2]string{[2]string{"usb0","USB Ethernet"}, var drivers = [][2]string{[2]string{"usb0", "USB Ethernet"},
[2]string{sysgo.WifiDev,"Wi-Fi"}} [2]string{sysgo.WifiDev, "Wi-Fi"}}
for _, u := range drivers {
for _,u := range drivers { li := NewPageListItem()
li := NewPageListItem() li.Parent = self
li.Parent = self li.PosX = start_x
li.PosX = start_x li.PosY = start_y + last_height
li.PosY = start_y + last_height li.Width = UI.Width
li.Width = UI.Width li.Fonts["normal"] = self.ListFont
li.Fonts["normal"] = self.ListFont li.Active = false
li.Active = false li.Value = u[0]
li.Value = u[0] li.Init(u[1])
li.Init(u[1]) last_height += li.Height
last_height += li.Height self.MyList = append(self.MyList, li)
self.MyList = append(self.MyList,li) }
}
} }
func (self *GateWayPage) Init() { func (self *GateWayPage) Init() {
if self.Screen != nil { if self.Screen != nil {
if self.Screen.CanvasHWND != nil && self.CanvasHWND == nil { if self.Screen.CanvasHWND != nil && self.CanvasHWND == nil {
self.HWND = self.Screen.CanvasHWND self.HWND = self.Screen.CanvasHWND
self.CanvasHWND = surface.Surface( self.Screen.Width,self.Screen.Height ) self.CanvasHWND = surface.Surface(self.Screen.Width, self.Screen.Height)
} }
} }
self.PosX = self.Index*self.Screen.Width self.PosX = self.Index * self.Screen.Width
self.Width = self.Screen.Width self.Width = self.Screen.Width
self.Height = self.Screen.Height self.Height = self.Screen.Height
done := UI.NewIconItem() done := UI.NewIconItem()
done.ImgSurf = UI.MyIconPool.GetImgSurf("done") done.ImgSurf = UI.MyIconPool.GetImgSurf("done")
done.MyType = UI.ICON_TYPES["STAT"] done.MyType = UI.ICON_TYPES["STAT"]
done.Parent = self done.Parent = self
self.Icons["done"] = done self.Icons["done"] = done
ps := NewListPageSelector() ps := NewListPageSelector()
ps.Parent = self ps.Parent = self
self.Ps = ps self.Ps = ps
self.PsIndex = 0 self.PsIndex = 0
self.GenList() self.GenList()
self.Scroller = UI.NewListScroller() self.Scroller = UI.NewListScroller()
self.Scroller.Parent = self self.Scroller.Parent = self
self.Scroller.PosX = self.Width - 10 self.Scroller.PosX = self.Width - 10
self.Scroller.PosY = 2 self.Scroller.PosY = 2
self.Scroller.Init() self.Scroller.Init()
self.Scroller.SetCanvasHWND(self.HWND) self.Scroller.SetCanvasHWND(self.HWND)
} }
func (self *GateWayPage) Click() { func (self *GateWayPage) Click() {
if len(self.MyList) == 0 { if len(self.MyList) == 0 {
return return
} }
if self.PsIndex >= len(self.MyList) { if self.PsIndex >= len(self.MyList) {
self.PsIndex = len(self.MyList) -1 self.PsIndex = len(self.MyList) - 1
} }
cur_li := self.MyList[self.PsIndex].(*PageListItem) cur_li := self.MyList[self.PsIndex].(*PageListItem)
if cur_li.Active == true { if cur_li.Active == true {
out := UI.System( "sudo ip route | grep default | cut -d \" \" -f3" ) out := UI.System("sudo ip route | grep default | cut -d \" \" -f3")
if len(out) > 7 { if len(out) > 7 {
self.Screen.MsgBox.SetText(strings.Trim(out,"\r\n ")) self.Screen.MsgBox.SetText(strings.Trim(out, "\r\n "))
self.Screen.MsgBox.Draw() self.Screen.MsgBox.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
return return
} }
if strings.Contains(runtime.GOARCH,"arm") == true { if strings.Contains(runtime.GOARCH, "arm") == true {
for i,_ := range self.MyList { for i, _ := range self.MyList {
self.MyList[i].(*PageListItem).Active = false self.MyList[i].(*PageListItem).Active = false
} }
cur_li.Active = self.ApplyGateWay(cur_li.Value) cur_li.Active = self.ApplyGateWay(cur_li.Value)
self.Screen.MsgBox.SetText("Applying") self.Screen.MsgBox.SetText("Applying")
self.Screen.MsgBox.Draw() self.Screen.MsgBox.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
time.BlockDelay(1000) time.BlockDelay(1000)
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
}else { } else {
self.Screen.MsgBox.SetText("Do it in GameShell") self.Screen.MsgBox.SetText("Do it in GameShell")
self.Screen.MsgBox.Draw() self.Screen.MsgBox.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
} }
func (self *GateWayPage) ClearAllGateways() { func (self *GateWayPage) ClearAllGateways() {
self.Screen.MsgBox.SetText("Cleaning up") self.Screen.MsgBox.SetText("Cleaning up")
self.Screen.MsgBox.Draw() self.Screen.MsgBox.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
UI.System("sudo ip route del 0/0") UI.System("sudo ip route del 0/0")
time.BlockDelay(800) time.BlockDelay(800)
for i,_ := range self.MyList { for i, _ := range self.MyList {
self.MyList[i].(*PageListItem).Active = false self.MyList[i].(*PageListItem).Active = false
} }
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
func (self *GateWayPage) ApplyGateWay( gateway string ) bool { func (self *GateWayPage) ApplyGateWay(gateway string) bool {
UI.System("sudo ip route del 0/0") UI.System("sudo ip route del 0/0")
if gateway == "usb0" { if gateway == "usb0" {
out := UI.System("sudo ifconfig usb0 | grep inet | tr -s \" \"| cut -d \" \" -f3") out := UI.System("sudo ifconfig usb0 | grep inet | tr -s \" \"| cut -d \" \" -f3")
if len(out) > 7 { if len(out) > 7 {
if strings.Contains(out,"error") == false { if strings.Contains(out, "error") == false {
out = strings.Trim(out,"\r\n ") out = strings.Trim(out, "\r\n ")
parts := strings.Split(out,".") parts := strings.Split(out, ".")
if len(parts) == 4 { // IPv4 if len(parts) == 4 { // IPv4
tmp,err := strconv.Atoi(parts[3]) tmp, err := strconv.Atoi(parts[3])
if err == nil { if err == nil {
if tmp == 0 { if tmp == 0 {
tmp = tmp + 1 tmp = tmp + 1
}else if tmp == 1 { } else if tmp == 1 {
tmp = tmp + 1 tmp = tmp + 1
}else if tmp > 1 { } else if tmp > 1 {
tmp = tmp -1 tmp = tmp - 1
} }
parts[3] = strconv.Itoa(tmp) parts[3] = strconv.Itoa(tmp)
ipaddress := strings.Join(parts,".") ipaddress := strings.Join(parts, ".")
UI.System( fmt.Sprintf("sudo route add default gw %s",ipaddress) ) UI.System(fmt.Sprintf("sudo route add default gw %s", ipaddress))
return true return true
} }
} }
} }
} }
}else { // wlan0 } else { // wlan0
if self.Screen.IsWifiConnectedNow() == true { if self.Screen.IsWifiConnectedNow() == true {
UI.System(fmt.Sprintf("sudo dhclient %s",sysgo.WifiDev)) UI.System(fmt.Sprintf("sudo dhclient %s", sysgo.WifiDev))
return true return true
}else { } else {
self.Screen.MsgBox.SetText("Wi-Fi is not connected") self.Screen.MsgBox.SetText("Wi-Fi is not connected")
self.Screen.MsgBox.Draw() self.Screen.MsgBox.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
return false return false
} }
} }
return false return false
} }
func (self *GateWayPage) OnLoadCb() { func (self *GateWayPage) OnLoadCb() {
self.PosY = 0 self.PosY = 0
self.DrawOnce = false self.DrawOnce = false
thedrv := "" thedrv := ""
if strings.Contains(runtime.GOARCH,"arm") == true { if strings.Contains(runtime.GOARCH, "arm") == true {
out := UI.System("sudo ip route | grep default") out := UI.System("sudo ip route | grep default")
if len(out) > 7 { if len(out) > 7 {
if strings.Contains(out,"usb0") { if strings.Contains(out, "usb0") {
thedrv = "usb0" thedrv = "usb0"
}else if strings.Contains(out,sysgo.WifiDev) { } else if strings.Contains(out, sysgo.WifiDev) {
thedrv = sysgo.WifiDev thedrv = sysgo.WifiDev
} }
} }
} }
for i, _ := range self.MyList { for i, _ := range self.MyList {
self.MyList[i].(*PageListItem).Active = false self.MyList[i].(*PageListItem).Active = false
} }
if thedrv != "" { if thedrv != "" {
for i, v := range self.MyList { for i, v := range self.MyList {
if strings.Contains( v.(*PageListItem).Value, thedrv) { if strings.Contains(v.(*PageListItem).Value, thedrv) {
self.MyList[i].(*PageListItem).Active = true self.MyList[i].(*PageListItem).Active = true
} }
} }
} }
} }
func (self *GateWayPage) KeyDown(ev *event.Event ) { func (self *GateWayPage) KeyDown(ev *event.Event) {
if ev.Data["Key"] == UI.CurKeys["A"] || ev.Data["Key"] == UI.CurKeys["Menu"] { if ev.Data["Key"] == UI.CurKeys["A"] || ev.Data["Key"] == UI.CurKeys["Menu"] {
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
@@ -345,80 +336,79 @@ func (self *GateWayPage) KeyDown(ev *event.Event ) {
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["B"] { if ev.Data["Key"] == UI.CurKeys["B"] {
self.Click() self.Click()
} }
if ev.Data["Key"] == UI.CurKeys["Y"] { if ev.Data["Key"] == UI.CurKeys["Y"] {
self.ClearAllGateways() self.ClearAllGateways()
} }
if ev.Data["Key"] == UI.CurKeys["Up"] { if ev.Data["Key"] == UI.CurKeys["Up"] {
self.ScrollUp() self.ScrollUp()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["Down"] { if ev.Data["Key"] == UI.CurKeys["Down"] {
self.ScrollDown() self.ScrollDown()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
} }
func (self *GateWayPage) Draw() { func (self *GateWayPage) Draw() {
self.ClearCanvas() self.ClearCanvas()
if len(self.MyList) == 0 { if len(self.MyList) == 0 {
return return
} }
if len(self.MyList) * UI.DefaultInfoPageListItemHeight > self.Height { if len(self.MyList)*UI.DefaultInfoPageListItemHeight > self.Height {
self.Ps.(*ListPageSelector).Width = self.Width - 11 self.Ps.(*ListPageSelector).Width = self.Width - 11
self.Ps.Draw() self.Ps.Draw()
for _,v := range self.MyList { for _, v := range self.MyList {
if v.(*PageListItem).PosY > self.Height + self.Height/2 { if v.(*PageListItem).PosY > self.Height+self.Height/2 {
break break
} }
if v.(*PageListItem).PosY < 0 { if v.(*PageListItem).PosY < 0 {
continue continue
} }
v.Draw() v.Draw()
} }
self.Scroller.UpdateSize( len(self.MyList)*UI.DefaultInfoPageListItemHeight, self.Scroller.UpdateSize(len(self.MyList)*UI.DefaultInfoPageListItemHeight,
self.PsIndex*UI.DefaultInfoPageListItemHeight) self.PsIndex*UI.DefaultInfoPageListItemHeight)
self.Scroller.Draw() self.Scroller.Draw()
}else { } else {
self.Ps.(*ListPageSelector).Width = self.Width self.Ps.(*ListPageSelector).Width = self.Width
self.Ps.Draw() self.Ps.Draw()
for _,v := range self.MyList { for _, v := range self.MyList {
if v.(*PageListItem).PosY > self.Height + self.Height/2 { if v.(*PageListItem).PosY > self.Height+self.Height/2 {
break break
} }
if v.(*PageListItem).PosY < 0 { if v.(*PageListItem).PosY < 0 {
continue continue
} }
v.Draw() v.Draw()
} }
} }
if self.HWND != nil { if self.HWND != nil {
surface.Fill(self.HWND, &color.Color{255,255,255,255}) surface.Fill(self.HWND, &color.Color{255, 255, 255, 255})
rect_ := rect.Rect(self.PosX,self.PosY,self.Width,self.Height) rect_ := rect.Rect(self.PosX, self.PosY, self.Width, self.Height)
surface.Blit(self.HWND,self.CanvasHWND,&rect_,nil) surface.Blit(self.HWND, self.CanvasHWND, &rect_, nil)
} }
} }

27
Menu/GameShell/10_Settings/GateWay/plugin_init.go
View File

@@ -1,14 +1,14 @@
package GateWay package GateWay
import ( import (
/* /*
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/surface" "github.com/cuu/gogame/surface"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
*/ */
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
//"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS" //"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS"
) )
@@ -16,21 +16,20 @@ import (
/******************************************************************************/ /******************************************************************************/
type GatewayPlugin struct { type GatewayPlugin struct {
UI.Plugin UI.Plugin
Page1st *GateWayPage Page1st *GateWayPage
} }
func (self *GatewayPlugin) Init(main_screen *UI.MainScreen) {
func (self *GatewayPlugin) Init( main_screen *UI.MainScreen ) {
self.Page1st = NewGateWayPage() self.Page1st = NewGateWayPage()
self.Page1st.SetScreen( main_screen) self.Page1st.SetScreen(main_screen)
self.Page1st.SetName("Gateway switch") self.Page1st.SetName("Gateway switch")
self.Page1st.Init() self.Page1st.Init()
} }
func (self *GatewayPlugin) Run( main_screen *UI.MainScreen ) { func (self *GatewayPlugin) Run(main_screen *UI.MainScreen) {
if main_screen != nil { if main_screen != nil {
main_screen.PushCurPage() main_screen.PushCurPage()
main_screen.SetCurPage(self.Page1st) main_screen.SetCurPage(self.Page1st)
main_screen.Draw() main_screen.Draw()
main_screen.SwapAndShow() main_screen.SwapAndShow()
} }

442
Menu/GameShell/10_Settings/Languages/languages_page.go
View File

@@ -1,290 +1,281 @@
package Languages package Languages
import ( import (
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"path/filepath" "path/filepath"
"strings" "strings"
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/color"
"github.com/cuu/gogame/draw" "github.com/cuu/gogame/draw"
"github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/surface" "github.com/cuu/gogame/surface"
"github.com/cuu/gogame/color"
"github.com/cuu/gogame/event"
"github.com/cuu/gogame/time" "github.com/cuu/gogame/time"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
) )
type ListPageSelector struct { type ListPageSelector struct {
UI.InfoPageSelector UI.InfoPageSelector
} }
func NewListPageSelector() *ListPageSelector { func NewListPageSelector() *ListPageSelector {
p := &ListPageSelector{} p := &ListPageSelector{}
p.Width = UI.Width p.Width = UI.Width
p.BackgroundColor = &color.Color{131,199,219,255} //SkinManager().GiveColor('Front') p.BackgroundColor = &color.Color{131, 199, 219, 255} //SkinManager().GiveColor('Front')
return p return p
} }
func (self *ListPageSelector) Draw() { func (self *ListPageSelector) Draw() {
idx := self.Parent.GetPsIndex() idx := self.Parent.GetPsIndex()
mylist := self.Parent.GetMyList() mylist := self.Parent.GetMyList()
if idx < len(mylist) { if idx < len(mylist) {
x,y := mylist[idx].Coord() x, y := mylist[idx].Coord()
_,h := mylist[idx].Size() _, h := mylist[idx].Size()
self.PosX = x+2 self.PosX = x + 2
self.PosY = y+1 self.PosY = y + 1
self.Height = h-3 self.Height = h - 3
canvas_ := self.Parent.GetCanvasHWND() canvas_ := self.Parent.GetCanvasHWND()
rect_ := rect.Rect(self.PosX,self.PosY,self.Width-4, self.Height) rect_ := rect.Rect(self.PosX, self.PosY, self.Width-4, self.Height)
draw.AARoundRect(canvas_,&rect_,self.BackgroundColor,4,0,self.BackgroundColor) draw.AARoundRect(canvas_, &rect_, self.BackgroundColor, 4, 0, self.BackgroundColor)
} }
} }
type PageListItem struct { type PageListItem struct {
UI.InfoPageListItem UI.InfoPageListItem
Active bool Active bool
Value string Value string
} }
func NewPageListItem() *PageListItem { func NewPageListItem() *PageListItem {
p := &PageListItem{} p := &PageListItem{}
p.Height = UI.DefaultInfoPageListItemHeight p.Height = UI.DefaultInfoPageListItemHeight
p.ReadOnly = false p.ReadOnly = false
p.Labels = make(map[string]UI.LabelInterface) p.Labels = make(map[string]UI.LabelInterface)
p.Icons = make( map[string]UI.IconItemInterface) p.Icons = make(map[string]UI.IconItemInterface)
p.Fonts = make(map[string]*ttf.Font) p.Fonts = make(map[string]*ttf.Font)
return p return p
} }
func (self *PageListItem) Draw() { func (self *PageListItem) Draw() {
x,_ := self.Labels["Text"].Coord() x, _ := self.Labels["Text"].Coord()
w,h := self.Labels["Text"].Size() w, h := self.Labels["Text"].Size()
self.Labels["Text"].NewCoord( x, self.PosY + (self.Height - h)/2 ) self.Labels["Text"].NewCoord(x, self.PosY+(self.Height-h)/2)
if self.Active == true {
self.Parent.(*LanguagesPage).Icons["done"].NewCoord(self.Parent.(*LanguagesPage).Width-30, self.PosY+5)
self.Parent.(*LanguagesPage).Icons["done"].Draw()
}
if self.Active == true { self.Labels["Text"].SetBold(self.Active)
self.Parent.(*LanguagesPage).Icons["done"].NewCoord(self.Parent.(*LanguagesPage).Width-30,self.PosY+5) self.Labels["Text"].Draw()
self.Parent.(*LanguagesPage).Icons["done"].Draw()
}
self.Labels["Text"].SetBold(self.Active) if _, ok := self.Labels["Small"]; ok {
self.Labels["Text"].Draw() x, _ = self.Labels["Small"].Coord()
w, h = self.Labels["Small"].Size()
self.Labels["Small"].NewCoord(self.Width-w-10, self.PosY+(self.Height-h)/2)
self.Labels["Small"].Draw()
}
if _, ok := self.Labels["Small"]; ok { canvas_ := self.Parent.GetCanvasHWND()
x,_ = self.Labels["Small"].Coord() draw.Line(canvas_, &color.Color{169, 169, 169, 255},
w,h = self.Labels["Small"].Size() self.PosX, self.PosY+self.Height-1,
self.PosX+self.Width, self.PosY+self.Height-1, 1)
self.Labels["Small"].NewCoord( self.Width - w - 10 , self.PosY + (self.Height - h)/2 )
self.Labels["Small"].Draw()
}
canvas_ := self.Parent.GetCanvasHWND()
draw.Line(canvas_, &color.Color{169,169,169,255},
self.PosX, self.PosY+self.Height -1,
self.PosX + self.Width, self.PosY+self.Height -1 ,1)
} }
type LanguagesPage struct { type LanguagesPage struct {
UI.Page UI.Page
ListFont *ttf.Font ListFont *ttf.Font
BGwidth int BGwidth int
BGheight int BGheight int
DrawOnce bool DrawOnce bool
Scroller *UI.ListScroller Scroller *UI.ListScroller
Icons map[string]UI.IconItemInterface Icons map[string]UI.IconItemInterface
} }
func NewLanguagesPage() *LanguagesPage { func NewLanguagesPage() *LanguagesPage {
p := &LanguagesPage{} p := &LanguagesPage{}
p.ListFont = UI.Fonts["notosanscjk15"] p.ListFont = UI.Fonts["notosanscjk15"]
p.FootMsg = [5]string{"Nav","","","Back","Select"} p.FootMsg = [5]string{"Nav", "", "", "Back", "Select"}
p.BGwidth = UI.Width p.BGwidth = UI.Width
p.BGheight = UI.Height - 24 - 20 p.BGheight = UI.Height - 24 - 20
p.Icons = make(map[string]UI.IconItemInterface) p.Icons = make(map[string]UI.IconItemInterface)
return p return p
} }
func (self *LanguagesPage) GenList() { func (self *LanguagesPage) GenList() {
self.MyList = nil self.MyList = nil
start_x := 0 start_x := 0
start_y := 0 start_y := 0
last_height := 0 last_height := 0
file_paths,err := filepath.Glob("sysgo/langs/*.ini")//sorted file_paths, err := filepath.Glob("sysgo/langs/*.ini") //sorted
if err == nil { if err == nil {
for _,u := range file_paths { for _, u := range file_paths {
parts := strings.Split(filepath.Base(u),"_") parts := strings.Split(filepath.Base(u), "_")
if len(parts) > 1 { if len(parts) > 1 {
li := NewPageListItem() li := NewPageListItem()
li.Parent = self li.Parent = self
li.PosX = start_x li.PosX = start_x
li.PosY = start_y + last_height li.PosY = start_y + last_height
li.Width = UI.Width li.Width = UI.Width
li.Fonts["normal"] = self.ListFont li.Fonts["normal"] = self.ListFont
li.Active = false li.Active = false
li.Value = filepath.Base(u) li.Value = filepath.Base(u)
lang_name := parts[1] lang_name := parts[1]
parts = strings.Split(lang_name,".") parts = strings.Split(lang_name, ".")
lang_name = parts[0] lang_name = parts[0]
li.Init(lang_name) li.Init(lang_name)
last_height += li.Height last_height += li.Height
self.MyList = append(self.MyList,li) self.MyList = append(self.MyList, li)
} }
} }
} }
} }
func (self *LanguagesPage) Init() { func (self *LanguagesPage) Init() {
if self.Screen != nil { if self.Screen != nil {
if self.Screen.CanvasHWND != nil && self.CanvasHWND == nil { if self.Screen.CanvasHWND != nil && self.CanvasHWND == nil {
self.HWND = self.Screen.CanvasHWND self.HWND = self.Screen.CanvasHWND
self.CanvasHWND = surface.Surface( self.Screen.Width,self.Screen.Height ) self.CanvasHWND = surface.Surface(self.Screen.Width, self.Screen.Height)
} }
} }
self.PosX = self.Index*self.Screen.Width self.PosX = self.Index * self.Screen.Width
self.Width = self.Screen.Width self.Width = self.Screen.Width
self.Height = self.Screen.Height self.Height = self.Screen.Height
done := UI.NewIconItem() done := UI.NewIconItem()
done.ImgSurf = UI.MyIconPool.GetImgSurf("done") done.ImgSurf = UI.MyIconPool.GetImgSurf("done")
done.MyType = UI.ICON_TYPES["STAT"] done.MyType = UI.ICON_TYPES["STAT"]
done.Parent = self done.Parent = self
self.Icons["done"] = done self.Icons["done"] = done
ps := NewListPageSelector() ps := NewListPageSelector()
ps.Parent = self ps.Parent = self
self.Ps = ps self.Ps = ps
self.PsIndex = 0 self.PsIndex = 0
self.GenList() self.GenList()
self.Scroller = UI.NewListScroller() self.Scroller = UI.NewListScroller()
self.Scroller.Parent = self self.Scroller.Parent = self
self.Scroller.PosX = self.Width - 10 self.Scroller.PosX = self.Width - 10
self.Scroller.PosY = 2 self.Scroller.PosY = 2
self.Scroller.Init() self.Scroller.Init()
self.Scroller.SetCanvasHWND(self.HWND) self.Scroller.SetCanvasHWND(self.HWND)
} }
func (self *LanguagesPage) Click() { func (self *LanguagesPage) Click() {
if len(self.MyList) == 0 { if len(self.MyList) == 0 {
return return
} }
if self.PsIndex >= len(self.MyList) { if self.PsIndex >= len(self.MyList) {
self.PsIndex = len(self.MyList) -1 self.PsIndex = len(self.MyList) - 1
} }
cur_li := self.MyList[self.PsIndex] cur_li := self.MyList[self.PsIndex]
if cur_li.(*PageListItem).Active == true { if cur_li.(*PageListItem).Active == true {
return return
} }
for i,_ := range self.MyList { for i, _ := range self.MyList {
self.MyList[i].(*PageListItem).Active = false self.MyList[i].(*PageListItem).Active = false
} }
cur_li.(*PageListItem).Active = true cur_li.(*PageListItem).Active = true
d := []byte(fmt.Sprintf("%s",cur_li.(*PageListItem).Value)) d := []byte(fmt.Sprintf("%s", cur_li.(*PageListItem).Value))
err := ioutil.WriteFile("sysgo/.lang", d, 0644) err := ioutil.WriteFile("sysgo/.lang", d, 0644)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
} }
self.Screen.MsgBox.SetText("Applying") self.Screen.MsgBox.SetText("Applying")
self.Screen.MsgBox.Draw() self.Screen.MsgBox.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
UI.MyLangManager.UpdateLang() UI.MyLangManager.UpdateLang()
event.Post(UI.RESTARTUI,"") event.Post(UI.RESTARTUI, "")
time.BlockDelay(1000) time.BlockDelay(1000)
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
func (self *LanguagesPage) OnLoadCb() { func (self *LanguagesPage) OnLoadCb() {
self.PosY = 0 self.PosY = 0
self.DrawOnce = false self.DrawOnce = false
fname :="sysgo/.lang" fname := "sysgo/.lang"
thelang := "" thelang := ""
if UI.FileExists(fname) { if UI.FileExists(fname) {
config_bytes,err := ioutil.ReadFile(fname) config_bytes, err := ioutil.ReadFile(fname)
if err == nil { if err == nil {
thelang = strings.Trim(string(config_bytes),"\r\n ") thelang = strings.Trim(string(config_bytes), "\r\n ")
if len(thelang) < 3 { if len(thelang) < 3 {
thelang = "English" thelang = "English"
} }
} }
for i, v := range self.MyList { for i, v := range self.MyList {
if strings.Contains( v.(*PageListItem).Value, thelang) { if strings.Contains(v.(*PageListItem).Value, thelang) {
self.MyList[i].(*PageListItem).Active = true self.MyList[i].(*PageListItem).Active = true
break break
} }
} }
} }
} }
func (self *LanguagesPage) KeyDown(ev *event.Event ) { func (self *LanguagesPage) KeyDown(ev *event.Event) {
if ev.Data["Key"] == UI.CurKeys["A"] || ev.Data["Key"] == UI.CurKeys["Menu"] { if ev.Data["Key"] == UI.CurKeys["A"] || ev.Data["Key"] == UI.CurKeys["Menu"] {
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
@@ -292,76 +283,75 @@ func (self *LanguagesPage) KeyDown(ev *event.Event ) {
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["B"] { if ev.Data["Key"] == UI.CurKeys["B"] {
self.Click() self.Click()
} }
if ev.Data["Key"] == UI.CurKeys["Up"] { if ev.Data["Key"] == UI.CurKeys["Up"] {
self.ScrollUp() self.ScrollUp()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["Down"] { if ev.Data["Key"] == UI.CurKeys["Down"] {
self.ScrollDown() self.ScrollDown()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
} }
func (self *LanguagesPage) Draw() { func (self *LanguagesPage) Draw() {
self.ClearCanvas() self.ClearCanvas()
if len(self.MyList) == 0 { if len(self.MyList) == 0 {
return return
} }
if len(self.MyList) * UI.DefaultInfoPageListItemHeight > self.Height { if len(self.MyList)*UI.DefaultInfoPageListItemHeight > self.Height {
self.Ps.(*ListPageSelector).Width = self.Width - 11 self.Ps.(*ListPageSelector).Width = self.Width - 11
self.Ps.Draw() self.Ps.Draw()
for _,v := range self.MyList { for _, v := range self.MyList {
if v.(*PageListItem).PosY > self.Height + self.Height/2 { if v.(*PageListItem).PosY > self.Height+self.Height/2 {
break break
} }
if v.(*PageListItem).PosY < 0 { if v.(*PageListItem).PosY < 0 {
continue continue
} }
v.Draw() v.Draw()
} }
self.Scroller.UpdateSize( len(self.MyList)*UI.DefaultInfoPageListItemHeight, self.Scroller.UpdateSize(len(self.MyList)*UI.DefaultInfoPageListItemHeight,
self.PsIndex*UI.DefaultInfoPageListItemHeight) self.PsIndex*UI.DefaultInfoPageListItemHeight)
self.Scroller.Draw() self.Scroller.Draw()
}else { } else {
self.Ps.(*ListPageSelector).Width = self.Width self.Ps.(*ListPageSelector).Width = self.Width
self.Ps.Draw() self.Ps.Draw()
for _,v := range self.MyList { for _, v := range self.MyList {
if v.(*PageListItem).PosY > self.Height + self.Height/2 { if v.(*PageListItem).PosY > self.Height+self.Height/2 {
break break
} }
if v.(*PageListItem).PosY < 0 { if v.(*PageListItem).PosY < 0 {
continue continue
} }
v.Draw() v.Draw()
} }
} }
if self.HWND != nil { if self.HWND != nil {
surface.Fill(self.HWND, &color.Color{255,255,255,255}) surface.Fill(self.HWND, &color.Color{255, 255, 255, 255})
rect_ := rect.Rect(self.PosX,self.PosY,self.Width,self.Height) rect_ := rect.Rect(self.PosX, self.PosY, self.Width, self.Height)
surface.Blit(self.HWND,self.CanvasHWND,&rect_,nil) surface.Blit(self.HWND, self.CanvasHWND, &rect_, nil)
} }
} }

27
Menu/GameShell/10_Settings/Languages/plugin_init.go
View File

@@ -1,14 +1,14 @@
package Languages package Languages
import ( import (
/* /*
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/surface" "github.com/cuu/gogame/surface"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
*/ */
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
//"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS" //"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS"
) )
@@ -16,21 +16,20 @@ import (
/******************************************************************************/ /******************************************************************************/
type LanguagesPlugin struct { type LanguagesPlugin struct {
UI.Plugin UI.Plugin
LanguagesPage *LanguagesPage LanguagesPage *LanguagesPage
} }
func (self *LanguagesPlugin) Init(main_screen *UI.MainScreen) {
func (self *LanguagesPlugin) Init( main_screen *UI.MainScreen ) {
self.LanguagesPage = NewLanguagesPage() self.LanguagesPage = NewLanguagesPage()
self.LanguagesPage.SetScreen( main_screen) self.LanguagesPage.SetScreen(main_screen)
self.LanguagesPage.SetName("Languages") self.LanguagesPage.SetName("Languages")
self.LanguagesPage.Init() self.LanguagesPage.Init()
} }
func (self *LanguagesPlugin) Run( main_screen *UI.MainScreen ) { func (self *LanguagesPlugin) Run(main_screen *UI.MainScreen) {
if main_screen != nil { if main_screen != nil {
main_screen.PushCurPage() main_screen.PushCurPage()
main_screen.SetCurPage(self.LanguagesPage) main_screen.SetCurPage(self.LanguagesPage)
main_screen.Draw() main_screen.Draw()
main_screen.SwapAndShow() main_screen.SwapAndShow()
} }

50
Menu/GameShell/10_Settings/LauncherPy/plugin_init.go
View File

@@ -1,43 +1,43 @@
package LauncherPy package LauncherPy
import ( import (
"log" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
"os/exec" "github.com/cuu/gogame/time"
"os/user" "log"
"github.com/cuu/gogame/time" "os/exec"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "os/user"
) )
/******************************************************************************/ /******************************************************************************/
type LauncherPyPlugin struct { type LauncherPyPlugin struct {
UI.Plugin UI.Plugin
} }
func (self *LauncherPyPlugin) Init( main_screen *UI.MainScreen ) { func (self *LauncherPyPlugin) Init(main_screen *UI.MainScreen) {
} }
func (self *LauncherPyPlugin) Run( main_screen *UI.MainScreen ) { func (self *LauncherPyPlugin) Run(main_screen *UI.MainScreen) {
if main_screen != nil { if main_screen != nil {
main_screen.MsgBox.SetText("Rebooting to Launcher") main_screen.MsgBox.SetText("Rebooting to Launcher")
main_screen.MsgBox.Draw() main_screen.MsgBox.Draw()
main_screen.SwapAndShow() main_screen.SwapAndShow()
time.BlockDelay(550) time.BlockDelay(550)
usr, _ := user.Current() usr, _ := user.Current()
dir := usr.HomeDir dir := usr.HomeDir
if usr.Username == "root" { if usr.Username == "root" {
dir = "/home/cpi" dir = "/home/cpi"
} }
cmd := exec.Command("sed","-i","s/launchergo/launcher/g",dir+"/.bashrc") cmd := exec.Command("sed", "-i", "s/launchergo/launcher/g", dir+"/.bashrc")
err := cmd.Run() err := cmd.Run()
if err != nil { if err != nil {
log.Println("sed failed", err) log.Println("sed failed", err)
}else { } else {
cmd = exec.Command("sudo","reboot") cmd = exec.Command("sudo", "reboot")
cmd.Run() cmd.Run()
} }
} }
} }

456
Menu/GameShell/10_Settings/Lima/gpu_driver_page.go
View File

@@ -1,291 +1,282 @@
package Lima package Lima
import ( import (
//"fmt" //"fmt"
//"io/ioutil" //"io/ioutil"
//"path/filepath" //"path/filepath"
"strings" "github.com/mitchellh/go-homedir"
"runtime" "github.com/veandco/go-sdl2/ttf"
"github.com/veandco/go-sdl2/ttf" "runtime"
"github.com/mitchellh/go-homedir" "strings"
"github.com/cuu/gogame/draw" "github.com/cuu/gogame/color"
"github.com/cuu/gogame/draw"
"github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/surface" "github.com/cuu/gogame/surface"
"github.com/cuu/gogame/color"
"github.com/cuu/gogame/event"
"github.com/cuu/gogame/time" "github.com/cuu/gogame/time"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
) )
type ListPageSelector struct { type ListPageSelector struct {
UI.InfoPageSelector UI.InfoPageSelector
} }
func NewListPageSelector() *ListPageSelector { func NewListPageSelector() *ListPageSelector {
p := &ListPageSelector{} p := &ListPageSelector{}
p.Width = UI.Width p.Width = UI.Width
p.BackgroundColor = &color.Color{131,199,219,255} //SkinManager().GiveColor('Front') p.BackgroundColor = &color.Color{131, 199, 219, 255} //SkinManager().GiveColor('Front')
return p return p
} }
func (self *ListPageSelector) Draw() { func (self *ListPageSelector) Draw() {
idx := self.Parent.GetPsIndex() idx := self.Parent.GetPsIndex()
mylist := self.Parent.GetMyList() mylist := self.Parent.GetMyList()
if idx < len(mylist) { if idx < len(mylist) {
x,y := mylist[idx].Coord() x, y := mylist[idx].Coord()
_,h := mylist[idx].Size() _, h := mylist[idx].Size()
self.PosX = x+2 self.PosX = x + 2
self.PosY = y+1 self.PosY = y + 1
self.Height = h-3 self.Height = h - 3
canvas_ := self.Parent.GetCanvasHWND() canvas_ := self.Parent.GetCanvasHWND()
rect_ := rect.Rect(self.PosX,self.PosY,self.Width-4, self.Height) rect_ := rect.Rect(self.PosX, self.PosY, self.Width-4, self.Height)
draw.AARoundRect(canvas_,&rect_,self.BackgroundColor,4,0,self.BackgroundColor) draw.AARoundRect(canvas_, &rect_, self.BackgroundColor, 4, 0, self.BackgroundColor)
} }
} }
type PageListItem struct { type PageListItem struct {
UI.InfoPageListItem UI.InfoPageListItem
Active bool Active bool
Value string Value string
} }
func NewPageListItem() *PageListItem { func NewPageListItem() *PageListItem {
p := &PageListItem{} p := &PageListItem{}
p.Height = UI.DefaultInfoPageListItemHeight p.Height = UI.DefaultInfoPageListItemHeight
p.ReadOnly = false p.ReadOnly = false
p.Labels = make(map[string]UI.LabelInterface) p.Labels = make(map[string]UI.LabelInterface)
p.Icons = make( map[string]UI.IconItemInterface) p.Icons = make(map[string]UI.IconItemInterface)
p.Fonts = make(map[string]*ttf.Font) p.Fonts = make(map[string]*ttf.Font)
return p return p
} }
func (self *PageListItem) Draw() { func (self *PageListItem) Draw() {
x,_ := self.Labels["Text"].Coord() x, _ := self.Labels["Text"].Coord()
w,h := self.Labels["Text"].Size() w, h := self.Labels["Text"].Size()
self.Labels["Text"].NewCoord( x, self.PosY + (self.Height - h)/2 ) self.Labels["Text"].NewCoord(x, self.PosY+(self.Height-h)/2)
if self.Active == true {
self.Parent.(*GPUDriverPage).Icons["done"].NewCoord(self.Parent.(*GPUDriverPage).Width-30, self.PosY+5)
self.Parent.(*GPUDriverPage).Icons["done"].Draw()
}
if self.Active == true { self.Labels["Text"].SetBold(self.Active)
self.Parent.(*GPUDriverPage).Icons["done"].NewCoord(self.Parent.(*GPUDriverPage).Width-30,self.PosY+5) self.Labels["Text"].Draw()
self.Parent.(*GPUDriverPage).Icons["done"].Draw()
}
self.Labels["Text"].SetBold(self.Active) if _, ok := self.Labels["Small"]; ok {
self.Labels["Text"].Draw() x, _ = self.Labels["Small"].Coord()
w, h = self.Labels["Small"].Size()
self.Labels["Small"].NewCoord(self.Width-w-10, self.PosY+(self.Height-h)/2)
self.Labels["Small"].Draw()
}
if _, ok := self.Labels["Small"]; ok { canvas_ := self.Parent.GetCanvasHWND()
x,_ = self.Labels["Small"].Coord() draw.Line(canvas_, &color.Color{169, 169, 169, 255},
w,h = self.Labels["Small"].Size() self.PosX, self.PosY+self.Height-1,
self.PosX+self.Width, self.PosY+self.Height-1, 1)
self.Labels["Small"].NewCoord( self.Width - w - 10 , self.PosY + (self.Height - h)/2 )
self.Labels["Small"].Draw()
}
canvas_ := self.Parent.GetCanvasHWND()
draw.Line(canvas_, &color.Color{169,169,169,255},
self.PosX, self.PosY+self.Height -1,
self.PosX + self.Width, self.PosY+self.Height -1 ,1)
} }
type GPUDriverPage struct { type GPUDriverPage struct {
UI.Page UI.Page
ListFont *ttf.Font ListFont *ttf.Font
BGwidth int BGwidth int
BGheight int BGheight int
DrawOnce bool DrawOnce bool
Scroller *UI.ListScroller Scroller *UI.ListScroller
Icons map[string]UI.IconItemInterface Icons map[string]UI.IconItemInterface
} }
func NewGPUDriverPage() *GPUDriverPage { func NewGPUDriverPage() *GPUDriverPage {
p := &GPUDriverPage{} p := &GPUDriverPage{}
p.ListFont = UI.Fonts["notosanscjk12"] p.ListFont = UI.Fonts["notosanscjk12"]
p.FootMsg = [5]string{"Nav","","","Back","Select"} p.FootMsg = [5]string{"Nav", "", "", "Back", "Select"}
p.BGwidth = UI.Width p.BGwidth = UI.Width
p.BGheight = UI.Height - 24 - 20 p.BGheight = UI.Height - 24 - 20
p.Icons = make(map[string]UI.IconItemInterface) p.Icons = make(map[string]UI.IconItemInterface)
return p return p
} }
func (self *GPUDriverPage) GenList() { func (self *GPUDriverPage) GenList() {
self.MyList = nil self.MyList = nil
start_x := 0 start_x := 0
start_y := 0 start_y := 0
last_height := 0 last_height := 0
var drivers = [][2]string{[2]string{"fbturbo","FBTURBO driver (Software Rendering)"}, var drivers = [][2]string{[2]string{"fbturbo", "FBTURBO driver (Software Rendering)"},
[2]string{"modesetting","LIMA driver (Experimental Hardware Rendering)"}} [2]string{"modesetting", "LIMA driver (Experimental Hardware Rendering)"}}
for _, u := range drivers {
for _,u := range drivers { li := NewPageListItem()
li := NewPageListItem() li.Parent = self
li.Parent = self li.PosX = start_x
li.PosX = start_x li.PosY = start_y + last_height
li.PosY = start_y + last_height li.Width = UI.Width
li.Width = UI.Width li.Fonts["normal"] = self.ListFont
li.Fonts["normal"] = self.ListFont li.Active = false
li.Active = false li.Value = u[0]
li.Value = u[0] li.Init(u[1])
li.Init(u[1]) last_height += li.Height
last_height += li.Height self.MyList = append(self.MyList, li)
self.MyList = append(self.MyList,li) }
}
} }
func (self *GPUDriverPage) Init() { func (self *GPUDriverPage) Init() {
if self.Screen != nil { if self.Screen != nil {
if self.Screen.CanvasHWND != nil && self.CanvasHWND == nil { if self.Screen.CanvasHWND != nil && self.CanvasHWND == nil {
self.HWND = self.Screen.CanvasHWND self.HWND = self.Screen.CanvasHWND
self.CanvasHWND = surface.Surface( self.Screen.Width,self.Screen.Height ) self.CanvasHWND = surface.Surface(self.Screen.Width, self.Screen.Height)
} }
} }
self.PosX = self.Index*self.Screen.Width self.PosX = self.Index * self.Screen.Width
self.Width = self.Screen.Width self.Width = self.Screen.Width
self.Height = self.Screen.Height self.Height = self.Screen.Height
done := UI.NewIconItem() done := UI.NewIconItem()
done.ImgSurf = UI.MyIconPool.GetImgSurf("done") done.ImgSurf = UI.MyIconPool.GetImgSurf("done")
done.MyType = UI.ICON_TYPES["STAT"] done.MyType = UI.ICON_TYPES["STAT"]
done.Parent = self done.Parent = self
self.Icons["done"] = done self.Icons["done"] = done
ps := NewListPageSelector() ps := NewListPageSelector()
ps.Parent = self ps.Parent = self
self.Ps = ps self.Ps = ps
self.PsIndex = 0 self.PsIndex = 0
self.GenList() self.GenList()
self.Scroller = UI.NewListScroller() self.Scroller = UI.NewListScroller()
self.Scroller.Parent = self self.Scroller.Parent = self
self.Scroller.PosX = self.Width - 10 self.Scroller.PosX = self.Width - 10
self.Scroller.PosY = 2 self.Scroller.PosY = 2
self.Scroller.Init() self.Scroller.Init()
self.Scroller.SetCanvasHWND(self.HWND) self.Scroller.SetCanvasHWND(self.HWND)
} }
func (self *GPUDriverPage) Click() { func (self *GPUDriverPage) Click() {
if len(self.MyList) == 0 { if len(self.MyList) == 0 {
return return
} }
if self.PsIndex >= len(self.MyList) { if self.PsIndex >= len(self.MyList) {
self.PsIndex = len(self.MyList) -1 self.PsIndex = len(self.MyList) - 1
} }
cur_li := self.MyList[self.PsIndex].(*PageListItem) cur_li := self.MyList[self.PsIndex].(*PageListItem)
if cur_li.Active == true { if cur_li.Active == true {
return return
} }
if strings.Contains(runtime.GOARCH,"arm") == true { if strings.Contains(runtime.GOARCH, "arm") == true {
for i,_ := range self.MyList { for i, _ := range self.MyList {
self.MyList[i].(*PageListItem).Active = false self.MyList[i].(*PageListItem).Active = false
} }
cur_li.Active = true cur_li.Active = true
self.Screen.MsgBox.SetText("Applying") self.Screen.MsgBox.SetText("Applying")
self.Screen.MsgBox.Draw() self.Screen.MsgBox.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
if strings.Contains(cur_li.Value,"modesetting") { if strings.Contains(cur_li.Value, "modesetting") {
lockfile,_ := homedir.Expand("~/.lima") lockfile, _ := homedir.Expand("~/.lima")
UI.System("touch "+lockfile) UI.System("touch " + lockfile)
UI.ArmSystem("sudo mv /usr/lib/xorg/modules/drivers/modesetting_drv.so.lima /usr/lib/xorg/modules/drivers/modesetting_drv.so") UI.ArmSystem("sudo mv /usr/lib/xorg/modules/drivers/modesetting_drv.so.lima /usr/lib/xorg/modules/drivers/modesetting_drv.so")
UI.ArmSystem("sudo sed -i '/^#.*lima/s/^#//' /etc/ld.so.conf.d/00-arm-linux-gnueabihf.conf") UI.ArmSystem("sudo sed -i '/^#.*lima/s/^#//' /etc/ld.so.conf.d/00-arm-linux-gnueabihf.conf")
UI.ArmSystem("sudo ldconfig") UI.ArmSystem("sudo ldconfig")
}else { } else {
lockfile,_ := homedir.Expand("~/.lima") lockfile, _ := homedir.Expand("~/.lima")
UI.System("rm "+lockfile) UI.System("rm " + lockfile)
UI.ArmSystem("sudo mv /usr/lib/xorg/modules/drivers/modesetting_drv.so /usr/lib/xorg/modules/drivers/modesetting_drv.so.lima") UI.ArmSystem("sudo mv /usr/lib/xorg/modules/drivers/modesetting_drv.so /usr/lib/xorg/modules/drivers/modesetting_drv.so.lima")
UI.ArmSystem("sudo sed -i 's/^[^#]*lima/#&/' /etc/ld.so.conf.d/00-arm-linux-gnueabihf.conf") UI.ArmSystem("sudo sed -i 's/^[^#]*lima/#&/' /etc/ld.so.conf.d/00-arm-linux-gnueabihf.conf")
UI.ArmSystem("sudo ldconfig") UI.ArmSystem("sudo ldconfig")
} }
time.BlockDelay(1000) time.BlockDelay(1000)
UI.System("sudo reboot") UI.System("sudo reboot")
}else { } else {
self.Screen.MsgBox.SetText("Do it in GameShell") self.Screen.MsgBox.SetText("Do it in GameShell")
self.Screen.MsgBox.Draw() self.Screen.MsgBox.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
} }
func (self *GPUDriverPage) OnLoadCb() { func (self *GPUDriverPage) OnLoadCb() {
self.PosY = 0 self.PosY = 0
self.DrawOnce = false self.DrawOnce = false
thedrv := "" thedrv := ""
if strings.Contains(runtime.GOARCH,"arm") == true { if strings.Contains(runtime.GOARCH, "arm") == true {
lockfile,_ := homedir.Expand("~/.lima") lockfile, _ := homedir.Expand("~/.lima")
if UI.FileExists(lockfile) { if UI.FileExists(lockfile) {
thedrv = "modesetting" thedrv = "modesetting"
}else { } else {
thedrv = "fbturbo" thedrv = "fbturbo"
} }
} }
if thedrv == "" { if thedrv == "" {
thedrv = "fbturbo" thedrv = "fbturbo"
} }
for i, v := range self.MyList { for i, v := range self.MyList {
if strings.Contains( v.(*PageListItem).Value, thedrv) { if strings.Contains(v.(*PageListItem).Value, thedrv) {
self.MyList[i].(*PageListItem).Active = true self.MyList[i].(*PageListItem).Active = true
break break
} }
} }
} }
func (self *GPUDriverPage) KeyDown(ev *event.Event ) { func (self *GPUDriverPage) KeyDown(ev *event.Event) {
if ev.Data["Key"] == UI.CurKeys["A"] || ev.Data["Key"] == UI.CurKeys["Menu"] { if ev.Data["Key"] == UI.CurKeys["A"] || ev.Data["Key"] == UI.CurKeys["Menu"] {
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
@@ -293,76 +284,75 @@ func (self *GPUDriverPage) KeyDown(ev *event.Event ) {
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["B"] { if ev.Data["Key"] == UI.CurKeys["B"] {
self.Click() self.Click()
} }
if ev.Data["Key"] == UI.CurKeys["Up"] { if ev.Data["Key"] == UI.CurKeys["Up"] {
self.ScrollUp() self.ScrollUp()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["Down"] { if ev.Data["Key"] == UI.CurKeys["Down"] {
self.ScrollDown() self.ScrollDown()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
} }
func (self *GPUDriverPage) Draw() { func (self *GPUDriverPage) Draw() {
self.ClearCanvas() self.ClearCanvas()
if len(self.MyList) == 0 { if len(self.MyList) == 0 {
return return
} }
if len(self.MyList) * UI.DefaultInfoPageListItemHeight > self.Height { if len(self.MyList)*UI.DefaultInfoPageListItemHeight > self.Height {
self.Ps.(*ListPageSelector).Width = self.Width - 11 self.Ps.(*ListPageSelector).Width = self.Width - 11
self.Ps.Draw() self.Ps.Draw()
for _,v := range self.MyList { for _, v := range self.MyList {
if v.(*PageListItem).PosY > self.Height + self.Height/2 { if v.(*PageListItem).PosY > self.Height+self.Height/2 {
break break
} }
if v.(*PageListItem).PosY < 0 { if v.(*PageListItem).PosY < 0 {
continue continue
} }
v.Draw() v.Draw()
} }
self.Scroller.UpdateSize( len(self.MyList)*UI.DefaultInfoPageListItemHeight, self.Scroller.UpdateSize(len(self.MyList)*UI.DefaultInfoPageListItemHeight,
self.PsIndex*UI.DefaultInfoPageListItemHeight) self.PsIndex*UI.DefaultInfoPageListItemHeight)
self.Scroller.Draw() self.Scroller.Draw()
}else { } else {
self.Ps.(*ListPageSelector).Width = self.Width self.Ps.(*ListPageSelector).Width = self.Width
self.Ps.Draw() self.Ps.Draw()
for _,v := range self.MyList { for _, v := range self.MyList {
if v.(*PageListItem).PosY > self.Height + self.Height/2 { if v.(*PageListItem).PosY > self.Height+self.Height/2 {
break break
} }
if v.(*PageListItem).PosY < 0 { if v.(*PageListItem).PosY < 0 {
continue continue
} }
v.Draw() v.Draw()
} }
} }
if self.HWND != nil { if self.HWND != nil {
surface.Fill(self.HWND, UI.MySkinManager.GiveColor("White")) surface.Fill(self.HWND, UI.MySkinManager.GiveColor("White"))
rect_ := rect.Rect(self.PosX,self.PosY,self.Width,self.Height) rect_ := rect.Rect(self.PosX, self.PosY, self.Width, self.Height)
surface.Blit(self.HWND,self.CanvasHWND,&rect_,nil) surface.Blit(self.HWND, self.CanvasHWND, &rect_, nil)
} }
} }

27
Menu/GameShell/10_Settings/Lima/plugin_init.go
View File

@@ -1,14 +1,14 @@
package Lima package Lima
import ( import (
/* /*
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/surface" "github.com/cuu/gogame/surface"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
*/ */
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
//"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS" //"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS"
) )
@@ -16,21 +16,20 @@ import (
/******************************************************************************/ /******************************************************************************/
type LimaPlugin struct { type LimaPlugin struct {
UI.Plugin UI.Plugin
GPUDriverPage *GPUDriverPage GPUDriverPage *GPUDriverPage
} }
func (self *LimaPlugin) Init(main_screen *UI.MainScreen) {
func (self *LimaPlugin) Init( main_screen *UI.MainScreen ) {
self.GPUDriverPage = NewGPUDriverPage() self.GPUDriverPage = NewGPUDriverPage()
self.GPUDriverPage.SetScreen( main_screen) self.GPUDriverPage.SetScreen(main_screen)
self.GPUDriverPage.SetName("GPU Driver Switch") self.GPUDriverPage.SetName("GPU Driver Switch")
self.GPUDriverPage.Init() self.GPUDriverPage.Init()
} }
func (self *LimaPlugin) Run( main_screen *UI.MainScreen ) { func (self *LimaPlugin) Run(main_screen *UI.MainScreen) {
if main_screen != nil { if main_screen != nil {
main_screen.PushCurPage() main_screen.PushCurPage()
main_screen.SetCurPage(self.GPUDriverPage) main_screen.SetCurPage(self.GPUDriverPage)
main_screen.Draw() main_screen.Draw()
main_screen.SwapAndShow() main_screen.SwapAndShow()
} }

27
Menu/GameShell/10_Settings/PowerOFF/plugin_init.go
View File

@@ -1,14 +1,14 @@
package PowerOFF package PowerOFF
import ( import (
/* /*
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/surface" "github.com/cuu/gogame/surface"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
*/ */
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
//"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS" //"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS"
) )
@@ -16,21 +16,20 @@ import (
/******************************************************************************/ /******************************************************************************/
type PowerOFFPlugin struct { type PowerOFFPlugin struct {
UI.Plugin UI.Plugin
PowerOFFPage *PowerOFFConfirmPage PowerOFFPage *PowerOFFConfirmPage
} }
func (self *PowerOFFPlugin) Init(main_screen *UI.MainScreen) {
func (self *PowerOFFPlugin) Init( main_screen *UI.MainScreen ) {
self.PowerOFFPage = NewPowerOFFConfirmPage() self.PowerOFFPage = NewPowerOFFConfirmPage()
self.PowerOFFPage.SetScreen( main_screen) self.PowerOFFPage.SetScreen(main_screen)
self.PowerOFFPage.SetName("PowerOFF") self.PowerOFFPage.SetName("PowerOFF")
self.PowerOFFPage.Init() self.PowerOFFPage.Init()
} }
func (self *PowerOFFPlugin) Run( main_screen *UI.MainScreen ) { func (self *PowerOFFPlugin) Run(main_screen *UI.MainScreen) {
if main_screen != nil { if main_screen != nil {
main_screen.PushCurPage() main_screen.PushCurPage()
main_screen.SetCurPage(self.PowerOFFPage) main_screen.SetCurPage(self.PowerOFFPage)
main_screen.Draw() main_screen.Draw()
main_screen.SwapAndShow() main_screen.SwapAndShow()
} }

69
Menu/GameShell/10_Settings/PowerOFF/poweroff_confirm_page.go
View File

@@ -1,64 +1,61 @@
package PowerOFF package PowerOFF
import ( import (
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
) )
type PowerOFFConfirmPage struct { type PowerOFFConfirmPage struct {
UI.ConfirmPage UI.ConfirmPage
} }
func NewPowerOFFConfirmPage() *PowerOFFConfirmPage { func NewPowerOFFConfirmPage() *PowerOFFConfirmPage {
p := &PowerOFFConfirmPage{} p := &PowerOFFConfirmPage{}
p.ListFont = UI.Fonts["veramono20"] p.ListFont = UI.Fonts["veramono20"]
p.ConfirmText = "Awaiting Input" p.ConfirmText = "Awaiting Input"
p.FootMsg = [5]string{ "Nav","Reboot","","Cancel","Shutdown" } p.FootMsg = [5]string{"Nav", "Reboot", "", "Cancel", "Shutdown"}
p.ConfirmPage.ConfirmText = p.ConfirmText p.ConfirmPage.ConfirmText = p.ConfirmText
p.ConfirmPage.FootMsg = p.FootMsg p.ConfirmPage.FootMsg = p.FootMsg
p.ConfirmPage.ListFont = p.ListFont p.ConfirmPage.ListFont = p.ListFont
return p return p
} }
func (self *PowerOFFConfirmPage) KeyDown(ev *event.Event) { func (self *PowerOFFConfirmPage) KeyDown(ev *event.Event) {
if ev.Data["Key"] == UI.CurKeys["Menu"] || ev.Data["Key"] == UI.CurKeys["A"] { if ev.Data["Key"] == UI.CurKeys["Menu"] || ev.Data["Key"] == UI.CurKeys["A"] {
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["B"] { if ev.Data["Key"] == UI.CurKeys["B"] {
cmdpath := "" cmdpath := ""
if UI.CheckBattery() < 20 { if UI.CheckBattery() < 20 {
cmdpath = "feh --bg-center sysgo/gameshell/wallpaper/gameover.png;" cmdpath = "feh --bg-center sysgo/gameshell/wallpaper/gameover.png;"
}else { } else {
cmdpath = "feh --bg-center sysgo/gameshell/wallpaper/seeyou.png;" cmdpath = "feh --bg-center sysgo/gameshell/wallpaper/seeyou.png;"
} }
cmdpath = cmdpath + "sleep 3;" cmdpath = cmdpath + "sleep 3;"
cmdpath = cmdpath + "sudo halt -p" cmdpath = cmdpath + "sudo halt -p"
event.Post(UI.RUNSYS,cmdpath) event.Post(UI.RUNSYS, cmdpath)
} }
if ev.Data["Key"] == UI.CurKeys["X"] { if ev.Data["Key"] == UI.CurKeys["X"] {
cmdpath := "feh --bg-center sysgo/gameshell/wallpaper/seeyou.png;" cmdpath := "feh --bg-center sysgo/gameshell/wallpaper/seeyou.png;"
cmdpath += "sleep 3;" cmdpath += "sleep 3;"
cmdpath += "sudo reboot" cmdpath += "sudo reboot"
event.Post(UI.RUNSYS,cmdpath) event.Post(UI.RUNSYS, cmdpath)
} }
} }

27
Menu/GameShell/10_Settings/PowerOptions/plugin_init.go
View File

@@ -1,14 +1,14 @@
package PowerOptions package PowerOptions
import ( import (
/* /*
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/surface" "github.com/cuu/gogame/surface"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
*/ */
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
//"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS" //"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS"
) )
@@ -16,21 +16,20 @@ import (
/******************************************************************************/ /******************************************************************************/
type PowerOptionsPlugin struct { type PowerOptionsPlugin struct {
UI.Plugin UI.Plugin
PowerOptionsPage *PowerOptionsPage PowerOptionsPage *PowerOptionsPage
} }
func (self *PowerOptionsPlugin) Init(main_screen *UI.MainScreen) {
func (self *PowerOptionsPlugin) Init( main_screen *UI.MainScreen ) {
self.PowerOptionsPage = NewPowerOptionsPage() self.PowerOptionsPage = NewPowerOptionsPage()
self.PowerOptionsPage.SetScreen( main_screen) self.PowerOptionsPage.SetScreen(main_screen)
self.PowerOptionsPage.SetName("PowerOptions") self.PowerOptionsPage.SetName("PowerOptions")
self.PowerOptionsPage.Init() self.PowerOptionsPage.Init()
} }
func (self *PowerOptionsPlugin) Run( main_screen *UI.MainScreen ) { func (self *PowerOptionsPlugin) Run(main_screen *UI.MainScreen) {
if main_screen != nil { if main_screen != nil {
main_screen.PushCurPage() main_screen.PushCurPage()
main_screen.SetCurPage(self.PowerOptionsPage) main_screen.SetCurPage(self.PowerOptionsPage)
main_screen.Draw() main_screen.Draw()
main_screen.SwapAndShow() main_screen.SwapAndShow()
} }

772
Menu/GameShell/10_Settings/PowerOptions/power_options_page.go
View File

File diff suppressed because it is too large Load Diff

252
Menu/GameShell/10_Settings/Settings.go
View File

@@ -3,47 +3,43 @@ package Settings
import ( import (
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"path/filepath" "path/filepath"
// "github.com/cuu/gogame/surface" // "github.com/cuu/gogame/surface"
"github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
"github.com/cuu/gogame/draw" "github.com/cuu/gogame/draw"
"github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
//child packages //child packages
"github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/About" "github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/About"
"github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/Sound" "github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/Bluetooth"
"github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/Brightness" "github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/Brightness"
"github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/Wifi" "github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/Sound"
"github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/Bluetooth" "github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/Wifi"
"github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/Update" "github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/Languages"
"github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/Storage" "github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/Storage"
"github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/Languages" "github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/Update"
"github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/PowerOFF"
"github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/PowerOptions"
"github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/Airplane"
"github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/ButtonsLayout"
"github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/TimeZone"
//"github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/Lima"
"github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/GateWay"
"github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/Airplane"
"github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/ButtonsLayout"
"github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/PowerOFF"
"github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/PowerOptions"
"github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/TimeZone"
//"github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/Lima"
"github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings/GateWay"
) )
type SettingsPageSelector struct { type SettingsPageSelector struct {
UI.PageSelector UI.PageSelector
BackgroundColor *color.Color BackgroundColor *color.Color
} }
func NewSettingsPageSelector() *SettingsPageSelector{ func NewSettingsPageSelector() *SettingsPageSelector {
s := &SettingsPageSelector{} s := &SettingsPageSelector{}
s.BackgroundColor = &color.Color{131,199,219,255} s.BackgroundColor = &color.Color{131, 199, 219, 255}
s.Width = UI.Width s.Width = UI.Width
@@ -53,20 +49,20 @@ func NewSettingsPageSelector() *SettingsPageSelector{
func (self *SettingsPageSelector) Draw() { func (self *SettingsPageSelector) Draw() {
idx := self.Parent.GetPsIndex() idx := self.Parent.GetPsIndex()
mylist := self.Parent.GetMyList() mylist := self.Parent.GetMyList()
if idx < len( mylist) { if idx < len(mylist) {
_,y_ := mylist[idx].Coord() _, y_ := mylist[idx].Coord()
_,h_ := mylist[idx].Size() _, h_ := mylist[idx].Size()
x := 2 x := 2
y := y_+1 y := y_ + 1
h := h_-3 h := h_ - 3
self.PosX = x self.PosX = x
self.PosY = y self.PosY = y
self.Height = h self.Height = h
rect_ := rect.Rect(x,y,self.Width-4,h) rect_ := rect.Rect(x, y, self.Width-4, h)
canvas_ := self.Parent.GetCanvasHWND() canvas_ := self.Parent.GetCanvasHWND()
draw.AARoundRect(canvas_, &rect_,self.BackgroundColor,4,0,self.BackgroundColor) draw.AARoundRect(canvas_, &rect_, self.BackgroundColor, 4, 0, self.BackgroundColor)
} }
} }
@@ -75,22 +71,21 @@ func (self *SettingsPageSelector) Draw() {
type SettingsPage struct { type SettingsPage struct {
UI.Page UI.Page
AList map[string]map[string]string AList map[string]map[string]string
ListFontObj *ttf.Font ListFontObj *ttf.Font
Scrolled int Scrolled int
BGwidth int BGwidth int
BGheight int BGheight int
DrawOnce bool DrawOnce bool
Scroller *UI.ListScroller Scroller *UI.ListScroller
Icons map[string]UI.IconItemInterface Icons map[string]UI.IconItemInterface
MyPath string MyPath string
} }
func NewSettingsPage() *SettingsPage { func NewSettingsPage() *SettingsPage {
p := &SettingsPage{} p := &SettingsPage{}
p.FootMsg = [5]string{"Nav","","","Back","Enter"} p.FootMsg = [5]string{"Nav", "", "", "Back", "Enter"}
p.ListFontObj = UI.Fonts["varela15"] p.ListFontObj = UI.Fonts["varela15"]
p.MyPath = "Menu/GameShell/10_Settings" p.MyPath = "Menu/GameShell/10_Settings"
@@ -99,29 +94,29 @@ func NewSettingsPage() *SettingsPage {
} }
func (self *SettingsPage) GenList() []*UI.UIPlugin { func (self *SettingsPage) GenList() []*UI.UIPlugin {
alist := []*UI.UIPlugin{ alist := []*UI.UIPlugin{
&UI.UIPlugin{UI.PluginPackage,"", "Airplane", "Airplane Mode", &Airplane.APIOBJ}, &UI.UIPlugin{UI.PluginPackage, "", "Airplane", "Airplane Mode", &Airplane.APIOBJ},
&UI.UIPlugin{UI.PluginPackage,"", "PowerOptions", "Power Options", &PowerOptions.APIOBJ}, &UI.UIPlugin{UI.PluginPackage, "", "PowerOptions", "Power Options", &PowerOptions.APIOBJ},
&UI.UIPlugin{UI.PluginPackage,"", "Wifi", "Wi-Fi", &Wifi.APIOBJ}, &UI.UIPlugin{UI.PluginPackage, "", "Wifi", "Wi-Fi", &Wifi.APIOBJ},
&UI.UIPlugin{UI.PluginPackage,"", "Bluetooth", "Bluetooth", &Bluetooth.APIOBJ}, &UI.UIPlugin{UI.PluginPackage, "", "Bluetooth", "Bluetooth", &Bluetooth.APIOBJ},
&UI.UIPlugin{UI.PluginPackage,"", "Sound", "Sound Volume" , &Sound.APIOBJ}, &UI.UIPlugin{UI.PluginPackage, "", "Sound", "Sound Volume", &Sound.APIOBJ},
&UI.UIPlugin{UI.PluginPackage,"", "Brightness", "BackLight Brightness", &Brightness.APIOBJ}, &UI.UIPlugin{UI.PluginPackage, "", "Brightness", "BackLight Brightness", &Brightness.APIOBJ},
&UI.UIPlugin{UI.PluginPackage,"", "Storage", "", &Storage.APIOBJ}, &UI.UIPlugin{UI.PluginPackage, "", "Storage", "", &Storage.APIOBJ},
&UI.UIPlugin{UI.PluginPackage,"", "TimeZone", "Timezone", &TimeZone.APIOBJ}, &UI.UIPlugin{UI.PluginPackage, "", "TimeZone", "Timezone", &TimeZone.APIOBJ},
&UI.UIPlugin{UI.PluginPackage,"", "Languages", "Languages", &Languages.APIOBJ}, &UI.UIPlugin{UI.PluginPackage, "", "Languages", "Languages", &Languages.APIOBJ},
&UI.UIPlugin{UI.PluginPackage,"", "Update", "Update LauncherGo", &Update.APIOBJ}, &UI.UIPlugin{UI.PluginPackage, "", "Update", "Update LauncherGo", &Update.APIOBJ},
&UI.UIPlugin{UI.PluginPackage,"", "About", "About", &About.APIOBJ}, &UI.UIPlugin{UI.PluginPackage, "", "About", "About", &About.APIOBJ},
&UI.UIPlugin{UI.PluginPackage,"", "PowerOFF", "Power off", &PowerOFF.APIOBJ}, &UI.UIPlugin{UI.PluginPackage, "", "PowerOFF", "Power off", &PowerOFF.APIOBJ},
&UI.UIPlugin{UI.PluginPackage,"", "ButtonsLayout", "Buttons Layout", &ButtonsLayout.APIOBJ}, &UI.UIPlugin{UI.PluginPackage, "", "ButtonsLayout", "Buttons Layout", &ButtonsLayout.APIOBJ},
// &UI.UIPlugin{UI.PluginPackage,"", "LauncherPy", "Switch to Launcher", &LauncherPy.APIOBJ}, // &UI.UIPlugin{UI.PluginPackage,"", "LauncherPy", "Switch to Launcher", &LauncherPy.APIOBJ},
//&UI.UIPlugin{UI.PluginPackage,"", "Lima", "GPU Driver Switch", &Lima.APIOBJ}, //&UI.UIPlugin{UI.PluginPackage,"", "Lima", "GPU Driver Switch", &Lima.APIOBJ},
&UI.UIPlugin{UI.PluginPackage,"", "GateWay", "Network gateway switch", &GateWay.APIOBJ}, &UI.UIPlugin{UI.PluginPackage, "", "GateWay", "Network gateway switch", &GateWay.APIOBJ},
} }
return alist return alist
} }
func (self *SettingsPage) Init() { func (self *SettingsPage) Init() {
@@ -132,52 +127,50 @@ func (self *SettingsPage) Init() {
self.Height = self.Screen.Height self.Height = self.Screen.Height
self.CanvasHWND = self.Screen.CanvasHWND self.CanvasHWND = self.Screen.CanvasHWND
ps := NewSettingsPageSelector() ps := NewSettingsPageSelector()
ps.Parent = self ps.Parent = self
self.Ps = ps self.Ps = ps
self.PsIndex = 0 self.PsIndex = 0
start_x := 0 start_x := 0
start_y := 0 start_y := 0
alist := self.GenList() alist := self.GenList()
for i,v := range alist{ for i, v := range alist {
li := UI.NewListItem() li := UI.NewListItem()
li.Parent = self li.Parent = self
li.PosX = start_x li.PosX = start_x
li.PosY = start_y + i*li.Height li.PosY = start_y + i*li.Height
li.Width = UI.Width li.Width = UI.Width
li.Fonts["normal"] = self.ListFontObj li.Fonts["normal"] = self.ListFontObj
if v.LabelText != "" { if v.LabelText != "" {
li.Init(v.LabelText) li.Init(v.LabelText)
}else{ } else {
li.Init(v.FolderName) li.Init(v.FolderName)
} }
if v.SoFile!= "" && UI.FileExists( filepath.Join(self.MyPath,v.FolderName,v.SoFile )) { if v.SoFile != "" && UI.FileExists(filepath.Join(self.MyPath, v.FolderName, v.SoFile)) {
pi,err := UI.LoadPlugin(filepath.Join(self.MyPath,v.FolderName,v.SoFile )) pi, err := UI.LoadPlugin(filepath.Join(self.MyPath, v.FolderName, v.SoFile))
UI.Assert(err) UI.Assert(err)
li.LinkObj = UI.InitPlugin(pi,self.Screen) li.LinkObj = UI.InitPlugin(pi, self.Screen)
self.MyList = append(self.MyList,li) self.MyList = append(self.MyList, li)
}else { } else {
if v.EmbInterface != nil { if v.EmbInterface != nil {
v.EmbInterface.Init(self.Screen) v.EmbInterface.Init(self.Screen)
li.LinkObj = v.EmbInterface li.LinkObj = v.EmbInterface
self.MyList = append(self.MyList,li) self.MyList = append(self.MyList, li)
} }
} }
} }
self.Scroller = UI.NewListScroller() self.Scroller = UI.NewListScroller()
self.Scroller.Parent = self self.Scroller.Parent = self
self.Scroller.PosX = self.Width - 10 self.Scroller.PosX = self.Width - 10
self.Scroller.PosY = 2 self.Scroller.PosY = 2
self.Scroller.Init() self.Scroller.Init()
} }
@@ -185,47 +178,46 @@ func (self *SettingsPage) Init() {
func (self *SettingsPage) ScrollUp() { func (self *SettingsPage) ScrollUp() {
if len(self.MyList) == 0 { if len(self.MyList) == 0 {
return return
} }
self.PsIndex -= 1 self.PsIndex -= 1
if self.PsIndex < 0 { if self.PsIndex < 0 {
self.PsIndex = 0 self.PsIndex = 0
} }
cur_li := self.MyList[self.PsIndex] cur_li := self.MyList[self.PsIndex]
x,y := cur_li.Coord() x, y := cur_li.Coord()
if y < 0 { if y < 0 {
for i:=0;i<len(self.MyList);i++ { for i := 0; i < len(self.MyList); i++ {
_,h := self.MyList[i].Size() _, h := self.MyList[i].Size()
x,y = self.MyList[i].Coord() x, y = self.MyList[i].Coord()
self.MyList[i].NewCoord(x, y+h) self.MyList[i].NewCoord(x, y+h)
} }
} }
} }
func (self *SettingsPage) ScrollDown() { func (self *SettingsPage) ScrollDown() {
if len(self.MyList) == 0 { if len(self.MyList) == 0 {
return return
} }
self.PsIndex += 1 self.PsIndex += 1
if self.PsIndex >= len(self.MyList) { if self.PsIndex >= len(self.MyList) {
self.PsIndex = len(self.MyList) - 1 self.PsIndex = len(self.MyList) - 1
} }
cur_li := self.MyList[self.PsIndex] cur_li := self.MyList[self.PsIndex]
x,y := cur_li.Coord() x, y := cur_li.Coord()
_,h := cur_li.Size() _, h := cur_li.Size()
if y + h > self.Height { if y+h > self.Height {
for i:=0;i<len(self.MyList);i++ { for i := 0; i < len(self.MyList); i++ {
_,h = self.MyList[i].Size() _, h = self.MyList[i].Size()
x,y = self.MyList[i].Coord() x, y = self.MyList[i].Coord()
self.MyList[i].NewCoord(x, y - h) self.MyList[i].NewCoord(x, y-h)
} }
} }
} }
@@ -244,7 +236,7 @@ func (self *SettingsPage) Click() {
} }
func (self *SettingsPage) KeyDown( ev *event.Event) { func (self *SettingsPage) KeyDown(ev *event.Event) {
if ev.Data["Key"] == UI.CurKeys["A"] || ev.Data["Key"] == UI.CurKeys["Menu"] { if ev.Data["Key"] == UI.CurKeys["A"] || ev.Data["Key"] == UI.CurKeys["Menu"] {
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
@@ -252,7 +244,6 @@ func (self *SettingsPage) KeyDown( ev *event.Event) {
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["Up"] { if ev.Data["Key"] == UI.CurKeys["Up"] {
self.ScrollUp() self.ScrollUp()
self.Screen.Draw() self.Screen.Draw()
@@ -270,7 +261,6 @@ func (self *SettingsPage) KeyDown( ev *event.Event) {
} }
} }
func (self *SettingsPage) Draw() { func (self *SettingsPage) Draw() {
self.ClearCanvas() self.ClearCanvas()
@@ -278,47 +268,45 @@ func (self *SettingsPage) Draw() {
return return
} }
_,h_ := self.MyList[0].Size() _, h_ := self.MyList[0].Size()
if len(self.MyList) * h_ > self.Height { if len(self.MyList)*h_ > self.Height {
_,ph_ := self.Ps.Size() _, ph_ := self.Ps.Size()
self.Ps.NewSize(self.Width - 11, ph_) self.Ps.NewSize(self.Width-11, ph_)
self.Ps.Draw() self.Ps.Draw()
for _,v := range self.MyList { for _, v := range self.MyList {
v.Draw() v.Draw()
} }
self.Scroller.UpdateSize(len(self.MyList)*h_,self.PsIndex*h_) self.Scroller.UpdateSize(len(self.MyList)*h_, self.PsIndex*h_)
self.Scroller.Draw() self.Scroller.Draw()
}else { } else {
_,ph_ := self.Ps.Size() _, ph_ := self.Ps.Size()
self.Ps.NewSize(self.Width,ph_) self.Ps.NewSize(self.Width, ph_)
self.Ps.Draw() self.Ps.Draw()
for _,v := range self.MyList { for _, v := range self.MyList {
v.Draw() v.Draw()
} }
} }
} }
/******************************************************************************/ /******************************************************************************/
type SettingsPlugin struct { type SettingsPlugin struct {
UI.Plugin UI.Plugin
Page UI.PageInterface Page UI.PageInterface
} }
func (self *SettingsPlugin) Init(main_screen *UI.MainScreen) {
func (self *SettingsPlugin) Init( main_screen *UI.MainScreen ) {
self.Page = NewSettingsPage() self.Page = NewSettingsPage()
self.Page.SetScreen( main_screen) self.Page.SetScreen(main_screen)
self.Page.SetName("Settings") self.Page.SetName("Settings")
self.Page.Init() self.Page.Init()
} }
func (self *SettingsPlugin) Run( main_screen *UI.MainScreen ) { func (self *SettingsPlugin) Run(main_screen *UI.MainScreen) {
if main_screen != nil { if main_screen != nil {
main_screen.PushPage(self.Page) main_screen.PushPage(self.Page)
main_screen.Draw() main_screen.Draw()

27
Menu/GameShell/10_Settings/Sound/plugin_init.go
View File

@@ -5,14 +5,14 @@ package Sound
* `sudo apt-get install alsa-utils` * `sudo apt-get install alsa-utils`
*/ */
import ( import (
/* /*
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/surface" "github.com/cuu/gogame/surface"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
*/ */
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
//"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS" //"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS"
) )
@@ -20,21 +20,20 @@ import (
/******************************************************************************/ /******************************************************************************/
type SoundPlugin struct { type SoundPlugin struct {
UI.Plugin UI.Plugin
SoundPage *SoundPage SoundPage *SoundPage
} }
func (self *SoundPlugin) Init(main_screen *UI.MainScreen) {
func (self *SoundPlugin) Init( main_screen *UI.MainScreen ) {
self.SoundPage = NewSoundPage() self.SoundPage = NewSoundPage()
self.SoundPage.SetScreen( main_screen) self.SoundPage.SetScreen(main_screen)
self.SoundPage.SetName("Sound Volume") self.SoundPage.SetName("Sound Volume")
self.SoundPage.Init() self.SoundPage.Init()
} }
func (self *SoundPlugin) Run( main_screen *UI.MainScreen ) { func (self *SoundPlugin) Run(main_screen *UI.MainScreen) {
if main_screen != nil { if main_screen != nil {
main_screen.PushCurPage() main_screen.PushCurPage()
main_screen.SetCurPage(self.SoundPage) main_screen.SetCurPage(self.SoundPage)
main_screen.Draw() main_screen.Draw()
main_screen.SwapAndShow() main_screen.SwapAndShow()
} }

298
Menu/GameShell/10_Settings/Sound/sound_page.go
View File

@@ -1,94 +1,92 @@
package Sound package Sound
import( import (
"fmt" "fmt"
"github.com/veandco/go-sdl2/sdl" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/event" "github.com/veandco/go-sdl2/sdl"
"github.com/cuu/gogame/surface" "github.com/cuu/gogame/draw"
"github.com/cuu/gogame/draw" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/surface"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
) )
type OnChangeCB_T func(int) type OnChangeCB_T func(int)
type SliderIcon struct { type SliderIcon struct {
UI.IconItem UI.IconItem
Parent *SoundSlider Parent *SoundSlider
} }
func NewSliderIcon() *SliderIcon { func NewSliderIcon() *SliderIcon {
p := &SliderIcon{} p := &SliderIcon{}
p.MyType = UI.ICON_TYPES["EXE"] p.MyType = UI.ICON_TYPES["EXE"]
p.Align = UI.ALIGN["VCenter"] p.Align = UI.ALIGN["VCenter"]
return p return p
} }
func (self *SliderIcon) Draw() { func (self *SliderIcon) Draw() {
if self.Parent == nil { if self.Parent == nil {
fmt.Println("Error: SliderIcon Draw Parent nil") fmt.Println("Error: SliderIcon Draw Parent nil")
return return
} }
parent_x,parent_y := self.Parent.Coord() parent_x, parent_y := self.Parent.Coord()
if self.Label != nil { if self.Label != nil {
// lab_x,lab_y := self.Label.Coord() // lab_x,lab_y := self.Label.Coord()
lab_w,lab_h:= self.Label.Size() lab_w, lab_h := self.Label.Size()
if self.Align == UI.ALIGN["VCenter"] { if self.Align == UI.ALIGN["VCenter"] {
// fmt.Println("IconItem Draw VCenter:",lab_w,lab_h,self.Label.GetText()) // fmt.Println("IconItem Draw VCenter:",lab_w,lab_h,self.Label.GetText())
self.Label.NewCoord( self.PosX - lab_w/2 + parent_x, self.PosY + self.Height/2+6+parent_y) self.Label.NewCoord(self.PosX-lab_w/2+parent_x, self.PosY+self.Height/2+6+parent_y)
}else if self.Align == UI.ALIGN["HLeft"] { } else if self.Align == UI.ALIGN["HLeft"] {
self.Label.NewCoord( self.PosX + self.Width/2+3+parent_x, self.PosY - lab_h/2 + parent_y) self.Label.NewCoord(self.PosX+self.Width/2+3+parent_x, self.PosY-lab_h/2+parent_y)
} }
self.Label.Draw() self.Label.Draw()
} }
if self.ImgSurf != nil { if self.ImgSurf != nil {
surface.Blit(self.Parent.GetCanvasHWND(), self.ImgSurf,draw.MidRect(self.PosX + parent_x, self.PosY + parent_y, surface.Blit(self.Parent.GetCanvasHWND(), self.ImgSurf, draw.MidRect(self.PosX+parent_x, self.PosY+parent_y,
self.Width,self.Height, UI.Width, UI.Height),nil) self.Width, self.Height, UI.Width, UI.Height), nil)
} }
} }
type SliderMultiIcon struct { type SliderMultiIcon struct {
UI.MultiIconItem UI.MultiIconItem
Parent *SoundSlider Parent *SoundSlider
} }
func NewSliderMultiIcon() *SliderMultiIcon { func NewSliderMultiIcon() *SliderMultiIcon {
p := &SliderMultiIcon{} p := &SliderMultiIcon{}
p.MyType = UI.ICON_TYPES["EXE"] p.MyType = UI.ICON_TYPES["EXE"]
p.Align = UI.ALIGN["VCenter"] p.Align = UI.ALIGN["VCenter"]
p.IconIndex = 0 p.IconIndex = 0
p.IconWidth = 18 p.IconWidth = 18
p.IconHeight = 18 p.IconHeight = 18
return p return p
} }
func (self *SliderMultiIcon) Draw() { func (self *SliderMultiIcon) Draw() {
if self.Parent == nil { if self.Parent == nil {
fmt.Println("Error: SliderMultiIcon Draw Parent nil") fmt.Println("Error: SliderMultiIcon Draw Parent nil")
return return
} }
parent_x,parent_y := self.Parent.Coord() parent_x, parent_y := self.Parent.Coord()
if self.Label != nil { if self.Label != nil {
// lab_x,lab_y := self.Label.Coord() // lab_x,lab_y := self.Label.Coord()
lab_w,lab_h:= self.Label.Size() lab_w, lab_h := self.Label.Size()
if self.Align == UI.ALIGN["VCenter"] { if self.Align == UI.ALIGN["VCenter"] {
self.Label.NewCoord( self.PosX - lab_w/2 + parent_x, self.PosY + self.Height/2+6 + parent_y) self.Label.NewCoord(self.PosX-lab_w/2+parent_x, self.PosY+self.Height/2+6+parent_y)
}else if self.Align == UI.ALIGN["HLeft"] { } else if self.Align == UI.ALIGN["HLeft"] {
self.Label.NewCoord( self.PosX + self.Width/2+3 + parent_x, self.PosY - lab_h/2 + parent_y ) self.Label.NewCoord(self.PosX+self.Width/2+3+parent_x, self.PosY-lab_h/2+parent_y)
} }
self.Label.Draw() self.Label.Draw()
@@ -96,177 +94,175 @@ func (self *SliderMultiIcon) Draw() {
if self.ImgSurf != nil { if self.ImgSurf != nil {
portion := rect.Rect(0,self.IconIndex*self.IconHeight,self.IconWidth,self.IconHeight) portion := rect.Rect(0, self.IconIndex*self.IconHeight, self.IconWidth, self.IconHeight)
surface.Blit(self.Parent.GetCanvasHWND(), surface.Blit(self.Parent.GetCanvasHWND(),
self.ImgSurf,draw.MidRect(self.PosX + parent_x, self.PosY + parent_y, self.ImgSurf, draw.MidRect(self.PosX+parent_x, self.PosY+parent_y,
self.Width,self.Height, UI.Width, UI.Height),&portion) self.Width, self.Height, UI.Width, UI.Height), &portion)
} }
} }
type SoundSlider struct { type SoundSlider struct {
UI.Slider UI.Slider
BGpng *SliderIcon BGpng *SliderIcon
BGwidth int BGwidth int
BGheight int BGheight int
//NeedleSurf //NeedleSurf
Scale *SliderMultiIcon Scale *SliderMultiIcon
Parent *SoundPage Parent *SoundPage
OnChangeCB OnChangeCB_T OnChangeCB OnChangeCB_T
snd_segs [][2]int snd_segs [][2]int
} }
func NewSoundSlider() *SoundSlider { func NewSoundSlider() *SoundSlider {
p := &SoundSlider{} p := &SoundSlider{}
p.Range = [2]int{0,255} p.Range = [2]int{0, 255}
p.Value = 0 p.Value = 0
p.BGwidth = 192 p.BGwidth = 192
p.BGheight = 173 p.BGheight = 173
p.snd_segs = [][2]int{ [2]int{0,20},[2]int{21,40},[2]int{41,50}, p.snd_segs = [][2]int{[2]int{0, 20}, [2]int{21, 40}, [2]int{41, 50},
[2]int{51,60},[2]int{61,70},[2]int{71,85}, [2]int{51, 60}, [2]int{61, 70}, [2]int{71, 85},
[2]int{86,90},[2]int{91,95},[2]int{96,100}} [2]int{86, 90}, [2]int{91, 95}, [2]int{96, 100}}
return p return p
} }
func (self *SoundSlider) GetCanvasHWND() *sdl.Surface { func (self *SoundSlider) GetCanvasHWND() *sdl.Surface {
return self.CanvasHWND return self.CanvasHWND
} }
func (self *SoundSlider) Init() { func (self *SoundSlider) Init() {
self.Width = self.Parent.Width self.Width = self.Parent.Width
self.Height = self.Parent.Height self.Height = self.Parent.Height
self.BGpng = NewSliderIcon() self.BGpng = NewSliderIcon()
self.BGpng.ImgSurf = UI.MyIconPool.GetImgSurf("vol") self.BGpng.ImgSurf = UI.MyIconPool.GetImgSurf("vol")
self.BGpng.MyType = UI.ICON_TYPES["STAT"] self.BGpng.MyType = UI.ICON_TYPES["STAT"]
self.BGpng.Parent = self self.BGpng.Parent = self
self.BGpng.Adjust(0,0,self.BGwidth,self.BGheight,0) self.BGpng.Adjust(0, 0, self.BGwidth, self.BGheight, 0)
self.Scale = NewSliderMultiIcon() self.Scale = NewSliderMultiIcon()
self.Scale.MyType = UI.ICON_TYPES["STAT"] self.Scale.MyType = UI.ICON_TYPES["STAT"]
self.Scale.Parent = self self.Scale.Parent = self
self.Scale.ImgSurf = UI.MyIconPool.GetImgSurf("scale") self.Scale.ImgSurf = UI.MyIconPool.GetImgSurf("scale")
self.Scale.IconWidth = 82 self.Scale.IconWidth = 82
self.Scale.IconHeight = 63 self.Scale.IconHeight = 63
self.Scale.Adjust(0,0,82,63,0) self.Scale.Adjust(0, 0, 82, 63, 0)
} }
func (self *SoundSlider) SetValue(vol int) { // pct 0 - 100 func (self *SoundSlider) SetValue(vol int) { // pct 0 - 100
for i,v := range self.snd_segs { for i, v := range self.snd_segs {
if vol >= v[0] && vol <= v[1] { if vol >= v[0] && vol <= v[1] {
self.Value = i self.Value = i
break break
} }
} }
} }
func (self *SoundSlider) Further() { func (self *SoundSlider) Further() {
self.Value += 1 self.Value += 1
if self.Value >= len(self.snd_segs) -1 { if self.Value >= len(self.snd_segs)-1 {
self.Value = len(self.snd_segs) -1 self.Value = len(self.snd_segs) - 1
} }
vol := self.snd_segs[self.Value][0] + (self.snd_segs[self.Value][1]-self.snd_segs[self.Value][0])/2 vol := self.snd_segs[self.Value][0] + (self.snd_segs[self.Value][1]-self.snd_segs[self.Value][0])/2
if self.OnChangeCB != nil { if self.OnChangeCB != nil {
self.OnChangeCB(vol) self.OnChangeCB(vol)
} }
} }
func (self *SoundSlider) StepBack() { func (self *SoundSlider) StepBack() {
self.Value -= 1 self.Value -= 1
if self.Value < 0 { if self.Value < 0 {
self.Value = 0 self.Value = 0
} }
vol := self.snd_segs[self.Value][0] + (self.snd_segs[self.Value][1]-self.snd_segs[self.Value][0])/2 vol := self.snd_segs[self.Value][0] + (self.snd_segs[self.Value][1]-self.snd_segs[self.Value][0])/2
if self.OnChangeCB != nil { if self.OnChangeCB != nil {
self.OnChangeCB(vol) self.OnChangeCB(vol)
} }
} }
func (self *SoundSlider) Draw() { func (self *SoundSlider) Draw() {
self.BGpng.NewCoord(self.Width/2,self.Height/2) self.BGpng.NewCoord(self.Width/2, self.Height/2)
//fmt.Printf("%x\n",self.BGpng.Parent) //fmt.Printf("%x\n",self.BGpng.Parent)
self.BGpng.Draw() self.BGpng.Draw()
self.Scale.NewCoord(self.Width/2,self.Height/2) self.Scale.NewCoord(self.Width/2, self.Height/2)
self.Scale.IconIndex = self.Value self.Scale.IconIndex = self.Value
self.Scale.Draw() self.Scale.Draw()
} }
type SoundPage struct { type SoundPage struct {
UI.Page UI.Page
MySlider *SoundSlider
MySlider *SoundSlider
} }
func NewSoundPage() *SoundPage { func NewSoundPage() *SoundPage {
p := &SoundPage{} p := &SoundPage{}
p.PageIconMargin = 20 p.PageIconMargin = 20
p.SelectedIconTopOffset = 20 p.SelectedIconTopOffset = 20
p.EasingDur = 10 p.EasingDur = 10
p.Align = UI.ALIGN["SLeft"] p.Align = UI.ALIGN["SLeft"]
p.FootMsg = [5]string{"Nav","","","Back","Enter"} p.FootMsg = [5]string{"Nav", "", "", "Back", "Enter"}
return p return p
} }
func (self *SoundPage) Init() { func (self *SoundPage) Init() {
self.CanvasHWND = self.Screen.CanvasHWND self.CanvasHWND = self.Screen.CanvasHWND
self.Width = self.Screen.Width self.Width = self.Screen.Width
self.Height = self.Screen.Height self.Height = self.Screen.Height
self.MySlider = NewSoundSlider() self.MySlider = NewSoundSlider()
self.MySlider.Parent = self self.MySlider.Parent = self
self.MySlider.SetCanvasHWND(self.CanvasHWND) self.MySlider.SetCanvasHWND(self.CanvasHWND)
self.MySlider.OnChangeCB = self.WhenSliderDrag self.MySlider.OnChangeCB = self.WhenSliderDrag
self.MySlider.Init() self.MySlider.Init()
v,err := GetVolume() v, err := GetVolume()
if err == nil { if err == nil {
self.MySlider.SetValue(v) self.MySlider.SetValue(v)
}else { } else {
fmt.Println(err) fmt.Println(err)
} }
} }
func (self *SoundPage) OnLoadCb() { func (self *SoundPage) OnLoadCb() {
v,err := GetVolume() v, err := GetVolume()
if err == nil { if err == nil {
self.MySlider.SetValue(v) self.MySlider.SetValue(v)
}else { } else {
fmt.Println(err) fmt.Println(err)
} }
} }
func (self *SoundPage) WhenSliderDrag(val int) { //value 0 - 100 func (self *SoundPage) WhenSliderDrag(val int) { //value 0 - 100
if val <0 || val > 100 { if val < 0 || val > 100 {
return return
} }
self.Screen.TitleBar.SetSoundVolume(val) self.Screen.TitleBar.SetSoundVolume(val)
SetVolume(val) SetVolume(val)
} }
func (self *SoundPage) KeyDown(ev *event.Event) { func (self *SoundPage) KeyDown(ev *event.Event) {
@@ -277,23 +273,21 @@ func (self *SoundPage) KeyDown(ev *event.Event) {
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["Right"] { if ev.Data["Key"] == UI.CurKeys["Right"] {
self.MySlider.Further() self.MySlider.Further()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["Left"] { if ev.Data["Key"] == UI.CurKeys["Left"] {
self.MySlider.StepBack() self.MySlider.StepBack()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
} }
func (self *SoundPage) Draw() { func (self *SoundPage) Draw() {
self.ClearCanvas() self.ClearCanvas()
self.MySlider.Draw() self.MySlider.Draw()
} }

2
Menu/GameShell/10_Settings/Sound/volume_linux.go
View File

@@ -1,4 +1,6 @@
//go:build !windows && !darwin
// +build !windows,!darwin // +build !windows,!darwin
/* /*
* Copied from https://github.com/itchyny/volume-go, MIT License * Copied from https://github.com/itchyny/volume-go, MIT License
*/ */

2
Menu/GameShell/10_Settings/Sound/volume_unix.go
View File

@@ -1,4 +1,6 @@
//go:build !windows
// +build !windows // +build !windows
/* /*
* Copied from https://github.com/itchyny/volume-go, MIT License * Copied from https://github.com/itchyny/volume-go, MIT License
*/ */

29
Menu/GameShell/10_Settings/Storage/plugin_init.go
View File

@@ -1,37 +1,34 @@
package Storage package Storage
import ( import (
/* /*
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/surface" "github.com/cuu/gogame/surface"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
*/ */
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
) )
/******************************************************************************/ /******************************************************************************/
type StoragePlugin struct { type StoragePlugin struct {
UI.Plugin UI.Plugin
StoragePage *StoragePage StoragePage *StoragePage
} }
func (self *StoragePlugin) Init(main_screen *UI.MainScreen) {
func (self *StoragePlugin) Init( main_screen *UI.MainScreen ) {
self.StoragePage = NewStoragePage() self.StoragePage = NewStoragePage()
self.StoragePage.SetScreen( main_screen) self.StoragePage.SetScreen(main_screen)
self.StoragePage.SetName("Storage") self.StoragePage.SetName("Storage")
self.StoragePage.Init() self.StoragePage.Init()
} }
func (self *StoragePlugin) Run( main_screen *UI.MainScreen ) { func (self *StoragePlugin) Run(main_screen *UI.MainScreen) {
if main_screen != nil { if main_screen != nil {
main_screen.PushCurPage() main_screen.PushCurPage()
main_screen.SetCurPage(self.StoragePage) main_screen.SetCurPage(self.StoragePage)
main_screen.Draw() main_screen.Draw()
main_screen.SwapAndShow() main_screen.SwapAndShow()
} }

127
Menu/GameShell/10_Settings/Storage/storage_page.go
View File

@@ -4,11 +4,10 @@ import (
"fmt" "fmt"
"syscall" "syscall"
"github.com/cuu/gogame/draw" "github.com/cuu/gogame/color"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/draw"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
) )
const ( const (
@@ -19,18 +18,18 @@ const (
) )
type StoragePage struct { type StoragePage struct {
UI.Page UI.Page
BGpng UI.IconItemInterface BGpng UI.IconItemInterface
BGwidth int // 96 BGwidth int // 96
BGheight int // 73 BGheight int // 73
BGlabel UI.LabelInterface BGlabel UI.LabelInterface
FreeLabel UI.LabelInterface FreeLabel UI.LabelInterface
BGmsg string // "%.1GB of %.1fGB Used" BGmsg string // "%.1GB of %.1fGB Used"
DskUsg [2]float64 DskUsg [2]float64
HighColor *color.Color //MySkinManager.GiveColor('High') HighColor *color.Color //MySkinManager.GiveColor('High')
} }
@@ -53,7 +52,7 @@ func DiskUsage(path string) (disk DiskStatus) {
} }
func NewStoragePage() *StoragePage { func NewStoragePage() *StoragePage {
p:= &StoragePage{} p := &StoragePage{}
p.PageIconMargin = 20 p.PageIconMargin = 20
p.SelectedIconTopOffset = 20 p.SelectedIconTopOffset = 20
@@ -61,89 +60,87 @@ func NewStoragePage() *StoragePage {
p.Align = UI.ALIGN["SLeft"] p.Align = UI.ALIGN["SLeft"]
p.FootMsg = [5]string{"Nav","","","Back",""} p.FootMsg = [5]string{"Nav", "", "", "Back", ""}
p.HighColor = &color.Color{51, 166, 255,255} p.HighColor = &color.Color{51, 166, 255, 255}
p.BGwidth = 96 p.BGwidth = 96
p.BGheight = 73 p.BGheight = 73
p.BGmsg = "%.1fGB of %.1fGB Used" p.BGmsg = "%.1fGB of %.1fGB Used"
return p return p
} }
func (self *StoragePage) DiskUsage() (float64,float64) { func (self *StoragePage) DiskUsage() (float64, float64) {
disk := DiskUsage("/") disk := DiskUsage("/")
all := float64(disk.All)/float64(GB) all := float64(disk.All) / float64(GB)
free := float64(disk.Free)/float64(GB) free := float64(disk.Free) / float64(GB)
return free,all return free, all
} }
func (self *StoragePage) Init() { func (self *StoragePage) Init() {
self.DskUsg[0],self.DskUsg[1] = self.DiskUsage() self.DskUsg[0], self.DskUsg[1] = self.DiskUsage()
self.CanvasHWND = self.Screen.CanvasHWND self.CanvasHWND = self.Screen.CanvasHWND
self.Width = self.Screen.Width self.Width = self.Screen.Width
self.Height = self.Screen.Height self.Height = self.Screen.Height
bgpng := UI.NewIconItem() bgpng := UI.NewIconItem()
bgpng.ImgSurf = UI.MyIconPool.GetImgSurf("icon_sd") bgpng.ImgSurf = UI.MyIconPool.GetImgSurf("icon_sd")
bgpng.MyType = UI.ICON_TYPES["STAT"] bgpng.MyType = UI.ICON_TYPES["STAT"]
bgpng.Parent = self bgpng.Parent = self
bgpng.AddLabel( fmt.Sprintf(self.BGmsg,self.DskUsg[1]-self.DskUsg[0],self.DskUsg[1]),UI.Fonts["varela15"]) bgpng.AddLabel(fmt.Sprintf(self.BGmsg, self.DskUsg[1]-self.DskUsg[0], self.DskUsg[1]), UI.Fonts["varela15"])
bgpng.Adjust(0,0,self.BGwidth,self.BGheight,0) bgpng.Adjust(0, 0, self.BGwidth, self.BGheight, 0)
self.BGpng = bgpng self.BGpng = bgpng
self.BGlabel = UI.NewLabel() self.BGlabel = UI.NewLabel()
self.BGlabel.SetCanvasHWND(self.CanvasHWND) self.BGlabel.SetCanvasHWND(self.CanvasHWND)
usage_percent := int((self.DskUsg[0]/self.DskUsg[1])*100.0) usage_percent := int((self.DskUsg[0] / self.DskUsg[1]) * 100.0)
self.BGlabel.Init(fmt.Sprintf("%d%%",usage_percent ),UI.Fonts["varela25"],nil) self.BGlabel.Init(fmt.Sprintf("%d%%", usage_percent), UI.Fonts["varela25"], nil)
self.BGlabel.SetColor(self.HighColor) self.BGlabel.SetColor(self.HighColor)
self.FreeLabel = UI.NewLabel() self.FreeLabel = UI.NewLabel()
self.FreeLabel.SetCanvasHWND(self.CanvasHWND) self.FreeLabel.SetCanvasHWND(self.CanvasHWND)
self.FreeLabel.Init("Free",UI.Fonts["varela13"],nil) self.FreeLabel.Init("Free", UI.Fonts["varela13"], nil)
self.FreeLabel.SetColor(self.BGlabel.(*UI.Label).Color) self.FreeLabel.SetColor(self.BGlabel.(*UI.Label).Color)
} }
func (self *StoragePage) Draw() { func (self *StoragePage) Draw() {
self.ClearCanvas() self.ClearCanvas()
self.BGpng.NewCoord(self.Width/2,self.Height/2-10) self.BGpng.NewCoord(self.Width/2, self.Height/2-10)
self.BGpng.Draw() self.BGpng.Draw()
self.BGlabel.NewCoord(self.Width/2-28,self.Height/2-30) self.BGlabel.NewCoord(self.Width/2-28, self.Height/2-30)
self.BGlabel.Draw() self.BGlabel.Draw()
x,_ := self.BGlabel.Coord() x, _ := self.BGlabel.Coord()
self.FreeLabel.NewCoord(x+10 ,self.Height/2) self.FreeLabel.NewCoord(x+10, self.Height/2)
self.FreeLabel.Draw() self.FreeLabel.Draw()
usage_percent := (self.DskUsg[0]/self.DskUsg[1] ) usage_percent := (self.DskUsg[0] / self.DskUsg[1])
if usage_percent < 0.1 { if usage_percent < 0.1 {
usage_percent = 0.1 usage_percent = 0.1
} }
rect_ := draw.MidRect(self.Width/2,self.Height-30,170,17, UI.Width,UI.Height) rect_ := draw.MidRect(self.Width/2, self.Height-30, 170, 17, UI.Width, UI.Height)
draw.AARoundRect(self.CanvasHWND,rect_,&color.Color{169,169,169,255},5,0,&color.Color{169,169,169,255}) draw.AARoundRect(self.CanvasHWND, rect_, &color.Color{169, 169, 169, 255}, 5, 0, &color.Color{169, 169, 169, 255})
rect2_ := draw.MidRect(self.Width/2,self.Height-30,int(170.0*(1.0-usage_percent)),17, UI.Width,UI.Height) rect2_ := draw.MidRect(self.Width/2, self.Height-30, int(170.0*(1.0-usage_percent)), 17, UI.Width, UI.Height)
rect2_.X = rect_.X rect2_.X = rect_.X
rect2_.Y = rect_.Y rect2_.Y = rect_.Y
draw.AARoundRect(self.CanvasHWND,rect2_,&color.Color{131,199,219,255},5,0,&color.Color{131,199,219,255})
draw.AARoundRect(self.CanvasHWND, rect2_, &color.Color{131, 199, 219, 255}, 5, 0, &color.Color{131, 199, 219, 255})
} }

120
Menu/GameShell/10_Settings/TimeZone/list_item.go
View File

@@ -1,105 +1,99 @@
package TimeZone package TimeZone
import ( import (
//"fmt" //"fmt"
//"strings" //"strings"
//"io/ioutil" //"io/ioutil"
"path/filepath" "github.com/veandco/go-sdl2/ttf"
"github.com/veandco/go-sdl2/ttf" "path/filepath"
//"github.com/veandco/go-sdl2/sdl" //"github.com/veandco/go-sdl2/sdl"
//"github.com/cuu/gogame/surface" //"github.com/cuu/gogame/surface"
//"github.com/cuu/gogame/rect" //"github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
"github.com/cuu/gogame/draw" "github.com/cuu/gogame/draw"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
) )
var TimeZoneListPageListItemDefaultHeight = 30 var TimeZoneListPageListItemDefaultHeight = 30
type TimeZoneListPageInterface interface { type TimeZoneListPageInterface interface {
UI.PageInterface UI.PageInterface
GetMapIcons() map[string]UI.IconItemInterface GetMapIcons() map[string]UI.IconItemInterface
} }
type TimeZoneListPageListItem struct { type TimeZoneListPageListItem struct {
UI.HierListItem UI.HierListItem
Parent TimeZoneListPageInterface Parent TimeZoneListPageInterface
} }
func NewTimeZoneListPageListItem() *TimeZoneListPageListItem { func NewTimeZoneListPageListItem() *TimeZoneListPageListItem {
p := &TimeZoneListPageListItem{} p := &TimeZoneListPageListItem{}
p.Labels = make(map[string]UI.LabelInterface) p.Labels = make(map[string]UI.LabelInterface)
p.Icons = make( map[string]UI.IconItemInterface) p.Icons = make(map[string]UI.IconItemInterface)
p.Fonts = make(map[string]*ttf.Font) p.Fonts = make(map[string]*ttf.Font)
p.MyType = UI.ICON_TYPES["EXE"] p.MyType = UI.ICON_TYPES["EXE"]
p.Height = TimeZoneListPageListItemDefaultHeight p.Height = TimeZoneListPageListItemDefaultHeight
p.Width = 0 p.Width = 0
return p
return p
} }
func (self *TimeZoneListPageListItem) Init(text string) { func (self *TimeZoneListPageListItem) Init(text string) {
l := UI.NewLabel() l := UI.NewLabel()
l.PosX = 20 l.PosX = 20
l.SetCanvasHWND(self.Parent.GetCanvasHWND()) l.SetCanvasHWND(self.Parent.GetCanvasHWND())
if self.IsDir() == true || self.IsFile() == true { if self.IsDir() == true || self.IsFile() == true {
self.Path = text self.Path = text
} }
label_text := filepath.Base(text) label_text := filepath.Base(text)
if self.IsDir() == true { if self.IsDir() == true {
l.Init(label_text, self.Fonts["normal"],nil) l.Init(label_text, self.Fonts["normal"], nil)
}else { } else {
l.Init(label_text,self.Fonts["normal"],nil) l.Init(label_text, self.Fonts["normal"], nil)
} }
self.Labels["Text"] = l self.Labels["Text"] = l
} }
func (self *TimeZoneListPageListItem) Draw() { func (self *TimeZoneListPageListItem) Draw() {
x,y := self.Labels["Text"].Coord() x, y := self.Labels["Text"].Coord()
_,h := self.Labels["Text"].Size() _, h := self.Labels["Text"].Size()
if self.Path != "[..]" {
self.Labels["Text"].NewCoord(23, y)
if self.Path != "[..]" { } else {
self.Labels["Text"].NewCoord(23,y) self.Labels["Text"].NewCoord(3, y)
}
}else { x, y = self.Labels["Text"].Coord()
self.Labels["Text"].NewCoord(3,y) self.Labels["Text"].NewCoord(x, self.PosY+(self.Height-h)/2)
}
x,y = self.Labels["Text"].Coord() self.Labels["Text"].Draw()
self.Labels["Text"].NewCoord(x, self.PosY + (self.Height-h)/2)
self.Labels["Text"].Draw() parent_icons := self.Parent.GetMapIcons()
_, h = parent_icons["sys"].Size()
parent_icons := self.Parent.GetMapIcons() if self.IsDir() == true && self.Path != "[..]" {
_,h = parent_icons["sys"].Size() parent_icons["sys"].SetIconIndex(0)
parent_icons["sys"].NewCoord(self.PosX+12, self.PosY+(self.Height-h)/2+h/2)
parent_icons["sys"].Draw()
}
if self.IsDir() == true && self.Path != "[..]" { if self.IsFile() == true {
parent_icons["sys"].SetIconIndex (0) parent_icons["sys"].SetIconIndex(1)
parent_icons["sys"].NewCoord(self.PosX+12,self.PosY+(self.Height-h)/2+h/2) parent_icons["sys"].NewCoord(self.PosX+12, self.PosY+(self.Height-h)/2+h/2)
parent_icons["sys"].Draw() parent_icons["sys"].Draw()
} }
if self.IsFile() == true { draw.Line(self.Parent.GetCanvasHWND(), &color.Color{169, 169, 169, 255},
parent_icons["sys"].SetIconIndex(1) self.PosX, self.PosY+self.Height-1, self.PosX+self.Width, self.PosY+self.Height-1, 1)
parent_icons["sys"].NewCoord(self.PosX+12,self.PosY+(self.Height-h)/2+h/2)
parent_icons["sys"].Draw()
}
draw.Line(self.Parent.GetCanvasHWND(),&color.Color{169,169,169,255},
self.PosX,self.PosY+self.Height-1,self.PosX+self.Width,self.PosY+self.Height-1,1)
} }

27
Menu/GameShell/10_Settings/TimeZone/plugin_init.go
View File

@@ -1,14 +1,14 @@
package TimeZone package TimeZone
import ( import (
/* /*
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/surface" "github.com/cuu/gogame/surface"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
*/ */
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
//"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS" //"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS"
) )
@@ -16,21 +16,20 @@ import (
/******************************************************************************/ /******************************************************************************/
type TimeZonePlugin struct { type TimeZonePlugin struct {
UI.Plugin UI.Plugin
TimeZonePage *TimeZoneListPage TimeZonePage *TimeZoneListPage
} }
func (self *TimeZonePlugin) Init(main_screen *UI.MainScreen) {
func (self *TimeZonePlugin) Init( main_screen *UI.MainScreen ) {
self.TimeZonePage = NewTimeZoneListPage() self.TimeZonePage = NewTimeZoneListPage()
self.TimeZonePage.SetScreen( main_screen) self.TimeZonePage.SetScreen(main_screen)
self.TimeZonePage.SetName("Timezone Selection") self.TimeZonePage.SetName("Timezone Selection")
self.TimeZonePage.Init() self.TimeZonePage.Init()
} }
func (self *TimeZonePlugin) Run( main_screen *UI.MainScreen ) { func (self *TimeZonePlugin) Run(main_screen *UI.MainScreen) {
if main_screen != nil { if main_screen != nil {
main_screen.PushCurPage() main_screen.PushCurPage()
main_screen.SetCurPage(self.TimeZonePage) main_screen.SetCurPage(self.TimeZonePage)
main_screen.Draw() main_screen.Draw()
main_screen.SwapAndShow() main_screen.SwapAndShow()
} }

479
Menu/GameShell/10_Settings/TimeZone/time_zone_page.go
View File

@@ -1,364 +1,349 @@
package TimeZone package TimeZone
import ( import (
"fmt" "fmt"
"os/exec" "os/exec"
"path/filepath" "path/filepath"
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/draw" "github.com/cuu/gogame/color"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/draw"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/time" "github.com/cuu/gogame/time"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
) )
var TimeZonePath = "/usr/share/zoneinfo/posix" var TimeZonePath = "/usr/share/zoneinfo/posix"
type ListPageSelector struct { type ListPageSelector struct {
UI.InfoPageSelector UI.InfoPageSelector
} }
func NewListPageSelector() *ListPageSelector { func NewListPageSelector() *ListPageSelector {
p := &ListPageSelector{} p := &ListPageSelector{}
p.Width = UI.Width p.Width = UI.Width
p.BackgroundColor = &color.Color{131,199,219,255} //SkinManager().GiveColor('Front') p.BackgroundColor = &color.Color{131, 199, 219, 255} //SkinManager().GiveColor('Front')
return p return p
} }
func (self *ListPageSelector) Draw() { func (self *ListPageSelector) Draw() {
idx := self.Parent.GetPsIndex() idx := self.Parent.GetPsIndex()
mylist := self.Parent.GetMyList() mylist := self.Parent.GetMyList()
if idx < len(mylist) { if idx < len(mylist) {
x,y := mylist[idx].Coord() x, y := mylist[idx].Coord()
_,h := mylist[idx].Size() _, h := mylist[idx].Size()
self.PosX = x+2 self.PosX = x + 2
self.PosY = y+1 self.PosY = y + 1
self.Height = h-3 self.Height = h - 3
canvas_ := self.Parent.GetCanvasHWND() canvas_ := self.Parent.GetCanvasHWND()
rect_ := rect.Rect(self.PosX,self.PosY,self.Width-4, self.Height) rect_ := rect.Rect(self.PosX, self.PosY, self.Width-4, self.Height)
draw.AARoundRect(canvas_,&rect_,self.BackgroundColor,4,0,self.BackgroundColor) draw.AARoundRect(canvas_, &rect_, self.BackgroundColor, 4, 0, self.BackgroundColor)
} }
} }
type TimeZoneListPage struct { type TimeZoneListPage struct {
UI.Page UI.Page
Scroller *UI.ListScroller Scroller *UI.ListScroller
Icons map[string]UI.IconItemInterface Icons map[string]UI.IconItemInterface
ListFont *ttf.Font ListFont *ttf.Font
MyStack *UI.FolderStack MyStack *UI.FolderStack
BGpng *UI.IconItem BGpng *UI.IconItem
BGwidth int BGwidth int
BGheight int BGheight int
SwapMyList []UI.ListItemInterface SwapMyList []UI.ListItemInterface
} }
type ListEle struct { type ListEle struct {
Name string
Name string FilePath string
FilePath string IsFile bool
IsFile bool
} }
func NewTimeZoneListPage() *TimeZoneListPage { func NewTimeZoneListPage() *TimeZoneListPage {
p := &TimeZoneListPage{} p := &TimeZoneListPage{}
p.BGwidth = 56 p.BGwidth = 56
p.BGheight = 70 p.BGheight = 70
p.FootMsg = [5]string{ "Nav","","","Back","Select" } p.FootMsg = [5]string{"Nav", "", "", "Back", "Select"}
p.ListFont = UI.Fonts["notosanscjk15"] p.ListFont = UI.Fonts["notosanscjk15"]
p.MyStack = UI.NewFolderStack() p.MyStack = UI.NewFolderStack()
p.MyStack.SetRootPath( TimeZonePath ) p.MyStack.SetRootPath(TimeZonePath)
p.Icons = make(map[string]UI.IconItemInterface ) p.Icons = make(map[string]UI.IconItemInterface)
return p return p
} }
func (self *TimeZoneListPage) GetMapIcons() map[string]UI.IconItemInterface { func (self *TimeZoneListPage) GetMapIcons() map[string]UI.IconItemInterface {
return self.Icons return self.Icons
} }
func (self *TimeZoneListPage) buildDirectoryList(path string) []*ListEle { func (self *TimeZoneListPage) buildDirectoryList(path string) []*ListEle {
//[*ListEle{},*ListEle{}] //[*ListEle{},*ListEle{}]
var ret []*ListEle var ret []*ListEle
file_paths,err := filepath.Glob(path+"/*")//sorted file_paths, err := filepath.Glob(path + "/*") //sorted
if err == nil { if err == nil {
for _, u := range file_paths { for _, u := range file_paths {
e := &ListEle{} e := &ListEle{}
e.Name = filepath.Base(u) e.Name = filepath.Base(u)
e.FilePath = u e.FilePath = u
if UI.IsAFile(u) { if UI.IsAFile(u) {
e.IsFile = true e.IsFile = true
}else { } else {
e.IsFile = false e.IsFile = false
} }
ret = append(ret,e) ret = append(ret, e)
} }
} }
return ret return ret
} }
func (self *TimeZoneListPage) SyncList(path string) { func (self *TimeZoneListPage) SyncList(path string) {
alist := self.buildDirectoryList(path) alist := self.buildDirectoryList(path)
if len(alist) == 0 { if len(alist) == 0 {
fmt.Println("buildDirectoryList empty") fmt.Println("buildDirectoryList empty")
return return
} }
self.MyList = nil self.MyList = nil
self.SwapMyList = nil self.SwapMyList = nil
start_x := 0
start_y := 0
start_x := 0 hasparent := 0
start_y := 0
hasparent := 0 if self.MyStack.Length() > 0 {
hasparent = 1
if self.MyStack.Length() > 0 { li := NewTimeZoneListPageListItem()
hasparent = 1 li.Parent = self
li.PosX = start_x
li.PosY = start_y
li.Width = UI.Width
li.Fonts["normal"] = self.ListFont
li.MyType = UI.ICON_TYPES["DIR"]
li.Init("[..]")
li := NewTimeZoneListPageListItem() self.MyList = append(self.MyList, li)
li.Parent = self
li.PosX = start_x
li.PosY = start_y
li.Width = UI.Width
li.Fonts["normal"] = self.ListFont
li.MyType = UI.ICON_TYPES["DIR"]
li.Init("[..]")
self.MyList = append(self.MyList,li) }
} for i, v := range alist {
li := NewTimeZoneListPageListItem()
li.Parent = self
li.PosX = start_x
li.PosY = start_y + (i+hasparent)*TimeZoneListPageListItemDefaultHeight
li.Width = UI.Width
li.Fonts["normal"] = self.ListFont
li.MyType = UI.ICON_TYPES["FILE"]
for i,v := range alist{ if v.IsFile == false {
li := NewTimeZoneListPageListItem() li.MyType = UI.ICON_TYPES["DIR"]
li.Parent = self } else {
li.PosX = start_x li.MyType = UI.ICON_TYPES["FILE"]
li.PosY = start_y + (i+hasparent) *TimeZoneListPageListItemDefaultHeight }
li.Width = UI.Width
li.Fonts["normal"] = self.ListFont
li.MyType = UI.ICON_TYPES["FILE"]
if v.IsFile == false { li.Init(v.Name)
li.MyType = UI.ICON_TYPES["DIR"] li.Path = v.FilePath
}else{
li.MyType = UI.ICON_TYPES["FILE"]
}
li.Init(v.Name) self.MyList = append(self.MyList, li)
li.Path = v.FilePath }
self.MyList = append(self.MyList,li) for _, v := range self.MyList {
} self.SwapMyList = append(self.SwapMyList, v)
}
for _,v := range self.MyList {
self.SwapMyList = append(self.SwapMyList,v)
}
} }
func (self *TimeZoneListPage) Init() { func (self *TimeZoneListPage) Init() {
self.PosX = self.Index * self.Screen.Width self.PosX = self.Index * self.Screen.Width
self.Width = self.Screen.Width self.Width = self.Screen.Width
self.Height = self.Screen.Height self.Height = self.Screen.Height
self.CanvasHWND = self.Screen.CanvasHWND self.CanvasHWND = self.Screen.CanvasHWND
ps := NewListPageSelector() ps := NewListPageSelector()
ps.Parent = self ps.Parent = self
self.Ps = ps self.Ps = ps
self.PsIndex = 0 self.PsIndex = 0
self.SyncList( TimeZonePath ) self.SyncList(TimeZonePath)
icon_for_list := UI.NewMultiIconItem() icon_for_list := UI.NewMultiIconItem()
icon_for_list.ImgSurf = UI.MyIconPool.GetImgSurf("sys") icon_for_list.ImgSurf = UI.MyIconPool.GetImgSurf("sys")
icon_for_list.MyType = UI.ICON_TYPES["STAT"] icon_for_list.MyType = UI.ICON_TYPES["STAT"]
icon_for_list.Parent = self icon_for_list.Parent = self
icon_for_list.Adjust(0,0,18,18,0) icon_for_list.Adjust(0, 0, 18, 18, 0)
self.Icons["sys"] = icon_for_list self.Icons["sys"] = icon_for_list
bgpng := UI.NewIconItem() bgpng := UI.NewIconItem()
bgpng.ImgSurf = UI.MyIconPool.GetImgSurf("empty") bgpng.ImgSurf = UI.MyIconPool.GetImgSurf("empty")
bgpng.MyType = UI.ICON_TYPES["STAT"] bgpng.MyType = UI.ICON_TYPES["STAT"]
bgpng.Parent = self bgpng.Parent = self
bgpng.AddLabel("No timezones found on system!", UI.MyLangManager.TrFont("varela22")) bgpng.AddLabel("No timezones found on system!", UI.MyLangManager.TrFont("varela22"))
bgpng.SetLabelColor( UI.MySkinManager.GiveColor("Disabled") ) bgpng.SetLabelColor(UI.MySkinManager.GiveColor("Disabled"))
bgpng.Adjust(0,0,self.BGwidth,self.BGheight,0) bgpng.Adjust(0, 0, self.BGwidth, self.BGheight, 0)
self.BGpng = bgpng self.BGpng = bgpng
self.Scroller = UI.NewListScroller() self.Scroller = UI.NewListScroller()
self.Scroller.Parent = self self.Scroller.Parent = self
self.Scroller.PosX = self.Width - 10 self.Scroller.PosX = self.Width - 10
self.Scroller.PosY = 2 self.Scroller.PosY = 2
self.Scroller.Init() self.Scroller.Init()
} }
func (self *TimeZoneListPage) Click() { func (self *TimeZoneListPage) Click() {
if len(self.MyList) == 0 { if len(self.MyList) == 0 {
return return
} }
cur_li := self.MyList[self.PsIndex].(*TimeZoneListPageListItem) cur_li := self.MyList[self.PsIndex].(*TimeZoneListPageListItem)
if cur_li.MyType == UI.ICON_TYPES["DIR"] { if cur_li.MyType == UI.ICON_TYPES["DIR"] {
if cur_li.Path == "[..]" { if cur_li.Path == "[..]" {
self.MyStack.Pop() self.MyStack.Pop()
self.SyncList(self.MyStack.Last()) self.SyncList(self.MyStack.Last())
self.PsIndex = 0 self.PsIndex = 0
}else { } else {
self.MyStack.Push( self.MyList[self.PsIndex].(*TimeZoneListPageListItem).Path) self.MyStack.Push(self.MyList[self.PsIndex].(*TimeZoneListPageListItem).Path)
self.SyncList(self.MyStack.Last()) self.SyncList(self.MyStack.Last())
self.PsIndex = 0 self.PsIndex = 0
} }
} }
if cur_li.MyType == UI.ICON_TYPES["FILE"] { //set the current timezone if cur_li.MyType == UI.ICON_TYPES["FILE"] { //set the current timezone
self.Screen.MsgBox.SetText("Applying") self.Screen.MsgBox.SetText("Applying")
self.Screen.MsgBox.Draw() self.Screen.MsgBox.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
time.BlockDelay(300) time.BlockDelay(300)
cpCmd := exec.Command("sudo","cp", cur_li.Path,"/etc/localtime") cpCmd := exec.Command("sudo", "cp", cur_li.Path, "/etc/localtime")
err := cpCmd.Run() err := cpCmd.Run()
if err != nil{ if err != nil {
fmt.Println(err) fmt.Println(err)
}else { } else {
self.Screen.TitleBar.UpdateTimeLocation() self.Screen.TitleBar.UpdateTimeLocation()
} }
fmt.Println("add ",cur_li.Path) fmt.Println("add ", cur_li.Path)
} }
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
func (self *TimeZoneListPage) Rescan() { func (self *TimeZoneListPage) Rescan() {
self.SyncList(TimeZonePath) self.SyncList(TimeZonePath)
self.PsIndex = 0 self.PsIndex = 0
} }
func (self *TimeZoneListPage) KeyDown(ev *event.Event) { func (self *TimeZoneListPage) KeyDown(ev *event.Event) {
if ev.Data["Key"] == UI.CurKeys["Menu"] || ev.Data["Key"] == UI.CurKeys["A"] { if ev.Data["Key"] == UI.CurKeys["Menu"] || ev.Data["Key"] == UI.CurKeys["A"] {
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["Up"] { if ev.Data["Key"] == UI.CurKeys["Up"] {
self.ScrollUp() self.ScrollUp()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["Down"] { if ev.Data["Key"] == UI.CurKeys["Down"] {
self.ScrollDown() self.ScrollDown()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["Right"] { if ev.Data["Key"] == UI.CurKeys["Right"] {
self.FastScrollDown(5) self.FastScrollDown(5)
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["Left"] { if ev.Data["Key"] == UI.CurKeys["Left"] {
self.FastScrollUp(5) self.FastScrollUp(5)
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["Enter"] { if ev.Data["Key"] == UI.CurKeys["Enter"] {
self.Click() self.Click()
} }
} }
func (self *TimeZoneListPage) Draw() { func (self *TimeZoneListPage) Draw() {
self.ClearCanvas() self.ClearCanvas()
if len(self.MyList) == 0 { if len(self.MyList) == 0 {
self.BGpng.NewCoord(self.Width/2,self.Height/2) self.BGpng.NewCoord(self.Width/2, self.Height/2)
self.BGpng.Draw() self.BGpng.Draw()
} }
if len(self.MyList) *TimeZoneListPageListItemDefaultHeight > self.Height { if len(self.MyList)*TimeZoneListPageListItemDefaultHeight > self.Height {
self.Ps.(*ListPageSelector).Width = self.Width - 11 self.Ps.(*ListPageSelector).Width = self.Width - 11
self.Ps.Draw() self.Ps.Draw()
for _,v := range self.MyList { for _, v := range self.MyList {
if v.(*TimeZoneListPageListItem).PosY > self.Height + self.Height/2 { if v.(*TimeZoneListPageListItem).PosY > self.Height+self.Height/2 {
break break
} }
if v.(*TimeZoneListPageListItem).PosY < 0 { if v.(*TimeZoneListPageListItem).PosY < 0 {
continue continue
} }
v.Draw() v.Draw()
} }
self.Scroller.UpdateSize( len(self.MyList)*TimeZoneListPageListItemDefaultHeight, self.Scroller.UpdateSize(len(self.MyList)*TimeZoneListPageListItemDefaultHeight,
self.PsIndex*TimeZoneListPageListItemDefaultHeight) self.PsIndex*TimeZoneListPageListItemDefaultHeight)
self.Scroller.Draw() self.Scroller.Draw()
}else { } else {
self.Ps.(*ListPageSelector).Width = self.Width self.Ps.(*ListPageSelector).Width = self.Width
self.Ps.Draw() self.Ps.Draw()
for _,v := range self.MyList { for _, v := range self.MyList {
if v.(*TimeZoneListPageListItem).PosY > self.Height + self.Height/2 { if v.(*TimeZoneListPageListItem).PosY > self.Height+self.Height/2 {
break break
} }
if v.(*TimeZoneListPageListItem).PosY < 0 { if v.(*TimeZoneListPageListItem).PosY < 0 {
continue continue
} }
v.Draw()
}
}
v.Draw()
}
}
} }

11
Menu/GameShell/10_Settings/Update/plugin_init.go
View File

@@ -1,22 +1,23 @@
package Update package Update
import ( import (
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
) )
/******************************************************************************/ /******************************************************************************/
type UpdatePlugin struct { type UpdatePlugin struct {
UI.Plugin UI.Plugin
Page UI.PageInterface Page UI.PageInterface
} }
func (self *UpdatePlugin) Init(main_screen *UI.MainScreen) {
func (self *UpdatePlugin) Init( main_screen *UI.MainScreen ) {
self.Page = NewUpdatePage() self.Page = NewUpdatePage()
self.Page.SetScreen( main_screen) self.Page.SetScreen(main_screen)
self.Page.SetName("Update LauncherGo") self.Page.SetName("Update LauncherGo")
self.Page.Init() self.Page.Init()
} }
func (self *UpdatePlugin) Run( main_screen *UI.MainScreen ) { func (self *UpdatePlugin) Run(main_screen *UI.MainScreen) {
if main_screen != nil { if main_screen != nil {
main_screen.PushPage(self.Page) main_screen.PushPage(self.Page)
main_screen.Draw() main_screen.Draw()

314
Menu/GameShell/10_Settings/Update/update_page.go
View File

@@ -1,46 +1,46 @@
package Update package Update
import ( import (
"fmt" "bytes"
"bytes" "encoding/json"
"strings" "fmt"
gotime "time"
"os/exec"
"encoding/json"
"net/http"
"github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/time" "github.com/cuu/gogame/time"
// "github.com/cuu/gogame/surface" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/event" "net/http"
//"github.com/cuu/gogame/rect" "os/exec"
"strings"
gotime "time"
// "github.com/cuu/gogame/surface"
"github.com/cuu/gogame/event"
//"github.com/cuu/gogame/rect"
//"github.com/cuu/gogame/color" //"github.com/cuu/gogame/color"
// "github.com/cuu/gogame/font" // "github.com/cuu/gogame/font"
//"github.com/cuu/gogame/draw" //"github.com/cuu/gogame/draw"
"github.com/clockworkpi/LauncherGoDev/sysgo" "github.com/clockworkpi/LauncherGoDev/sysgo"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
) )
var InfoPageListItemDefaultHeight = 30 var InfoPageListItemDefaultHeight = 30
var launchergo_path = "/home/cpi/launchergo" var launchergo_path = "/home/cpi/launchergo"
type UpdateConfirmPage struct { type UpdateConfirmPage struct {
UI.ConfirmPage UI.ConfirmPage
URL string URL string
MD5 string MD5 string
Version string Version string
GIT bool GIT bool
} }
func NewUpdateConfirmPage() *UpdateConfirmPage { func NewUpdateConfirmPage() *UpdateConfirmPage {
p := &UpdateConfirmPage{} p := &UpdateConfirmPage{}
p.ListFont = UI.Fonts["veramono20"] p.ListFont = UI.Fonts["veramono20"]
p.FootMsg = [5]string{"Nav","","","Cancel","Yes"} p.FootMsg = [5]string{"Nav", "", "", "Cancel", "Yes"}
p.ConfirmText = "Confirm Update?" p.ConfirmText = "Confirm Update?"
return p return p
} }
func (self *UpdateConfirmPage) KeyDown(ev *event.Event) { func (self *UpdateConfirmPage) KeyDown(ev *event.Event) {
@@ -51,209 +51,207 @@ func (self *UpdateConfirmPage) KeyDown(ev *event.Event) {
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["B"] { if ev.Data["Key"] == UI.CurKeys["B"] {
fmt.Println("Update Confirm Page B",self.GIT) fmt.Println("Update Confirm Page B", self.GIT)
if self.GIT == true { if self.GIT == true {
//go exec requires FullPath of script filename //go exec requires FullPath of script filename
cmdpath := fmt.Sprintf("%s/update.sh %s",UI.GetExePath(),self.Version) cmdpath := fmt.Sprintf("%s/update.sh %s", UI.GetExePath(), self.Version)
event.Post(UI.RUNSH,cmdpath) event.Post(UI.RUNSH, cmdpath)
return return
} }
} }
} }
func (self *UpdateConfirmPage) OnReturnBackCb() { func (self *UpdateConfirmPage) OnReturnBackCb() {
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
func (self *UpdateConfirmPage) Draw() { func (self *UpdateConfirmPage) Draw() {
self.ClearCanvas() self.ClearCanvas()
self.DrawBG() self.DrawBG()
for _,v := range self.MyList{ for _, v := range self.MyList {
v.Draw() v.Draw()
} }
self.Reset() self.Reset()
} }
type UpdatePage struct { type UpdatePage struct {
UI.Page UI.Page
AList map[string]map[string]string AList map[string]map[string]string
ListFontObj *ttf.Font ListFontObj *ttf.Font
MyList []*UI.InfoPageListItem MyList []*UI.InfoPageListItem
ConfirmPage *UpdateConfirmPage ConfirmPage *UpdateConfirmPage
} }
func NewUpdatePage() *UpdatePage { func NewUpdatePage() *UpdatePage {
p := &UpdatePage{} p := &UpdatePage{}
p.FootMsg = [5]string{ "Nav","Check Update","","Back","" } p.FootMsg = [5]string{"Nav", "Check Update", "", "Back", ""}
p.PageIconMargin = 20 p.PageIconMargin = 20
p.SelectedIconTopOffset = 20 p.SelectedIconTopOffset = 20
p.EasingDur = 10 p.EasingDur = 10
p.Align = UI.ALIGN["SLeft"] p.Align = UI.ALIGN["SLeft"]
p.ListFontObj = UI.Fonts["varela15"] p.ListFontObj = UI.Fonts["varela15"]
p.AList = make( map[string]map[string]string ) p.AList = make(map[string]map[string]string)
return p return p
} }
func (self *UpdatePage) GenList() { func (self *UpdatePage) GenList() {
self.MyList = nil self.MyList = nil
self.MyList = make([]*UI.InfoPageListItem,0) self.MyList = make([]*UI.InfoPageListItem, 0)
start_x := 0 start_x := 0
start_y := 0 start_y := 0
i := 0 i := 0
for k,_ := range self.AList { for k, _ := range self.AList {
li := UI.NewInfoPageListItem() li := UI.NewInfoPageListItem()
li.Parent = self li.Parent = self
li.PosX = start_x li.PosX = start_x
li.PosY = start_y + i*InfoPageListItemDefaultHeight li.PosY = start_y + i*InfoPageListItemDefaultHeight
li.Width = UI.Width li.Width = UI.Width
li.Fonts["normal"] = self.ListFontObj li.Fonts["normal"] = self.ListFontObj
li.Fonts["small"] = UI.Fonts["varela12"] li.Fonts["small"] = UI.Fonts["varela12"]
if self.AList[k]["label"] != "" { if self.AList[k]["label"] != "" {
li.Init(self.AList[k]["label"]) li.Init(self.AList[k]["label"])
}else { } else {
li.Init(self.AList[k]["key"] ) li.Init(self.AList[k]["key"])
} }
li.Flag = self.AList[k]["key"] li.Flag = self.AList[k]["key"]
li.SetSmallText( self.AList[k]["value"]) li.SetSmallText(self.AList[k]["value"])
self.MyList = append(self.MyList,li) self.MyList = append(self.MyList, li)
i+=1 i += 1
} }
} }
func (self *UpdatePage) Init() { func (self *UpdatePage) Init() {
self.CanvasHWND = self.Screen.CanvasHWND self.CanvasHWND = self.Screen.CanvasHWND
self.Width = self.Screen.Width self.Width = self.Screen.Width
self.Height = self.Screen.Height self.Height = self.Screen.Height
self.ConfirmPage = NewUpdateConfirmPage() self.ConfirmPage = NewUpdateConfirmPage()
self.ConfirmPage.Screen = self.Screen self.ConfirmPage.Screen = self.Screen
self.ConfirmPage.Name = "Update Confirm" self.ConfirmPage.Name = "Update Confirm"
self.ConfirmPage.Init() self.ConfirmPage.Init()
it := make(map[string]string) it := make(map[string]string)
it["key"] = "version" it["key"] = "version"
it["label"] = "Version" it["label"] = "Version"
it["value"] = sysgo.VERSION it["value"] = sysgo.VERSION
self.AList["version"] = it self.AList["version"] = it
self.GenList() self.GenList()
} }
func (self *UpdatePage) CheckUpdate() bool { func (self *UpdatePage) CheckUpdate() bool {
self.Screen.MsgBox.SetText("Checking Update") self.Screen.MsgBox.SetText("Checking Update")
self.Screen.MsgBox.Draw() self.Screen.MsgBox.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
type Response struct { type Response struct {
GitVersion string `json:"gitversion"` GitVersion string `json:"gitversion"`
} }
timeout := gotime.Duration(8 * gotime.Second)
client := http.Client{
Timeout: timeout,
}
timeout := gotime.Duration(8 * gotime.Second) resp, err := client.Get(sysgo.UPDATE_URL)
client := http.Client{ if err != nil {
Timeout: timeout, fmt.Println(err)
} return false
}
resp, err := client.Get(sysgo.UPDATE_URL) var ret Response
if err != nil { buf := new(bytes.Buffer)
fmt.Println(err)
return false
}
var ret Response
buf := new(bytes.Buffer)
buf.ReadFrom(resp.Body) buf.ReadFrom(resp.Body)
respByte := buf.Bytes() respByte := buf.Bytes()
if err := json.Unmarshal(respByte, &ret); err != nil { if err := json.Unmarshal(respByte, &ret); err != nil {
fmt.Println(err) fmt.Println(err)
return false return false
} }
fmt.Println("got git version :", ret.GitVersion) fmt.Println("got git version :", ret.GitVersion)
launchergo_git_rev_parse := exec.Command("git", "rev-parse", "--short", "HEAD") launchergo_git_rev_parse := exec.Command("git", "rev-parse", "--short", "HEAD")
launchergo_git_rev_parse.Dir = launchergo_path launchergo_git_rev_parse.Dir = launchergo_path
var out bytes.Buffer var out bytes.Buffer
launchergo_git_rev_parse.Stdout = &out launchergo_git_rev_parse.Stdout = &out
err = launchergo_git_rev_parse.Run() err = launchergo_git_rev_parse.Run()
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return false return false
} }
git_revision_short_hash := strings.Trim(out.String(), "\r\n ") git_revision_short_hash := strings.Trim(out.String(), "\r\n ")
if git_revision_short_hash != ret.GitVersion { if git_revision_short_hash != ret.GitVersion {
self.ConfirmPage.Version = ret.GitVersion self.ConfirmPage.Version = ret.GitVersion
self.ConfirmPage.GIT = true self.ConfirmPage.GIT = true
self.Screen.PushCurPage() self.Screen.PushCurPage()
self.Screen.SetCurPage(self.ConfirmPage) self.Screen.SetCurPage(self.ConfirmPage)
self.Screen.Draw() self.Screen.Draw()
self.ConfirmPage.SnapMsg( fmt.Sprintf("Update to %s?",ret.GitVersion)) self.ConfirmPage.SnapMsg(fmt.Sprintf("Update to %s?", ret.GitVersion))
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
}else { } else {
self.Screen.Draw() self.Screen.Draw()
self.Screen.MsgBox.SetText("Launchergo is up to date") self.Screen.MsgBox.SetText("Launchergo is up to date")
self.Screen.MsgBox.Draw() self.Screen.MsgBox.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
time.BlockDelay(765) time.BlockDelay(765)
} }
defer resp.Body.Close() defer resp.Body.Close()
return true
return true
} }
func (self *UpdatePage) KeyDown(ev *event.Event) { func (self *UpdatePage) KeyDown(ev *event.Event) {
if ev.Data["Key"] == UI.CurKeys["A"] || ev.Data["Key"] == UI.CurKeys["Menu"] { if ev.Data["Key"] == UI.CurKeys["A"] || ev.Data["Key"] == UI.CurKeys["Menu"] {
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["X"] { if ev.Data["Key"] == UI.CurKeys["X"] {
if self.Screen.IsWifiConnectedNow() == true { if self.Screen.IsWifiConnectedNow() == true {
if self.CheckUpdate() == true { if self.CheckUpdate() == true {
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
}else { } else {
self.Screen.Draw() self.Screen.Draw()
self.Screen.MsgBox.SetText("Check Update Failed") self.Screen.MsgBox.SetText("Check Update Failed")
self.Screen.MsgBox.Draw() self.Screen.MsgBox.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
}else { } else {
self.Screen.Draw() self.Screen.Draw()
self.Screen.MsgBox.SetText("Please Check your Wi-Fi connection") self.Screen.MsgBox.SetText("Please Check your Wi-Fi connection")
self.Screen.MsgBox.Draw() self.Screen.MsgBox.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
} }
} }
func (self *UpdatePage) Draw() { func (self *UpdatePage) Draw() {
self.ClearCanvas() self.ClearCanvas()
for _,v := range self.MyList { for _, v := range self.MyList {
v.Draw() v.Draw()
} }
} }

251
Menu/GameShell/10_Settings/Wifi/net_item.go
View File

@@ -1,51 +1,50 @@
package Wifi package Wifi
import ( import (
"fmt" "fmt"
//"strconv" //"strconv"
//"strings" //"strings"
"github.com/veandco/go-sdl2/sdl"
"github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/color"
"github.com/cuu/gogame/draw"
"github.com/cuu/gogame/rect"
"github.com/cuu/gogame/surface"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
"github.com/cuu/gogame/color"
"github.com/cuu/gogame/draw"
"github.com/cuu/gogame/rect"
"github.com/cuu/gogame/surface"
"github.com/veandco/go-sdl2/sdl"
"github.com/veandco/go-sdl2/ttf"
) )
var NetItemDefaultHeight = 30 var NetItemDefaultHeight = 30
type NetItemMultiIcon struct { type NetItemMultiIcon struct {
UI.MultiIconItem UI.MultiIconItem
CanvasHWND *sdl.Surface // self._Parent._CanvasHWND CanvasHWND *sdl.Surface // self._Parent._CanvasHWND
Parent UI.WidgetInterface // Parent UI.WidgetInterface //
} }
func NewNetItemMultiIcon() *NetItemMultiIcon{ func NewNetItemMultiIcon() *NetItemMultiIcon {
p := &NetItemMultiIcon{} p := &NetItemMultiIcon{}
p.IconIndex = 0 p.IconIndex = 0
p.IconWidth = 18 p.IconWidth = 18
p.IconHeight = 18 p.IconHeight = 18
p.Width = 18 p.Width = 18
p.Height = 18 p.Height = 18
return p return p
} }
func (self *NetItemMultiIcon) Draw() { func (self *NetItemMultiIcon) Draw() {
_,h_ := self.Parent.Size() _, h_ := self.Parent.Size()
dest_rect := rect.Rect(self.PosX,self.PosY+(h_-self.Height)/2, self.Width,self.Height) dest_rect := rect.Rect(self.PosX, self.PosY+(h_-self.Height)/2, self.Width, self.Height)
area_rect := rect.Rect(0,self.IconIndex*self.IconHeight,self.IconWidth,self.IconHeight) area_rect := rect.Rect(0, self.IconIndex*self.IconHeight, self.IconWidth, self.IconHeight)
surface.Blit(self.CanvasHWND,self.ImgSurf,&dest_rect,&area_rect) surface.Blit(self.CanvasHWND, self.ImgSurf, &dest_rect, &area_rect)
} }
type NetItemIcon struct { type NetItemIcon struct {
UI.IconItem UI.IconItem
CanvasHWND *sdl.Surface CanvasHWND *sdl.Surface
Parent UI.WidgetInterface Parent UI.WidgetInterface
} }
func NewNetItemIcon() *NetItemIcon { func NewNetItemIcon() *NetItemIcon {
@@ -56,35 +55,32 @@ func NewNetItemIcon() *NetItemIcon {
} }
func (self *NetItemIcon) Draw() { func (self *NetItemIcon) Draw() {
_,h_ := self.Parent.Size() _, h_ := self.Parent.Size()
dest_rect := rect.Rect(self.PosX,self.PosY+(h_-self.Height)/2,self.Width,self.Height) dest_rect := rect.Rect(self.PosX, self.PosY+(h_-self.Height)/2, self.Width, self.Height)
surface.Blit(self.CanvasHWND,self.ImgSurf,&dest_rect,nil) surface.Blit(self.CanvasHWND, self.ImgSurf, &dest_rect, nil)
} }
type NetItem struct { type NetItem struct {
UI.Widget UI.Widget
Bssid string //eg: 50:3A:A0:51:18:3C Bssid string //eg: 50:3A:A0:51:18:3C
Essid string //eg: MERCURY_EB88 Essid string //eg: MERCURY_EB88
ip string ip string
Encrypt string // WPA2 Encrypt string // WPA2
Channel string //'10' Channel string //'10'
Signal int16 // -67 Signal int16 // -67
Mode string // Master or AdHoc Mode string // Master or AdHoc
Parent *WifiList Parent *WifiList
IsActive bool IsActive bool
Password string Password string
Labels map[string]UI.LabelInterface Labels map[string]UI.LabelInterface
Icons map[string]UI.IconItemInterface Icons map[string]UI.IconItemInterface
Fonts map[string]*ttf.Font Fonts map[string]*ttf.Font
FontObj *ttf.Font FontObj *ttf.Font
} }
func NewNetItem() *NetItem { func NewNetItem() *NetItem {
@@ -93,47 +89,46 @@ func NewNetItem() *NetItem {
p.Height = NetItemDefaultHeight p.Height = NetItemDefaultHeight
p.Labels = make(map[string]UI.LabelInterface) p.Labels = make(map[string]UI.LabelInterface)
p.Icons = make( map[string]UI.IconItemInterface) p.Icons = make(map[string]UI.IconItemInterface)
p.Fonts = make(map[string]*ttf.Font) p.Fonts = make(map[string]*ttf.Font)
return p return p
} }
func (self *NetItem) SetActive( act bool) { func (self *NetItem) SetActive(act bool) {
self.IsActive = act self.IsActive = act
} }
func (self *NetItem) UpdateStrenLabel() { // ## sig_str should be 'number',eg:'-70' func (self *NetItem) UpdateStrenLabel() { // ## sig_str should be 'number',eg:'-70'
if _, ok := self.Labels["stren"]; ok { if _, ok := self.Labels["stren"]; ok {
self.Labels["stren"].SetText( fmt.Sprintf("%d",self.CalcWifiQuality()) ) self.Labels["stren"].SetText(fmt.Sprintf("%d", self.CalcWifiQuality()))
} }
} }
func (self *NetItem) Init(is_active bool) { func (self *NetItem) Init(is_active bool) {
//strenstr := "quality" //strenstr := "quality"
//gap := 7 //gap := 7
the_main_screen := self.Parent.GetScreen() the_main_screen := self.Parent.GetScreen()
if is_active { if is_active {
self.SetActive(is_active) self.SetActive(is_active)
} }
essid_label := UI.NewLabel()
essid_label.PosX = 36
essid_label.CanvasHWND = self.Parent.GetCanvasHWND()
essid_label := UI.NewLabel() essid_ := ""
essid_label.PosX = 36
essid_label.CanvasHWND = self.Parent.GetCanvasHWND()
essid_ := "" if len(self.Essid) > 19 {
if len(self.Essid) > 19 {
essid_ = self.Essid[:20] essid_ = self.Essid[:20]
}else { } else {
essid_ = self.Essid essid_ = self.Essid
} }
if len(essid_) == 0 { if len(essid_) == 0 {
essid_ = self.Bssid essid_ = self.Bssid
@@ -145,113 +140,111 @@ func (self *NetItem) Init(is_active bool) {
//fmt.Println("essid: ",essid_, len(essid_)) //fmt.Println("essid: ",essid_, len(essid_))
essid_label.Init(essid_, self.FontObj,nil) essid_label.Init(essid_, self.FontObj, nil)
self.Labels["essid"] = essid_label self.Labels["essid"] = essid_label
stren_label := UI.NewLabel() stren_label := UI.NewLabel()
stren_label.CanvasHWND = self.Parent.GetCanvasHWND() stren_label.CanvasHWND = self.Parent.GetCanvasHWND()
stren_l := fmt.Sprintf("%%%d ",self.CalcWifiQuality()) stren_l := fmt.Sprintf("%%%d ", self.CalcWifiQuality())
if len(stren_l) == 0 { if len(stren_l) == 0 {
stren_l = "%%0" stren_l = "%%0"
} }
stren_label.Init(stren_l, self.FontObj,nil) stren_label.Init(stren_l, self.FontObj, nil)
stren_label.PosX = self.Width - 23 - stren_label.Width-2 stren_label.PosX = self.Width - 23 - stren_label.Width - 2
self.Labels["stren"] = stren_label self.Labels["stren"] = stren_label
lock_icon := NewNetItemIcon() lock_icon := NewNetItemIcon()
lock_icon.ImgSurf = UI.MyIconPool.GetImgSurf("lock") lock_icon.ImgSurf = UI.MyIconPool.GetImgSurf("lock")
lock_icon.CanvasHWND = self.Parent.GetCanvasHWND() lock_icon.CanvasHWND = self.Parent.GetCanvasHWND()
lock_icon.Parent = self // WidgetInterface lock_icon.Parent = self // WidgetInterface
self.Icons["lock"] = lock_icon self.Icons["lock"] = lock_icon
done_icon := NewNetItemIcon() done_icon := NewNetItemIcon()
done_icon.ImgSurf = UI.MyIconPool.GetImgSurf("done") done_icon.ImgSurf = UI.MyIconPool.GetImgSurf("done")
done_icon.CanvasHWND = self.Parent.GetCanvasHWND() done_icon.CanvasHWND = self.Parent.GetCanvasHWND()
done_icon.Parent = self done_icon.Parent = self
self.Icons["done"] = done_icon self.Icons["done"] = done_icon
nimt := NewNetItemMultiIcon() nimt := NewNetItemMultiIcon()
nimt.ImgSurf = the_main_screen.TitleBar.Icons["wifistatus"].GetImgSurf() nimt.ImgSurf = the_main_screen.TitleBar.Icons["wifistatus"].GetImgSurf()
nimt.CanvasHWND = self.Parent.GetCanvasHWND() nimt.CanvasHWND = self.Parent.GetCanvasHWND()
nimt.Parent = self // WidgetInterface nimt.Parent = self // WidgetInterface
self.Icons["wifistatus"] = nimt self.Icons["wifistatus"] = nimt
} }
func (self *NetItem) Connect() { func (self *NetItem) Connect() {
} }
func (self *NetItem) CalcWifiQuality() int { func (self *NetItem) CalcWifiQuality() int {
qua := 0 qua := 0
qua = 2 * (int(self.Signal) + 100) qua = 2 * (int(self.Signal) + 100)
return qua return qua
} }
func (self *NetItem) CalcWifiStrength() int { func (self *NetItem) CalcWifiStrength() int {
segs := [][]int{ []int{-2,-1}, []int{0,25}, []int{25,50}, []int{50,75},[]int{75,100}} segs := [][]int{[]int{-2, -1}, []int{0, 25}, []int{25, 50}, []int{50, 75}, []int{75, 100}}
stren_number := self.CalcWifiQuality() stren_number := self.CalcWifiQuality()
ge := 0 ge := 0
if stren_number == 0 { if stren_number == 0 {
return ge return ge
} }
for i,v := range segs { for i, v := range segs {
if stren_number >= v[0] && stren_number <= v[1] { if stren_number >= v[0] && stren_number <= v[1] {
ge = i ge = i
break break
} }
} }
return ge return ge
} }
func (self *NetItem) Draw() { func (self *NetItem) Draw() {
for i,v := range self.Labels { for i, v := range self.Labels {
x_,_ := v.Coord() x_, _ := v.Coord()
_,h_ := v.Size() _, h_ := v.Size()
self.Labels[i].NewCoord(x_,self.PosY+(self.Height - h_)/2) self.Labels[i].NewCoord(x_, self.PosY+(self.Height-h_)/2)
self.Labels[i].Draw() self.Labels[i].Draw()
} }
if self.IsActive == true { if self.IsActive == true {
self.Icons["done"].NewCoord(14,self.PosY) self.Icons["done"].NewCoord(14, self.PosY)
self.Icons["done"].Draw() self.Icons["done"].Draw()
} }
/* /*
if self.Encrypt != "Unsecured" { if self.Encrypt != "Unsecured" {
w_,_ := self.Labels["stren"].Size() w_,_ := self.Labels["stren"].Size()
self.Icons["lock"].NewCoord(self.Width -23 - w_ -2 - 18, self.PosY) self.Icons["lock"].NewCoord(self.Width -23 - w_ -2 - 18, self.PosY)
self.Icons["lock"].Draw() self.Icons["lock"].Draw()
} }
*/ */
//the_main_screen := self.Parent.GetScreen() //the_main_screen := self.Parent.GetScreen()
ge := self.CalcWifiStrength() ge := self.CalcWifiStrength()
if ge > 0 { if ge > 0 {
self.Icons["wifistatus"].SetIconIndex(ge) self.Icons["wifistatus"].SetIconIndex(ge)
self.Icons["wifistatus"].NewCoord(self.Width-23,self.PosY) self.Icons["wifistatus"].NewCoord(self.Width-23, self.PosY)
self.Icons["wifistatus"].Draw() self.Icons["wifistatus"].Draw()
}else { } else {
self.Icons["wifistatus"].SetIconIndex(0) self.Icons["wifistatus"].SetIconIndex(0)
self.Icons["wifistatus"].NewCoord(self.Width-23,self.PosY) self.Icons["wifistatus"].NewCoord(self.Width-23, self.PosY)
self.Icons["wifistatus"].Draw() self.Icons["wifistatus"].Draw()
} }
draw.Line(self.Parent.GetCanvasHWND(), draw.Line(self.Parent.GetCanvasHWND(),
&color.Color{169,169,169,255}, &color.Color{169, 169, 169, 255},
self.PosX,self.PosY+self.Height-1, self.PosX, self.PosY+self.Height-1,
self.PosX+self.Width,self.PosY+self.Height-1, self.PosX+self.Width, self.PosY+self.Height-1,
1) 1)
} }

58
Menu/GameShell/10_Settings/Wifi/plugin_init.go
View File

@@ -1,61 +1,59 @@
package Wifi package Wifi
import ( import (
//gotime "time" //gotime "time"
/* /*
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/surface" "github.com/cuu/gogame/surface"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
*/ */
"github.com/clockworkpi/LauncherGoDev/sysgo" "github.com/clockworkpi/LauncherGoDev/sysgo"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
//"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS" //"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS"
wifi "github.com/cuu/wpa-connect" wifi "github.com/cuu/wpa-connect"
) )
/******************************************************************************/ /******************************************************************************/
type WifiPlugin struct { type WifiPlugin struct {
UI.Plugin UI.Plugin
ScanPage *WifiList ScanPage *WifiList
PasswordPage *UI.Keyboard PasswordPage *UI.Keyboard
} }
var ( var (
GsScanManager = wifi.NewScanManager(sysgo.WifiDev) GsScanManager = wifi.NewScanManager(sysgo.WifiDev)
GsConnectManager = wifi.NewConnectManager(sysgo.WifiDev) GsConnectManager = wifi.NewConnectManager(sysgo.WifiDev)
) )
func (self *WifiPlugin) Init(main_screen *UI.MainScreen) {
func (self *WifiPlugin) Init( main_screen *UI.MainScreen ) { self.PasswordPage = UI.NewKeyboard()
self.PasswordPage.Name = "Enter wifi password"
self.PasswordPage.Screen = main_screen
self.PasswordPage.Init()
self.PasswordPage = UI.NewKeyboard() self.ScanPage = NewWifiList()
self.PasswordPage.Name = "Enter wifi password" self.ScanPage.Name = "Scan wifi"
self.PasswordPage.Screen= main_screen
self.PasswordPage.Init()
self.ScanPage = NewWifiList() self.ScanPage.Screen = main_screen
self.ScanPage.Name = "Scan wifi"
self.ScanPage.Screen = main_screen self.PasswordPage.Caller = self.ScanPage
self.PasswordPage.Caller = self.ScanPage self.ScanPage.Init()
self.ScanPage.Init()
} }
func (self *WifiPlugin) Run( main_screen *UI.MainScreen ) { func (self *WifiPlugin) Run(main_screen *UI.MainScreen) {
if main_screen != nil { if main_screen != nil {
main_screen.PushCurPage() main_screen.PushCurPage()
main_screen.SetCurPage(self.ScanPage) main_screen.SetCurPage(self.ScanPage)
main_screen.Draw() main_screen.Draw()
main_screen.SwapAndShow() main_screen.SwapAndShow()
} }
} }
var APIOBJ WifiPlugin var APIOBJ WifiPlugin

902
Menu/GameShell/10_Settings/Wifi/wifi.go
View File

File diff suppressed because it is too large Load Diff

27
Menu/GameShell/98_TinyCloud/plugin_init.go
View File

@@ -1,14 +1,14 @@
package TinyCloud package TinyCloud
import ( import (
/* /*
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/surface" "github.com/cuu/gogame/surface"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
*/ */
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
//"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS" //"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS"
) )
@@ -16,21 +16,20 @@ import (
/******************************************************************************/ /******************************************************************************/
type TinyCloudPlugin struct { type TinyCloudPlugin struct {
UI.Plugin UI.Plugin
MainPage *TinyCloudPage MainPage *TinyCloudPage
} }
func (self *TinyCloudPlugin) Init( main_screen *UI.MainScreen ) { func (self *TinyCloudPlugin) Init(main_screen *UI.MainScreen) {
self.MainPage = NewTinyCloudPage() self.MainPage = NewTinyCloudPage()
self.MainPage.SetScreen( main_screen) self.MainPage.SetScreen(main_screen)
self.MainPage.SetName("Tiny cloud") self.MainPage.SetName("Tiny cloud")
self.MainPage.Init() self.MainPage.Init()
} }
func (self *TinyCloudPlugin) Run( main_screen *UI.MainScreen ) { func (self *TinyCloudPlugin) Run(main_screen *UI.MainScreen) {
if main_screen != nil { if main_screen != nil {
main_screen.PushCurPage() main_screen.PushCurPage()
main_screen.SetCurPage(self.MainPage) main_screen.SetCurPage(self.MainPage)
main_screen.Draw() main_screen.Draw()
main_screen.SwapAndShow() main_screen.SwapAndShow()
} }

250
Menu/GameShell/98_TinyCloud/tiny_cloud_page.go
View File

@@ -1,215 +1,209 @@
package TinyCloud package TinyCloud
import ( import (
"fmt" "fmt"
"github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/surface"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/surface"
"github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
) )
type TinyCloudLabel struct { type TinyCloudLabel struct {
Key string Key string
Lable string Lable string
Font *ttf.Font Font *ttf.Font
Color *color.Color Color *color.Color
} }
type TinyCloudPage struct { type TinyCloudPage struct {
UI.Page UI.Page
ListFontObj *ttf.Font ListFontObj *ttf.Font
URLColor *color.Color URLColor *color.Color
TextColor *color.Color TextColor *color.Color
Labels map[string]UI.LabelInterface Labels map[string]UI.LabelInterface
Icons map[string]UI.IconItemInterface Icons map[string]UI.IconItemInterface
Coords map[string]UI.Coord Coords map[string]UI.Coord
IP string IP string
PngSize map[string]UI.Plane PngSize map[string]UI.Plane
} }
func NewTinyCloudPage() *TinyCloudPage { func NewTinyCloudPage() *TinyCloudPage {
p := &TinyCloudPage{} p := &TinyCloudPage{}
p.PageIconMargin = 20 p.PageIconMargin = 20
p.SelectedIconTopOffset = 20 p.SelectedIconTopOffset = 20
p.EasingDur = 10 p.EasingDur = 10
p.Align = UI.ALIGN["SLeft"] p.Align = UI.ALIGN["SLeft"]
p.FootMsg = [5]string{"Nav.","","","Back",""} p.FootMsg = [5]string{"Nav.", "", "", "Back", ""}
p.Coords = make(map[string]UI.Coord) p.Coords = make(map[string]UI.Coord)
p.PngSize = make(map[string]UI.Plane) p.PngSize = make(map[string]UI.Plane)
p.URLColor = UI.MySkinManager.GiveColor("URL") p.URLColor = UI.MySkinManager.GiveColor("URL")
p.TextColor = UI.MySkinManager.GiveColor("Text") p.TextColor = UI.MySkinManager.GiveColor("Text")
p.ListFontObj = UI.MyLangManager.TrFont("varela13") p.ListFontObj = UI.MyLangManager.TrFont("varela13")
p.Labels = make(map[string]UI.LabelInterface) p.Labels = make(map[string]UI.LabelInterface)
p.Icons = make(map[string]UI.IconItemInterface) p.Icons = make(map[string]UI.IconItemInterface)
return p return p
} }
func (self *TinyCloudPage) OnLoadCb() { func (self *TinyCloudPage) OnLoadCb() {
self.PosY = 0 self.PosY = 0
} }
func (self *TinyCloudPage) SetCoords() { func (self *TinyCloudPage) SetCoords() {
self.Coords["forID"] = UI.Coord{15,11} self.Coords["forID"] = UI.Coord{15, 11}
self.Coords["forKey"] = UI.Coord{71,self.Coords["forID"].Y} self.Coords["forKey"] = UI.Coord{71, self.Coords["forID"].Y}
self.Coords["key_and_pass"] = UI.Coord{36, self.Coords["forID"].Y} self.Coords["key_and_pass"] = UI.Coord{36, self.Coords["forID"].Y}
self.Coords["forssh"] = UI.Coord{self.Coords["forID"].X,36} self.Coords["forssh"] = UI.Coord{self.Coords["forID"].X, 36}
self.Coords["ssh_addr"] = UI.Coord{self.Coords["forID"].X,54} self.Coords["ssh_addr"] = UI.Coord{self.Coords["forID"].X, 54}
self.Coords["forwin"] = UI.Coord{self.Coords["forID"].X,80} self.Coords["forwin"] = UI.Coord{self.Coords["forID"].X, 80}
self.Coords["samba_games"] = UI.Coord{ self.Coords["forID"].X,97} self.Coords["samba_games"] = UI.Coord{self.Coords["forID"].X, 97}
self.Coords["samba_music"] = UI.Coord{ self.Coords["samba_games"].X,115} self.Coords["samba_music"] = UI.Coord{self.Coords["samba_games"].X, 115}
self.Coords["for_airplay"] = UI.Coord{ self.Coords["forID"].X,140} self.Coords["for_airplay"] = UI.Coord{self.Coords["forID"].X, 140}
self.Coords["airplay_name"] = UI.Coord{ 68,self.Coords["for_airplay"].Y} self.Coords["airplay_name"] = UI.Coord{68, self.Coords["for_airplay"].Y}
self.Coords["for-usb-eth"] = UI.Coord{ self.Coords["forID"].X,163} self.Coords["for-usb-eth"] = UI.Coord{self.Coords["forID"].X, 163}
self.Coords["usb-eth-addr"] = UI.Coord{ 112,self.Coords["for-usb-eth"].Y} self.Coords["usb-eth-addr"] = UI.Coord{112, self.Coords["for-usb-eth"].Y}
self.Coords["bg"] = UI.Coord{ self.Width/2,self.Height/2 } self.Coords["bg"] = UI.Coord{self.Width / 2, self.Height / 2}
self.Coords["online"] = UI.Coord{ 266, 99 } self.Coords["online"] = UI.Coord{266, 99}
} }
func (self *TinyCloudPage) SetLabels() { func (self *TinyCloudPage) SetLabels() {
if self.Screen.IsWifiConnectedNow() { if self.Screen.IsWifiConnectedNow() {
self.IP = self.Screen.GetWirelessIP() self.IP = self.Screen.GetWirelessIP()
fmt.Printf("TinyCould : %s\n",self.IP) fmt.Printf("TinyCould : %s\n", self.IP)
}else { } else {
self.IP = "xxx.xxx.xxx.xxx" self.IP = "xxx.xxx.xxx.xxx"
} }
labels := []*TinyCloudLabel{
&TinyCloudLabel{"forssh", "For ssh and scp:", self.ListFontObj, self.TextColor},
&TinyCloudLabel{"ssh_addr", fmt.Sprintf("ssh cpi@%s", self.IP), self.ListFontObj, self.URLColor},
&TinyCloudLabel{"forwin", "For Windows network:", self.ListFontObj, self.TextColor},
&TinyCloudLabel{"samba_games", fmt.Sprintf("\\\\%s\\games", self.IP), self.ListFontObj, self.URLColor},
&TinyCloudLabel{"samba_music", fmt.Sprintf("\\\\%s\\music", self.IP), self.ListFontObj, self.URLColor},
&TinyCloudLabel{"forID", "ID:", self.ListFontObj, self.TextColor},
&TinyCloudLabel{"forKey", "Key:", self.ListFontObj, self.TextColor},
&TinyCloudLabel{"key_and_pass", "cpi", self.ListFontObj, self.URLColor},
&TinyCloudLabel{"for_airplay", "Airplay:", self.ListFontObj, self.TextColor},
&TinyCloudLabel{"airplay_name", "clockworkpi", self.ListFontObj, self.URLColor},
&TinyCloudLabel{"for-usb-eth", "USB-Ethernet:", self.ListFontObj, self.TextColor},
&TinyCloudLabel{"usb-eth-addr", "192.168.10.1", self.ListFontObj, self.URLColor},
}
labels := []*TinyCloudLabel{ for _, v := range labels {
&TinyCloudLabel{"forssh","For ssh and scp:",self.ListFontObj,self.TextColor}, l := UI.NewLabel()
&TinyCloudLabel{"ssh_addr",fmt.Sprintf("ssh cpi@%s",self.IP), self.ListFontObj,self.URLColor}, l.SetCanvasHWND(self.CanvasHWND)
&TinyCloudLabel{"forwin", "For Windows network:", self.ListFontObj, self.TextColor}, l.Init(v.Lable, v.Font, nil)
&TinyCloudLabel{"samba_games", fmt.Sprintf("\\\\%s\\games", self.IP), self.ListFontObj,self.URLColor}, l.SetColor(v.Color)
&TinyCloudLabel{"samba_music", fmt.Sprintf("\\\\%s\\music" , self.IP), self.ListFontObj,self.URLColor}, self.Labels[v.Key] = l
&TinyCloudLabel{"forID", "ID:", self.ListFontObj, self.TextColor}, }
&TinyCloudLabel{"forKey", "Key:", self.ListFontObj, self.TextColor},
&TinyCloudLabel{"key_and_pass", "cpi", self.ListFontObj, self.URLColor},
&TinyCloudLabel{"for_airplay", "Airplay:", self.ListFontObj, self.TextColor},
&TinyCloudLabel{"airplay_name","clockworkpi", self.ListFontObj, self.URLColor},
&TinyCloudLabel{"for-usb-eth","USB-Ethernet:", self.ListFontObj, self.TextColor},
&TinyCloudLabel{"usb-eth-addr","192.168.10.1", self.ListFontObj, self.URLColor},
}
for _,v := range labels { self.SetCoords()
l := UI.NewLabel()
l.SetCanvasHWND(self.CanvasHWND)
l.Init(v.Lable,v.Font,nil)
l.SetColor(v.Color)
self.Labels[v.Key] = l
}
self.SetCoords()
} }
func (self *TinyCloudPage) Init() { func (self *TinyCloudPage) Init() {
if self.Screen == nil { if self.Screen == nil {
panic("No Screen") panic("No Screen")
} }
if self.Screen.CanvasHWND != nil && self.CanvasHWND == nil{ if self.Screen.CanvasHWND != nil && self.CanvasHWND == nil {
self.HWND = self.Screen.CanvasHWND self.HWND = self.Screen.CanvasHWND
self.CanvasHWND = surface.Surface(self.Screen.Width,self.Screen.Height) self.CanvasHWND = surface.Surface(self.Screen.Width, self.Screen.Height)
} }
self.PosX = self.Index*self.Screen.Width self.PosX = self.Index * self.Screen.Width
self.Width = self.Screen.Width self.Width = self.Screen.Width
self.Height = self.Screen.Height self.Height = self.Screen.Height
self.PngSize["bg"] = UI.Plane{253,114} self.PngSize["bg"] = UI.Plane{253, 114}
self.PngSize["online"] = UI.Plane{75,122} self.PngSize["online"] = UI.Plane{75, 122}
bgpng := UI.NewIconItem() bgpng := UI.NewIconItem()
bgpng.ImgSurf = UI.MyIconPool.GetImgSurf("needwifi_bg") bgpng.ImgSurf = UI.MyIconPool.GetImgSurf("needwifi_bg")
bgpng.MyType = UI.ICON_TYPES["STAT"] bgpng.MyType = UI.ICON_TYPES["STAT"]
bgpng.Parent = self bgpng.Parent = self
bgpng.Adjust(0,0,self.PngSize["bg"].W,self.PngSize["bg"].H,0) bgpng.Adjust(0, 0, self.PngSize["bg"].W, self.PngSize["bg"].H, 0)
self.Icons["bg"] = bgpng self.Icons["bg"] = bgpng
onlinepng := UI.NewIconItem() onlinepng := UI.NewIconItem()
onlinepng.ImgSurf = UI.MyIconPool.GetImgSurf("online") onlinepng.ImgSurf = UI.MyIconPool.GetImgSurf("online")
onlinepng.MyType = UI.ICON_TYPES["STAT"] onlinepng.MyType = UI.ICON_TYPES["STAT"]
onlinepng.Parent = self onlinepng.Parent = self
onlinepng.Adjust(0,0,self.PngSize["online"].W, self.PngSize["online"].H,0) onlinepng.Adjust(0, 0, self.PngSize["online"].W, self.PngSize["online"].H, 0)
self.Icons["online"] = onlinepng self.Icons["online"] = onlinepng
self.SetLabels() self.SetLabels()
} }
func (self *TinyCloudPage) KeyDown( ev *event.Event ) { func (self *TinyCloudPage) KeyDown(ev *event.Event) {
if ev.Data["Key"] == UI.CurKeys["A"] || ev.Data["Key"] == UI.CurKeys["Menu"] { if ev.Data["Key"] == UI.CurKeys["A"] || ev.Data["Key"] == UI.CurKeys["Menu"] {
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
return return
} }
func (self *TinyCloudPage) Draw() { func (self *TinyCloudPage) Draw() {
self.ClearCanvas() self.ClearCanvas()
if self.Screen.IsWifiConnectedNow() { if self.Screen.IsWifiConnectedNow() {
self.Icons["online"].NewCoord(self.Coords["online"].X, self.Coords["online"].Y) self.Icons["online"].NewCoord(self.Coords["online"].X, self.Coords["online"].Y)
self.Icons["online"].Draw() self.Icons["online"].Draw()
for k, _ := range self.Labels {
if _, ok := self.Coords[k]; ok {
self.Labels[k].NewCoord(self.Coords[k].X, self.Coords[k].Y)
self.Labels[k].Draw()
}
}
for k,_ := range self.Labels{ self.Labels["key_and_pass"].NewCoord(103, self.Coords["key_and_pass"].Y)
if _ ,ok := self.Coords[k]; ok { self.Labels["key_and_pass"].Draw()
self.Labels[k].NewCoord( self.Coords[k].X, self.Coords[k].Y) } else {
self.Labels[k].Draw() self.Icons["bg"].NewCoord(self.Coords["bg"].X, self.Coords["bg"].Y)
} self.Icons["bg"].Draw()
}
self.Labels["key_and_pass"].NewCoord( 103,self.Coords["key_and_pass"].Y) self.Labels["for-usb-eth"].NewCoord(self.Coords["for-usb-eth"].X+55, self.Coords["for-usb-eth"].Y)
self.Labels["key_and_pass"].Draw() self.Labels["for-usb-eth"].Draw()
}else {
self.Icons["bg"].NewCoord(self.Coords["bg"].X, self.Coords["bg"].Y)
self.Icons["bg"].Draw()
self.Labels["for-usb-eth"].NewCoord(self.Coords["for-usb-eth"].X+55, self.Coords["for-usb-eth"].Y) self.Labels["usb-eth-addr"].NewCoord(self.Coords["usb-eth-addr"].X+55, self.Coords["usb-eth-addr"].Y)
self.Labels["for-usb-eth"].Draw() self.Labels["usb-eth-addr"].Draw()
self.Labels["usb-eth-addr"].NewCoord(self.Coords["usb-eth-addr"].X+55, self.Coords["usb-eth-addr"].Y) }
self.Labels["usb-eth-addr"].Draw()
if self.HWND != nil {
surface.Fill(self.HWND, UI.MySkinManager.GiveColor("white"))
} rect_ := rect.Rect(self.PosX, self.PosY, self.Width, self.Height)
surface.Blit(self.HWND, self.CanvasHWND, &rect_, nil)
if self.HWND != nil { }
surface.Fill(self.HWND,UI.MySkinManager.GiveColor("white"))
rect_ := rect.Rect(self.PosX,self.PosY,self.Width,self.Height)
surface.Blit(self.HWND,self.CanvasHWND,&rect_,nil)
}
} }

27
Menu/GameShell/99_PowerOFF/plugin_init.go
View File

@@ -1,14 +1,14 @@
package PowerOFF package PowerOFF
import ( import (
/* /*
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/surface" "github.com/cuu/gogame/surface"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
*/ */
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
//"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS" //"github.com/clockworkpi/LauncherGoDev/sysgo/DBUS"
) )
@@ -16,21 +16,20 @@ import (
/******************************************************************************/ /******************************************************************************/
type PowerOFFPlugin struct { type PowerOFFPlugin struct {
UI.Plugin UI.Plugin
PowerOFFPage *PowerOFFConfirmPage PowerOFFPage *PowerOFFConfirmPage
} }
func (self *PowerOFFPlugin) Init(main_screen *UI.MainScreen) {
func (self *PowerOFFPlugin) Init( main_screen *UI.MainScreen ) {
self.PowerOFFPage = NewPowerOFFConfirmPage() self.PowerOFFPage = NewPowerOFFConfirmPage()
self.PowerOFFPage.SetScreen( main_screen) self.PowerOFFPage.SetScreen(main_screen)
self.PowerOFFPage.SetName("PowerOFF") self.PowerOFFPage.SetName("PowerOFF")
self.PowerOFFPage.Init() self.PowerOFFPage.Init()
} }
func (self *PowerOFFPlugin) Run( main_screen *UI.MainScreen ) { func (self *PowerOFFPlugin) Run(main_screen *UI.MainScreen) {
if main_screen != nil { if main_screen != nil {
main_screen.PushCurPage() main_screen.PushCurPage()
main_screen.SetCurPage(self.PowerOFFPage) main_screen.SetCurPage(self.PowerOFFPage)
main_screen.Draw() main_screen.Draw()
main_screen.SwapAndShow() main_screen.SwapAndShow()
} }

69
Menu/GameShell/99_PowerOFF/poweroff_confirm_page.go
View File

@@ -1,64 +1,61 @@
package PowerOFF package PowerOFF
import ( import (
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
) )
type PowerOFFConfirmPage struct { type PowerOFFConfirmPage struct {
UI.ConfirmPage UI.ConfirmPage
} }
func NewPowerOFFConfirmPage() *PowerOFFConfirmPage { func NewPowerOFFConfirmPage() *PowerOFFConfirmPage {
p := &PowerOFFConfirmPage{} p := &PowerOFFConfirmPage{}
p.ListFont = UI.Fonts["veramono20"] p.ListFont = UI.Fonts["veramono20"]
p.ConfirmText = "Awaiting Input" p.ConfirmText = "Awaiting Input"
p.FootMsg = [5]string{ "Nav","Reboot","","Cancel","Shutdown" } p.FootMsg = [5]string{"Nav", "Reboot", "", "Cancel", "Shutdown"}
p.ConfirmPage.ConfirmText = p.ConfirmText p.ConfirmPage.ConfirmText = p.ConfirmText
p.ConfirmPage.FootMsg = p.FootMsg p.ConfirmPage.FootMsg = p.FootMsg
p.ConfirmPage.ListFont = p.ListFont p.ConfirmPage.ListFont = p.ListFont
return p return p
} }
func (self *PowerOFFConfirmPage) KeyDown(ev *event.Event) { func (self *PowerOFFConfirmPage) KeyDown(ev *event.Event) {
if ev.Data["Key"] == UI.CurKeys["Menu"] || ev.Data["Key"] == UI.CurKeys["A"] { if ev.Data["Key"] == UI.CurKeys["Menu"] || ev.Data["Key"] == UI.CurKeys["A"] {
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["B"] { if ev.Data["Key"] == UI.CurKeys["B"] {
cmdpath := "" cmdpath := ""
if UI.CheckBattery() < 20 { if UI.CheckBattery() < 20 {
cmdpath = "feh --bg-center sysgo/gameshell/wallpaper/gameover.png;" cmdpath = "feh --bg-center sysgo/gameshell/wallpaper/gameover.png;"
}else { } else {
cmdpath = "feh --bg-center sysgo/gameshell/wallpaper/seeyou.png;" cmdpath = "feh --bg-center sysgo/gameshell/wallpaper/seeyou.png;"
} }
cmdpath = cmdpath + "sleep 3;" cmdpath = cmdpath + "sleep 3;"
cmdpath = cmdpath + "sudo halt -p" cmdpath = cmdpath + "sudo halt -p"
event.Post(UI.RUNSYS,cmdpath) event.Post(UI.RUNSYS, cmdpath)
} }
if ev.Data["Key"] == UI.CurKeys["X"] { if ev.Data["Key"] == UI.CurKeys["X"] {
cmdpath := "feh --bg-center sysgo/gameshell/wallpaper/seeyou.png;" cmdpath := "feh --bg-center sysgo/gameshell/wallpaper/seeyou.png;"
cmdpath += "sleep 3;" cmdpath += "sleep 3;"
cmdpath += "sudo reboot" cmdpath += "sudo reboot"
event.Post(UI.RUNSYS,cmdpath) event.Post(UI.RUNSYS, cmdpath)
} }
} }

673
main.go
View File

@@ -1,224 +1,219 @@
package main package main
import ( import (
"os"
"fmt" "fmt"
"log" "io/ioutil"
"io/ioutil" "log"
"strconv" "os"
"strings" "os/exec"
"runtime" "path/filepath"
"path/filepath" "runtime"
"os/exec" "strconv"
"syscall" "strings"
//"encoding/json" "syscall"
gotime "time" //"encoding/json"
"github.com/veandco/go-sdl2/sdl" "github.com/veandco/go-sdl2/sdl"
gotime "time"
//"github.com/go-ini/ini" //"github.com/go-ini/ini"
"github.com/cuu/gogame" "github.com/cuu/gogame"
"github.com/cuu/gogame/display" "github.com/cuu/gogame/display"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
// "github.com/cuu/gogame/color" // "github.com/cuu/gogame/color"
"github.com/cuu/gogame/font" "github.com/cuu/gogame/font"
//"github.com/cuu/gogame/time" //"github.com/cuu/gogame/time"
"github.com/clockworkpi/LauncherGoDev/sysgo" "github.com/clockworkpi/LauncherGoDev/sysgo"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
) )
var ( var (
flash_led1_counter = 0 flash_led1_counter = 0
last_brt = -1 last_brt = -1
passout_time_stage = 0 passout_time_stage = 0
led1_proc_file = "/proc/driver/led1" led1_proc_file = "/proc/driver/led1"
everytime_keydown = gotime.Now() everytime_keydown = gotime.Now()
sound_patch *UI.SoundPatch
sound_patch *UI.SoundPatch
) )
// flash the Led1 on the GS back // flash the Led1 on the GS back
func FlashLed1(main_screen *UI.MainScreen) { func FlashLed1(main_screen *UI.MainScreen) {
for { for {
if UI.FileExists(led1_proc_file) { if UI.FileExists(led1_proc_file) {
if main_screen.Closed == false { if main_screen.Closed == false {
if flash_led1_counter > 0 { if flash_led1_counter > 0 {
d := []byte(fmt.Sprintf("%d",0)) d := []byte(fmt.Sprintf("%d", 0))
err := ioutil.WriteFile(led1_proc_file, d, 0644) // turn off led1 err := ioutil.WriteFile(led1_proc_file, d, 0644) // turn off led1
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
} }
flash_led1_counter = 0 flash_led1_counter = 0
} }
} else { } else {
flash_led1_counter +=1 flash_led1_counter += 1
if flash_led1_counter == 3 { if flash_led1_counter == 3 {
d := []byte(fmt.Sprintf("%d",1)) d := []byte(fmt.Sprintf("%d", 1))
err := ioutil.WriteFile(led1_proc_file, d, 0644) err := ioutil.WriteFile(led1_proc_file, d, 0644)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
} }
} }
if flash_led1_counter == 5 { if flash_led1_counter == 5 {
d := []byte(fmt.Sprintf("%d",0)) d := []byte(fmt.Sprintf("%d", 0))
err := ioutil.WriteFile(led1_proc_file, d, 0644) err := ioutil.WriteFile(led1_proc_file, d, 0644)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
} }
} }
if flash_led1_counter == 11 { if flash_led1_counter == 11 {
flash_led1_counter = 1 flash_led1_counter = 1
} }
} }
} }
gotime.Sleep(200 * gotime.Millisecond) gotime.Sleep(200 * gotime.Millisecond)
} }
} }
//happens everytime when KeyDown occurs //happens everytime when KeyDown occurs
func RestoreLastBackLightBrightness(main_screen *UI.MainScreen) bool { func RestoreLastBackLightBrightness(main_screen *UI.MainScreen) bool {
passout_time_stage = 0 passout_time_stage = 0
main_screen.TitleBar.InLowBackLight = -1 main_screen.TitleBar.InLowBackLight = -1
main_screen.Closed = false main_screen.Closed = false
if last_brt == -1 { if last_brt == -1 {
return true return true
} }
if UI.FileExists(sysgo.BackLight) { if UI.FileExists(sysgo.BackLight) {
lines,err := UI.ReadLines(sysgo.BackLight) lines, err := UI.ReadLines(sysgo.BackLight)
if err == nil { if err == nil {
brt,err2 := strconv.Atoi(strings.Trim(lines[0],"\r\n ")) brt, err2 := strconv.Atoi(strings.Trim(lines[0], "\r\n "))
if err2 == nil { if err2 == nil {
if brt < last_brt { if brt < last_brt {
d := []byte(fmt.Sprintf("%d",last_brt)) d := []byte(fmt.Sprintf("%d", last_brt))
ioutil.WriteFile(sysgo.BackLight,d,0644) ioutil.WriteFile(sysgo.BackLight, d, 0644)
last_brt = -1 last_brt = -1
} }
} }
}else { } else {
fmt.Println(err) fmt.Println(err)
} }
}else { } else {
} }
if UI.FileExists(led1_proc_file) { if UI.FileExists(led1_proc_file) {
d := []byte(fmt.Sprintf("%d",0)) d := []byte(fmt.Sprintf("%d", 0))
err := ioutil.WriteFile(led1_proc_file, d, 0644) err := ioutil.WriteFile(led1_proc_file, d, 0644)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
} }
} }
//Stop CounterScreen here //Stop CounterScreen here
if main_screen.CounterScreen.Counting == true { if main_screen.CounterScreen.Counting == true {
main_screen.CounterScreen.StopCounter() main_screen.CounterScreen.StopCounter()
main_screen.Draw() main_screen.Draw()
main_screen.SwapAndShow() main_screen.SwapAndShow()
return false return false
} }
return true return true
} }
//power stuff dealer //power stuff dealer
func InspectionTeam(main_screen *UI.MainScreen) { func InspectionTeam(main_screen *UI.MainScreen) {
for { for {
cur_time := gotime.Now() cur_time := gotime.Now()
elapsed := cur_time.Sub(everytime_keydown) elapsed := cur_time.Sub(everytime_keydown)
time1 := sysgo.PowerLevels[sysgo.CurPowerLevel].Dim time1 := sysgo.PowerLevels[sysgo.CurPowerLevel].Dim
time2 := sysgo.PowerLevels[sysgo.CurPowerLevel].Close time2 := sysgo.PowerLevels[sysgo.CurPowerLevel].Close
time3 := sysgo.PowerLevels[sysgo.CurPowerLevel].PowerOff time3 := sysgo.PowerLevels[sysgo.CurPowerLevel].PowerOff
if elapsed > gotime.Duration(time1) *gotime.Second && passout_time_stage == 0 { if elapsed > gotime.Duration(time1)*gotime.Second && passout_time_stage == 0 {
fmt.Println("timeout, dim screen ",elapsed) fmt.Println("timeout, dim screen ", elapsed)
if main_screen.TitleBar.InLowBackLight >= 0 { if main_screen.TitleBar.InLowBackLight >= 0 {
everytime_keydown = cur_time everytime_keydown = cur_time
continue continue
} }
if UI.FileExists(sysgo.BackLight) { if UI.FileExists(sysgo.BackLight) {
lines,err := UI.ReadLines(sysgo.BackLight) lines, err := UI.ReadLines(sysgo.BackLight)
if err == nil { if err == nil {
brt,err2 := strconv.Atoi(strings.Trim(lines[0],"\r\n ")) brt, err2 := strconv.Atoi(strings.Trim(lines[0], "\r\n "))
if err2 == nil { if err2 == nil {
if brt > 0 { if brt > 0 {
if last_brt < 0 { if last_brt < 0 {
last_brt = brt last_brt = brt
} }
d := []byte(fmt.Sprintf("%d",1)) // lowest backlight d := []byte(fmt.Sprintf("%d", 1)) // lowest backlight
ioutil.WriteFile(sysgo.BackLight,d,0644) ioutil.WriteFile(sysgo.BackLight, d, 0644)
} }
} }
} }
main_screen.TitleBar.InLowBackLight = 0
if time2 != 0 {
passout_time_stage = 1 // next
}
}
everytime_keydown = cur_time
} else if elapsed > gotime.Duration(time2)*gotime.Second && passout_time_stage == 1 {
fmt.Println("timeout, close screen ", elapsed)
main_screen.TitleBar.InLowBackLight = 0 if main_screen.Closed == true {
if time2 != 0 { everytime_keydown = cur_time
passout_time_stage = 1 // next continue
} }
} if UI.FileExists(sysgo.BackLight) {
everytime_keydown = cur_time d := []byte(fmt.Sprintf("%d", 0))
}else if elapsed > gotime.Duration(time2) *gotime.Second && passout_time_stage == 1 { ioutil.WriteFile(sysgo.BackLight, d, 0644)
fmt.Println("timeout, close screen ", elapsed) }
if main_screen.Closed == true { main_screen.TitleBar.InLowBackLight = 0
everytime_keydown = cur_time main_screen.Closed = true
continue if time3 != 0 {
} passout_time_stage = 2 // next
if UI.FileExists(sysgo.BackLight) { }
d := []byte(fmt.Sprintf("%d",0))
ioutil.WriteFile(sysgo.BackLight,d,0644)
}
main_screen.TitleBar.InLowBackLight = 0 everytime_keydown = cur_time
main_screen.Closed = true } else if elapsed > gotime.Duration(time3)*gotime.Second && passout_time_stage == 2 {
if time3 != 0 {
passout_time_stage = 2 // next
}
everytime_keydown = cur_time fmt.Println("Power Off counting down")
}else if elapsed > gotime.Duration(time3) * gotime.Second && passout_time_stage == 2{
fmt.Println("Power Off counting down") if UI.FileExists(sysgo.BackLight) { //hdmi does not have BackLight dev node
d := []byte(fmt.Sprintf("%d", last_brt))
ioutil.WriteFile(sysgo.BackLight, d, 0644)
if UI.FileExists(sysgo.BackLight) { //hdmi does not have BackLight dev node main_screen.CounterScreen.Draw()
d := []byte(fmt.Sprintf("%d",last_brt)) main_screen.CounterScreen.SwapAndShow()
ioutil.WriteFile(sysgo.BackLight,d,0644) main_screen.CounterScreen.StartCounter()
main_screen.CounterScreen.Draw() }
main_screen.CounterScreen.SwapAndShow()
main_screen.CounterScreen.StartCounter()
} main_screen.TitleBar.InLowBackLight = 0
main_screen.TitleBar.InLowBackLight = 0 passout_time_stage = 4
passout_time_stage = 4 }
} gotime.Sleep(gotime.Duration(UI.DT) * gotime.Millisecond)
}
gotime.Sleep(gotime.Duration(UI.DT) * gotime.Millisecond)
}
} }
//If not under awesomeWM, AutoRedraw improves the experience of gsnotify //If not under awesomeWM, AutoRedraw improves the experience of gsnotify
@@ -226,84 +221,84 @@ func InspectionTeam(main_screen *UI.MainScreen) {
func AutoRedraw(main_screen *UI.MainScreen) { func AutoRedraw(main_screen *UI.MainScreen) {
for { for {
if main_screen.TitleBar.InLowBackLight < 0 { if main_screen.TitleBar.InLowBackLight < 0 {
UI.SwapAndShow() UI.SwapAndShow()
} }
gotime.Sleep(650 * gotime.Millisecond) gotime.Sleep(650 * gotime.Millisecond)
} }
} }
func PreparationInAdv(){ func PreparationInAdv() {
if strings.Contains(runtime.GOARCH,"arm") == false { if strings.Contains(runtime.GOARCH, "arm") == false {
return return
} }
if UI.FileExists("sysgo/.powerlevel") == false { if UI.FileExists("sysgo/.powerlevel") == false {
UI.System("touch sysgo/.powerlevel") UI.System("touch sysgo/.powerlevel")
UI.System(fmt.Sprintf("sudo iw %s set power_save off >/dev/null",sysgo.WifiDev)) UI.System(fmt.Sprintf("sudo iw %s set power_save off >/dev/null", sysgo.WifiDev))
}else{ } else {
b, err := ioutil.ReadFile("sysgo/.powerlevel") b, err := ioutil.ReadFile("sysgo/.powerlevel")
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
} }
pwl := strings.Trim(string(b),"\r\n ") pwl := strings.Trim(string(b), "\r\n ")
if pwl != ""{ if pwl != "" {
sysgo.CurPowerLevel = pwl sysgo.CurPowerLevel = pwl
if pwl == "supersaving" { if pwl == "supersaving" {
UI.System(fmt.Sprintf("sudo iw %s set power_save on >/dev/null",sysgo.WifiDev)) UI.System(fmt.Sprintf("sudo iw %s set power_save on >/dev/null", sysgo.WifiDev))
}else{ } else {
UI.System(fmt.Sprintf("sudo iw %s set power_save off >/dev/null",sysgo.WifiDev)) UI.System(fmt.Sprintf("sudo iw %s set power_save off >/dev/null", sysgo.WifiDev))
} }
}else { } else {
UI.System(fmt.Sprintf("sudo iw %s set power_save off >/dev/null",sysgo.WifiDev)) UI.System(fmt.Sprintf("sudo iw %s set power_save off >/dev/null", sysgo.WifiDev))
} }
} }
} }
func release_self_fds() { func release_self_fds() {
fds_flags := []string{"pipe","socket:",".ttf"} fds_flags := []string{"pipe", "socket:", ".ttf"}
file_paths,err := filepath.Glob("/proc/self/fd/*") file_paths, err := filepath.Glob("/proc/self/fd/*")
if err != nil { if err != nil {
fmt.Println("release_self_fds error",err) fmt.Println("release_self_fds error", err)
return return
} }
ret := make(map[string]string) ret := make(map[string]string)
path := "" path := ""
for _,v := range file_paths { for _, v := range file_paths {
path,err = os.Readlink(v) path, err = os.Readlink(v)
if err == nil { if err == nil {
ret[v] = path ret[v] = path
} }
} }
for k,v := range ret { for k, v := range ret {
for _,f := range fds_flags { for _, f := range fds_flags {
if strings.Contains(v,f) { if strings.Contains(v, f) {
id,_ := strconv.Atoi(filepath.Base(k)) id, _ := strconv.Atoi(filepath.Base(k))
//fmt.Println("closing ",id) //fmt.Println("closing ",id)
err = syscall.Close(id) err = syscall.Close(id)
if err != nil { if err != nil {
fmt.Println("syscall.CLose err ",err) fmt.Println("syscall.CLose err ", err)
} }
} }
} }
} }
} }
func run() int { func run() int {
display.Init() display.Init()
font.Init() font.Init()
screen := display.SetMode(int32(UI.Width),int32(UI.Height),0,32) screen := display.SetMode(int32(UI.Width), int32(UI.Height), 0, 32)
UI.Init() UI.Init()
PreparationInAdv() PreparationInAdv()
main_screen := UI.NewMainScreen() main_screen := UI.NewMainScreen()
main_screen.HWND = screen main_screen.HWND = screen
@@ -316,17 +311,17 @@ func run() int {
foot_bar.Init(main_screen) foot_bar.Init(main_screen)
main_screen.TitleBar = title_bar main_screen.TitleBar = title_bar
main_screen.FootBar = foot_bar main_screen.FootBar = foot_bar
ReadTheDirIntoPages(main_screen,"Menu",0,nil) ReadTheDirIntoPages(main_screen, "Menu", 0, nil)
ReadTheDirIntoPages(main_screen,"/home/cpi/apps/Menu",1,main_screen.Pages[len(main_screen.Pages)-1]) ReadTheDirIntoPages(main_screen, "/home/cpi/apps/Menu", 1, main_screen.Pages[len(main_screen.Pages)-1])
ReunionPagesIcons(main_screen) ReunionPagesIcons(main_screen)
main_screen.FartherPages() main_screen.FartherPages()
sound_patch = UI.NewSoundPatch() sound_patch = UI.NewSoundPatch()
sound_patch.Parent = main_screen sound_patch.Parent = main_screen
sound_patch.Init() sound_patch.Init()
main_screen.Draw() main_screen.Draw()
main_screen.SwapAndShow() main_screen.SwapAndShow()
@@ -334,160 +329,156 @@ func run() int {
UI.SwapAndShow() UI.SwapAndShow()
//fmt.Println(main_screen) //fmt.Println(main_screen)
event.AllocEvents(5) event.AllocEvents(5)
event.AddCustomEvent(UI.RUNEVT) event.AddCustomEvent(UI.RUNEVT)
event.AddCustomEvent(UI.RUNSH) event.AddCustomEvent(UI.RUNSH)
event.AddCustomEvent(UI.RUNSYS) event.AddCustomEvent(UI.RUNSYS)
event.AddCustomEvent(UI.RESTARTUI) event.AddCustomEvent(UI.RESTARTUI)
event.AddCustomEvent(UI.POWEROPT) event.AddCustomEvent(UI.POWEROPT)
go FlashLed1(main_screen) go FlashLed1(main_screen)
go InspectionTeam(main_screen) go InspectionTeam(main_screen)
go main_screen.TitleBar.RoundRobinCheck() go main_screen.TitleBar.RoundRobinCheck()
//go AutoRedraw(main_screen) //go AutoRedraw(main_screen)
running := true running := true
for running { for running {
ev := event.Poll() ev := event.Wait()
if ev.Type == event.QUIT { if ev.Type == event.QUIT {
running = false running = false
break break
} }
if ev.Type == event.USEREVENT { if ev.Type == event.USEREVENT {
fmt.Println("UserEvent: ", ev.Data["Msg"])
fmt.Println("UserEvent: ",ev.Data["Msg"]) switch ev.Code {
case UI.RUNEVT:
main_screen.OnExitCb()
gogame.Quit()
switch ev.Code { fmt.Println("RUNEVT")
case UI.RUNEVT:
main_screen.OnExitCb()
gogame.Quit()
fmt.Println("RUNEVT") endpos := len(ev.Data["Msg"])
space_break_pos := endpos
for i := 0; i < endpos; i++ {
if i > 6 && string(ev.Data["Msg"][i]) == "/" && string(ev.Data["Msg"][i-1]) == " " {
space_break_pos = i - 1
break
}
}
endpos := len(ev.Data["Msg"]) exec_app_cmd := "cd " + filepath.Dir(ev.Data["Msg"][:space_break_pos]) + ";"
space_break_pos := endpos exec_app_cmd += ev.Data["Msg"]
for i:=0;i<endpos;i++ { exec_app_cmd += "; sync & cd " + UI.GetExePath() + "; " + os.Args[0] + ";"
if i > 6 && string(ev.Data["Msg"][i]) == "/" && string(ev.Data["Msg"][i-1]) == " " { fmt.Println(exec_app_cmd)
space_break_pos = i-1 release_self_fds()
break cmd := exec.Command("/bin/sh", "-c", exec_app_cmd)
} err := cmd.Start()
} if err != nil {
fmt.Println(err)
}
err = cmd.Process.Release()
if err != nil {
fmt.Println(err)
}
os.Exit(0)
exec_app_cmd := "cd " + filepath.Dir( ev.Data["Msg"][:space_break_pos] )+";" case UI.RUNSYS:
exec_app_cmd += ev.Data["Msg"] main_screen.OnExitCb()
exec_app_cmd +="; sync & cd "+UI.GetExePath()+"; "+os.Args[0]+";" gogame.Quit()
fmt.Println(exec_app_cmd) release_self_fds()
release_self_fds() exec_app_cmd := ev.Data["Msg"]
cmd := exec.Command("/bin/sh","-c",exec_app_cmd) cmd := exec.Command("/bin/sh", "-c", exec_app_cmd)
err := cmd.Start() err := cmd.Start()
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
} }
err = cmd.Process.Release() err = cmd.Process.Release()
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
} }
os.Exit(0) os.Exit(0)
case UI.RUNSYS: case UI.RUNSH:
main_screen.OnExitCb() main_screen.OnExitCb()
gogame.Quit() gogame.Quit()
release_self_fds()
exec_app_cmd := ev.Data["Msg"]
cmd := exec.Command("/bin/sh","-c",exec_app_cmd)
err := cmd.Start()
if err != nil {
fmt.Println(err)
}
err = cmd.Process.Release()
if err != nil {
fmt.Println(err)
}
os.Exit(0)
case UI.RUNSH: fmt.Println("RUNSH")
main_screen.OnExitCb() exec_app_cmd := ev.Data["Msg"] + ";"
gogame.Quit() fmt.Println(exec_app_cmd)
release_self_fds()
cmd := exec.Command("/bin/sh", "-c", exec_app_cmd)
err := cmd.Start()
if err != nil {
fmt.Println(err)
}
err = cmd.Process.Release()
if err != nil {
fmt.Println(err)
}
os.Exit(0)
fmt.Println("RUNSH") case UI.RESTARTUI:
exec_app_cmd := ev.Data["Msg"]+";" main_screen.OnExitCb()
fmt.Println(exec_app_cmd) gogame.Quit()
release_self_fds() exec_app_cmd := " sync & cd " + UI.GetExePath() + "; " + os.Args[0] + ";"
cmd := exec.Command("/bin/sh","-c",exec_app_cmd) fmt.Println(exec_app_cmd)
err := cmd.Start() release_self_fds()
if err != nil { cmd := exec.Command("/bin/sh", "-c", exec_app_cmd)
fmt.Println(err) err := cmd.Start()
} if err != nil {
err = cmd.Process.Release() fmt.Println(err)
if err != nil { }
fmt.Println(err) err = cmd.Process.Release()
} if err != nil {
os.Exit(0) fmt.Println(err)
}
os.Exit(0)
case UI.RESTARTUI: case UI.POWEROPT:
main_screen.OnExitCb() everytime_keydown = gotime.Now()
gogame.Quit()
exec_app_cmd :=" sync & cd "+UI.GetExePath()+"; "+os.Args[0]+";"
fmt.Println(exec_app_cmd)
release_self_fds()
cmd := exec.Command("/bin/sh","-c",exec_app_cmd)
err := cmd.Start()
if err != nil {
fmt.Println(err)
}
err = cmd.Process.Release()
if err != nil {
fmt.Println(err)
}
os.Exit(0)
case UI.POWEROPT:
everytime_keydown = gotime.Now()
}
}
} }
if ev.Type == event.KEYDOWN { if ev.Type == event.KEYDOWN {
everytime_keydown = gotime.Now() everytime_keydown = gotime.Now()
if RestoreLastBackLightBrightness(main_screen) == false { if RestoreLastBackLightBrightness(main_screen) == false {
continue continue
} }
if ev.Data["Key"] == "Q" { if ev.Data["Key"] == "Q" {
main_screen.OnExitCb() main_screen.OnExitCb()
return 0 return 0
} }
if ev.Data["Key"] == "Keypad +" {
if main_screen.CurPage().GetName() != "Sound volume" {
main_screen.Draw()
sound_patch.VolumeUp()
sound_patch.Draw()
main_screen.SwapAndShow()
}
continue
}
if ev.Data["Key"] == "Keypad +" { if ev.Data["Key"] == "Keypad -" {
if main_screen.CurPage().GetName() != "Sound volume" { if main_screen.CurPage().GetName() != "Sound volume" {
main_screen.Draw() main_screen.Draw()
sound_patch.VolumeUp() sound_patch.VolumeDown()
sound_patch.Draw() sound_patch.Draw()
main_screen.SwapAndShow() main_screen.SwapAndShow()
}
continue
}
if ev.Data["Key"] == "Keypad -" { }
if main_screen.CurPage().GetName() != "Sound volume" { continue
main_screen.Draw() }
sound_patch.VolumeDown()
sound_patch.Draw()
main_screen.SwapAndShow()
}
continue
}
main_screen.KeyDown(ev) main_screen.KeyDown(ev)
main_screen.LastKeyDown = everytime_keydown main_screen.LastKeyDown = everytime_keydown
} }
gotime.Sleep(50*gotime.Millisecond) gotime.Sleep(50 * gotime.Millisecond)
} }
return 0 return 0
@@ -498,9 +489,9 @@ func main() {
var exitcode int var exitcode int
defer sdl.Quit() defer sdl.Quit()
//runtime.GOMAXPROCS(1) //runtime.GOMAXPROCS(1)
os.Setenv("SDL_VIDEO_CENTERED","1") os.Setenv("SDL_VIDEO_CENTERED", "1")
exitcode = run() exitcode = run()

343
mainscreen.go
View File

@@ -1,154 +1,153 @@
package main package main
import ( import (
//"os" //"os"
"fmt" "fmt"
"log" "io/ioutil"
"io/ioutil" "log"
// "strconv" // "strconv"
"strings" "strings"
// "runtime" // "runtime"
"path/filepath" "path/filepath"
//os/exec" //os/exec"
"encoding/json" "encoding/json"
"sort" "sort"
"github.com/go-ini/ini" "github.com/go-ini/ini"
"github.com/yookoala/realpath" "github.com/yookoala/realpath"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI" "github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI/Emulator" "github.com/clockworkpi/LauncherGoDev/Menu/GameShell/98_TinyCloud"
"github.com/clockworkpi/LauncherGoDev/Menu/GameShell/10_Settings" "github.com/clockworkpi/LauncherGoDev/Menu/GameShell/99_PowerOFF"
"github.com/clockworkpi/LauncherGoDev/Menu/GameShell/98_TinyCloud" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
"github.com/clockworkpi/LauncherGoDev/Menu/GameShell/99_PowerOFF" "github.com/clockworkpi/LauncherGoDev/sysgo/UI/Emulator"
) )
var ( var (
UIPluginList = []*UI.UIPlugin { UIPluginList = []*UI.UIPlugin{
&UI.UIPlugin{1,"", "Menu/GameShell/10_Settings", "Settings", &Settings.APIOBJ}, &UI.UIPlugin{1, "", "Menu/GameShell/10_Settings", "Settings", &Settings.APIOBJ},
&UI.UIPlugin{1,"", "Menu/GameShell/98_TinyCloud", "TinyCloud", &TinyCloud.APIOBJ}, &UI.UIPlugin{1, "", "Menu/GameShell/98_TinyCloud", "TinyCloud", &TinyCloud.APIOBJ},
&UI.UIPlugin{1,"", "Menu/GameShell/99_PowerOFF", "PowerOFF", &PowerOFF.APIOBJ}, &UI.UIPlugin{1, "", "Menu/GameShell/99_PowerOFF", "PowerOFF", &PowerOFF.APIOBJ},
} }
) )
func ReunionPagesIcons(self *UI.MainScreen) { func ReunionPagesIcons(self *UI.MainScreen) {
type Tup struct { type Tup struct {
FileName string FileName string
OrigIdx int OrigIdx int
} }
var tmp []Tup var tmp []Tup
for i,p := range self.Pages { for i, p := range self.Pages {
p_icons := p.GetIcons() p_icons := p.GetIcons()
for i,x := range p_icons { for i, x := range p_icons {
var t Tup var t Tup
if x.GetFileName() != ""{ if x.GetFileName() != "" {
if strings.Contains(x.GetFileName(),"_") == false { if strings.Contains(x.GetFileName(), "_") == false {
t = Tup{"98_"+x.GetFileName(),i} t = Tup{"98_" + x.GetFileName(), i}
}else { } else {
t = Tup{x.GetFileName(),i} t = Tup{x.GetFileName(), i}
} }
}else{ } else {
t = Tup{"",i} t = Tup{"", i}
} }
tmp = append(tmp,t) tmp = append(tmp, t)
} }
sort.Slice(tmp, func(i, j int) bool { return tmp[i].FileName < tmp[j].FileName }) sort.Slice(tmp, func(i, j int) bool { return tmp[i].FileName < tmp[j].FileName })
//fmt.Println(tmp) //fmt.Println(tmp)
var retro_games_idx []int var retro_games_idx []int
retro_games_dir := "20_Retro Games" retro_games_dir := "20_Retro Games"
for _,x := range tmp { for _, x := range tmp {
if strings.HasPrefix(x.FileName, retro_games_dir) { if strings.HasPrefix(x.FileName, retro_games_dir) {
retro_games_idx = append(retro_games_idx,x.OrigIdx) retro_games_idx = append(retro_games_idx, x.OrigIdx)
} }
} }
if len(retro_games_idx) > 1 { if len(retro_games_idx) > 1 {
p_icons_0_link_page := p_icons[retro_games_idx[0]].GetLinkPage().(*UI.Page) p_icons_0_link_page := p_icons[retro_games_idx[0]].GetLinkPage().(*UI.Page)
for i:=1;i<len(retro_games_idx);i++ { for i := 1; i < len(retro_games_idx); i++ {
icons_other_page := p_icons[retro_games_idx[i]].GetLinkPage().GetIcons() icons_other_page := p_icons[retro_games_idx[i]].GetLinkPage().GetIcons()
p_icons_0_link_page.Icons = append(p_icons_0_link_page.Icons, icons_other_page...) p_icons_0_link_page.Icons = append(p_icons_0_link_page.Icons, icons_other_page...)
} }
var tmpswap []Tup var tmpswap []Tup
onlyone := false onlyone := false
for _,x := range tmp { for _, x := range tmp {
if strings.HasPrefix(x.FileName,retro_games_dir) == false{ if strings.HasPrefix(x.FileName, retro_games_dir) == false {
tmpswap = append(tmpswap,x) tmpswap = append(tmpswap, x)
} }
if strings.HasPrefix(x.FileName,retro_games_dir) == true && onlyone == false { if strings.HasPrefix(x.FileName, retro_games_dir) == true && onlyone == false {
tmpswap = append(tmpswap,x) tmpswap = append(tmpswap, x)
onlyone = true onlyone = true
} }
} }
tmp = tmpswap tmp = tmpswap
} }
var new_icons []UI.IconItemInterface var new_icons []UI.IconItemInterface
for _,x := range tmp { for _, x := range tmp {
new_icons = append(new_icons, p_icons[x.OrigIdx]) new_icons = append(new_icons, p_icons[x.OrigIdx])
} }
self.Pages[i].(*UI.Page).Icons = new_icons self.Pages[i].(*UI.Page).Icons = new_icons
} }
} }
func ReadTheDirIntoPages(self *UI.MainScreen, _dir string, pglevel int, cur_page UI.PageInterface) { func ReadTheDirIntoPages(self *UI.MainScreen, _dir string, pglevel int, cur_page UI.PageInterface) {
if UI.FileExists(_dir) == false && UI.IsDirectory(_dir) == false { if UI.FileExists(_dir) == false && UI.IsDirectory(_dir) == false {
return return
} }
files,err := ioutil.ReadDir(_dir) files, err := ioutil.ReadDir(_dir)
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
return return
} }
for _,f := range files { // already sorted for _, f := range files { // already sorted
if UI.IsDirectory( _dir +"/"+f.Name()) && strings.HasPrefix( f.Name(), ".") == false { if UI.IsDirectory(_dir+"/"+f.Name()) && strings.HasPrefix(f.Name(), ".") == false {
if pglevel == 0 { if pglevel == 0 {
page := UI.NewPage() page := UI.NewPage()
page.Name = self.ExtraName(f.Name()) page.Name = self.ExtraName(f.Name())
self.Pages = append(self.Pages, page) self.Pages = append(self.Pages, page)
ReadTheDirIntoPages(self,_dir+"/"+f.Name(),pglevel+1, self.Pages[ len(self.Pages) - 1] ) ReadTheDirIntoPages(self, _dir+"/"+f.Name(), pglevel+1, self.Pages[len(self.Pages)-1])
}else{ // on cur_page now } else { // on cur_page now
i2:= self.ExtraName(f.Name()) i2 := self.ExtraName(f.Name())
iconitem := UI.NewIconItem() iconitem := UI.NewIconItem()
iconitem.FileName = f.Name() iconitem.FileName = f.Name()
iconitem.AddLabel(i2,self.IconFont) iconitem.AddLabel(i2, self.IconFont)
if UI.FileExists(filepath.Join(_dir,f.Name(),i2+".png")) { //eg: 20_Prog/Prog.png , cut 20_ if UI.FileExists(filepath.Join(_dir, f.Name(), i2+".png")) { //eg: 20_Prog/Prog.png , cut 20_
iconitem.ImageName = filepath.Join(_dir,f.Name(),i2+".png") iconitem.ImageName = filepath.Join(_dir, f.Name(), i2+".png")
}else if UI.FileExists( UI.SkinMap(_dir+"/"+i2+".png")) { } else if UI.FileExists(UI.SkinMap(_dir + "/" + i2 + ".png")) {
iconitem.ImageName = UI.SkinMap(_dir+"/"+i2+".png") iconitem.ImageName = UI.SkinMap(_dir + "/" + i2 + ".png")
}else { } else {
//fmt.Println( UI.SkinMap(_dir+"/"+i2+".png") ) //fmt.Println( UI.SkinMap(_dir+"/"+i2+".png") )
untitled := UI.NewUntitledIcon() untitled := UI.NewUntitledIcon()
untitled.Init() untitled.Init()
if len(i2) > 1 { if len(i2) > 1 {
untitled.SetWords(string(i2[0]),string(i2[1])) untitled.SetWords(string(i2[0]), string(i2[1]))
}else if len(i2) == 1 { } else if len(i2) == 1 {
untitled.SetWords(string(i2[0]),string(i2[0])) untitled.SetWords(string(i2[0]), string(i2[0]))
}else { } else {
untitled.SetWords("G","s") untitled.SetWords("G", "s")
} }
iconitem.ImgSurf = untitled.Surface() iconitem.ImgSurf = untitled.Surface()
iconitem.ImageName = "" iconitem.ImageName = ""
} }
if self.IsPluginPackage(_dir+"/"+f.Name()) { if self.IsPluginPackage(_dir + "/" + f.Name()) {
p_c := UI.PluginConfig{} p_c := UI.PluginConfig{}
dat, err := ioutil.ReadFile(_dir+"/"+f.Name()+"/" +UI.Plugin_flag) dat, err := ioutil.ReadFile(_dir + "/" + f.Name() + "/" + UI.Plugin_flag)
UI.ShowErr(err) UI.ShowErr(err)
err = json.Unmarshal(dat, &p_c) err = json.Unmarshal(dat, &p_c)
@@ -157,113 +156,113 @@ func ReadTheDirIntoPages(self *UI.MainScreen, _dir string, pglevel int, cur_page
p_c.NAME = f.Name() p_c.NAME = f.Name()
} }
so_file := filepath.Join(_dir,f.Name(),p_c.SO_FILE) so_file := filepath.Join(_dir, f.Name(), p_c.SO_FILE)
if UI.FileExists(so_file) && UI.IsAFile(so_file) { if UI.FileExists(so_file) && UI.IsAFile(so_file) {
pi,err := UI.LoadPlugin(_dir+"/"+f.Name()+"/"+p_c.SO_FILE) pi, err := UI.LoadPlugin(_dir + "/" + f.Name() + "/" + p_c.SO_FILE)
UI.Assert(err) UI.Assert(err)
iconitem.CmdInvoke = UI.InitPlugin(pi,self) iconitem.CmdInvoke = UI.InitPlugin(pi, self)
if iconitem.CmdInvoke != nil { if iconitem.CmdInvoke != nil {
iconitem.MyType = UI.ICON_TYPES["FUNC"] iconitem.MyType = UI.ICON_TYPES["FUNC"]
iconitem.CmdPath = f.Name() iconitem.CmdPath = f.Name()
cur_page.AppendIcon(iconitem) cur_page.AppendIcon(iconitem)
} }
} else { } else {
for _,v := range UIPluginList { for _, v := range UIPluginList {
if v.LabelText == p_c.NAME { if v.LabelText == p_c.NAME {
v.EmbInterface.Init(self) v.EmbInterface.Init(self)
iconitem.CmdInvoke = v.EmbInterface iconitem.CmdInvoke = v.EmbInterface
if iconitem.CmdInvoke != nil { if iconitem.CmdInvoke != nil {
iconitem.MyType = UI.ICON_TYPES["FUNC"] iconitem.MyType = UI.ICON_TYPES["FUNC"]
iconitem.CmdPath = f.Name() iconitem.CmdPath = f.Name()
cur_page.AppendIcon(iconitem) cur_page.AppendIcon(iconitem)
} }
} }
} }
} }
} }
//Init it //Init it
}else if self.IsEmulatorPackage(_dir+"/"+f.Name()) { } else if self.IsEmulatorPackage(_dir + "/" + f.Name()) {
a_c := Emulator.ActionConfig{} a_c := Emulator.ActionConfig{}
a_c.FILETYPE="file" a_c.FILETYPE = "file"
a_c.TITLE = "Game" a_c.TITLE = "Game"
cfg, err := ini.Load(_dir+"/"+f.Name()+"/" +UI.Emulator_flag) cfg, err := ini.Load(_dir + "/" + f.Name() + "/" + UI.Emulator_flag)
UI.ShowErr(err) UI.ShowErr(err)
err = cfg.MapTo(&a_c) err = cfg.MapTo(&a_c)
if err == nil { if err == nil {
//fmt.Println(a_c) //fmt.Println(a_c)
if UI.FileExists(filepath.Join(_dir,f.Name(),"retroarch-local.cfg")) { if UI.FileExists(filepath.Join(_dir, f.Name(), "retroarch-local.cfg")) {
a_c.RETRO_CONFIG = UI.CmdClean( filepath.Join(_dir,f.Name(),"retroarch-local.cfg") ) a_c.RETRO_CONFIG = UI.CmdClean(filepath.Join(_dir, f.Name(), "retroarch-local.cfg"))
fmt.Println("a local retroarch cfg: ",a_c.RETRO_CONFIG) fmt.Println("a local retroarch cfg: ", a_c.RETRO_CONFIG)
} }
em := Emulator.NewMyEmulator() em := Emulator.NewMyEmulator()
em.EmulatorConfig = &a_c em.EmulatorConfig = &a_c
em.Init(self) em.Init(self)
iconitem.CmdInvoke = em iconitem.CmdInvoke = em
if iconitem.CmdInvoke != nil { if iconitem.CmdInvoke != nil {
iconitem.MyType = UI.ICON_TYPES["Emulator"] iconitem.MyType = UI.ICON_TYPES["Emulator"]
iconitem.CmdPath = f.Name() iconitem.CmdPath = f.Name()
cur_page.AppendIcon(iconitem) cur_page.AppendIcon(iconitem)
} }
}else { } else {
fmt.Println("ReadTheDirIntoPages EmulatorConfig ",err) fmt.Println("ReadTheDirIntoPages EmulatorConfig ", err)
} }
}else if self.IsExecPackage(_dir+"/"+f.Name()) { } else if self.IsExecPackage(_dir + "/" + f.Name()) {
iconitem.MyType = UI.ICON_TYPES["EXE"] iconitem.MyType = UI.ICON_TYPES["EXE"]
rel_path,err := realpath.Realpath( filepath.Join(_dir,f.Name(),i2+".sh")) rel_path, err := realpath.Realpath(filepath.Join(_dir, f.Name(), i2+".sh"))
if err != nil { if err != nil {
rel_path,_ = filepath.Abs(filepath.Join(_dir,f.Name(),i2+".sh")) rel_path, _ = filepath.Abs(filepath.Join(_dir, f.Name(), i2+".sh"))
} }
iconitem.CmdPath = rel_path iconitem.CmdPath = rel_path
UI.MakeExecutable( iconitem.CmdPath ) UI.MakeExecutable(iconitem.CmdPath)
cur_page.AppendIcon(iconitem) cur_page.AppendIcon(iconitem)
}else { } else {
iconitem.MyType = UI.ICON_TYPES["DIR"] iconitem.MyType = UI.ICON_TYPES["DIR"]
linkpage := UI.NewPage() linkpage := UI.NewPage()
linkpage.Name = i2 linkpage.Name = i2
iconitem.LinkPage = linkpage iconitem.LinkPage = linkpage
cur_page.AppendIcon(iconitem) cur_page.AppendIcon(iconitem)
ReadTheDirIntoPages(self,_dir+"/"+f.Name(),pglevel+1, iconitem.LinkPage) ReadTheDirIntoPages(self, _dir+"/"+f.Name(), pglevel+1, iconitem.LinkPage)
} }
} }
} else if UI.IsAFile(_dir+"/"+f.Name()) && strings.HasPrefix( f.Name(), ".") == false && (pglevel > 0) { } else if UI.IsAFile(_dir+"/"+f.Name()) && strings.HasPrefix(f.Name(), ".") == false && (pglevel > 0) {
if strings.HasSuffix(strings.ToLower(f.Name()),UI.IconExt) { if strings.HasSuffix(strings.ToLower(f.Name()), UI.IconExt) {
i2 := self.ExtraName(f.Name()) i2 := self.ExtraName(f.Name())
iconitem := UI.NewIconItem() iconitem := UI.NewIconItem()
rel_path,err := realpath.Realpath( _dir+"/"+f.Name() ) rel_path, err := realpath.Realpath(_dir + "/" + f.Name())
if err != nil { if err != nil {
rel_path,_ = filepath.Abs(_dir+"/"+f.Name()) rel_path, _ = filepath.Abs(_dir + "/" + f.Name())
} }
iconitem.CmdPath = rel_path iconitem.CmdPath = rel_path
iconitem.FileName = f.Name() iconitem.FileName = f.Name()
UI.MakeExecutable( iconitem.CmdPath ) UI.MakeExecutable(iconitem.CmdPath)
iconitem.MyType = UI.ICON_TYPES["EXE"] iconitem.MyType = UI.ICON_TYPES["EXE"]
if UI.FileExists( UI.SkinMap( _dir+"/"+ UI.ReplaceSuffix(i2,"png"))) { if UI.FileExists(UI.SkinMap(_dir + "/" + UI.ReplaceSuffix(i2, "png"))) {
iconitem.ImageName = UI.SkinMap( _dir+"/"+ UI.ReplaceSuffix(i2,"png")) iconitem.ImageName = UI.SkinMap(_dir + "/" + UI.ReplaceSuffix(i2, "png"))
}else { } else {
untitled:= UI.NewUntitledIcon() untitled := UI.NewUntitledIcon()
untitled.Init() untitled.Init()
if len(i2) > 1 { if len(i2) > 1 {
untitled.SetWords(string(i2[0]),string(i2[1])) untitled.SetWords(string(i2[0]), string(i2[1]))
}else if len(i2) == 1 { } else if len(i2) == 1 {
untitled.SetWords(string(i2[0]),string(i2[0])) untitled.SetWords(string(i2[0]), string(i2[0]))
}else { } else {
untitled.SetWords("G","s") untitled.SetWords("G", "s")
} }
iconitem.ImgSurf = untitled.Surface() iconitem.ImgSurf = untitled.Surface()
iconitem.ImageName = "" iconitem.ImageName = ""
} }
iconitem.AddLabel(strings.Split(i2,".")[0], self.IconFont) iconitem.AddLabel(strings.Split(i2, ".")[0], self.IconFont)
iconitem.LinkPage = nil iconitem.LinkPage = nil
cur_page.AppendIcon(iconitem) cur_page.AppendIcon(iconitem)
} }

167
sysgo/DBUS/dbus.go
View File

@@ -2,22 +2,22 @@ package DBUS
import ( import (
"fmt" "fmt"
"strings" "strings"
//"strconv" //"strconv"
"github.com/godbus/dbus" "github.com/godbus/dbus"
) )
type DbusInterface struct { type DbusInterface struct {
Dest string Dest string
Path dbus.ObjectPath Path dbus.ObjectPath
Iface string Iface string
Obj *dbus.Object Obj *dbus.Object
SigFuncs map[string]interface{} SigFuncs map[string]interface{}
} }
func NewDbusInterface(conn *dbus.Conn,dest string, path dbus.ObjectPath ,iface string) *DbusInterface { func NewDbusInterface(conn *dbus.Conn, dest string, path dbus.ObjectPath, iface string) *DbusInterface {
m := &DbusInterface{} m := &DbusInterface{}
o := conn.Object(dest,path) o := conn.Object(dest, path)
m.Obj = o.(*dbus.Object) m.Obj = o.(*dbus.Object)
m.Dest = dest m.Dest = dest
@@ -31,53 +31,52 @@ func NewDbusInterface(conn *dbus.Conn,dest string, path dbus.ObjectPath ,iface s
return m return m
} }
func (self *DbusInterface) Method(name string, args...interface{} ) *dbus.Call { func (self *DbusInterface) Method(name string, args ...interface{}) *dbus.Call {
var method string var method string
if self.Iface != "" { if self.Iface != "" {
method = fmt.Sprintf("%s.%s.%s", self.Dest, self.Iface,name) method = fmt.Sprintf("%s.%s.%s", self.Dest, self.Iface, name)
}else { } else {
method = fmt.Sprintf("%s.%s", self.Dest,name) method = fmt.Sprintf("%s.%s", self.Dest, name)
} }
if args != nil { if args != nil {
return self.Obj.Call( method , 0,args...) return self.Obj.Call(method, 0, args...)
}else { } else {
return self.Obj.Call( method, 0) return self.Obj.Call(method, 0)
} }
} }
func (self *DbusInterface) Get( thecall *dbus.Call, retvalues ...interface{}) error { func (self *DbusInterface) Get(thecall *dbus.Call, retvalues ...interface{}) error {
if len(thecall.Body) == 0 { if len(thecall.Body) == 0 {
return nil return nil
} }
err:= thecall.Store(retvalues...) err := thecall.Store(retvalues...)
if err != nil { if err != nil {
panic(fmt.Sprintf("Failed: %s,%s",err,thecall.Method)) panic(fmt.Sprintf("Failed: %s,%s", err, thecall.Method))
} }
return err return err
} }
func (self *DbusInterface) EnableSignal(signame string) { func (self *DbusInterface) EnableSignal(signame string) {
iface := self.Dest iface := self.Dest
if self.Iface != "" { if self.Iface != "" {
iface = iface+ "."+self.Iface iface = iface + "." + self.Iface
} }
self.Obj.AddMatchSignal(iface,signame) self.Obj.AddMatchSignal(iface, signame)
} }
func (self *DbusInterface) HandleSignal(sig *dbus.Signal) {
func (self *DbusInterface) HandleSignal( sig *dbus.Signal) {
iface := self.Dest iface := self.Dest
if self.Iface != "" { if self.Iface != "" {
iface = iface+ "."+self.Iface iface = iface + "." + self.Iface
} }
if strings.HasPrefix(sig.Name,iface) { if strings.HasPrefix(sig.Name, iface) {
func_name := strings.Replace( sig.Name, iface, "",-1)[1:] func_name := strings.Replace(sig.Name, iface, "", -1)[1:]
for k,v := range self.SigFuncs { for k, v := range self.SigFuncs {
if k == func_name { if k == func_name {
v.(func([]interface{}))(sig.Body) v.(func([]interface{}))(sig.Body)
break break
@@ -93,9 +92,9 @@ type DBusInterface interface {
} }
type DBus struct { type DBus struct {
Conn *dbus.Conn Conn *dbus.Conn
Daemon *DbusInterface Daemon *DbusInterface
Wifi *DbusInterface Wifi *DbusInterface
} }
func NewDBus() *DBus { func NewDBus() *DBus {
@@ -104,102 +103,102 @@ func NewDBus() *DBus {
} }
func (self *DBus) Init() { func (self *DBus) Init() {
//conn_option := dbus.WithSignalHandler(self) //conn_option := dbus.WithSignalHandler(self)
conn, err := dbus.SystemBus() conn, err := dbus.SystemBus()
//conn,err := dbus.SystemBusPrivate(conn_option) //conn,err := dbus.SystemBusPrivate(conn_option)
if err != nil { if err != nil {
panic(fmt.Sprintf("Failed to connect to system bus:", err)) panic(fmt.Sprintf("Failed to connect to system bus:", err))
} }
self.Conn = conn self.Conn = conn
self.Daemon = NewDbusInterface(conn, "org.wicd.daemon","/org/wicd/daemon" ,"",) self.Daemon = NewDbusInterface(conn, "org.wicd.daemon", "/org/wicd/daemon", "")
self.Wifi = NewDbusInterface(conn, "org.wicd.daemon","/org/wicd/daemon/wireless","wireless") self.Wifi = NewDbusInterface(conn, "org.wicd.daemon", "/org/wicd/daemon/wireless", "wireless")
} }
func (self *DBus) WifiStrength() int { func (self *DBus) WifiStrength() int {
var fast bool var fast bool
var iwconfig string var iwconfig string
var sig_display_type int var sig_display_type int
var strength int var strength int
self.Daemon.Get( self.Daemon.Method("NeedsExternalCalls"), &fast) self.Daemon.Get(self.Daemon.Method("NeedsExternalCalls"), &fast)
if fast == false { if fast == false {
self.Wifi.Get( self.Wifi.Method("GetIwconfig"), &iwconfig ) self.Wifi.Get(self.Wifi.Method("GetIwconfig"), &iwconfig)
}else{ } else {
iwconfig = "" iwconfig = ""
} }
self.Daemon.Get( self.Daemon.Method("GetSignalDisplayType"), &sig_display_type ) self.Daemon.Get(self.Daemon.Method("GetSignalDisplayType"), &sig_display_type)
if sig_display_type == 0 { if sig_display_type == 0 {
self.Wifi.Get( self.Wifi.Method("GetCurrentSignalStrength",iwconfig), &strength) self.Wifi.Get(self.Wifi.Method("GetCurrentSignalStrength", iwconfig), &strength)
} else{ } else {
self.Wifi.Get( self.Wifi.Method("GetCurrentDBMStrength",iwconfig), &strength) self.Wifi.Get(self.Wifi.Method("GetCurrentDBMStrength", iwconfig), &strength)
} }
return strength return strength
} }
func (self *DBus) check_for_wireless(iwconfig string, wireless_ip string) bool { func (self *DBus) check_for_wireless(iwconfig string, wireless_ip string) bool {
var network string var network string
var sig_display_type int var sig_display_type int
var strength int var strength int
if wireless_ip == "" { if wireless_ip == "" {
return false return false
} }
self.Wifi.Get( self.Wifi.Method("GetCurrentNetwork",iwconfig), &network) self.Wifi.Get(self.Wifi.Method("GetCurrentNetwork", iwconfig), &network)
self.Daemon.Get( self.Daemon.Method("GetSignalDisplayType"), &sig_display_type ) self.Daemon.Get(self.Daemon.Method("GetSignalDisplayType"), &sig_display_type)
if sig_display_type == 0 { if sig_display_type == 0 {
self.Wifi.Get( self.Wifi.Method("GetCurrentSignalStrength",iwconfig), &strength) self.Wifi.Get(self.Wifi.Method("GetCurrentSignalStrength", iwconfig), &strength)
}else { } else {
self.Wifi.Get( self.Wifi.Method("GetCurrentDBMStrength",iwconfig), &strength) self.Wifi.Get(self.Wifi.Method("GetCurrentDBMStrength", iwconfig), &strength)
} }
if strength == 0 { if strength == 0 {
return false return false
} }
strength_str := "" strength_str := ""
self.Daemon.Get( self.Daemon.Method("FormatSignalForPrinting",strength), &strength_str) self.Daemon.Get(self.Daemon.Method("FormatSignalForPrinting", strength), &strength_str)
return true return true
} }
func (self *DBus) GetWifiIP() string { func (self *DBus) GetWifiIP() string {
var wireless_ip string var wireless_ip string
if self.Wifi != nil { if self.Wifi != nil {
self.Wifi.Get( self.Wifi.Method("GetWirelessIP", ""), &wireless_ip) self.Wifi.Get(self.Wifi.Method("GetWirelessIP", ""), &wireless_ip)
} }
return wireless_ip return wireless_ip
} }
func (self *DBus) IsWifiConnectedNow() bool { func (self *DBus) IsWifiConnectedNow() bool {
var fast bool var fast bool
var iwconfig string var iwconfig string
var wireless_connecting bool var wireless_connecting bool
var wireless_ip string var wireless_ip string
self.Wifi.Get( self.Wifi.Method("CheckIfWirelessConnecting"), &wireless_connecting ) self.Wifi.Get(self.Wifi.Method("CheckIfWirelessConnecting"), &wireless_connecting)
self.Daemon.Get( self.Daemon.Method("NeedsExternalCalls"), &fast) self.Daemon.Get(self.Daemon.Method("NeedsExternalCalls"), &fast)
if wireless_connecting == true { if wireless_connecting == true {
return false return false
}else { } else {
if fast == false { if fast == false {
self.Wifi.Get( self.Wifi.Method("GetIwconfig"), &iwconfig ) self.Wifi.Get(self.Wifi.Method("GetIwconfig"), &iwconfig)
}else { } else {
iwconfig = "" iwconfig = ""
} }
self.Wifi.Get( self.Wifi.Method("GetWirelessIP", iwconfig), &wireless_ip) self.Wifi.Get(self.Wifi.Method("GetWirelessIP", iwconfig), &wireless_ip)
if self.check_for_wireless(iwconfig,wireless_ip) == true { if self.check_for_wireless(iwconfig, wireless_ip) == true {
return true return true
}else { } else {
return false return false
} }
@@ -210,24 +209,24 @@ func (self *DBus) ListenSignal() {
c := make(chan *dbus.Signal, 10) c := make(chan *dbus.Signal, 10)
self.Conn.Signal(c) self.Conn.Signal(c)
for v := range c { for v := range c {
//fmt.Printf("%+v %#v\n",v,v) //fmt.Printf("%+v %#v\n",v,v)
//fmt.Printf("body len:%d \n\n",len(v.Body)) //fmt.Printf("body len:%d \n\n",len(v.Body))
self.Wifi.HandleSignal(v) self.Wifi.HandleSignal(v)
self.Daemon.HandleSignal(v) self.Daemon.HandleSignal(v)
} }
} }
var DBusHandler *DBus //global var DBusHandler *DBus //global
func init() { func init() {
if DBusHandler == nil { if DBusHandler == nil {
DBusHandler = NewDBus() DBusHandler = NewDBus()
DBusHandler.Init() DBusHandler.Init()
go DBusHandler.ListenSignal() go DBusHandler.ListenSignal()
} }
} }

98
sysgo/UI/Emulator/emulator.go
View File

@@ -1,87 +1,77 @@
package Emulator package Emulator
import ( import (
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
) )
type ActionConfig struct { type ActionConfig struct {
ROM string `ini:"ROM"` ROM string `ini:"ROM"`
ROM_SO string `ini:"ROM_SO"` ROM_SO string `ini:"ROM_SO"`
EXT []string `ini:"EXT,omitempty"` EXT []string `ini:"EXT,omitempty"`
EXCLUDE []string `ini:"EXCLUDE,omitempty"` EXCLUDE []string `ini:"EXCLUDE,omitempty"`
FILETYPE string `ini:"FILETYPE"` // defalut is file FILETYPE string `ini:"FILETYPE"` // defalut is file
LAUNCHER string `ini:"LAUNCHER"` LAUNCHER string `ini:"LAUNCHER"`
TITLE string `ini:"TITLE"` // defaut is Game TITLE string `ini:"TITLE"` // defaut is Game
SO_URL string `ini:"SO_URL"` SO_URL string `ini:"SO_URL"`
RETRO_CONFIG string `ini:"RETRO_CONFIG"` RETRO_CONFIG string `ini:"RETRO_CONFIG"`
} }
var ( var (
FavGID = 31415 FavGID = 31415
FavGname = "cpifav" FavGname = "cpifav"
) )
type MyEmulator struct { // as leader of RomListPage and FavListPage, it's a PluginInterface type MyEmulator struct { // as leader of RomListPage and FavListPage, it's a PluginInterface
Name string Name string
RomPage *RomListPage RomPage *RomListPage
FavPage *FavListPage FavPage *FavListPage
DeleteConfirmPage *UI.DeleteConfirmPage DeleteConfirmPage *UI.DeleteConfirmPage
EmulatorConfig *ActionConfig EmulatorConfig *ActionConfig
SpeedMax int
SpeedTimeInter int
SpeedMax int
SpeedTimeInter int
} }
func NewMyEmulator() *MyEmulator{ func NewMyEmulator() *MyEmulator {
p := &MyEmulator{} p := &MyEmulator{}
p.SpeedMax = 5 p.SpeedMax = 5
p.SpeedTimeInter = 300 p.SpeedTimeInter = 300
return p return p
} }
func (self *MyEmulator) GetName() string { func (self *MyEmulator) GetName() string {
return "MyEmulator" return "MyEmulator"
} }
func (self *MyEmulator) Init(main_screen *UI.MainScreen) { func (self *MyEmulator) Init(main_screen *UI.MainScreen) {
self.DeleteConfirmPage = UI.NewDeleteConfirmPage() self.DeleteConfirmPage = UI.NewDeleteConfirmPage()
self.DeleteConfirmPage.Screen = main_screen self.DeleteConfirmPage.Screen = main_screen
self.DeleteConfirmPage.Name = "Delete Confirm" self.DeleteConfirmPage.Name = "Delete Confirm"
self.DeleteConfirmPage.Init() self.DeleteConfirmPage.Init()
self.RomPage = NewRomListPage()
self.RomPage.Screen = main_screen
self.RomPage.Name = self.EmulatorConfig.TITLE
self.RomPage.EmulatorConfig = self.EmulatorConfig
self.RomPage.Leader = self
self.RomPage.Init()
self.FavPage = NewFavListPage()
self.FavPage.Screen = main_screen
self.FavPage.Name = "FavouriteGames"
self.FavPage.EmulatorConfig = self.EmulatorConfig
self.FavPage.Leader = self
self.FavPage.Init()
self.RomPage = NewRomListPage()
self.RomPage.Screen = main_screen
self.RomPage.Name = self.EmulatorConfig.TITLE
self.RomPage.EmulatorConfig = self.EmulatorConfig
self.RomPage.Leader = self
self.RomPage.Init()
self.FavPage = NewFavListPage()
self.FavPage.Screen = main_screen
self.FavPage.Name = "FavouriteGames"
self.FavPage.EmulatorConfig = self.EmulatorConfig
self.FavPage.Leader = self
self.FavPage.Init()
} }
func (self *MyEmulator) Run(main_screen *UI.MainScreen) { func (self *MyEmulator) Run(main_screen *UI.MainScreen) {
if main_screen != nil { if main_screen != nil {
main_screen.PushCurPage() main_screen.PushCurPage()
main_screen.SetCurPage(self.RomPage) main_screen.SetCurPage(self.RomPage)
main_screen.Draw() main_screen.Draw()
main_screen.SwapAndShow() main_screen.SwapAndShow()
} }
} }

780
sysgo/UI/Emulator/fav_list_page.go
View File

@@ -1,550 +1,536 @@
package Emulator package Emulator
import ( import (
"fmt" "errors"
"os" "fmt"
"strings" "github.com/veandco/go-sdl2/ttf"
"path/filepath" "os"
"errors" "path/filepath"
gotime "time" "strings"
"github.com/veandco/go-sdl2/ttf" gotime "time"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/color" "github.com/clockworkpi/LauncherGoDev/sysgo/UI"
"github.com/cuu/gogame/color"
"github.com/cuu/gogame/time" "github.com/cuu/gogame/time"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
) )
type FavListPage struct { type FavListPage struct {
UI.Page UI.Page
Icons map[string]UI.IconItemInterface Icons map[string]UI.IconItemInterface
ListFont *ttf.Font ListFont *ttf.Font
MyStack *UI.FolderStack MyStack *UI.FolderStack
EmulatorConfig *ActionConfig EmulatorConfig *ActionConfig
RomSoConfirmDownloadPage *RomSoConfirmPage RomSoConfirmDownloadPage *RomSoConfirmPage
MyList []UI.ListItemInterface
BGwidth int
BGheight int //70
Scroller *UI.ListScroller
Scrolled int
Leader *MyEmulator
MyList []UI.ListItemInterface
BGwidth int
BGheight int //70
Scroller *UI.ListScroller
Scrolled int
Leader *MyEmulator
} }
func NewFavListPage() *FavListPage { func NewFavListPage() *FavListPage {
p := &FavListPage{} p := &FavListPage{}
p.PageIconMargin = 20 p.PageIconMargin = 20
p.SelectedIconTopOffset = 20 p.SelectedIconTopOffset = 20
p.EasingDur = 10 p.EasingDur = 10
p.Align = UI.ALIGN["SLeft"] p.Align = UI.ALIGN["SLeft"]
p.FootMsg = [5]string{ "Nav","Scan","Remove","","Run" } p.FootMsg = [5]string{"Nav", "Scan", "Remove", "", "Run"}
p.Icons=make(map[string]UI.IconItemInterface) p.Icons = make(map[string]UI.IconItemInterface)
p.ListFont = UI.Fonts["notosanscjk15"] p.ListFont = UI.Fonts["notosanscjk15"]
p.MyStack = UI.NewFolderStack() p.MyStack = UI.NewFolderStack()
p.BGwidth = 75 p.BGwidth = 75
p.BGheight = 73 p.BGheight = 73
p.ScrollStep = 1 p.ScrollStep = 1
return p return p
} }
func (self *FavListPage) GetMyList() []UI.ListItemInterface { func (self *FavListPage) GetMyList() []UI.ListItemInterface {
return self.MyList return self.MyList
} }
func (self *FavListPage) GetMapIcons() map[string]UI.IconItemInterface { func (self *FavListPage) GetMapIcons() map[string]UI.IconItemInterface {
return self.Icons return self.Icons
} }
func (self *FavListPage) GetEmulatorConfig() *ActionConfig { func (self *FavListPage) GetEmulatorConfig() *ActionConfig {
return self.EmulatorConfig return self.EmulatorConfig
} }
func (self *FavListPage) GeneratePathList(path string) ([]map[string]string,error) { func (self *FavListPage) GeneratePathList(path string) ([]map[string]string, error) {
if UI.IsDirectory(path) == false { if UI.IsDirectory(path) == false {
return nil,errors.New("Path is not a folder") return nil, errors.New("Path is not a folder")
} }
dirmap := make(map[string]string) dirmap := make(map[string]string)
var ret []map[string]string var ret []map[string]string
file_paths,err := filepath.Glob(path+"/*")//sorted file_paths, err := filepath.Glob(path + "/*") //sorted
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return ret,err return ret, err
} }
for _,v := range file_paths { for _, v := range file_paths {
if UI.IsDirectory(v) && self.EmulatorConfig.FILETYPE == "dir" { // like DOSBOX if UI.IsDirectory(v) && self.EmulatorConfig.FILETYPE == "dir" { // like DOSBOX
gameshell_bat := self.EmulatorConfig.EXT[0] gameshell_bat := self.EmulatorConfig.EXT[0]
if UI.GetGid(v) != FavGID { //only favs if UI.GetGid(v) != FavGID { //only favs
continue continue
} }
if UI.FileExists( filepath.Join(v,gameshell_bat)) == true { if UI.FileExists(filepath.Join(v, gameshell_bat)) == true {
dirmap["gamedir"] = v dirmap["gamedir"] = v
ret = append(ret,dirmap) ret = append(ret, dirmap)
} }
} }
if UI.IsAFile(v) && self.EmulatorConfig.FILETYPE == "file" { if UI.IsAFile(v) && self.EmulatorConfig.FILETYPE == "file" {
if UI.GetGid(v) != FavGID { //only favs if UI.GetGid(v) != FavGID { //only favs
continue continue
} }
bname := filepath.Base(v) bname := filepath.Base(v)
if len(bname) > 1 { if len(bname) > 1 {
pieces := strings.Split(bname,".") pieces := strings.Split(bname, ".")
if len(pieces) > 1 { if len(pieces) > 1 {
pieces_ext := strings.ToLower( pieces[len(pieces)-1]) pieces_ext := strings.ToLower(pieces[len(pieces)-1])
for _,u := range self.EmulatorConfig.EXT { for _, u := range self.EmulatorConfig.EXT {
if pieces_ext == u { if pieces_ext == u {
dirmap["file"] = v dirmap["file"] = v
ret = append(ret,dirmap) ret = append(ret, dirmap)
break break
} }
} }
} }
} }
} }
} }
return ret,nil return ret, nil
} }
func (self *FavListPage) SyncList( path string ) { func (self *FavListPage) SyncList(path string) {
alist,err := self.GeneratePathList(path) alist, err := self.GeneratePathList(path)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
self.MyList = nil self.MyList = nil
start_x := 0 start_x := 0
start_y := 0 start_y := 0
hasparent := 0 hasparent := 0
if self.MyStack.Length() > 0 { if self.MyStack.Length() > 0 {
hasparent = 1 hasparent = 1
li := NewEmulatorListItem() li := NewEmulatorListItem()
li.Parent = self li.Parent = self
li.PosX = start_x li.PosX = start_x
li.PosY = start_y li.PosY = start_y
li.Width = UI.Width li.Width = UI.Width
li.Fonts["normal"] = self.ListFont li.Fonts["normal"] = self.ListFont
li.MyType = UI.ICON_TYPES["DIR"] li.MyType = UI.ICON_TYPES["DIR"]
li.Init("[..]") li.Init("[..]")
self.MyList = append(self.MyList,li) self.MyList = append(self.MyList, li)
} }
for i,v := range alist { for i, v := range alist {
li := NewEmulatorListItem() li := NewEmulatorListItem()
li.Parent = self li.Parent = self
li.PosX = start_x li.PosX = start_x
li.PosY = start_y + (i+hasparent)*li.Height li.PosY = start_y + (i+hasparent)*li.Height
li.Fonts["normal"] = self.ListFont li.Fonts["normal"] = self.ListFont
li.MyType = UI.ICON_TYPES["FILE"] li.MyType = UI.ICON_TYPES["FILE"]
init_val := "NoName" init_val := "NoName"
if val, ok := v["directory"]; ok { if val, ok := v["directory"]; ok {
li.MyType = UI.ICON_TYPES["DIR"] li.MyType = UI.ICON_TYPES["DIR"]
init_val = val init_val = val
} }
if val, ok := v["file"]; ok { if val, ok := v["file"]; ok {
init_val = val init_val = val
} }
if val, ok := v["gamedir"]; ok { if val, ok := v["gamedir"]; ok {
init_val = val init_val = val
} }
li.Init(init_val) li.Init(init_val)
self.MyList = append(self.MyList,li) self.MyList = append(self.MyList, li)
} }
} }
func (self *FavListPage) Init() { func (self *FavListPage) Init() {
self.PosX = self.Index *self.Screen.Width self.PosX = self.Index * self.Screen.Width
self.Width = self.Screen.Width self.Width = self.Screen.Width
self.Height = self.Screen.Height self.Height = self.Screen.Height
self.CanvasHWND = self.Screen.CanvasHWND self.CanvasHWND = self.Screen.CanvasHWND
ps := UI.NewInfoPageSelector() ps := UI.NewInfoPageSelector()
ps.Width = UI.Width - 12 ps.Width = UI.Width - 12
ps.PosX = 2 ps.PosX = 2
ps.Parent = self ps.Parent = self
self.Ps = ps self.Ps = ps
self.PsIndex = 0 self.PsIndex = 0
self.MyStack.SetRootPath(self.EmulatorConfig.ROM) self.MyStack.SetRootPath(self.EmulatorConfig.ROM)
self.SyncList( self.EmulatorConfig.ROM ) self.SyncList(self.EmulatorConfig.ROM)
icon_for_list := UI.NewMultiIconItem() icon_for_list := UI.NewMultiIconItem()
icon_for_list.ImgSurf = UI.MyIconPool.GetImgSurf("sys") icon_for_list.ImgSurf = UI.MyIconPool.GetImgSurf("sys")
icon_for_list.MyType = UI.ICON_TYPES["STAT"] icon_for_list.MyType = UI.ICON_TYPES["STAT"]
icon_for_list.Parent = self icon_for_list.Parent = self
icon_for_list.Adjust(0,0,18,18,0) icon_for_list.Adjust(0, 0, 18, 18, 0)
self.Icons["sys"] = icon_for_list self.Icons["sys"] = icon_for_list
bgpng := UI.NewIconItem() bgpng := UI.NewIconItem()
bgpng.ImgSurf = UI.MyIconPool.GetImgSurf("star") bgpng.ImgSurf = UI.MyIconPool.GetImgSurf("star")
bgpng.MyType = UI.ICON_TYPES["STAT"] bgpng.MyType = UI.ICON_TYPES["STAT"]
bgpng.Parent = self bgpng.Parent = self
bgpng.AddLabel("my favourites games",UI.Fonts["varela22"]) bgpng.AddLabel("my favourites games", UI.Fonts["varela22"])
bgpng.SetLabelColor(&color.Color{204,204,204,255} ) bgpng.SetLabelColor(&color.Color{204, 204, 204, 255})
bgpng.Adjust(0,0,self.BGwidth,self.BGheight,0) bgpng.Adjust(0, 0, self.BGwidth, self.BGheight, 0)
self.Icons["bg"] = bgpng self.Icons["bg"] = bgpng
self.Scroller = UI.NewListScroller() self.Scroller = UI.NewListScroller()
self.Scroller.Parent = self self.Scroller.Parent = self
self.Scroller.PosX = self.Width - 10 self.Scroller.PosX = self.Width - 10
self.Scroller.PosY = 2 self.Scroller.PosY = 2
self.Scroller.Init() self.Scroller.Init()
rom_so_confirm_page := NewRomSoConfirmPage() rom_so_confirm_page := NewRomSoConfirmPage()
rom_so_confirm_page.Screen = self.Screen rom_so_confirm_page.Screen = self.Screen
rom_so_confirm_page.Name = "Download Confirm" rom_so_confirm_page.Name = "Download Confirm"
rom_so_confirm_page.Parent = self rom_so_confirm_page.Parent = self
rom_so_confirm_page.Init() rom_so_confirm_page.Init()
self.RomSoConfirmDownloadPage = rom_so_confirm_page self.RomSoConfirmDownloadPage = rom_so_confirm_page
} }
func (self *FavListPage) ScrollUp() { func (self *FavListPage) ScrollUp() {
if len(self.MyList) == 0 { if len(self.MyList) == 0 {
return return
} }
self.PsIndex -=1 self.PsIndex -= 1
if self.PsIndex < 0 { if self.PsIndex < 0 {
self.PsIndex = 0 self.PsIndex = 0
} }
cur_li := self.MyList[self.PsIndex] cur_li := self.MyList[self.PsIndex]
x,y := cur_li.Coord() x, y := cur_li.Coord()
_,h := cur_li.Size() _, h := cur_li.Size()
if y < 0 { if y < 0 {
for i,_ := range self.MyList{ for i, _ := range self.MyList {
x,y = self.MyList[i].Coord() x, y = self.MyList[i].Coord()
_, h = self.MyList[i].Size() _, h = self.MyList[i].Size()
self.MyList[i].NewCoord(x, y + h) self.MyList[i].NewCoord(x, y+h)
} }
self.Scrolled +=1 self.Scrolled += 1
} }
} }
func (self *FavListPage) ScrollDown() {
if len(self.MyList) == 0 {
return
}
self.PsIndex += 1
func (self *FavListPage) ScrollDown(){ if self.PsIndex >= len(self.MyList) {
if len(self.MyList) == 0 { self.PsIndex = len(self.MyList) - 1
return }
}
self.PsIndex +=1
if self.PsIndex >= len(self.MyList) { cur_li := self.MyList[self.PsIndex]
self.PsIndex = len(self.MyList) - 1 x, y := cur_li.Coord()
} _, h := cur_li.Size()
if y+h > self.Height {
cur_li := self.MyList[self.PsIndex] for i, _ := range self.MyList {
x,y := cur_li.Coord() x, y = self.MyList[i].Coord()
_,h := cur_li.Size() _, h = self.MyList[i].Size()
if y + h > self.Height { self.MyList[i].NewCoord(x, y-h)
for i,_ := range self.MyList{ }
x,y = self.MyList[i].Coord() self.Scrolled -= 1
_, h = self.MyList[i].Size() }
self.MyList[i].NewCoord(x,y-h)
}
self.Scrolled -=1
}
} }
func (self *FavListPage) SyncScroll() { func (self *FavListPage) SyncScroll() {
if self.Scrolled == 0 { if self.Scrolled == 0 {
return return
} }
if self.PsIndex < len(self.MyList) { if self.PsIndex < len(self.MyList) {
cur_li := self.MyList[self.PsIndex] cur_li := self.MyList[self.PsIndex]
x,y := cur_li.Coord() x, y := cur_li.Coord()
_,h := cur_li.Size() _, h := cur_li.Size()
if self.Scrolled > 0 { if self.Scrolled > 0 {
if y < 0 { if y < 0 {
for i,_ := range self.MyList{ for i, _ := range self.MyList {
x,y = self.MyList[i].Coord() x, y = self.MyList[i].Coord()
_,h = self.MyList[i].Size() _, h = self.MyList[i].Size()
self.MyList[i].NewCoord(x, y + self.Scrolled*h) self.MyList[i].NewCoord(x, y+self.Scrolled*h)
} }
} }
}else if self.Scrolled < 0 { } else if self.Scrolled < 0 {
if y + h > self.Height { if y+h > self.Height {
for i,_ := range self.MyList { for i, _ := range self.MyList {
x,y = self.MyList[i].Coord() x, y = self.MyList[i].Coord()
_,h = self.MyList[i].Size() _, h = self.MyList[i].Size()
self.MyList[i].NewCoord(x,y + self.Scrolled*h) self.MyList[i].NewCoord(x, y+self.Scrolled*h)
} }
} }
} }
} }
} }
func (self *FavListPage) Click() { func (self *FavListPage) Click() {
if len(self.MyList) == 0 { if len(self.MyList) == 0 {
return return
} }
if self.PsIndex > len(self.MyList)-1 {
return
}
if self.PsIndex > len(self.MyList) - 1 { cur_li := self.MyList[self.PsIndex]
return
}
if cur_li.(*EmulatorListItem).MyType == UI.ICON_TYPES["DIR"] {
if cur_li.(*EmulatorListItem).Path == "[..]" {
self.MyStack.Pop()
self.SyncList(self.MyStack.Last())
self.PsIndex = 0
} else {
self.MyStack.Push(self.MyList[self.PsIndex].(*EmulatorListItem).Path)
self.SyncList(self.MyStack.Last())
self.PsIndex = 0
}
}
cur_li := self.MyList[self.PsIndex] if cur_li.(*EmulatorListItem).MyType == UI.ICON_TYPES["FILE"] {
self.Screen.MsgBox.SetText("Launching")
self.Screen.MsgBox.Draw()
self.Screen.SwapAndShow()
if cur_li.(*EmulatorListItem).MyType == UI.ICON_TYPES["DIR"] { path := ""
if cur_li.(*EmulatorListItem).Path == "[..]" { if self.EmulatorConfig.FILETYPE == "dir" {
self.MyStack.Pop() path = filepath.Join(cur_li.(*EmulatorListItem).Path, self.EmulatorConfig.EXT[0])
self.SyncList(self.MyStack.Last()) } else {
self.PsIndex = 0 path = cur_li.(*EmulatorListItem).Path
}else{ }
self.MyStack.Push(self.MyList[self.PsIndex].(*EmulatorListItem).Path)
self.SyncList(self.MyStack.Last())
self.PsIndex = 0
}
}
if cur_li.(*EmulatorListItem).MyType == UI.ICON_TYPES["FILE"] { fmt.Println("Run ", path)
self.Screen.MsgBox.SetText("Launching")
self.Screen.MsgBox.Draw()
self.Screen.SwapAndShow()
path := "" escaped_path := UI.CmdClean(path)
if self.EmulatorConfig.FILETYPE == "dir" {
path = filepath.Join(cur_li.(*EmulatorListItem).Path,self.EmulatorConfig.EXT[0])
}else{
path = cur_li.(*EmulatorListItem).Path
}
fmt.Println("Run ",path) if self.EmulatorConfig.FILETYPE == "dir" {
escaped_path = UI.CmdClean(path)
}
escaped_path := UI.CmdClean(path) custom_config := ""
if self.EmulatorConfig.FILETYPE == "dir" { if self.EmulatorConfig.RETRO_CONFIG != "" && len(self.EmulatorConfig.RETRO_CONFIG) > 5 {
escaped_path = UI.CmdClean(path) custom_config = " -c " + self.EmulatorConfig.RETRO_CONFIG
} }
custom_config := "" partsofpath := []string{self.EmulatorConfig.LAUNCHER, self.EmulatorConfig.ROM_SO, custom_config, escaped_path}
if self.EmulatorConfig.RETRO_CONFIG != "" && len(self.EmulatorConfig.RETRO_CONFIG) > 5 { cmdpath := strings.Join(partsofpath, " ")
custom_config = " -c " + self.EmulatorConfig.RETRO_CONFIG
}
partsofpath := []string{self.EmulatorConfig.LAUNCHER,self.EmulatorConfig.ROM_SO,custom_config,escaped_path} if self.EmulatorConfig.ROM_SO == "" { //empty means No needs for rom so
event.Post(UI.RUNEVT, cmdpath)
} else {
cmdpath := strings.Join( partsofpath," ") if UI.FileExists(strings.Split(self.EmulatorConfig.ROM_SO, " ")[0]) == true {
event.Post(UI.RUNEVT, cmdpath)
} else {
self.Screen.PushCurPage()
self.Screen.SetCurPage(self.RomSoConfirmDownloadPage)
self.Screen.Draw()
self.Screen.SwapAndShow()
}
}
if self.EmulatorConfig.ROM_SO =="" { //empty means No needs for rom so return
event.Post(UI.RUNEVT,cmdpath)
}else{
if UI.FileExists( strings.Split(self.EmulatorConfig.ROM_SO," ")[0] ) == true { }
event.Post(UI.RUNEVT,cmdpath)
} else {
self.Screen.PushCurPage()
self.Screen.SetCurPage( self.RomSoConfirmDownloadPage)
self.Screen.Draw()
self.Screen.SwapAndShow()
}
}
return self.Screen.Draw()
self.Screen.SwapAndShow()
}
self.Screen.Draw()
self.Screen.SwapAndShow()
} }
func (self *FavListPage) ReScan() { func (self *FavListPage) ReScan() {
//fmt.Println("FavListPage ReScan ",self.EmulatorConfig.ROM) //fmt.Println("FavListPage ReScan ",self.EmulatorConfig.ROM)
if self.MyStack.Length() == 0 { if self.MyStack.Length() == 0 {
self.SyncList(self.EmulatorConfig.ROM) self.SyncList(self.EmulatorConfig.ROM)
}else{ } else {
self.SyncList(self.MyStack.Last()) self.SyncList(self.MyStack.Last())
} }
idx := self.PsIndex
idx := self.PsIndex if idx > len(self.MyList)-1 {
idx = len(self.MyList)
if idx > 0 {
idx -= 1
} else if idx == 0 {
//nothing in MyList
}
}
if idx > len(self.MyList) - 1 { self.PsIndex = idx //sync PsIndex
idx = len(self.MyList)
if idx > 0 {
idx -= 1
}else if idx == 0 {
//nothing in MyList
}
}
self.PsIndex = idx //sync PsIndex self.SyncScroll()
self.SyncScroll()
} }
func (self *FavListPage) OnReturnBackCb() { func (self *FavListPage) OnReturnBackCb() {
self.ReScan() self.ReScan()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
func (self *FavListPage) OnLoadCb() { func (self *FavListPage) OnLoadCb() {
self.ReScan() self.ReScan()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
func (self *FavListPage) SpeedScroll(thekey string ) { func (self *FavListPage) SpeedScroll(thekey string) {
if self.Screen.LastKey == thekey { if self.Screen.LastKey == thekey {
self.ScrollStep += 1 self.ScrollStep += 1
if self.ScrollStep >= self.Leader.SpeedMax { if self.ScrollStep >= self.Leader.SpeedMax {
self.ScrollStep = self.Leader.SpeedMax self.ScrollStep = self.Leader.SpeedMax
} }
} else { } else {
self.ScrollStep = 1 self.ScrollStep = 1
} }
cur_time := gotime.Now() cur_time := gotime.Now()
if cur_time.Sub(self.Screen.LastKeyDown) > gotime.Duration(self.Leader.SpeedTimeInter)*gotime.Millisecond { if cur_time.Sub(self.Screen.LastKeyDown) > gotime.Duration(self.Leader.SpeedTimeInter)*gotime.Millisecond {
self.ScrollStep = 1 self.ScrollStep = 1
} }
} }
func (self *FavListPage) KeyDown(ev *event.Event) { func (self *FavListPage) KeyDown(ev *event.Event) {
if ev.Data["Key"] == UI.CurKeys["Menu"] || ev.Data["Key"] == UI.CurKeys["Left"] { if ev.Data["Key"] == UI.CurKeys["Menu"] || ev.Data["Key"] == UI.CurKeys["Left"] {
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["Up"]{ if ev.Data["Key"] == UI.CurKeys["Up"] {
self.SpeedScroll(ev.Data["Key"]) self.SpeedScroll(ev.Data["Key"])
self.ScrollUp() self.ScrollUp()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["Down"] { if ev.Data["Key"] == UI.CurKeys["Down"] {
self.SpeedScroll(ev.Data["Key"]) self.SpeedScroll(ev.Data["Key"])
self.ScrollDown() self.ScrollDown()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["Enter"] { if ev.Data["Key"] == UI.CurKeys["Enter"] {
self.Click() self.Click()
} }
if ev.Data["Key"] == UI.CurKeys["X"] { //Scan current if ev.Data["Key"] == UI.CurKeys["X"] { //Scan current
self.ReScan() self.ReScan()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["Y"] {// del if ev.Data["Key"] == UI.CurKeys["Y"] { // del
if len(self.MyList) == 0 { if len(self.MyList) == 0 {
return return
} }
cur_li := self.MyList[self.PsIndex] cur_li := self.MyList[self.PsIndex]
if cur_li.(*EmulatorListItem).IsFile() { if cur_li.(*EmulatorListItem).IsFile() {
uid := UI.GetUid(cur_li.(*EmulatorListItem).Path) uid := UI.GetUid(cur_li.(*EmulatorListItem).Path)
os.Chown(cur_li.(*EmulatorListItem).Path,uid ,uid) os.Chown(cur_li.(*EmulatorListItem).Path, uid, uid)
self.Screen.MsgBox.SetText("Deleting") self.Screen.MsgBox.SetText("Deleting")
self.Screen.MsgBox.Draw() self.Screen.MsgBox.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
time.BlockDelay(600) time.BlockDelay(600)
self.ReScan() self.ReScan()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
} }
} }
func (self *FavListPage) Draw() { func (self *FavListPage) Draw() {
self.ClearCanvas() self.ClearCanvas()
if len(self.MyList) == 0 { if len(self.MyList) == 0 {
self.Icons["bg"].NewCoord(self.Width/2,self.Height/2) self.Icons["bg"].NewCoord(self.Width/2, self.Height/2)
self.Icons["bg"].Draw() self.Icons["bg"].Draw()
}else{ } else {
_,h := self.Ps.Size() _, h := self.Ps.Size()
if len(self.MyList) * UI.HierListItemDefaultHeight > self.Height { if len(self.MyList)*UI.HierListItemDefaultHeight > self.Height {
self.Ps.NewSize(self.Width - 10, h) self.Ps.NewSize(self.Width-10, h)
self.Ps.Draw() self.Ps.Draw()
for _, v := range self.MyList {
_, y := v.Coord()
if y > self.Height+self.Height/2 {
break
}
for _,v := range self.MyList { if y < 0 {
_, y := v.Coord() continue
if y > self.Height + self.Height/2 { }
break
}
if y < 0 { v.Draw()
continue }
}
v.Draw() self.Scroller.UpdateSize(len(self.MyList)*UI.HierListItemDefaultHeight,
} self.PsIndex*UI.HierListItemDefaultHeight)
self.Scroller.Draw()
self.Scroller.UpdateSize( len(self.MyList)*UI.HierListItemDefaultHeight, } else {
self.PsIndex*UI.HierListItemDefaultHeight) self.Ps.NewSize(self.Width, h)
self.Scroller.Draw() self.Ps.Draw()
for _, v := range self.MyList {
v.Draw()
}
}else { }
self.Ps.NewSize(self.Width,h) }
self.Ps.Draw()
for _,v := range self.MyList {
v.Draw()
}
}
}
} }

146
sysgo/UI/Emulator/list_item.go
View File

@@ -1,118 +1,112 @@
package Emulator package Emulator
import ( import (
"fmt" "fmt"
"strings" "github.com/veandco/go-sdl2/ttf"
"io/ioutil" "io/ioutil"
"path/filepath" "path/filepath"
"github.com/veandco/go-sdl2/ttf" "strings"
//"github.com/veandco/go-sdl2/sdl" //"github.com/veandco/go-sdl2/sdl"
//"github.com/cuu/gogame/surface" //"github.com/cuu/gogame/surface"
//"github.com/cuu/gogame/rect" //"github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
"github.com/cuu/gogame/draw" "github.com/cuu/gogame/draw"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
) )
type EmulatorPageInterface interface { type EmulatorPageInterface interface {
UI.PageInterface UI.PageInterface
GetMapIcons() map[string]UI.IconItemInterface GetMapIcons() map[string]UI.IconItemInterface
GetEmulatorConfig() *ActionConfig GetEmulatorConfig() *ActionConfig
} }
type EmulatorListItem struct { type EmulatorListItem struct {
UI.HierListItem UI.HierListItem
Parent EmulatorPageInterface Parent EmulatorPageInterface
} }
func NewEmulatorListItem() *EmulatorListItem { func NewEmulatorListItem() *EmulatorListItem {
p := &EmulatorListItem{} p := &EmulatorListItem{}
p.Labels = make(map[string]UI.LabelInterface) p.Labels = make(map[string]UI.LabelInterface)
p.Icons = make( map[string]UI.IconItemInterface) p.Icons = make(map[string]UI.IconItemInterface)
p.Fonts = make(map[string]*ttf.Font) p.Fonts = make(map[string]*ttf.Font)
p.MyType = UI.ICON_TYPES["EXE"] p.MyType = UI.ICON_TYPES["EXE"]
p.Height = 32 p.Height = 32
p.Width = 0 p.Width = 0
return p
return p
} }
func (self *EmulatorListItem) Init(text string) { func (self *EmulatorListItem) Init(text string) {
l := UI.NewLabel() l := UI.NewLabel()
l.PosX = 20 l.PosX = 20
l.SetCanvasHWND(self.Parent.GetCanvasHWND()) l.SetCanvasHWND(self.Parent.GetCanvasHWND())
if self.IsDir() == true || self.IsFile() == true { if self.IsDir() == true || self.IsFile() == true {
self.Path = text self.Path = text
} }
label_text := filepath.Base(text) label_text := filepath.Base(text)
ext:= filepath.Ext(text) ext := filepath.Ext(text)
if ext != "" { if ext != "" {
alias_file := strings.Replace(text,ext,"",-1) + ".alias" alias_file := strings.Replace(text, ext, "", -1) + ".alias"
if UI.FileExists(alias_file) == true { if UI.FileExists(alias_file) == true {
b, err := ioutil.ReadFile(alias_file) b, err := ioutil.ReadFile(alias_file)
if err != nil { if err != nil {
fmt.Print(err) fmt.Print(err)
}else { } else {
label_text = string(b) label_text = string(b)
} }
} }
} }
if self.IsDir() == true { if self.IsDir() == true {
l.Init(label_text, self.Fonts["normal"],nil) l.Init(label_text, self.Fonts["normal"], nil)
}else { } else {
l.Init(label_text,self.Fonts["normal"],nil) l.Init(label_text, self.Fonts["normal"], nil)
} }
self.Labels["Text"] = l self.Labels["Text"] = l
} }
func (self *EmulatorListItem) Draw() { func (self *EmulatorListItem) Draw() {
x,y := self.Labels["Text"].Coord() x, y := self.Labels["Text"].Coord()
_,h := self.Labels["Text"].Size() _, h := self.Labels["Text"].Size()
if self.Path != "[..]" {
self.Labels["Text"].NewCoord(23, y)
if self.Path != "[..]" { } else {
self.Labels["Text"].NewCoord(23,y) self.Labels["Text"].NewCoord(3, y)
}
}else { x, y = self.Labels["Text"].Coord()
self.Labels["Text"].NewCoord(3,y) self.Labels["Text"].NewCoord(x, self.PosY+(self.Height-h)/2)
}
x,y = self.Labels["Text"].Coord() self.Labels["Text"].Draw()
self.Labels["Text"].NewCoord(x, self.PosY + (self.Height-h)/2)
self.Labels["Text"].Draw() parent_icons := self.Parent.GetMapIcons()
_, h = parent_icons["sys"].Size()
parent_icons := self.Parent.GetMapIcons() if self.IsDir() == true && self.Path != "[..]" {
_,h = parent_icons["sys"].Size() parent_icons["sys"].SetIconIndex(0)
parent_icons["sys"].NewCoord(self.PosX+12, self.PosY+(self.Height-h)/2+h/2)
parent_icons["sys"].Draw()
}
if self.IsDir() == true && self.Path != "[..]" { if self.IsFile() == true {
parent_icons["sys"].SetIconIndex (0) parent_icons["sys"].SetIconIndex(1)
parent_icons["sys"].NewCoord(self.PosX+12,self.PosY+(self.Height-h)/2+h/2) parent_icons["sys"].NewCoord(self.PosX+12, self.PosY+(self.Height-h)/2+h/2)
parent_icons["sys"].Draw() parent_icons["sys"].Draw()
} }
if self.IsFile() == true { draw.Line(self.Parent.GetCanvasHWND(), &color.Color{169, 169, 169, 255},
parent_icons["sys"].SetIconIndex(1) self.PosX, self.PosY+self.Height-1, self.PosX+self.Width, self.PosY+self.Height-1, 1)
parent_icons["sys"].NewCoord(self.PosX+12,self.PosY+(self.Height-h)/2+h/2)
parent_icons["sys"].Draw()
}
draw.Line(self.Parent.GetCanvasHWND(),&color.Color{169,169,169,255},
self.PosX,self.PosY+self.Height-1,self.PosX+self.Width,self.PosY+self.Height-1,1)
} }

848
sysgo/UI/Emulator/rom_list_page.go
View File

File diff suppressed because it is too large Load Diff

149
sysgo/UI/Emulator/rom_so_confirm_page.go
View File

@@ -1,122 +1,119 @@
package Emulator package Emulator
import ( import (
"fmt" "fmt"
//"strconv" //"strconv"
"strings" "strings"
"path/filepath" "path/filepath"
"github.com/clockworkpi/LauncherGoDev/sysgo"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/clockworkpi/LauncherGoDev/sysgo"
"github.com/clockworkpi/LauncherGoDev/sysgo/UI"
) )
type RomSoConfirmPage struct { type RomSoConfirmPage struct {
UI.ConfirmPage UI.ConfirmPage
Parent EmulatorPageInterface Parent EmulatorPageInterface
DownloadPage *UI.DownloadProcessPage DownloadPage *UI.DownloadProcessPage
} }
func NewRomSoConfirmPage() *RomSoConfirmPage { func NewRomSoConfirmPage() *RomSoConfirmPage {
p := &RomSoConfirmPage{} p := &RomSoConfirmPage{}
p.PageIconMargin = 20 p.PageIconMargin = 20
p.SelectedIconTopOffset = 20 p.SelectedIconTopOffset = 20
p.EasingDur = 10 p.EasingDur = 10
p.Align = UI.ALIGN["SLeft"] p.Align = UI.ALIGN["SLeft"]
p.ListFont = UI.Fonts["veramono18"] p.ListFont = UI.Fonts["veramono18"]
p.FootMsg = [5]string{"Nav","","","Cancel","Yes"} p.FootMsg = [5]string{"Nav", "", "", "Cancel", "Yes"}
p.ConfirmText ="Do you want to setup this game engine automatically?" p.ConfirmText = "Do you want to setup this game engine automatically?"
return p return p
} }
func (self *RomSoConfirmPage) Init() { func (self *RomSoConfirmPage) Init() {
self.PosX = self.Index * self.Screen.Width self.PosX = self.Index * self.Screen.Width
self.Width = self.Screen.Width self.Width = self.Screen.Width
self.Height = self.Screen.Height self.Height = self.Screen.Height
self.CanvasHWND = self.Screen.CanvasHWND self.CanvasHWND = self.Screen.CanvasHWND
li := UI.NewMultiLabel() li := UI.NewMultiLabel()
li.SetCanvasHWND(self.CanvasHWND) li.SetCanvasHWND(self.CanvasHWND)
li.Width = 160 li.Width = 160
li.Init(self.ConfirmText,self.ListFont,nil) li.Init(self.ConfirmText, self.ListFont, nil)
li.PosX = (self.Width - li.Width)/2 li.PosX = (self.Width - li.Width) / 2
li.PosY = (self.Height - li.Height)/2 li.PosY = (self.Height - li.Height) / 2
self.BGPosX = li.PosX-20 self.BGPosX = li.PosX - 20
self.BGPosY = li.PosY-20 self.BGPosY = li.PosY - 20
self.BGWidth = li.Width+40 self.BGWidth = li.Width + 40
self.BGHeight = li.Height+40 self.BGHeight = li.Height + 40
self.MyList = append(self.MyList ,li ) self.MyList = append(self.MyList, li)
} }
func (self *RomSoConfirmPage) SnapMsg(msg string) { func (self *RomSoConfirmPage) SnapMsg(msg string) {
self.MyList[0].SetText(msg) self.MyList[0].SetText(msg)
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
self.MyList[0].SetText(self.ConfirmText) self.MyList[0].SetText(self.ConfirmText)
} }
func (self *RomSoConfirmPage) OnReturnBackCb() { func (self *RomSoConfirmPage) OnReturnBackCb() {
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
func (self *RomSoConfirmPage) KeyDown(ev *event.Event) { func (self *RomSoConfirmPage) KeyDown(ev *event.Event) {
if ev.Data["Key"] == UI.CurKeys["Menu"] || ev.Data["Key"] == UI.CurKeys["A"] { if ev.Data["Key"] == UI.CurKeys["Menu"] || ev.Data["Key"] == UI.CurKeys["A"] {
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == UI.CurKeys["B"] { if ev.Data["Key"] == UI.CurKeys["B"] {
bat := UI.CheckBattery() bat := UI.CheckBattery()
if bat < 5 && bat >= 0 { if bat < 5 && bat >= 0 {
self.SnapMsg("Battery must over 5%") self.SnapMsg("Battery must over 5%")
}else { // -1 or something else, } else { // -1 or something else,
if self.DownloadPage == nil { if self.DownloadPage == nil {
self.DownloadPage = UI.NewDownloadProcessPage() self.DownloadPage = UI.NewDownloadProcessPage()
self.DownloadPage.Screen = self.Screen self.DownloadPage.Screen = self.Screen
self.DownloadPage.Name = "Downloading" self.DownloadPage.Name = "Downloading"
self.DownloadPage.Init() self.DownloadPage.Init()
} }
self.Screen.PushPage(self.DownloadPage) self.Screen.PushPage(self.DownloadPage)
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
ec := self.Parent.GetEmulatorConfig() ec := self.Parent.GetEmulatorConfig()
if sysgo.CurKeySet == "PC" { if sysgo.CurKeySet == "PC" {
so_url := ec.SO_URL so_url := ec.SO_URL
so_url = strings.Replace(so_url,"armhf","x86_64",-1) so_url = strings.Replace(so_url, "armhf", "x86_64", -1)
fmt.Println(so_url) fmt.Println(so_url)
self.DownloadPage.StartDownload(so_url,filepath.Dir(ec.ROM_SO)) self.DownloadPage.StartDownload(so_url, filepath.Dir(ec.ROM_SO))
}else{ } else {
so_url := ec.SO_URL so_url := ec.SO_URL
go self.DownloadPage.StartDownload(so_url,filepath.Dir(ec.ROM_SO)) go self.DownloadPage.StartDownload(so_url, filepath.Dir(ec.ROM_SO))
} }
} }
} }
} }
func (self *RomSoConfirmPage) Draw() { func (self *RomSoConfirmPage) Draw() {
self.ClearCanvas() self.ClearCanvas()
self.DrawBG() self.DrawBG()
for _,v := range self.MyList{ for _, v := range self.MyList {
v.Draw() v.Draw()
} }
} }

101
sysgo/UI/UI.go
View File

@@ -1,54 +1,52 @@
package UI package UI
import ( import (
"fmt" "fmt"
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/font"
"github.com/clockworkpi/LauncherGoDev/sysgo" "github.com/clockworkpi/LauncherGoDev/sysgo"
"github.com/cuu/gogame/font"
) )
type WidgetInterface interface { type WidgetInterface interface {
Size() (int,int) Size() (int, int)
NewSize(w,h int) NewSize(w, h int)
Coord()(int,int) Coord() (int, int)
NewCoord(x,y int) NewCoord(x, y int)
} }
type Coord struct { type Coord struct {
X int X int
Y int Y int
} }
type Plane struct { type Plane struct {
W int W int
H int H int
} }
type Widget struct { type Widget struct {
PosX int PosX int
PosY int PosY int
Width int Width int
Height int Height int
} }
func (self *Widget) Size() (int,int) { func (self *Widget) Size() (int, int) {
return self.Width,self.Height return self.Width, self.Height
} }
func (self *Widget) NewSize(w,h int) { func (self *Widget) NewSize(w, h int) {
self.Width = w self.Width = w
self.Height = h self.Height = h
} }
func (self *Widget) Coord() (int,int) { func (self *Widget) Coord() (int, int) {
return self.PosX,self.PosY return self.PosX, self.PosY
} }
func (self *Widget) NewCoord(x,y int) { func (self *Widget) NewCoord(x, y int) {
self.PosX = x self.PosX = x
self.PosY = y self.PosY = y
} }
@@ -57,58 +55,55 @@ func (self *Widget) NewCoord(x,y int) {
func Init() { func Init() {
font.Init() font.Init()
skinpath := sysgo.SKIN+"/truetype" skinpath := sysgo.SKIN + "/truetype"
Fonts = make(map[string]*ttf.Font) Fonts = make(map[string]*ttf.Font)
fonts_path := make(map[string]string) fonts_path := make(map[string]string)
fonts_path["varela"] = fmt.Sprintf("%s/VarelaRound-Regular.ttf", skinpath)
fonts_path["veramono"] = fmt.Sprintf("%s/VeraMono.ttf", skinpath)
fonts_path["noto"] = fmt.Sprintf("%s/NotoSansMono-Regular.ttf", skinpath)
fonts_path["notocjk"] = fmt.Sprintf("%s/NotoSansCJK-Regular.ttf", skinpath)
fonts_path["varela"] = fmt.Sprintf("%s/VarelaRound-Regular.ttf",skinpath) for i := 10; i < 41; i++ {
fonts_path["veramono"] = fmt.Sprintf("%s/VeraMono.ttf",skinpath) keyname := fmt.Sprintf("varela%d", i)
fonts_path["noto"] = fmt.Sprintf("%s/NotoSansMono-Regular.ttf", skinpath) Fonts[keyname] = font.Font(fonts_path["varela"], i)
fonts_path["notocjk"] = fmt.Sprintf("%s/NotoSansCJK-Regular.ttf" ,skinpath)
for i:=10;i<41;i++ {
keyname := fmt.Sprintf("varela%d",i)
Fonts[ keyname ] = font.Font(fonts_path["varela"],i)
} }
Fonts["varela120"] = font.Font(fonts_path["varela"],120) Fonts["varela120"] = font.Font(fonts_path["varela"], 120)
for i:=10;i<26;i++ { for i := 10; i < 26; i++ {
keyname := fmt.Sprintf("veramono%d", i) keyname := fmt.Sprintf("veramono%d", i)
Fonts[keyname] = font.Font(fonts_path["veramono"],i) Fonts[keyname] = font.Font(fonts_path["veramono"], i)
} }
for i:= 10;i<28;i++ { for i := 10; i < 28; i++ {
keyname := fmt.Sprintf("notosansmono%d", i) keyname := fmt.Sprintf("notosansmono%d", i)
Fonts[keyname] = font.Font(fonts_path["noto"], i) Fonts[keyname] = font.Font(fonts_path["noto"], i)
} }
for i:=10;i<28;i++ { for i := 10; i < 28; i++ {
keyname := fmt.Sprintf("notosanscjk%d",i) keyname := fmt.Sprintf("notosanscjk%d", i)
Fonts[keyname] = font.Font(fonts_path["notocjk"],i) Fonts[keyname] = font.Font(fonts_path["notocjk"], i)
} }
// //
keys_def_init() keys_def_init()
//// global variables Init //// global variables Init
if MyIconPool == nil { if MyIconPool == nil {
MyIconPool = NewIconPool() MyIconPool = NewIconPool()
MyIconPool.Init() MyIconPool.Init()
} }
if MyLangManager == nil { if MyLangManager == nil {
MyLangManager = NewLangManager() MyLangManager = NewLangManager()
MyLangManager.Init() MyLangManager.Init()
} }
if MySkinManager == nil { if MySkinManager == nil {
MySkinManager = NewSkinManager() MySkinManager = NewSkinManager()
MySkinManager.Init() MySkinManager.Init()
} }
} }

77
sysgo/UI/above_all_patch.go
View File

@@ -1,76 +1,73 @@
package UI package UI
import( import (
"github.com/veandco/go-sdl2/sdl" "github.com/veandco/go-sdl2/sdl"
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/color"
"github.com/cuu/gogame/draw" "github.com/cuu/gogame/draw"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color"
) )
type AboveAllPatch struct { type AboveAllPatch struct {
Widget
Widget Text string
Text string FontObj *ttf.Font
FontObj *ttf.Font Color *color.Color
ValColor *color.Color
Color *color.Color CanvasHWND *sdl.Surface
ValColor *color.Color
CanvasHWND *sdl.Surface Icons map[string]IconItemInterface
Icons map[string]IconItemInterface Value int
Value int
} }
func NewAboveAllPatch() *AboveAllPatch { func NewAboveAllPatch() *AboveAllPatch {
p := &AboveAllPatch{} p := &AboveAllPatch{}
p.PosX = Width /2 p.PosX = Width / 2
p.PosY = Height /2 p.PosY = Height / 2
p.Width = 50 p.Width = 50
p.Height = 120 p.Height = 120
p.FontObj = Fonts["veramono20"] p.FontObj = Fonts["veramono20"]
p.Color = MySkinManager.GiveColor("Text") p.Color = MySkinManager.GiveColor("Text")
p.ValColor = MySkinManager.GiveColor("URL") p.ValColor = MySkinManager.GiveColor("URL")
p.Icons = make( map[string]IconItemInterface ) p.Icons = make(map[string]IconItemInterface)
p.Value = 0 p.Value = 0
return p return p
} }
func (self *AboveAllPatch) SetCanvasHWND( _canvashwnd *sdl.Surface) { func (self *AboveAllPatch) SetCanvasHWND(_canvashwnd *sdl.Surface) {
self.CanvasHWND = _canvashwnd self.CanvasHWND = _canvashwnd
} }
func (self *AboveAllPatch) Draw() { func (self *AboveAllPatch) Draw() {
start_rect := draw.MidRect(self.PosX,self.PosY,self.Width,self.Height,Width,Height) start_rect := draw.MidRect(self.PosX, self.PosY, self.Width, self.Height, Width, Height)
draw.AARoundRect(self.CanvasHWND,start_rect,self.Color,3,0,self.Color) draw.AARoundRect(self.CanvasHWND, start_rect, self.Color, 3, 0, self.Color)
if self.Value > 10 { if self.Value > 10 {
vol_height := int(float64(self.Height) * (float64(self.Value)/100.0)) vol_height := int(float64(self.Height) * (float64(self.Value) / 100.0))
dheight := self.Height - vol_height dheight := self.Height - vol_height
vol_rect := rect.Rect(self.PosX - self.Width/2,self.PosY - self.Height/2+dheight,self.Width,vol_height) vol_rect := rect.Rect(self.PosX-self.Width/2, self.PosY-self.Height/2+dheight, self.Width, vol_height)
draw.AARoundRect(self.CanvasHWND,&vol_rect,self.ValColor,3,0,self.ValColor) draw.AARoundRect(self.CanvasHWND, &vol_rect, self.ValColor, 3, 0, self.ValColor)
}else { } else {
vol_height := 10 vol_height := 10
dheight := self.Height - vol_height dheight := self.Height - vol_height
vol_rect := rect.Rect(self.PosX - self.Width/2,self.PosY - self.Height/2+dheight,self.Width,vol_height) vol_rect := rect.Rect(self.PosX-self.Width/2, self.PosY-self.Height/2+dheight, self.Width, vol_height)
draw.AARoundRect(self.CanvasHWND,&vol_rect,self.ValColor,3,0,self.ValColor) draw.AARoundRect(self.CanvasHWND, &vol_rect, self.ValColor, 3, 0, self.ValColor)
} }
} }

187
sysgo/UI/confirm_page.go
View File

@@ -4,146 +4,140 @@ import (
//"fmt" //"fmt"
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
// "github.com/cuu/gogame/surface" // "github.com/cuu/gogame/surface"
"github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
// "github.com/cuu/gogame/font" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect"
// "github.com/cuu/gogame/font"
"github.com/cuu/gogame/draw" "github.com/cuu/gogame/draw"
) )
type ListPageSelector struct { type ListPageSelector struct {
PageSelector PageSelector
BackgroundColor *color.Color BackgroundColor *color.Color
Parent *ConfirmPage Parent *ConfirmPage
} }
func NewListPageSelector() *ListPageSelector { func NewListPageSelector() *ListPageSelector {
p := &ListPageSelector{} p := &ListPageSelector{}
p.Width = Width p.Width = Width
p.BackgroundColor = &color.Color{131,199,219,255} p.BackgroundColor = &color.Color{131, 199, 219, 255}
return p return p
} }
func (self *ListPageSelector) Draw() { func (self *ListPageSelector) Draw() {
idx := self.Parent.GetPsIndex() idx := self.Parent.GetPsIndex()
mylist := self.Parent.MyList mylist := self.Parent.MyList
if idx > (len(mylist) -1) { if idx > (len(mylist) - 1) {
idx = len(mylist) idx = len(mylist)
if idx > 0 { if idx > 0 {
idx -= 1 idx -= 1
}else if idx == 0 { } else if idx == 0 {
return return
} }
} }
x,y := mylist[idx].Coord() x, y := mylist[idx].Coord()
_,h := mylist[idx].Size() _, h := mylist[idx].Size()
self.PosX = x self.PosX = x
self.PosY = y self.PosY = y
self.Height = h -3 self.Height = h - 3
canvas_ := self.Parent.GetCanvasHWND()
rect_ := rect.Rect(self.PosX, self.PosY, self.Width-4, self.Height)
draw.AARoundRect(canvas_,&rect_,self.BackgroundColor,4,0,self.BackgroundColor)
canvas_ := self.Parent.GetCanvasHWND()
rect_ := rect.Rect(self.PosX, self.PosY, self.Width-4, self.Height)
draw.AARoundRect(canvas_, &rect_, self.BackgroundColor, 4, 0, self.BackgroundColor)
} }
type ConfirmPage struct { type ConfirmPage struct {
Page Page
ListFont *ttf.Font ListFont *ttf.Font
FileName string FileName string
TrashDir string TrashDir string
ConfirmText string ConfirmText string
BGPosX int BGPosX int
BGPosY int BGPosY int
BGWidth int BGWidth int
BGHeight int BGHeight int
Icons map[string]IconItemInterface Icons map[string]IconItemInterface
MyList []LabelInterface
MyList []LabelInterface
} }
func NewConfirmPage() *ConfirmPage {
p := &ConfirmPage{}
p.ListFont = Fonts["veramono20"]
p.FootMsg = [5]string{"Nav", "", "", "Cancel", "Yes"}
p.ConfirmText = "Confirm?"
func NewConfirmPage() *ConfirmPage { return p
p := &ConfirmPage{}
p.ListFont = Fonts["veramono20"]
p.FootMsg = [5]string{"Nav","","","Cancel","Yes"}
p.ConfirmText ="Confirm?"
return p
} }
func (self *ConfirmPage) Reset() { func (self *ConfirmPage) Reset() {
self.MyList[0].SetText(self.ConfirmText) self.MyList[0].SetText(self.ConfirmText)
x,y := self.MyList[0].Coord() x, y := self.MyList[0].Coord()
w,h := self.MyList[0].Size() w, h := self.MyList[0].Size()
self.MyList[0].NewCoord( (self.Width - w)/2, (self.Height - h)/2) self.MyList[0].NewCoord((self.Width-w)/2, (self.Height-h)/2)
x,y = self.MyList[0].Coord() x, y = self.MyList[0].Coord()
self.BGPosX = x - 10 self.BGPosX = x - 10
self.BGPosY = y - 10 self.BGPosY = y - 10
self.BGWidth = w + 20 self.BGWidth = w + 20
self.BGHeight = h + 20 self.BGHeight = h + 20
} }
func (self *ConfirmPage) SnapMsg(msg string) { func (self *ConfirmPage) SnapMsg(msg string) {
self.MyList[0].SetText(msg) self.MyList[0].SetText(msg)
x,y := self.MyList[0].Coord() x, y := self.MyList[0].Coord()
w,h := self.MyList[0].Size() w, h := self.MyList[0].Size()
self.MyList[0].NewCoord( (self.Width - w )/2, (self.Height - h)/2 ) self.MyList[0].NewCoord((self.Width-w)/2, (self.Height-h)/2)
x, y = self.MyList[0].Coord() x, y = self.MyList[0].Coord()
self.BGPosX = x - 10 self.BGPosX = x - 10
self.BGPosY = y - 10 self.BGPosY = y - 10
self.BGWidth = w + 20 self.BGWidth = w + 20
self.BGHeight = h +20 self.BGHeight = h + 20
} }
func (self *ConfirmPage) Init() { func (self *ConfirmPage) Init() {
if self.Screen != nil { if self.Screen != nil {
self.PosX = self.Index * self.Screen.Width self.PosX = self.Index * self.Screen.Width
self.Width = self.Screen.Width self.Width = self.Screen.Width
self.Height = self.Screen.Height self.Height = self.Screen.Height
self.CanvasHWND = self.Screen.CanvasHWND self.CanvasHWND = self.Screen.CanvasHWND
ps := NewListPageSelector() ps := NewListPageSelector()
ps.Parent = self ps.Parent = self
self.Ps = ps self.Ps = ps
self.PsIndex = 0 self.PsIndex = 0
li := NewLabel() li := NewLabel()
li.SetCanvasHWND(self.CanvasHWND) li.SetCanvasHWND(self.CanvasHWND)
li.Init(self.ConfirmText,self.ListFont,nil) li.Init(self.ConfirmText, self.ListFont, nil)
li.PosX = (self.Width - li.Width)/2 li.PosX = (self.Width - li.Width) / 2
li.PosY = (self.Height - li.Height)/2 li.PosY = (self.Height - li.Height) / 2
self.BGPosX = li.PosX - 10 self.BGPosX = li.PosX - 10
self.BGPosY = li.PosY - 10 self.BGPosY = li.PosY - 10
self.BGWidth = li.Width + 20 self.BGWidth = li.Width + 20
self.BGHeight = li.Height + 20 self.BGHeight = li.Height + 20
self.MyList = append(self.MyList,li) self.MyList = append(self.MyList, li)
} }
} }
func (self *ConfirmPage) KeyDown(ev *event.Event) {
func (self *ConfirmPage) KeyDown( ev *event.Event ) {
if ev.Data["Key"] == CurKeys["A"] || ev.Data["Key"] == CurKeys["Menu"] { if ev.Data["Key"] == CurKeys["A"] || ev.Data["Key"] == CurKeys["Menu"] {
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
@@ -153,17 +147,16 @@ func (self *ConfirmPage) KeyDown( ev *event.Event ) {
} }
func (self *ConfirmPage) DrawBG() { func (self *ConfirmPage) DrawBG() {
rect_ := rect.Rect(self.BGPosX,self.BGPosY,self.BGWidth,self.BGHeight) rect_ := rect.Rect(self.BGPosX, self.BGPosY, self.BGWidth, self.BGHeight)
draw.Rect(self.CanvasHWND,&color.Color{255,255,255,255}, &rect_, 0) // SkinManager().GiveColor('White') draw.Rect(self.CanvasHWND, &color.Color{255, 255, 255, 255}, &rect_, 0) // SkinManager().GiveColor('White')
draw.Rect(self.CanvasHWND,&color.Color{83,83,83,255}, &rect_, 1)//SkinManager().GiveColor('Text') draw.Rect(self.CanvasHWND, &color.Color{83, 83, 83, 255}, &rect_, 1) //SkinManager().GiveColor('Text')
} }
func (self *ConfirmPage) Draw() { func (self *ConfirmPage) Draw() {
self.DrawBG() self.DrawBG()
for _,v := range self.MyList{ for _, v := range self.MyList {
v.Draw() v.Draw()
} }
self.Reset() self.Reset()
} }

16
sysgo/UI/constants.go
View File

@@ -1,18 +1,16 @@
package UI package UI
var ( var (
Width = 320 Width = 320
Height = 240 Height = 240
IconWidth = 80 IconWidth = 80
IconHeight = 80 IconHeight = 80
IconExt = ".sh" IconExt = ".sh"
ICON_TYPES = map[string]int{"Emulator":7,"FILE":6,"STAT":5,"NAV":4,"LETTER":3,"FUNC":2,"DIR":1,"EXE":0,"None":-1 } ICON_TYPES = map[string]int{"Emulator": 7, "FILE": 6, "STAT": 5, "NAV": 4, "LETTER": 3, "FUNC": 2, "DIR": 1, "EXE": 0, "None": -1}
ALIGN = map[string]int{ "HLeft":0,"HCenter":1,"HRight":2,"VMiddle":3,"SLeft":4,"VCenter":5,"SCenter":6} ALIGN = map[string]int{"HLeft": 0, "HCenter": 1, "HRight": 2, "VMiddle": 3, "SLeft": 4, "VCenter": 5, "SCenter": 6}
DT = 50
DT = 50
) )
var ( var (

202
sysgo/UI/counter_screen.go
View File

@@ -1,168 +1,162 @@
package UI package UI
import ( import (
"fmt" "fmt"
gotime "time" "github.com/veandco/go-sdl2/ttf"
"github.com/veandco/go-sdl2/ttf" gotime "time"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/surface" "github.com/cuu/gogame/surface"
"github.com/clockworkpi/LauncherGoDev/sysgo"
"github.com/clockworkpi/LauncherGoDev/sysgo"
) )
type CounterScreen struct { type CounterScreen struct {
FullScreen FullScreen
CounterFont *ttf.Font
TextFont1 *ttf.Font
TextFont2 *ttf.Font
CounterFont *ttf.Font TopLabel LabelInterface
TextFont1 *ttf.Font BottomLabel LabelInterface
TextFont2 *ttf.Font NumberLabel LabelInterface
BGColor *color.Color
FGColor *color.Color
TopLabel LabelInterface Counting bool
BottomLabel LabelInterface
NumberLabel LabelInterface
BGColor *color.Color
FGColor *color.Color
Counting bool Number int // 10
Number int // 10 inter_counter int //
inter_counter int //
TheTicker *gotime.Ticker
TickerStoped chan bool
TheTicker *gotime.Ticker
TickerStoped chan bool
} }
func NewCounterScreen() *CounterScreen { func NewCounterScreen() *CounterScreen {
p := &CounterScreen{} p := &CounterScreen{}
p.Width = Width p.Width = Width
p.Height = Height p.Height = Height
p.Number = 10 p.Number = 10
p.CounterFont = Fonts["varela120"] p.CounterFont = Fonts["varela120"]
p.TextFont1 = Fonts["varela15"] p.TextFont1 = Fonts["varela15"]
p.TextFont2 = Fonts["varela12"] p.TextFont2 = Fonts["varela12"]
p.BGColor = &color.Color{0,0,0,255} p.BGColor = &color.Color{0, 0, 0, 255}
p.FGColor = &color.Color{255,255,255,255} p.FGColor = &color.Color{255, 255, 255, 255}
return p return p
} }
func (self *CounterScreen ) Interval() { func (self *CounterScreen) Interval() {
for { for {
select { select {
case <-self.TheTicker.C: case <-self.TheTicker.C:
self.inter_counter += 1 self.inter_counter += 1
if self.Number == 0 { if self.Number == 0 {
self.Counting = false self.Counting = false
self.TheTicker.Stop() self.TheTicker.Stop()
fmt.Println("do the real shutdown") fmt.Println("do the real shutdown")
if sysgo.CurKeySet != "PC" { if sysgo.CurKeySet != "PC" {
cmdpath := "feh --bg-center sysgo/gameshell/wallpaper/seeyou.png;" cmdpath := "feh --bg-center sysgo/gameshell/wallpaper/seeyou.png;"
cmdpath = cmdpath + "sleep 3;" cmdpath = cmdpath + "sleep 3;"
cmdpath = cmdpath + "sudo halt -p" cmdpath = cmdpath + "sudo halt -p"
event.Post(RUNEVT,cmdpath) event.Post(RUNEVT, cmdpath)
} }
break break
} }
if self.inter_counter >= 2 { if self.inter_counter >= 2 {
self.Number -= 1 self.Number -= 1
if self.Number < 0 { if self.Number < 0 {
self.Number = 0 self.Number = 0
} }
fmt.Println("sub Number ", self.Number) fmt.Println("sub Number ", self.Number)
self.inter_counter = 0 self.inter_counter = 0
self.Draw() self.Draw()
self.SwapAndShow() self.SwapAndShow()
} }
case <- self.TickerStoped: case <-self.TickerStoped:
break break
} }
} }
} }
func (self *CounterScreen) StartCounter() { func (self *CounterScreen) StartCounter() {
if self.Counting == true { if self.Counting == true {
return return
} }
self.Number = 10 self.Number = 10
self.inter_counter = 0 self.inter_counter = 0
self.Counting = true self.Counting = true
self.TheTicker = gotime.NewTicker(500 * gotime.Millisecond) self.TheTicker = gotime.NewTicker(500 * gotime.Millisecond)
go self.Interval() go self.Interval()
} }
func (self *CounterScreen) StopCounter() { func (self *CounterScreen) StopCounter() {
if self.Counting == false { if self.Counting == false {
return return
} }
self.Counting = false self.Counting = false
self.Number = 0 self.Number = 0
self.inter_counter = 0 self.inter_counter = 0
self.TheTicker.Stop() self.TheTicker.Stop()
self.TickerStoped <- true self.TickerStoped <- true
} }
func (self *CounterScreen) Init() { func (self *CounterScreen) Init() {
self.CanvasHWND = surface.Surface(self.Width,self.Height) self.CanvasHWND = surface.Surface(self.Width, self.Height)
self.TopLabel = NewLabel() self.TopLabel = NewLabel()
self.TopLabel.SetCanvasHWND( self.CanvasHWND) self.TopLabel.SetCanvasHWND(self.CanvasHWND)
self.TopLabel.Init("System shutdown in", self.TextFont1,self.FGColor) self.TopLabel.Init("System shutdown in", self.TextFont1, self.FGColor)
self.BottomLabel = NewLabel() self.BottomLabel = NewLabel()
self.BottomLabel.SetCanvasHWND(self.CanvasHWND) self.BottomLabel.SetCanvasHWND(self.CanvasHWND)
self.BottomLabel.Init("Press any key to stop countdown",self.TextFont2,self.FGColor) self.BottomLabel.Init("Press any key to stop countdown", self.TextFont2, self.FGColor)
self.NumberLabel = NewLabel()
self.NumberLabel.SetCanvasHWND(self.CanvasHWND)
number_str := fmt.Sprintf("%d", self.Number)
self.NumberLabel.Init(number_str, self.CounterFont, self.FGColor)
self.NumberLabel = NewLabel() self.TickerStoped = make(chan bool, 1)
self.NumberLabel.SetCanvasHWND(self.CanvasHWND)
number_str := fmt.Sprintf("%d",self.Number)
self.NumberLabel.Init(number_str,self.CounterFont,self.FGColor)
self.TickerStoped = make(chan bool,1)
} }
func (self *CounterScreen) Draw() { func (self *CounterScreen) Draw() {
surface.Fill(self.CanvasHWND, self.BGColor) surface.Fill(self.CanvasHWND, self.BGColor)
self.TopLabel.NewCoord(Width/2,15) self.TopLabel.NewCoord(Width/2, 15)
self.TopLabel.DrawCenter(false) self.TopLabel.DrawCenter(false)
self.BottomLabel.NewCoord(Width/2, Height-15) self.BottomLabel.NewCoord(Width/2, Height-15)
self.BottomLabel.DrawCenter(false) self.BottomLabel.DrawCenter(false)
self.NumberLabel.NewCoord(Width/2,Height/2) self.NumberLabel.NewCoord(Width/2, Height/2)
number_str := fmt.Sprintf("%d",self.Number) number_str := fmt.Sprintf("%d", self.Number)
self.NumberLabel.SetText(number_str) self.NumberLabel.SetText(number_str)
self.NumberLabel.DrawCenter(false) self.NumberLabel.DrawCenter(false)
} }

94
sysgo/UI/delete_confirm_page.go
View File

@@ -1,77 +1,73 @@
package UI package UI
import( import (
"fmt" "fmt"
"os" "os"
"path/filepath" "path/filepath"
"strings" "strings"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/time" "github.com/cuu/gogame/time"
) )
type DeleteConfirmPage struct { type DeleteConfirmPage struct {
ConfirmPage ConfirmPage
} }
func NewDeleteConfirmPage() *DeleteConfirmPage { func NewDeleteConfirmPage() *DeleteConfirmPage {
p := &DeleteConfirmPage{} p := &DeleteConfirmPage{}
p.ListFont = Fonts["veramono20"] p.ListFont = Fonts["veramono20"]
p.FootMsg = [5]string{"Nav","","","Cancel","Yes"} p.FootMsg = [5]string{"Nav", "", "", "Cancel", "Yes"}
p.ConfirmText ="Confirm Delete ?" p.ConfirmText = "Confirm Delete ?"
return p
return p
} }
func (self *DeleteConfirmPage) SetTrashDir(d string) { func (self *DeleteConfirmPage) SetTrashDir(d string) {
self.TrashDir = d self.TrashDir = d
if IsDirectory(self.TrashDir)== false { if IsDirectory(self.TrashDir) == false {
panic("DeleteConfirmPage SetTrashDir errors") panic("DeleteConfirmPage SetTrashDir errors")
} }
} }
func (self *DeleteConfirmPage) SetFileName(fn string) { func (self *DeleteConfirmPage) SetFileName(fn string) {
self.FileName = fn self.FileName = fn
} }
func (self *DeleteConfirmPage) KeyDown(ev *event.Event) { func (self *DeleteConfirmPage) KeyDown(ev *event.Event) {
if ev.Data["Key"] == CurKeys["A"] || ev.Data["Key"] == CurKeys["Menu"] { if ev.Data["Key"] == CurKeys["A"] || ev.Data["Key"] == CurKeys["Menu"] {
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
if ev.Data["Key"] == CurKeys["B"] { if ev.Data["Key"] == CurKeys["B"] {
err := os.Remove(filepath.Join(self.TrashDir, filepath.Base(self.FileName))) err := os.Remove(filepath.Join(self.TrashDir, filepath.Base(self.FileName)))
if err != nil { if err != nil {
fmt.Println("DeleteConfirmPage os.Remove errors :",err) fmt.Println("DeleteConfirmPage os.Remove errors :", err)
} }
err = os.Rename(filepath.Base(self.FileName), filepath.Join(self.TrashDir, filepath.Base(self.FileName))) err = os.Rename(filepath.Base(self.FileName), filepath.Join(self.TrashDir, filepath.Base(self.FileName)))
if err != nil { if err != nil {
if strings.Contains(err.Error(),"exists" ) { if strings.Contains(err.Error(), "exists") {
self.Screen.MsgBox.SetText("Already Existed") self.Screen.MsgBox.SetText("Already Existed")
} else { } else {
self.Screen.MsgBox.SetText("Error") self.Screen.MsgBox.SetText("Error")
} }
self.Screen.MsgBox.Draw() self.Screen.MsgBox.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} else { } else {
self.SnapMsg("Deleting") self.SnapMsg("Deleting")
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
self.Reset() self.Reset()
time.BlockDelay(300) time.BlockDelay(300)
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
fmt.Println(self.FileName) fmt.Println(self.FileName)
} }
} }

365
sysgo/UI/download_process_page.go
View File

@@ -1,238 +1,232 @@
package UI package UI
import ( import (
"fmt" "fmt"
"os" "os"
"strings" "os/exec"
"path/filepath" "path/filepath"
"os/exec" "strings"
gotime "time" "net/url"
"net/url" gotime "time"
"github.com/cuu/grab"
"github.com/cuu/gogame/color"
"github.com/cuu/gogame/event"
"github.com/cuu/gogame/draw"
"github.com/cuu/gogame/color"
"github.com/cuu/gogame/draw"
"github.com/cuu/gogame/event"
"github.com/cuu/grab"
) )
type DownloadProcessPage struct { type DownloadProcessPage struct {
Page Page
URL string URL string
DST_DIR string DST_DIR string
Value int Value int
PngSize map[string][2]int PngSize map[string][2]int
Doing bool Doing bool
FileNameLabel LabelInterface FileNameLabel LabelInterface
SizeLabel LabelInterface SizeLabel LabelInterface
Icons map[string]IconItemInterface Icons map[string]IconItemInterface
URLColor *color.Color URLColor *color.Color
TextColor *color.Color TextColor *color.Color
TheTicker *gotime.Ticker TheTicker *gotime.Ticker
Downloader *grab.Client
resp *grab.Response
req *grab.Request
Downloader *grab.Client
resp *grab.Response
req *grab.Request
} }
func NewDownloadProcessPage() *DownloadProcessPage { func NewDownloadProcessPage() *DownloadProcessPage {
p := &DownloadProcessPage{} p := &DownloadProcessPage{}
p.FootMsg = [5]string{"Nav","","","Back",""} p.FootMsg = [5]string{"Nav", "", "", "Back", ""}
p.URLColor = &color.Color{51, 166, 255,255 } // URL p.URLColor = &color.Color{51, 166, 255, 255} // URL
p.TextColor = &color.Color{83,83,83,255 } // Text p.TextColor = &color.Color{83, 83, 83, 255} // Text
p.PngSize = make(map[string][2]int,0) p.PngSize = make(map[string][2]int, 0)
p.Icons=make(map[string]IconItemInterface) p.Icons = make(map[string]IconItemInterface)
return p return p
} }
func (self *DownloadProcessPage) Init() { func (self *DownloadProcessPage) Init() {
self.PosX = self.Index * self.Screen.Width self.PosX = self.Index * self.Screen.Width
self.Width = self.Screen.Width self.Width = self.Screen.Width
self.Height = self.Screen.Height self.Height = self.Screen.Height
self.CanvasHWND = self.Screen.CanvasHWND self.CanvasHWND = self.Screen.CanvasHWND
self.PngSize["bg"] = [2]int{48,79} self.PngSize["bg"] = [2]int{48, 79}
self.PngSize["needwifi_bg"] = [2]int{253,132} self.PngSize["needwifi_bg"] = [2]int{253, 132}
bgpng := NewIconItem() bgpng := NewIconItem()
bgpng.ImgSurf = MyIconPool.GetImgSurf("rom_download") bgpng.ImgSurf = MyIconPool.GetImgSurf("rom_download")
bgpng.MyType = ICON_TYPES["STAT"] bgpng.MyType = ICON_TYPES["STAT"]
bgpng.Parent = self bgpng.Parent = self
bgpng.Adjust(0,0,self.PngSize["bg"][0],self.PngSize["bg"][1],0) bgpng.Adjust(0, 0, self.PngSize["bg"][0], self.PngSize["bg"][1], 0)
self.Icons["bg"] = bgpng self.Icons["bg"] = bgpng
needwifi_bg := NewIconItem() needwifi_bg := NewIconItem()
needwifi_bg.ImgSurf = MyIconPool.GetImgSurf("needwifi_bg") needwifi_bg.ImgSurf = MyIconPool.GetImgSurf("needwifi_bg")
needwifi_bg.MyType = ICON_TYPES["STAT"] needwifi_bg.MyType = ICON_TYPES["STAT"]
needwifi_bg.Parent = self needwifi_bg.Parent = self
needwifi_bg.Adjust(0,0,self.PngSize["needwifi_bg"][0],self.PngSize["needwifi_bg"][1],0) needwifi_bg.Adjust(0, 0, self.PngSize["needwifi_bg"][0], self.PngSize["needwifi_bg"][1], 0)
self.Icons["needwifi_bg"] = needwifi_bg self.Icons["needwifi_bg"] = needwifi_bg
self.FileNameLabel = NewLabel() self.FileNameLabel = NewLabel()
self.FileNameLabel.SetCanvasHWND(self.CanvasHWND) self.FileNameLabel.SetCanvasHWND(self.CanvasHWND)
self.FileNameLabel.Init("", Fonts["varela12"],nil) self.FileNameLabel.Init("", Fonts["varela12"], nil)
self.SizeLabel = NewLabel() self.SizeLabel = NewLabel()
self.SizeLabel.SetCanvasHWND(self.CanvasHWND) self.SizeLabel.SetCanvasHWND(self.CanvasHWND)
self.SizeLabel.Init("0/0Kb",Fonts["varela12"],nil) self.SizeLabel.Init("0/0Kb", Fonts["varela12"], nil)
self.SizeLabel.SetColor( self.URLColor ) self.SizeLabel.SetColor(self.URLColor)
self.Downloader = grab.NewClient() self.Downloader = grab.NewClient()
} }
func (self *DownloadProcessPage) OnExitCb() { func (self *DownloadProcessPage) OnExitCb() {
//Stop Ticker and the Grab //Stop Ticker and the Grab
if self.TheTicker != nil { if self.TheTicker != nil {
self.TheTicker.Stop() self.TheTicker.Stop()
} }
} }
// should be in a gorotine // should be in a gorotine
func (self *DownloadProcessPage) UpdateProcessInterval() { func (self *DownloadProcessPage) UpdateProcessInterval() {
if self.Doing == true { if self.Doing == true {
return return
} }
self.Doing = true self.Doing = true
for { for {
gotime.Sleep(150 * gotime.Millisecond) gotime.Sleep(150 * gotime.Millisecond)
fmt.Printf(" transferred %v / %v bytes (%.2f%%)\n", fmt.Printf(" transferred %v / %v bytes (%.2f%%)\n",
self.resp.BytesComplete(), self.resp.BytesComplete(),
self.resp.Size, self.resp.Size,
100*self.resp.Progress()) 100*self.resp.Progress())
self.Value = int(100.0*self.resp.Progress()) self.Value = int(100.0 * self.resp.Progress())
total := float64(self.resp.Size)/1000.0/1000.0 total := float64(self.resp.Size) / 1000.0 / 1000.0
downloaded := float64(self.resp.BytesComplete())/1000.0/1000.0 downloaded := float64(self.resp.BytesComplete()) / 1000.0 / 1000.0
lb_str := fmt.Sprintf("%.2f/%.2fMb",downloaded,total) lb_str := fmt.Sprintf("%.2f/%.2fMb", downloaded, total)
self.SizeLabel.SetText(lb_str) self.SizeLabel.SetText(lb_str)
self.FileNameLabel.SetText(filepath.Base(self.resp.Filename)) self.FileNameLabel.SetText(filepath.Base(self.resp.Filename))
self.Screen.Draw()
self.Screen.SwapAndShow()
self.Screen.Draw() if self.resp.Progress() >= 1.0 {
self.Screen.SwapAndShow() // download is complete
fmt.Println("download is complete ", self.Value)
self.Value = 0
self.Doing = false
break
}
if self.resp.Progress() >= 1.0 { if self.Doing == false {
// download is complete break
fmt.Println("download is complete ",self.Value) }
self.Value = 0
self.Doing=false
break
}
if self.Doing == false {
break
}
}
self.Doing=false
if err := self.resp.Err(); err != nil {
self.DownloadErr()
fmt.Fprintf(os.Stderr, "Download failed: %v\n", err)
cmd := exec.Command("rm","-rf",self.resp.Filename)
cmd.Dir= self.DST_DIR
cmd.Run()
} }
fmt.Printf("Download saved to %s/%v \n",self.DST_DIR, self.resp.Filename) self.Doing = false
filename := filepath.Base(self.resp.Filename) if err := self.resp.Err(); err != nil {
self.DownloadErr()
fmt.Fprintf(os.Stderr, "Download failed: %v\n", err)
if strings.HasSuffix(filename,".zip") { cmd := exec.Command("rm", "-rf", self.resp.Filename)
cmd := exec.Command("unzip",filename) cmd.Dir = self.DST_DIR
cmd.Dir = self.DST_DIR cmd.Run()
cmd.Run() }
}else if strings.HasSuffix(filename,".zsync") {
cmd := exec.Command("rm","-rf",filename)
cmd.Dir = self.DST_DIR
cmd.Run()
}else if strings.HasSuffix(filename,".tar.gz") {
cmd := exec.Command("tar", "xf", filename)
cmd.Dir= self.DST_DIR
cmd.Run()
}
cmd := exec.Command("rm","-rf",filename) fmt.Printf("Download saved to %s/%v \n", self.DST_DIR, self.resp.Filename)
cmd.Dir = self.DST_DIR
cmd.Run()
self.DoneAndReturnUpLevel() filename := filepath.Base(self.resp.Filename)
if strings.HasSuffix(filename, ".zip") {
cmd := exec.Command("unzip", filename)
cmd.Dir = self.DST_DIR
cmd.Run()
} else if strings.HasSuffix(filename, ".zsync") {
cmd := exec.Command("rm", "-rf", filename)
cmd.Dir = self.DST_DIR
cmd.Run()
} else if strings.HasSuffix(filename, ".tar.gz") {
cmd := exec.Command("tar", "xf", filename)
cmd.Dir = self.DST_DIR
cmd.Run()
}
cmd := exec.Command("rm", "-rf", filename)
cmd.Dir = self.DST_DIR
cmd.Run()
self.DoneAndReturnUpLevel()
} }
func (self *DownloadProcessPage) DownloadErr() { func (self *DownloadProcessPage) DownloadErr() {
self.Screen.MsgBox.SetText("Download Failed") self.Screen.MsgBox.SetText("Download Failed")
self.Screen.MsgBox.Draw() self.Screen.MsgBox.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
func (self *DownloadProcessPage) DoneAndReturnUpLevel() { func (self *DownloadProcessPage) DoneAndReturnUpLevel() {
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
self.Screen.Draw() self.Screen.Draw()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
func (self *DownloadProcessPage) StartDownload(_url, dst_dir string) {
if self.Screen.IsWifiConnectedNow() == false {
return
}
func (self *DownloadProcessPage) StartDownload(_url,dst_dir string) { _, err := url.ParseRequestURI(_url)
if err == nil && IsDirectory(dst_dir) {
self.URL = _url
self.DST_DIR = dst_dir
} else {
if self.Screen.IsWifiConnectedNow() == false { self.Screen.MsgBox.SetText("Invaid")
return self.Screen.MsgBox.Draw()
} self.Screen.SwapAndShow()
fmt.Println("DownloadProcessPage StartDownload Invalid ", err)
return
}
_, err := url.ParseRequestURI(_url) if self.Doing == false {
if err == nil && IsDirectory(dst_dir) { self.req, _ = grab.NewRequest(self.DST_DIR, _url)
self.URL = _url fmt.Printf("Downloading %v...\n", self.req.URL())
self.DST_DIR = dst_dir self.resp = self.Downloader.Do(self.req)
}else{ fmt.Printf(" %v\n", self.resp.HTTPResponse.Status)
self.UpdateProcessInterval()
self.Screen.MsgBox.SetText("Invaid") }
self.Screen.MsgBox.Draw()
self.Screen.SwapAndShow()
fmt.Println("DownloadProcessPage StartDownload Invalid ",err)
return
}
if self.Doing == false {
self.req, _ = grab.NewRequest(self.DST_DIR, _url)
fmt.Printf("Downloading %v...\n", self.req.URL())
self.resp = self.Downloader.Do(self.req)
fmt.Printf(" %v\n", self.resp.HTTPResponse.Status)
self.UpdateProcessInterval()
}
} }
func (self *DownloadProcessPage) StopDownload() { func (self *DownloadProcessPage) StopDownload() {
self.Doing=false self.Doing = false
} }
func (self *DownloadProcessPage) KeyDown( ev *event.Event) { func (self *DownloadProcessPage) KeyDown(ev *event.Event) {
if ev.Data["Key"] == CurKeys["A"] || ev.Data["Key"] == CurKeys["Menu"] { if ev.Data["Key"] == CurKeys["A"] || ev.Data["Key"] == CurKeys["Menu"] {
self.StopDownload() self.StopDownload()
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
self.Screen.Draw() self.Screen.Draw()
@@ -243,49 +237,48 @@ func (self *DownloadProcessPage) KeyDown( ev *event.Event) {
func (self *DownloadProcessPage) Draw() { func (self *DownloadProcessPage) Draw() {
self.ClearCanvas() self.ClearCanvas()
if self.Screen.IsWifiConnectedNow() == false { if self.Screen.IsWifiConnectedNow() == false {
self.Icons["needwifi_bg"].NewCoord(self.Width/2,self.Height/2) self.Icons["needwifi_bg"].NewCoord(self.Width/2, self.Height/2)
self.Icons["needwifi_bg"].Draw() self.Icons["needwifi_bg"].Draw()
return return
} }
self.Icons["bg"].NewCoord(self.Width/2,self.Height/2-20) self.Icons["bg"].NewCoord(self.Width/2, self.Height/2-20)
self.Icons["bg"].Draw() self.Icons["bg"].Draw()
percent := self.Value percent := self.Value
if percent < 10 { if percent < 10 {
percent = 10 percent = 10
} }
rect_ := draw.MidRect(self.Width/2,self.Height/2+33,170,17, Width,Height) rect_ := draw.MidRect(self.Width/2, self.Height/2+33, 170, 17, Width, Height)
draw.AARoundRect(self.CanvasHWND,rect_, draw.AARoundRect(self.CanvasHWND, rect_,
&color.Color{228,228,228,255},5,0,&color.Color{228,228,228,255}) &color.Color{228, 228, 228, 255}, 5, 0, &color.Color{228, 228, 228, 255})
rect2_ := draw.MidRect(self.Width/2, self.Height/2+33, int(170.0*(float64(percent)/100.0)), 17, Width, Height)
rect2_ := draw.MidRect( self.Width/2,self.Height/2+33,int(170.0*(float64(percent)/100.0)),17, Width,Height ) rect2_.X = rect_.X
rect2_.Y = rect_.Y
rect2_.X = rect_.X draw.AARoundRect(self.CanvasHWND, rect2_,
rect2_.Y = rect_.Y &color.Color{131, 199, 219, 255}, 5, 0, &color.Color{131, 199, 219, 255})
draw.AARoundRect(self.CanvasHWND,rect2_, w, h := self.FileNameLabel.Size()
&color.Color{131, 199, 219,255},5,0,&color.Color{131, 199, 219,255})
w,h := self.FileNameLabel.Size() rect3_ := draw.MidRect(self.Width/2, self.Height/2+53, w, h, Width, Height)
rect3_ := draw.MidRect(self.Width/2,self.Height/2+53,w, h,Width,Height) w, h = self.SizeLabel.Size()
w, h = self.SizeLabel.Size() rect4_ := draw.MidRect(self.Width/2, self.Height/2+70, w, h, Width, Height)
rect4_ := draw.MidRect(self.Width/2,self.Height/2+70,w, h,Width,Height) self.FileNameLabel.NewCoord(int(rect3_.X), int(rect3_.Y))
self.FileNameLabel.Draw()
self.FileNameLabel.NewCoord(int(rect3_.X),int(rect3_.Y)) self.SizeLabel.NewCoord(int(rect4_.X), int(rect4_.Y))
self.FileNameLabel.Draw() self.SizeLabel.Draw()
self.SizeLabel.NewCoord(int(rect4_.X),int(rect4_.Y))
self.SizeLabel.Draw()
} }

11
sysgo/UI/events.go
View File

@@ -1,10 +1,9 @@
package UI package UI
const ( const (
RUNEVT=1 RUNEVT = 1
RESTARTUI=2 RESTARTUI = 2
RUNSH=3 RUNSH = 3
RUNSYS=4 RUNSYS = 4
POWEROPT=5 POWEROPT = 5
) )

65
sysgo/UI/folder_stack.go
View File

@@ -1,46 +1,45 @@
package UI package UI
import ( import (
"sync" "sync"
) )
type FolderStack struct { type FolderStack struct {
lock *sync.Mutex lock *sync.Mutex
head *element head *element
Size int Size int
RootPath string RootPath string
} }
func (stk *FolderStack) Push(data interface{}) { func (stk *FolderStack) Push(data interface{}) {
stk.lock.Lock() stk.lock.Lock()
element := new(element) element := new(element)
element.data = data element.data = data
temp := stk.head temp := stk.head
element.next = temp element.next = temp
stk.head = element stk.head = element
stk.Size++ stk.Size++
stk.lock.Unlock() stk.lock.Unlock()
} }
func (stk *FolderStack) Pop() interface{} { func (stk *FolderStack) Pop() interface{} {
if stk.head == nil { if stk.head == nil {
return nil return nil
} }
stk.lock.Lock() stk.lock.Lock()
r := stk.head.data r := stk.head.data
stk.head = stk.head.next stk.head = stk.head.next
stk.Size-- stk.Size--
stk.lock.Unlock() stk.lock.Unlock()
return r return r
} }
func (stk *FolderStack) SetRootPath(path string) { func (stk *FolderStack) SetRootPath(path string) {
stk.RootPath = path stk.RootPath = path
} }
func (stk *FolderStack) Length() int { func (stk *FolderStack) Length() int {
@@ -48,16 +47,16 @@ func (stk *FolderStack) Length() int {
} }
func (stk *FolderStack) Last() string { func (stk *FolderStack) Last() string {
idx := stk.Length() -1 idx := stk.Length() - 1
if idx < 0 { if idx < 0 {
return stk.RootPath return stk.RootPath
}else { } else {
return stk.head.data.(string) return stk.head.data.(string)
} }
} }
func NewFolderStack() *FolderStack { func NewFolderStack() *FolderStack {
stk := new(FolderStack) stk := new(FolderStack)
stk.lock = &sync.Mutex{} stk.lock = &sync.Mutex{}
return stk return stk
} }

9
sysgo/UI/fonts.go
View File

@@ -1,8 +1,7 @@
package UI package UI
import(
"github.com/veandco/go-sdl2/ttf" import (
"github.com/veandco/go-sdl2/ttf"
) )
var Fonts map[string]*ttf.Font var Fonts map[string]*ttf.Font

113
sysgo/UI/foot_bar.go
View File

@@ -2,18 +2,17 @@ package UI
import ( import (
"fmt" "fmt"
// "io/ioutil" // "io/ioutil"
"log" "log"
"github.com/veandco/go-sdl2/sdl" "github.com/veandco/go-sdl2/sdl"
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/draw"
"github.com/cuu/gogame/font"
"github.com/cuu/gogame/image"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/surface" "github.com/cuu/gogame/surface"
"github.com/cuu/gogame/draw"
"github.com/cuu/gogame/image"
"github.com/cuu/gogame/font"
) )
var FootBar_BarHeight = 20 var FootBar_BarHeight = 20
@@ -33,7 +32,7 @@ func NewFootBarIconItem() *FootBarIconItem {
return m return m
} }
func (self *FootBarIconItem) Adjust(x,y,w,h,at int) { func (self *FootBarIconItem) Adjust(x, y, w, h, at int) {
self.PosX = x self.PosX = x
self.PosY = y self.PosY = y
self.Width = w self.Width = w
@@ -45,54 +44,52 @@ func (self *FootBarIconItem) Adjust(x,y,w,h,at int) {
} }
self.CreateImgSurf() self.CreateImgSurf()
// self.AdjustLinkPage() // self.AdjustLinkPage()
} }
func (self *FootBarIconItem) TotalWidth() int { func (self *FootBarIconItem) TotalWidth() int {
lab_w,_ := self.Label.Size() lab_w, _ := self.Label.Size()
return self.Width + lab_w return self.Width + lab_w
} }
func (self *FootBarIconItem) Draw() { func (self *FootBarIconItem) Draw() {
if self.Label != nil { if self.Label != nil {
lab_w,lab_h:= self.Label.Size() lab_w, lab_h := self.Label.Size()
if self.Align == ALIGN["VCenter"] { if self.Align == ALIGN["VCenter"] {
self.Label.NewCoord( self.PosX - lab_w/2, self.PosY+ self.Height/2+12) self.Label.NewCoord(self.PosX-lab_w/2, self.PosY+self.Height/2+12)
} else if self.Align == ALIGN["HLeft"] { } else if self.Align == ALIGN["HLeft"] {
self.Label.NewCoord( self.PosX + self.Width/2+3, self.PosY - lab_h/2) self.Label.NewCoord(self.PosX+self.Width/2+3, self.PosY-lab_h/2)
} }
self.Label.Draw() self.Label.Draw()
} }
if self.ImgSurf != nil { if self.ImgSurf != nil {
portion := rect.Rect(0, self.IconIndex*self.IconHeight, self.IconWidth, self.IconHeight) portion := rect.Rect(0, self.IconIndex*self.IconHeight, self.IconWidth, self.IconHeight)
surface.Blit(self.Parent.CanvasHWND, self.ImgSurf, draw.MidRect(self.PosX,self.PosY, self.Width,self.Height, Width,Height),&portion) surface.Blit(self.Parent.CanvasHWND, self.ImgSurf, draw.MidRect(self.PosX, self.PosY, self.Width, self.Height, Width, Height), &portion)
}else { } else {
fmt.Println("self.ImgSurf is nil ") fmt.Println("self.ImgSurf is nil ")
} }
} }
type FootBar struct { type FootBar struct {
Widget Widget
BarHeight int BarHeight int
BorderWidth int BorderWidth int
CanvasHWND *sdl.Surface CanvasHWND *sdl.Surface
HWND *sdl.Surface HWND *sdl.Surface
Icons map[string]IconItemInterface Icons map[string]IconItemInterface
IconWidth int IconWidth int
IconHeight int IconHeight int
LabelFont *ttf.Font LabelFont *ttf.Font
State string State string
SkinManager *SkinManager SkinManager *SkinManager
icon_base_path string icon_base_path string
} }
func NewFootBar() *FootBar { func NewFootBar() *FootBar {
f := &FootBar{} f := &FootBar{}
f.Width = Width f.Width = Width
@@ -113,37 +110,36 @@ func NewFootBar() *FootBar {
return f return f
} }
func (self *FootBar) ReadFootBarIcons( icondir string) { func (self *FootBar) ReadFootBarIcons(icondir string) {
if FileExists(icondir) == false && IsDirectory(icondir) == false { if FileExists(icondir) == false && IsDirectory(icondir) == false {
return return
} }
keynames := [5]string{"nav","x","y","a","b"} keynames := [5]string{"nav", "x", "y", "a", "b"}
share_surf := image.Load(self.icon_base_path+"footbar.png") share_surf := image.Load(self.icon_base_path + "footbar.png")
for i,v := range keynames { // share_surf contains same number of image pieces of keynames for i, v := range keynames { // share_surf contains same number of image pieces of keynames
it := NewFootBarIconItem() it := NewFootBarIconItem()
it.MyType = ICON_TYPES["NAV"] it.MyType = ICON_TYPES["NAV"]
it.Parent = self it.Parent = self
it.ImgSurf = share_surf it.ImgSurf = share_surf
it.Align = ALIGN["HLeft"] // (X)Text it.Align = ALIGN["HLeft"] // (X)Text
it.IconWidth = self.IconWidth it.IconWidth = self.IconWidth
it.IconHeight =self.IconHeight it.IconHeight = self.IconHeight
it.AddLabel("game", self.LabelFont) it.AddLabel("game", self.LabelFont)
it.Adjust( self.IconWidth/2+i*self.IconWidth, self.IconHeight/2+2, self.IconWidth,self.IconHeight,0) it.Adjust(self.IconWidth/2+i*self.IconWidth, self.IconHeight/2+2, self.IconWidth, self.IconHeight, 0)
it.IconIndex = i it.IconIndex = i
if val, ok := self.Icons[v]; ok { if val, ok := self.Icons[v]; ok {
if val.(*FootBarIconItem).ImgSurf != nil { if val.(*FootBarIconItem).ImgSurf != nil {
val.(*FootBarIconItem).ImgSurf.Free() val.(*FootBarIconItem).ImgSurf.Free()
} }
} }
self.Icons[v] = it self.Icons[v] = it
} }
} }
func (self *FootBar) Init(main_screen *MainScreen) { func (self *FootBar) Init(main_screen *MainScreen) {
self.CanvasHWND = surface.Surface(self.Width,self.Height) self.CanvasHWND = surface.Surface(self.Width, self.Height)
self.HWND = main_screen.HWND self.HWND = main_screen.HWND
self.SkinManager = main_screen.SkinManager self.SkinManager = main_screen.SkinManager
@@ -156,7 +152,7 @@ func (self *FootBar) Init(main_screen *MainScreen) {
round_corners.MyType = ICON_TYPES["STAT"] round_corners.MyType = ICON_TYPES["STAT"]
round_corners.Parent = self round_corners.Parent = self
round_corners.ImgSurf = MyIconPool.GetImgSurf("roundcorners") round_corners.ImgSurf = MyIconPool.GetImgSurf("roundcorners")
round_corners.Adjust(0,0,10,10,0) round_corners.Adjust(0, 0, 10, 10, 0)
self.Icons["round_corners"] = round_corners self.Icons["round_corners"] = round_corners
@@ -171,21 +167,21 @@ func (self *FootBar) ResetNavText() {
func (self *FootBar) UpdateNavText(texts string) { func (self *FootBar) UpdateNavText(texts string) {
self.State = "tips" self.State = "tips"
// my_text := font.Render(self.LabelFont, texts, true,self.SkinManager.GiveColor("Text"),nil) // my_text := font.Render(self.LabelFont, texts, true,self.SkinManager.GiveColor("Text"),nil)
left_width := self.Width - 18 left_width := self.Width - 18
final_piece := "" final_piece := ""
for i,_ := range texts { for i, _ := range texts {
text_ := texts[:i+1] text_ := texts[:i+1]
my_text := font.Render(self.LabelFont, text_, true, self.SkinManager.GiveColor("Text"),nil) my_text := font.Render(self.LabelFont, text_, true, self.SkinManager.GiveColor("Text"), nil)
final_piece = text_ final_piece = text_
if int(my_text.W) >= left_width { if int(my_text.W) >= left_width {
my_text.Free() my_text.Free()
break break
} }
my_text.Free() my_text.Free()
} }
fmt.Printf("finalpiece %s\n", final_piece) fmt.Printf("finalpiece %s\n", final_piece)
@@ -195,28 +191,27 @@ func (self *FootBar) UpdateNavText(texts string) {
} }
func (self *FootBar) SetLabelTexts( texts [5]string) { func (self *FootBar) SetLabelTexts(texts [5]string) {
keynames := [5]string{"nav","x","y","a","b"} keynames := [5]string{"nav", "x", "y", "a", "b"}
if len(texts) < 5 { if len(texts) < 5 {
log.Fatal("SetLabelTexts texts length error") log.Fatal("SetLabelTexts texts length error")
return return
} }
for idx,x := range keynames { for idx, x := range keynames {
self.Icons[x].SetLabelText(texts[idx]) self.Icons[x].SetLabelText(texts[idx])
} }
} }
func (self *FootBar) ClearCanvas() { func (self *FootBar) ClearCanvas() {
surface.Fill( self.CanvasHWND, self.SkinManager.GiveColor("White")) surface.Fill(self.CanvasHWND, self.SkinManager.GiveColor("White"))
self.Icons["round_corners"].NewCoord(5,self.Height-5) self.Icons["round_corners"].NewCoord(5, self.Height-5)
self.Icons["round_corners"].SetIconIndex(2) self.Icons["round_corners"].SetIconIndex(2)
self.Icons["round_corners"].Draw() self.Icons["round_corners"].Draw()
self.Icons["round_corners"].NewCoord(self.Width-5, self.Height-5)
self.Icons["round_corners"].NewCoord(self.Width - 5,self.Height - 5)
self.Icons["round_corners"].SetIconIndex(3) self.Icons["round_corners"].SetIconIndex(3)
self.Icons["round_corners"].Draw() self.Icons["round_corners"].Draw()
@@ -232,26 +227,26 @@ func (self *FootBar) Draw() {
if self.State == "normal" { if self.State == "normal" {
_w := 0 _w := 0
for i,x := range []string{"b","a","y","x"} { for i, x := range []string{"b", "a", "y", "x"} {
if self.Icons[x].GetLabelText() != "" { if self.Icons[x].GetLabelText() != "" {
if i== 0 { if i == 0 {
_w += self.Icons[x].TotalWidth() _w += self.Icons[x].TotalWidth()
}else { } else {
_w += self.Icons[x].TotalWidth()+5 _w += self.Icons[x].TotalWidth() + 5
} }
start_x := self.Width - _w start_x := self.Width - _w
start_y := self.IconHeight/2+2 start_y := self.IconHeight/2 + 2
self.Icons[x].NewCoord(start_x, start_y) self.Icons[x].NewCoord(start_x, start_y)
self.Icons[x].Draw() self.Icons[x].Draw()
} }
} }
} }
draw.Line(self.CanvasHWND, self.SkinManager.GiveColor("Line"),0,0,Width,0,self.BorderWidth) draw.Line(self.CanvasHWND, self.SkinManager.GiveColor("Line"), 0, 0, Width, 0, self.BorderWidth)
if self.HWND != nil { if self.HWND != nil {
rect_ := rect.Rect(self.PosX, Height - self.Height, Width, self.BarHeight) rect_ := rect.Rect(self.PosX, Height-self.Height, Width, self.BarHeight)
surface.Blit(self.HWND,self.CanvasHWND, &rect_,nil) surface.Blit(self.HWND, self.CanvasHWND, &rect_, nil)
} }
} }

34
sysgo/UI/fullscreen.go
View File

@@ -1,40 +1,36 @@
package UI package UI
import ( import (
"github.com/cuu/gogame/surface"
"github.com/veandco/go-sdl2/sdl"
"github.com/veandco/go-sdl2/sdl" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/surface"
"github.com/cuu/gogame/rect"
) )
type FullScreen struct { type FullScreen struct {
Widget Widget
CanvasHWND *sdl.Surface CanvasHWND *sdl.Surface
HWND *sdl.Surface HWND *sdl.Surface
} }
func NewFullScreen() *FullScreen { func NewFullScreen() *FullScreen {
p := &FullScreen{} p := &FullScreen{}
p.Width = Width p.Width = Width
p.Height = Height p.Height = Height
return p return p
} }
func (self *FullScreen) SwapAndShow() { func (self *FullScreen) SwapAndShow() {
if self.HWND !=nil { if self.HWND != nil {
rect_ := rect.Rect(self.PosX,self.PosY,self.Width,self.Height) rect_ := rect.Rect(self.PosX, self.PosY, self.Width, self.Height)
surface.Blit(self.HWND,self.CanvasHWND,&rect_,nil) surface.Blit(self.HWND, self.CanvasHWND, &rect_, nil)
SwapAndShow() SwapAndShow()
} }
} }
func (self *FullScreen) Draw() { func (self *FullScreen) Draw() {
} }

189
sysgo/UI/hier_list_item.go
View File

@@ -1,161 +1,156 @@
package UI package UI
import( import (
"fmt" "fmt"
"path/filepath" "io/ioutil"
"strings" "path/filepath"
"io/ioutil" "strings"
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/surface"
"github.com/cuu/gogame/draw"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
"github.com/cuu/gogame/draw"
"github.com/cuu/gogame/surface"
) )
type ListItemIcon struct { type ListItemIcon struct {
IconItem IconItem
} }
func NewListItemIcon() *ListItemIcon { func NewListItemIcon() *ListItemIcon {
p := &ListItemIcon{} p := &ListItemIcon{}
p.MyType = ICON_TYPES["EXE"] p.MyType = ICON_TYPES["EXE"]
p.Align = ALIGN["VCenter"] p.Align = ALIGN["VCenter"]
p.Width = 18 p.Width = 18
p.Height = 18 p.Height = 18
return p return p
} }
func (self *ListItemIcon) Draw() { func (self *ListItemIcon) Draw() {
_,h := self.Parent.Size() _, h := self.Parent.Size()
rect_ := rect.Rect(self.PosX,self.PosY+(h-self.Height)/2,self.Width,self.Height) rect_ := rect.Rect(self.PosX, self.PosY+(h-self.Height)/2, self.Width, self.Height)
surface.Blit(self.Parent.GetCanvasHWND(), self.ImgSurf,&rect_,nil) surface.Blit(self.Parent.GetCanvasHWND(), self.ImgSurf, &rect_, nil)
} }
/// [..] [.] /// [..] [.]
type HierListItem struct { type HierListItem struct {
ListItem ListItem
MyType int MyType int
Path string Path string
Active bool Active bool
Playing bool Playing bool
} }
var HierListItemDefaultHeight = 32 var HierListItemDefaultHeight = 32
func NewHierListItem() *HierListItem { func NewHierListItem() *HierListItem {
p := &HierListItem{} p := &HierListItem{}
p.Labels = make(map[string]LabelInterface) p.Labels = make(map[string]LabelInterface)
p.Icons = make( map[string]IconItemInterface) p.Icons = make(map[string]IconItemInterface)
p.Fonts = make(map[string]*ttf.Font) p.Fonts = make(map[string]*ttf.Font)
p.MyType = ICON_TYPES["EXE"] p.MyType = ICON_TYPES["EXE"]
p.Height = HierListItemDefaultHeight p.Height = HierListItemDefaultHeight
p.Width = 0 p.Width = 0
return p return p
} }
func (self *HierListItem) IsFile() bool { func (self *HierListItem) IsFile() bool {
if self.MyType == ICON_TYPES["FILE"] { if self.MyType == ICON_TYPES["FILE"] {
return true return true
} }
return false return false
} }
func (self *HierListItem) IsDir() bool { func (self *HierListItem) IsDir() bool {
if self.MyType == ICON_TYPES["DIR"] { if self.MyType == ICON_TYPES["DIR"] {
return true return true
} }
return false return false
} }
func (self *HierListItem) Init(text string) { func (self *HierListItem) Init(text string) {
l := NewLabel() l := NewLabel()
l.PosX = 20 l.PosX = 20
if self.Parent == nil { if self.Parent == nil {
fmt.Println("Parent nil") fmt.Println("Parent nil")
return return
} }
l.SetCanvasHWND(self.Parent.GetCanvasHWND()) l.SetCanvasHWND(self.Parent.GetCanvasHWND())
if self.IsDir() == true || self.IsFile() == true { if self.IsDir() == true || self.IsFile() == true {
self.Path = text self.Path = text
} }
label_text := filepath.Base(text) label_text := filepath.Base(text)
ext:= filepath.Ext(text) ext := filepath.Ext(text)
if ext != "" { if ext != "" {
alias_file := strings.Replace(text,ext,"",-1) + ".alias" alias_file := strings.Replace(text, ext, "", -1) + ".alias"
if FileExists(alias_file) == true { if FileExists(alias_file) == true {
b, err := ioutil.ReadFile(alias_file) b, err := ioutil.ReadFile(alias_file)
if err != nil { if err != nil {
fmt.Print(err) fmt.Print(err)
}else { } else {
label_text = string(b) label_text = string(b)
} }
} }
} }
if self.IsDir() == true { if self.IsDir() == true {
l.Init(label_text, self.Fonts["normal"],nil) l.Init(label_text, self.Fonts["normal"], nil)
}else { } else {
l.Init(label_text,self.Fonts["normal"],nil) l.Init(label_text, self.Fonts["normal"], nil)
} }
self.Labels["Text"] = l self.Labels["Text"] = l
} }
func (self *HierListItem) Draw() { func (self *HierListItem) Draw() {
x,y := self.Labels["Text"].Coord() x, y := self.Labels["Text"].Coord()
_,h := self.Labels["Text"].Size() _, h := self.Labels["Text"].Size()
if self.Path != "[..]" { if self.Path != "[..]" {
self.Labels["Text"].NewCoord(23,y) self.Labels["Text"].NewCoord(23, y)
}else { } else {
self.Labels["Text"].NewCoord(3,y) self.Labels["Text"].NewCoord(3, y)
} }
x,y = self.Labels["Text"].Coord() x, y = self.Labels["Text"].Coord()
self.Labels["Text"].NewCoord(x, self.PosY + (self.Height-h)/2) self.Labels["Text"].NewCoord(x, self.PosY+(self.Height-h)/2)
self.Labels["Text"].Draw() self.Labels["Text"].Draw()
/*
w,h := self.Parent.Icons["sys"].Size()
/* if self.IsDir() == true && self.Path != "[..]" {
w,h := self.Parent.Icons["sys"].Size() self.Parent.Icons["sys"].IconIndex = 0
self.Parent.Icons["sys"].NewCoord(self.PosX+12,self.PosY+(self.Height-h)/2+h/2)
self.Parent.Icons["sys"].Draw()
}
if self.IsDir() == true && self.Path != "[..]" { if self.IsFile() == true {
self.Parent.Icons["sys"].IconIndex = 0 self.Parent.Icons["sys"].IconIndex = 1
self.Parent.Icons["sys"].NewCoord(self.PosX+12,self.PosY+(self.Height-h)/2+h/2) self.Parent.Icons["sys"].NewCoord(self.PosX+12,self.PosY+(self.Height-h)/2+h/2)
self.Parent.Icons["sys"].Draw() self.Parent.Icons["sys"].Draw()
} }
*/
if self.IsFile() == true { draw.Line(self.Parent.GetCanvasHWND(), &color.Color{169, 169, 169, 255},
self.Parent.Icons["sys"].IconIndex = 1 self.PosX, self.PosY+self.Height-1, self.PosX+self.Width, self.PosY+self.Height-1, 1)
self.Parent.Icons["sys"].NewCoord(self.PosX+12,self.PosY+(self.Height-h)/2+h/2)
self.Parent.Icons["sys"].Draw()
}
*/
draw.Line(self.Parent.GetCanvasHWND(),&color.Color{169,169,169,255},
self.PosX,self.PosY+self.Height-1,self.PosX+self.Width,self.PosY+self.Height-1,1)
} }

152
sysgo/UI/icon_item.go
View File

@@ -6,23 +6,22 @@ import (
"github.com/veandco/go-sdl2/sdl" "github.com/veandco/go-sdl2/sdl"
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/surface"
"github.com/cuu/gogame/draw"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
"github.com/cuu/gogame/draw"
"github.com/cuu/gogame/image" "github.com/cuu/gogame/image"
"github.com/cuu/gogame/rect"
"github.com/cuu/gogame/surface"
"github.com/cuu/gogame/transform" "github.com/cuu/gogame/transform"
"github.com/cuu/gogame/utils" "github.com/cuu/gogame/utils"
"github.com/cuu/gogame/rect"
) )
type IconItemInterface interface { type IconItemInterface interface {
Init(x,y,w,h,at int) Init(x, y, w, h, at int)
Adjust(x,y,w,h,at int) Adjust(x, y, w, h, at int)
GetCmdPath() string GetCmdPath() string
SetCmdPath( path string) SetCmdPath(path string)
SetMyType( thetype int ) SetMyType(thetype int)
GetMyType() int GetMyType() int
GetIconIndex() int GetIconIndex() int
@@ -31,16 +30,16 @@ type IconItemInterface interface {
GetIndex() int GetIndex() int
SetIndex(i int) SetIndex(i int)
SetParent( p interface{} ) SetParent(p interface{})
SetLabelColor(col *color.Color) SetLabelColor(col *color.Color)
SetLabelText(text string) SetLabelText(text string)
GetLabelText() string GetLabelText() string
Coord() (int,int) Coord() (int, int)
NewCoord(x,y int) NewCoord(x, y int)
Size() (int,int) Size() (int, int)
NewSize(w,h int) NewSize(w, h int)
TotalWidth() int TotalWidth() int
@@ -58,28 +57,26 @@ type IconItemInterface interface {
GetFileName() string GetFileName() string
Draw() Draw()
DrawTopLeft() DrawTopLeft()
} }
type IconItem struct { type IconItem struct {
Widget Widget
ImageName string ImageName string
ImgSurf *sdl.Surface ImgSurf *sdl.Surface
Parent PageInterface Parent PageInterface
Index int Index int
IconIndex int IconIndex int
MyType int MyType int
CmdPath string CmdPath string
CmdInvoke PluginInterface CmdInvoke PluginInterface
LinkPage PageInterface LinkPage PageInterface
Label LabelInterface Label LabelInterface
Align int Align int
AnimationTime int AnimationTime int
FileName string FileName string
} }
func NewIconItem() *IconItem { func NewIconItem() *IconItem {
i := &IconItem{} i := &IconItem{}
i.MyType = ICON_TYPES["EXE"] i.MyType = ICON_TYPES["EXE"]
@@ -89,8 +86,7 @@ func NewIconItem() *IconItem {
return i return i
} }
func (self *IconItem) Init(x, y, w, h, at int) {
func (self *IconItem) Init(x,y,w,h,at int) {
self.PosX = x self.PosX = x
self.PosY = y self.PosY = y
self.Width = w self.Width = w
@@ -98,7 +94,7 @@ func (self *IconItem) Init(x,y,w,h,at int) {
self.AnimationTime = at self.AnimationTime = at
} }
func (self *IconItem) Adjust(x,y,w,h,at int) { func (self *IconItem) Adjust(x, y, w, h, at int) {
self.PosX = x self.PosX = x
self.PosY = y self.PosY = y
self.Width = w self.Width = w
@@ -114,16 +110,15 @@ func (self *IconItem) Adjust(x,y,w,h,at int) {
} }
func (self *IconItem) GetCmdPath() string { func (self *IconItem) GetCmdPath() string {
return self.CmdPath return self.CmdPath
} }
func (self *IconItem) SetCmdPath( path string) { func (self *IconItem) SetCmdPath(path string) {
self.CmdPath = path self.CmdPath = path
} }
func (self *IconItem) SetMyType( thetype int ) { func (self *IconItem) SetMyType(thetype int) {
self.MyType = thetype self.MyType = thetype
} }
@@ -135,7 +130,7 @@ func (self *IconItem) GetIconIndex() int {
return self.IconIndex return self.IconIndex
} }
func (self *IconItem) SetIconIndex( idx int) { func (self *IconItem) SetIconIndex(idx int) {
self.IconIndex = idx self.IconIndex = idx
} }
@@ -147,7 +142,7 @@ func (self *IconItem) SetIndex(i int) {
self.Index = i self.Index = i
} }
func (self *IconItem) SetParent(p interface{} ) { func (self *IconItem) SetParent(p interface{}) {
self.Parent = p.(PageInterface) self.Parent = p.(PageInterface)
} }
@@ -163,11 +158,11 @@ func (self *IconItem) SetLabelText(text string) {
self.Label.SetText(text) self.Label.SetText(text)
} }
func (self *IconItem) Coord() (int,int) { func (self *IconItem) Coord() (int, int) {
return self.PosX,self.PosY return self.PosX, self.PosY
} }
func (self *IconItem) NewCoord(x,y int) { func (self *IconItem) NewCoord(x, y int) {
self.PosX = x self.PosX = x
self.PosY = y self.PosY = y
} }
@@ -176,17 +171,17 @@ func (self *IconItem) TotalWidth() int {
return 0 return 0
} }
func (self *IconItem) Size() (int,int) { func (self *IconItem) Size() (int, int) {
return self.Width,self.Height return self.Width, self.Height
} }
func (self *IconItem) AddLabel(text string, fontobj *ttf.Font) { func (self *IconItem) AddLabel(text string, fontobj *ttf.Font) {
if self.Label == nil { if self.Label == nil {
l:= NewLabel() l := NewLabel()
self.Label = l self.Label = l
} }
self.Label.Init(text,fontobj,nil) self.Label.Init(text, fontobj, nil)
} }
@@ -200,21 +195,20 @@ func (self *IconItem) AdjustLinkPage() {
self.LinkPage.SetAlign(ALIGN["SLeft"]) self.LinkPage.SetAlign(ALIGN["SLeft"])
self.LinkPage.UpdateIconNumbers() self.LinkPage.UpdateIconNumbers()
self.LinkPage.SetScreen(self.Parent.GetScreen()) self.LinkPage.SetScreen(self.Parent.GetScreen())
self.LinkPage.SetCanvasHWND( (self.Parent.GetScreen()).CanvasHWND ) self.LinkPage.SetCanvasHWND((self.Parent.GetScreen()).CanvasHWND)
self.LinkPage.SetFootMsg([5]string{ "Nav.","","","Back","Enter" } ) self.LinkPage.SetFootMsg([5]string{"Nav.", "", "", "Back", "Enter"})
if self.LinkPage.GetAlign() == ALIGN["HLeft"] { if self.LinkPage.GetAlign() == ALIGN["HLeft"] {
self.LinkPage.AdjustHLeftAlign() self.LinkPage.AdjustHLeftAlign()
}else if self.LinkPage.GetAlign() == ALIGN["SLeft"] { } else if self.LinkPage.GetAlign() == ALIGN["SLeft"] {
self.LinkPage.AdjustSAutoLeftAlign() self.LinkPage.AdjustSAutoLeftAlign()
if self.LinkPage.GetIconNumbers() > 1 { if self.LinkPage.GetIconNumbers() > 1 {
self.LinkPage.SetPsIndex(1) self.LinkPage.SetPsIndex(1)
self.LinkPage.SetIconIndex ( 1 ) self.LinkPage.SetIconIndex(1)
} }
} }
} }
} }
func (self *IconItem) GetImgSurf() *sdl.Surface { func (self *IconItem) GetImgSurf() *sdl.Surface {
return self.ImgSurf return self.ImgSurf
} }
@@ -223,18 +217,17 @@ func (self *IconItem) SetImgSurf(newsurf *sdl.Surface) {
self.ImgSurf = newsurf self.ImgSurf = newsurf
} }
func (self *IconItem) CreateImgSurf() { func (self *IconItem) CreateImgSurf() {
if self.ImgSurf == nil && self.ImageName != "" { if self.ImgSurf == nil && self.ImageName != "" {
self.ImgSurf = image.Load(self.ImageName) self.ImgSurf = image.Load(self.ImageName)
if int(self.ImgSurf.W) > IconWidth || int(self.ImgSurf.H) > IconHeight { if int(self.ImgSurf.W) > IconWidth || int(self.ImgSurf.H) > IconHeight {
self.ImgSurf = transform.Scale(self.ImgSurf,IconWidth,IconHeight) self.ImgSurf = transform.Scale(self.ImgSurf, IconWidth, IconHeight)
} }
} }
} }
func (self *IconItem) ChangeImgSurfColor(col *color.Color) { func (self *IconItem) ChangeImgSurfColor(col *color.Color) {
utils.ColorSurface(self.ImgSurf,col) utils.ColorSurface(self.ImgSurf, col)
} }
func (self *IconItem) Clear() { func (self *IconItem) Clear() {
@@ -246,65 +239,64 @@ func (self *IconItem) GetCmdInvoke() PluginInterface {
} }
func (self *IconItem) GetFileName() string { func (self *IconItem) GetFileName() string {
return self.FileName return self.FileName
} }
func (self *IconItem) DrawTopLeft() { func (self *IconItem) DrawTopLeft() {
if self.Parent == nil { if self.Parent == nil {
fmt.Println("Error: IconItem Draw Parent nil") fmt.Println("Error: IconItem Draw Parent nil")
return return
} }
parent_x,parent_y := self.Parent.Coord() parent_x, parent_y := self.Parent.Coord()
if self.Label != nil { if self.Label != nil {
// lab_x,lab_y := self.Label.Coord() // lab_x,lab_y := self.Label.Coord()
lab_w,lab_h:= self.Label.Size() lab_w, lab_h := self.Label.Size()
if self.Align == ALIGN["VCenter"] { if self.Align == ALIGN["VCenter"] {
// fmt.Println("IconItem Draw VCenter:",lab_w,lab_h,self.Label.GetText()) // fmt.Println("IconItem Draw VCenter:",lab_w,lab_h,self.Label.GetText())
self.Label.NewCoord( self.PosX - lab_w/2 + parent_x, self.PosY + self.Height/2+6+parent_y) self.Label.NewCoord(self.PosX-lab_w/2+parent_x, self.PosY+self.Height/2+6+parent_y)
}else if self.Align == ALIGN["HLeft"] { } else if self.Align == ALIGN["HLeft"] {
self.Label.NewCoord( self.PosX + self.Width/2+3+parent_x, self.PosY - lab_h/2 + parent_y) self.Label.NewCoord(self.PosX+self.Width/2+3+parent_x, self.PosY-lab_h/2+parent_y)
} }
self.Label.Draw() self.Label.Draw()
} }
if self.ImgSurf != nil { if self.ImgSurf != nil {
rect_ := rect.Rect( self.PosX+parent_x,self.PosY+parent_y, self.Width,self.Height ) // DIFF rect_ := rect.Rect(self.PosX+parent_x, self.PosY+parent_y, self.Width, self.Height) // DIFF
surface.Blit(self.Parent.GetCanvasHWND(), self.ImgSurf,&rect_,nil) surface.Blit(self.Parent.GetCanvasHWND(), self.ImgSurf, &rect_, nil)
} }
} }
func (self *IconItem) Draw() { func (self *IconItem) Draw() {
if self.Parent == nil { if self.Parent == nil {
fmt.Println("Error: IconItem Draw Parent nil") fmt.Println("Error: IconItem Draw Parent nil")
return return
} }
parent_x,parent_y := self.Parent.Coord() parent_x, parent_y := self.Parent.Coord()
if self.Label != nil { if self.Label != nil {
// lab_x,lab_y := self.Label.Coord() // lab_x,lab_y := self.Label.Coord()
lab_w,lab_h:= self.Label.Size() lab_w, lab_h := self.Label.Size()
if self.Align == ALIGN["VCenter"] { if self.Align == ALIGN["VCenter"] {
// fmt.Println("IconItem Draw VCenter:",lab_w,lab_h,self.Label.GetText()) // fmt.Println("IconItem Draw VCenter:",lab_w,lab_h,self.Label.GetText())
self.Label.NewCoord( self.PosX - lab_w/2 + parent_x, self.PosY + self.Height/2+6+parent_y) self.Label.NewCoord(self.PosX-lab_w/2+parent_x, self.PosY+self.Height/2+6+parent_y)
}else if self.Align == ALIGN["HLeft"] { } else if self.Align == ALIGN["HLeft"] {
self.Label.NewCoord( self.PosX + self.Width/2+3+parent_x, self.PosY - lab_h/2 + parent_y) self.Label.NewCoord(self.PosX+self.Width/2+3+parent_x, self.PosY-lab_h/2+parent_y)
} }
self.Label.Draw() self.Label.Draw()
} }
if self.ImgSurf != nil { if self.ImgSurf != nil {
surface.Blit(self.Parent.GetCanvasHWND(), self.ImgSurf,draw.MidRect(self.PosX + parent_x, self.PosY + parent_y, surface.Blit(self.Parent.GetCanvasHWND(), self.ImgSurf, draw.MidRect(self.PosX+parent_x, self.PosY+parent_y,
self.Width,self.Height, Width, Height),nil) self.Width, self.Height, Width, Height), nil)
} }
} }

24
sysgo/UI/icon_pool.go
View File

@@ -9,37 +9,35 @@ import (
"github.com/veandco/go-sdl2/sdl" "github.com/veandco/go-sdl2/sdl"
"github.com/cuu/gogame/image" "github.com/cuu/gogame/image"
) )
type IconPool struct { type IconPool struct {
GameShellIconPath string GameShellIconPath string
Icons map[string]*sdl.Surface Icons map[string]*sdl.Surface
} }
func NewIconPool() *IconPool { func NewIconPool() *IconPool {
i := &IconPool{} i := &IconPool{}
i.GameShellIconPath = SkinMap("sysgo/gameshell/icons/") i.GameShellIconPath = SkinMap("sysgo/gameshell/icons/")
i.Icons = make( map[string]*sdl.Surface ) i.Icons = make(map[string]*sdl.Surface)
return i return i
} }
func (self *IconPool) Init() { func (self *IconPool) Init() {
files,err := ioutil.ReadDir(self.GameShellIconPath) files, err := ioutil.ReadDir(self.GameShellIconPath)
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
return return
} }
for _,f := range files { for _, f := range files {
if f.IsDir() { if f.IsDir() {
//pass //pass
}else { } else {
if strings.HasSuffix(f.Name(),".png") == true { if strings.HasSuffix(f.Name(), ".png") == true {
keyname := strings.Split(f.Name(),".") keyname := strings.Split(f.Name(), ".")
if len(keyname) > 1 { if len(keyname) > 1 {
self.Icons[ keyname[0] ] = image.Load( self.GameShellIconPath+ "/"+f.Name() ) self.Icons[keyname[0]] = image.Load(self.GameShellIconPath + "/" + f.Name())
} }
} }
} }
@@ -47,7 +45,7 @@ func (self *IconPool) Init() {
} }
func (self *IconPool) GetImgSurf(keyname string) *sdl.Surface { func (self *IconPool) GetImgSurf(keyname string) *sdl.Surface {
if _,ok := self.Icons[keyname]; ok { if _, ok := self.Icons[keyname]; ok {
return self.Icons[keyname] return self.Icons[keyname]
} else { } else {
fmt.Println("IconPool GetImgSurf ", keyname, " failed") fmt.Println("IconPool GetImgSurf ", keyname, " failed")
@@ -56,5 +54,5 @@ func (self *IconPool) GetImgSurf(keyname string) *sdl.Surface {
} }
var MyIconPool *IconPool var MyIconPool *IconPool
// = NewIconPool()
// = NewIconPool()

65
sysgo/UI/info_page_list_item.go
View File

@@ -3,72 +3,71 @@ package UI
import ( import (
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/draw"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
"github.com/cuu/gogame/draw"
) )
var DefaultInfoPageListItemHeight = 30 var DefaultInfoPageListItemHeight = 30
type InfoPageListItem struct { type InfoPageListItem struct {
ListItem ListItem
Flag string Flag string
ReadOnly bool ReadOnly bool
} }
func NewInfoPageListItem() *InfoPageListItem { func NewInfoPageListItem() *InfoPageListItem {
p := &InfoPageListItem{} p := &InfoPageListItem{}
p.Height = DefaultInfoPageListItemHeight p.Height = DefaultInfoPageListItemHeight
p.ReadOnly = false p.ReadOnly = false
p.Labels = make(map[string]LabelInterface) p.Labels = make(map[string]LabelInterface)
p.Icons = make( map[string]IconItemInterface) p.Icons = make(map[string]IconItemInterface)
p.Fonts = make(map[string]*ttf.Font) p.Fonts = make(map[string]*ttf.Font)
return p return p
} }
func (self *InfoPageListItem) SetSmallText(text string) { func (self *InfoPageListItem) SetSmallText(text string) {
l := NewLabel() l := NewLabel()
l.PosX = 40 l.PosX = 40
l.SetCanvasHWND(self.Parent.GetCanvasHWND()) l.SetCanvasHWND(self.Parent.GetCanvasHWND())
l.Init(text,self.Fonts["small"],nil) l.Init(text, self.Fonts["small"], nil)
self.Labels["Small"] = l self.Labels["Small"] = l
} }
func (self *InfoPageListItem) Init(text string ) { func (self *InfoPageListItem) Init(text string) {
l := NewLabel() l := NewLabel()
l.PosX = 10 l.PosX = 10
l.SetCanvasHWND(self.Parent.GetCanvasHWND()) l.SetCanvasHWND(self.Parent.GetCanvasHWND())
l.Init(text,self.Fonts["normal"],nil) l.Init(text, self.Fonts["normal"], nil)
self.Labels["Text"] = l self.Labels["Text"] = l
} }
func (self *InfoPageListItem) Draw() { func (self *InfoPageListItem) Draw() {
if self.ReadOnly == true { if self.ReadOnly == true {
self.Labels["Text"].SetColor(&color.Color{130,130,130,255} ) //SkinManager().GiveColor("ReadOnlyText") self.Labels["Text"].SetColor(&color.Color{130, 130, 130, 255}) //SkinManager().GiveColor("ReadOnlyText")
}else { } else {
self.Labels["Text"].SetColor(&color.Color{83,83,83,255} ) // SkinManager().GiveColor("Text") self.Labels["Text"].SetColor(&color.Color{83, 83, 83, 255}) // SkinManager().GiveColor("Text")
} }
x,_ := self.Labels["Text"].Coord() x, _ := self.Labels["Text"].Coord()
w,h := self.Labels["Text"].Size() w, h := self.Labels["Text"].Size()
self.Labels["Text"].NewCoord( x + self.PosX, self.PosY + (self.Height - h)/2 ) self.Labels["Text"].NewCoord(x+self.PosX, self.PosY+(self.Height-h)/2)
self.Labels["Text"].Draw() self.Labels["Text"].Draw()
self.Labels["Text"].NewCoord(x, self.PosY + (self.Height - h)/2 ) self.Labels["Text"].NewCoord(x, self.PosY+(self.Height-h)/2)
if _, ok := self.Labels["Small"]; ok { if _, ok := self.Labels["Small"]; ok {
x,_ = self.Labels["Small"].Coord() x, _ = self.Labels["Small"].Coord()
w,h = self.Labels["Small"].Size() w, h = self.Labels["Small"].Size()
self.Labels["Small"].NewCoord( self.Width - w - 5 , self.PosY + (self.Height - h)/2 ) self.Labels["Small"].NewCoord(self.Width-w-5, self.PosY+(self.Height-h)/2)
self.Labels["Small"].Draw() self.Labels["Small"].Draw()
} }
canvas_ := self.Parent.GetCanvasHWND() canvas_ := self.Parent.GetCanvasHWND()
draw.Line(canvas_, &color.Color{169,169,169,255}, self.PosX, self.PosY+self.Height -1,self.PosX + self.Width, self.PosY+self.Height -1 ,1) draw.Line(canvas_, &color.Color{169, 169, 169, 255}, self.PosX, self.PosY+self.Height-1, self.PosX+self.Width, self.PosY+self.Height-1, 1)
} }

50
sysgo/UI/info_page_selector.go
View File

@@ -1,53 +1,49 @@
package UI package UI
import ( import (
//"fmt" //"fmt"
// "github.com/veandco/go-sdl2/ttf" // "github.com/veandco/go-sdl2/ttf"
// "github.com/cuu/gogame/surface" // "github.com/cuu/gogame/surface"
// "github.com/cuu/gogame/event" // "github.com/cuu/gogame/event"
"github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
"github.com/cuu/gogame/draw" "github.com/cuu/gogame/draw"
"github.com/cuu/gogame/rect"
) )
type InfoPageSelector struct { type InfoPageSelector struct {
PageSelector PageSelector
BackgroundColor *color.Color BackgroundColor *color.Color
} }
func NewInfoPageSelector() *InfoPageSelector { func NewInfoPageSelector() *InfoPageSelector {
p := &InfoPageSelector{} p := &InfoPageSelector{}
p.Width = Width p.Width = Width
p.BackgroundColor = &color.Color{131,199,219,255} //SkinManager().GiveColor('Front') p.BackgroundColor = &color.Color{131, 199, 219, 255} //SkinManager().GiveColor('Front')
return p return p
} }
func (self *InfoPageSelector) AnimateDraw(x2, y2 int) { func (self *InfoPageSelector) AnimateDraw(x2, y2 int) {
//pass //pass
} }
func (self *InfoPageSelector) Draw() { func (self *InfoPageSelector) Draw() {
idx := self.Parent.GetPsIndex() idx := self.Parent.GetPsIndex()
mylist := self.Parent.GetMyList() mylist := self.Parent.GetMyList()
if idx < len(mylist) { if idx < len(mylist) {
_,y := mylist[idx].Coord() _, y := mylist[idx].Coord()
_,h := mylist[idx].Size() _, h := mylist[idx].Size()
self.PosY = y + 1
self.Height = h - 3
self.PosY = y+1 canvas_ := self.Parent.GetCanvasHWND()
self.Height = h-3 rect_ := rect.Rect(self.PosX, self.PosY, self.Width-4, self.Height)
canvas_ := self.Parent.GetCanvasHWND() draw.AARoundRect(canvas_, &rect_, self.BackgroundColor, 4, 0, self.BackgroundColor)
rect_ := rect.Rect(self.PosX,self.PosY,self.Width-4, self.Height) }
draw.AARoundRect(canvas_,&rect_,self.BackgroundColor,4,0,self.BackgroundColor)
}
} }

204
sysgo/UI/keyboard.go
View File

@@ -1,19 +1,18 @@
package UI package UI
import ( import (
"fmt" "fmt"
"strings" "strings"
"github.com/cuu/gogame/font"
"github.com/cuu/gogame/draw"
"github.com/cuu/gogame/surface"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
"github.com/cuu/gogame/draw"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/cuu/gogame/font"
"github.com/cuu/gogame/surface"
"github.com/clockworkpi/LauncherGoDev/sysgo/easings" "github.com/clockworkpi/LauncherGoDev/sysgo/easings"
) )
//sysgo/UI/keyboard_keys.layout //sysgo/UI/keyboard_keys.layout
type KeyboardIcon struct { type KeyboardIcon struct {
TextItem // IconItem->TextItem->KeyboardIcon TextItem // IconItem->TextItem->KeyboardIcon
@@ -22,7 +21,7 @@ type KeyboardIcon struct {
func NewKeyboardIcon() *KeyboardIcon { func NewKeyboardIcon() *KeyboardIcon {
p := &KeyboardIcon{} p := &KeyboardIcon{}
p.Color = &color.Color{83,83,83,255}//SkinManager().GiveColor('Text') p.Color = &color.Color{83, 83, 83, 255} //SkinManager().GiveColor('Text')
p.MyType = ICON_TYPES["NAV"] p.MyType = ICON_TYPES["NAV"]
@@ -31,20 +30,18 @@ func NewKeyboardIcon() *KeyboardIcon {
func (self *KeyboardIcon) Draw() { func (self *KeyboardIcon) Draw() {
rect_ := draw.MidRect(self.PosX,self.PosY,self.Width,self.Height,Width,Height) rect_ := draw.MidRect(self.PosX, self.PosY, self.Width, self.Height, Width, Height)
surface.Blit(self.Parent.GetCanvasHWND(),self.ImgSurf,rect_,nil) surface.Blit(self.Parent.GetCanvasHWND(), self.ImgSurf, rect_, nil)
} }
type KeyboardSelector struct { type KeyboardSelector struct {
PageSelector PageSelector
Parent *Keyboard Parent *Keyboard
} }
func NewKeyboardSelector() *KeyboardSelector {
func NewKeyboardSelector() * KeyboardSelector {
p := &KeyboardSelector{} p := &KeyboardSelector{}
return p return p
@@ -53,19 +50,19 @@ func NewKeyboardSelector() * KeyboardSelector {
func (self *KeyboardSelector) Draw() { func (self *KeyboardSelector) Draw() {
sec_idx := self.Parent.SectionIndex sec_idx := self.Parent.SectionIndex
row_idx := self.Parent.RowIndex row_idx := self.Parent.RowIndex
idx := self.Parent.PsIndex idx := self.Parent.PsIndex
x, y := self.Parent.SecsKeys[sec_idx][row_idx][idx].Coord() x, y := self.Parent.SecsKeys[sec_idx][row_idx][idx].Coord()
w, h := self.Parent.SecsKeys[sec_idx][row_idx][idx].Size() w, h := self.Parent.SecsKeys[sec_idx][row_idx][idx].Size()
rect_ := draw.MidRect(x,y,w+6,h+1,self.Parent.Width,self.Parent.Height) rect_ := draw.MidRect(x, y, w+6, h+1, self.Parent.Width, self.Parent.Height)
if rect_.W <= 0 || rect_.H <= 0 { if rect_.W <= 0 || rect_.H <= 0 {
return return
} }
color_ := &color.Color{126,206,244,255} color_ := &color.Color{126, 206, 244, 255}
draw.AARoundRect(self.Parent.CanvasHWND,rect_,color_,3,0,color_) draw.AARoundRect(self.Parent.CanvasHWND, rect_, color_, 3, 0, color_)
} }
@@ -77,8 +74,8 @@ type Keyboard struct {
SecsKeys map[int][][]TextItemInterface SecsKeys map[int][][]TextItemInterface
SectionNumbers int SectionNumbers int
SectionIndex int SectionIndex int
Icons map[string]IconItemInterface Icons map[string]IconItemInterface
KeyboardLayoutFile string ///sysgo/UI/keyboard_keys.layout KeyboardLayoutFile string ///sysgo/UI/keyboard_keys.layout
@@ -105,30 +102,28 @@ func NewKeyboard() *Keyboard {
p.SectionNumbers = 3 p.SectionNumbers = 3
p.SectionIndex = 1 p.SectionIndex = 1
p.Icons = make( map[string]IconItemInterface ) p.Icons = make(map[string]IconItemInterface)
p.LeftOrRight = 1 p.LeftOrRight = 1
p.RowIndex = 0 p.RowIndex = 0
p.FootMsg = [5]string{"Nav.","ABC","Done","Backspace","Enter"} p.FootMsg = [5]string{"Nav.", "ABC", "Done", "Backspace", "Enter"}
p.Secs = make(map[int][][]string) p.Secs = make(map[int][][]string)
p.SecsKeys = make(map[int][][]TextItemInterface) p.SecsKeys = make(map[int][][]TextItemInterface)
p.KeyboardLayoutFile = "sysgo/UI/keyboard_keys.layout" p.KeyboardLayoutFile = "sysgo/UI/keyboard_keys.layout"
return p return p
} }
func (self *Keyboard) ReadLayoutFile( fname string) { func (self *Keyboard) ReadLayoutFile(fname string) {
LayoutIndex := 0 LayoutIndex := 0
content ,err := ReadLines(fname) content, err := ReadLines(fname)
Assert(err) Assert(err)
@@ -162,17 +157,15 @@ func (self *Keyboard) ReadLayoutFile( fname string) {
} }
} }
func (self *Keyboard) SetPassword(pwd string) { func (self *Keyboard) SetPassword(pwd string) {
pwd_seq_list := strings.SplitAfter(pwd,"") pwd_seq_list := strings.SplitAfter(pwd, "")
self.Textarea.ResetMyWords() self.Textarea.ResetMyWords()
for _,v := range pwd_seq_list { for _, v := range pwd_seq_list {
self.Textarea.AppendText(v) self.Textarea.AppendText(v)
} }
} }
func (self *Keyboard) Init() { func (self *Keyboard) Init() {
self.CanvasHWND = self.Screen.CanvasHWND self.CanvasHWND = self.Screen.CanvasHWND
self.ReadLayoutFile(self.KeyboardLayoutFile) //assign to self.Secs self.ReadLayoutFile(self.KeyboardLayoutFile) //assign to self.Secs
@@ -187,26 +180,26 @@ func (self *Keyboard) Init() {
word_margin := 15 word_margin := 15
secs_zero := strings.Join(self.Secs[0][0],"") secs_zero := strings.Join(self.Secs[0][0], "")
fw,_:= font.Size(fontobj,secs_zero) fw, _ := font.Size(fontobj, secs_zero)
start_x := (self.Width - fw - len(self.Secs[0][0])*word_margin)/2+word_margin/2 start_x := (self.Width-fw-len(self.Secs[0][0])*word_margin)/2 + word_margin/2
start_y := 0 start_y := 0
// cnt := 0 // cnt := 0
for i:=0; i < self.SectionNumbers; i++ { for i := 0; i < self.SectionNumbers; i++ {
self.SecsKeys[i] = [][]TextItemInterface{} self.SecsKeys[i] = [][]TextItemInterface{}
for j:=0; j < len(self.Secs[i]); j++ { for j := 0; j < len(self.Secs[i]); j++ {
self.SecsKeys[i] = append(self.SecsKeys[i],[]TextItemInterface{}) self.SecsKeys[i] = append(self.SecsKeys[i], []TextItemInterface{})
secs_ij := strings.Join(self.Secs[i][j],"") secs_ij := strings.Join(self.Secs[i][j], "")
fw,_ := font.Size(fontobj,secs_ij) fw, _ := font.Size(fontobj, secs_ij)
start_x = (self.Width-fw- len(self.Secs[i][j])*word_margin)/2+word_margin/2 start_x = (self.Width-fw-len(self.Secs[i][j])*word_margin)/2 + word_margin/2
start_x = start_x + i*self.Width start_x = start_x + i*self.Width
start_y = 84 + j * (word_margin+14) start_y = 84 + j*(word_margin+14)
for _,val := range self.Secs[i][j] { for _, val := range self.Secs[i][j] {
ti := NewTextItem() ti := NewTextItem()
ti.FontObj = fontobj ti.FontObj = fontobj
ti.Parent = self ti.Parent = self
@@ -216,23 +209,23 @@ func (self *Keyboard) Init() {
it.ImgSurf = MyIconPool.GetImgSurf(val) it.ImgSurf = MyIconPool.GetImgSurf(val)
it.Parent = self it.Parent = self
it.Str = val it.Str = val
it.Init(start_x+surface.GetWidth(it.ImgSurf)/2,start_y,surface.GetWidth(it.ImgSurf),surface.GetHeight(it.ImgSurf),0) it.Init(start_x+surface.GetWidth(it.ImgSurf)/2, start_y, surface.GetWidth(it.ImgSurf), surface.GetHeight(it.ImgSurf), 0)
self.SecsKeys[i][j] = append(self.SecsKeys[i][j],it) self.SecsKeys[i][j] = append(self.SecsKeys[i][j], it)
self.IconNumbers += 1 self.IconNumbers += 1
start_x = start_x + surface.GetWidth(it.ImgSurf)+word_margin start_x = start_x + surface.GetWidth(it.ImgSurf) + word_margin
}else { } else {
if val == "_S" { if val == "_S" {
val = "Space" val = "Space"
ti.FontObj = Fonts["veramono15"] ti.FontObj = Fonts["veramono15"]
ti.Bold = true ti.Bold = true
} }
cur_alpha_w,cur_alpha_h := font.Size(ti.FontObj,val) cur_alpha_w, cur_alpha_h := font.Size(ti.FontObj, val)
ti.Init(start_x + cur_alpha_w/2,start_y,cur_alpha_w,cur_alpha_h,0) ti.Init(start_x+cur_alpha_w/2, start_y, cur_alpha_w, cur_alpha_h, 0)
ti.Str = val ti.Str = val
start_x = start_x + cur_alpha_w+word_margin // prepare for next alphabet start_x = start_x + cur_alpha_w + word_margin // prepare for next alphabet
self.SecsKeys[i][j] = append(self.SecsKeys[i][j],ti) self.SecsKeys[i][j] = append(self.SecsKeys[i][j], ti)
} }
} }
} }
@@ -253,8 +246,8 @@ func (self *Keyboard) Init() {
ps := NewKeyboardSelector() ps := NewKeyboardSelector()
ps.Parent = self ps.Parent = self
ps.Init(start_x,start_y,25,25,128) ps.Init(start_x, start_y, 25, 25, 128)
ps.OnShow = true ps.OnShow = true
self.Ps = ps self.Ps = ps
self.PsIndex = 0 self.PsIndex = 0
@@ -264,13 +257,13 @@ func (self *Keyboard) Init() {
func (self *Keyboard) SelectUpChar() { func (self *Keyboard) SelectUpChar() {
sec_idx := self.SectionIndex sec_idx := self.SectionIndex
self.RowIndex -=1 self.RowIndex -= 1
if self.RowIndex < 0 { if self.RowIndex < 0 {
self.RowIndex = len(self.SecsKeys[sec_idx])-1 self.RowIndex = len(self.SecsKeys[sec_idx]) - 1
} }
if self.PsIndex >= len(self.SecsKeys[sec_idx][self.RowIndex]) { if self.PsIndex >= len(self.SecsKeys[sec_idx][self.RowIndex]) {
self.PsIndex = len(self.SecsKeys[sec_idx][self.RowIndex])-1 self.PsIndex = len(self.SecsKeys[sec_idx][self.RowIndex]) - 1
} }
self.ClearCanvas() self.ClearCanvas()
@@ -287,8 +280,8 @@ func (self *Keyboard) SelectDownChar() {
self.RowIndex = 0 self.RowIndex = 0
} }
if self.PsIndex >=len(self.SecsKeys[sec_idx][self.RowIndex]) { if self.PsIndex >= len(self.SecsKeys[sec_idx][self.RowIndex]) {
self.PsIndex = len(self.SecsKeys[sec_idx][self.RowIndex])-1 self.PsIndex = len(self.SecsKeys[sec_idx][self.RowIndex]) - 1
} }
self.ClearCanvas() self.ClearCanvas()
@@ -300,11 +293,11 @@ func (self *Keyboard) SelectNextChar() {
sec_idx := self.SectionIndex sec_idx := self.SectionIndex
row_idx := self.RowIndex row_idx := self.RowIndex
self.PsIndex+=1 self.PsIndex += 1
if self.PsIndex >= len(self.SecsKeys[sec_idx][row_idx]) { if self.PsIndex >= len(self.SecsKeys[sec_idx][row_idx]) {
self.PsIndex = 0 self.PsIndex = 0
self.RowIndex+=1 self.RowIndex += 1
if self.RowIndex >= len(self.SecsKeys[sec_idx]) { if self.RowIndex >= len(self.SecsKeys[sec_idx]) {
self.RowIndex = 0 self.RowIndex = 0
@@ -321,13 +314,13 @@ func (self *Keyboard) SelectNextChar() {
func (self *Keyboard) SelectPrevChar() { func (self *Keyboard) SelectPrevChar() {
sec_idx := self.SectionIndex sec_idx := self.SectionIndex
self.PsIndex-=1 self.PsIndex -= 1
if self.PsIndex < 0 { if self.PsIndex < 0 {
self.RowIndex-=1 self.RowIndex -= 1
if self.RowIndex <=0 { if self.RowIndex <= 0 {
self.RowIndex = len(self.SecsKeys[sec_idx])-1 self.RowIndex = len(self.SecsKeys[sec_idx]) - 1
} }
self.PsIndex = len(self.SecsKeys[sec_idx][self.RowIndex]) -1 self.PsIndex = len(self.SecsKeys[sec_idx][self.RowIndex]) - 1
} }
self.ClearCanvas() self.ClearCanvas()
@@ -339,17 +332,17 @@ func (self *Keyboard) ClickOnChar() {
sec_idx := self.SectionIndex sec_idx := self.SectionIndex
alphabet := self.SecsKeys[sec_idx][self.RowIndex][self.PsIndex].GetStr() alphabet := self.SecsKeys[sec_idx][self.RowIndex][self.PsIndex].GetStr()
if alphabet == "Space"{ if alphabet == "Space" {
alphabet = " " alphabet = " "
} }
if alphabet == "_L" || alphabet == "_R" { if alphabet == "_L" || alphabet == "_R" {
if alphabet == "_L" { if alphabet == "_L" {
self.Textarea.SubTextIndex() self.Textarea.SubTextIndex()
}else if alphabet == "_R"{ } else if alphabet == "_R" {
self.Textarea.AddTextIndex() self.Textarea.AddTextIndex()
} }
}else { } else {
self.Textarea.AppendText(alphabet) self.Textarea.AppendText(alphabet)
} }
@@ -360,23 +353,23 @@ func (self *Keyboard) ClickOnChar() {
func (self *Keyboard) KeyboardShift() { func (self *Keyboard) KeyboardShift() {
distance := self.Width //320 distance := self.Width //320
current_time := float32(0.0) current_time := float32(0.0)
start_posx := float32(0.0) start_posx := float32(0.0)
current_posx := start_posx current_posx := start_posx
final_posx := float32(distance) final_posx := float32(distance)
// posx_init := start // posx_init := start
dur := self.EasingDur dur := self.EasingDur
last_posx := float32(0.0) last_posx := float32(0.0)
var all_last_posx []int var all_last_posx []int
for i:=0;i<distance*dur;i++ { for i := 0; i < distance*dur; i++ {
current_posx = float32(easings.SineIn(float32(current_time), float32(start_posx), float32(final_posx-start_posx),float32(dur))) current_posx = float32(easings.SineIn(float32(current_time), float32(start_posx), float32(final_posx-start_posx), float32(dur)))
if current_posx >= final_posx { if current_posx >= final_posx {
current_posx = final_posx current_posx = final_posx
} }
dx := current_posx - last_posx dx := current_posx - last_posx
all_last_posx = append(all_last_posx,int(dx)) all_last_posx = append(all_last_posx, int(dx))
current_time+=1.0 current_time += 1.0
last_posx = current_posx last_posx = current_posx
if current_posx >= final_posx { if current_posx >= final_posx {
break break
@@ -384,19 +377,19 @@ func (self *Keyboard) KeyboardShift() {
} }
c := 0 c := 0
for _,v := range all_last_posx { for _, v := range all_last_posx {
c+=v c += v
} }
if c < int(final_posx - start_posx) { if c < int(final_posx-start_posx) {
all_last_posx = append(all_last_posx, int( int(final_posx) - c )) all_last_posx = append(all_last_posx, int(int(final_posx)-c))
} }
for _,v := range all_last_posx { for _, v := range all_last_posx {
for j:=0;j<self.SectionNumbers;j++ { for j := 0; j < self.SectionNumbers; j++ {
for _,u := range self.SecsKeys[j] { for _, u := range self.SecsKeys[j] {
for _,x := range u { for _, x := range u {
x_,y_ := x.Coord() x_, y_ := x.Coord()
x.NewCoord(x_+self.LeftOrRight*v,y_) x.NewCoord(x_+self.LeftOrRight*v, y_)
} }
} }
} }
@@ -415,8 +408,7 @@ func (self *Keyboard) ShiftKeyboardPage() {
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
} }
func (self *Keyboard) KeyDown(ev *event.Event) {
func (self *Keyboard) KeyDown( ev *event.Event) {
if ev.Data["Key"] == CurKeys["Up"] { if ev.Data["Key"] == CurKeys["Up"] {
self.SelectUpChar() self.SelectUpChar()
return return
@@ -442,18 +434,18 @@ func (self *Keyboard) KeyDown( ev *event.Event) {
return return
} }
if ev.Data["Key"] == CurKeys["X"] { if ev.Data["Key"] == CurKeys["X"] {
if self.SectionIndex <= 0 { if self.SectionIndex <= 0 {
self.LeftOrRight = -1 self.LeftOrRight = -1
} }
if self.SectionIndex >= (self.SectionNumbers - 1) { if self.SectionIndex >= (self.SectionNumbers - 1) {
self.LeftOrRight = 1 self.LeftOrRight = 1
} }
self.ShiftKeyboardPage() self.ShiftKeyboardPage()
} }
if ev.Data["Key"] == CurKeys["Menu"] { if ev.Data["Key"] == CurKeys["Menu"] {
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
@@ -463,12 +455,12 @@ func (self *Keyboard) KeyDown( ev *event.Event) {
} }
if ev.Data["Key"] == CurKeys["Y"] { // done if ev.Data["Key"] == CurKeys["Y"] { // done
fmt.Println(strings.Join(self.Textarea.MyWords,"")) fmt.Println(strings.Join(self.Textarea.MyWords, ""))
self.ReturnToUpLevelPage() self.ReturnToUpLevelPage()
self.Screen.SwapAndShow() self.Screen.SwapAndShow()
if self.Caller != nil { if self.Caller != nil {
self.Caller.OnKbdReturnBackCb() self.Caller.OnKbdReturnBackCb()
} }
//Uplevel/Parent page invoke OnReturnBackCb,eg: ConfigWireless //Uplevel/Parent page invoke OnReturnBackCb,eg: ConfigWireless
} }
@@ -480,7 +472,7 @@ func (self *Keyboard) KeyDown( ev *event.Event) {
} }
if ev.Data["Key"] == CurKeys["LK1"] { if ev.Data["Key"] == CurKeys["LK1"] {
if self.SectionIndex < self.SectionNumbers -1 { if self.SectionIndex < self.SectionNumbers-1 {
self.LeftOrRight = -1 self.LeftOrRight = -1
self.ShiftKeyboardPage() self.ShiftKeyboardPage()
} }
@@ -499,9 +491,9 @@ func (self *Keyboard) Draw() {
self.ClearCanvas() self.ClearCanvas()
self.Ps.Draw() self.Ps.Draw()
for i:=0; i < self.SectionNumbers; i++ { for i := 0; i < self.SectionNumbers; i++ {
for _,j := range self.SecsKeys[i] { for _, j := range self.SecsKeys[i] {
for _,u := range j { for _, u := range j {
u.Draw() u.Draw()
} }
} }

43
sysgo/UI/keys_def.go
View File

@@ -4,12 +4,10 @@ import (
"github.com/clockworkpi/LauncherGoDev/sysgo" "github.com/clockworkpi/LauncherGoDev/sysgo"
) )
var CurKeys map[string]string var CurKeys map[string]string
var GameShell map[string]string var GameShell map[string]string
var PC map[string]string var PC map[string]string
func DefinePC() { func DefinePC() {
PC["Up"] = "Up" PC["Up"] = "Up"
@@ -17,19 +15,19 @@ func DefinePC() {
PC["Left"] = "Left" PC["Left"] = "Left"
PC["Right"] = "Right" PC["Right"] = "Right"
PC["Menu"] = "Escape" PC["Menu"] = "Escape"
PC["X"] = "X" PC["X"] = "X"
PC["Y"] = "Y" PC["Y"] = "Y"
PC["A"] = "A" PC["A"] = "A"
PC["B"] = "B" PC["B"] = "B"
PC["Vol-"] = "Space" PC["Vol-"] = "Space"
PC["Vol+"] = "Return" PC["Vol+"] = "Return"
PC["Space"] = "Space" PC["Space"] = "Space"
PC["Enter"] = "Return" PC["Enter"] = "Return"
PC["Start"] = "S" PC["Start"] = "S"
PC["LK1"] = "H" PC["LK1"] = "H"
PC["LK5"] = "L" PC["LK5"] = "L"
} }
func DefineGameShell() { func DefineGameShell() {
@@ -38,33 +36,32 @@ func DefineGameShell() {
GameShell["Left"] = "Left" GameShell["Left"] = "Left"
GameShell["Right"] = "Right" GameShell["Right"] = "Right"
GameShell["Menu"] = "Escape" GameShell["Menu"] = "Escape"
GameShell["X"] = "U" GameShell["X"] = "U"
GameShell["Y"] = "I" GameShell["Y"] = "I"
GameShell["A"] = "J" GameShell["A"] = "J"
GameShell["B"] = "K" GameShell["B"] = "K"
GameShell["Vol-"] = "Space" GameShell["Vol-"] = "Space"
GameShell["Vol+"] = "Return" GameShell["Vol+"] = "Return"
GameShell["Space"] = "Space" GameShell["Space"] = "Space"
GameShell["Enter"] = "K" GameShell["Enter"] = "K"
GameShell["Start"] = "Return" GameShell["Start"] = "Return"
GameShell["LK1"] = "H" GameShell["LK1"] = "H"
GameShell["LK5"] = "L" GameShell["LK5"] = "L"
} }
func keys_def_init() {
func keys_def_init(){
GameShell = make(map[string]string) GameShell = make(map[string]string)
PC = make(map[string]string) PC = make(map[string]string)
DefineGameShell() DefineGameShell()
DefinePC() DefinePC()
if sysgo.CurKeySet == "GameShell" { if sysgo.CurKeySet == "GameShell" {
CurKeys = GameShell CurKeys = GameShell
}else { } else {
CurKeys = PC CurKeys = PC
} }
} }

85
sysgo/UI/label.go
View File

@@ -1,83 +1,81 @@
package UI package UI
import ( import (
//"fmt" //"fmt"
"github.com/veandco/go-sdl2/sdl" "github.com/veandco/go-sdl2/sdl"
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/surface"
"github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
"github.com/cuu/gogame/draw"
"github.com/cuu/gogame/font" "github.com/cuu/gogame/font"
"github.com/cuu/gogame/draw" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/surface"
) )
type LabelInterface interface { type LabelInterface interface {
Init( text string, font_obj *ttf.Font,col *color.Color ) Init(text string, font_obj *ttf.Font, col *color.Color)
SetCanvasHWND( canvas *sdl.Surface) SetCanvasHWND(canvas *sdl.Surface)
Coord() (int,int) Coord() (int, int)
Size() (int,int) Size() (int, int)
NewCoord(x,y int) NewCoord(x, y int)
NewSize(w,h int) NewSize(w, h int)
SetColor(col *color.Color ) SetColor(col *color.Color)
GetText() string GetText() string
SetText(text string) SetText(text string)
Draw() Draw()
DrawCenter(bold bool) DrawCenter(bold bool)
SetBold(b bool) SetBold(b bool)
} }
type Label struct { type Label struct {
Widget Widget
Text string Text string
FontObj *ttf.Font FontObj *ttf.Font
Color *color.Color Color *color.Color
CanvasHWND *sdl.Surface CanvasHWND *sdl.Surface
Bold bool Bold bool
// TextSurf *sdl.Surface // TextSurf *sdl.Surface
} }
func NewLabel() *Label { func NewLabel() *Label {
l := &Label{} l := &Label{}
l.Color = &color.Color{83,83,83,255} l.Color = &color.Color{83, 83, 83, 255}
l.Bold = false l.Bold = false
return l return l
} }
func (self *Label) Init(text string, font_obj *ttf.Font,col *color.Color ) { func (self *Label) Init(text string, font_obj *ttf.Font, col *color.Color) {
if col != nil { if col != nil {
self.Color = col self.Color = col
} }
self.Text = text self.Text = text
self.FontObj = font_obj self.FontObj = font_obj
self.Width,self.Height = font.Size(self.FontObj, self.Text) self.Width, self.Height = font.Size(self.FontObj, self.Text)
} }
func (self *Label) SetCanvasHWND( canvas *sdl.Surface) { func (self *Label) SetCanvasHWND(canvas *sdl.Surface) {
self.CanvasHWND = canvas self.CanvasHWND = canvas
} }
func (self *Label) Coord() (int,int) { func (self *Label) Coord() (int, int) {
return self.PosX,self.PosY return self.PosX, self.PosY
} }
func (self *Label) Size() (int,int) { func (self *Label) Size() (int, int) {
return self.Width,self.Height return self.Width, self.Height
} }
func (self *Label) NewCoord(x,y int) { func (self *Label) NewCoord(x, y int) {
self.PosX = x self.PosX = x
self.PosY = y self.PosY = y
} }
func (self *Label) SetColor(col *color.Color){ func (self *Label) SetColor(col *color.Color) {
if col != nil { if col != nil {
self.Color = col self.Color = col
} }
@@ -87,35 +85,34 @@ func (self *Label) GetText() string {
return self.Text return self.Text
} }
func (self *Label) SetText(text string) { func (self *Label) SetText(text string) {
self.Text = text self.Text = text
self.Width,self.Height = font.Size(self.FontObj, self.Text) self.Width, self.Height = font.Size(self.FontObj, self.Text)
} }
func (self *Label) SetBold(b bool) { func (self *Label) SetBold(b bool) {
self.Bold = b self.Bold = b
} }
func (self *Label) DrawCenter(bold bool) { // default bold is false func (self *Label) DrawCenter(bold bool) { // default bold is false
font.SetBold(self.FontObj,bold) font.SetBold(self.FontObj, bold)
my_text := font.Render(self.FontObj,self.Text, true, self.Color, nil) my_text := font.Render(self.FontObj, self.Text, true, self.Color, nil)
rect_ := draw.MidRect(self.PosX,self.PosY,self.Width,self.Height,Width,Height) rect_ := draw.MidRect(self.PosX, self.PosY, self.Width, self.Height, Width, Height)
surface.Blit(self.CanvasHWND,my_text,rect_,nil) surface.Blit(self.CanvasHWND, my_text, rect_, nil)
my_text.Free() my_text.Free()
} }
func (self *Label) Draw() { func (self *Label) Draw() {
font.SetBold(self.FontObj,self.Bold) // avoing same font tangling set_bold to others font.SetBold(self.FontObj, self.Bold) // avoing same font tangling set_bold to others
if len(self.Text) == 0 { if len(self.Text) == 0 {
return return
} }
my_text := font.Render(self.FontObj,self.Text, true, self.Color, nil) my_text := font.Render(self.FontObj, self.Text, true, self.Color, nil)
rect_ := rect.Rect(self.PosX,self.PosY,self.Width,self.Height) rect_ := rect.Rect(self.PosX, self.PosY, self.Width, self.Height)
surface.Blit(self.CanvasHWND,my_text,&rect_,nil) surface.Blit(self.CanvasHWND, my_text, &rect_, nil)
my_text.Free() my_text.Free()
} }

162
sysgo/UI/lang_manager.go
View File

@@ -1,27 +1,24 @@
package UI package UI
import ( import (
"fmt" "fmt"
"strings"
"io/ioutil"
"path/filepath"
"github.com/veandco/go-sdl2/ttf"
"github.com/go-ini/ini" "github.com/go-ini/ini"
"github.com/veandco/go-sdl2/ttf"
"io/ioutil"
"path/filepath"
"strings"
) )
func sliceToInt(s []int) int { func sliceToInt(s []int) int {
res := 0 res := 0
op := 1 op := 1
for i := len(s) - 1; i >= 0; i-- { for i := len(s) - 1; i >= 0; i-- {
res += s[i] * op res += s[i] * op
op *= 10 op *= 10
} }
return res return res
} }
func ParseNum(s string) []int { func ParseNum(s string) []int {
nLen := 0 nLen := 0
for i := 0; i < len(s); i++ { for i := 0; i < len(s); i++ {
@@ -39,85 +36,84 @@ func ParseNum(s string) []int {
} }
func GetNumberFromString(s string) int { func GetNumberFromString(s string) int {
is := ParseNum(s) is := ParseNum(s)
return sliceToInt(is) return sliceToInt(is)
} }
type LangManager struct { type LangManager struct {
Langs map[string]string
ConfigFilename string
Langs map[string]string CJKMode bool
ConfigFilename string
CJKMode bool
} }
func NewLangManager() *LangManager { func NewLangManager() *LangManager {
p := &LangManager{} p := &LangManager{}
p.ConfigFilename = "00_English.ini" p.ConfigFilename = "00_English.ini"
p.CJKMode = false p.CJKMode = false
return p return p
} }
func (self *LangManager) Init() { func (self *LangManager) Init() {
if self.Langs == nil { if self.Langs == nil {
self.SetLangs() self.SetLangs()
} }
} }
func (self *LangManager) UpdateLang() { func (self *LangManager) UpdateLang() {
self.Langs = nil self.Langs = nil
self.SetLangs() self.SetLangs()
} }
func (self *LangManager) IsCJKMode() bool { func (self *LangManager) IsCJKMode() bool {
var latins = [1]string{"English"} var latins = [1]string{"English"}
self.CJKMode= false self.CJKMode = false
for _,v := range latins { for _, v := range latins {
if strings.HasPrefix(self.ConfigFilename,v) { if strings.HasPrefix(self.ConfigFilename, v) {
self.CJKMode = false self.CJKMode = false
break break
} }
} }
return self.CJKMode return self.CJKMode
} }
func (self *LangManager) SetLangs() { func (self *LangManager) SetLangs() {
self.Langs = make(map[string]string) self.Langs = make(map[string]string)
fname := "sysgo/.lang" fname := "sysgo/.lang"
load_opts := ini.LoadOptions{ load_opts := ini.LoadOptions{
IgnoreInlineComment:true, IgnoreInlineComment: true,
} }
if FileExists(fname) { if FileExists(fname) {
config_bytes,err := ioutil.ReadFile(fname) config_bytes, err := ioutil.ReadFile(fname)
if err == nil { if err == nil {
self.ConfigFilename = strings.Trim(string(config_bytes),"\r\n ") self.ConfigFilename = strings.Trim(string(config_bytes), "\r\n ")
if len(self.ConfigFilename) < 3 { if len(self.ConfigFilename) < 3 {
self.ConfigFilename = "00_English.ini" self.ConfigFilename = "00_English.ini"
} }
} }
}else { } else {
System("touch " + fname) System("touch " + fname)
} }
config_file_relative_path := filepath.Join("sysgo","langs",self.ConfigFilename) config_file_relative_path := filepath.Join("sysgo", "langs", self.ConfigFilename)
if FileExists(config_file_relative_path) == false { if FileExists(config_file_relative_path) == false {
return return
} }
//no matter what ,we must have 00_English.ini //no matter what ,we must have 00_English.ini
cfg, err := ini.LoadSources(load_opts, config_file_relative_path) cfg, err := ini.LoadSources(load_opts, config_file_relative_path)
if err != nil { if err != nil {
fmt.Printf("Fail to read file: %v\n", err) fmt.Printf("Fail to read file: %v\n", err)
@@ -127,8 +123,8 @@ func (self *LangManager) SetLangs() {
section := cfg.Section("Langs") section := cfg.Section("Langs")
if section != nil { if section != nil {
opts := section.KeyStrings() opts := section.KeyStrings()
for _,v := range opts { for _, v := range opts {
self.Langs[v] = section.Key(v).String() self.Langs[v] = section.Key(v).String()
} }
} }
@@ -136,37 +132,37 @@ func (self *LangManager) SetLangs() {
func (self *LangManager) Tr(english_key_str string) string { func (self *LangManager) Tr(english_key_str string) string {
if self.Langs == nil { if self.Langs == nil {
return english_key_str return english_key_str
} }
if len(self.Langs) == 0 { if len(self.Langs) == 0 {
return english_key_str return english_key_str
} }
if v,ok := self.Langs[english_key_str]; ok { if v, ok := self.Langs[english_key_str]; ok {
return v return v
} }
return english_key_str return english_key_str
} }
func (self *LangManager) TrFont(orig_font_str string) *ttf.Font { func (self *LangManager) TrFont(orig_font_str string) *ttf.Font {
font_size_number := GetNumberFromString(orig_font_str) font_size_number := GetNumberFromString(orig_font_str)
if font_size_number > 120 { if font_size_number > 120 {
panic("font string format error") panic("font string format error")
} }
if strings.Contains(self.ConfigFilename,"English.ini") { if strings.Contains(self.ConfigFilename, "English.ini") {
return Fonts[orig_font_str] return Fonts[orig_font_str]
}else { } else {
if font_size_number > 28 { if font_size_number > 28 {
panic("cjk font size over 28") panic("cjk font size over 28")
} }
} }
return Fonts[ fmt.Sprintf("notosanscjk%d",font_size_number) ] return Fonts[fmt.Sprintf("notosanscjk%d", font_size_number)]
} }

46
sysgo/UI/list_item.go
View File

@@ -3,23 +3,20 @@ package UI
import ( import (
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/draw"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
"github.com/cuu/gogame/draw"
) )
type ListItemInterface interface { type ListItemInterface interface {
Init(text string) Init(text string)
Size() (int,int) Size() (int, int)
NewSize(w,h int) NewSize(w, h int)
Coord() (int,int) Coord() (int, int)
NewCoord(x,y int) NewCoord(x, y int)
GetLinkObj() PluginInterface GetLinkObj() PluginInterface
Draw() Draw()
} }
type ListItem struct { type ListItem struct {
@@ -36,50 +33,45 @@ type ListItem struct {
func NewListItem() *ListItem { func NewListItem() *ListItem {
i := &ListItem{} i := &ListItem{}
i.Labels = make(map[string]LabelInterface) i.Labels = make(map[string]LabelInterface)
i.Icons = make( map[string]IconItemInterface) i.Icons = make(map[string]IconItemInterface)
i.Fonts = make(map[string]*ttf.Font) i.Fonts = make(map[string]*ttf.Font)
i.Height = 30 i.Height = 30
i.Width = 0 i.Width = 0
return i return i
} }
func (self *ListItem) Init(text string) { func (self *ListItem) Init(text string) {
l := NewLabel() l := NewLabel()
l.PosX = 16 l.PosX = 16
l.SetCanvasHWND(self.Parent.GetCanvasHWND()) l.SetCanvasHWND(self.Parent.GetCanvasHWND())
l.Init(text,self.Fonts["normal"],nil) l.Init(text, self.Fonts["normal"], nil)
self.Labels["Text"] = l self.Labels["Text"] = l
} }
func (self *ListItem) Coord() (int, int) {
func (self *ListItem) Coord() (int,int) { return self.PosX, self.PosY
return self.PosX,self.PosY
} }
func (self *ListItem) Size() (int,int) { func (self *ListItem) Size() (int, int) {
return self.Width,self.Height return self.Width, self.Height
} }
func (self *ListItem) GetLinkObj() PluginInterface { func (self *ListItem) GetLinkObj() PluginInterface {
return self.LinkObj return self.LinkObj
} }
func (self *ListItem) Draw() { func (self *ListItem) Draw() {
x_,_ := self.Labels["Text"].Coord() x_, _ := self.Labels["Text"].Coord()
_,h_ := self.Labels["Text"].Size() _, h_ := self.Labels["Text"].Size()
self.Labels["Text"].NewCoord(x_, self.PosY+(self.Height - h_)/2) self.Labels["Text"].NewCoord(x_, self.PosY+(self.Height-h_)/2)
self.Labels["Text"].Draw() self.Labels["Text"].Draw()
draw.Line(self.Parent.GetCanvasHWND(), &color.Color{169, 169, 169, 255},
draw.Line(self.Parent.GetCanvasHWND(),&color.Color{169,169,169,255}, self.PosX, (self.PosY + self.Height - 1),
self.PosX, (self.PosY+self.Height-1), (self.PosX + self.Width), (self.PosY + self.Height - 1), 1)
(self.PosX+self.Width),(self.PosY+self.Height-1),1)
} }

238
sysgo/UI/main_screen.go
View File

@@ -3,68 +3,68 @@ package UI
import ( import (
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"strings"
"log" "log"
"strings"
//"encoding/json" //"encoding/json"
"path/filepath"
gotime "time"
"github.com/veandco/go-sdl2/sdl" "github.com/veandco/go-sdl2/sdl"
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"path/filepath"
gotime "time"
"github.com/cuu/gogame/display"
"github.com/cuu/gogame/surface"
"github.com/cuu/gogame/draw"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/display"
"github.com/cuu/gogame/draw"
"github.com/cuu/gogame/font" "github.com/cuu/gogame/font"
"github.com/cuu/gogame/rect"
"github.com/cuu/gogame/surface"
"github.com/cuu/gogame/time" "github.com/cuu/gogame/time"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
"github.com/clockworkpi/LauncherGoDev/sysgo" "github.com/clockworkpi/LauncherGoDev/sysgo"
) )
//eg: MainScreen //eg: MainScreen
type ScreenInterface interface { type ScreenInterface interface {
AppendPage( pg PageInterface ) AppendPage(pg PageInterface)
ClearCanvas() ClearCanvas()
CurPage() PageInterface CurPage() PageInterface
Draw() Draw()
ExtraName(name string) string ExtraName(name string) string
FartherPages() FartherPages()
Init() Init()
IsEmulatorPackage(dirname string ) bool IsEmulatorPackage(dirname string) bool
IsExecPackage(dirname string ) bool IsExecPackage(dirname string) bool
IsPluginPackage(dirname string ) bool IsPluginPackage(dirname string) bool
KeyDown(ev *event.Event) KeyDown(ev *event.Event)
OnExitCb() OnExitCb()
PushCurPage() PushCurPage()
PushPage( pg PageInterface) PushPage(pg PageInterface)
RunEXE( cmdpath string) RunEXE(cmdpath string)
SetCurPage( pg PageInterface) SetCurPage(pg PageInterface)
SwapAndShow() SwapAndShow()
IsWifiConnectedNow() IsWifiConnectedNow()
} }
type PluginConfig struct { type PluginConfig struct {
NAME string `json:"NAME"` // plugin name,default could be the same as Plugin Folder's name NAME string `json:"NAME"` // plugin name,default could be the same as Plugin Folder's name
SO_FILE string `json:"SO_FILE"` SO_FILE string `json:"SO_FILE"`
} }
type MessageBox struct { type MessageBox struct {
Label Label
Parent *MainScreen Parent *MainScreen
HWND *sdl.Surface HWND *sdl.Surface
} }
func NewMessageBox() *MessageBox { func NewMessageBox() *MessageBox {
m := &MessageBox{} m := &MessageBox{}
m.Color = &color.Color{83,83,83,255} m.Color = &color.Color{83, 83, 83, 255}
return m return m
} }
func (self *MessageBox) Init( text string, font_obj *ttf.Font, col *color.Color) { func (self *MessageBox) Init(text string, font_obj *ttf.Font, col *color.Color) {
if col != nil { if col != nil {
self.Color = col self.Color = col
} }
@@ -76,21 +76,21 @@ func (self *MessageBox) Init( text string, font_obj *ttf.Font, col *color.Color)
self.Height = 0 self.Height = 0
self.CanvasHWND = surface.Surface(self.Parent.Width, self.Parent.Height) self.CanvasHWND = surface.Surface(self.Parent.Width, self.Parent.Height)
self.HWND = self.Parent.CanvasHWND self.HWND = self.Parent.CanvasHWND
} }
func (self *MessageBox) SetText( text string) { func (self *MessageBox) SetText(text string) {
self.Text = text self.Text = text
} }
func (self *MessageBox) Draw() { func (self *MessageBox) Draw() {
self.Width = 0 self.Width = 0
self.Height = 0 self.Height = 0
surface.Fill(self.CanvasHWND, &color.Color{255,255,255,255} ) surface.Fill(self.CanvasHWND, &color.Color{255, 255, 255, 255})
words := strings.Split(self.Text," ") words := strings.Split(self.Text, " ")
space,_ := font.Size(self.FontObj," ") space, _ := font.Size(self.FontObj, " ")
max_width := self.Parent.Width - 40 max_width := self.Parent.Width - 40
x := 0 x := 0
@@ -99,8 +99,8 @@ func (self *MessageBox) Draw() {
row_total_width := 0 row_total_width := 0
lines := 0 lines := 0
for _,word := range words { for _, word := range words {
word_surface := font.Render( self.FontObj, word, true, self.Color,nil) word_surface := font.Render(self.FontObj, word, true, self.Color, nil)
word_width := int(word_surface.W) word_width := int(word_surface.W)
word_height := int(word_surface.H) word_height := int(word_surface.H)
row_total_width += word_width row_total_width += word_width
@@ -108,27 +108,27 @@ func (self *MessageBox) Draw() {
lines += word_height lines += word_height
} }
if (row_total_width + space ) >= max_width { if (row_total_width + space) >= max_width {
x = 0 x = 0
y += word_height y += word_height
row_total_width = word_width row_total_width = word_width
lines+=word_height lines += word_height
} }
dest_rect := rect.Rect(x,y, word_width,word_height) dest_rect := rect.Rect(x, y, word_width, word_height)
surface.Blit(self.CanvasHWND, word_surface, &dest_rect,nil) surface.Blit(self.CanvasHWND, word_surface, &dest_rect, nil)
word_surface.Free() word_surface.Free()
if len(words) == 1 { if len(words) == 1 {
x+=word_width x += word_width
} else { } else {
x += word_width+space x += word_width + space
} }
if x > self.Width { if x > self.Width {
self.Width = x self.Width = x
} }
if lines >= self.Parent.Height - 40 { if lines >= self.Parent.Height-40 {
break break
} }
} }
@@ -137,31 +137,30 @@ func (self *MessageBox) Draw() {
padding := 5 padding := 5
x = (self.Parent.Width - self.Width) / 2 x = (self.Parent.Width - self.Width) / 2
y = (self.Parent.Height - self.Height) /2 y = (self.Parent.Height - self.Height) / 2
rect_ := rect.Rect(x-padding,y-padding, self.Width+padding*2, self.Height+padding*2) rect_ := rect.Rect(x-padding, y-padding, self.Width+padding*2, self.Height+padding*2)
if self.HWND != nil { if self.HWND != nil {
draw.Rect(self.HWND , &color.Color{255,255,255,255},&rect_,0) draw.Rect(self.HWND, &color.Color{255, 255, 255, 255}, &rect_, 0)
rect__ := draw.MidRect(self.Parent.Width/2, self.Parent.Height/2,self.Width,self.Height,Width,Height) rect__ := draw.MidRect(self.Parent.Width/2, self.Parent.Height/2, self.Width, self.Height, Width, Height)
dest_rect := rect.Rect(0,0,self.Width,self.Height) dest_rect := rect.Rect(0, 0, self.Width, self.Height)
surface.Blit(self.HWND, self.CanvasHWND, rect__, &dest_rect) surface.Blit(self.HWND, self.CanvasHWND, rect__, &dest_rect)
draw.Rect(self.HWND , &color.Color{0,0,0,255},&rect_,1) draw.Rect(self.HWND, &color.Color{0, 0, 0, 255}, &rect_, 1)
} }
} }
type MainScreen struct { type MainScreen struct {
Widget Widget
Pages []PageInterface Pages []PageInterface
PageMax int PageMax int
PageIndex int PageIndex int
MyPageStack *PageStack MyPageStack *PageStack
@@ -175,52 +174,51 @@ type MainScreen struct {
IconFont *ttf.Font IconFont *ttf.Font
SkinManager *SkinManager SkinManager *SkinManager
CounterScreen *CounterScreen CounterScreen *CounterScreen
Closed bool Closed bool
UIPluginList []*UIPlugin UIPluginList []*UIPlugin
LastKey string LastKey string
LastKeyDown gotime.Time LastKeyDown gotime.Time
} }
func NewMainScreen() *MainScreen { func NewMainScreen() *MainScreen {
m := &MainScreen{} m := &MainScreen{}
m.PosY = TitleBar_BarHeight+1 m.PosY = TitleBar_BarHeight + 1
m.Width = Width m.Width = Width
m.Height = Height - FootBar_BarHeight - TitleBar_BarHeight - 1 m.Height = Height - FootBar_BarHeight - TitleBar_BarHeight - 1
m.MyPageStack = NewPageStack() m.MyPageStack = NewPageStack()
m.MsgBoxFont = Fonts["veramono20"] m.MsgBoxFont = Fonts["veramono20"]
m.IconFont = Fonts["varela15"] m.IconFont = Fonts["varela15"]
m.Closed = false m.Closed = false
return m return m
} }
func (self *MainScreen) Init() { func (self *MainScreen) Init() {
self.CanvasHWND = surface.Surface(self.Width,self.Height) self.CanvasHWND = surface.Surface(self.Width, self.Height)
self.MsgBox = NewMessageBox() self.MsgBox = NewMessageBox()
self.MsgBox.Parent = self self.MsgBox.Parent = self
self.MsgBox.Init(" ", self.MsgBoxFont, &color.Color{83,83,83,255}) self.MsgBox.Init(" ", self.MsgBoxFont, &color.Color{83, 83, 83, 255})
self.SkinManager = NewSkinManager() self.SkinManager = NewSkinManager()
self.SkinManager.Init() self.SkinManager.Init()
self.CounterScreen = NewCounterScreen() self.CounterScreen = NewCounterScreen()
self.CounterScreen.HWND = self.HWND self.CounterScreen.HWND = self.HWND
self.CounterScreen.Init() self.CounterScreen.Init()
//self.GenList() // load predefined plugin list,ready to be injected ,or ,as a .so for dynamic loading //self.GenList() // load predefined plugin list,ready to be injected ,or ,as a .so for dynamic loading
} }
func (self *MainScreen) FartherPages() { // right after ReadTheDirIntoPages func (self *MainScreen) FartherPages() { // right after ReadTheDirIntoPages
self.PageMax = len(self.Pages) self.PageMax = len(self.Pages)
for i:=0;i< self.PageMax; i++ { for i := 0; i < self.PageMax; i++ {
self.Pages[i].SetIndex(i) self.Pages[i].SetIndex(i)
self.Pages[i].SetCanvasHWND(self.CanvasHWND) self.Pages[i].SetCanvasHWND(self.CanvasHWND)
self.Pages[i].UpdateIconNumbers() // IconNumbers always == len(Pages[i].Icons) self.Pages[i].UpdateIconNumbers() // IconNumbers always == len(Pages[i].Icons)
@@ -229,16 +227,14 @@ func (self *MainScreen) FartherPages() { // right after ReadTheDirIntoPages
if self.Pages[i].GetIconNumbers() > 1 { if self.Pages[i].GetIconNumbers() > 1 {
self.Pages[i].SetPsIndex(1) self.Pages[i].SetPsIndex(1)
self.Pages[i].SetIconIndex( 1 ) self.Pages[i].SetIconIndex(1)
} }
} }
self.CurrentPage = self.Pages[ self.PageIndex ] self.CurrentPage = self.Pages[self.PageIndex]
self.CurrentPage.SetOnShow(true) self.CurrentPage.SetOnShow(true)
} }
func (self *MainScreen) CurPage() PageInterface { func (self *MainScreen) CurPage() PageInterface {
return self.CurrentPage return self.CurrentPage
} }
@@ -247,28 +243,28 @@ func (self *MainScreen) PushCurPage() {
self.MyPageStack.Push(self.CurrentPage) self.MyPageStack.Push(self.CurrentPage)
} }
func (self *MainScreen) SetCurPage( pg PageInterface) { func (self *MainScreen) SetCurPage(pg PageInterface) {
self.CurrentPage = pg self.CurrentPage = pg
pg.OnLoadCb() pg.OnLoadCb()
} }
func (self *MainScreen) PushPage( pg PageInterface) { func (self *MainScreen) PushPage(pg PageInterface) {
self.PushCurPage() self.PushCurPage()
self.SetCurPage(pg) self.SetCurPage(pg)
} }
func (self *MainScreen) AppendPage( pg PageInterface ) { func (self *MainScreen) AppendPage(pg PageInterface) {
self.Pages = append(self.Pages,pg) self.Pages = append(self.Pages, pg)
} }
func (self *MainScreen) ClearCanvas() { func (self *MainScreen) ClearCanvas() {
surface.Fill(self.CanvasHWND, &color.Color{255,255,255,255} ) surface.Fill(self.CanvasHWND, &color.Color{255, 255, 255, 255})
} }
func (self *MainScreen) SwapAndShow() { func (self *MainScreen) SwapAndShow() {
if self.HWND != nil { if self.HWND != nil {
rect_ := rect.Rect( self.PosX,self.PosY,self.Width,self.Height) rect_ := rect.Rect(self.PosX, self.PosY, self.Width, self.Height)
surface.Blit(self.HWND,self.CanvasHWND,&rect_, nil) surface.Blit(self.HWND, self.CanvasHWND, &rect_, nil)
} }
display.Flip() display.Flip()
@@ -276,50 +272,49 @@ func (self *MainScreen) SwapAndShow() {
func (self *MainScreen) ExtraName(name string) string { func (self *MainScreen) ExtraName(name string) string {
parts := strings.Split(name,"_") parts := strings.Split(name, "_")
if len(parts) > 1 { if len(parts) > 1 {
return parts[1] return parts[1]
}else if len(parts) == 1 { } else if len(parts) == 1 {
return parts[0] return parts[0]
}else { } else {
return name return name
} }
} }
//ExecPackage is all-in-one folder ,Name.sh,Name.png,etc //ExecPackage is all-in-one folder ,Name.sh,Name.png,etc
func (self *MainScreen) IsExecPackage(dirname string ) bool { func (self *MainScreen) IsExecPackage(dirname string) bool {
files,err := ioutil.ReadDir(dirname) files, err := ioutil.ReadDir(dirname)
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
return false return false
} }
bname := filepath.Base(dirname) bname := filepath.Base(dirname)
bname = self.ExtraName(bname) bname = self.ExtraName(bname)
for _,v := range files { for _, v := range files {
if v.Name() == bname+".sh" { if v.Name() == bname+".sh" {
return true return true
} }
} }
return false return false
} }
func (self *MainScreen) IsPluginPackage(dirname string ) bool { func (self *MainScreen) IsPluginPackage(dirname string) bool {
ret := false ret := false
files,err := ioutil.ReadDir(dirname) files, err := ioutil.ReadDir(dirname)
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
return false return false
} }
for _,f := range files { for _, f := range files {
if f.IsDir() { if f.IsDir() {
//pass //pass
}else { } else {
if strings.HasSuffix(f.Name(),Plugin_flag) == true { if strings.HasSuffix(f.Name(), Plugin_flag) == true {
ret = true ret = true
break break
} }
@@ -329,19 +324,19 @@ func (self *MainScreen) IsPluginPackage(dirname string ) bool {
return ret return ret
} }
func (self *MainScreen) IsEmulatorPackage(dirname string ) bool { func (self *MainScreen) IsEmulatorPackage(dirname string) bool {
ret := false ret := false
files,err := ioutil.ReadDir(dirname) files, err := ioutil.ReadDir(dirname)
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
return false return false
} }
for _,f := range files { for _, f := range files {
if f.IsDir() { if f.IsDir() {
//pass //pass
}else { } else {
if strings.HasSuffix(f.Name(),Emulator_flag) == true { if strings.HasSuffix(f.Name(), Emulator_flag) == true {
ret = true ret = true
break break
} }
@@ -353,9 +348,9 @@ func (self *MainScreen) IsEmulatorPackage(dirname string ) bool {
func (self *MainScreen) IsWifiConnectedNow() bool { func (self *MainScreen) IsWifiConnectedNow() bool {
cli := fmt.Sprintf( "ip -4 addr show %s | grep -oP '(?<=inet\\s)\\d+(\\.\\d+){3}'",sysgo.WifiDev) cli := fmt.Sprintf("ip -4 addr show %s | grep -oP '(?<=inet\\s)\\d+(\\.\\d+){3}'", sysgo.WifiDev)
out := System(cli) out := System(cli)
if len(out)<6 { if len(out) < 6 {
return false return false
} }
return true return true
@@ -363,24 +358,22 @@ func (self *MainScreen) IsWifiConnectedNow() bool {
func (self *MainScreen) GetWirelessIP() string { func (self *MainScreen) GetWirelessIP() string {
cli := fmt.Sprintf( "ip -4 addr show %s | grep -oP '(?<=inet\\s)\\d+(\\.\\d+){3}'",sysgo.WifiDev) cli := fmt.Sprintf("ip -4 addr show %s | grep -oP '(?<=inet\\s)\\d+(\\.\\d+){3}'", sysgo.WifiDev)
out := SystemTrim(cli) out := SystemTrim(cli)
return out
return out
} }
func (self *MainScreen) RunEXE( cmdpath string) { func (self *MainScreen) RunEXE(cmdpath string) {
self.DrawRun() self.DrawRun()
self.SwapAndShow() self.SwapAndShow()
time.BlockDelay(1000) time.BlockDelay(1000)
cmdpath = strings.Trim(cmdpath," ") cmdpath = strings.Trim(cmdpath, " ")
cmdpath = CmdClean(cmdpath) cmdpath = CmdClean(cmdpath)
event.Post(RUNEVT,cmdpath) event.Post(RUNEVT, cmdpath)
} }
@@ -402,11 +395,10 @@ func (self *MainScreen) KeyDown(ev *event.Event) {
} }
self.CurrentPage.KeyDown(ev) self.CurrentPage.KeyDown(ev)
self.LastKey = ev.Data["Key"] self.LastKey = ev.Data["Key"]
} }
func (self *MainScreen) DrawRun() { func (self *MainScreen) DrawRun() {
self.MsgBox.SetText("Launching....") self.MsgBox.SetText("Launching....")
self.MsgBox.Draw() self.MsgBox.Draw()
@@ -418,12 +410,12 @@ func (self *MainScreen) Draw() {
} }
if self.TitleBar != nil { if self.TitleBar != nil {
//every plugin_init should not do any Draw actions since CurrentPage might be nil at that time //every plugin_init should not do any Draw actions since CurrentPage might be nil at that time
self.TitleBar.Draw( self.CurrentPage.GetName()) self.TitleBar.Draw(self.CurrentPage.GetName())
} }
if self.FootBar != nil { if self.FootBar != nil {
self.FootBar.SetLabelTexts( self.CurrentPage.GetFootMsg()) self.FootBar.SetLabelTexts(self.CurrentPage.GetFootMsg())
self.FootBar.Draw() self.FootBar.Draw()
} }
} }

76
sysgo/UI/multi_icon_item.go
View File

@@ -1,20 +1,18 @@
package UI package UI
import ( import (
"fmt" "fmt"
"github.com/cuu/gogame/surface"
"github.com/cuu/gogame/image"
"github.com/cuu/gogame/draw" "github.com/cuu/gogame/draw"
"github.com/cuu/gogame/image"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/surface"
) )
type MultiIconItem struct { type MultiIconItem struct {
IconItem IconItem
IconWidth int IconWidth int
IconHeight int IconHeight int
} }
func NewMultiIconItem() *MultiIconItem { func NewMultiIconItem() *MultiIconItem {
@@ -25,53 +23,53 @@ func NewMultiIconItem() *MultiIconItem {
return m return m
} }
func (self * MultiIconItem) CreateImgSurf() { func (self *MultiIconItem) CreateImgSurf() {
if self.ImgSurf == nil && self.ImageName != "" { if self.ImgSurf == nil && self.ImageName != "" {
self.ImgSurf = image.Load(self.ImageName) self.ImgSurf = image.Load(self.ImageName)
} }
} }
func (self *MultiIconItem) DrawTopLeft() { func (self *MultiIconItem) DrawTopLeft() {
if self.Parent == nil { if self.Parent == nil {
fmt.Println("Error: MultiIconItem Draw Parent nil") fmt.Println("Error: MultiIconItem Draw Parent nil")
return return
} }
parent_x,parent_y := self.Parent.Coord() parent_x, parent_y := self.Parent.Coord()
if self.Label != nil { if self.Label != nil {
lab_w,lab_h:= self.Label.Size() lab_w, lab_h := self.Label.Size()
if self.Align == ALIGN["VCenter"] { if self.Align == ALIGN["VCenter"] {
self.Label.NewCoord( self.PosX - lab_w/2 + parent_x, self.PosY + self.Height/2+6 + parent_y) self.Label.NewCoord(self.PosX-lab_w/2+parent_x, self.PosY+self.Height/2+6+parent_y)
}else if self.Align == ALIGN["HLeft"] { } else if self.Align == ALIGN["HLeft"] {
self.Label.NewCoord( self.PosX + self.Width/2+3 + parent_x, self.PosY - lab_h/2 + parent_y ) self.Label.NewCoord(self.PosX+self.Width/2+3+parent_x, self.PosY-lab_h/2+parent_y)
} }
self.Label.Draw() self.Label.Draw()
} }
if self.ImgSurf != nil { if self.ImgSurf != nil {
portion := rect.Rect(0,self.IconIndex*self.IconHeight,self.IconWidth,self.IconHeight) portion := rect.Rect(0, self.IconIndex*self.IconHeight, self.IconWidth, self.IconHeight)
rect_ := rect.Rect( self.PosX+parent_x,self.PosY+parent_y, self.Width,self.Height ) // DIFF rect_ := rect.Rect(self.PosX+parent_x, self.PosY+parent_y, self.Width, self.Height) // DIFF
surface.Blit(self.Parent.GetCanvasHWND(),self.ImgSurf,&rect_,&portion) surface.Blit(self.Parent.GetCanvasHWND(), self.ImgSurf, &rect_, &portion)
} }
} }
func (self *MultiIconItem) Draw() { func (self *MultiIconItem) Draw() {
if self.Parent == nil { if self.Parent == nil {
fmt.Println("Error: MultiIconItem Draw Parent nil") fmt.Println("Error: MultiIconItem Draw Parent nil")
return return
} }
parent_x,parent_y := self.Parent.Coord() parent_x, parent_y := self.Parent.Coord()
if self.Label != nil { if self.Label != nil {
// lab_x,lab_y := self.Label.Coord() // lab_x,lab_y := self.Label.Coord()
lab_w,lab_h:= self.Label.Size() lab_w, lab_h := self.Label.Size()
if self.Align == ALIGN["VCenter"] { if self.Align == ALIGN["VCenter"] {
self.Label.NewCoord( self.PosX - lab_w/2 + parent_x, self.PosY + self.Height/2+6 + parent_y) self.Label.NewCoord(self.PosX-lab_w/2+parent_x, self.PosY+self.Height/2+6+parent_y)
}else if self.Align == ALIGN["HLeft"] { } else if self.Align == ALIGN["HLeft"] {
self.Label.NewCoord( self.PosX + self.Width/2+3 + parent_x, self.PosY - lab_h/2 + parent_y ) self.Label.NewCoord(self.PosX+self.Width/2+3+parent_x, self.PosY-lab_h/2+parent_y)
} }
self.Label.Draw() self.Label.Draw()
@@ -79,10 +77,10 @@ func (self *MultiIconItem) Draw() {
if self.ImgSurf != nil { if self.ImgSurf != nil {
portion := rect.Rect(0,self.IconIndex*self.IconHeight,self.IconWidth,self.IconHeight) portion := rect.Rect(0, self.IconIndex*self.IconHeight, self.IconWidth, self.IconHeight)
surface.Blit(self.Parent.GetCanvasHWND(), surface.Blit(self.Parent.GetCanvasHWND(),
self.ImgSurf,draw.MidRect(self.PosX + parent_x, self.PosY + parent_y, self.ImgSurf, draw.MidRect(self.PosX+parent_x, self.PosY+parent_y,
self.Width,self.Height, Width, Height),&portion) self.Width, self.Height, Width, Height), &portion)
} }
} }

65
sysgo/UI/multilabel.go
View File

@@ -6,10 +6,10 @@ import (
"github.com/veandco/go-sdl2/sdl" "github.com/veandco/go-sdl2/sdl"
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/surface"
"github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
"github.com/cuu/gogame/font" "github.com/cuu/gogame/font"
"github.com/cuu/gogame/rect"
"github.com/cuu/gogame/surface"
) )
//MultiLabel is also a LabelInterface //MultiLabel is also a LabelInterface
@@ -20,20 +20,20 @@ type MultiLabel struct {
Color *color.Color Color *color.Color
CanvasHWND *sdl.Surface CanvasHWND *sdl.Surface
//TextSurf *sdl.Surface //TextSurf *sdl.Surface
MaxWidth int MaxWidth int
Bold bool Bold bool
} }
func NewMultiLabel() *MultiLabel{ func NewMultiLabel() *MultiLabel {
l := &MultiLabel{} l := &MultiLabel{}
l.Color = &color.Color{83,83,83,255} l.Color = &color.Color{83, 83, 83, 255}
l.Width = 135 l.Width = 135
l.Height = 100 l.Height = 100
l.Bold = false l.Bold = false
return l return l
} }
func (self *MultiLabel) Init(text string, font_obj *ttf.Font,col *color.Color) { func (self *MultiLabel) Init(text string, font_obj *ttf.Font, col *color.Color) {
if col != nil { if col != nil {
self.Color = col self.Color = col
} }
@@ -46,12 +46,11 @@ func (self *MultiLabel) Init(text string, font_obj *ttf.Font,col *color.Color) {
} }
} }
func (self *MultiLabel) SetCanvasHWND( canvas *sdl.Surface) { func (self *MultiLabel) SetCanvasHWND(canvas *sdl.Surface) {
self.CanvasHWND = canvas self.CanvasHWND = canvas
} }
func (self *MultiLabel) SetColor(col *color.Color) {
func (self *MultiLabel) SetColor(col *color.Color){
if col != nil { if col != nil {
self.Color = col self.Color = col
} }
@@ -61,14 +60,13 @@ func (self *MultiLabel) GetText() string {
return self.Text return self.Text
} }
func (self *MultiLabel) SetText(text string) { func (self *MultiLabel) SetText(text string) {
self.Text = text self.Text = text
} }
func (self *MultiLabel) SetBold(b bool) { func (self *MultiLabel) SetBold(b bool) {
self.Bold = b self.Bold = b
} }
@@ -77,22 +75,22 @@ func (self *MultiLabel) DrawCenter(bold bool) {
} }
func (self *MultiLabel) Draw() { func (self *MultiLabel) Draw() {
font.SetBold(self.FontObj,self.Bold) // avoing same font tangling set_bold to others font.SetBold(self.FontObj, self.Bold) // avoing same font tangling set_bold to others
self.blit_text(self.CanvasHWND, self.Text,self.PosX,self.PosY,self.FontObj) self.blit_text(self.CanvasHWND, self.Text, self.PosX, self.PosY, self.FontObj)
} }
// difference to Label // difference to Label
func (self *MultiLabel) blit_text(surf *sdl.Surface,text string, pos_x,pos_y int, fnt *ttf.Font) { func (self *MultiLabel) blit_text(surf *sdl.Surface, text string, pos_x, pos_y int, fnt *ttf.Font) {
words := make([][]string, 0) words := make([][]string, 0)
temp := strings.Split(text,"\n") temp := strings.Split(text, "\n")
for _,v := range temp { for _, v := range temp {
t := strings.Split(v," ") t := strings.Split(v, " ")
words = append(words,t) words = append(words, t)
} }
space,_ := font.Size(fnt," ") space, _ := font.Size(fnt, " ")
max_width := self.Width max_width := self.Width
x,y := pos_x,pos_y x, y := pos_x, pos_y
row_total_width := 0 row_total_width := 0
lines := 0 lines := 0
@@ -102,32 +100,32 @@ func (self *MultiLabel) blit_text(surf *sdl.Surface,text string, pos_x,pos_y int
tmp = words[:4] tmp = words[:4]
} }
for _,line := range tmp { for _, line := range tmp {
word_height := 0 word_height := 0
tmp2 := line tmp2 := line
if len(line) > 12 { if len(line) > 12 {
tmp2 = line[:12] tmp2 = line[:12]
} }
for _,word := range tmp2 { for _, word := range tmp2 {
word_surface := font.Render(fnt,word,true,self.Color,nil) word_surface := font.Render(fnt, word, true, self.Color, nil)
word_width := surface.GetWidth(word_surface) word_width := surface.GetWidth(word_surface)
word_height = surface.GetHeight(word_surface) word_height = surface.GetHeight(word_surface)
row_total_width += word_width row_total_width += word_width
if row_total_width+space >= max_width { if row_total_width+space >= max_width {
x = pos_x x = pos_x
y = y+word_height y = y + word_height
row_total_width = word_width row_total_width = word_width
if lines == 0 { if lines == 0 {
lines = lines + word_height lines = lines + word_height
}else { } else {
lines = lines + word_height lines = lines + word_height
} }
} }
rect_ := rect.Rect(x,y,self.Width,self.Height) rect_ := rect.Rect(x, y, self.Width, self.Height)
surface.Blit(surf,word_surface,&rect_,nil) surface.Blit(surf, word_surface, &rect_, nil)
word_surface.Free() word_surface.Free()
x += (word_width+space) x += (word_width + space)
} }
x = pos_x x = pos_x
y += word_height y += word_height
@@ -137,4 +135,3 @@ func (self *MultiLabel) blit_text(surf *sdl.Surface,text string, pos_x,pos_y int
self.Height = lines self.Height = lines
} }

616
sysgo/UI/page.go
View File

File diff suppressed because it is too large Load Diff

46
sysgo/UI/plugin.go
View File

@@ -21,25 +21,23 @@ func (self *Plugin) GetName() string {
return self.Name return self.Name
} }
func (self *Plugin) Init( screen *MainScreen) { func (self *Plugin) Init(screen *MainScreen) {
} }
func (self *Plugin) Run(screen *MainScreen) {
func (self *Plugin) Run( screen *MainScreen) {
} }
func NewPluginPool() map[string]PluginInterface { func NewPluginPool() map[string]PluginInterface {
pp :=make( map[string]PluginInterface ) pp := make(map[string]PluginInterface)
return pp return pp
} }
func PluginPoolRegister( pi PluginInterface ) bool { func PluginPoolRegister(pi PluginInterface) bool {
name := pi.GetName() name := pi.GetName()
if _,ok := PluginPool[name]; ok { if _, ok := PluginPool[name]; ok {
return false return false
} }
@@ -48,20 +46,20 @@ func PluginPoolRegister( pi PluginInterface ) bool {
} }
func LoadPlugin( pname string) (*goplugin.Plugin,error) { func LoadPlugin(pname string) (*goplugin.Plugin, error) {
return goplugin.Open(pname) return goplugin.Open(pname)
} }
func InitPlugin(p *goplugin.Plugin, main_screen *MainScreen) PluginInterface { func InitPlugin(p *goplugin.Plugin, main_screen *MainScreen) PluginInterface {
symAPI,err := p.Lookup("APIOBJ") symAPI, err := p.Lookup("APIOBJ")
if err!= nil { if err != nil {
log.Fatal( "init plugin failed") log.Fatal("init plugin failed")
return nil return nil
} }
var pi PluginInterface var pi PluginInterface
pi,ok := symAPI.(PluginInterface) pi, ok := symAPI.(PluginInterface)
if !ok { if !ok {
log.Fatal("unexpected type from module symbol") log.Fatal("unexpected type from module symbol")
return nil return nil
@@ -75,15 +73,15 @@ func InitPlugin(p *goplugin.Plugin, main_screen *MainScreen) PluginInterface {
} }
func RunPlugin(p *goplugin.Plugin, main_screen *MainScreen) { func RunPlugin(p *goplugin.Plugin, main_screen *MainScreen) {
symAPI,err := p.Lookup("APIOBJ") symAPI, err := p.Lookup("APIOBJ")
if err!= nil { if err != nil {
log.Fatal( "init plugin failed") log.Fatal("init plugin failed")
return return
} }
var pi PluginInterface var pi PluginInterface
pi,ok := symAPI.(PluginInterface) pi, ok := symAPI.(PluginInterface)
if !ok { if !ok {
log.Fatal("unexpected type from module symbol") log.Fatal("unexpected type from module symbol")
return return
@@ -92,14 +90,14 @@ func RunPlugin(p *goplugin.Plugin, main_screen *MainScreen) {
} }
const ( const (
PluginPackage = iota PluginPackage = iota
PluginSo PluginSo
) )
type UIPlugin struct{ //Loadable and injectable type UIPlugin struct { //Loadable and injectable
Type int // 0 == loadable package, 1 == .so Type int // 0 == loadable package, 1 == .so
SoFile string SoFile string
FolderName string FolderName string
LabelText string LabelText string
EmbInterface PluginInterface EmbInterface PluginInterface
} }

53
sysgo/UI/scroller.go
View File

@@ -4,34 +4,33 @@ import (
"fmt" "fmt"
"github.com/veandco/go-sdl2/sdl" "github.com/veandco/go-sdl2/sdl"
// "github.com/veandco/go-sdl2/ttf" // "github.com/veandco/go-sdl2/ttf"
// "github.com/cuu/gogame/surface" // "github.com/cuu/gogame/surface"
// "github.com/cuu/gogame/rect" // "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
// "github.com/cuu/gogame/font" // "github.com/cuu/gogame/font"
"github.com/cuu/gogame/draw" "github.com/cuu/gogame/draw"
) )
type ListScroller struct{ type ListScroller struct {
Widget Widget
MinHeight int MinHeight int
Parent PageInterface Parent PageInterface
Color *color.Color Color *color.Color
StartX int StartX int
StartY int StartY int
EndX int EndX int
EndY int EndY int
Value int Value int
CanvasHWND *sdl.Surface CanvasHWND *sdl.Surface
} }
func NewListScroller() *ListScroller { func NewListScroller() *ListScroller {
l := &ListScroller{} l := &ListScroller{}
l.Width = 7 l.Width = 7
l.Color = &color.Color{131,199,219,255} // SkinManager().GiveColor('Front') l.Color = &color.Color{131, 199, 219, 255} // SkinManager().GiveColor('Front')
return l return l
} }
@@ -41,52 +40,52 @@ func (self *ListScroller) Init() {
self.SetCanvasHWND(cav_) self.SetCanvasHWND(cav_)
} }
func (self *ListScroller) SetCanvasHWND( canvas *sdl.Surface) { func (self *ListScroller) SetCanvasHWND(canvas *sdl.Surface) {
self.CanvasHWND = canvas self.CanvasHWND = canvas
} }
func (self *ListScroller) AnimateDraw(x2,y2 int) { func (self *ListScroller) AnimateDraw(x2, y2 int) {
} }
func (self *ListScroller) UpdateSize(bigheight, dirtyheight int) { func (self *ListScroller) UpdateSize(bigheight, dirtyheight int) {
_,h_ := self.Parent.Size() _, h_ := self.Parent.Size()
bodyheight := float64(h_)/float64(bigheight) bodyheight := float64(h_) / float64(bigheight)
if bodyheight > 1.0 { if bodyheight > 1.0 {
bodyheight = 1.0 bodyheight = 1.0
} }
margin := 4 margin := 4
self.Height = int( bodyheight * float64(h_) - float64(margin) ) self.Height = int(bodyheight*float64(h_) - float64(margin))
if self.Height < self.MinHeight { if self.Height < self.MinHeight {
self.Height = self.MinHeight self.Height = self.MinHeight
} }
self.StartX = self.Width/2 self.StartX = self.Width / 2
self.StartY = margin/2 + self.Height/2 self.StartY = margin/2 + self.Height/2
self.EndX = self.Width/2 self.EndX = self.Width / 2
self.EndY = h_ - margin/2 - self.Height/2 self.EndY = h_ - margin/2 - self.Height/2
process := float64(dirtyheight) / float64(bigheight) process := float64(dirtyheight) / float64(bigheight)
value := process * float64(self.EndY - self.StartY) value := process * float64(self.EndY-self.StartY)
self.Value = int(value) self.Value = int(value)
} }
func (self *ListScroller) Draw() { func (self *ListScroller) Draw() {
w_,h_ := self.Parent.Size() w_, h_ := self.Parent.Size()
start_rect := draw.MidRect(self.PosX+self.StartX,self.StartY+self.Value,self.Width,self.Height,w_,h_) start_rect := draw.MidRect(self.PosX+self.StartX, self.StartY+self.Value, self.Width, self.Height, w_, h_)
if self.Width < 1 { if self.Width < 1 {
fmt.Println("ListScroller width error") fmt.Println("ListScroller width error")
}else { } else {
draw.AARoundRect(self.CanvasHWND,start_rect,self.Color,3,0,self.Color) draw.AARoundRect(self.CanvasHWND, start_rect, self.Color, 3, 0, self.Color)
} }
} }

56
sysgo/UI/skin_manager.go
View File

@@ -1,12 +1,11 @@
package UI package UI
import ( import (
"fmt" "fmt"
"log" "log"
"strings"
"strconv" "strconv"
"strings"
"github.com/go-ini/ini" "github.com/go-ini/ini"
@@ -17,7 +16,6 @@ import (
type SkinManager struct { type SkinManager struct {
Colors map[string]*color.Color Colors map[string]*color.Color
} }
func NewSkinManager() *SkinManager { func NewSkinManager() *SkinManager {
@@ -26,7 +24,6 @@ func NewSkinManager() *SkinManager {
return s return s
} }
func (self *SkinManager) ConvertToRGB(hexstr string) *color.Color { func (self *SkinManager) ConvertToRGB(hexstr string) *color.Color {
if len(hexstr) < 7 || string(hexstr[0]) != "#" { // # 00 00 00 if len(hexstr) < 7 || string(hexstr[0]) != "#" { // # 00 00 00
log.Fatalf("ConvertToRGB hex string format error %s", hexstr) log.Fatalf("ConvertToRGB hex string format error %s", hexstr)
@@ -34,42 +31,42 @@ func (self *SkinManager) ConvertToRGB(hexstr string) *color.Color {
return nil return nil
} }
h := strings.TrimLeft(hexstr,"#") h := strings.TrimLeft(hexstr, "#")
r,_ := strconv.ParseInt(h[0:2], 16,0) r, _ := strconv.ParseInt(h[0:2], 16, 0)
g,_ := strconv.ParseInt(h[2:4], 16,0) g, _ := strconv.ParseInt(h[2:4], 16, 0)
b,_ := strconv.ParseInt(h[4:6], 16,0) b, _ := strconv.ParseInt(h[4:6], 16, 0)
col := &color.Color{ uint32(r),uint32(g),uint32(b),255 } col := &color.Color{uint32(r), uint32(g), uint32(b), 255}
return col return col
} }
func (self *SkinManager) ChangeSkin( skin_name string ) { func (self *SkinManager) ChangeSkin(skin_name string) {
} }
func (self *SkinManager) Init() { func (self *SkinManager) Init() {
self.Colors = make(map[string]*color.Color) self.Colors = make(map[string]*color.Color)
self.Colors["High"] = &color.Color{51,166,255,255} self.Colors["High"] = &color.Color{51, 166, 255, 255}
self.Colors["Text"] = &color.Color{83,83,83,255} self.Colors["Text"] = &color.Color{83, 83, 83, 255}
self.Colors["ReadOnlyText"] = &color.Color{130,130,130,255} self.Colors["ReadOnlyText"] = &color.Color{130, 130, 130, 255}
self.Colors["Front"] = &color.Color{131,199,219,255} self.Colors["Front"] = &color.Color{131, 199, 219, 255}
self.Colors["URL"] = &color.Color{51,166,255,255} self.Colors["URL"] = &color.Color{51, 166, 255, 255}
self.Colors["Line"] = &color.Color{169,169,169,255} self.Colors["Line"] = &color.Color{169, 169, 169, 255}
self.Colors["TitleBg"] = &color.Color{228,228,228,255} self.Colors["TitleBg"] = &color.Color{228, 228, 228, 255}
self.Colors["Active"] = &color.Color{175,90,0,255} self.Colors["Active"] = &color.Color{175, 90, 0, 255}
self.Colors["Disabled"] = &color.Color{204,204,204,255} self.Colors["Disabled"] = &color.Color{204, 204, 204, 255}
self.Colors["White"] = &color.Color{255,255,255,255} self.Colors["White"] = &color.Color{255, 255, 255, 255}
self.Colors["Black"] = &color.Color{0,0,0,255} self.Colors["Black"] = &color.Color{0, 0, 0, 255}
fname := sysgo.SKIN+"/config.ini" fname := sysgo.SKIN + "/config.ini"
load_opts := ini.LoadOptions{ load_opts := ini.LoadOptions{
IgnoreInlineComment:true, IgnoreInlineComment: true,
} }
cfg, err := ini.LoadSources(load_opts, fname ) cfg, err := ini.LoadSources(load_opts, fname)
if err != nil { if err != nil {
fmt.Printf("Fail to read file: %v\n", err) fmt.Printf("Fail to read file: %v\n", err)
return return
@@ -78,9 +75,9 @@ func (self *SkinManager) Init() {
section := cfg.Section("Colors") section := cfg.Section("Colors")
if section != nil { if section != nil {
colour_opts := section.KeyStrings() colour_opts := section.KeyStrings()
for _,v := range colour_opts { for _, v := range colour_opts {
if _, ok := self.Colors[v]; ok { // has this Color key if _, ok := self.Colors[v]; ok { // has this Color key
parsed_color := self.ConvertToRGB( section.Key(v).String() ) parsed_color := self.ConvertToRGB(section.Key(v).String())
if parsed_color != nil { if parsed_color != nil {
self.Colors[v] = parsed_color self.Colors[v] = parsed_color
} }
@@ -89,13 +86,12 @@ func (self *SkinManager) Init() {
} }
} }
func (self *SkinManager) GiveColor(name string) *color.Color { func (self *SkinManager) GiveColor(name string) *color.Color {
if val,ok := self.Colors[name]; ok { if val, ok := self.Colors[name]; ok {
return val return val
}else { } else {
return &color.Color{255,0,0,255} return &color.Color{255, 0, 0, 255}
} }
} }

56
sysgo/UI/slider.go
View File

@@ -2,67 +2,65 @@ package UI
import ( import (
//"fmt" //"fmt"
//"math" //"math"
//"sync" //"sync"
"github.com/veandco/go-sdl2/sdl" "github.com/veandco/go-sdl2/sdl"
//"github.com/cuu/gogame/surface" //"github.com/cuu/gogame/surface"
//"github.com/cuu/gogame/draw" //"github.com/cuu/gogame/draw"
//"github.com/cuu/gogame/rect" //"github.com/cuu/gogame/rect"
//"github.com/cuu/gogame/font" //"github.com/cuu/gogame/font"
"github.com/cuu/gogame/event" "github.com/cuu/gogame/event"
//"github.com/cuu/gogame/transform" //"github.com/cuu/gogame/transform"
//"github.com/clockworkpi/LauncherGoDev/sysgo/easings" //"github.com/clockworkpi/LauncherGoDev/sysgo/easings"
) )
type SliderInterface interface { type SliderInterface interface {
WidgetInterface WidgetInterface
Init() Init()
SetValue() SetValue()
SetRange(m1,m2 int) SetRange(m1, m2 int)
SetCanvasHWND( canvas *sdl.Surface) SetCanvasHWND(canvas *sdl.Surface)
KeyDown(ev *event.Event) KeyDown(ev *event.Event)
Draw() Draw()
} }
type Slider struct { type Slider struct {
Widget Widget
Value int Value int
CanvasHWND *sdl.Surface CanvasHWND *sdl.Surface
Range [2]int Range [2]int
} }
func NewSlider() *Slider { func NewSlider() *Slider {
p := &Slider{} p := &Slider{}
p.Range = [2]int{0,255} p.Range = [2]int{0, 255}
p.Value = 0 p.Value = 0
return p return p
} }
func (self *Slider) Init() { func (self *Slider) Init() {
self.Value = 0 self.Value = 0
} }
func (self *Slider) SetValue(v int) { func (self *Slider) SetValue(v int) {
self.Value = v self.Value = v
} }
func (self *Slider) SetRange(m1 ,m2 int) { func (self *Slider) SetRange(m1, m2 int) {
if m1 >= m2 { if m1 >= m2 {
return return
} }
self.Range[0] = m1 self.Range[0] = m1
self.Range[1] = m2 self.Range[1] = m2
} }
func (self *Slider) SetCanvasHWND( canvas *sdl.Surface) { func (self *Slider) SetCanvasHWND(canvas *sdl.Surface) {
self.CanvasHWND = canvas self.CanvasHWND = canvas
} }

120
sysgo/UI/sound_patch.go
View File

@@ -1,124 +1,120 @@
package UI package UI
import ( import (
"log" "log"
"github.com/itchyny/volume-go"
"github.com/cuu/gogame/draw" "github.com/cuu/gogame/draw"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
//"github.com/cuu/gogame/color" "github.com/itchyny/volume-go"
//"github.com/cuu/gogame/color"
) )
type SoundPatch struct { type SoundPatch struct {
AboveAllPatch AboveAllPatch
snd_segs [][2]int snd_segs [][2]int
Needle int Needle int
Parent *MainScreen Parent *MainScreen
} }
func NewSoundPatch() *SoundPatch { func NewSoundPatch() *SoundPatch {
p := &SoundPatch{} p := &SoundPatch{}
p.PosX = Width /2 p.PosX = Width / 2
p.PosY = Height /2 p.PosY = Height / 2
p.Width = 50 p.Width = 50
p.Height = 120 p.Height = 120
p.FontObj = Fonts["veramono20"] p.FontObj = Fonts["veramono20"]
p.Color = MySkinManager.GiveColor("Text") p.Color = MySkinManager.GiveColor("Text")
p.ValColor = MySkinManager.GiveColor("URL") p.ValColor = MySkinManager.GiveColor("URL")
p.Icons = make( map[string]IconItemInterface ) p.Icons = make(map[string]IconItemInterface)
p.Value = 0 p.Value = 0
p.snd_segs = [][2]int{ [2]int{0,20},[2]int{21,40},[2]int{41,50}, p.snd_segs = [][2]int{[2]int{0, 20}, [2]int{21, 40}, [2]int{41, 50},
[2]int{51,60},[2]int{61,70},[2]int{71,85}, [2]int{51, 60}, [2]int{61, 70}, [2]int{71, 85},
[2]int{86,90},[2]int{91,95},[2]int{96,100}} [2]int{86, 90}, [2]int{91, 95}, [2]int{96, 100}}
return p
return p
} }
func (self *SoundPatch) Init() { func (self *SoundPatch) Init() {
self.SetCanvasHWND(self.Parent.CanvasHWND) self.SetCanvasHWND(self.Parent.CanvasHWND)
} }
func (self *SoundPatch) VolumeUp() int { func (self *SoundPatch) VolumeUp() int {
vol, err := volume.GetVolume() vol, err := volume.GetVolume()
if err != nil { if err != nil {
log.Printf("SoundPatch VolumeUp get volume failed: %+v", err) log.Printf("SoundPatch VolumeUp get volume failed: %+v", err)
vol = 0 vol = 0
} }
for i,v := range self.snd_segs { for i, v := range self.snd_segs {
if vol >= v[0] && vol <= v[1] { if vol >= v[0] && vol <= v[1] {
self.Needle = i self.Needle = i
break break
} }
} }
self.Needle += 1 self.Needle += 1
if self.Needle > len(self.snd_segs) -1 { if self.Needle > len(self.snd_segs)-1 {
self.Needle = len(self.snd_segs) -1 self.Needle = len(self.snd_segs) - 1
} }
val := self.snd_segs[self.Needle][0] + (self.snd_segs[self.Needle][1] - self.snd_segs[self.Needle][0])/2 val := self.snd_segs[self.Needle][0] + (self.snd_segs[self.Needle][1]-self.snd_segs[self.Needle][0])/2
volume.SetVolume(val) volume.SetVolume(val)
self.Value = self.snd_segs[self.Needle][1] self.Value = self.snd_segs[self.Needle][1]
self.Parent.TitleBar.SetSoundVolume(val) self.Parent.TitleBar.SetSoundVolume(val)
return self.Value return self.Value
} }
func (self *SoundPatch) VolumeDown() int { func (self *SoundPatch) VolumeDown() int {
vol, err := volume.GetVolume() vol, err := volume.GetVolume()
if err != nil { if err != nil {
log.Printf("SoundPatch VolumeDown get volume failed: %+v\n", err) log.Printf("SoundPatch VolumeDown get volume failed: %+v\n", err)
vol = 0 vol = 0
} }
for i,v := range self.snd_segs { for i, v := range self.snd_segs {
if vol >= v[0] && vol <= v[1] { if vol >= v[0] && vol <= v[1] {
self.Needle = i self.Needle = i
break break
} }
} }
self.Needle -= 1 self.Needle -= 1
if self.Needle < 0 { if self.Needle < 0 {
self.Needle = 0 self.Needle = 0
} }
val := self.snd_segs[self.Needle][0] val := self.snd_segs[self.Needle][0]
if val < 0 { if val < 0 {
val = 0 val = 0
} }
volume.SetVolume(val) volume.SetVolume(val)
self.Value = val self.Value = val
self.Parent.TitleBar.SetSoundVolume(val) self.Parent.TitleBar.SetSoundVolume(val)
return self.Value return self.Value
} }
func (self *SoundPatch) Draw() { func (self *SoundPatch) Draw() {
for i:=0;i< (self.Needle+1);i++ { for i := 0; i < (self.Needle + 1); i++ {
vol_rect := rect.Rect(80+i*20, self.Height/2+20,10, 40) vol_rect := rect.Rect(80+i*20, self.Height/2+20, 10, 40)
draw.AARoundRect(self.CanvasHWND,&vol_rect,MySkinManager.GiveColor("Front"),3,0,MySkinManager.GiveColor("Front")) draw.AARoundRect(self.CanvasHWND, &vol_rect, MySkinManager.GiveColor("Front"), 3, 0, MySkinManager.GiveColor("Front"))
} }
} }

32
sysgo/UI/text_item.go
View File

@@ -1,33 +1,28 @@
package UI package UI
import ( import (
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/surface"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
"github.com/cuu/gogame/font"
"github.com/cuu/gogame/draw" "github.com/cuu/gogame/draw"
"github.com/cuu/gogame/font"
"github.com/cuu/gogame/surface"
) )
type TextItemInterface interface{ type TextItemInterface interface {
IconItemInterface
IconItemInterface
GetBold() bool GetBold() bool
SetBold(bold bool) SetBold(bold bool)
GetStr() string GetStr() string
} }
type TextItem struct { type TextItem struct {
IconItem IconItem
Str string Str string
Color *color.Color Color *color.Color
FontObj *ttf.Font FontObj *ttf.Font
Bold bool Bold bool
} }
func NewTextItem() *TextItem { func NewTextItem() *TextItem {
@@ -35,9 +30,9 @@ func NewTextItem() *TextItem {
p.Align = ALIGN["VCenter"] p.Align = ALIGN["VCenter"]
p.Color = &color.Color{83,83,83,255} p.Color = &color.Color{83, 83, 83, 255}
p.MyType = ICON_TYPES["LETTER"] p.MyType = ICON_TYPES["LETTER"]
p.Bold = false p.Bold = false
return p return p
} }
@@ -55,9 +50,9 @@ func (self *TextItem) GetStr() string {
} }
func (self *TextItem) Draw() { func (self *TextItem) Draw() {
font.SetBold(self.FontObj,self.Bold) font.SetBold(self.FontObj, self.Bold)
my_text := font.Render(self.FontObj,self.Str,true,self.Color,nil) my_text := font.Render(self.FontObj, self.Str, true, self.Color, nil)
if surface.GetWidth(my_text) != self.Width { if surface.GetWidth(my_text) != self.Width {
self.Width = surface.GetWidth(my_text) self.Width = surface.GetWidth(my_text)
@@ -67,8 +62,7 @@ func (self *TextItem) Draw() {
self.Height = surface.GetHeight(my_text) self.Height = surface.GetHeight(my_text)
} }
rect_ := draw.MidRect(self.PosX, self.PosY, self.Width, self.Height, Width, Height)
rect_ := draw.MidRect(self.PosX,self.PosY,self.Width,self.Height,Width,Height) surface.Blit(self.Parent.GetCanvasHWND(), my_text, rect_, nil)
surface.Blit(self.Parent.GetCanvasHWND(),my_text,rect_,nil)
my_text.Free() my_text.Free()
} }

112
sysgo/UI/textarea.go
View File

@@ -7,25 +7,25 @@ import (
"github.com/veandco/go-sdl2/sdl" "github.com/veandco/go-sdl2/sdl"
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/surface"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
"github.com/cuu/gogame/draw" "github.com/cuu/gogame/draw"
"github.com/cuu/gogame/font" "github.com/cuu/gogame/font"
"github.com/cuu/gogame/rect" "github.com/cuu/gogame/rect"
"github.com/cuu/gogame/surface"
) )
type Textarea struct { type Textarea struct {
Widget Widget
BackgroundColor *color.Color BackgroundColor *color.Color
CanvasHWND *sdl.Surface CanvasHWND *sdl.Surface
MyWords []string MyWords []string
BlitWords []string BlitWords []string
FontObj *ttf.Font FontObj *ttf.Font
LineNumber int LineNumber int
TextLimit int TextLimit int
TextFull bool TextFull bool
TextIndex int TextIndex int
BlitIndex int BlitIndex int
} }
func NewTextarea() *Textarea { func NewTextarea() *Textarea {
@@ -34,10 +34,10 @@ func NewTextarea() *Textarea {
p.TextLimit = 63 p.TextLimit = 63
p.TextFull = false p.TextFull = false
p.MyWords = make([]string,0) p.MyWords = make([]string, 0)
p.BlitWords = make([]string,0) p.BlitWords = make([]string, 0)
p.BackgroundColor = &color.Color{228,228,228,255} p.BackgroundColor = &color.Color{228, 228, 228, 255}
return p return p
} }
@@ -70,15 +70,14 @@ func (self *Textarea) RemoveFromLastText() []string {
if len(self.MyWords) > 0 { if len(self.MyWords) > 0 {
self.SubTextIndex() self.SubTextIndex()
if self.TextIndex < len(self.MyWords) { if self.TextIndex < len(self.MyWords) {
self.MyWords = append(self.MyWords[:self.TextIndex],self.MyWords[(self.TextIndex+1):]...) self.MyWords = append(self.MyWords[:self.TextIndex], self.MyWords[(self.TextIndex+1):]...)
} }
} }
return self.MyWords return self.MyWords
} }
func (self *Textarea) AppendText(alphabet string) {
func (self *Textarea) AppendText( alphabet string) {
self.AppendAndBlitText(alphabet) self.AppendAndBlitText(alphabet)
} }
@@ -87,61 +86,60 @@ func (self *Textarea) AppendAndBlitText(alphabet string) {
if self.TextIndex <= len(self.MyWords) { if self.TextIndex <= len(self.MyWords) {
self.MyWords = append(self.MyWords[:self.TextIndex], self.MyWords = append(self.MyWords[:self.TextIndex],
append([]string{alphabet},self.MyWords[self.TextIndex:]...)...) append([]string{alphabet}, self.MyWords[self.TextIndex:]...)...)
self.BlitText() self.BlitText()
self.AddTextIndex() self.AddTextIndex()
} }
}else { } else {
fmt.Printf("is Full %s\n",strings.Join(self.MyWords,"")) fmt.Printf("is Full %s\n", strings.Join(self.MyWords, ""))
} }
} }
func (self *Textarea) BuildBlitText() { func (self *Textarea) BuildBlitText() {
blit_rows := make([][]string,0) blit_rows := make([][]string, 0)
blit_rows = append(blit_rows,[]string{}) blit_rows = append(blit_rows, []string{})
w := 0 w := 0
// xmargin := 5 // xmargin := 5
endmargin :=15 endmargin := 15
linenumber := 0 linenumber := 0
cursor_row := 0 cursor_row := 0
for i, v := range self.MyWords {
for i,v := range self.MyWords { t := font.Render(self.FontObj, v, true, &color.Color{8, 135, 174, 255}, nil)
t := font.Render(self.FontObj,v,true,&color.Color{8,135,174,255},nil)
t_width := surface.GetWidth(t) t_width := surface.GetWidth(t)
w+=t_width w += t_width
blit_rows[linenumber] = append(blit_rows[linenumber],v) blit_rows[linenumber] = append(blit_rows[linenumber], v)
if i == self.TextIndex - 1 { if i == self.TextIndex-1 {
cursor_row = linenumber cursor_row = linenumber
} }
if w + t_width >= self.Width - endmargin { if w+t_width >= self.Width-endmargin {
w = 0 w = 0
linenumber += 1 linenumber += 1
blit_rows = append(blit_rows,[]string{}) blit_rows = append(blit_rows, []string{})
} }
t.Free() t.Free()
} }
if len(blit_rows) == 1 { if len(blit_rows) == 1 {
self.BlitWords = blit_rows[0] self.BlitWords = blit_rows[0]
self.BlitIndex = self.TextIndex self.BlitIndex = self.TextIndex
}else if len(blit_rows) == 2 || cursor_row < 2 { } else if len(blit_rows) == 2 || cursor_row < 2 {
self.BlitWords = append(blit_rows[0], blit_rows[1]...) self.BlitWords = append(blit_rows[0], blit_rows[1]...)
self.BlitIndex = self.TextIndex self.BlitIndex = self.TextIndex
}else { } else {
self.BlitWords = append(blit_rows[cursor_row-1], blit_rows[cursor_row]...) self.BlitWords = append(blit_rows[cursor_row-1], blit_rows[cursor_row]...)
self.BlitIndex = self.TextIndex self.BlitIndex = self.TextIndex
for i,v := range blit_rows { for i, v := range blit_rows {
if i == cursor_row - 1 { if i == cursor_row-1 {
break break
} }
self.BlitIndex -= len(v) self.BlitIndex -= len(v)
@@ -165,23 +163,23 @@ func (self *Textarea) BlitText() {
if len(self.MyWords) > self.TextLimit { if len(self.MyWords) > self.TextLimit {
self.TextFull = true self.TextFull = true
}else { } else {
self.TextFull = false self.TextFull = false
} }
for _,v := range self.BlitWords { for _, v := range self.BlitWords {
t := font.Render(self.FontObj,v,true,&color.Color{8,135,174,255},nil) t := font.Render(self.FontObj, v, true, &color.Color{8, 135, 174, 255}, nil)
w += surface.GetWidth(t) w += surface.GetWidth(t)
if w >= self.Width - endmargin && linenumber == 0 { if w >= self.Width-endmargin && linenumber == 0 {
linenumber += 1 linenumber += 1
x = self.PosX + xmargin x = self.PosX + xmargin
y = self.PosY + surface.GetHeight(t) * linenumber y = self.PosY + surface.GetHeight(t)*linenumber
w = 0 w = 0
} }
rect_ := rect.Rect(x,y,0,0) rect_ := rect.Rect(x, y, 0, 0)
surface.Blit(self.CanvasHWND,t,&rect_,nil) surface.Blit(self.CanvasHWND, t, &rect_, nil)
x += surface.GetWidth(t) x += surface.GetWidth(t)
t.Free() t.Free()
} }
@@ -191,40 +189,40 @@ func (self *Textarea) Cursor() {
w := 0 w := 0
xmargin := 5 xmargin := 5
endmargin := 15 endmargin := 15
x := self.PosX+xmargin x := self.PosX + xmargin
y := self.PosY y := self.PosY
linenumber := 0 linenumber := 0
for _,v := range self.BlitWords[:self.BlitIndex] { for _, v := range self.BlitWords[:self.BlitIndex] {
t := font.Render(self.FontObj,v,true,&color.Color{8,135,174,255},nil) t := font.Render(self.FontObj, v, true, &color.Color{8, 135, 174, 255}, nil)
w += surface.GetWidth(t) w += surface.GetWidth(t)
if w >= self.Width - endmargin && linenumber == 0 { if w >= self.Width-endmargin && linenumber == 0 {
x = self.PosX + xmargin x = self.PosX + xmargin
y = self.PosY + surface.GetHeight(t) y = self.PosY + surface.GetHeight(t)
w = 0 w = 0
linenumber +=1 linenumber += 1
} }
if w >= self.Width - endmargin*3 && linenumber > 0 { if w >= self.Width-endmargin*3 && linenumber > 0 {
x += surface.GetWidth(t) x += surface.GetWidth(t)
break break
} }
x += surface.GetWidth(t) x += surface.GetWidth(t)
t.Free() t.Free()
} }
c_t := font.Render(self.FontObj,"_",true,&color.Color{0,0,0,255},nil) c_t := font.Render(self.FontObj, "_", true, &color.Color{0, 0, 0, 255}, nil)
rect_ := rect.Rect(x+1,y-2,0,0) rect_ := rect.Rect(x+1, y-2, 0, 0)
surface.Blit(self.CanvasHWND,c_t,&rect_,nil) surface.Blit(self.CanvasHWND, c_t, &rect_, nil)
c_t.Free() c_t.Free()
} }
func (self *Textarea) Draw() { func (self *Textarea) Draw() {
rect_:= rect.Rect(self.PosX,self.PosY,self.Width,self.Height) rect_ := rect.Rect(self.PosX, self.PosY, self.Width, self.Height)
draw.AARoundRect(self.CanvasHWND,&rect_,self.BackgroundColor,4,0,self.BackgroundColor) draw.AARoundRect(self.CanvasHWND, &rect_, self.BackgroundColor, 4, 0, self.BackgroundColor)
self.BlitText() self.BlitText()
self.Cursor() self.Cursor()

387
sysgo/UI/title_bar.go
View File

@@ -1,33 +1,30 @@
package UI package UI
import ( import (
"fmt"
"os"
"log"
"strconv"
"bufio" "bufio"
"fmt"
"io/ioutil"
"log"
"os"
"os/exec"
"strconv"
"strings" "strings"
"os/exec"
"io/ioutil"
gotime "time" gotime "time"
"github.com/veandco/go-sdl2/sdl" "github.com/veandco/go-sdl2/sdl"
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/surface"
"github.com/cuu/gogame/rect"
"github.com/cuu/gogame/font"
"github.com/cuu/gogame/draw" "github.com/cuu/gogame/draw"
"github.com/cuu/gogame/font"
"github.com/cuu/gogame/rect"
"github.com/cuu/gogame/surface"
"github.com/itchyny/volume-go" "github.com/itchyny/volume-go"
"github.com/vjeantet/jodaTime" "github.com/vjeantet/jodaTime"
"github.com/clockworkpi/LauncherGoDev/sysgo" "github.com/clockworkpi/LauncherGoDev/sysgo"
) )
var TitleBar_BarHeight = 24 var TitleBar_BarHeight = 24
type TitleBarIconItem struct { type TitleBarIconItem struct {
@@ -45,7 +42,7 @@ func NewTitleBarIconItem() *TitleBarIconItem {
} }
func (self *TitleBarIconItem) Adjust(x,y,w,h,at int) { func (self *TitleBarIconItem) Adjust(x, y, w, h, at int) {
self.PosX = x self.PosX = x
self.PosY = y self.PosY = y
self.Width = w self.Width = w
@@ -57,20 +54,20 @@ func (self *TitleBarIconItem) Adjust(x,y,w,h,at int) {
} }
self.CreateImgSurf() self.CreateImgSurf()
// self.AdjustLinkPage() // self.AdjustLinkPage()
} }
func (self *TitleBarIconItem) Draw() { func (self *TitleBarIconItem) Draw() {
parent_x,parent_y := self.Parent.PosX,self.Parent.PosY parent_x, parent_y := self.Parent.PosX, self.Parent.PosY
if self.Label != nil { if self.Label != nil {
// lab_x,lab_y := self.Label.Coord() // lab_x,lab_y := self.Label.Coord()
lab_w,lab_h:= self.Label.Size() lab_w, lab_h := self.Label.Size()
if self.Align == ALIGN["VCenter"] { if self.Align == ALIGN["VCenter"] {
self.Label.NewCoord( self.PosX - lab_w/2 + parent_x, self.PosY + self.Height/2+6 + parent_y) self.Label.NewCoord(self.PosX-lab_w/2+parent_x, self.PosY+self.Height/2+6+parent_y)
}else if self.Align == ALIGN["HLeft"] { } else if self.Align == ALIGN["HLeft"] {
self.Label.NewCoord( self.PosX + self.Width/2+3 + parent_x, self.PosY - lab_h/2 + parent_y ) self.Label.NewCoord(self.PosX+self.Width/2+3+parent_x, self.PosY-lab_h/2+parent_y)
} }
self.Label.Draw() self.Label.Draw()
@@ -78,42 +75,40 @@ func (self *TitleBarIconItem) Draw() {
if self.ImgSurf != nil { if self.ImgSurf != nil {
portion := rect.Rect(0,self.IconIndex*self.IconHeight,self.IconWidth,self.IconHeight) portion := rect.Rect(0, self.IconIndex*self.IconHeight, self.IconWidth, self.IconHeight)
surface.Blit(self.Parent.CanvasHWND, surface.Blit(self.Parent.CanvasHWND,
self.ImgSurf,draw.MidRect(self.PosX + parent_x, self.PosY + parent_y, self.ImgSurf, draw.MidRect(self.PosX+parent_x, self.PosY+parent_y,
self.Width,self.Height, Width, Height),&portion) self.Width, self.Height, Width, Height), &portion)
} }
} }
type TitleBar struct { type TitleBar struct {
Widget Widget
BarHeight int BarHeight int
LOffset int LOffset int
ROffset int ROffset int
Icons map[string]IconItemInterface Icons map[string]IconItemInterface
IconWidth int IconWidth int
IconHeight int IconHeight int
BorderWidth int BorderWidth int
CanvasHWND *sdl.Surface CanvasHWND *sdl.Surface
HWND *sdl.Surface HWND *sdl.Surface
Title string Title string
InLowBackLight int InLowBackLight int
InAirPlaneMode bool InAirPlaneMode bool
SkinManager *SkinManager //set by MainScreen SkinManager *SkinManager //set by MainScreen
icon_base_path string /// SkinMap("gameshell/titlebar_icons/") icon_base_path string /// SkinMap("gameshell/titlebar_icons/")
MyTimeLocation *gotime.Location MyTimeLocation *gotime.Location
TitleFont *ttf.Font TitleFont *ttf.Font
TimeFont *ttf.Font TimeFont *ttf.Font
} }
func NewTitleBar() *TitleBar { func NewTitleBar() *TitleBar {
t := &TitleBar{} t := &TitleBar{}
@@ -132,12 +127,12 @@ func NewTitleBar() *TitleBar {
t.Icons = make(map[string]IconItemInterface) t.Icons = make(map[string]IconItemInterface)
t.icon_base_path = SkinMap("sysgo/gameshell/titlebar_icons/") t.icon_base_path = SkinMap("sysgo/gameshell/titlebar_icons/")
t.TitleFont = Fonts["varela16"] t.TitleFont = Fonts["varela16"]
t.TimeFont = Fonts["varela12"] t.TimeFont = Fonts["varela12"]
t.InLowBackLight = -1 t.InLowBackLight = -1
return t return t
} }
@@ -145,42 +140,42 @@ func NewTitleBar() *TitleBar {
func (self *TitleBar) RoundRobinCheck() { func (self *TitleBar) RoundRobinCheck() {
for { for {
if self.InLowBackLight < 0 { if self.InLowBackLight < 0 {
self.CheckBatteryStat() self.CheckBatteryStat()
self.CheckBluetooth() self.CheckBluetooth()
self.UpdateWifiStrength() self.UpdateWifiStrength()
SwapAndShow() SwapAndShow()
}else if self.InLowBackLight >= 0 { } else if self.InLowBackLight >= 0 {
self.InLowBackLight +=1 self.InLowBackLight += 1
if self.InLowBackLight > 10 { if self.InLowBackLight > 10 {
self.CheckBatteryStat() self.CheckBatteryStat()
self.CheckBluetooth() self.CheckBluetooth()
self.UpdateWifiStrength() self.UpdateWifiStrength()
self.InLowBackLight = 0 // reset self.InLowBackLight = 0 // reset
} }
} }
gotime.Sleep(3000 * gotime.Millisecond) gotime.Sleep(3000 * gotime.Millisecond)
} }
} }
func (self *TitleBar) IsWifiConnectedNow() bool { func (self *TitleBar) IsWifiConnectedNow() bool {
cli := fmt.Sprintf( "ip -4 addr show %s | grep -oP '(?<=inet\\s)\\d+(\\.\\d+){3}'",sysgo.WifiDev) cli := fmt.Sprintf("ip -4 addr show %s | grep -oP '(?<=inet\\s)\\d+(\\.\\d+){3}'", sysgo.WifiDev)
out := System(cli) out := System(cli)
if(len(out) > 7) { if len(out) > 7 {
if strings.Contains(out,"not") { if strings.Contains(out, "not") {
return false return false
}else { } else {
return true return true
} }
} }
return false return false
} }
@@ -189,29 +184,29 @@ func (self *TitleBar) UpdateWifiStrength() {
} }
func (t *TitleBar) GetWifiStrength() int { func (t *TitleBar) GetWifiStrength() int {
qua := 0 qua := 0
cli := fmt.Sprintf("iwconfig %s | grep Signal | /usr/bin/awk '{print $4}' | /usr/bin/cut -d'=' -f2",sysgo.WifiDev) cli := fmt.Sprintf("iwconfig %s | grep Signal | /usr/bin/awk '{print $4}' | /usr/bin/cut -d'=' -f2", sysgo.WifiDev)
out := System(cli) out := System(cli)
if(len(out) > 2) { if len(out) > 2 {
if strings.Contains(out,"No") == false { if strings.Contains(out, "No") == false {
out = strings.TrimSuffix(out, "\n") out = strings.TrimSuffix(out, "\n")
stren,err := strconv.ParseInt(out, 10, 0) stren, err := strconv.ParseInt(out, 10, 0)
if err == nil { if err == nil {
qua = 2 * (int(stren) + 100) qua = 2 * (int(stren) + 100)
}else { } else {
fmt.Println(err) fmt.Println(err)
} }
} }
} }
segs := [][]int{ []int{-2,-1}, []int{0,25}, []int{25,50}, []int{50,75},[]int{75,100}} segs := [][]int{[]int{-2, -1}, []int{0, 25}, []int{25, 50}, []int{50, 75}, []int{75, 100}}
stren_number := qua stren_number := qua
ge := 0 ge := 0
if stren_number == 0 { if stren_number == 0 {
return ge return ge
} }
for i,v := range segs { for i, v := range segs {
if stren_number >= v[0] && stren_number <= v[1] { if stren_number >= v[0] && stren_number <= v[1] {
ge = i ge = i
break break
@@ -223,17 +218,17 @@ func (t *TitleBar) GetWifiStrength() int {
func (self *TitleBar) SyncSoundVolume() { func (self *TitleBar) SyncSoundVolume() {
vol, err := volume.GetVolume() vol, err := volume.GetVolume()
if err != nil { if err != nil {
log.Printf("TitleBar SyncSoundVolume get volume failed: %+v\n", err) log.Printf("TitleBar SyncSoundVolume get volume failed: %+v\n", err)
vol = 0 vol = 0
} }
fmt.Printf("TitleBar SyncSoundVolume current volume: %d\n", vol) fmt.Printf("TitleBar SyncSoundVolume current volume: %d\n", vol)
snd_segs := [][]int{ []int{0,10}, []int{10,30}, []int{30,70},[]int{70,100} } snd_segs := [][]int{[]int{0, 10}, []int{10, 30}, []int{30, 70}, []int{70, 100}}
ge := 0 ge := 0
for i,v := range snd_segs { for i, v := range snd_segs {
if vol >= v[0] && vol <= v[1] { if vol >= v[0] && vol <= v[1] {
ge = i ge = i
break break
@@ -248,10 +243,10 @@ func (self *TitleBar) SyncSoundVolume() {
// for outside widget to update sound icon // for outside widget to update sound icon
func (self *TitleBar) SetSoundVolume(vol int) { func (self *TitleBar) SetSoundVolume(vol int) {
snd_segs := [][]int{ []int{0,10}, []int{10,30}, []int{30,70},[]int{70,100} } snd_segs := [][]int{[]int{0, 10}, []int{10, 30}, []int{30, 70}, []int{70, 100}}
ge := 0 ge := 0
for i,v := range snd_segs { for i, v := range snd_segs {
if vol >= v[0] && vol <= v[1] { if vol >= v[0] && vol <= v[1] {
ge = i ge = i
break break
@@ -264,14 +259,14 @@ func (self *TitleBar) SetSoundVolume(vol int) {
} }
func (self *TitleBar) CheckBatteryStat() { func (self *TitleBar) CheckBatteryStat() {
bat_segs:= [][]int{[]int{0,6},[]int{7,15},[]int{16,20},[]int{21,30},[]int{31,50},[]int{51,60},[]int{61,80},[]int{81,90},[]int{91,100}} bat_segs := [][]int{[]int{0, 6}, []int{7, 15}, []int{16, 20}, []int{21, 30}, []int{31, 50}, []int{51, 60}, []int{61, 80}, []int{81, 90}, []int{91, 100}}
if FileExists(sysgo.Battery) == false { if FileExists(sysgo.Battery) == false {
self.Icons["battery"] = self.Icons["battery_unknown"] self.Icons["battery"] = self.Icons["battery_unknown"]
return return
} }
file, err := os.Open( sysgo.Battery ) file, err := os.Open(sysgo.Battery)
if err != nil { if err != nil {
fmt.Println("Could not open file ", sysgo.Battery) fmt.Println("Could not open file ", sysgo.Battery)
self.Icons["battery"] = self.Icons["battery_unknown"] self.Icons["battery"] = self.Icons["battery_unknown"]
@@ -282,29 +277,29 @@ func (self *TitleBar) CheckBatteryStat() {
bat_uevent := make(map[string]string) bat_uevent := make(map[string]string)
scanner := bufio.NewScanner(file) scanner := bufio.NewScanner(file)
scanner.Split(bufio.ScanLines) scanner.Split(bufio.ScanLines)
for scanner.Scan() { for scanner.Scan() {
line := scanner.Text() line := scanner.Text()
line = strings.Trim(line," ") line = strings.Trim(line, " ")
pis := strings.Split(line,"=") pis := strings.Split(line, "=")
if len(pis) > 1 { if len(pis) > 1 {
bat_uevent[ pis[0] ] = pis[1] bat_uevent[pis[0]] = pis[1]
} }
} }
cur_cap := 0 cur_cap := 0
if val, ok := bat_uevent["POWER_SUPPLY_CAPACITY"]; ok { if val, ok := bat_uevent["POWER_SUPPLY_CAPACITY"]; ok {
cur_cap,_ = strconv.Atoi(val) cur_cap, _ = strconv.Atoi(val)
}else { } else {
cur_cap = 0 cur_cap = 0
} }
cap_ge := 0 cap_ge := 0
for i,v := range bat_segs { for i, v := range bat_segs {
if cur_cap >= v[0] && cur_cap <= v[1] { if cur_cap >= v[0] && cur_cap <= v[1] {
cap_ge = i cap_ge = i
break break
@@ -315,7 +310,7 @@ func (self *TitleBar) CheckBatteryStat() {
if val == "Charging" { if val == "Charging" {
self.Icons["battery_charging"].SetIconIndex(cap_ge) self.Icons["battery_charging"].SetIconIndex(cap_ge)
self.Icons["battery"] = self.Icons["battery_charging"] self.Icons["battery"] = self.Icons["battery_charging"]
}else { } else {
self.Icons["battery_discharging"].SetIconIndex(cap_ge) self.Icons["battery_discharging"].SetIconIndex(cap_ge)
self.Icons["battery"] = self.Icons["battery_discharging"] self.Icons["battery"] = self.Icons["battery_discharging"]
} }
@@ -323,27 +318,27 @@ func (self *TitleBar) CheckBatteryStat() {
} }
func (self *TitleBar) SetBatteryStat( bat int) { func (self *TitleBar) SetBatteryStat(bat int) {
} }
func (self *TitleBar) CheckBluetooth() { func (self *TitleBar) CheckBluetooth() {
out := System("hcitool dev | grep hci0 |cut -f3") out := System("hcitool dev | grep hci0 |cut -f3")
if len(out) < 17 { if len(out) < 17 {
fmt.Println("Titlebar CheckBluetooth: no bluetooth",out) fmt.Println("Titlebar CheckBluetooth: no bluetooth", out)
self.Icons["bluetooth"].SetIconIndex(2) self.Icons["bluetooth"].SetIconIndex(2)
return return
}else { } else {
out = System("sudo rfkill list | grep hci0 -A 2 | grep yes") out = System("sudo rfkill list | grep hci0 -A 2 | grep yes")
if len(out) > 10 { if len(out) > 10 {
self.Icons["bluetooth"].SetIconIndex(1) self.Icons["bluetooth"].SetIconIndex(1)
return return
} }
} }
self.Icons["bluetooth"].SetIconIndex(0) self.Icons["bluetooth"].SetIconIndex(0)
} }
@@ -351,41 +346,41 @@ func (self *TitleBar) Init(main_screen *MainScreen) {
start_x := 0 start_x := 0
self.CanvasHWND = surface.Surface(self.Width,self.Height) self.CanvasHWND = surface.Surface(self.Width, self.Height)
self.HWND = main_screen.HWND self.HWND = main_screen.HWND
self.SkinManager = main_screen.SkinManager self.SkinManager = main_screen.SkinManager
icon_wifi_status := NewTitleBarIconItem() icon_wifi_status := NewTitleBarIconItem()
icon_wifi_status.MyType = ICON_TYPES["STAT"] icon_wifi_status.MyType = ICON_TYPES["STAT"]
icon_wifi_status.ImageName = self.icon_base_path+"wifi.png" icon_wifi_status.ImageName = self.icon_base_path + "wifi.png"
icon_wifi_status.Parent = self icon_wifi_status.Parent = self
icon_wifi_status.Adjust(start_x+self.IconWidth+5,self.IconHeight/2+(self.BarHeight-self.IconHeight)/2,self.IconWidth,self.IconHeight,0) icon_wifi_status.Adjust(start_x+self.IconWidth+5, self.IconHeight/2+(self.BarHeight-self.IconHeight)/2, self.IconWidth, self.IconHeight, 0)
self.Icons["wifistatus"] = icon_wifi_status self.Icons["wifistatus"] = icon_wifi_status
battery_charging := NewTitleBarIconItem() battery_charging := NewTitleBarIconItem()
battery_charging.MyType = ICON_TYPES["STAT"] battery_charging.MyType = ICON_TYPES["STAT"]
battery_charging.Parent = self battery_charging.Parent = self
battery_charging.ImageName = self.icon_base_path+"withcharging.png" battery_charging.ImageName = self.icon_base_path + "withcharging.png"
battery_charging.Adjust(start_x+self.IconWidth+self.IconWidth+8,self.IconHeight/2+(self.BarHeight-self.IconHeight)/2,self.IconWidth,self.IconHeight,0) battery_charging.Adjust(start_x+self.IconWidth+self.IconWidth+8, self.IconHeight/2+(self.BarHeight-self.IconHeight)/2, self.IconWidth, self.IconHeight, 0)
self.Icons["battery_charging"] = battery_charging self.Icons["battery_charging"] = battery_charging
battery_discharging := NewTitleBarIconItem() battery_discharging := NewTitleBarIconItem()
battery_discharging.MyType = ICON_TYPES["STAT"] battery_discharging.MyType = ICON_TYPES["STAT"]
battery_discharging.Parent = self battery_discharging.Parent = self
battery_discharging.ImageName = self.icon_base_path+"without_charging.png" battery_discharging.ImageName = self.icon_base_path + "without_charging.png"
battery_discharging.Adjust(start_x+self.IconWidth+self.IconWidth+8,self.IconHeight/2+(self.BarHeight-self.IconHeight)/2,self.IconWidth,self.IconHeight,0) battery_discharging.Adjust(start_x+self.IconWidth+self.IconWidth+8, self.IconHeight/2+(self.BarHeight-self.IconHeight)/2, self.IconWidth, self.IconHeight, 0)
self.Icons["battery_discharging"] = battery_discharging self.Icons["battery_discharging"] = battery_discharging
battery_unknown := NewTitleBarIconItem() battery_unknown := NewTitleBarIconItem()
battery_unknown.MyType = ICON_TYPES["STAT"] battery_unknown.MyType = ICON_TYPES["STAT"]
battery_unknown.Parent = self battery_unknown.Parent = self
battery_unknown.ImageName = self.icon_base_path+"battery_unknown.png" battery_unknown.ImageName = self.icon_base_path + "battery_unknown.png"
battery_unknown.Adjust(start_x+self.IconWidth+self.IconWidth+8,self.IconHeight/2+(self.BarHeight-self.IconHeight)/2,self.IconWidth,self.IconHeight,0) battery_unknown.Adjust(start_x+self.IconWidth+self.IconWidth+8, self.IconHeight/2+(self.BarHeight-self.IconHeight)/2, self.IconWidth, self.IconHeight, 0)
self.Icons["battery_unknown"] = battery_unknown self.Icons["battery_unknown"] = battery_unknown
@@ -394,22 +389,21 @@ func (self *TitleBar) Init(main_screen *MainScreen) {
sound_volume := NewTitleBarIconItem() sound_volume := NewTitleBarIconItem()
sound_volume.MyType = ICON_TYPES["STAT"] sound_volume.MyType = ICON_TYPES["STAT"]
sound_volume.Parent = self sound_volume.Parent = self
sound_volume.ImageName = self.icon_base_path+"soundvolume.png" sound_volume.ImageName = self.icon_base_path + "soundvolume.png"
sound_volume.Adjust(start_x+self.IconWidth+self.IconWidth+8,self.IconHeight/2+(self.BarHeight-self.IconHeight)/2,self.IconWidth,self.IconHeight,0) sound_volume.Adjust(start_x+self.IconWidth+self.IconWidth+8, self.IconHeight/2+(self.BarHeight-self.IconHeight)/2, self.IconWidth, self.IconHeight, 0)
self.Icons["soundvolume"] = sound_volume self.Icons["soundvolume"] = sound_volume
self.SyncSoundVolume() self.SyncSoundVolume()
bluetooth := NewTitleBarIconItem() bluetooth := NewTitleBarIconItem()
bluetooth.MyType = ICON_TYPES["STAT"] bluetooth.MyType = ICON_TYPES["STAT"]
bluetooth.Parent = self bluetooth.Parent = self
bluetooth.ImageName = self.icon_base_path+"bluetooth.png" bluetooth.ImageName = self.icon_base_path + "bluetooth.png"
bluetooth.Adjust(start_x+self.IconWidth+self.IconWidth+8,self.IconHeight/2+(self.BarHeight-self.IconHeight)/2,self.IconWidth,self.IconHeight,0) bluetooth.Adjust(start_x+self.IconWidth+self.IconWidth+8, self.IconHeight/2+(self.BarHeight-self.IconHeight)/2, self.IconWidth, self.IconHeight, 0)
self.Icons["bluetooth"] = bluetooth
self.CheckBluetooth()
self.Icons["bluetooth"] = bluetooth
self.CheckBluetooth()
round_corners := NewTitleBarIconItem() round_corners := NewTitleBarIconItem()
round_corners.IconWidth = 10 round_corners.IconWidth = 10
@@ -418,37 +412,37 @@ func (self *TitleBar) Init(main_screen *MainScreen) {
round_corners.MyType = ICON_TYPES["STAT"] round_corners.MyType = ICON_TYPES["STAT"]
round_corners.Parent = self round_corners.Parent = self
round_corners.ImgSurf = MyIconPool.GetImgSurf("roundcorners") round_corners.ImgSurf = MyIconPool.GetImgSurf("roundcorners")
round_corners.Adjust(0,0,10,10,0) round_corners.Adjust(0, 0, 10, 10, 0)
self.Icons["round_corners"] = round_corners self.Icons["round_corners"] = round_corners
if self.IsWifiConnectedNow() { if self.IsWifiConnectedNow() {
print("wifi is connected") print("wifi is connected")
}else { } else {
cmd := "sudo rfkill list | grep yes | cut -d \" \" -f3" //make sure sudo rfkill needs no password cmd := "sudo rfkill list | grep yes | cut -d \" \" -f3" //make sure sudo rfkill needs no password
out, err := exec.Command("bash", "-c", cmd).Output() out, err := exec.Command("bash", "-c", cmd).Output()
if err != nil { if err != nil {
fmt.Printf("Failed to execute command: %s\n", cmd) fmt.Printf("Failed to execute command: %s\n", cmd)
}else { } else {
outs := strings.Split(string(out),"\n") outs := strings.Split(string(out), "\n")
if len(outs) > 0 && outs[0] == "yes" { if len(outs) > 0 && outs[0] == "yes" {
self.InAirPlaneMode = true self.InAirPlaneMode = true
}else{ } else {
self.InAirPlaneMode = false self.InAirPlaneMode = false
} }
} }
} }
self.UpdateTimeLocation() self.UpdateTimeLocation()
} }
func (self *TitleBar) ClearCanvas() { func (self *TitleBar) ClearCanvas() {
surface.Fill(self.CanvasHWND, self.SkinManager.GiveColor("TitleBg")) surface.Fill(self.CanvasHWND, self.SkinManager.GiveColor("TitleBg"))
self.Icons["round_corners"].NewCoord(5,5) self.Icons["round_corners"].NewCoord(5, 5)
self.Icons["round_corners"].SetIconIndex(0) self.Icons["round_corners"].SetIconIndex(0)
self.Icons["round_corners"].Draw() self.Icons["round_corners"].Draw()
@@ -458,53 +452,51 @@ func (self *TitleBar) ClearCanvas() {
} }
func (self *TitleBar) UpdateTimeLocation() {
func (self *TitleBar) UpdateTimeLocation() { d, err := ioutil.ReadFile("/etc/localtime")
if err != nil {
return
}
d,err := ioutil.ReadFile("/etc/localtime") self.MyTimeLocation, err = gotime.LoadLocationFromTZData("local", d)
if err != nil { if err != nil {
return fmt.Println(err)
} self.MyTimeLocation = nil
}
self.MyTimeLocation,err = gotime.LoadLocationFromTZData("local", d)
if err != nil {
fmt.Println(err)
self.MyTimeLocation = nil
}
} }
func (self *TitleBar) GetLocalTime() gotime.Time { func (self *TitleBar) GetLocalTime() gotime.Time {
if self.MyTimeLocation == nil { if self.MyTimeLocation == nil {
return gotime.Now() return gotime.Now()
}else { } else {
return gotime.Now().In(self.MyTimeLocation) return gotime.Now().In(self.MyTimeLocation)
} }
} }
func (self *TitleBar) Draw(title string) { func (self *TitleBar) Draw(title string) {
self.ClearCanvas() self.ClearCanvas()
self.Title = title self.Title = title
cur_time := jodaTime.Format("HH:mm", self.GetLocalTime()) cur_time := jodaTime.Format("HH:mm", self.GetLocalTime())
time_text_w, time_text_h := font.Size(self.TimeFont, cur_time) time_text_w, time_text_h := font.Size(self.TimeFont, cur_time)
title_text_w, title_text_h := font.Size(self.TitleFont, self.Title) title_text_w, title_text_h := font.Size(self.TitleFont, self.Title)
title_text_surf := font.Render(self.TitleFont, self.Title, true, self.SkinManager.GiveColor("Text"),nil) title_text_surf := font.Render(self.TitleFont, self.Title, true, self.SkinManager.GiveColor("Text"), nil)
surface.Blit(self.CanvasHWND,title_text_surf, draw.MidRect(title_text_w/2+self.LOffset,title_text_h/2+(self.BarHeight-title_text_h)/2,title_text_w,title_text_h,Width,Height),nil) surface.Blit(self.CanvasHWND, title_text_surf, draw.MidRect(title_text_w/2+self.LOffset, title_text_h/2+(self.BarHeight-title_text_h)/2, title_text_w, title_text_h, Width, Height), nil)
title_text_surf.Free() title_text_surf.Free()
time_text_surf := font.Render(self.TimeFont, cur_time,true,self.SkinManager.GiveColor("Text"),nil) time_text_surf := font.Render(self.TimeFont, cur_time, true, self.SkinManager.GiveColor("Text"), nil)
surface.Blit(self.CanvasHWND, time_text_surf, draw.MidRect(Width-time_text_w/2-self.ROffset, time_text_h/2+(self.BarHeight-time_text_h)/2, time_text_w,time_text_h,Width,Height),nil) surface.Blit(self.CanvasHWND, time_text_surf, draw.MidRect(Width-time_text_w/2-self.ROffset, time_text_h/2+(self.BarHeight-time_text_h)/2, time_text_w, time_text_h, Width, Height), nil)
time_text_surf.Free() time_text_surf.Free()
start_x := Width - time_text_w - self.ROffset - self.IconWidth*3 // close to the time_text start_x := Width - time_text_w - self.ROffset - self.IconWidth*3 // close to the time_text
self.Icons["bluetooth"].NewCoord(start_x - self.IconWidth,self.IconHeight/2+(self.BarHeight-self.IconHeight)/2) self.Icons["bluetooth"].NewCoord(start_x-self.IconWidth, self.IconHeight/2+(self.BarHeight-self.IconHeight)/2)
self.Icons["sound"].NewCoord( start_x, self.IconHeight/2+ (self.BarHeight-self.IconHeight)/2) self.Icons["sound"].NewCoord(start_x, self.IconHeight/2+(self.BarHeight-self.IconHeight)/2)
self.Icons["battery"].NewCoord(start_x+self.IconWidth+self.IconWidth+8, self.IconHeight/2+(self.BarHeight-self.IconHeight)/2) self.Icons["battery"].NewCoord(start_x+self.IconWidth+self.IconWidth+8, self.IconHeight/2+(self.BarHeight-self.IconHeight)/2)
if self.IsWifiConnectedNow() == true { if self.IsWifiConnectedNow() == true {
@@ -512,14 +504,14 @@ func (self *TitleBar) Draw(title string) {
//fmt.Println("wifi ge: ",ge) //fmt.Println("wifi ge: ",ge)
if ge > 0 { if ge > 0 {
self.Icons["wifistatus"].SetIconIndex(ge) self.Icons["wifistatus"].SetIconIndex(ge)
self.Icons["wifistatus"].NewCoord(start_x+self.IconWidth+5, self.IconHeight/2+(self.BarHeight-self.IconHeight)/2 ) self.Icons["wifistatus"].NewCoord(start_x+self.IconWidth+5, self.IconHeight/2+(self.BarHeight-self.IconHeight)/2)
self.Icons["wifistatus"].Draw() self.Icons["wifistatus"].Draw()
}else { } else {
self.Icons["wifistatus"].SetIconIndex(0) self.Icons["wifistatus"].SetIconIndex(0)
self.Icons["wifistatus"].NewCoord(start_x+self.IconWidth+5, self.IconHeight/2+(self.BarHeight-self.IconHeight)/2 ) self.Icons["wifistatus"].NewCoord(start_x+self.IconWidth+5, self.IconHeight/2+(self.BarHeight-self.IconHeight)/2)
self.Icons["wifistatus"].Draw() self.Icons["wifistatus"].Draw()
} }
}else { } else {
self.Icons["wifistatus"].SetIconIndex(0) self.Icons["wifistatus"].SetIconIndex(0)
@@ -531,15 +523,12 @@ func (self *TitleBar) Draw(title string) {
self.Icons["sound"].Draw() self.Icons["sound"].Draw()
self.Icons["battery"].Draw() self.Icons["battery"].Draw()
self.Icons["bluetooth"].Draw() self.Icons["bluetooth"].Draw()
draw.Line(self.CanvasHWND,self.SkinManager.GiveColor("Line"), 0,self.BarHeight,self.Width,self.BarHeight, self.BorderWidth) draw.Line(self.CanvasHWND, self.SkinManager.GiveColor("Line"), 0, self.BarHeight, self.Width, self.BarHeight, self.BorderWidth)
if self.HWND != nil { if self.HWND != nil {
rect_ := rect.Rect(self.PosX,self.PosY, self.Width,self.Height) rect_ := rect.Rect(self.PosX, self.PosY, self.Width, self.Height)
surface.Blit(self.HWND, self.CanvasHWND, &rect_, nil) surface.Blit(self.HWND, self.CanvasHWND, &rect_, nil)
} }
} }

34
sysgo/UI/untitled_icon.go
View File

@@ -6,33 +6,32 @@ import (
"github.com/veandco/go-sdl2/sdl" "github.com/veandco/go-sdl2/sdl"
"github.com/veandco/go-sdl2/ttf" "github.com/veandco/go-sdl2/ttf"
"github.com/cuu/gogame/surface"
"github.com/cuu/gogame/draw"
"github.com/cuu/gogame/color" "github.com/cuu/gogame/color"
"github.com/cuu/gogame/image" "github.com/cuu/gogame/draw"
"github.com/cuu/gogame/font" "github.com/cuu/gogame/font"
"github.com/cuu/gogame/image"
"github.com/cuu/gogame/surface"
) )
type UntitledIcon struct { type UntitledIcon struct {
Widget Widget
Words []string Words []string
FontObj *ttf.Font FontObj *ttf.Font
BG *sdl.Surface BG *sdl.Surface
Color *color.Color Color *color.Color
BlankPng string BlankPng string
Text *sdl.Surface Text *sdl.Surface
} }
func NewUntitledIcon() *UntitledIcon { func NewUntitledIcon() *UntitledIcon {
u := &UntitledIcon{} u := &UntitledIcon{}
u.Width = 80 u.Width = 80
u.Height = 80 u.Height = 80
u.Words = []string{"G","s"} u.Words = []string{"G", "s"}
u.FontObj = Fonts["varela40"] u.FontObj = Fonts["varela40"]
u.Color = &color.Color{83,83,83,255} u.Color = &color.Color{83, 83, 83, 255}
u.BlankPng = SkinMap("sysgo/gameshell/blank.png") u.BlankPng = SkinMap("sysgo/gameshell/blank.png")
return u return u
@@ -42,15 +41,15 @@ func (self *UntitledIcon) Init() {
self.BG = image.Load(self.BlankPng) self.BG = image.Load(self.BlankPng)
} }
func (self *UntitledIcon) SetWords( TwoWords ...string) { func (self *UntitledIcon) SetWords(TwoWords ...string) {
if len(TwoWords) == 1 { if len(TwoWords) == 1 {
self.Words[0] = strings.ToUpper(TwoWords[0]) self.Words[0] = strings.ToUpper(TwoWords[0])
} }
if len(TwoWords) == 2 { if len(TwoWords) == 2 {
self.Words[0] = strings.ToUpper( TwoWords[0]) self.Words[0] = strings.ToUpper(TwoWords[0])
self.Words[1] = strings.ToLower( TwoWords[1] ) self.Words[1] = strings.ToLower(TwoWords[1])
self.Text = font.Render(self.FontObj, strings.Join(self.Words,""),true,self.Color, nil) self.Text = font.Render(self.FontObj, strings.Join(self.Words, ""), true, self.Color, nil)
} }
} }
@@ -59,7 +58,7 @@ func (self *UntitledIcon) Draw() {
w_ := self.Text.W w_ := self.Text.W
h_ := self.Text.H h_ := self.Text.H
surface.Blit(self.BG,self.Text,draw.MidRect(self.Width/2, self.Height/2, int(w_),int(h_), self.Width, self.Height),nil) surface.Blit(self.BG, self.Text, draw.MidRect(self.Width/2, self.Height/2, int(w_), int(h_), self.Width, self.Height), nil)
} }
} }
@@ -67,6 +66,3 @@ func (self *UntitledIcon) Surface() *sdl.Surface {
self.Draw() self.Draw()
return self.BG return self.BG
} }

222
sysgo/UI/util_funcs.go
View File

@@ -1,18 +1,18 @@
package UI package UI
import ( import (
"os"
"log"
"path/filepath"
"strings"
"fmt"
"bufio" "bufio"
"bytes" "bytes"
"io" "fmt"
"io"
"log"
"os"
"os/exec"
"path/filepath"
"runtime"
"strconv" "strconv"
"syscall" "strings"
"os/exec" "syscall"
"runtime"
"github.com/cuu/gogame/display" "github.com/cuu/gogame/display"
@@ -27,14 +27,14 @@ func ShowErr(e error) {
func Assert(e error) { func Assert(e error) {
if e != nil { if e != nil {
log.Fatal("Assert: " , e) log.Fatal("Assert: ", e)
} }
} }
func CheckAndPanic(e error) { func CheckAndPanic(e error) {
if e != nil { if e != nil {
panic(e) panic(e)
} }
} }
func Abs(n int) int { func Abs(n int) int {
@@ -42,42 +42,41 @@ func Abs(n int) int {
return (n ^ y) - y return (n ^ y) - y
} }
func SkinMap(orig_file_or_dir string) string { func SkinMap(orig_file_or_dir string) string {
DefaultSkin := "skin/default/" DefaultSkin := "skin/default/"
ret := "" ret := ""
if strings.HasPrefix(orig_file_or_dir, "/home/cpi/apps/Menu") { if strings.HasPrefix(orig_file_or_dir, "/home/cpi/apps/Menu") {
ret = strings.Replace(orig_file_or_dir,"/home/cpi/apps/Menu/", sysgo.SKIN+"/Menu/GameShell/",-1) ret = strings.Replace(orig_file_or_dir, "/home/cpi/apps/Menu/", sysgo.SKIN+"/Menu/GameShell/", -1)
if FileExists(ret) == false {
ret = DefaultSkin+orig_file_or_dir
}
}else { // there is no need to add insert "sysgo" in the middle
ret = sysgo.SKIN+orig_file_or_dir
if FileExists(ret) == false { if FileExists(ret) == false {
ret = DefaultSkin+orig_file_or_dir ret = DefaultSkin + orig_file_or_dir
}
} else { // there is no need to add insert "sysgo" in the middle
ret = sysgo.SKIN + orig_file_or_dir
if FileExists(ret) == false {
ret = DefaultSkin + orig_file_or_dir
} }
} }
if FileExists(ret) { if FileExists(ret) {
return ret return ret
}else { // if not existed both in default or custom skin ,return where it is } else { // if not existed both in default or custom skin ,return where it is
return orig_file_or_dir return orig_file_or_dir
} }
} }
func CmdClean(cmdpath string) string { func CmdClean(cmdpath string) string {
spchars := "\\`$();|{}&'\"*?<>[]!^~-#\n\r " spchars := "\\`$();|{}&'\"*?<>[]!^~-#\n\r "
for _,v:= range spchars { for _, v := range spchars {
cmdpath = strings.Replace(cmdpath,string(v),"\\"+string(v),-1) cmdpath = strings.Replace(cmdpath, string(v), "\\"+string(v), -1)
} }
return cmdpath return cmdpath
} }
func FileExists(name string) bool { func FileExists(name string) bool {
if _, err := os.Stat(name ); err == nil { if _, err := os.Stat(name); err == nil {
return true return true
}else { } else {
return false return false
} }
} }
@@ -86,22 +85,20 @@ func IsDirectory(path string) bool {
fileInfo, err := os.Stat(path) fileInfo, err := os.Stat(path)
if err != nil { if err != nil {
return false return false
}else { } else {
return fileInfo.IsDir() return fileInfo.IsDir()
} }
} }
func IsAFile(path string) bool { func IsAFile(path string) bool {
fileInfo, err := os.Stat(path) fileInfo, err := os.Stat(path)
if err != nil { if err != nil {
return false return false
}else { } else {
return fileInfo.Mode().IsRegular() return fileInfo.Mode().IsRegular()
} }
} }
func MakeExecutable(path string) { func MakeExecutable(path string) {
fileInfo, err := os.Stat(path) fileInfo, err := os.Stat(path)
if err != nil { if err != nil {
@@ -110,7 +107,7 @@ func MakeExecutable(path string) {
} }
mode := fileInfo.Mode() mode := fileInfo.Mode()
mode |= (mode & 0444) >> 2 mode |= (mode & 0444) >> 2
os.Chmod(path,mode) os.Chmod(path, mode)
} }
func GetExePath() string { func GetExePath() string {
@@ -118,15 +115,15 @@ func GetExePath() string {
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
} }
return dir return dir
} }
func ReplaceSuffix(orig_file_str string, new_ext string) string { func ReplaceSuffix(orig_file_str string, new_ext string) string {
orig_ext := filepath.Ext(orig_file_str) orig_ext := filepath.Ext(orig_file_str)
if orig_ext!= "" { if orig_ext != "" {
las_pos := strings.LastIndex(orig_file_str,".") las_pos := strings.LastIndex(orig_file_str, ".")
return orig_file_str[0:las_pos]+"."+new_ext return orig_file_str[0:las_pos] + "." + new_ext
} }
return orig_file_str // failed just return back where it came return orig_file_str // failed just return back where it came
} }
@@ -135,10 +132,10 @@ func SwapAndShow() {
display.Flip() display.Flip()
} }
func ReadLines(path string)(lines [] string,err error){ func ReadLines(path string) (lines []string, err error) {
var ( var (
file *os.File file *os.File
part [] byte part []byte
prefix bool prefix bool
) )
@@ -147,15 +144,15 @@ func ReadLines(path string)(lines [] string,err error){
} }
reader := bufio.NewReader(file) reader := bufio.NewReader(file)
buffer := bytes.NewBuffer(make([]byte,0)) buffer := bytes.NewBuffer(make([]byte, 0))
for { for {
if part, prefix, err = reader.ReadLine();err != nil { if part, prefix, err = reader.ReadLine(); err != nil {
break break
} }
buffer.Write(part) buffer.Write(part)
if !prefix { if !prefix {
lines = append(lines,buffer.String()) lines = append(lines, buffer.String())
buffer.Reset() buffer.Reset()
} }
} }
@@ -166,26 +163,25 @@ func ReadLines(path string)(lines [] string,err error){
return return
} }
func WriteLines(lines [] string,path string)(err error){ func WriteLines(lines []string, path string) (err error) {
var file *os.File var file *os.File
if file,err = os.Create(path); err != nil{ if file, err = os.Create(path); err != nil {
return return
} }
defer file.Close() defer file.Close()
for _,elem := range lines { for _, elem := range lines {
_,err := file.WriteString(strings.TrimSpace(elem)+"\n") _, err := file.WriteString(strings.TrimSpace(elem) + "\n")
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
break break
} }
} }
return return
} }
func GetGid(path string) int { func GetGid(path string) int {
s, err := os.Stat(path) s, err := os.Stat(path)
if err != nil { if err != nil {
@@ -200,7 +196,6 @@ func GetGid(path string) int {
return int(sys_interface.(*syscall.Stat_t).Gid) return int(sys_interface.(*syscall.Stat_t).Gid)
} }
func GetUid(path string) int { func GetUid(path string) int {
s, err := os.Stat(path) s, err := os.Stat(path)
if err != nil { if err != nil {
@@ -215,76 +210,73 @@ func GetUid(path string) int {
return int(sys_interface.(*syscall.Stat_t).Uid) return int(sys_interface.(*syscall.Stat_t).Uid)
} }
func CheckBattery() int { func CheckBattery() int {
if FileExists(sysgo.Battery) == false { if FileExists(sysgo.Battery) == false {
return -1 return -1
} }
batinfos,err := ReadLines(sysgo.Battery) batinfos, err := ReadLines(sysgo.Battery)
if err == nil { if err == nil {
for _,v := range batinfos { for _, v := range batinfos {
if strings.HasPrefix(v,"POWER_SUPPLY_CAPACITY") { if strings.HasPrefix(v, "POWER_SUPPLY_CAPACITY") {
parts := strings.Split(v,"=") parts := strings.Split(v, "=")
if len(parts) > 1 { if len(parts) > 1 {
cur_cap,err := strconv.Atoi(parts[1]) cur_cap, err := strconv.Atoi(parts[1])
if err == nil { if err == nil {
return cur_cap return cur_cap
}else { } else {
return 0 return 0
} }
} }
} }
} }
}else{ } else {
fmt.Println(err) fmt.Println(err)
} }
return 0 return 0
} }
func System(cmd string) string { func System(cmd string) string {
ret := "" ret := ""
out,err := exec.Command("bash","-c",cmd).Output() out, err := exec.Command("bash", "-c", cmd).Output()
if err != nil { if err != nil {
if _, ok := err.(*exec.ExitError); ok { if _, ok := err.(*exec.ExitError); ok {
//exit code !=0 ,but it can be ignored //exit code !=0 ,but it can be ignored
}else{ } else {
fmt.Println(err) fmt.Println(err)
} }
}else { } else {
ret = string(out) ret = string(out)
} }
return ret return ret
} }
func ArmSystem(cmd string) string { func ArmSystem(cmd string) string {
if strings.Contains(runtime.GOARCH,"arm") == true { if strings.Contains(runtime.GOARCH, "arm") == true {
return System(cmd) return System(cmd)
}else { } else {
return "" return ""
} }
} }
func SystemTrim(cmd string) string { func SystemTrim(cmd string) string {
ret := "" ret := ""
out,err := exec.Command("bash","-c",cmd).Output() out, err := exec.Command("bash", "-c", cmd).Output()
if err != nil { if err != nil {
if _, ok := err.(*exec.ExitError); ok { if _, ok := err.(*exec.ExitError); ok {
//exit code !=0 ,but it can be ignored //exit code !=0 ,but it can be ignored
}else{ } else {
fmt.Println(err) fmt.Println(err)
} }
}else { } else {
ret = string(out) ret = string(out)
} }
return strings.Trim(ret,"\r\n") return strings.Trim(ret, "\r\n")
} }
func cmdEnv() []string { func cmdEnv() []string {

67
sysgo/config.go
View File

@@ -2,49 +2,46 @@ package sysgo
import ( import (
"fmt" "fmt"
"os"
"github.com/go-ini/ini" "github.com/go-ini/ini"
"os"
) )
type PowerLevel struct { type PowerLevel struct {
Dim int Dim int
Close int Close int
PowerOff int PowerOff int
} }
var PowerLevels map[string]*PowerLevel var PowerLevels map[string]*PowerLevel
var ( var (
//CurKeySet = "PC" // PC or GameShell //CurKeySet = "PC" // PC or GameShell
CurKeySet = "GameShell" CurKeySet = "GameShell"
DontLeave = false DontLeave = false
BackLight = "/proc/driver/backlight" BackLight = "/proc/driver/backlight"
Battery = "/sys/class/power_supply/axp20x-battery/uevent" Battery = "/sys/class/power_supply/axp20x-battery/uevent"
MPD_socket = "/tmp/mpd.socket" MPD_socket = "/tmp/mpd.socket"
UPDATE_URL="https://raw.githubusercontent.com/clockworkpi/CPI/master/launchergo_ver.json" UPDATE_URL = "https://raw.githubusercontent.com/clockworkpi/CPI/master/launchergo_ver.json"
VERSION="0.22" VERSION = "0.22"
SKIN="skin/default/" // !!!need the last slash!!! SKIN = "skin/default/" // !!!need the last slash!!!
//load from dot files
CurPowerLevel= "performance"
Lang = "English"
WifiDev = "wlan0"
//load from dot files
CurPowerLevel = "performance"
Lang = "English"
WifiDev = "wlan0"
) )
func init() { func init() {
if PowerLevels == nil { if PowerLevels == nil {
PowerLevels = make(map[string]*PowerLevel) PowerLevels = make(map[string]*PowerLevel)
PowerLevels["supersaving"] = &PowerLevel{10, 30, 120} PowerLevels["supersaving"] = &PowerLevel{10, 30, 120}
PowerLevels["powersaving"] = &PowerLevel{40, 120, 300} PowerLevels["powersaving"] = &PowerLevel{40, 120, 300}
PowerLevels["server"] = &PowerLevel{40, 120, 0 } PowerLevels["server"] = &PowerLevel{40, 120, 0}
PowerLevels["performance"] = &PowerLevel{40, 0, 0 } PowerLevels["performance"] = &PowerLevel{40, 0, 0}
} }
//sudo LauncherGoDev=1 ./launchergo # for develop code on PC //sudo LauncherGoDev=1 ./launchergo # for develop code on PC
dev_mode := os.Getenv("LauncherGoDev") dev_mode := os.Getenv("LauncherGoDev")
@@ -53,11 +50,11 @@ func init() {
return return
} }
if _, err := os.Stat("app-local.ini" ); err == nil { if _, err := os.Stat("app-local.ini"); err == nil {
load_opts := ini.LoadOptions{ load_opts := ini.LoadOptions{
IgnoreInlineComment:true, IgnoreInlineComment: true,
} }
cfg, err := ini.LoadSources(load_opts, "app-local.ini" ) cfg, err := ini.LoadSources(load_opts, "app-local.ini")
if err != nil { if err != nil {
fmt.Printf("Fail to read file: %v\n", err) fmt.Printf("Fail to read file: %v\n", err)
return return
@@ -65,12 +62,12 @@ func init() {
section := cfg.Section("GameShell") section := cfg.Section("GameShell")
if section != nil { if section != nil {
gs_opts := section.KeyStrings() gs_opts := section.KeyStrings()
for i,v := range gs_opts { for i, v := range gs_opts {
fmt.Println(i,v, section.Key(v).String()) fmt.Println(i, v, section.Key(v).String())
switch v{ switch v {
case "WifiDev": case "WifiDev":
WifiDev = section.Key(v).String() WifiDev = section.Key(v).String()
case "CurKeySet": case "CurKeySet":
CurKeySet = section.Key(v).String() CurKeySet = section.Key(v).String()
} }

13
sysgo/plugins/HelloWorld/helloworld.go
View File

@@ -8,25 +8,16 @@ type HelloWorldPage struct {
UI.Page UI.Page
} }
type HelloWorldPlugin struct { type HelloWorldPlugin struct {
UI.Plugin UI.Plugin
} }
func (self *HelloWorldPlugin) Init(main_screen *UI.MainScreen) {
func (self *HelloWorldPlugin) Init( main_screen *UI.MainScreen ) {
} }
func (self *HelloWorldPlugin) Run( main_screen *UI.MainScreen ) { func (self *HelloWorldPlugin) Run(main_screen *UI.MainScreen) {
} }
var APIOBJ HelloWorldPlugin var APIOBJ HelloWorldPlugin

3
sysgo/wicd/misc/misc.go
View File

@@ -125,11 +125,10 @@ func LoadEncryptionMethods(wired bool) []*CurType {
for _, v := range enctypes { for _, v := range enctypes {
c := parse_enc_templat(v) c := parse_enc_templat(v)
c.Type = v c.Type = v
encryptionTypes = append(encryptionTypes, c) encryptionTypes = append(encryptionTypes, c)
} }
return encryptionTypes return encryptionTypes
} }