def __init__(self, **kwargs):
super().__init__()
self.from_lang = DropDown(bar_width=10,
scroll_type=['bars', 'content'],
effect_cls='ScrollEffect',
smooth_scroll_end=10)
self.from_lang.bar_inactive_color = self.from_lang.bar_color
for lang in list(self.langs.keys()):
btn = DropDownButton(text=lang.title(), size_hint_y=None)
btn.bind(on_release=lambda btn: self.from_lang.select(btn.text))
self.from_lang.add_widget(btn)
self.mainbutton_from_lang = DropDownButton(text='Detect Language ↓',
size_hint=(0.9, 0.8))
self.mainbutton_from_lang.bind(on_release=self.from_lang.open)
self.from_lang.bind(on_select=lambda instance, x: self.lang_changed(
self.mainbutton_from_lang, x, 'input'))
self.ids.from_lang.add_widget(self.mainbutton_from_lang)
self.to_lang = DropDown(bar_width=10,
scroll_type=['bars', 'content'],
effect_cls='ScrollEffect',
smooth_scroll_end=10)
self.to_lang.bar_inactive_color = self.to_lang.bar_color
for lang in list(self.langs.keys())[1:]:
btn = DropDownButton(text=lang.title(), size_hint_y=None)
btn.bind(on_release=lambda btn: self.to_lang.select(btn.text))
self.to_lang.add_widget(btn)
self.mainbutton_to_lang = DropDownButton(text='English ↓',
size_hint=(0.9, 0.8))
self.mainbutton_to_lang.bind(on_release=self.to_lang.open)
self.to_lang.bind(on_select=lambda instance, x: self.lang_changed(
self.mainbutton_to_lang, x, 'output'))
self.ids.to_lang.add_widget(self.mainbutton_to_lang)
def __init__(self, **kwargs):
super(Toolbar, self).__init__(**kwargs)
self.user = None
self.color_drop = DropDown(size_hint=(None, None), size=(100, 30))
for col in ('red', 'blue', 'golden', 'green', 'rainbow', 'purple', 'normal'):
btn = Button(text=col, size_hint=(None, None), size=(100, 30))
btn.bind(on_release=lambda btn_: self.color_drop.select(btn_.text))
self.color_drop.add_widget(btn)
self.text_col_btn = Button(text='color', size_hint=(None, None), size=(100, 30))
self.text_col_btn.bind(on_release=self.color_drop.open)
self.add_widget(self.text_col_btn)
self.color_drop.bind(on_select=self.on_col_select)
self.item_drop = DropDown(size_hint=(None, None), size=(200, 30))
self.text_item_btn = Button(text='no item', size_hint=(None, None), size=(200, 30))
self.text_item_btn.bind(on_release=self.build_item_drop)
self.text_item_btn.bind(on_release=self.item_drop.open)
self.add_widget(self.text_item_btn)
self.item_drop.bind(on_select=self.on_item_select)
self.sfx_main_btn = Button(text='SFX')
self.sfx_dropdown = None
self.sfx_name = None
self.sfx_list = []
self.load_sfx()
self.add_widget(self.sfx_main_btn)
def __init__(self, **kwargs):
super(Buttons, self).__init__(**kwargs)
self.label = Label(text='Currency rates',
font_size='20sp',
color=[105, 106, 188, 1])
self.add_widget(self.label)
self._from = 'CHF'
self._to = 'RUB'
self.years = 1
self.dropdownFrom = DropDown()
self.dropdownTo = DropDown()
self.buttonFrom = self.createButton("From", self.dropdownFrom, True)
self.buttonTo = self.createButton("To", self.dropdownTo, False)
self.add_widget(self.buttonFrom)
self.add_widget(self.buttonTo)
self.yearsDropdown = DropDown()
self.years = self.createYearsButton("Years", self.yearsDropdown)
self.add_widget(self.years)
btn = Button(text='Show',
size_hint_y=None,
size_hint_x=None,
height=60)
btn.bind(on_release=lambda btn: self.on_release(btn),
on_press=lambda btn: self.on_press(btn))
self.add_widget(btn)
def load_data(self, event):
try:
self.data.head()
except Exception:
return 0
print(self.data.head()) # Testing
cols = self.data.columns
self.x_cols = []
if self.x_dropdown:
self.x_btn.unbind(on_release=self.x_dropdown.open)
del self.x_dropdown
self.x_dropdown = DropDown(dismiss_on_select=False)
for col in cols:
btn = ToggleButton(text=col, size_hint_y=None, height=44)
btn.bind(on_release=lambda btn: self.x_dropdown.select(btn.text))
self.x_dropdown.add_widget(btn)
self.x_btn.bind(on_release=self.x_dropdown.open)
self.x_dropdown.bind(on_select=self.select_xcol)
self.y_cols = []
if self.y_dropdown:
self.y_btn.unbind(on_release=self.y_dropdown.open)
del self.y_dropdown
self.y_dropdown = DropDown(dismiss_on_select=False)
for col in cols:
btn = ToggleButton(text=col, size_hint_y=None, height=44)
btn.bind(on_release=lambda btn: self.y_dropdown.select(btn.text))
self.y_dropdown.add_widget(btn)
self.y_btn.bind(on_release=self.y_dropdown.open)
self.y_dropdown.bind(on_select=self.select_ycol)
def __init__(self, **kwargs):
super(templateScreen, self).__init__(**kwargs)
self.monitor_button_dict = dict()
# display space
self.layout_line = GridLayout(cols=3,
spacing=20,
padding=20,
size_hint_y=None)
self.layout_line.bind(minimum_height=self.layout_line.setter('height'))
self.scroll = ScrollView(size_hint=(1, 1.5))
self.scroll.add_widget(self.layout_line)
self.work_space = BoxLayout(orientation='vertical')
self.work_space.add_widget(self.scroll)
# button menu
self.button_menu = BoxLayout(orientation='horizontal',
size_hint_y=.2,
spacing=10,
padding=10)
# drop down list for monitor type set up
self.dropdown_monitor_type = DropDown()
self.mainbutton_monitor_type = Button(text='Monitor type')
self.mainbutton_monitor_type.bind(
on_release=self.dropdown_monitor_type.open)
self.dropdown_monitor_type.bind(on_select=lambda instance, x: setattr(
self.mainbutton_monitor_type, 'text', x))
# drop down list for location selection set up
self.dropdown = DropDown()
self.mainbutton = Button(text="location list insert")
self.mainbutton.bind(on_release=self.dropdown.open)
self.dropdown.bind(
on_select=lambda instance, x: setattr(self.mainbutton, 'text', x))
# add button
self.add_btn = Button(text="Add", background_color=(0, 0, 255, 1))
self.add_btn.bind(on_press=self.add_location)
# navigating button
self.navigate_btn = Button(text="Switch to [destination]",
background_color=(0, 0, 1, 255))
self.navigate_btn.bind(on_press=self.navigation)
# push all buttons into button menu
self.button_menu.add_widget(self.add_btn)
self.button_menu.add_widget(self.mainbutton_monitor_type)
self.button_menu.add_widget(self.mainbutton)
self.button_menu.add_widget(self.navigate_btn)
# add button menu into work space layout
self.work_space.add_widget(self.button_menu)
# add work space layout to the screen
self.add_widget(self.work_space)
def __init__(self, **kwargs):
super(Menu, self).__init__(**kwargs)
self.ids.player1select.text = 'Select Player 1'
self.ids.player2select.text = 'Select Player 2'
self.dropdown1 = DropDown()
self.dropdown2 = DropDown()
self._get_players()
self._create_dropdowns(self.ids.player1select, self.dropdown1)
self._create_dropdowns(self.ids.player2select, self.dropdown2)
def new_leads_form(self, instance):
self.rep_name = self.name_input.text
#add industry dropdown
self.add_widget(Label(text='Select Industries'))
self.industry_dropdown = DropDown()
for i in self.industries:
btn = Button(text='%s' % i, size_hint_y=None, height=44)
btn.bind(on_release=lambda btn: self.industry_dropdown.select(btn.text)) #may not need - may only retain one value
btn.bind(on_release=lambda btn: self.industries_chosen.append(btn.text)) # self.industries_chosen.append(btn.text))
self.industry_dropdown.add_widget(btn)
self.add_widget(self.industry_dropdown)
self.ind_button = Button(text='Industries...')
self.ind_button.bind(on_release=self.industry_dropdown.open)
self.add_widget(self.ind_button)
#add postal dropdown
self.add_widget(Label(text='For which Postal Codes'))
self.postal_dropdown = DropDown()
for i in self.get_whose_postal(self.rep_name)[2]:
bttn = Button(text='%s' % i, size_hint_y=None, height=44)
bttn.bind(on_release=lambda bttn: self.postal_dropdown.select(bttn.text)) #may not need - may only retain one value
bttn.bind(on_release=lambda bttn: self.postals_chosen.append(bttn.text))
self.postal_dropdown.add_widget(bttn)
self.add_widget(self.postal_dropdown)
self.postal_button = Button(text='Your Postal Codes...')
self.postal_button.bind(on_release=self.postal_dropdown.open)
self.add_widget(self.postal_button)
self.add_widget(Label(text='Check this box once you have confirmed that in your documents folder there is a folder called "Lead_GEN" with your Siebel, Xpert and Hubview accounts as well as Major Reps Accounts all as individual .csv files'))
self.confirm_dir_struct = CheckBox()
self.confirm_dir_struct.bind(active=self.validate_dir)
#linkedin
self.add_widget(Label(text='Include Linkedin Search?'))
self.linkedin_opt = CheckBox()
self.linkedin_opt.bind(active=self.get_linkedin_info)
self.add_widget(self.linkedin_opt)
self.add_widget(Label(text='Due to LinkedIn policies, this will use up all available searches for the day. \n You will also need to return at a later date to this app if you plan on getting more than 100 leads today \n (again due to LinkedIn policies...lame I know)'))
self.add_widget(Label(text='Do not click the above box if this is not ok'))
self.submit_button = Button(text='Submit')
self.submit_button.bind(on_release=self.submit_newleads)
def build(self):
rl = RelativeLayout(size=(300, 300))
currencies = ["Dollar", "Euro", "Robux", "Dong"]
results = Label(text="Results", pos=(352, 135), size_hint=(.2, .1))
#self.hide_widget(results)
b5 = Button(text="Convert", pos=(352, 235), size_hint=(.2, .1))
b2 = DropDown()
for i in currencies:
btn = Button(text=i, size_hint_y=None, height=44)
btn.bind(on_release=lambda btn: b2.select(btn.text))
b2.add_widget(btn)
# create a big main button
mainbutton = Button(text='Currency 1',
size_hint=(.2, .2),
pos_hint={
'center_x': .27,
'center_y': .6
})
mainbutton.bind(on_release=b2.open)
b2.bind(on_select=lambda instance, x: setattr(mainbutton, 'text', x))
b3 = DropDown()
for z in currencies:
btn1 = Button(text=z, size_hint_y=None, height=44)
btn1.bind(on_release=lambda btn1: b3.select(btn1.text))
b3.add_widget(btn1)
# create a big main button
mainbutton2 = Button(text='Currency 2',
size_hint=(.2, .2),
pos_hint={
'center_x': .81,
'center_y': .6
})
mainbutton2.bind(on_release=b3.open)
b3.bind(on_select=lambda instance, x: setattr(mainbutton2, 'text', x))
b4 = TextInput(size_hint=(.2, .1),
pos=(352, 335),
text="Enter Value",
multiline=False)
def callback(instance):
value = float(b4.text) * 2.5
results.text = str(value)
b5.bind(on_press=callback)
rl.add_widget(mainbutton)
rl.add_widget(mainbutton2)
rl.add_widget(b4)
rl.add_widget(results)
rl.add_widget(b5)
return rl
def __init__(self, *args, **kwargs):
super(ClassSummary, self).__init__(*args, **kwargs)
# The first item in this panel should be a dropdown containing
# all of the contours in the current image.
self.contour_select_dropdown = DropDown()
self.contour_select_dropdown.auto_dismiss = False
self.editor_box = CustomBoxLayout(orientation='vertical',
padding=[8, 8, 8, 8],
spacing=5)
self.class_select_dropdown = DropDown()
self.class_select_dropdown.auto_dismiss = False
self.class_select_button = Button(text='Select Class',
size_hint_y=None,
height=30)
self.class_select_button.bind(on_press=self._class_select_pressed)
self.name_input = TextInput(text='Item Name',
multiline=False,
size_hint_y=None,
height=30)
self.comment_input = TextInput(text='Comments',
multiline=True,
size_hint_y=None,
height=120)
self.name_input.bind(text=self._name_text_changed)
self.comment_input.bind(text=self._comment_text_changed)
self.editor_box.add_widget(self.class_select_button)
self.editor_box.add_widget(self.name_input)
self.editor_box.add_widget(self.comment_input)
self.dropdown_activator = DropDownContourItem(
class_color=hex_color('#000000'), index=-1, class_name='none')
self.dropdown_activator.bind(on_press=self._activator_pressed)
self.add_widget(self.dropdown_activator)
self.add_widget(self.editor_box)
self.dropdown_open = False
self.current_entry = None
self.dataset = None
self.contours = []
self.contour_dropdown_items = []
self.current_contour = None
self.class_names = []
self.class_buttons = []
def __init__(self, *args, **kwargs):
super(OneDayParameterWindow, self).__init__(*args, **kwargs)
self.drop_down = CustomDropDown()
self.temperatures = [
0, -999, -999, -999, -999
] # stores the values user inputs in each temperature box, used for value comparison
# create drop down menu of select cities
dropdown = DropDown()
events = ["Light Rain", "Moderate Rain", "Heavy Rain", "Thunderstorm", "Wintry Mix", "Sleet", "Freezing Rain", "Flurries", "Snow Showers", \
"Snow", "Heavy Snow"]
for event in events:
# create button individually for each city
btn = Button(text='%r' % event,
size_hint_y=None,
height=30,
pos=(25, 25),
on_release=lambda btn: sv.eventSave(btn.text))
btn.bind(
on_release=lambda btn: dropdown.select(btn.text)
) # attach a callback which will pass the text selected as data
dropdown.add_widget(btn)
# create the main or default button
mainbutton = Button(text='Event Type', size_hint=(0.5, 0.5))
mainbutton.bind(
on_release=dropdown.open) # show drop down menu when released
dropdown.bind(on_select=lambda instance, x: setattr(
mainbutton, 'text', x)) # assign data to button text
self.dropDownList.add_widget(mainbutton)
## For second drop down menu, for units measuring precipitation amounts
dropdownTwo = DropDown()
units = ["in", "ft", "mm", "cm"]
for unit in units:
# create button individually for each unit
btnTwo = Button(text='%r' % unit,
size_hint_y=None,
height=30,
pos=(25, 25),
on_release=lambda btn: sv.unitSave(btnTwo.text))
btnTwo.bind(
on_release=lambda btnTwo: dropdownTwo.select(btnTwo.text)
) # attach a callback which will pass the text selected as data
dropdownTwo.add_widget(btnTwo)
# create the main or default button
mainbuttonTwo = Button(text='Units', size_hint=(0.5, 0.5))
mainbuttonTwo.bind(on_release=dropdownTwo.open)
dropdownTwo.bind(on_select=lambda instance, x: setattr(
mainbuttonTwo, 'text', x)) # assign data to button text
self.dropDownListTwo.add_widget(mainbuttonTwo)
def build(self):
"""Parent widget"""
parent = FloatLayout(size=Window.size)
self.painter = PainterWidget()
parent.add_widget(self.painter)
"""Clear Button"""
parent.add_widget(
Button(text='Clear', size_hint=(.07, .07), pos_hint={'x': .0, 'y': .93}, on_press=self.painter.clear))
drpName = []
drpName2 = []
"""Color drop down"""
for i in range(10):
drpName.append(DropDown())
btnName = Button(text="Colors", size_hint=(.07, .07), pos_hint={'x': .07, 'y': .93}, )
btn1 = Button(text="Blue", size_hint_y=None, height=btnName.height, on_release=self.painter.blue)
btn2 = Button(text="Red", size_hint_y=None, height=btnName.height, on_release=self.painter.red)
btn3 = Button(text="Green", size_hint_y=None, height=btnName.height, on_release=self.painter.green)
btn4 = Button(text="Yellow", size_hint_y=None, height=btnName.height, on_release=self.painter.yellow)
btn5 = Button(text="Purple", size_hint_y=None, height=btnName.height, on_release=self.painter.purple)
btn6 = Button(text="Black", size_hint_y=None, height=btnName.height, on_release=self.painter.black)
drpName[i].add_widget(btn1)
drpName[i].add_widget(btn2)
drpName[i].add_widget(btn3)
drpName[i].add_widget(btn4)
drpName[i].add_widget(btn5)
drpName[i].add_widget(btn6)
btnName.bind(on_release=drpName[i].open)
parent.add_widget(btnName)
"""Size drop down"""
for i in range(10):
drpName2.append(DropDown())
btnName2 = Button(text="Size", size_hint=(.07, .07), pos_hint={'x': .14, 'y': .93}, )
size1 = Button(text="1", size_hint_y=None, height=btnName2.height, on_release=self.painter.line_size1)
size2 = Button(text="2", size_hint_y=None, height=btnName2.height, on_release=self.painter.line_size2)
size3 = Button(text="3", size_hint_y=None, height=btnName2.height, on_release=self.painter.line_size3)
size4 = Button(text="4", size_hint_y=None, height=btnName2.height, on_release=self.painter.line_size4)
drpName2[i].add_widget(size1)
drpName2[i].add_widget(size2)
drpName2[i].add_widget(size3)
drpName2[i].add_widget(size4)
btnName2.bind(on_release=drpName2[i].open)
parent.add_widget(btnName2)
"""Save widget"""
parent.add_widget(
Button(text='Save', size_hint=(.07, .07), pos_hint={'x': .93, 'y': .93}, on_press=self.painter.popupsave))
return parent
def alarmPopup(self, *args):
# content of the popup to be sorted in this float layout
box = FloatLayout()
# hour selector
hourbutton = Button(text='Select Hour', size_hint=(.2, .2),
pos_hint={'x': .2, 'y': .5})
# dropdown menu which drops down from the hourbutton
hourdropdown = DropDown()
for i in range(24):
if i < 10:
btn = Button(text='0%r' % i, size_hint_y=None, height=70)
else:
btn = Button(text='%r' % i, size_hint_y=None, height=70)
btn.bind(on_release=lambda btn: hourdropdown.select(btn.text))
hourdropdown.add_widget(btn)
hourbutton.bind(on_release=hourdropdown.open)
hourdropdown.bind(on_select=lambda instance, x: setattr(hourbutton, 'text', x))
# add widgets to the popup's float layout
box.add_widget(hourbutton)
box.add_widget(hourdropdown)
# minute selector
minutebutton = Button(text='Select Minute', size_hint=(.2, .2),
pos_hint={'x': .6, 'y': .5})
# dopdown menu which drops down from the minutebutton
minutedropdown = DropDown()
for i in range(60):
if i < 10:
btn = Button(text='0%r' % i, size_hint_y=None, height=70)
else:
btn = Button(text='%r' % i, size_hint_y=None, height=70)
btn.bind(on_release=lambda btn: minutedropdown.select(btn.text))
minutedropdown.add_widget(btn)
minutebutton.bind(on_release=minutedropdown.open)
minutedropdown.bind(on_select=lambda instance, x: setattr(minutebutton, 'text', x))
# add widgets to the popup's float layout
box.add_widget(minutebutton)
box.add_widget(minutedropdown)
# button to dismiss alarm selector and set alarm once user has chosen alarm
dismissButton = PopupDismissButton()
box.add_widget(dismissButton)
currentDay = time.strftime("%A")
alarmPopup = Popup(title='Set Your Alarm for {}:'.format(currentDay), content=box, size_hint=(.8, .8))
dismissButton.bind(on_press=partial(dismissButton.dismissPopup, alarmPopup, hourbutton, minutebutton))
alarmPopup.open()
def build(self):
self.iller = DropDown()
self.iller.secim=None
isaretci.execute('SELECT il_id, il_ad FROM tbl_il')
for il in isaretci.fetchall():
dugme=Button(text=il[1].encode("utf-8"), size_hint_y=None, height=25)
dugme.il_id=il[0]
dugme.bind(on_release=self.secimIl)
self.iller.add_widget(dugme)
self.ilceler = DropDown()
self.ilceler.secim=None
self.semtler = DropDown()
self.semtler.secim=None
def __init__(self, **kwargs):
super(InitOptions, self).__init__(**kwargs)
self.cols = 3
self.rows = 2
self.add_widget(Label(text='Number of frets'))
self.add_widget(Label(text='Tuning'))
self.add_widget(Label(text='Orientation'))
self.fretDropDown = DropDown()
for scaleLength in SCALELENGTHTABLE:
btn = Button(text=scaleLength)
btn.size_hint_y = None
btn.height = 44
btn.bind(on_release=lambda btn: self.fretDropDown.select(btn.text))
self.fretDropDown.add_widget(btn)
self.frets = Button(text='24')
self.frets.bind(on_release=self.fretDropDown.open)
self.fretDropDown.bind(
on_select=lambda instance, x: setattr(self.frets, 'text', x))
self.tuningDropDown = DropDown()
for tuning in TUNINGTABLE:
btn = Button(text=tuning[0])
btn.size_hint_y = None
btn.height = 44
btn.bind(
on_release=lambda btn: self.tuningDropDown.select(btn.text))
self.tuningDropDown.add_widget(btn)
self.tunings = Button(text='Standard')
self.tunings.bind(on_release=self.tuningDropDown.open)
self.tuningDropDown.bind(
on_select=lambda instance, x: setattr(self.tunings, 'text', x))
self.orientationDropDown = DropDown()
for orientation in ORIENTATIONTABLE:
btn = Button(text=orientation)
btn.size_hint_y = None
btn.height = 44
btn.bind(on_release=lambda btn: self.orientationDropDown.select(
btn.text))
self.orientationDropDown.add_widget(btn)
self.orientations = Button(text='LEFT HANDED')
self.orientations.bind(on_release=self.orientationDropDown.open)
self.orientationDropDown.bind(on_select=lambda instance, x: setattr(
self.orientations, 'text', x))
self.add_widget(self.frets)
self.add_widget(self.tunings)
self.add_widget(self.orientations)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.rows = 2
self.middle_division_up = GridLayout(cols=2, size_hint_y=0.2)
self.add_widget(self.middle_division_up)
self.middle_division_down = GridLayout(cols=7)
self.add_widget(self.middle_division_down)
month_scroll = DropDown()
month_names = [
"January", "February", "March", "April", "May", "June", "July",
"August", "September", "October", "November", "December"
]
for index, month_name in enumerate(month_names):
month_scroll.add_widget(
ToggleButton(text=month_name,
on_press=self.month_pressed,
size_hint_y=None,
id=str(index + 1),
group="months"))
self.middle_division_up.add_widget(
Button(on_release=lambda x: month_scroll.open(x),
text="Month",
font_size=17,
size_hint_y=0.3,
background_color=[0.4, 0.7, 1, 1]))
scroll_layout = GridLayout(cols=1)
year_scroll = DropDown()
current_year = datetime.today().year
amount_of_year_buttons = 100
for i in range(amount_of_year_buttons):
year_scroll.add_widget(
ToggleButton(text=str(current_year + i),
size_hint_y=None,
on_press=self.year_pressed,
group="years"))
# ^^przyciski z wypisanymi latami
scroll_layout.add_widget(
Button(on_release=lambda x: year_scroll.open(x),
text="Year",
font_size=17,
background_color=[0.4, 0.7, 1, 1]))
# ^^przycisk scroll drop
self.middle_division_up.add_widget(scroll_layout)
def draw_layout(self):
self.button_x = .5
if manager.CURRENT_GROUP != None:
self.button_x = .3
self.dropdown = DropDown(auto_width=False, width=180, max_height=180)
self.dropdown.main_button = HoverButton(text="Select User",
size=(180,40),
size_hint=(None,None),
pos_hint={"center_x":.5, 'top':.8},
button_down=DD_DCHRC[1],
button_up=DD_DCHRC[0],
on_release=self.dropdown.open)
self.layout.add_widget(self.dropdown.main_button)
self.remove_user_dropdown()
self.layout.add_widget(HoverButton(text="Remove",
button_down=BTN_DCHRC[1],
button_up=BTN_DCHRC[0],
font_size=14,
size_hint=(None,None),
size=(100,40),
pos_hint={"center_x":.7, 'top':.35},
on_press=self.remove_from_group))
else:
self.layout.add_widget(Label(text="No Group Selected",
font_size=14,
pos_hint={"center_x":.5, 'top':1.2}))
self.layout.add_widget(HoverButton(text="Cancel",
button_down=BTN_DCHRC[1],
button_up=BTN_DCHRC[0],
font_size=14,
size_hint=(None,None),
size=(100,40),
pos_hint={"center_x":self.button_x, 'top':.35},
on_press=self.dismiss))
def update_action_button(self):
action_button = self.ids.action_button
options = (
ActionButtonOption(text=_('Sign'), func=lambda btn: self.do_sign(), enabled=self.can_sign),
ActionButtonOption(text=_('Broadcast'), func=lambda btn: self.do_broadcast(), enabled=self.can_broadcast),
ActionButtonOption(text=_('Bump fee'), func=lambda btn: self.do_rbf(), enabled=self.can_rbf),
ActionButtonOption(text=_('Cancel (double-spend)'), func=lambda btn: self.do_dscancel(), enabled=self.can_dscancel),
ActionButtonOption(text=_('Remove'), func=lambda btn: self.remove_local_tx(), enabled=self.can_remove_tx),
)
num_options = sum(map(lambda o: bool(o.enabled), options))
# if no options available, hide button
if num_options == 0:
action_button.disabled = True
action_button.opacity = 0
return
action_button.disabled = False
action_button.opacity = 1
if num_options == 1:
# only one option, button will correspond to that
for option in options:
if option.enabled:
action_button.text = option.text
self._action_button_fn = option.func
else:
# multiple options. button opens dropdown which has one sub-button for each
dropdown = DropDown()
action_button.text = _('Options')
self._action_button_fn = dropdown.open
for option in options:
if option.enabled:
btn = Button(text=option.text, size_hint_y=None, height='48dp')
btn.bind(on_release=option.func)
dropdown.add_widget(btn)
def __init__(self,**kwargs):
super(Shown_Mama, self).__init__(**kwargs)
Window.bind(on_resize=self.window_size_changed)
self.chveneba_klasi = Shown_Scroll()
self.pirovneba_klasi = Pirovneba_box1()
self.add_widget(self.chveneba_klasi)
self.add_widget(self.pirovneba_klasi)
self.dropdown = DropDown() # Create the dropdown once and keep a reference to it
self.dropdown.bind(on_select=lambda instance, x: setattr(self.button, 'text', x))
self.button = Button(text='იუნკერთა სია', font_size=20, size_hint=(.15,.10),font_name="bpg_arial_2009",
pos_hint= {'x':.0,'y':.80},background_color = get_color_from_hex("#ff680a"),on_release=self.refresh_dopdown)
self.add_widget(self.button)
self.items_klasi = Shown_Box()
self.chveneba_klasi.add_widget(self.items_klasi)
self.sataurebi_lay = sataurebi_layout()
self.add_widget(self.sataurebi_lay)
self.refres_btn = Button(text = "ძებნა",font_name="bpg_arial_2009", font_size=20)
self.refres_btn.bind(on_release = self.refresh)
self.pirovneba_klasi.add_widget(self.refres_btn)
self.delete_btn = Button(text = "წაშლა",font_name="bpg_arial_2009", font_size=20)
self.delete_btn.bind(on_release = self.delete_junker)
self.pirovneba_klasi.add_widget(self.delete_btn)
def create_sfx_dropdown(self):
self.sfx_dropdown = DropDown()
fav_sfx = App.get_running_app().get_fav_sfx()
btn = Button(text="None", size_hint_y=None, height=40)
btn.bind(on_release=lambda x: self.sfx_dropdown.select(x.text))
self.sfx_dropdown.add_widget(btn)
for sfx in fav_sfx.value:
if sfx in self.sfx_list:
btn = Button(text=sfx, size_hint_y=None, height=40,
background_normal='atlas://data/images/defaulttheme/button_pressed',
background_down='atlas://data/images/defaulttheme/button')
btn.bind(on_release=lambda x: self.sfx_dropdown.select(x.text))
self.sfx_dropdown.add_widget(btn)
for sfx in self.sfx_list:
if sfx not in fav_sfx.value:
btn = Button(text=sfx, size_hint_y=None, height=40)
btn.bind(on_release=lambda x: self.sfx_dropdown.select(x.text))
self.sfx_dropdown.add_widget(btn)
btn = Button(text="None", size_hint_y=None, height=40)
btn.bind(on_release=lambda x: self.sfx_dropdown.select(x.text))
self.sfx_main_btn.bind(on_release=self.sfx_dropdown.open)
self.sfx_dropdown.add_widget(btn)
self.sfx_dropdown.bind(on_select=lambda instance, x: setattr(self.sfx_main_btn, 'text', x))
self.sfx_dropdown.bind(on_select=lambda instance, x: setattr(self, 'sfx_name', x))
self.sfx_dropdown.bind(on_dismiss=self.refocus_screen)
def build(self, *args):
if None in (self.key, self.sett):
Clock.schedule_once(self.build, 0)
return
self.mainbutton = None
self.dropdown = None
self.dropdown = DropDown()
self.dropdown.bind(
on_select=lambda instance, x: self.sett(self.key, x))
readoutbut = Button(text='Readout',
size_hint_y=None,
height=self.height)
readoutbut.bind(
on_press=lambda instance: self.dropdown.select('readout'))
self.dropdown.add_widget(readoutbut)
textinbut = Button(text='Text input',
size_hint_y=None,
height=self.height)
textinbut.bind(
on_press=lambda instance: self.dropdown.select('textinput'))
self.dropdown.add_widget(textinbut)
togbut = Button(text='Toggle button',
size_hint_y=None,
height=self.height)
togbut.bind(
on_press=lambda instance: self.dropdown.select('togglebutton'))
self.dropdown.add_widget(togbut)
sliderbut = Button(text='Slider', size_hint_y=None, height=self.height)
sliderbut.bind(
on_press=lambda instance: self.dropdown.select('slider'))
self.dropdown.add_widget(sliderbut)
self.bind(on_press=self.dropdown.open)
def switch_screen(self, button, *args):
response_list = show().json()['data']
self.list_dropdown = DropDown(size_hint=(1, 1))
for item in response_list:
self.list_dropdown.add_widget(ProductView(dict(name=item[0],
price=item[1],
provider=item[2]),
size_hint_y=None,
height=144,
pos_hint={'center_x':
0.5},
color=(0, 0, 0, 1),
background_color=(255,
255,
255,
255)))
buy_button = Button(text="Home",
size_hint_y=None,
height=144,
pos_hint={'center_x': 0.5},
color=(0, 0, 0, 1),
background_color=(255, 255, 255, 255))
buy_button.bind(on_press=self.return_home)
self.list_dropdown.add_widget(buy_button)
self.current = "list"
try:
self.list_screen.add_widget(self.list_dropdown)
except Exception:
pass
self.dropdown.dismiss()
def DropDown(self):
dropdown = DropDown()
for index in self.players:
# When adding widgets, we need to specify the height manually
# (disabling the size_hint_y) so the dropdown can calculate
# the area it needs.
btn = Button(text='%s' % index,
font_size=40,
size_hint_y=None,
height=60)
# for each button, attach a callback that will call the select() method
# on the dropdown. We'll pass the text of the button as the data of the
# selection.
btn.bind(on_release=lambda btn: dropdown.select(btn.text))
# then add the button inside the dropdown
dropdown.add_widget(btn)
# create a big main button
#mainbutton = Button(text='Hello', size_hint_y= None, height=44)
# show the dropdown menu when the main button is released
# note: all the bind() calls pass the instance of the caller (here, the
# mainbutton instance) as the first argument of the callback (here,
# dropdown.open.).
#self.ids.addplayerbtn.bind(on_release=dropdown.open)
dropdown.open(self.ids.splayerbtn)
# one last thing, listen for the selection in the dropdown list and
# assign the data to the button text.
dropdown.bind(on_select=lambda instance, x: setattr(
self.ids.splayerbtn, 'text', x))
#print(mainbutton.text)
#runTouchApp(mainbutton)
self.ids.checkoutbtn.disabled = False
self.ids.checkinbtn.disabled = False
def __init__(self, enum_class, **kwargs):
super(EnumDropDown, self).__init__(**kwargs)
self.dropdown = DropDown()
self.mainbutton = Button(text='Hello', size_hint=(None, None))
self.mainbutton.bind(on_release=self.dropdown.open)
for data in enum_class:
# When adding widgets, we need to specify the height manually
# (disabling the size_hint_y) so the dropdown can calculate
# the area it needs.
btn = Button(text=f'Value {data.name!s}',
size_hint_y=None,
height=44)
# for each button, attach a callback that will call the select() method
# on the dropdown. We'll pass the text of the button as the data of the
# selection.
btn.bind(on_release=lambda btn: self.dropdown.select(btn.text))
# then add the button inside the dropdown
self.dropdown.add_widget(btn)
self.dropdown.bind(
on_select=lambda instance, x: setattr(self.mainbutton, 'text', x))
self.add_widget(self.mainbutton)
def __init__(self, **kwargs):
super(ScaleOptions, self).__init__(**kwargs)
self.cols = 3
self.rows = 1
self.root = TextInput(text='Root Note')
#self.scaleType = TextInput(text='Scale Type')
self.scaleDropDown = DropDown()
for scale in SCALETABLE:
btn = Button(text=scale[0])
btn.size_hint_y = None
btn.height = 44
btn.bind(
on_release=lambda btn: self.scaleDropDown.select(btn.text))
self.scaleDropDown.add_widget(btn)
self.scaleType = Button(text='Scale Type')
self.scaleType.bind(on_release=self.scaleDropDown.open)
self.scaleDropDown.bind(
on_select=lambda instance, x: setattr(self.scaleType, 'text', x))
self.loadButton = Button(text='Show Scale')
self.loadButton.bind(on_press=self.callback)
self.add_widget(self.root)
self.add_widget(self.scaleType)
self.add_widget(self.loadButton)
def __init__(self, **kwargs):
super(ChordOptions, self).__init__(**kwargs)
self.cols = 4
self.rows = 1
self.root = TextInput(text='Root Note')
#self.triadType = TextInput(text='Scale Type')
self.triadDropDown = DropDown()
for triad in CHORDTYPETABLE:
btn = Button(text=triad[0])
btn.size_hint_y = None
btn.height = 44
btn.bind(
on_release=lambda btn: self.triadDropDown.select(btn.text))
self.triadDropDown.add_widget(btn)
self.triadType = Button(text='Chord')
self.triadType.bind(on_release=self.triadDropDown.open)
self.triadDropDown.bind(
on_select=lambda instance, x: setattr(self.triadType, 'text', x))
self.extensions = TextInput(text='Extensions')
self.loadButton = Button(text='Show Chord')
self.loadButton.bind(on_press=self.callback)
self.add_widget(self.root)
self.add_widget(self.triadType)
self.add_widget(self.extensions)
self.add_widget(self.loadButton)
def create_pos_drop(self):
self.pos_drop = DropDown(size_hint=(None, None), size=(100, 30))
for pos in ('center', 'right', 'left'):
btn = Button(text=pos, size_hint=(None, None), size=(100, 30))
btn.bind(on_release=lambda btn_: self.pos_drop.select(btn_.text))
self.pos_drop.add_widget(btn)
self.pos_drop.bind(on_select=self.on_pos_select)
def __init__(self, **kwargs):
super(AddGauge, self).__init__(**kwargs)
self.log = logging.getLogger('digilogger')
win_w = Window.size[0]
win_h = Window.size[1]
if (platform.platform() ==
'Linux-4.1.19-v7+-armv7l-with-Ubuntu-16.04-xenial'):
win_h = 480
self.Parent = None
self.dButton = None
self.aButton = None
self.appLayout = FloatLayout(size=(800, 600))
reads = read()
self.typeDict = read.readIn(reads, "AddGauge.csv")
self.codetype = DropDown()
for x in self.typeDict.keys():
self.cur = Button(text=x, size_hint_y=None, height=30)
self.cur.bind(on_release=partial(self.userSelect, x))
self.codetype.add_widget(self.cur)
self.mainbutton = Button(text='New Gauge',
size_hint=(None, None),
size=(200, 30))
self.mainbutton.pos = (20, win_h - self.mainbutton.size[1])
self.mainbutton.bind(on_release=self.codetype.open)
self.add_widget(self.mainbutton)
def create_pos_drop(self):
self.pos_drop = DropDown(size_hint=(None, None), size=(100, 30), scroll_type=["bars", "content"], effect_cls="ScrollEffect", bar_width=10)
for pos in ('center', 'right', 'left'):
btn = Button(text=pos, size_hint=(None, None), size=(100, 30))
btn.bind(on_release=lambda btn_: self.pos_drop.select(btn_.text))
self.pos_drop.add_widget(btn)
self.pos_drop.bind(on_select=self.on_pos_select)
def __init__(self, sg=None, **kwargs):
super(SearchLayout, self).__init__(**kwargs)
self.cols = 2
self.sg_t = sg
self.search_keyword = TextInput(multiline=False,
size_hint_y=None,
height=40)
self.search_keyword.bind(text=self.name_get_text)
self.idWithTitle = {}
self.search_button = Button(text='Search Entity',
size_hint_y=None,
height=40,
size_hint_x=None,
width=250)
self.search_button.bind(on_press=self.search)
self.dropdown = DropDown()
#print("Hello")
self.search_button.bind(on_release=self.dropdown.open)
self.dropdown.bind(on_select=lambda instance, x: setattr(
self.search_button, 'text', x))
#runTouchApp(self.search_button)
#self.search_button = Button(text = 'Search Entity')
#self.search_button.bind(on_press = self.search)
self.add_widget(self.search_keyword) #row=9
self.add_widget(self.search_button) #row=10
def update(self, *args):
self.ids["Title"].text = self.title
self.ids["Description"].text = self.description
self._editorHolder.clear_widgets()
if self.type == "numericSlider":
if self.sliderMin is None or self.sliderMax is None:
raise ValueError("'sliderMin' and / or 'sliderMax' cannot be 'None' if type is numericSlider")
self._editorWidget = Slider(min=self.sliderMin, max=self.sliderMax,
value=Config.getint(self.section, self.option), step=1)
self._editorWidget.bind(value=self.value_changed)
self._editorWidget2 = TextInput(multiline=False, font_size=self._editorHolder.height / 2,
text=Config.get(self.section, self.option), input_filter="int")
self._editorWidget2.bind(on_text_validate=self.text_box_int_validator)
self._editorWidget2.bind(focus=self.text_box_int_validator)
elif self.type == "bool":
self._editorWidget = Switch(active=Config.getboolean(self.section, self.option))
self._editorWidget.bind(active=self.value_changed)
elif self.type == "string":
self._editorWidget = TextInput(multiline=False, font_size=self._editorHolder.height / 2,
text=Config.get(self.section, self.option))
self._editorWidget.bind(on_text_validate=lambda *args: self.value_changed(None, self._editorWidget.text))
self._editorWidget.bind(focus=lambda *args: self.value_changed(None, self._editorWidget.text))
elif self.type == "option":
self._editorWidget = Button(text=Config.get(self.section, self.option))
dropDown = DropDown()
for option in self.options:
text = str(option)
try:
text = text + " - " + str(self.extra_info[option])
except KeyError:
pass
btn = Button(text=text, size_hint_y=None, height=self.height)
btn.tag = str(option)
btn.bind(on_release=lambda _btn: dropDown.select(_btn.tag))
dropDown.add_widget(btn)
self._editorWidget.bind(on_release=dropDown.open)
self._editorWidget.bind(on_release=lambda *args: emptyFunction(dropDown.children))
dropDown.bind(on_select=lambda instance, x: setattr(self._editorWidget, 'text', x))
dropDown.bind(on_select=self.value_changed)
if self._editorWidget2 is not None:
self._editorHolder.add_widget(self._editorWidget2)
if self.type != "title":
self._editorHolder.add_widget(self._editorWidget)
