setup(
name='drlaunch',
- version="0.9.2",
+ version="1.0"
description="DrLaunch",
author="Stefanos Harhalakis",
author_email="v13@v13.gr",
import os
import pickle
-version = "0.9.2"
+version = "1.0"
try:
from glib import get_user_config_dir
self.size = (2,2)
self.themebgsize = 96
- self.iconsize = 64
-# self.iconspace = 42 # For 4 icons (height)
- self.iconspace = 36 # For 8 icons (width)
+ self.iconsize0 = 64
+### self.iconspace = 42 # For 4 icons (height)
+## self.iconspace = 36 # For 8 icons (width)
+
+# self.iconsize = 64
+# self.iconpadding = 12
+# self.iconmargin = 6
+
self.apps=None
self.indiv=True
self.longpress=False
self.nobg=False
self.themebg=False
- self.maxsz=(8,4)
+ self.setDefaultSizes()
+
+ #self.maxsz=(8,4)
def setSize(self, sz):
- self.size=sz
+ maxsz=self.getMaxSize()
+ sz2=(min(sz[0], maxsz[0]), min(sz[1], maxsz[1]))
+ self.size=sz2
def getSize(self):
return(self.size)
+ def setDefaultSizes(self):
+ self.iconsize=64
+ self.iconpadding=12
+ self.iconmargin=6
+
def getMaxSize(self):
- return(self.maxsz)
+ isf=self.getIconSizeFull()
+ retx=int(800/isf)
+ rety=int((480-60)/isf)
+ maxsz=(retx, rety)
+ return(maxsz)
def getIconSize(self):
return(self.iconsize)
+ def setIconSize(self, sz):
+ self.iconsize=sz
+
+ def getIconSpace(self):
+ return((2*self.iconpadding) + (2*self.iconmargin))
+
+ def getIconSizeFull(self):
+ ret=self.iconsize + (2*self.iconpadding) + (2*self.iconmargin)
+ return(ret)
+
+ def getIconMargin(self):
+ return(self.iconmargin)
+
+ def setIconMargin(self, sz):
+ self.iconmargin=sz
+
+ def getIconPadding(self):
+ return(self.iconpadding)
+
+ def setIconPadding(self, sz):
+ self.iconpadding=sz
+
def setIndiv(self, indiv):
self.indiv=indiv
return(self.apps)
+ def filterDefault(self, value, default):
+ if value==default:
+ return(-1)
+ else:
+ return(value)
+
+ def provideDefault(self, value, default):
+ if value==-1:
+ return(default)
+ else:
+ return(value)
+
def save(self):
self.check_init()
if dt==None:
dt={
- 'version': 6,
+ 'version': 7,
'data': {},
}
'animate': self.getAnimate(),
'nobg': self.getNoBg(),
'themebg': self.getThemeBg(),
+ 'iconsize': self.filterDefault(self.getIconSize(), 64),
+ 'iconpadding': self.filterDefault(self.getIconPadding(), 12),
+ 'iconmargin': self.filterDefault(self.getIconMargin(), 6),
}
fn=get_config_fn()
return(dt)
+ def parse_v6(self, dt):
+ dt['version']=7
+
+ for i in dt['data']:
+ dt['data'][i]['iconsize']=-1
+ dt['data'][i]['iconpadding']=-1
+ dt['data'][i]['iconmargin']=-1
+
+ return(dt)
+
def load_all(self):
fn=get_config_fn()
if ret['version']==5:
ret=self.parse_v5(ret)
+
+ if ret['version']==6:
+ ret=self.parse_v6(ret)
except Exception, e:
print "config error:", e
ret=None
self.setAnimate(dt['animate'])
self.setNoBg(dt['nobg'])
self.setThemeBg(dt['themebg'])
+ self.setIconSize(self.provideDefault(dt['iconsize'], 64))
+ self.setIconPadding(self.provideDefault(dt['iconpadding'], 12))
+ self.setIconMargin(self.provideDefault(dt['iconmargin'], 6))
def check_init(self):
if self.id==None:
# Background surface for icons
iconbg=None
+sthemebg1=None
+sthemebg2=None
# Load an icon
# Fall-back to default/blue if not found or name==None
self.name=None
self.icon=None
self.sicon=None
- self.sthemebg1=None
- self.sthemebg2=None
self.lastpress=0
self.ispressed=False
self.cached_icons={}
+ self.draw_queued=False
+
def timePressed(self):
""" return how much time a button is pressed """
dt=time.time() - self.lastpress
return(dt)
+ def reload(self):
+ self.clearAnimationCache()
+ self.clearBgCache()
+ self.invalidate()
+
def setApp(self, dt):
if dt==None:
self.name=None
self.icon=dt['icon2']
self.sicon=None
self.clearAnimationCache()
+ self.clearBgCache()
self.invalidate()
def clearAnimationCache(self):
self.cached_icons={}
+ def clearBgCache(self):
+ global iconbg, sthemebg1, sthemebg2
+
+ iconbg=None
+ sthemebg1=None
+ sthemebg2=None
+
def getSize(self):
- return(self.config.iconsize+self.config.iconspace)
+ return(self.config.getIconSizeFull())
+ # return(self.config.iconsize+self.config.iconspace)
def setAngle(self, angle):
""" Set the angle. Return True if the angle changed or False if it
if iconbg!=None and t_pressed<=0.001:
return(iconbg)
- w=self.config.iconsize + self.config.iconspace
+ w=self.getSize()
s=cairo.ImageSurface(cairo.FORMAT_ARGB32, w, w)
cr0=cairo.Context(s)
cr=gtk.gdk.CairoContext(cr0)
x=0
y=0
- x3=x + (self.config.iconspace/6)
- y3=y + (self.config.iconspace/6)
+ x3=x + (self.config.iconmargin)
+ y3=y + (self.config.iconmargin)
r=10 # Radius
- w=self.config.iconsize+(self.config.iconspace*2/3)
+ w=self.config.iconsize+(self.config.iconpadding*2)
cr.move_to(x3+r, y3)
cr.arc(x3+w-r, y3+r, r, pi*1.5, pi*2)
def get_sthemebg(self, pressed):
""" Return the theme's background icon as a surface. Cache it. """
- if not pressed and self.sthemebg1!=None:
- return(self.sthemebg1)
- if pressed and self.sthemebg2!=None:
- return(self.sthemebg2)
+ global sthemebg1, sthemebg2
+
+ if not pressed and sthemebg1!=None:
+ return(sthemebg1)
+ if pressed and sthemebg2!=None:
+ return(sthemebg2)
fn="/etc/hildon/theme/images/"
if pressed:
else:
fn+="ApplicationShortcutApplet.png"
- w=self.config.themebgsize
+ w=self.config.iconsize + (self.config.iconpadding*2)
buf=gtk.gdk.pixbuf_new_from_file_at_size(fn, w, w)
s=cairo.ImageSurface(cairo.FORMAT_ARGB32, w, w)
cr0=cairo.Context(s)
cr.paint()
if not pressed:
- self.sthemebg1=s
+ sthemebg1=s
else:
- self.sthemebg2=s
+ sthemebg2=s
return(s)
if not pressed and self.cached_icons.has_key(angle):
return(self.cached_icons[angle])
- w=self.config.iconsize + self.config.iconspace
+ w=self.config.getIconSizeFull()
s=cairo.ImageSurface(cairo.FORMAT_ARGB32, w, w)
cr0=cairo.Context(s)
cr=gtk.gdk.CairoContext(cr0)
# have in mind the size difference of iconsize+iconspace with
# the fixed themebgsize
- xy0=int((w-self.config.themebgsize)/2)
+ #xy0=int((w-self.config.themebgsize)/2)
+ #xy0=int((w-self.config.iconsize)/2)
+ xy0=self.config.iconmargin
cr.save()
cr.set_source_surface(s2, xy0, xy0)
return
self.draw_queued=True
- w=self.config.iconsize + self.config.iconspace
+ w=self.getSize()
rect=gdk.Rectangle(self.x, self.y, w, w)
gdk.Window.invalidate_rect(window, rect, True)
self.icons=Icons(self.isconfig, self.config)
self.setMode('l')
- self.setSize((8,4))
+ self.setSize(config.getMaxSize())
self.reloadIcons()
def connect(self, what, *args):
def iconAt(self, x, y):
""" Get icon at coordinates x,y. X and Y are in pixels """
- w=self.config.iconsize + self.config.iconspace
+ w=self.config.getIconSizeFull()
if self.mode=='l' or self.config.getIndiv():
x2=int(x / w)
def _draw(self, cr, event):
self.draw_pending=False
- w=self.config.iconsize + self.config.iconspace
+ w=self.config.getIconSizeFull()
for x,y in self.icons:
if self.mode=='l' or self.config.getIndiv():
- x2=x * (self.config.iconsize + self.config.iconspace)
- y2=y * (self.config.iconsize + self.config.iconspace)
+ #x2=x * (self.config.iconsize + self.config.iconspace)
+ #y2=y * (self.config.iconsize + self.config.iconspace)
+ x2=x * self.config.getIconSizeFull()
+ y2=y * self.config.getIconSizeFull()
else:
- x2=y * (self.config.iconsize + self.config.iconspace)
- y2=(self.size[1]-x-1) * \
- (self.config.iconsize + self.config.iconspace)
+ #x2=y * (self.config.iconsize + self.config.iconspace)
+ #y2=(self.size[1]-x-1) * \
+ # (self.config.iconsize + self.config.iconspace)
+ x2=y * self.config.getIconSizeFull()
+ y2=(self.size[1]-x-1) * self.config.getIconSizeFull()
# Only repaint the needed icons
rect=gdk.Rectangle(x2, y2, w, w)
ic=self.icons.get(x,y)
ic.clearAnimationCache()
+ def clearBgCache(self):
+ """ Clear backgrounds cache """
+ for x,y in self.icons:
+ ic=self.icons.get(x,y)
+ ic.clearBgCache()
+
def do_expose_event(self, event):
cr=self.window.cairo_create()
def setSize(self, size):
IconGrid.setSize(self, size)
- w=self.size[0] * (self.config.iconsize + self.config.iconspace)
- h=self.size[1] * (self.config.iconsize + self.config.iconspace)
+ w=self.size[0] * self.config.getIconSizeFull()
+ h=self.size[1] * self.config.getIconSizeFull()
self.set_size_request(w, h)
+ def reconfig(self):
+ self.reloadIcons()
+ self.setSize(self.size)
+ self.icons.resizeMax()
+ self.queue_draw()
+
def do_realize(self):
screen=self.get_screen()
self.set_colormap(screen.get_rgba_colormap())
# signal handlers
self.h={}
+ self.maxsz=(0,0)
+
# setup allicons
+ self.resizeMax()
+
+ def resizeMax(self):
+ sz=self.maxsz
maxsz=self.config.getMaxSize()
- for x in xrange(maxsz[0]):
- for y in xrange(maxsz[1]):
- k=(x,y)
- ico=Icon(self.isconfig, self.config)
- self.allicons[k]=ico
- self.connect_one(ico)
+
+ # Create new entries in x
+ if maxsz[0]>sz[0]:
+ for x in xrange(maxsz[0]-sz[0]):
+ for y in xrange(sz[1]):
+ k=(x+sz[0],y)
+ ico=Icon(self.isconfig, self.config)
+ self.allicons[k]=ico
+ self.connect_one(ico)
+ sz=(maxsz[0], sz[1])
+ elif maxsz[0]<sz[0]:
+ for x in xrange(sz[0]-maxsz[0]):
+ for y in xrange(sz[1]):
+ k=(maxsz[0]+x,y)
+ self.allicons.pop(k)
+ sz=(maxsz[0], sz[1])
+
+ # Create new entries in y
+ if maxsz[1]>sz[1]:
+ for y in xrange(maxsz[1]-sz[1]):
+ for x in xrange(sz[0]):
+ k=(x,y+sz[1])
+ ico=Icon(self.isconfig, self.config)
+ self.allicons[k]=ico
+ self.connect_one(ico)
+ sz=(sz[0], maxsz[1])
+ elif maxsz[1]<sz[1]:
+ for y in xrange(sz[1]-maxsz[1]):
+ for x in xrange(sz[0]):
+ k=(x,y+maxsz[1])
+ self.allicons.pop(k)
+ sz=(sz[0], maxsz[1])
+
+ self.maxsz=sz
@classmethod
def register_signals(cls):
# 'extcalllog', 'browser', 'modest', 'osso-addressbook']
wapps=self.config.getApps()
- sz=self.config.getSize()
+ #sz=self.config.getSize()
+ sz=self.getSize()
for k in wapps:
x,y=k
app['icon2']=getIcon(app['icon'], self.config.getIconSize())
self.get(x,y).setApp(app)
else:
- self.get(x,y).setApp(None)
+ ic=self.get(x,y)
+ ic.setApp(None)
+
+ # Reload icons to make sure backgrounds, etc are valid
+ for x in xrange(sz[0]):
+ for y in xrange(sz[1]):
+ ic=self.get(x,y)
+ ic.reload()
+
# for f in fn:
# dt=apps.readOne(f)
config.setAnimate(dt['animate'])
config.setNoBg(dt['nobg'])
config.setThemeBg(dt['themebg'])
+ config.setIconSize(dt['iconsize'])
+ config.setIconPadding(dt['iconpadding'])
+ config.setIconMargin(dt['iconmargin'])
config.save()
# Resize widget
self.setSize(dt['size'])
self.reloadIcons()
+ self.icons.resizeMax()
# Free memory that is used for animations if animations are disabled
if not dt['animate']:
self.clearAnimationCache()
+ # Free memory of backgrounds in case they changed
+ self.clearBgCache()
+
self.queue_draw()
def handle_click(self, sender, icon):
""" common handler for longpress and click """
if icon.name!=None and icon.name!='':
- print "name:", icon.name
launcher.launch(icon.name)
def signalLongpress(self, sender, icon):
config=self.get_config()
w=(self.size[0] * config.iconsize) + \
- (self.size[0] * config.iconspace)
+ (self.size[0] * config.getIconSpace())
+# (self.size[0] * config.iconspace)
h=(self.size[1] * config.iconsize) + \
- (self.size[1] * config.iconspace)
+ (self.size[1] * config.getIconSpace())
+# (self.size[1] * config.iconspace)
self.set_size_request(w, h)
self.resize(w, h)
import gobject
import hildon
import time
+import copy
from hildon import StackableWindow
#from portrait import FremantleRotation
from about import DlgAbout
from portrait import FremantleRotation
+class DialogIconSize(gtk.Dialog):
+ def __init__(self, config):
+ gtk.Dialog.__init__(self, "Adjust icon size")
+
+ # Operate on copy of config
+ self.config=copy.copy(config)
+ # And keep another copy to be able to undo
+ self.config0=copy.copy(config)
+
+ vbox=self.vbox
+
+ self.labelDim=gtk.Label("koko")
+ vbox.add(self.labelDim)
+
+ vbox.add(gtk.Label("Icon size:"))
+ scale=gtk.HScale()
+ scale.set_digits(0)
+ scale.set_value_pos(gtk.POS_RIGHT)
+ scale.set_range(48,128)
+ scale.set_increments(8, 16)
+ self.scaleIconSize=scale
+ vbox.add(scale)
+
+ hbox=gtk.HBox()
+ vbox.add(hbox)
+
+ vbox2=gtk.VBox()
+ vbox2.add(gtk.Label("Padding:"))
+ scale=gtk.HScale()
+ scale.set_digits(0)
+ scale.set_value_pos(gtk.POS_RIGHT)
+ scale.set_range(2,16)
+ scale.set_increments(2,2)
+ self.scaleIconPadding=scale
+ vbox2.add(scale)
+ hbox.add(vbox2)
+
+ vbox2=gtk.VBox()
+ vbox2.add(gtk.Label("Margin:"))
+ scale=gtk.HScale()
+ scale.set_digits(0)
+ scale.set_value_pos(gtk.POS_RIGHT)
+ scale.set_range(2,16)
+ scale.set_increments(2,2)
+ self.scaleIconMargin=scale
+ vbox2.add(scale)
+ hbox.add(vbox2)
+
+ self.scaleIconSize.set_value(self.config.getIconSize())
+ self.scaleIconPadding.set_value(self.config.getIconPadding())
+ self.scaleIconMargin.set_value(self.config.getIconMargin())
+
+ # Set thos after settings initial values to avoid unwanted effects
+ self.scaleIconSize.connect('value-changed', self.slotSzChangeSize)
+ self.scaleIconPadding.connect('value-changed', self.slotSzChangePadding)
+ self.scaleIconMargin.connect('value-changed', self.slotSzChangeMargin)
+
+ hbox=gtk.HBox()
+ vbox.add(hbox)
+
+ but=hildon.Button(
+ gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT,
+ hildon.BUTTON_ARRANGEMENT_VERTICAL)
+ but.set_title("OK")
+ but.connect("clicked", self.slotButtonOK)
+ #hbox.add(but)
+ self.action_area.pack_start(but)
+ self.buttonOK=but
+
+ but=hildon.Button(
+ gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT,
+ hildon.BUTTON_ARRANGEMENT_VERTICAL)
+ but.set_title("Undo")
+ but.connect("clicked", self.slotButtonUndo)
+ #hbox.add(but)
+ self.action_area.pack_start(but)
+ self.buttonUndo=but
+
+ but=hildon.Button(
+ gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT,
+ hildon.BUTTON_ARRANGEMENT_VERTICAL)
+ but.set_title("Restore defaults")
+ but.connect("clicked", self.slotButtonDefaults)
+ #hbox.add(but)
+ self.action_area.pack_start(but)
+ self.buttonDefaults=but
+
+ self.show_all()
+
+ self.recalc()
+
+ def setWH(self, w, h):
+ self.labelDim.set_text("Grid size: %d x %d icons" % (w, h))
+ #self.labelWidth.set_text("Width: %d icons" % w)
+ #self.labelHeight.set_text("Height: %d icons" % h)
+
+ def recalc(self):
+ maxsz=self.config.getMaxSize()
+ self.setWH(maxsz[0], maxsz[1])
+
+ def getIconSize(self):
+ return(self.scaleIconSize.get_value())
+
+ def setIconSize(self, iconsize):
+ self.scaleIconSize.set_value(iconsize)
+
+ def getIconPadding(self):
+ return(self.scaleIconPadding.get_value())
+
+ def setIconPadding(self, pad):
+ self.scaleIconPadding.set_value(pad)
+
+ def getIconMargin(self):
+ return(self.scaleIconMargin.get_value())
+
+ def setIconMargin(self, margin):
+ self.scaleIconMargin.set_value(margin)
+
+ def slotSzChangeSize(self, sender):
+ self.config.setIconSize(int(self.getIconSize()))
+ self.recalc()
+
+ def slotSzChangeMargin(self, sender):
+ self.config.setIconMargin(int(self.getIconMargin()))
+ self.recalc()
+
+ def slotSzChangePadding(self, sender):
+ self.config.setIconPadding(int(self.getIconPadding()))
+ self.recalc()
+
+ def slotButtonUndo(self, sender):
+ self.config=copy.copy(self.config0)
+ self.recalc()
+ self.resetSliders()
+
+ def slotButtonDefaults(self, sender):
+ self.config.setDefaultSizes()
+ self.recalc()
+ self.resetSliders()
+
+ def slotButtonOK(self, sender):
+ self.response(gtk.RESPONSE_OK)
+
+ def resetSliders(self):
+ self.scaleIconSize.set_value(self.config.getIconSize())
+ self.scaleIconPadding.set_value(self.config.getIconPadding())
+ self.scaleIconMargin.set_value(self.config.getIconMargin())
+
+ def getData(self):
+ ret={
+ 'size': self.config.getIconSize(),
+ 'padding': self.config.getIconPadding(),
+ 'margin': self.config.getIconMargin()
+ }
+
+ return(ret)
+
+
class WinConfig(StackableWindow): #, FremantleRotation):
def __init__(self, config, *args):
StackableWindow.__init__(self)
# FremantleRotation.__init__(self, "DrlaunchPlugin",
# mode=FremantleRotation.AUTOMATIC)
- self.config=config
+ self.config=copy.copy(config)
self.setupUi()
maxsz=self.config.getMaxSize()
+ self.maxmaxsz=(16,16)
+
# ----------------------------------------------
vbox.add(gtk.Label('Width:'))
self.butsSizeX=[]
self.butsSize=self.butsSizeX # For now
- for i in xrange(maxsz[0]):
+ for i in xrange(self.maxmaxsz[0]):
but=hildon.GtkToggleButton(gtk.HILDON_SIZE_FINGER_HEIGHT)
but.set_label("%s" % (i+1,))
but.connect('toggled', self.slotButtonSizeX, i)
vbox.add(hbox2)
self.butsSizeY=[]
- for i in xrange(maxsz[1]):
+ for i in xrange(self.maxmaxsz[1]):
but=hildon.GtkToggleButton(gtk.HILDON_SIZE_FINGER_HEIGHT)
but.set_label("%s" % (i+1,))
but.connect('toggled', self.slotButtonSizeY, i)
but=hildon.CheckButton(
gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT)
but.set_label("No background")
- #but.connect('toggled', self.slotButtonNoBackground)
+ but.connect('toggled', self.slotButtonNoBackground)
self.buttonNoBackground=but
vbox.add(but)
+ but=hildon.Button(
+ gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT,
+ hildon.BUTTON_ARRANGEMENT_VERTICAL)
+ but.set_label("Adjust icon size")
+ but.connect('clicked', self.slotButtonIconSize)
+ self.buttonIconSize=but
+ vbox.add(but)
+
#1 hbox.add(al)
but=hildon.Button(
gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT,
self.setAnimate(self.config.getAnimate())
self.setNoBg(self.config.getNoBg())
self.setThemeBg(self.config.getThemeBg())
+# self.setIconSize(self.config.getIconSize())
+# self.setIconPadding(self.config.getIconPadding())
+# self.setIconMargin(self.config.getIconMargin())
hbox=gtk.HBox()
hbox.add(self.col1)
self.add(self.pa)
+ self.adjustMaxSize()
+
# def setupUi(self, orientation):
#
# self.setupUi0()
# self.add(self.pa)
# self.pa.show_all()
+ def adjustMaxSize(self):
+ sz=self.config.getMaxSize()
+ maxsz=self.maxmaxsz
+
+ for x in xrange(maxsz[0]):
+ if x<sz[0]:
+ self.butsSizeX[x].show()
+ else:
+ self.butsSizeX[x].hide()
+
+ for y in xrange(maxsz[1]):
+ if y<sz[1]:
+ self.butsSizeY[y].show()
+ else:
+ self.butsSizeY[y].hide()
+
+ osz=self.getSize()
+ nsz=[osz[0], osz[1]]
+
+ if osz[0]>sz[0]:
+ nsz[0]=sz[0]
+ if osz[1]>sz[1]:
+ nsz[1]=sz[1]
+ self.setSize(nsz)
+
+ self.setIndiv(self.getIndiv())
+
def setLayoutPortrait(self):
print "lo: p"
hbox=gtk.HBox()
but=self.buttonRotateIndividually
self.setIndiv(but.get_active())
+ def slotButtonNoBackground(self, sender):
+ nobg=self.getNoBg()
+ self.setNoBg(nobg)
+
def slotButtonAbout(self, sender):
DlgAbout.present2(self)
+ def slotButtonIconSize(self, sender):
+ dlg=DialogIconSize(self.config)
+ ret=dlg.run()
+ dt=dlg.getData()
+ dlg.destroy()
+
+ if ret!=gtk.RESPONSE_OK:
+ return
+
+ self.config.setIconSize(dt['size'])
+ self.config.setIconMargin(dt['margin'])
+ self.config.setIconPadding(dt['padding'])
+ self.igw.reconfig()
+ self.adjustMaxSize()
+ self.queue_draw()
+
+ def show_all(self):
+ StackableWindow.show_all(self)
+ self.adjustMaxSize()
+ self.queue_draw()
+
+ def slotScaleIconSzChange(self, sender):
+ return
+ self.config.setIconSize(self.getIconSize())
+ self.config.setIconMargin(self.getIconMargin())
+ self.config.setIconPadding(self.getIconPadding())
+ self.igw.reconfig()
+ self.adjustMaxSize()
+ self.queue_draw()
+
# def slotButtonLongpress(self, sender):
# but=self.buttonRequireLongpress
# self.set
self.igw.setSize(sz)
self.igw.queue_draw()
+ self.queue_draw()
def getSize(self):
return(self.igw.getSize())
i.set_sensitive(True)
else:
+ sz=self.config.getMaxSize()
+
for i in self.butsSizeY:
i.set_sensitive(False)
cnt=0
for i in self.butsSizeX:
cnt+=1
- if cnt>4:
+ # Height is always the narrower, so use that as a limit
+ if cnt>sz[1]:
i.set_sensitive(False)
+ else:
+ i.set_sensitive(True)
sz=self.getSize()
szx=sz[0]
- if szx>4:
- szx=4
+ if szx>sz[1]:
+ szx=sz[1]
self.setSize((szx, szx))
self.buttonRotateIndividually.set_active(indiv)
def setAnimate(self, ar):
self.buttonAnimateRotation.set_active(ar)
+ def getNoBg(self):
+ ret=self.buttonNoBackground.get_active()
+
+ return(ret)
+
def setNoBg(self, nobg):
self.buttonNoBackground.set_active(nobg)
+ self.buttonThemeBackground.set_sensitive(not nobg)
+
def setThemeBg(self, themebg):
self.buttonThemeBackground.set_active(themebg)
'animate': ar,
'nobg': nobg,
'themebg': themebg,
+ 'iconsize': self.config.getIconSize(),
+ 'iconpadding': self.config.getIconPadding(),
+ 'iconmargin': self.config.getIconMargin(),
}
return(ret)
projects / drlaunch / commitdiff