add power options and airplane mode

2025-12-12 07:58:51 +01:00 · 2018-12-21 16:55:28 +08:00 · 2018-12-21 16:55:28 +08:00 · dac6b17fd3
commit dac6b17fd3
parent 4da846400e
10 changed files with 1054 additions and 21 deletions
--- a/Menu/GameShell/10_Settings/Airplane/airplane_page.go
+++ b/Menu/GameShell/10_Settings/Airplane/airplane_page.go
@ -0,0 +1,242 @@
+package Airplane
+
+import (
+  //"fmt"
+  //"io/ioutil"
+  //"path/filepath"
+  "strings"
+  
+  "github.com/veandco/go-sdl2/ttf"
+
+
+  //"github.com/cuu/gogame/draw"
+	"github.com/cuu/gogame/rect"
+	"github.com/cuu/gogame/surface"
+	"github.com/cuu/gogame/color"
+	"github.com/cuu/gogame/event"
+	"github.com/cuu/gogame/time"
+  
+  //"github.com/cuu/LauncherGoDev/sysgo"
+
+  "github.com/cuu/LauncherGoDev/sysgo/UI"
+
+)
+
+type AirplanePage struct {
+  UI.Page
+  
+  ListFontObj *ttf.Font
+  
+  BGwidth int
+  BGheight int
+  
+  Scrolled int
+  Scroller *UI.ListScroller
+  
+  airwire_y int //0
+  dialog_index int//0
+  
+  Icons map[string]UI.IconItemInterface
+
+}
+
+func NewAirplanePage() *AirplanePage {
+  p := &AirplanePage{}
+	p.PageIconMargin = 20
+	p.SelectedIconTopOffset = 20
+	p.EasingDur = 10
+  
+	p.Align = UI.ALIGN["SLeft"]
+	
+  p.ListFontObj = UI.MyLangManager.TrFont("varela13")
+	p.FootMsg = [5]string{ "Nav","Rescue","","Back","Toggle"}  
+  
+  p.BGwidth = UI.Width
+  p.BGheight = UI.Height-24-20
+
+  p.Icons = make( map[string]UI.IconItemInterface  )
+  
+  return p
+}
+
+func (self *AirplanePage) GenList() {
+  self.MyList = nil
+
+}
+
+
+func (self *AirplanePage) Init() {
+  if self.Screen != nil {
+    if self.Screen.CanvasHWND != nil && self.CanvasHWND == nil {
+      self.HWND = self.Screen.CanvasHWND
+      self.CanvasHWND = surface.Surface(self.Screen.Width,self.Screen.Height)
+    }
+  }
+  
+  self.PosX = self.Index*self.Screen.Width 
+  self.Width = self.Screen.Width
+  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
+
+  GS := UI.NewIconItem()
+  GS.ImgSurf = UI.MyIconPool.GetImgSurf("GS")
+  GS.MyType = UI.ICON_TYPES["STAT"]
+  GS.Parent = self
+  GS.Adjust(0,0,72,95,0)
+  self.Icons["GS"] = GS  
+  
+  DialogBoxs := UI.NewMultiIconItem()
+  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.PosX = self.Width - 10
+  self.Scroller.PosY = 2
+  self.Scroller.Init()
+  self.Scroller.SetCanvasHWND(self.HWND)    
+
+}
+
+func (self *AirplanePage) ScrollUp() {
+  dis := 10
+  
+  if self.PosY < 0 {
+    self.PosY += dis
+    self.Scrolled += dis
+  }
+}
+
+func (self *AirplanePage) ScrollDown() {
+  dis := 10
+  
+  if UI.Abs(self.Scrolled) < (self.BGheight - self.Height) / 2 + 0 {
+    self.PosY -= dis
+    self.Scrolled -=dis 
+  }
+
+}
+
+
+func (self *AirplanePage) ToggleModeAni() {
+  
+  out := UI.System("sudo rfkill list | grep yes | cut -d \" \" -f3")
+  
+  if strings.Contains(out,"yes") {
+    data := self.EasingData(0,43)
+    
+    for _,v := range data {
+      self.airwire_y -= v
+      self.dialog_index = 2
+      time.BlockDelay(40)
+      self.Screen.Draw()
+      self.Screen.SwapAndShow()
+    }
+    
+    UI.System("sudo rfkill unblock all")
+    self.Screen.TitleBar.InAirPlaneMode = false
+    
+  }else {
+    data := self.EasingData(0,43)
+    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]
+    }
+    for _,v := range data {
+      self.airwire_y += v
+      self.dialog_index = 3
+      time.BlockDelay(40)
+      self.Screen.Draw()
+      self.Screen.SwapAndShow()
+    }    
+    UI.System("sudo rfkill block all")
+    self.Screen.TitleBar.InAirPlaneMode = true
+  }
+}
+
+func (self *AirplanePage) ToggleMode() {
+
+}
+
+func (self *AirplanePage) UnBlockAll() {
+
+  self.Screen.MsgBox.SetText("TurningOn")
+  self.Screen.MsgBox.Draw()
+  UI.System("sudo rfkill unblock all")
+  self.Screen.TitleBar.InAirPlaneMode = false
+}
+
+func (self *AirplanePage) OnLoadCb() {
+  self.Scrolled = 0
+  self.PosY = 0
+  //self.DrawOnce = false
+  
+  out := UI.System("sudo rfkill list | grep yes | cut -d \" \" -f3")
+  
+  if strings.Contains(out,"yes") {
+    self.Screen.TitleBar.InAirPlaneMode = true
+    self.airwire_y = 50+43
+    self.dialog_index = 1
+  }else {
+    self.dialog_index = 0
+    self.airwire_y = 50
+    self.Screen.TitleBar.InAirPlaneMode = false
+  }
+}
+
+func (self *AirplanePage) KeyDown(ev *event.Event) {
+  
+	if ev.Data["Key"] == UI.CurKeys["A"] || ev.Data["Key"] == UI.CurKeys["Menu"] {
+		self.ReturnToUpLevelPage()
+		self.Screen.Draw()
+		self.Screen.SwapAndShow()
+	}  
+  
+  if ev.Data["Key"] == UI.CurKeys["B"] {
+    self.ToggleModeAni()
+  }
+  
+  if ev.Data["Key"] == UI.CurKeys["X"] {
+    self.UnBlockAll()
+    self.Screen.SwapAndShow()
+    time.BlockDelay(1000)
+    self.Screen.Draw()
+    self.Screen.SwapAndShow()
+  }
+}
+
+
+func (self *AirplanePage) Draw() {
+  
+  self.ClearCanvas()
+  self.Icons["DialogBoxs"].NewCoord(145,23)
+  self.Icons["airwire"].NewCoord(80,self.airwire_y)
+
+  self.Icons["DialogBoxs"].SetIconIndex(self.dialog_index)
+  
+  self.Icons["DialogBoxs"].DrawTopLeft()
+  
+  self.Icons["airwire"].Draw()
+  
+  self.Icons["GS"].NewCoord(98,118)
+  self.Icons["GS"].Draw()
+  
+  if self.HWND != nil {
+    surface.Fill(self.HWND, &color.Color{255,255,255,255})
+    rect_ := rect.Rect(self.PosX,self.PosY,self.Width,self.Height)
+    surface.Blit(self.HWND,self.CanvasHWND,&rect_,nil)
+  }
+}
--- a/Menu/GameShell/10_Settings/Airplane/plugin_init.go
+++ b/Menu/GameShell/10_Settings/Airplane/plugin_init.go
@ -0,0 +1,42 @@
+package Airplane
+
+/*
+ * sysgo.BackLight  
+ */
+import (
+/*
+	"github.com/veandco/go-sdl2/ttf"
+
+	"github.com/cuu/gogame/surface"
+	"github.com/cuu/gogame/event"
+	"github.com/cuu/gogame/rect"
+	"github.com/cuu/gogame/color"
+*/	
+	"github.com/cuu/LauncherGoDev/sysgo/UI"
+	//"github.com/cuu/LauncherGoDev/sysgo/DBUS"
+)
+
+/******************************************************************************/
+type AirplanePlugin struct {
+	UI.Plugin
+  AirplanePage *AirplanePage
+}
+
+
+func (self *AirplanePlugin) Init( main_screen *UI.MainScreen ) {
+	self.AirplanePage = NewAirplanePage()
+	self.AirplanePage.SetScreen( main_screen)
+	self.AirplanePage.SetName("Airplane")
+	self.AirplanePage.Init()  
+}
+
+func (self *AirplanePlugin) Run( main_screen *UI.MainScreen ) {
+	if main_screen != nil {
+    main_screen.PushCurPage()
+    main_screen.SetCurPage(self.AirplanePage)
+		main_screen.Draw()
+		main_screen.SwapAndShow()
+	}
+}
+
+var APIOBJ AirplanePlugin
--- a/Menu/GameShell/10_Settings/Bluetooth/bluetooth_page.go
+++ b/Menu/GameShell/10_Settings/Bluetooth/bluetooth_page.go
@ -684,7 +684,7 @@ func (self *BluetoothPage) OnLoadCb() {
  self.Offline = false
  
  if self.Screen.TitleBar.InAirPlaneMode == false {
-    out := System("hcitool dev | grep hci0 |cut -f3")
+    out := UI.System("hcitool dev | grep hci0 |cut -f3")
    if len(out) < 17 {
      self.Offline = true
      fmt.Println("Bluetooth OnLoadCb ,can not find hci0 alive,try to reboot")
@ -779,7 +779,7 @@ func (self *BluetoothPage) KeyDown(ev *event.Event) {
    if len(self.MyList) == 0 {
      return
    }
-    if self.Offline = true {
+    if self.Offline == true {
      return
    }
    self.InfoPage.Props    = self.MyList[self.PsIndex].(*NetItem).Props
--- a/Menu/GameShell/10_Settings/PowerOptions/plugin_init.go
+++ b/Menu/GameShell/10_Settings/PowerOptions/plugin_init.go
@ -0,0 +1,39 @@
+package PowerOptions
+
+import (
+/*
+	"github.com/veandco/go-sdl2/ttf"
+
+	"github.com/cuu/gogame/surface"
+	"github.com/cuu/gogame/event"
+	"github.com/cuu/gogame/rect"
+	"github.com/cuu/gogame/color"
+*/	
+	"github.com/cuu/LauncherGoDev/sysgo/UI"
+	//"github.com/cuu/LauncherGoDev/sysgo/DBUS"
+)
+
+/******************************************************************************/
+type PowerOptionsPlugin struct {
+	UI.Plugin
+  PowerOptionsPage *PowerOptionsPage
+}
+
+
+func (self *PowerOptionsPlugin) Init( main_screen *UI.MainScreen ) {
+	self.PowerOptionsPage = NewPowerOptionsPage()
+	self.PowerOptionsPage.SetScreen( main_screen)
+	self.PowerOptionsPage.SetName("PowerOptions")
+	self.PowerOptionsPage.Init()  
+}
+
+func (self *PowerOptionsPlugin) Run( main_screen *UI.MainScreen ) {
+	if main_screen != nil {
+    main_screen.PushCurPage()
+    main_screen.SetCurPage(self.PowerOptionsPage)
+		main_screen.Draw()
+		main_screen.SwapAndShow()
+	}
+}
+
+var APIOBJ PowerOptionsPlugin
--- a/Menu/GameShell/10_Settings/PowerOptions/power_options_page.go
+++ b/Menu/GameShell/10_Settings/PowerOptions/power_options_page.go
@ -0,0 +1,632 @@
+package PowerOptions
+
+import (
+  "fmt"
+  "io/ioutil"
+  //"path/filepath"
+  //"strings"
+  
+  "github.com/veandco/go-sdl2/ttf"
+
+
+  "github.com/cuu/gogame/draw"
+	"github.com/cuu/gogame/rect"
+	"github.com/cuu/gogame/surface"
+	"github.com/cuu/gogame/color"
+	"github.com/cuu/gogame/event"
+	"github.com/cuu/gogame/time"
+  
+  "github.com/cuu/LauncherGoDev/sysgo"
+
+  "github.com/cuu/LauncherGoDev/sysgo/UI"
+
+)
+
+type ListPageSelector struct {
+  UI.InfoPageSelector
+}
+
+func NewListPageSelector() *ListPageSelector {
+  
+  p := &ListPageSelector{}
+  
+  p.Width = UI.Width
+  p.BackgroundColor = &color.Color{131,199,219,255} //SkinManager().GiveColor('Front')
+  
+  return p
+
+}
+
+
+func (self *ListPageSelector) Draw() {
+  
+  idx := self.Parent.GetPsIndex()
+  mylist := self.Parent.GetMyList()
+ 
+  if idx < len(mylist) {
+    x,y := mylist[idx].Coord()
+    _,h := mylist[idx].Size()
+    
+    self.PosX = x+2
+    self.PosY = y+1
+    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)
+  } 
+}
+
+type PageListItem struct {
+  UI.InfoPageListItem
+  
+  Active bool
+  Value string
+}
+
+
+func NewPageListItem() *PageListItem {
+  
+  p := &PageListItem{}
+  p.Height = UI.DefaultInfoPageListItemHeight
+  p.ReadOnly = false
+	p.Labels = make(map[string]UI.LabelInterface)
+	p.Icons  = make( map[string]UI.IconItemInterface)
+	p.Fonts  = make(map[string]*ttf.Font)  
+
+  return p
+}
+
+
+func (self *PageListItem) Draw() {
+    
+  x,_ := self.Labels["Text"].Coord()
+  w,h := self.Labels["Text"].Size()
+  
+  self.Labels["Text"].NewCoord( x, self.PosY + (self.Height - h)/2 )
+  
+  
+  if self.Active == true {
+    self.Parent.(*PowerOptionsPage).Icons["done"].NewCoord(self.Parent.(*PowerOptionsPage).Width-30,self.PosY+5)
+    self.Parent.(*PowerOptionsPage).Icons["done"].Draw()
+  }
+  
+  self.Labels["Text"].SetBold(self.Active)
+  self.Labels["Text"].Draw()
+  
+  
+  
+  if _, ok := self.Labels["Small"]; ok {
+    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()
+    
+  }
+  
+  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 InfoPage struct {
+  UI.Page
+  ListFontObj *ttf.Font
+  
+  Time1 int
+  Time2 int
+  Time3 int
+
+  AList map[string]map[string]string
+}
+
+func NewInfoPage() *InfoPage {
+  
+  p := &InfoPage{}
+  
+  p.ListFontObj = UI.MyLangManager.TrFont("varela15")
+  p.FootMsg = [5]string{"Nav","","","Back",""}
+  
+  p.Time1 = 40
+  p.Time2 = 120 // 120 secs
+  p.Time3 = 300 // 5 minutes
+  
+  p.AList = make(map[string]map[string]string)
+  
+  return p
+}
+
+
+func (self *InfoPage) ConvertSecToMin( secs int) string {
+  sec_str := ""
+  min_str := ""
+  
+  if secs > 60 {
+    m := int(secs/60)
+    s := secs % 60
+    
+    if m > 1 {
+      min_str = fmt.Sprintf("%d "+UI.MyLangManager.Tr("minutes")+ " ", m)
+    }else {
+      min_str = fmt.Sprintf("%d "+UI.MyLangManager.Tr("minute")+ " ", m)
+    }
+    
+    if s == 1 {
+      sec_str = fmt.Sprintf("%d "+UI.MyLangManager.Tr("second"), s)
+    }else if s > 1 {
+      sec_str = fmt.Sprintf("%d "+UI.MyLangManager.Tr("seconds"), s)
+    }
+    
+  }else if secs <= 60 && secs > 0 {
+    if secs > 1 {
+      sec_str = fmt.Sprintf("%d "+UI.MyLangManager.Tr("seconds"), secs)
+    }else {
+      sec_str = fmt.Sprintf("%d "+UI.MyLangManager.Tr("second"), secs)
+    }
+    
+  
+  }else if secs == 0 {
+    sec_str = UI.MyLangManager.Tr("Never")
+  }
+  
+  
+  return min_str + sec_str
+
+}
+
+func (self *InfoPage) RefreshList() {
+  
+  self.AList["time1"]["value"] = self.ConvertSecToMin(self.Time1)
+  self.AList["time2"]["value"] = self.ConvertSecToMin(self.Time2)
+  self.AList["time3"]["value"] = self.ConvertSecToMin(self.Time3)
+  
+  i := 0 
+  for _ ,v := range self.AList {
+    self.MyList[i].(*PageListItem).SetSmallText( v["value"] )
+    i+=1
+  }
+
+}
+
+func (self *InfoPage) GenList() {
+
+  time1 := make(map[string]string)
+  
+  time1["key"] = "time1"
+  
+  if self.Time1 == 0 {
+    time1["value"] = UI.MyLangManager.Tr("Never")
+  }else {
+    time1["value"] = fmt.Sprintf("%d secs",self.Time1)
+  }
+  time1["label"] = "Screen dimming"
+  
+  time2 := make(map[string]string)
+  time2["key"] = "time2"
+  
+  if self.Time2 == 0 {
+    time2["value"] = UI.MyLangManager.Tr("Never")
+  }else {
+    time2["value"] = fmt.Sprintf("%d secs",self.Time2)
+  }
+  
+  time2["label"] = "Screen OFF"
+  
+  time3 := make(map[string]string)
+  time3["key"] = "time3"
+  
+  if self.Time3 == 0 {
+    time3["value"] = UI.MyLangManager.Tr("Never")
+  }else {
+    time3["value"] = fmt.Sprintf("%d secs",self.Time3)
+  }
+  
+  time3["label"] = "Power OFF"
+  
+  
+  self.AList["time1"] = time1
+  self.AList["time2"] = time2
+  self.AList["time3"] = time3  
+  
+  
+  self.MyList = nil
+  
+  start_x := 0 
+  start_y := 0 
+  
+  
+  i:=0
+  for _,v := range self.AList {
+    
+    li := NewPageListItem()
+    li.Parent = self
+    li.PosX = start_x
+    li.PosY = start_y + i*UI.DefaultInfoPageListItemHeight
+    li.Width = UI.Width
+    li.Fonts["normal"] = self.ListFontObj
+    li.Fonts["small"]  = UI.MyLangManager.TrFont("varela12")
+    
+    if v["label"] != "" {
+      li.Init( v["label"])
+    }else {
+      li.Init(v["key"])
+    }
+    
+    li.Flag = v["key"]
+    
+    li.SetSmallText(v["value"])
+    
+    self.MyList = append(self.MyList,li)
+  
+  }
+}
+
+func (self *InfoPage) Init() {
+
+  if self.Screen != nil {
+    if self.Screen.CanvasHWND != nil && self.CanvasHWND == nil {
+      self.CanvasHWND = self.Screen.CanvasHWND
+    }
+  }
+  
+  self.PosX = self.Index*self.Screen.Width 
+  self.Width = self.Screen.Width
+  self.Height = self.Screen.Height
+
+  ps := NewListPageSelector()
+  ps.Parent = self
+  self.Ps = ps
+  self.PsIndex = 0
+        
+  self.GenList()
+}
+
+func (self *InfoPage) Click() {
+  
+  if self.PsIndex >= len(self.MyList) {
+    return
+  }
+  
+  cur_li := self.MyList[self.PsIndex]
+  
+  fmt.Println(cur_li.(*PageListItem).Flag )
+
+}
+
+func (self *InfoPage) OnLoadCb() {
+  
+  self.RefreshList()
+  
+}
+
+
+func (self *InfoPage) KeyDown(ev *event.Event) {
+
+
+	if ev.Data["Key"] == UI.CurKeys["A"] || ev.Data["Key"] == UI.CurKeys["Menu"] {
+		self.ReturnToUpLevelPage()
+		self.Screen.Draw()
+		self.Screen.SwapAndShow()
+	} 
+  
+  if ev.Data["Key"]  == UI.CurKeys["Up"] {
+  
+    self.ScrollUp()
+    self.Screen.Draw()
+    self.Screen.SwapAndShow()
+  }
+  
+  if ev.Data["Key"]  == UI.CurKeys["Down"] {
+  
+    self.ScrollDown()
+    self.Screen.Draw()
+    self.Screen.SwapAndShow()
+  }
+}
+
+func (self *InfoPage) Draw() {
+  self.ClearCanvas()
+  self.Ps.Draw()
+  for _,v := range self.MyList{
+    v.Draw()
+  }
+}
+
+
+type PowerOptionsPage struct {
+  UI.Page
+  
+  ListFont *ttf.Font
+  BGwidth int
+  BGheight int
+  
+  AList map[string]map[string]string
+  DrawOnce bool
+  InfoPage *InfoPage
+  Scroller *UI.ListScroller
+  Icons map[string]UI.IconItemInterface
+}
+
+
+func NewPowerOptionsPage() *PowerOptionsPage {
+  
+  p := &PowerOptionsPage{}
+  
+  p.BGwidth = UI.Width 
+  p.BGheight = UI.Height - 24 - 20
+  
+  p.AList = make(map[string]map[string]string)
+  p.Icons = make(map[string]UI.IconItemInterface)
+
+  p.ListFont = UI.Fonts["notosanscjk15"]
+  p.FootMsg =  [5]string{"Nav","","Detail","Back","Select"}
+  
+  return p
+}
+
+func (self *PowerOptionsPage) GenList() {
+  
+  self.MyList = nil
+  
+  start_x := 0
+  start_y := 0 
+  
+  last_height :=0
+  
+  supersaving := make(map[string]string)
+  supersaving["key"] = "super"
+  supersaving["label"] = "Power saving"
+  supersaving["value"] = "supersaving"
+
+  powersaving := make(map[string]string)
+  powersaving["key"] = "saving"
+  powersaving["label"] = "Balanced"
+  powersaving["value"] = "powersaving"
+
+  performance := make(map[string]string)
+  performance["key"] = "performance"
+  performance["label"] = "Performance"
+  performance["value"] = "performance"
+
+  server_saving := make(map[string]string)
+  server_saving["key"] = "server"
+  server_saving["label"] = "Server"
+  server_saving["value"] = "server"
+  
+  self.AList["supersaving"] = supersaving
+  self.AList["powersaving"] = powersaving
+  self.AList["server"]      = server_saving
+  self.AList["performance"] = performance
+  
+  
+  for _,u := range [4]string{"supersaving","powersaving","server","performance"} {
+    
+    v := self.AList[u]
+    
+    li := NewPageListItem()
+    li.Parent = self
+    li.PosX = start_x
+    li.PosY = start_y + last_height
+    li.Width  = UI.Width
+    
+    li.Fonts["normal"] = self.ListFont
+    li.Active = false
+    li.Value = v["value"]
+    
+    if v["label"] != "" {
+      li.Init(v["label"])
+    }else {
+      li.Init(v["key"])
+    }
+    
+    last_height += li.Height
+    
+    self.MyList = append(self.MyList,li)
+  
+  }
+}
+
+
+func (self *PowerOptionsPage) Init() {
+  
+  if self.Screen != nil {
+    if self.Screen.CanvasHWND != nil && self.CanvasHWND == nil {
+      self.HWND = self.Screen.CanvasHWND
+      self.CanvasHWND = surface.Surface(self.Screen.Width,self.Screen.Height)
+    }
+  }
+  
+  self.PosX = self.Index*self.Screen.Width 
+  self.Width = self.Screen.Width
+  self.Height = self.Screen.Height  
+  
+  done := UI.NewIconItem()
+  done.ImgSurf = UI.MyIconPool.GetImgSurf("done")
+  done.MyType = UI.ICON_TYPES["STAT"]
+  done.Parent = self
+  
+  self.Icons["done"] = done 
+  
+  ps := NewListPageSelector()
+  ps.Parent = self
+  
+  self.Ps = ps
+  self.PsIndex = 0
+  
+  self.GenList()
+  
+  self.Scroller = UI.NewListScroller()
+  self.Scroller.Parent = self
+  self.Scroller.PosX = self.Width - 10
+  self.Scroller.PosY = 2
+  self.Scroller.Init()
+  self.Scroller.SetCanvasHWND(self.HWND)  
+
+  self.InfoPage = NewInfoPage()
+  self.InfoPage.Screen = self.Screen
+  self.InfoPage.Name   = "Power option detail"
+  self.InfoPage.Init()
+  
+}
+
+func (self *PowerOptionsPage) Click() {
+  if len(self.MyList) == 0 {
+    return
+  }
+  
+  cur_li := self.MyList[self.PsIndex].(*PageListItem)
+  
+  if cur_li.Active == true {
+    return
+  }
+  
+  for i,_ := range self.MyList {
+    self.MyList[i].(*PageListItem).Active = false
+  }
+  
+  cur_li.Active = true
+  
+  fmt.Println(cur_li.Value)
+  
+  d := []byte(cur_li.Value)
+  err := ioutil.WriteFile("sysgo/.powerlevel", d, 0644)
+  if err != nil {
+    fmt.Println(err)
+  }
+  
+  sysgo.CurPowerLevel = cur_li.Value
+  
+  if sysgo.CurPowerLevel == "supersaving" {
+    UI.System("sudo iw wlan0 set power_save on >/dev/null")
+  }else{
+    UI.System("sudo iw wlan0 set power_save off >/dev/null")
+  }
+  
+  self.Screen.MsgBox.SetText("Applying")
+  self.Screen.MsgBox.Draw()
+  self.Screen.SwapAndShow()  
+  
+  event.Post(UI.POWEROPT,"")
+  
+  time.BlockDelay(1000)
+  
+  self.Screen.Draw()
+  self.Screen.SwapAndShow()  
+}
+
+func (self *PowerOptionsPage) OnLoadCb() {
+  
+  self.PosY = 0
+  self.DrawOnce = false
+  
+  for i,_ := range self.MyList{
+    if self.MyList[i].(*PageListItem).Value == sysgo.CurPowerLevel {
+      self.MyList[i].(*PageListItem).Active = true
+    }
+  }
+}
+
+func (self *PowerOptionsPage) KeyDown(ev *event.Event) {
+	if ev.Data["Key"] == UI.CurKeys["A"] || ev.Data["Key"] == UI.CurKeys["Menu"] {
+		self.ReturnToUpLevelPage()
+		self.Screen.Draw()
+		self.Screen.SwapAndShow()
+	}
+  
+  if ev.Data["Key"] == UI.CurKeys["B"] {
+    self.Click()
+  }  
+  
+  if ev.Data["Key"]  == UI.CurKeys["Up"] {
+  
+    self.ScrollUp()
+    self.Screen.Draw()
+    self.Screen.SwapAndShow()
+  }
+  
+  if ev.Data["Key"]  == UI.CurKeys["Down"] {
+  
+    self.ScrollDown()
+    self.Screen.Draw()
+    self.Screen.SwapAndShow()
+  } 
+  
+  if ev.Data["Key"]  == UI.CurKeys["Y"] {
+    cur_li := self.MyList[self.PsIndex].(*PageListItem)
+    
+    time1 := sysgo.PowerLevels[cur_li.Value].Dim
+    time2 := sysgo.PowerLevels[cur_li.Value].Close
+    time3 := sysgo.PowerLevels[cur_li.Value].PowerOff
+     
+            
+    self.InfoPage.Time1 = time1
+    self.InfoPage.Time2 = time2
+    self.InfoPage.Time3 = time3
+    
+            
+    self.Screen.PushPage(self.InfoPage)
+    self.Screen.Draw()
+    self.Screen.SwapAndShow()
+  }
+}
+
+func (self *PowerOptionsPage) Draw() {
+  self.ClearCanvas()
+  if len(self.MyList) == 0 {
+    return
+  }
+  
+  if len(self.MyList) * UI.DefaultInfoPageListItemHeight > self.Height {
+    
+    self.Ps.(*ListPageSelector).Width = self.Width - 11
+    self.Ps.Draw()
+    
+    for _,v := range self.MyList {
+      if v.(*PageListItem).PosY > self.Height + self.Height/2 {
+        break
+      }
+      
+      if v.(*PageListItem).PosY < 0 {
+        continue
+      }
+      
+      v.Draw()
+    
+    }
+    
+    
+    self.Scroller.UpdateSize( len(self.MyList)*UI.DefaultInfoPageListItemHeight,
+                          self.PsIndex*UI.DefaultInfoPageListItemHeight)
+    self.Scroller.Draw()
+    
+  }else {
+    self.Ps.(*ListPageSelector).Width = self.Width
+    self.Ps.Draw()
+    for _,v := range self.MyList {
+      if v.(*PageListItem).PosY > self.Height + self.Height/2 {
+        break
+      }
+      
+      if v.(*PageListItem).PosY < 0 {
+        continue
+      }
+      
+      v.Draw()
+    
+    }    
+  }
+  
+  if self.HWND != nil {
+    surface.Fill(self.HWND, &color.Color{255,255,255,255})
+    rect_ := rect.Rect(self.PosX,self.PosY,self.Width,self.Height)
+    surface.Blit(self.HWND,self.CanvasHWND,&rect_,nil)
+  }
+  
+}
+
+
--- a/Menu/GameShell/10_Settings/Settings.go
+++ b/Menu/GameShell/10_Settings/Settings.go
@ -25,6 +25,10 @@ import (
  "github.com/cuu/LauncherGoDev/Menu/GameShell/10_Settings/Languages"
  
  "github.com/cuu/LauncherGoDev/Menu/GameShell/10_Settings/PowerOFF"
+  "github.com/cuu/LauncherGoDev/Menu/GameShell/10_Settings/PowerOptions"
+  "github.com/cuu/LauncherGoDev/Menu/GameShell/10_Settings/Airplane"
+  
+
 )

 type SettingsPageSelector struct {
@ -92,18 +96,20 @@ func NewSettingsPage() *SettingsPage {

 func (self *SettingsPage) GenList() []*UI.UIPlugin {
  alist := []*UI.UIPlugin{
-    
-    &UI.UIPlugin{0,"",  "Wifi",      "Wi-Fi",&Wifi.APIOBJ},
-    &UI.UIPlugin{0,"",  "Bluetooth", "Bluetooth",&Bluetooth.APIOBJ},
+  
+    &UI.UIPlugin{0,"",    "Airplane",      "Airplane Mode",            &Airplane.APIOBJ},
+    &UI.UIPlugin{0,"",    "PowerOptions",  "Power Options",            &PowerOptions.APIOBJ},
+    &UI.UIPlugin{0,"",    "Wifi",          "Wi-Fi",                    &Wifi.APIOBJ},
+    &UI.UIPlugin{0,"",    "Bluetooth",     "Bluetooth",                &Bluetooth.APIOBJ},

-    &UI.UIPlugin{0,"",      "Sound",     "Sound Volume" ,          &Sound.APIOBJ},
-    &UI.UIPlugin{0,"", "Brightness",     "BackLight Brightness",   &Brightness.APIOBJ},
-    &UI.UIPlugin{0,"", "Storage",        "",                       &Storage.APIOBJ},
-    &UI.UIPlugin{0,"", "Languages",        "Languages",            &Languages.APIOBJ},    
-    &UI.UIPlugin{0,"",     "Update",     "Update",                 &Update.APIOBJ},
-    &UI.UIPlugin{0,"",      "About",     "About",                  &About.APIOBJ},
-    &UI.UIPlugin{0,"",      "PowerOFF",     "Power off",                  &PowerOFF.APIOBJ},
-    &UI.UIPlugin{1,"", "LauncherPy",     "Switch to Launcher",     &LauncherPy.APIOBJ},
+    &UI.UIPlugin{0,"",    "Sound",          "Sound Volume" ,            &Sound.APIOBJ},
+    &UI.UIPlugin{0,"",    "Brightness",     "BackLight Brightness",     &Brightness.APIOBJ},
+    &UI.UIPlugin{0,"",    "Storage",        "",                         &Storage.APIOBJ},
+    &UI.UIPlugin{0,"",    "Languages",      "Languages",                &Languages.APIOBJ},    
+    &UI.UIPlugin{0,"",    "Update",         "Update",                   &Update.APIOBJ},
+    &UI.UIPlugin{0,"",    "About",          "About",                    &About.APIOBJ},
+    &UI.UIPlugin{0,"",    "PowerOFF",       "Power off",                &PowerOFF.APIOBJ},
+    &UI.UIPlugin{1,"",    "LauncherPy",     "Switch to Launcher",       &LauncherPy.APIOBJ},
    
  }
  
--- a/main.go
+++ b/main.go
@ -227,9 +227,14 @@ func PreparationInAdv(){
    
    pwl := strings.Trim(string(b),"\r\n ")
    
-    if pwl == "supersaving" {
-      UI.System("sudo iw wlan0 set power_save on >/dev/null")
-    }else{
+    if pwl != ""{
+      sysgo.CurPowerLevel = pwl
+      if pwl == "supersaving" {
+        UI.System("sudo iw wlan0 set power_save on >/dev/null")
+      }else{
+        UI.System("sudo iw wlan0 set power_save off >/dev/null")
+      }
+    }else {
      UI.System("sudo iw wlan0 set power_save off >/dev/null")
    }
  }
@ -271,12 +276,13 @@ func run() int {
 	UI.SwapAndShow()
 	
 	//fmt.Println(main_screen)
-  event.AllocEvents(4)
+  event.AllocEvents(5)
  event.AddCustomEvent(UI.RUNEVT)
  event.AddCustomEvent(UI.RUNSH)
  event.AddCustomEvent(UI.RUNSYS)
  event.AddCustomEvent(UI.RESTARTUI)
-  
+  event.AddCustomEvent(UI.POWEROPT)
+
  go FlashLed1(main_screen)
  go InspectionTeam(main_screen)
  
@ -360,7 +366,11 @@ func run() int {
          if err != nil {
            fmt.Println(err)
          }
-          os.Exit(0)                    
+          os.Exit(0)
+          
+        case UI.POWEROPT:
+          everytime_keydown = gotime.Now()
+
      }
      
      
--- a/sysgo/UI/events.go
+++ b/sysgo/UI/events.go
@ -6,5 +6,5 @@ const (
    RESTARTUI=2
    RUNSH=3
    RUNSYS=4
-    
+    POWEROPT=5
 )
--- a/sysgo/UI/icon_item.go
+++ b/sysgo/UI/icon_item.go
@ -12,6 +12,8 @@ import (
 	"github.com/cuu/gogame/image"
 	"github.com/cuu/gogame/transform"
 	"github.com/cuu/gogame/utils"
+  "github.com/cuu/gogame/rect"
+
 )

 type IconItemInterface interface {
@ -55,7 +57,9 @@ type IconItemInterface interface {
 	GetCmdInvoke() PluginInterface

 	GetFileName() string
-	Draw() 
+	Draw()
+  DrawTopLeft() 
+  
 }

 type IconItem struct {
@ -244,6 +248,37 @@ func (self *IconItem) GetCmdInvoke() PluginInterface {
 func (self *IconItem) GetFileName() string {
  return self.FileName
 }
+
+func (self *IconItem) DrawTopLeft() {
+  if self.Parent == nil {
+    fmt.Println("Error: IconItem Draw Parent nil")
+    return
+  }
+	parent_x,parent_y := self.Parent.Coord()
+	
+	if self.Label != nil {
+//		lab_x,lab_y := self.Label.Coord()
+		lab_w,lab_h:= self.Label.Size()
+		
+		if self.Align == ALIGN["VCenter"] {
+//			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)
+			
+		}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.Draw()
+	}
+
+	if self.ImgSurf != nil {
+    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)
+	}
+
+}
+
 func (self *IconItem) Draw() {
  if self.Parent == nil {
    fmt.Println("Error: IconItem Draw Parent nil")
--- a/sysgo/UI/multi_icon_item.go
+++ b/sysgo/UI/multi_icon_item.go
@ -31,6 +31,33 @@ func (self * MultiIconItem) CreateImgSurf() {
 	}
 }

+func (self *MultiIconItem) DrawTopLeft() {
+  if self.Parent == nil {
+    fmt.Println("Error: MultiIconItem Draw Parent nil")
+    return
+  }
+  
+  parent_x,parent_y := self.Parent.Coord()
+  
+  if self.Label != nil {
+    lab_w,lab_h:= self.Label.Size()
+    if self.Align == ALIGN["VCenter"] {
+      
+      self.Label.NewCoord( self.PosX - lab_w/2 + parent_x, self.PosY + self.Height/2+6 + parent_y)
+    }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.Draw()
+  }
+  
+  if self.ImgSurf != nil {
+		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
+		surface.Blit(self.Parent.GetCanvasHWND(),self.ImgSurf,&rect_,&portion)
+  }
+
+}
+
 func (self *MultiIconItem) Draw() {
  if self.Parent == nil {
    fmt.Println("Error: MultiIconItem Draw Parent nil")