def _makeWdg(self, wdgInfo):
"""Returns a widget depending on wdgInfo:
- None or False: returns None or False
- a string: returns an RO.Wdg.StrVariable with text=wdgInfo
- a Tkinter Variable: returns an RO.Wdg.StrVariable with textvariable=wdgInfo
- a Tkinter Widget: returns wdgInfo unaltered
"""
if wdgInfo in (None, False):
return wdgInfo
elif isinstance(wdgInfo, Tkinter.Widget):
# a widget; assume it's a Label widget of some kind
return wdgInfo
if isinstance(wdgInfo, Tkinter.Variable):
# a Tkinter variable
wdg = Label.StrLabel(
master=self.master,
textvariable=wdgInfo,
helpText=self.helpText,
helpURL=self.helpURL,
)
else:
wdg = Label.StrLabel(
master=self.master,
text=wdgInfo,
helpText=self.helpText,
helpURL=self.helpURL,
)
return wdg
def testEqual(self):
field1 = Label.Field()
field2 = Label.Field()
self.assertEqual(field1,field2,'Label Field Comparison not working')
field1.setData('0365')
field2.setData('0365')
self.assertEqual(field1,field2,'Label Field Comparison not working')
def get(self):
user = users.get_current_user()
if (self.request.get('Type') == 'All'):
str = Label.get_label_object_list_for_user_JSON(user)
self.response.out.write(str)
elif (self.request.get('Type') == 'Unique'):
str = Label.get_labels_dict_JSON(user)
self.response.out.write(str)
def LabelPeaks(self, PeakTolerance = 0.5):
"""
Should be called once, *if* the annotations differ, so that we can match
corresponding peaks which have different masses due to PTM attachment.
"""
# Label the spectra so that I can know which peaks belong to what name eg. b7
Label.LabelSpectrum(self.SpectrumA, self.PeptideA, PeakTolerance)
Label.LabelSpectrum(self.SpectrumB, self.PeptideB, PeakTolerance)
def testDifferent(self):
field1 = Label.Field()
field1.setData('0365')
field2 = Label.Field()
field2.setData('0364')
self.assertNotEqual(field1,field2,'Label Field Comparison not working')
field3 = Label.Field()
self.assertNotEqual(field1,field3,'Label Field Comparison not working')
def initCommandSettingsMenu(self):
# Labels first
Label.hideLabels(self.labels)
self.labels = self.labelDict['commandSettingsMenu']
Label.showLabels(self.labels)
# Buttons
Button.hideButtons(self.buttons)
self.buttons = self.buttonDict['commandSettingsMenu']
Button.showButtons(self.buttons)
def initAboutMenu(self):
# Labels first
Label.hideLabels(self.labels)
self.labels = self.labelDict['aboutMenu']
Label.showLabels(self.labels)
# Buttons second
Button.hideButtons(self.buttons)
self.buttons = self.buttonDict['aboutMenu']
Button.showButtons(self.buttons)
def __init__(self, master):
self.master = master
master.title("A simple GUI")
self.label = Label(master, text="This is our first GUI!")
self.label.pack()
self.greet_button = Button(master, text="Greet", command=self.greet)
self.greet_button.pack()
self.close_button = Button(master, text="Close", command=master.quit)
self.close_button.pack()
def transform_image_to_RGB(path_data,
from_picture=0,
to_picture=2,
mode="test",
end_name='leftImg8bit.png'):
"""
:param path_data: path to the folder that contain all the data
:param from_picture: first picture that will be transform
:param to_picture: last picture that will be transform
:param mode: train val or test
:param end_name: end of the name of image that you want to keep
:return: Nothing but save to_picture-from_picture images into RGB format that will be in the path_data/mode
location and have the exact end_name
"""
# Make the DataSet and the names
paths, names = make_dataset(mode=mode,
path_data=path_data,
end_name=end_name)
# sort the path and name so that it is always organized in the same way
paths.sort()
names.sort()
# Reduce the number of image
paths = paths #[from_picture:to_picture]
names = names #[from_picture:to_picture]
# Create the dictionary that will transform 1D to RBG image
labels = Label.create_label_plot()
train_id2label = Label.train_id2label(labels)
# Loop over each picture
for i in range(len(paths)):
# Create the Picture type
picture = Picture(path_image=paths[i])
# Transform into RGB
RGB = picture.classes_to_color(id_to_label=train_id2label)
# Change the name
path_export_color = paths[i].replace(end_name, 'prediction_color.png')
# transform into PIL image
RGB = np.uint8(RGB)
RGB = Image.fromarray(RGB)
# Save the file
RGB.save(path_export_color)
with open(
"/home_expes/kt82128h/GridNet/Python_Files/Python_print_test.txt",
'a') as txtfile:
txtfile.write("image saved " + path_export_color + "\n")
def initLabels(self):
self.labelDict['startMenu'] = [
Label.showText(self, 1 / 2, 1 / 4, 3 / 4, 1 / 8, 10,
__class__.largeStyle,
'Sustainable Earth Arduino Garden')
]
self.labelDict['commandsMenu'] = [
Label.showText(self, 1 / 2, 1 / 8, 1 / 2, 1 / 12, 10,
__class__.largeStyle, 'Garden Command Center'),
Label.showText(self, 1 / 3, 1 / 2, 1 / 2, 14 / 25, 10,
__class__.smallStyle, self.logText)
]
self.labelDict['settingsMenu'] = [
Label.showText(self, 1 / 2, 1 / 8, 1 / 2, 1 / 12, 10,
__class__.largeStyle, 'General Settings')
]
self.labelDict['aboutMenu'] = [
Label.showText(self, 1 / 2, 1 / 8, 1 / 2, 1 / 12, 10,
__class__.largeStyle, 'About'),
Label.showText(self, 1 / 2, 1 / 2, 3 / 5, 1 / 3, 10,
__class__.smallStyle, self.aboutText)
]
self.labelDict['commandSettingsMenu'] = [
Label.showText(self, 1 / 2, 1 / 8, 1 / 2, 1 / 12, 10,
__class__.largeStyle, 'Garden Water Settings'),
Label.showText(
self, 1 / 3, 16 / 36, 1 / 3, 1 / 20, 10, __class__.smallStyle,
'Watering Interval: %d minutes' %
arduinoControl.waterInterval),
]
def find_top_labels(self, g, k=6):
labels = self.__ontology.get_labels()
label_score = []
for i in range(len(labels)):
# put a condition that verifies if the labels is
#print labels[i] + ' -- ' + g.get_name()
score = self.__predictor.run(labels[i], g)
label_score.append((score, labels[i]))
#print 'feature: ' + repr(g.get_features())
#print 'labels: ' + repr(labels)
#print 'scores: ' + repr(label_score)
label_score.sort(reverse=True)
#print 'scores: ' + repr(label_score)
feature_bond_structure = self.__ontology.get_bond_structure(
g.get_name())
#print g.get_name() + ' ' + repr(feature_bond_structure)
for i in range(k):
name = label_score[i][1]
print 'label: ' + name
# when features connect to labels
label_modalities = self.__ontology.get_modalities(name)
#print 'modalities: '+repr(label_modalities)
for bond in feature_bond_structure:
if bond[0] in label_modalities:
score = label_score[i][0]
level = self.__ontology.get_level(name)
modality = self.__ontology.get_modalities(name)
g.add_top_label(
Label(name, modality, level, score, -1, 0.0))
break
def get(self):
t = get_template('search.html')
c = Context()
user = users.get_current_user()
if self.request.get('action_type') == "ShowLabel":
label_name = self.request.get('Id')
htmlParser = Label.get_articles_list_with_label_as_HTMLParser(user, label_name)
elif self.request.get('action_type') == "ShowPending":
label_name = self.request.get('pending_id')
htmlParser = PendingSharedLabel.pending_share_preview_as_HTMLparser(user, label_name)
if (isinstance( htmlParser, int)):
self.response.out.write("an error occurred")
return
results = htmlParser.results
my_html_parser_encoder = JSONConvertors.HTMLparserEncoder()
resultsJSON = my_html_parser_encoder.encode(htmlParser)
c['users'] = users
c['hidden_label_name'] = label_name
c['results'] = results
c['resultsJSON'] = resultsJSON
c['formAction'] = '/AddFollow'
c['showlabel'] = True
c['showlabelsearch'] = True
self.response.out.write(t.render(c))
def post(self):
user = users.get_current_user()
label_name = self.request.get('label_name')
article_key = self.request.get('article_key')
comment_content =self.request.get('comment_content')
res = Label.update_comment(user, label_name, article_key, comment_content)
self.response.out.write(simplejson.dumps(res))
def _makeWdg(self, wdgInfo, **kargs):
"""Return a widget depending on wdgInfo:
- None or False: returns None or False
- a string: returns a Label with text=wdgInfo
- a Tkinter Variable: returns a Label with textvariable=wdgInfo
- a Tkinter Widget: returns wdgInfo unaltered
kargs is ignored if wdgInfo is a widget
"""
if wdgInfo is None:
return wdgInfo
elif isinstance(wdgInfo, Tkinter.Widget):
# a widget; assume it's a Label widget of some kind
return wdgInfo
# at this point we know we are going to create our own widget
# set up the keyword arguments
kargs.setdefault("helpText", self.helpText)
kargs.setdefault("helpURL", self.helpURL)
if isinstance(wdgInfo, Tkinter.Variable):
kargs["textvariable"] = wdgInfo
else:
kargs["text"] = wdgInfo
return Label.StrLabel(self, **kargs)
def testLabelFormat(self):
"""
Confirm that an integer or floating point value is not accepted a labeValue
"""
label = Label.Field()
self.assertRaises(Exception.A429Exception,label.setData,5)
self.assertRaises(Exception.A429Exception,label.setData,8.5)
def handleScannedPartId(self, partId):
result = self.partDB.db.query(filter=lambda k, v: (k == partId))
if len(result) == 0:
raise Exception('Part ID %s not found in database.' % (partId))
if self.partDB.args.fix:
result = self.partDB.db.query(filter=lambda k, v: (k == partId))
data = result[partId]
distributorMatches = {}
for distributorName in data['distributor']:
minimumData = {
'distributor': {
distributorName: {
'distributorPartNumber':
data['distributor'][distributorName]
['distributorPartNumber']
}
}
}
newData = self.partDB.distributors[distributorName].getData(
minimumData)
Database.mergeData(data, newData, override=True)
self.partDB.db.update(data)
if len(result) > 0:
if (self.partDB.args.printLabel):
label = Label.Label()
label.createLabelFromData(data=data)
label.cupsPrint(printerName=self.partDB.args.printerName)
else:
raise Exception('ID %s not found in database.' %
(self.partDB.args.id))
return
data = result[partId]
self.partDB.displayItem(data)
print(
'Quantity is %u. Scan/Enter new quantity (+/- for relative) or press return:'
% data['quantity'])
quantityInput = self.scanAndInput()
if quantityInput != b'':
quantityInputAscii = quantityInput.decode('ascii')
# check if first character is + or -
if (quantityInputAscii[0]) == '+' or (quantityInputAscii[0]
== '-'):
data['quantity'] += int(quantityInputAscii)
else:
data['quantity'] = int(quantityInputAscii)
print('New quantity is %u.' % (data['quantity']))
self.partDB.db.update(data)
def testPackNoData(self):
'''
Call pack when the label was not set
'''
labelField = Label.Field()
labelField.setData(str(41))
labelField.clear()
self.assertRaises(Exception.A429NoData,labelField.pack)
def get(self):
user = users.get_current_user()
label_name = self.request.get('label_name')
res = Label.delete_label(user,label_name)
if (not res):
self.response.out.write(simplejson.dumps(""))
else:
self.response.out.write(simplejson.dumps(label_name))
def testLabelPacking(self):
"""
pack different labels and confirm they are coded properly
"""
for label,packed in self.refValues:
labelField = Label.Field()
labelField.setData(str(label))
self.assertEqual(labelField.pack(),packed, "Label Not Packed Properly")
def testLabelUnpacking(self):
"""
unpack different labels and confirm they are decoded properly
"""
for label,packed in self.refValues:
labelField = Label.Field()
labelField.unpack(packed)
self.assertEqual(labelField.getData(),int(str(label),8), "Label Not Unpacked Properly")
def _useAttributes(self, attributes):
if "assignee" in attributes: # pragma no branch
assert attributes["assignee"] is None or isinstance(attributes["assignee"], dict), attributes["assignee"]
self._assignee = None if attributes["assignee"] is None else NamedUser.NamedUser(self._requester, attributes["assignee"], completed=False)
if "body" in attributes: # pragma no branch
assert attributes["body"] is None or isinstance(attributes["body"], (str, unicode)), attributes["body"]
self._body = attributes["body"]
if "closed_at" in attributes: # pragma no branch
assert attributes["closed_at"] is None or isinstance(attributes["closed_at"], (str, unicode)), attributes["closed_at"]
self._closed_at = self._parseDatetime(attributes["closed_at"])
if "closed_by" in attributes: # pragma no branch
assert attributes["closed_by"] is None or isinstance(attributes["closed_by"], dict), attributes["closed_by"]
self._closed_by = None if attributes["closed_by"] is None else NamedUser.NamedUser(self._requester, attributes["closed_by"], completed=False)
if "comments" in attributes: # pragma no branch
assert attributes["comments"] is None or isinstance(attributes["comments"], (int, long)), attributes["comments"]
self._comments = attributes["comments"]
if "created_at" in attributes: # pragma no branch
assert attributes["created_at"] is None or isinstance(attributes["created_at"], (str, unicode)), attributes["created_at"]
self._created_at = self._parseDatetime(attributes["created_at"])
if "html_url" in attributes: # pragma no branch
assert attributes["html_url"] is None or isinstance(attributes["html_url"], (str, unicode)), attributes["html_url"]
self._html_url = attributes["html_url"]
if "id" in attributes: # pragma no branch
assert attributes["id"] is None or isinstance(attributes["id"], (int, long)), attributes["id"]
self._id = attributes["id"]
if "labels" in attributes: # pragma no branch
assert attributes["labels"] is None or all(isinstance(element, dict) for element in attributes["labels"]), attributes["labels"]
self._labels = None if attributes["labels"] is None else [
Label.Label(self._requester, element, completed=False)
for element in attributes["labels"]
]
if "milestone" in attributes: # pragma no branch
assert attributes["milestone"] is None or isinstance(attributes["milestone"], dict), attributes["milestone"]
self._milestone = None if attributes["milestone"] is None else Milestone.Milestone(self._requester, attributes["milestone"], completed=False)
if "number" in attributes: # pragma no branch
assert attributes["number"] is None or isinstance(attributes["number"], (int, long)), attributes["number"]
self._number = attributes["number"]
if "pull_request" in attributes: # pragma no branch
assert attributes["pull_request"] is None or isinstance(attributes["pull_request"], dict), attributes["pull_request"]
self._pull_request = None if attributes["pull_request"] is None else IssuePullRequest.IssuePullRequest(self._requester, attributes["pull_request"], completed=False)
if "repository" in attributes: # pragma no branch
assert attributes["repository"] is None or isinstance(attributes["repository"], dict), attributes["repository"]
self._repository = None if attributes["repository"] is None else Repository.Repository(self._requester, attributes["repository"], completed=False)
if "state" in attributes: # pragma no branch
assert attributes["state"] is None or isinstance(attributes["state"], (str, unicode)), attributes["state"]
self._state = attributes["state"]
if "title" in attributes: # pragma no branch
assert attributes["title"] is None or isinstance(attributes["title"], (str, unicode)), attributes["title"]
self._title = attributes["title"]
if "updated_at" in attributes: # pragma no branch
assert attributes["updated_at"] is None or isinstance(attributes["updated_at"], (str, unicode)), attributes["updated_at"]
self._updated_at = self._parseDatetime(attributes["updated_at"])
if "url" in attributes: # pragma no branch
assert attributes["url"] is None or isinstance(attributes["url"], (str, unicode)), attributes["url"]
self._url = attributes["url"]
if "user" in attributes: # pragma no branch
assert attributes["user"] is None or isinstance(attributes["user"], dict), attributes["user"]
self._user = None if attributes["user"] is None else NamedUser.NamedUser(self._requester, attributes["user"], completed=False)
def post(self):
user = users.get_current_user()
label_name = self.request.get('label_name')
new_name = self.request.get('new_name')
res = Label.rename_label(user, label_name, new_name)
if (res != True):
self.response.out.write(simplejson.dumps(""))
else:
self.response.out.write(simplejson.dumps(label_name + "_|_" + new_name))
def create_label(self, name, color):
assert isinstance(name, (str, unicode)), name
assert isinstance(color, (str, unicode)), color
post_parameters = {
"name": name,
"color": color,
}
headers, data = self._requester.requestAndCheck(
"POST", self.url + "/labels", None, post_parameters)
return Label.Label(self._requester, data, completed=True)
def set_text(self, text):
if type(text) in StringTypes:
self.text = text
else:
raise TypeError, type(text)
if not self.label:
self.label = Label(h_align=Align.CENTER,
v_align=Align.CENTER,
text_prop={
'align_h': 'center',
'align_v': 'center',
'mode': 'hard',
'hfill': False
})
self.label.set_text(text)
self.add_child(self.label)
else:
self.label.set_text(text)
def run(self):
result = self.partDB.db.query(
filter=lambda k, v: (k == self.partDB.args.id))
if len(result) > 0:
label = Label.Label()
label.createLabelFromData(data=result[self.partDB.args.id])
label.cupsPrint(printerName=self.partDB.args.printerName)
else:
raise Exception('ID %s not found in database.' %
(self.partDB.args.id))
def getSurface(self):
self.labelAmount = Label.Label(
"Amount: " + str(self.amount)) #Update the amount label
#Recreate surface after amount change
self.surface = pygame.image.load(self.icon).convert()
self.surface.blit(self.labelName.getSurface(), (0, 0))
self.surface.blit(self.labelPrice.getSurface(),
(0, 0 + self.height / 3))
self.surface.blit(self.labelAmount.getSurface(),
(0, 0 + self.height * 2 / 3))
return self.surface
def body(self, master):
Label.StrLabel(master=master,
text="Delete Preseturation:").grid(row=0,
column=0,
columnspan=5)
self.currNameWdg = OptionMenu.OptionMenu(
master=master,
items=self._currNameList,
)
self.currNameWdg.grid(row=1, column=1)
def __init__(self,name,parity='odd'):
'''
Create an A429 Message by simply adding a label and a parity bit
Note that the parity is odd by default but can be modified as necessary
'''
self.name = name
self._fields = list()
self.fieldAdditionRules = (self.__field_overlaps,self.__field_name_already_exist)
self.addField(Label.Field())
self.addField(Parity.Field(parity))
def __init__(self, name, id, price, amount, location, width, height, icon,
command, commandRight):
self.name = name
self.id = id
self.price = price
self.amount = amount
self.location = location
self.width = width
self.height = height
self.icon = icon
self.surface = pygame.image.load(icon).convert()
self.button = Button.Button(width, height, location, command,
commandRight, self)
self.totalPrice = price * amount
self.labelName = Label.Label("Name: " + str(name))
self.labelPrice = Label.Label("Price: " + str(price))
self.labelAmount = Label.Label("Amount: " + str(amount))
self.surface.blit(self.labelName.getSurface(), (0, 0))
self.surface.blit(self.labelPrice.getSurface(), (0, 0 + height / 3))
self.surface.blit(self.labelAmount.getSurface(),
(0, 0 + height * 2 / 3))
def on_loop(self):
if self._screen == "Main":
self.title = Label.Label("Main Screen").getSurface()
self.buttons = []
for itemCat in self._itemCategories:
self.buttons.append(itemCat.getButton())
self.buttons.append(self.checkoutButton)
elif self._screen.find("itemCatScreen:") != -1:
self.title = Label.Label(
"Item Category Screen of: " + self._itemCategories[int(
self._screen.replace("itemCatScreen:", ""))].name
).getSurface()
itemCatNumber = int(self._screen.replace("itemCatScreen:", ""))
self.buttons = []
for item in self._itemCategories[itemCatNumber].items:
self.buttons.append(item.getButton())
self.buttons.append(self.backButton)
elif self._screen == "checkOut":
self.title = Label.Label("Check Out Screen").getSurface()
self.buttons = []
self.buttons.append(self.finishButton)
self.buttons.append(self.addMoney10Button)
self.buttons.append(self.addMoney10MButton)
self.buttons.append(self.backButton)
itemsShopped = []
for itemCat in self._itemCategories:
for item in itemCat.items:
if item.amount > 0:
itemsShopped.append(item)
self.surfacesOfItemsShopped = []
for item in itemsShopped:
self.surfacesOfItemsShopped.append(
Label.Label("Name: " + item.name + "Price: " +
str(item.price) + " Amount: " +
str(item.amount) + " TotPrice: " +
str(item.getTotalPrice())))
def __init__(self, director, size, color):
gtk.Layout.__init__(self)
self._canRecord = True
try:
s = subprocess.Popen(['ffmpeg'], \
stderr=subprocess.STDOUT, stdout=subprocess.PIPE).communicate()[0]
except OSError:
self._canRecord = False
self._director = director
self._color = color
self._size = size
#self.set_double_buffered(True) # this is possibly set by default. need to come up with another double buffering solution
self._screenshotPath = ""
self._screenshotName = ""
self._isRecording = False
self._renderNode = Node(MakeRect(0,0,self._size.width, self._size.height))
self._renderNode.setBackgroundColor(Color(1.0, 1.0, 1.0, 0.90))
label = Label("Rendering video...", color=BlackColor())
label.setFontSize(36)
label.setPosition(Point(0, self._size.height/2))
self._renderNode.addChild(label)
self._framerate = None
self._exposeCounter = 0
self.set_flags(gtk.CAN_FOCUS)
self.grab_focus()
self.set_events(GTK_EVENT_MASKS)
self.set_size_request(size.width, size.height)
self.connect("expose-event", self._onExpose)
gestureDispatch = self._director.getGestureDispatch()
self.connect("motion-notify-event", gestureDispatch._onMouseMotion)
self.connect("button-press-event", gestureDispatch._onMousePress)
self.connect("button-release-event", gestureDispatch._onMouseRelease)
self.connect("scroll-event", gestureDispatch._onMouseScroll)
self.connect("key-press-event", gestureDispatch._onKeyPress)
self.connect("key-release-event", gestureDispatch._onKeyRelease)
def pending_share_preview_as_HTMLparser(invited_user, pending_id):
pending_obj = get_single_pending(invited_user, pending_id)
if not isinstance(pending_obj, PendingSharedLabel):
return pending_obj
article_objects_list = Label.get_articles_list_with_label(pending_obj.inviting_user, pending_obj.label_name)
if (article_objects_list == -7):
return -7
html_parser = HTMLparser.HTMLparser(url=None, html=None)
html_parser.results = article_objects_list
html_parser.numOfResults = len(article_objects_list)
return html_parser
def set_text(self, text):
if type(text) in StringTypes:
self.text = text
else:
raise TypeError, type(text)
if not self.label:
self.label = Label(h_align = Align.CENTER, v_align = Align.CENTER,
text_prop = { 'align_h': 'center',
'align_v': 'center',
'mode' : 'hard',
'hfill': False } )
self.label.set_text(text)
self.add_child(self.label)
else:
self.label.set_text(text)
def post(self):
t = get_template('search.html')
c = Context()
user = users.get_current_user()
search_term = self.request.get('SearchTerm')
label_name = self.request.get('hidden_label_name')
htmlParser = Label.search_in_labels_return_HTMLparser(user, label_name, search_term)
results = htmlParser.results
if len(results) == 0:
self.response.out.write("No results found")
return
my_html_parser_encoder = JSONConvertors.HTMLparserEncoder()
resultsJSON = my_html_parser_encoder.encode(htmlParser)
c['users'] = users
c['results'] = results
c['resultsJSON'] = resultsJSON
c['formAction'] = '/AddFollow'
c['showlabel'] = True
c['showlabelsearch'] = False
self.response.out.write(t.render(c))
def acceptPendingSharedLabel(invited_user, pending_id):
try:
query = db.GqlQuery("SELECT * FROM PendingSharedLabel WHERE invited_user = :1 "+
"AND Id = :2 ",
invited_user, pending_id)
except Exception:
return -7
num_results = query.count(10)
if (num_results == 0):
return -4
for pending_obj in query:
num = Label.execute_label_sharing_after_approved(pending_obj.inviting_user,pending_obj.label_name,pending_obj.invited_user)
if (num < 0):
return num
try:
pending_obj.delete()
except Exception:
return -7
return num # return number of articles added on this label
def post(self):
label_name = self.request.get('label_name')
user = users.get_current_user()
res = Label.get_emails_of_users_on_this_shared_label(user, label_name)
self.response.out.write(res)
class Button(Container):
"""
left x coordinate. Integer
top y coordinate. Integer
width Integer
height Integer
text The label on the button. String
handler Function to call when button is hit
bg_color Background color (Color)
fg_color Foreground color (Color)
selected_bg_color Background color (Color)
selected_fg_color Foreground color (Color)
border Border
bd_color Border color (Color)
bd_width Border width Integer
"""
def __init__(self, text=' ', handler=None, left=None, top=None,
width=70, height=None, bg_color=None, fg_color=None,
selected_bg_color=None, selected_fg_color=None,
border=-1, bd_color=None, bd_width=None):
default_button_height = 25
if not height:
height = default_button_height
Container.__init__(self, 'widget', left, top, width, height, bg_color,
fg_color, selected_bg_color, selected_fg_color,
border, bd_color, bd_width)
self.h_margin = 2
self.v_margin = 2
self.handler = handler
if text and type(text) in StringTypes:
self.set_text(text)
else:
self.set_text('')
button_normal = self.content_layout.types['button']
font_percent = button_normal.font.size * 100 / default_button_height
self.info_normal = button_normal, int(font_percent * self.height / 120)
button_selected = self.content_layout.types['button selected']
font_percent = button_selected.font.size * 100 / default_button_height
self.info_selected = button_selected, int(font_percent * self.height / 120)
self.fg_color = fg_color or Color(button_normal.rectangle.color)
self.bg_color = bg_color or Color(button_normal.rectangle.bgcolor)
self.selected_fg_color = selected_fg_color or Color(button_selected.rectangle.color)
self.selected_bg_color = selected_bg_color or Color(button_selected.rectangle.bgcolor)
# now check the height, maybe the font is too large
self.height = max(self.height, button_normal.height + 2 * self.v_margin,
button_selected.font.height + 2 * self.v_margin)
# the label to not selected font
self.__set_font__()
self.set_v_align(Align.BOTTOM)
self.set_h_align(Align.CENTER)
def __set_font__(self):
if self.selected:
i = self.info_selected
else:
i = self.info_normal
self.label.set_font(i[0].font.name, i[1], Color(i[0].font.color))
def toggle_selected(self):
self.selected = not self.selected
self.__set_font__()
def _draw(self):
if not self.width or not self.height or not self.text:
raise TypeError, 'Not all needed variables set.'
if self.selected:
rect = self.content_layout.types['button selected'].rectangle
else:
rect = self.content_layout.types['button'].rectangle
self.surface = self.get_surface()
if not self.border:
self.osd.drawroundbox(0, 0, self.width, self.height,
rect.bgcolor, rect.size, rect.color,
rect.radius, self.surface)
else:
self.osd.drawroundbox(0, 0, self.width, self.height,
rect.bgcolor, 0, rect.color,
0, self.surface)
Container._draw(self)
def get_text(self):
return self.text
def set_text(self, text):
if type(text) in StringTypes:
self.text = text
else:
raise TypeError, type(text)
if not self.label:
self.label = Label(h_align = Align.CENTER, v_align = Align.CENTER,
text_prop = { 'align_h': 'center',
'align_v': 'center',
'mode' : 'hard',
'hfill': False } )
self.label.set_text(text)
self.add_child(self.label)
else:
self.label.set_text(text)
def post(self):
user = users.get_current_user()
res = Label.add_label_JSON_INPUT(user,self.request.body)
self.response.out.write(simplejson.dumps(res))
def post(self):
inviting_user = users.get_current_user()
label_name = self.request.get('label_name')
new_user_email = self.request.get('user_name')
res = Label.get_label_by_email(inviting_user , new_user_email, label_name)
self.response.out.write(simplejson.dumps(res))
import Label as lbx W = 180 H = 50 X = 19 Y = 49 GapX = 15 GapY = 2 NumPerRow = 3 print cur_page_data for i in range(len(cur_page_data)): item = cur_page_data[i] rowIdx, colIdx = divmod(i, NumPerRow) x = X + colIdx * (W + GapX) y = Y + rowIdx * (H + GapY) print x, y lbx.fill_rect( (x, y, W, H), 0xf9d8a8 ) lbx.draw_text( unicode(item['Item Name']), 12, (x + 10, y + 10, 0, 0), family=u"Verdana")
def post(self):
user = users.get_current_user()
label_name = self.request.get('label_name')
article_key = self.request.get('article_key')
res = Label.remove_label_from_article(user, label_name, article_key)
self.response.out.write(simplejson.dumps(res))
def post(self):
label_name = self.request.get('label_name')
user = users.get_current_user()
res = Label.remove_user_from_shared_label(user, label_name)
self.response.out.write(simplejson.dumps(res))
def post(self):
label_name = self.request.get('label_name')
user = users.get_current_user()
res = Label.duplicate_label_to_private(user, label_name)
self.response.out.write(res)
