def create_dropdown(self):
"""
Create a dropdown box.
"""
self.dropdown = DropDown()
roles = ["Top", "Jungle", "Middle", "ADC", "Support"]
for role in roles:
# 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=role, 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))
self.dropdown.add_widget(btn)
# Display the button's text as the selected text
self.dropdown.bind(on_select=lambda instance, x:
setattr(self.dropdown_button, 'text', x))
# Enable the go button
self.dropdown.bind(on_select=self.enable_go_button)
class DropBut(Button):
def __init__(self, **kwargs):
super(DropBut, self).__init__(**kwargs)
self.drop_list = None
self.drop_list = DropDown()
self.picked = False
self.id = self.get_id()
for ing in supported_ings:
btn = Button(text=ing, size_hint_y=None, height=25)
btn.bind(on_release=lambda btn: self.drop_list.select(btn.text))
self.drop_list.add_widget(btn)
self.bind(on_release=self.drop_list.open)
self.drop_list.bind(on_select=self.pick_ing)
def get_id(self):
dp_btns.append(True)
return str(len(dp_btns) - 1)
def pick_ing(self, instance, x):
setattr(self, 'text', x)
if not self.picked:
inputs.append(x)
self.picked = True
else:
inputs[int(self.id)] = x
print(inputs)
class acilirKutu(App):
def secim(self, nesne):
# Önceden seçilmiş bir düğme var ise, arka plan rengini
# ön tanımlı renge dönüştürelim
if self.acilirkutu.secim:
self.acilirkutu.secim.background_color= [1, 1, 1, 1]
self.acilirkutu.select(nesne.text)
self.anadugme.text=nesne.text
# secim özelliğine yeni nesneyi ekleyelim ve
# arka plan rengini kırmızı yapalım
self.acilirkutu.secim=nesne
nesne.background_color= 1, 0, 0, 1
def build(self):
duzen = BoxLayout()
self.anadugme = Button(text='Başlat', size_hint=(None, None))
self.acilirkutu = DropDown()
self.acilirkutu.secim=None
for x in ( "Mustafa", "Dilek", "Fatih", "Melike"):
dugme=Button(text=x, size_hint_y=None, height=25)
dugme.bind(on_release=self.secim)
self.acilirkutu.add_widget(dugme)
self.anadugme.bind(on_release=self.acilirkutu.open)
duzen.add_widget(self.anadugme)
return duzen
def __init__(self, entries=[], **kwargs):
super(DropdownBox, self).__init__(orientation='horizontal',
spacing=0,
**kwargs)
self.dropdown = DropDown()
self.selected_text = LabelB(bcolor=(0, 0, 0, 0.3))
self.dropdown.bind(on_select=lambda instance, x: setattr(
self.selected_text, 'text', x))
v_button = LabelB(text='V',
bcolor=(0, 0, 0, 0.8),
size_hint=(None, None))
# Set the V button to a square size equal to the size of the Dropdown Box
self.bind(size=lambda obj, size: v_button.setter('size')
(v_button, (size[1], size[1])))
self.bind(on_release=lambda x: self.dropdown.open(self))
self.bind(mouse_hover=lambda instance, hover: partial(
DropdownBox.highlight_selection, self.selection_color, v_button,
hover)())
self.bind(values=self.updated_values)
self.bind(default=self.updated_default)
self.add_widget(self.selected_text)
self.add_widget(v_button)
self.selected_text.bind(text=self.setter('text'))
self.values = entries
def create_dropdown(self, *args):
self.dropdown_list = DropDown()
for player in self.root.players:
player_name = player.name.upper()
# button for dropdown list 1
btn = Button(
text=f'[b][color=#ffffff]{player_name}[/b][/color]', size_hint_y=None,
height=self.width // 25,
markup=True
)
# Storing the btn references into a list
self.btns[player_name] = btn
# Create the binding function
btn.bind(on_release=lambda btn: self.dropdown_list.select(btn.text))
# Add the widget to the dropdown window
self.dropdown_list.add_widget(btn)
# Bind the select name btns to opening the dropdown window
self.ids.select_name_btn.bind(on_release=self.dropdown_list.open)
# Binding the select name btns to also update their text values
self.dropdown_list.bind(
on_select=functools.partial(self.select_player, self.ids.select_name_btn)
)
class SettingsScreen(ActionBarScreen):
STR_SETTINGS = StringProperty()
STR_RESET_DEFAULTS = StringProperty()
STR_RESET_DEFAULTS_HELP = StringProperty()
STR_RESET = StringProperty()
STR_LANGUAGE_CHANGE = StringProperty()
def __init__(self, **kwargs): # inicializace
self.root = kwargs['root']
self.root.insertStrings.append((self, ))
super(SettingsScreen, self).__init__(**kwargs)
self.dropdown = DropDown()
for index in LANGUAGES.itervalues():
btn = Button(text=index, size_hint_y=None, height=44, font_size='24dp', font_name="font/Roboto-Regular.ttf")
btn.bind(on_release=lambda btn: self.dropdown.select(btn.text))
self.dropdown.add_widget(btn)
self.language.bind(on_release=self.dropdown.open)
self.dropdown.bind(on_select=lambda instance, x: setattr(self.language, 'text', x))
self.language.bind(text=self.change)
def reset_defaults(self, *args):
# Výmaz konfiguračního souboru po stisku tlačítka reset
self.root.Cfg = ['' for y in range(4)]
self.root.refreshCfg()
def on_pre_enter(self, *args):
# Před vstupem na obrazovku načte jazyky
self.language.text = LANGUAGES.get(self.root.Cfg[0])
def change(self, *args):
# Změní jazyk, znovu načte řetězce
self.root.Cfg[0] = [y[0] for y in LANGUAGES.items() if y[1] == self.language.text][0]
self.root.refreshCfg()
self.root.doStrInsert()
def __init__(self, **kwargs):
super(FileMenu, self).__init__(**kwargs)
self.dropdown = DropDown()
self.dropdown.add_widget(NewFileButton(ctxt=self._ctxt))
self.dropdown.add_widget(OpenFileButton(ctxt=self._ctxt))
self.dropdown.add_widget(SaveFileButton(ctxt=self._ctxt))
class Uygulama(App):
def secim(self,nesne):
if nesne.text=="mavi":
self.resim.color=(0,0,1,1)
elif nesne.text=="kirmizi":
self.resim.color=(1,0,0,1)
elif nesne.text=="yeşil":
self.resim.color=(0,1,0,1)
self.dropdown.select(nesne.text)
self.anaDugme.text=nesne.text
def build(self):
self.renkler=(["mavi"],["kirmizi"],["yeşil"])
duzen=BoxLayout()
self.dropdown=DropDown()
self.resim=Image()
for renk in self.renkler:
dugme=Button(text=renk[0],size_hint_y=None,height=50)
dugme.bind(on_relase=self.secim)
self.dropdown.add_widget(dugme)
self.anaDugme=Button(text="Renkler",size_hint=(None,None))
self.anaDugme.bind(on_relase=self.dropdown.open)
duzen.add_widget(self.anaDugme)
duzen.add_widget(self.resim)
return duzen
def DropDownCreation(data):
Dropdown = DropDown()
for i in data:
drop_option = Button(text = i, size_hint_y = None, height = 40)
drop_option.bind(on_release = lambda drop_option: Dropdown.select(drop_option.text))
Dropdown.add_widget(drop_option)
return Dropdown
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=_('Remove'), func=lambda btn: self.remove_local_tx(), enabled=self.is_local_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=48)
btn.bind(on_release=option.func)
dropdown.add_widget(btn)
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=_('Remove'), func=lambda btn: self.remove_local_tx(), enabled=self.is_local_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(DropDownButton, self).__init__(**kwargs)
self.drop_list = DropDown()
if kwargs.has_key('type'):
types = kwargs['type']
else:
types = ['empty']
if kwargs.has_key('module') and kwargs.has_key('widget'):
mod = __import__(kwargs['module'], fromlist=kwargs['widget'])
widget_name = kwargs['widget']
else:
mod = __import__('kivy.uix.button', fromlist=['Button'])
widget_name = 'Button'
for i in types:
attr = getattr(mod, widget_name)
btn = attr(text=i, size_hint_y=None, height=50)
btn.bind(on_release=lambda btn: self.drop_list.select(btn.text))
self.drop_list.add_widget(btn)
self.bind(on_release=self.drop_list.open)
self.drop_list.bind(on_select=lambda instance, x: setattr(self, 'text', x))
def __init__(self, **kwargs):
super(GeneScreen, self).__init__(**kwargs)
# Widget Container
screen_container = BoxLayout(orientation='vertical',
padding=[1])
# *Logo----------------------------------------------------------------
self.logo = HomeButton()
screen_container.add_widget(self.logo)
# *Gene Selection Title------------------------------------------------
screen_container.add_widget(Label(text='Gene Selection',
size_hint=(1, .1),
color=(0, .1, .25, .75)))
# *Drop Down Menu------------------------------------------------------
self.dropdown = DropDown()
self.dropdown.bind(on_select=self.set_gene)
self.dd_btns = [] # A list of drop down buttons for easy deletion
# Populate when top button hit
self.mainbutton = CustomButton(text='Select a gene',
size_hint=(1, .2))
self.mainbutton.bind(on_release=self.load_genes) # Populate dropdown
self.dropdown.bind(on_select=lambda instance, x:
setattr(self.mainbutton, 'text', x))
# Place on screen
screen_container.add_widget(self.mainbutton)
# *Gene Buttons--------------------------------------------------------
# Declarations
self.button_holder = BoxLayout(orientation='horizontal')
# Edit Button
self.edit_btn = CustomButton(text="Edit",
size_hint=(.3, .3))
self.edit_btn.bind(on_release=self.switch_screen)
# New Button
self.new_btn = CustomButton(text="New",
size_hint=(.3, .3))
self.new_btn.bind(on_release=self.switch_screen)
# Delete Button
self.delete_btn = CustomButton(text="Delete",
size_hint=(.3, .3))
self.delete_btn.bind(on_release=self.delete)
# Placement
self.button_holder.add_widget(self.edit_btn)
self.button_holder.add_widget(self.new_btn)
self.button_holder.add_widget(self.delete_btn)
screen_container.add_widget(self.button_holder) # Place Container
# Pack all widgets
self.add_widget(screen_container)
# Reset drop down when screen is loaded
self.bind(on_enter=self.reset_menu)
class FormScreen(GridLayout):
def submission(self):
print("Submitted")
print(self.username.text)
print(self.password.text)
print(self.mainbutton.text)
def __init__(self, **kwargs):
super(FormScreen, self).__init__(**kwargs)
self.cols = 2
self.image = AsyncImage(source='https://www.logolynx.com/images/logolynx/ad/ad0eb0cfc1afa21d427b5bae775fe536.jpeg')
self.add_widget(self.image)
self.add_widget(Label(text='Registration Form'))
# Label and Text Entry
self.add_widget(Label(text='User Name'))
self.username = TextInput(multiline=False)
self.add_widget(self.username)
# Label and Password Entry
self.add_widget(Label(text='password'))
self.password = TextInput(password=True, multiline=False)
self.add_widget(self.password)
# Label and Dropdown
self.add_widget(Label(text='Select Option'))
self.dropdown = DropDown()
options = ['One', 'Two', 'Three']
self.mainbutton = Button(text="One")
self.add_widget(self.mainbutton)
self.mainbutton.bind(on_release=self.dropdown.open)
## Assigns the selected option
self.dropdown.bind(on_select=lambda instance, x: setattr(self.mainbutton, 'text', x))
for option in options:
# When adding widgets, we need to specify the height manually
# (disabling the size_hint_y) so the dropdown can calculate
# the area it needs.
self.btn = Button(text=option, 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.
self.btn.bind(on_release=lambda btn: self.dropdown.select(btn.text))
# then add the button inside the dropdown
self.dropdown.add_widget(self.btn)
# Submit Button
self.submitbtn = Button(text="Submit")
self.add_widget(self.submitbtn)
self.submitbtn.bind(on_release=lambda x:self.submission())
def __init__(self, screen_manager, **kwargs):
super(ChatScreen, self).__init__(**kwargs)
self.screen_manager = screen_manager
self.database = None
self.client_transport = None
self.contact = None
self.client_login = None
self.main_layout = GridLayout(cols=1)
self.header_layout = GridLayout(cols=3, size_hint=(1, 0.1))
self.scroll_view = ScrollView(size_hint=(1, 0.8),
size=(100, 100),
scroll_y=0)
self.footer_layout = GridLayout(cols=2, size_hint=(1, 0.1))
self.contact_list_button = Button(text='<=', size_hint=(0.1, 1))
self.contact_list_button.on_press = self.go_to_contact_list
self.label = CLabel(text="Chat with bla bla", size_hint=(0.9, 1))
self.contact_menu = DropDown()
for name in ['Info', 'Delete']:
btn = Button(text=f'{name}', size_hint_y=None, height=30)
btn.bind(on_release=lambda btn: self.contact_menu.select(btn.text))
self.contact_menu.add_widget(btn)
self.main_button = Button(text=':', size_hint=(.1, .3))
self.main_button.bind(on_release=self.contact_menu.open)
self.contact_menu.bind(
on_select=lambda instance, x: self.menu_contact(x))
self.messages = []
self.messages_layout = GridLayout(cols=1,
padding=(30, 0, 30, 0),
size_hint_y=None,
row_force_default=True,
row_default_height=40)
self.messages_layout.bind(
minimum_height=self.messages_layout.setter('height'))
self.scroll_view.add_widget(self.messages_layout)
self.text_input = TextInput(size_hint=(0.9, 1))
self.send_button = Button(text='>>', size_hint=(0.1, 1))
self.send_button.on_press = self.send_message
self.header_layout.add_widget(self.contact_list_button)
self.header_layout.add_widget(self.label)
self.header_layout.add_widget(self.main_button)
self.footer_layout.add_widget(self.text_input)
self.footer_layout.add_widget(self.send_button)
self.main_layout.add_widget(self.header_layout)
self.main_layout.add_widget(self.scroll_view)
self.main_layout.add_widget(self.footer_layout)
self.add_widget(self.main_layout)
def __init__(
self,
title,
base_value,
modifier=[],
test_type=TestType.OTHER,
damage=None,
damage_bonus=0,
**kwargs,
):
super(TestPopup, self).__init__(**kwargs)
self.title = "{} Test".format(title)
self.base_value = base_value
self.difficulty = 0
self.misc_mod = 0
self.roll = 0
self.current_value = self.base_value
self.modifier = modifier.copy()
self.test_type = test_type
self.damage = damage
self.damage_bonus = damage_bonus
self.difficulty_dropdown = DropDown()
for difficulty in test_difficulties:
button = DropdownButton(*difficulty)
button.bind(on_release=lambda btn: self.difficulty_dropdown.select(
[btn.text, btn.modifier]))
self.difficulty_dropdown.add_widget(button)
self.ids["button_difficulty"].bind(
on_release=self.difficulty_dropdown.open)
self.difficulty_dropdown.bind(on_select=self.set_difficulty)
self.ids["modifier_box"].height = 0
fatigue_mod = {"name": "Fatigue", "bonus": -10, "type": "status"}
char = CHARACTER.get("character")
if char["status"]["fatigue"] > 0:
fatigue_mod["on"] = True
self.current_value += fatigue_mod["bonus"]
else:
fatigue_mod["on"] = False
self.modifier.append(fatigue_mod)
for mod in self.modifier:
modifier_box = ModifierBox(mod)
modifier_box.ids["checkbox_on"].bind(
active=self.modify_current_value)
self.ids["modifier_box"].add_widget(modifier_box)
self.ids["modifier_box"].height += modifier_box.height
dos_config = DoSAlgorithm(config.get("config")["dos_algorithm"])
if dos_config == DoSAlgorithm.DARK_HERESY_2:
self.dos_func = utils.calculate_dos_dh2
elif dos_config == DoSAlgorithm.ROGUE_TRADER:
self.dos_func = utils.calculate_dos_rt
if dos_config == DoSAlgorithm.MIXED and test_type == TestType.OTHER:
self.dos_func = utils.calculate_dos_rt
if dos_config == DoSAlgorithm.MIXED and test_type == TestType.FIGHT:
self.dos_func = utils.calculate_dos_dh2
if test_type == TestType.FIGHT:
self.ids["button_damage"].on_press = self.roll_damage
self.open()
def test_on_release(self):
w = DropDown()
w.on_select = MagicMock()
a = MatiereOption(dropdown=w)
a.trigger_action(0)
assert w.on_select.called
assert w.on_select.call_args == call(a)
def create_loc_drop(self):
self.loc_drop = DropDown(size_hint=(None, None),
size=(200, 30),
scroll_type=["bars", "content"],
effect_cls="ScrollEffect",
bar_width=10)
self.create_location_buttons(self.loc_drop)
self.loc_drop.bind(on_select=self.on_loc_select_clicked)
def create_dropdown(self):
self.dropdown2 = DropDown()
for time in self.times:
btn = Button(text= time, size_hint_y=None, height=44)
btn.bind(on_release=lambda btn: self.dropdown2.select(btn.text))
self.dropdown2.add_widget(btn)
self.btnResult.bind(on_release=self.dropdown2.open)
self.dropdown2.bind(on_select=lambda instance, x: self.display_posture(x))
def create_dropdown(self):
self.dropdown = DropDown()
for session in self.sessions:
btn = Button(text= session, size_hint_y=None, height=44)
btn.bind(on_release=lambda btn: self.dropdown.select(btn.text))
self.dropdown.add_widget(btn)
self.btnSession.bind(on_release=self.dropdown.open)
self.dropdown.bind(on_select=lambda instance, x: setattr(self.btnSession, 'text', x))
def __init__(self, value):
self.value = value
self.dropDown = DropDown()
if self.value.__len__() > 0:
for index in range(self.value.__len__()):
btn = Button(text= self.value[index], size_hint_y=None, height=50)
btn.bind(on_release=lambda btn: self.dropDown.select(btn.text))
self.dropDown.add_widget(btn)
def buildDropdown(self, langs):
languages = DropDown()
for index in range(len(langs)):
btn = Button(text=langs[index], size_hint_y=None, height=22)
btn.bind(on_release=lambda btn: self.languages.select(btn.text))
btn.bind(on_press=lambda btn: self.changeLanguage(btn.text))
languages.add_widget(btn)
return languages
def CreateDataFilenameDropdown(self, datadir):
dropdown = DropDown()
for (dirpath, dirnames, filenames) in os.walk(datadir):
for filename in sorted(filenames):
if filename.endswith('.csv'):
btn = Button(text=filename, size_hint_y=None, height=44)
btn.bind(on_release=lambda btn: dropdown.select(btn.text))
dropdown.add_widget(btn)
return dropdown
def __init__(self, container_buttons_height_ratio=2., **kwargs):
super(DropDownButton, self).__init__(**kwargs)
self.container_buttons_height_ratio = container_buttons_height_ratio
self.dropdown = DropDown()
self.add_dropdown_contents()
self.add_widget(self.dropdown)
self.bind(on_release=self.dropdown.open)
self.set_initial_dropdown_selection()
self.dropdown.dismiss()
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 __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, trade_screen=None, **kwargs):
super(SymbolSearch, self).__init__(**kwargs)
self.font_size = 40
self.multiline = False
self.dropdown = DropDown()
self.dropdown_items = []
self.dropdown.max_height = Window.size[1] * .2
self.dropdown.background_color = (1,1,1,1)
self.trade_screen = trade_screen
def __init__(self, *args, **kwargs):
super(MapScreen, self).__init__(*args, **kwargs)
# Заголовок
self.head = AviaLabel(size_hint=(.3, .1),
font_size=25,
pos_hint={
'center_x': 0.15,
'center_y': .95
})
self.head.text = 'Карта'
self.add_widget(self.head)
# Окно поиска
self.dropdown = DropDown()
self.search = TextInput(
multiline=False,
size_hint=(1, 0.1),
font_size=40,
pos_hint={
'center_x': .5,
'center_y': .85
},
#on_text_validate=self.dropdown.open
)
self.search.bind(text=self.update_dropdown)
#Действие в момент выбора
#self.dropdown.bind(on_select=lambda instance, x: setattr(self.search, 'text', x))
self.add_widget(self.search)
# Карта
self.airport = Image(source='airport.png',
size_hint=(1 * 4, 0.7 * 4),
pos_hint={
'center_x': .5,
'center_y': .45
})
self.add_widget(self.airport, 5)
#Кнопка приближения
self.plus_button = Button(text="+",
size_hint=(None, None),
size=(80, 80),
pos=(Window.size[0] - 90,
Window.size[1] * 0.2 + 90))
self.plus_button.bind(on_release=self.big_map)
self.add_widget(self.plus_button)
#Кнопка отдаления
self.minus_button = Button(text="-",
size_hint=(None, None),
size=(80, 80),
pos=(Window.size[0] - 90,
Window.size[1] * 0.2))
self.minus_button.bind(on_release=self.small_map)
self.add_widget(self.minus_button)
def __init__(self, callback=None, *args, **kwargs):
super(MainWidget, self).__init__(*args, **kwargs)
self.callback = callback
self.is_fm = True
x = y = 300
points = []
for i in range(50, self.size[0] - 150):
points.extend([i, y])
self.s = SignalDraw(points=points,
size=[self.size[0] - 100, self.size[1]])
self.add_widget(self.s)
self.b = Button(text='Submit',
size=[100, 100],
pos=[self.size[0] - 100, 0])
self.b.bind(on_press=self.submit)
self.add_widget(self.b)
self.dropdown = DropDown()
btn = Button(text='Sine', size_hint_y=None, height=44)
btn.bind(on_release=lambda btn: self.dropdown.select(btn.text))
self.dropdown.add_widget(btn)
btn = Button(text='Cosine', size_hint_y=None, height=44)
btn.bind(on_release=lambda btn: self.dropdown.select(btn.text))
self.dropdown.add_widget(btn)
btn = Button(text='Square', size_hint_y=None, height=44)
btn.bind(on_release=lambda btn: self.dropdown.select(btn.text))
self.dropdown.add_widget(btn)
self.am_button = Button(text='Frequency Modulation (FM)',
size=[100, 100],
pos=[self.size[0] - 100, 100])
self.am_button.bind(
on_release=lambda btn: self.set_am_fm(self.am_button.text))
self.add_widget(self.am_button)
self.mainbutton = Button(text='Choose signal',
size_hint=(None, None),
size=[100, 100],
pos=[self.size[0] - 100, 200])
self.mainbutton.bind(on_release=self.dropdown.open)
self.dropdown.bind(on_select=self.dropdown_select)
self.add_widget(self.mainbutton)
self.slider = Slider(min=1,
max=30,
value=3 * math.pi,
pos=[self.size[0] - 100, 300])
self.add_widget(self.slider)
def __init__(self, default_text='', **kwargs):
super(DropDownMenu, self).__init__(**kwargs)
self.drop_list = None
self.drop_list = DropDown()
self.text = default_text
self.name = ''
"""Button bindings"""
self.bind(on_release=self.drop_list.open)
"""Dropdown bindings"""
self.drop_list.bind(on_select=self.set_text)
def build(self):
self.root = Builder.load_string(kv)
self.acilirkutu = DropDown()
for x in ("Mustafa", "Dilek", "Fatih", "Melike"):
dugme = Button(text=x, size_hint_y=None, height=25)
dugme.bind(on_release=self.secim)
self.acilirkutu.add_widget(dugme)
return self.root
def __init__(self, **kwargs):
self.email_db = []
if EMAILS_LIST.exists():
with EMAILS_LIST.open() as femails:
self.email_db = set(
map(lambda e: e.strip(), femails.readlines()))
self.drop_down = DropDown()
self.drop_down.bind(on_select=self.on_select)
super(ComboEdit, self).__init__(**kwargs)
def __init__(self, **kwargs):
self.connectionHandler = kwargs.get('connectionHandler', None)
self.screenManager = kwargs.get('screenManager', None)
self.name = kwargs.get('channel_info', 'ChannelScreen')
super(ChannelScreen, self).__init__()
self.channelbutton = self.ids.channels
self.backbutton = self.ids.back
self.backbutton.bind(on_press=self.goBack)
self.channelbutton.bind(on_press=self.drop_down_ch)
self.dropdown = DropDown()
def __init__(self, **kwargs):
super(UpdateScreen, self).__init__(**kwargs)
self.cols = 2
dropDown = DropDown()
for index in range(10):
btn = Button(Text="Value %d" % index, size_hint_y=None, height=44)
dropDown.add_widget(btn)
self.add_widget(dropDown)
def buildDropDown(self, args):
self.ids.dropdown_item.text = self.initial_selected_text
self.menu = DropDown()
for each in self.menu_items:
btn = DropItem(text=each.split(".")[0], icon="music-note",
icon_color=random.choice(clr))
btn.bind(on_release=lambda btn: self.set_item(self.menu, btn))
self.menu.add_widget(btn)
self.menu.spacing = 0
self.menu.add_widget(MDSeparator())
class Color_Picker(Selection):
colors = {"Sky Blue": (0.529, 0.808, 0.922)}
browse_btn = Button(text="Browse")
#browse_btn.bind(on_release=lambda x : x.root.browse(x))
# bind button to static FileBrowser' browse() function
#browse_btn.bind(on_release=lambda x : FileBrowser.open(FileBrowser.instance))
def __init__(self, **kwargs):
super(Color_Picker, self).__init__(**kwargs)
# Layout for selecting items
self.dropdown = DropDown()
self.app = MDApp.get_running_app()
self.picker_btn.text = "Choose Color"
self.picker_btn.bind(on_release=self.dropdown.open)
# Add colors to dropdown
for color in self.colors:
btn = Button(text=color, size_hint_y=None, height=40)
# When a color is selected the name is passed to dropdown object
btn.bind(on_release=lambda btn: self.dropdown.select(btn.text))
self.dropdown.add_widget(btn)
self.dropdown.bind(
on_select=lambda instance, x: setattr(self, 'selection', x))
def dismiss(self):
self.dropdown.dismiss()
def on_leave(self):
self.dropdown.clear_widgets()
def addButtons(self):
for i, button_text_label in enumerate(self.buttonList):
temp_button = MyButton(text = button_text_label)
#if these two colors are not redefined in the inherited class, the default is used
temp_button.color = self.menu_color_letters
temp_button.background_color = [.8, .7,0, .9]
#now add dropdown buttons
dropdown = DropDown()
#if in parameter settings, combine dict to string
if i is 1:
for y in self.paradigm_setup_values:
submenu_string = y+': '+str(self.paradigm_setup_values[y])
btn = Button(text=submenu_string, size_hint_y=None, height=44)
btn.background_color = [.8, .9,.7, .9]
btn.bind(on_release=lambda btn: dropdown.select(btn.text))
dropdown.add_widget(btn)
else:
for submenu_string in self.menu_items[i]:
# 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=submenu_string, size_hint_y=None, height=44)
btn.background_color = [.8, .9,.7, .9]
# 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)
#bind the dropdown to the main menu button
temp_button.bind(on_release = dropdown.open)
dropdown.bind(on_select=lambda instance, x: self.menu_function_handler(x))
#get info about what has been pressed
#dropdown.bind(on_select=lambda instance, x: setattr(temp_button, 'text', x))
self.layout_top_menu.add_widget(temp_button)
class LeaderBoardLayout(Widget):
def __init__(self, **kwargs):
""" Creates the buttons, text inputs and labels to be used by the other functions
:param kwargs:
:return:
"""
super(LeaderBoardLayout, self).__init__(**kwargs)
self.choice_button = Button(text="Get results")
self.results_label = Label(text="High scores", font_size="20sp")
self.name_input = TextInput(text="Enter username here.", multiline=False)
self.options_dropdown = DropDown()
self.dropdown_button = Button(text="Select an option")
self.dropdown_button.bind(on_release=self.options_dropdown.open)
self.layout = GridLayout(rows=5)
self.drop_down_options = ["Top 10 Scores", "Add New User", "Top scores for user"]
self.selected_url = "None"
def create_layout(self):
"""Adds the objects created in __init__ to a GridLayout and creates a drop down
:return:
"""
self.choice_button.bind(on_press=self.callback)
for d in self.drop_down_options:
btn = Button(text=d, size_hint_y=None, height=44)
btn.bind(on_release=lambda btn: self.options_dropdown.select(btn.text))
self.options_dropdown.add_widget(btn)
self.options_dropdown.bind(on_select=lambda instance, x: setattr(self.dropdown_button, "text", x))
self.layout.add_widget(self.dropdown_button)
self.layout.add_widget(self.name_input)
self.layout.add_widget(self.choice_button)
self.layout.add_widget(self.results_label)
return self.layout
def server_results(self, request, results):
""" Outputs the request result into a label
"""
self.results_label.text = str(results)
def callback(self, event):
"""Depending on which drop down option was selected a request a URL is
chosen to request data from teh server. """
playername = self.name_input.text[:3]
self.name_input.text = playername
self.results_label.text = "Getting scores"
if self.dropdown_button.text == "Top 10 Scores":
self.selected_url = "http://bsccg04.ga.fal.io/top10.py"
elif self.dropdown_button.text == "Add New User":
self.selected_url = "http://bsccg04.ga.fal.io/new_user.py?playername=" + playername
elif self.dropdown_button.text == "Top scores for user":
self.selected_url = "http://bsccg04.ga.fal.io/users_high_score.py?playername=" + playername
request = UrlRequest(self.selected_url, self.server_results)
def populate_drop_down(self, entries, attribute, location):
"""Populate a drop down menu."""
drop_down = DropDown()
for entry in entries:
Logger.info("populate dropdown for {}: {}"
"".format(attribute, entry))
button = Button(
text=entry.name, height=44, size_hint_y=None,
on_release=lambda a, entry=entry:
setattr(self, attribute, entry))
drop_down.add_widget(button)
drop_down.open(location)
class MyDrop(App):
def __init__(self, **kwargs):
super(MyDrop, self).__init__(**kwargs)
api = 'http://127.0.0.1:3000/api/1.0/places.json'
resp = requests.get(api)
places = []
try:
if not resp.status_code == 200:
raise Exception('ApiException', 'Error found while calling the API backend')
for data in [resp.json()[key] for key in resp.json().keys() if key == 'data']:
for place in data:
places.append(place['name'])
self.lista = tuple(places)
except Exception as err:
return err
def d(self, n):
self.dropdown.select(n.text)
def build(self):
self.box = FloatLayout()
self.l = Label(pos_hint={'x': 0.5 / 2, 'center_y': 0.9},
size_hint=(0.5, 0.2),
text='[color=ff3333][b][size=35]TARIFAS DE TAXI[/b][/color]',
markup=True)
self.dropdown = DropDown()
for i in self.lista:
b1 = Button(text=i, size_hint_y=None, height=50)
b1.bind(on_release=self.d)
self.dropdown.add_widget(b1)
self.b2 = Button(pos_hint={'x': 0, 'center_y': .4},
size_hint=(0.5, 0.2),
text='[color=3333ff][size=24]ORIGEN[/color]',
markup=True)
self.b2.bind(on_release=self.dropdown.open)
self.b3 = Button(pos_hint={'x': 0.5, 'center_y': .4}, size_hint=(0.5, 0.2),
text='[color=3333ff][size=24]DESTINO[/color]', markup=True)
self.b3.bind(on_release=self.dropdown.open)
self.b_calcular = Button(pos_hint={'x': 0.5 / 2, 'center_y': .1}, size_hint=(0.5, 0.2),
text='[color=3333ff][size=24]CALCULAR TARIFA[/color]', markup=True)
self.b_calcular.bind()
self.box.add_widget(self.b2)
self.box.add_widget(self.b3)
self.box.add_widget(self.b_calcular)
self.box.add_widget(self.l)
return self.box
def __init__(self, widget, **kwargs):
super(DataBindingEditor, self).__init__(**kwargs)
dropdown = DropDown()
for variable in variables:
# 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' % variable, size_hint_y=None, height=40)
# 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=widget.variable.name, size_hint=(None, None), pos_hint={'center_x': 0.5, 'center_y': 0.5})
# 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.).
mainbutton.bind(on_release=dropdown.open)
# 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(mainbutton, 'text', x))
dropdown.bind(on_select=lambda instance, x: widget.set_var(x))
self.add_widget(mainbutton)
def __init__(self, player, **kwargs):
BoxLayout.__init__(self, **kwargs)
self.queue = Queue()
self.activeslider = False
self.dropdown = DropDown()
self.stationdropdown = DropDown()
self.currentplayer = player
self.playerstatus = "Pending ...."
self.playername = self.currentplayer.group.label
self.rendering = self.currentplayer.renderingControl.subscribe(
event_queue=self.queue)
self.info = self.currentplayer.avTransport.subscribe(
event_queue=self.queue)
self.timer = Clock.schedule_interval(self.monitor, 0)
def __init__(self, **kwargs):
super(Root, self).__init__(**kwargs)
self.sm.transition = BlurTransition()
for slide, name in self.slides:
self.sm.add_widget(slide, name)
self.dropdown = DropDown()
for name in self.sm.slide_names:
btn = Button(text=name, size_hint_y=None, height="40dp")
btn.bind(on_release=lambda btn: self.dropdown.select(btn.text))
self.dropdown.add_widget(btn)
self.sm.add_widget(Factory.EndSlide, "Fine della presentazione")
def dd_open_wrapper(*args, **kwargs):
self.dd_open = True
return self.dropdown.open(*args, **kwargs)
def dd_dismiss_wrapper(*args):
self.dd_open = False
self.controls.ddbutton.bind(on_release=dd_open_wrapper)
self.dropdown.bind(on_select=lambda instance, x: setattr(self.controls.ddbutton, 'text', x),
on_dismiss=dd_dismiss_wrapper)
self.dropdown.bind(on_select=lambda instance, x: self.sm.switch_to_slide(x))
self.controls.ddbutton.text = self.sm.current
self.sm.bind(current=self.controls.ddbutton.setter("text"))
class acilirKutuKv(App):
def secim(self, nesne):
self.acilirkutu.select(nesne.text)
self.root.ids.anadugme.text=nesne.text
def build(self):
self.root=Builder.load_string(kv)
self.acilirkutu = DropDown()
for x in ( "Mustafa", "Dilek", "Fatih", "Melike"):
dugme=Button(text=x, size_hint_y=None, height=25)
dugme.bind(on_release=self.secim)
self.acilirkutu.add_widget(dugme)
return self.root
def loaded(self, event):
if self.auto:
self.client.register(self.client.config.get('connection', '_id'))
return
self.layout.remove_widget(self.connecting_label)
del self.connecting_label
self.dropdown = DropDown()
for stage in sorted(self.client.meteor.find('stages'), key=lambda x: x['title']):
self.dropdown.add_widget(Label(text = stage['title'], size_hint_y = None, height = 40))
seen = []
for minion in sorted(self.client.meteor.find('minions',
selector = {'stage': stage['_id'], 'type': 'media'}), key=lambda x: x['title']):
# workaround for python-meteor bug
if not minion['stage'] == stage['_id']: continue
if minion['_id'] in seen: continue
else: seen.append(minion['_id'])
button = Button(text = minion['title'], size_hint_y = None, height = 30)
button.minion_id = minion['_id']
button.bind(on_press = self.do_register)
self.dropdown.add_widget(button)
self.dropdown_button = Button(text = 'Select Minion')
self.dropdown_button.bind(on_release = self.dropdown.open)
self.layout.add_widget(self.dropdown_button)
self.auto_checkbox = CheckBox()
self.auto_label = Label(text = 'Connect automatically on start')
self.layout.add_widget(self.auto_checkbox)
self.layout.add_widget(self.auto_label)
def build(self):
self.recent_path=os.getcwd()
self.cursor=None
self.set_language('en')
self.conn=None
self.table_dropdown = DropDown()
return Builder.load_file('main.kv')
def make_dropdown(self):
self.dropdown = DropDown()
for folder in os.listdir( self.parent.cfg_path ):
if '.' not in folder:
# 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=folder, 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)
# create a big main button
mainbutton = Button(text=self.parent.profile, size_hint=(None, 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.).
mainbutton.bind(on_release=self.dropdown.open)
def profile_select(instance, x):
setattr(mainbutton, 'text', x)
self.parent.profile = x
# one last thing, listen for the selection in the dropdown list and
# assign the data to the button text.
self.dropdown.bind( on_select=profile_select )
return mainbutton
def create_dropdown(self):
self.dropdownlist = DropDown()
for ix in self.linked_dataframe.index:
# 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 = DtbObjctDPbutton(
linked_dataframe = self.linked_dataframe,
objct_id = ix,
attr_displayed_list = self.attr_displayed_list,
attr_backcolor = self.attr_backcolor,
size_hint = (None,None),
size = self.size
)
# 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.dropdownlist.select(btn.objct_id)
)
# then add the button inside the dropdown
self.dropdownlist.add_widget(btn)
# one last thing, listen for the selection in the dropdown list and
# assign the data to the button text.
self.dropdownlist.bind(
on_select=lambda instance,
x: self.new_objct_id(objct_id = x)
)
def build(self):
self.box = FloatLayout()
self.l = Label(pos_hint={'x': 0.5 / 2, 'center_y': 0.9},
size_hint=(0.5, 0.2),
text='[color=ff3333][b][size=35]TARIFAS DE TAXI[/b][/color]',
markup=True)
self.dropdown = DropDown()
for i in self.lista:
b1 = Button(text=i, size_hint_y=None, height=50)
b1.bind(on_release=self.d)
self.dropdown.add_widget(b1)
self.b2 = Button(pos_hint={'x': 0, 'center_y': .4},
size_hint=(0.5, 0.2),
text='[color=3333ff][size=24]ORIGEN[/color]',
markup=True)
self.b2.bind(on_release=self.dropdown.open)
self.b3 = Button(pos_hint={'x': 0.5, 'center_y': .4}, size_hint=(0.5, 0.2),
text='[color=3333ff][size=24]DESTINO[/color]', markup=True)
self.b3.bind(on_release=self.dropdown.open)
self.b_calcular = Button(pos_hint={'x': 0.5 / 2, 'center_y': .1}, size_hint=(0.5, 0.2),
text='[color=3333ff][size=24]CALCULAR TARIFA[/color]', markup=True)
self.b_calcular.bind()
self.box.add_widget(self.b2)
self.box.add_widget(self.b3)
self.box.add_widget(self.b_calcular)
self.box.add_widget(self.l)
return self.box
class ProcesoPopup(Popup):
def __init__(self, sistema):
Popup.__init__(self)
self.sistema = sistema
self.lista_recursos = DropDown()
self.btn_lista.bind(on_release=self.lista_recursos.open)
self.lista_recursos.bind(on_select=self.usar_recurso)
def agregar_recurso(self, recurso):
btn = Button(text=recurso, size_hint_y=None, height=44)
btn.bind(on_release=lambda btn: self.lista_recursos.select(btn.text))
self.lista_recursos.add_widget(btn)
def usar_recurso(self, btn, recurso):
self.txt_recursos.text = self.txt_recursos.text + recurso + ", "
def info_nuevo(self):
return {}
def limpiar(self):
self.txt_nombre.text = ""
self.txt_tiempo.text = ""
self.txt_recursos.text = ""
self.txt_procesador.text= ""
self.dismiss()
def agregar(self):
nombre = self.txt_nombre.text
tiempo = int(self.txt_tiempo.text)
recursos = self.txt_recursos.text.replace(" ", "").split(",")
if '' in recursos:
recursos.remove('')
n_procesador = int(self.txt_procesador.text)
self.sistema.agregar_proceso(nombre, tiempo, recursos, n_procesador, **self.info_nuevo())
self.limpiar()
def update_profile_dropdown(self):
self.load_profile_names()
self.profile_dropdown = DropDown(do_scroll_x=False, size_hint=(1, None), size=(Window.width, Window.height), bar_width=20) #do_scroll_x=False, size_hint=(1, None), size=(Window.width, Window.height), bar_width=20)
for name in self.profile_file_names:
self.button = Button(text=name[:-5], size_hint=(1, None), height=44)
self.button.bind(on_release=self.load_profile)
self.profile_dropdown.add_widget(self.button)
self.select_profile_button.bind(on_release=self.profile_dropdown.open)
def __init__(self, on_release, **kwargs):
self.on_release = on_release
super(ChoicePopup, self).__init__(**kwargs)
self.dropdown = DropDown()
self.choice_input.bind(text=self.make_dropdown, focus=self.on_focus)
self.dropdown.bind(
on_select=lambda instance, x: setattr(self.choice_input, 'text', x)
)
class PlayerPerformanceScreen(Screen):
top_graph = ObjectProperty(None)
item_texture = ObjectProperty(None)
item_drop_btn = ObjectProperty(None)
_item_dropdown = None
def _item_selected(self, local_item_name):
# convert local to key name
try:
item = [k for k,v in dotalocal.item.iteritems() if v == local_item_name][0]
except IndexError:
log.error('_item_selected: Invalid item name {}'.format(local_item_name))
return
self.item_drop_btn.text = local_item_name
self.item_texture = pas_agg.create_item_graph(squeeze.my_id, item)
def _init_item_dropdown(self):
self._item_dropdown = DropDown()
for item_name in sorted(dotalocal.item.itervalues()):
btn = Button(text=item_name, size_hint_y=None, height=32)
btn.bind(on_release=lambda btn: self._item_dropdown.select(btn.text))
self._item_dropdown.add_widget(btn)
self.item_drop_btn.bind(on_release=self._item_dropdown.open)
self._item_dropdown.bind(on_select=lambda inst, x: self._item_selected(x))
def load_replays(self, replay_list):
if not self._item_dropdown:
self._init_item_dropdown()
pas_agg.d2rp_list = []
for replay_id in replay_list:
# skip replays the player did not play in
player = squeeze.player_from_replay(squeeze.my_id, replay_id)
if player is None:
continue
squeeze.dump_demo(replay_id)
match = squeeze.replay(replay_id)
d2rp = D2RP(squeeze.fs_replay_path(replay_id))
pas_agg.d2rp_list.append(d2rp)
self.top_graph.texture = pas_agg.create_cs_graph(squeeze.my_id)
def __init__(self, sistema): Popup.__init__(self) self.sistema = sistema self.lista_recursos = DropDown() self.btn_lista.bind(on_release=self.lista_recursos.open) self.lista_recursos.bind(on_select=self.usar_recurso)
def __init__(self,**kwargs):
super (ScreenMain,self).__init__(**kwargs)
self.dropdown = DropDown()
self.messages_grid = self.ids.messages_grid
self.child_id = 0
self.msg_id =10
Clock.schedule_once(self.prepare, 0)
def _init_item_dropdown(self):
self._item_dropdown = DropDown()
for item_name in sorted(dotalocal.item.itervalues()):
btn = Button(text=item_name, size_hint_y=None, height=32)
btn.bind(on_release=lambda btn: self._item_dropdown.select(btn.text))
self._item_dropdown.add_widget(btn)
self.item_drop_btn.bind(on_release=self._item_dropdown.open)
self._item_dropdown.bind(on_select=lambda inst, x: self._item_selected(x))
def __setup_player_dropdown(self):
self.dropdown_player = DropDown()
self.dropdown_player.bind(on_select=self.on_player_select)
players = sorted(PlayerData.get_players(), key=lambda player: player['name'])
for player in players:
btn = PlayerButton(data=player)
btn.bind(on_release=lambda btn: self.dropdown_player.select(btn.data))
self.dropdown_player.add_widget(btn)
def init_type_dropdown(self):
d = DropDown()
action_types = ['say', 'listen', 'play']
for action_type in action_types:
b = Button(text=action_type, size_hint_y=None, height=dp(30))
def action_select_callback(button):
d.select(button.text)
# reset parameters when changing action type
if self.action_type != button.text:
self.parameters = None
self.action_type = button.text
b.bind(on_release=action_select_callback)
d.add_widget(b)
d.bind(on_select=\
lambda instance, text: setattr(self.type_button_wid, 'text', text))
self.type_button_wid.bind(on_release=d.open)
def Initialize(self, path):
self.sample, self.contents, self.line_nos = ParseData(path)
platforms = DropDown()
for platform in sorted(self.contents.itervalues().next().keys()):
btn = Button(text = platform, size_hint_y = None, height = 33)
btn.bind(on_release = lambda btn: self.SetPlatform(btn.text, platforms))
platforms.add_widget(btn)
self.plat_list.append(platform)
self.plat_btn.bind(on_release = platforms.open)
platforms.bind(on_select = lambda instance, x: setattr(self.plat_btn, 'text', x))
test_filter = DropDown()
for filter_type in ["None", "Matching", "MatchingPlat", "Matching+NoRes", "MatchingPlat+NoRes"]:
btn = Button(text = filter_type, size_hint_y = None, height = 33)
btn.bind(on_release = lambda btn: self.SetFilter(btn.text, test_filter))
test_filter.add_widget(btn)
self.filter_btn.bind(on_release = test_filter.open)
test_filter.bind(on_select = lambda instance, x: setattr(self.filter_btn, 'text', x))
def build(self):
self.root=Builder.load_string(kv)
self.acilirkutu = DropDown()
for x in ( "Mustafa", "Dilek", "Fatih", "Melike"):
dugme=Button(text=x, size_hint_y=None, height=25)
dugme.bind(on_release=self.secim)
self.acilirkutu.add_widget(dugme)
return self.root
