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)
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 ouvrirMenuAttaque(self): box = BoxLayout(orientation='vertical') self.fenetreAttaque = Popup(title="Attaque") dropdown = DropDown() stats = Label(text='Veuillez selectionner une cible') confirm = Button(text="Voir") attaquer = Button(text="Attaquer") for key in store: btn = Button(text=store.get(key)['nom'], size_hint_y=None, height=44) btn.bind(on_release=lambda btn: dropdown.select(btn.text)) dropdown.add_widget(btn) mainbutton = Button(text='Cible :', size_hint=(None, None)) mainbutton.bind(on_release=dropdown.open) dropdown.bind(on_select=lambda instance, x: setattr(mainbutton, 'text', x)) box2 = BoxLayout(orientation='horizontal') fermer = Button(text="Fermer", font_size=20) box.add_widget(mainbutton) box.add_widget(stats) box2.add_widget(confirm) box2.add_widget(attaquer) box.add_widget(box2) box.add_widget(fermer) self.fenetreAttaque.add_widget(box) mainbutton.size_hint=(1,.1) confirm.size_hint=(.1,.1) fermer.size_hint=(1,.1) attaquer.size_hint=(.1,.1) confirm.bind(on_press=lambda x: self.actualise(stats, mainbutton.text)) attaquer.bind(on_press=lambda x: self.attaque(mainbutton.text)) fermer.bind(on_press=self.fenetreAttaque.dismiss) self.fenetreAttaque.open()
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 build(self): self.title = 'Quick-Keys' self.icon = '1479186122476.png' Window.size = (winheight, winwidth) parent = FloatLayout() #parent.size = Window.size for i in range(len(symbols)): #btn[i] = Button(text = symbols[str(i+1)], size_hint = (widspacex, widspacey), pos_hint = widspaces[i]) #btn[i].bind(on_press = callback) #parent.add_widget(btn[i]) popup[i] = Popup(title = 'replace ' + symbols[str(i + 1)] + ' with', content = TextInput(text = symbols[str(i+1)], multiline = False)) #print popup[i].content.text popup[i].bind(on_dismiss = popup_callback) #newSymbol(str(i+1), popup[i].content.text)) btn[i] = addbutton(symbols[str(i+1)], (widspacex, widspacey), widspaces[i], popup[i].open, parent) serports = serial_ports() #print len(serports) port = DropDown() for i in range(len(serports)): dropbtn = Button(text = serports[i], size_hint_y = None, height = 44) dropbtn.bind(on_release = lambda dropbtn: port.select(dropbtn.text)) port.add_widget(dropbtn) portbtn = Button(text = ser.port, size_hint = (2/3, widspacey), pos_hint = {'x' : 0, 'y' : 0}) portbtn.bind(on_release = port.open) port.bind(on_select=lambda instance, x: setattr(portbtn, 'text', x)) parent.add_widget(portbtn) applybtn = addbutton('save', (1/3, widspacey), {'x' : 2/3, 'y' : 0}, callback, parent) #applybtn.bind(on_press = ser #applybtn = Button(text = 'apply', size_hint = (1/3, widspacey), pos_hint = {'x' : 2/3, 'y' : 0}) #applybtn.bind(on_press = callback) #parent.add_widget(applybtn) return parent
def addDetails(*args): print("In procedure to add details") gridlayout = args[0] btn_add = args[1] label = Label(text="Argument Value Type: ",color=(1,0,0,1),font_size=10) label2 = Label(text="Default Argument Parameter: ",color=(1,0,0,1),font_size=10) label3 = Label(text="Default Value",color=(1,0,0,1),font_size=10) textInput = TextInput(id="textInputIDForDefaultArgParameter") textInput2 = TextInput(id="textInputIDForDefaultValue") gridlayout.add_widget(label) btnMain = Button(text="ValueType",id="valueTypeID") gridlayout.add_widget(btnMain) gridlayout.add_widget(label2) gridlayout.add_widget(textInput) gridlayout.add_widget(label3) gridlayout.add_widget(textInput2) kindOfValues = ['ABP','NSR','NER','STR','NBR'] dropdown = DropDown() for eachType in kindOfValues: btn_tmp = Button(text=eachType, size_hint_y=None, height=20) btn_tmp.bind(on_release=lambda btn_tmp: dropdown.select(btn_tmp.text)) dropdown.add_widget(btn_tmp) btnMain.bind(on_release=dropdown.open) dropdown.bind(on_select=lambda instance, x: setattr(btnMain,'text',x)) btn_add.disabled = False
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 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 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 __init__(self,*args,**kwargs): super(MenuScreen, self).__init__(*args, **kwargs) self.drop_down = CustomDropDown() notes_dropdown = ObjectProperty(None) dropdown = DropDown() notes = ['Features', 'Suggestions', 'Abbreviations', 'Miscellaneous'] for note in notes: # 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='%r' % note, size_hint_y=None, height=30) # 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='Usage Notes 2', size_hint=(1, 1)) # 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) #dd_btn.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: setattr(dd_btn, 'text', x)) self.top_layout.add_widget(mainbutton)
def make_dropdown(labels, callback, width = 80, line_height = 30): dropdown = DropDown(auto_width=False, width=width) for name in labels: btn = Button(text=str(name), size_hint_y=None, height=line_height) btn.bind(on_release=lambda btn: dropdown.select(btn.text)) dropdown.add_widget(btn) dropdown.bind(on_select=callback) return dropdown
def comment_pop(instance): """ Creates a Popup to Log Task into timesheet """ con=lite.connect('TimeTracker.db') with con: cur=con.cursor() cur.execute("SELECT DISTINCT TASK FROM Timesheet ORDER BY TASK ") rows = cur.fetchall() task_list=['OTHER'] for row in rows: task_list.append(row[0]) if con: con.close() f=FloatLayout() global popup1 popup1 = Popup(title='Task Desciption', content=f, size_hint=(1.0, 0.6), size=(400, 400)) g=GridLayout(cols=2,row_force_default=True, row_default_height=40, padding=(1,0,1,0)) g.add_widget(Label(text="SELECT TASK ",pos=(400,800))) global task task=TextInput(size_hint=(1,0.75),write_tab=False,text_size=(2,None)) dropdown = DropDown() for index in range(len(rows)+1): btn = Button(text=task_list[index], size_hint_y=None, height=44) btn.bind(on_release=lambda btn: dropdown.select(btn.text)) dropdown.add_widget(btn) global mainbutton mainbutton = Button(text='TASK', size_hint=(None, None),size=(100, 44), pos_hint={'center_x': .5, 'center_y': .5}) mainbutton.bind(on_release=dropdown.open) dropdown.bind(on_select=MyApp.select_task) g.add_widget(mainbutton) g.add_widget(Label(text="ADD TASK",pos=(400,600))) g.add_widget(task) g.add_widget(Label(text="COMMENTS",pos=(400,400))) global comment comment=TextInput(size_hint=(1,0.75),write_tab=False) g.add_widget(comment) global msg msg=Label(text="Please enter the task and comment to save the task \n", pos=(popup1.width-350,popup1.height-200)) comment.bind(on_text= msg.setter("Please enter the task and comment to save the task \n")) btn1=Button(text='SAVE',size_hint=(0.2,0.1),pos=(popup1.width-350, popup1.height-250)) btn1.bind(on_press=MyApp.update_timesheet) btn2=Button(text='CANCEL',size_hint=(0.2,0.1), pos=(popup1.width-50,popup1.height-250)) f.add_widget(msg) f.add_widget(btn1) f.add_widget(btn2) f.add_widget(g) popup1.open() btn2.bind(on_press=popup1.dismiss)
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)
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 __init__(self, **kwargs): super(ApplicationDisplay, self).__init__(**kwargs) self.text= Label (text = str (UID_result)) self.add_widget(self.text) dropdown = DropDown() ApplicationList = ["Gmail","Vault"] for index in ApplicationList: # 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=str(index), 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: dropdown.select(btn.text)) # then add the button inside the dropdown dropdown.add_widget(btn) # create a big main button mainbutton = Button(text='Application Menu', size_hint=(1, None)) # 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)) self.add_widget(mainbutton)
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)
def changeSecurity(self): security = [1, 2, 3, 4, 5] #Create Dropdown dropdown = DropDown() #Fill DropDown for row in range(len(security)): btn = Button(text= str(security[row]), size_hint_y = None, height=44) btn.bind(on_release=lambda btn: dropdown.select(btn.text)) dropdown.add_widget(btn) mainbutton = self.ids.security mainbutton.bind(on_release=dropdown.open) dropdown.bind(on_select=lambda instance, x: setattr(mainbutton, 'text', x))
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, *args, **kwargs): super(topBar, self).__init__(*args, **kwargs) dropdown = DropDown() self.dropdown = dropdown os.chdir("./SavedTMs/") turingMachines = [] for file in glob.glob("*.xml"): turingMachines.append(str(file)) #Check that there is a file to load, if not display "No saved Files" if len(turingMachines) == 0: # the size_hint_y) so the dropdown can calculate the area it needs. btn = Button(text="No Saved Files", size_hint_y=None, height=30) # then add the button inside the dropdown dropdown.add_widget(btn) for tms in turingMachines: # 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' % tms, size_hint_y=None, height=30) # 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='Load Turing Machine', size_hint=(1, 1)) print 'load Turing Machine has been selected' self.mainbutton = mainbutton # 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) #dd_btn.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)) # USE THE BELOW CODE TO CALL METHODS FROM THIS CLASS dropdown.bind(on_select=lambda instance, x: self.printMeth(getattr(x,'text',x))) self.top_layout.add_widget(mainbutton)
def display_verbs(self): dropdown = DropDown() verbs = get_all_verbs(False) for verb in verbs: new_option = ComOption(verb) new_option.bind(on_release=lambda btn: dropdown.select(btn.text)) dropdown.add_widget(new_option) mainbutton = self.ids.verb mainbutton.text = 'Did' mainbutton.bind(on_release=dropdown.open) dropdown.bind(on_select=lambda instance, x: setattr(mainbutton, 'text', x))
def fillSubcategory(self): #Create Dropdown dropdown = DropDown() #Fill Dropdown for index in range(4): btn = Button(text='Value %d' % index, size_hint_y = None, height=44) btn.bind(on_release=lambda btn: dropdown.select(btn.text)) dropdown.add_widget(btn) #Bind new text to original button mainbutton = self.ids.subcatDrop mainbutton.bind(on_release=dropdown.open) dropdown.bind(on_select=lambda instance, x: setattr(mainbutton, 'text', x)) bsdb.close()
def showModes(self, relativeTo): """show the list of modes""" try: dropdown = DropDown(auto_width=True) btn = Button(text='Disabled', markup=True, size_hint_y=None, height='44dp') btn.bind(on_press=lambda btn: dropdown.select(btn.text)) dropdown.add_widget(btn) btn = Button(text='Toggle', markup=True, size_hint_y=None, height='44dp') btn.bind(on_press=lambda btn: dropdown.select(btn.text)) dropdown.add_widget(btn) btn = Button(text='Button', markup=True, size_hint_y=None, height='44dp') btn.bind(on_press=lambda btn: dropdown.select(btn.text)) dropdown.add_widget(btn) btn = Button(text='Analog', markup=True, size_hint_y=None, height='44dp') btn.bind(on_press=lambda btn: dropdown.select(btn.text)) dropdown.add_widget(btn) dropdown.bind(on_select=self.ModeSelected) dropdown.open(relativeTo) except Exception as e: showError(e)
class NoteItem(BoxLayout): def __init__(self, **kwargs): super(NoteItem, self).__init__(**kwargs) self.dropdown = DropDown() def addNoteItem(self, w): """ inventoryitem = Inventarios() inventoryitem.Clave = w.parent.txt_clave.text inventoryitem.Producto = w.parent.txt_producto.text inventoryitem.Existencias = w.parent.txt_existencias.text inventoryitem.Minimo = w.parent.txt_minimo.text inventoryitem.Maximo = w.parent.txt_maximo.text inventoryitem.Precio = w.parent.txt_precio.text inventoryitem.save() """ newitem = NoteItem() w.text = "X" table = app.root.ventas.lst_note table.add_widget(newitem, index=len(table.layout.children)) app.root.ventas.txt_total.text = str(float(app.root.ventas.txt_total.text) + float(w.parent.txt_total.text)) def on_completeproduct(self, w): print w.text if len(w.text) > 2: self.dropdown.clear_widgets() # for item in app.root.inventarios: for item in app.root.inventarios: if w.text.upper() in item.Producto.upper(): but = WhiteButton(text=item.Producto, size_hint_y=None, height=40) but.bind(on_press=self.fillProduct) but.Item = item self.dropdown.add_widget(but) self.dropdown.open(w) def fillProduct(self, w): self.txt_producto.text = w.text self.txt_precio.text = w.Item.Precio if self.txt_cant.text != "": self.txt_total.text = str(float(self.txt_cant.text) * float(self.txt_precio.text)) self.dropdown.dismiss()
def createMenu(self): d = DropDown() for user in users: btn = Button(text=str(user), size_hint_y=None, height=35) btn.bind(on_press=lambda btn: d.select(btn.text)) d.add_widget(btn) self.mainbutton = Button(text="Select User", size_hint=[.4, .05], pos_hint={'x': .3, 'y': .5}) self.mainbutton.bind(on_release=d.open) d.bind(on_select=lambda d, x: setattr(self.mainbutton, 'text', x)) self.add_widget(self.mainbutton)
def on_cinfdata(self, instance, value): """Setup the setup selection page, when the cinfdata ObjectProperty is set (happens only on startup)""" dropdown = DropDown() for setup in self.cinfdata.get_setups(): btn = SetupButton(text='Setup: ' + setup['title'], size_hint_y=None, height=44, setup=setup) btn.bind(on_release=lambda btn: dropdown.select(btn)) dropdown.add_widget(btn) self.mainbutton.bind(on_release=lambda widget: dropdown.open(widget)) dropdown.bind(on_select=self._select)
def fillToteSize(self): bsdb = sqlite3.connect('backstockdb') cursor = bsdb.cursor() sql = "SELECT value FROM miscFields WHERE param = 'toteSize'" #Create Dropdown dropdown = DropDown() #Fill DropDown for row in cursor.execute(sql): btn = Button(text=row[0], size_hint_y = None, height=44) btn.bind(on_release=lambda btn: dropdown.select(btn.text)) dropdown.add_widget(btn) mainbutton = self.ids.toteSize mainbutton.bind(on_release=dropdown.open) dropdown.bind(on_select=lambda instance, x: setattr(mainbutton, 'text', x))
def dropdown(): dropdown = DropDown() for index in range(10): btn = Button(text= "Value %d" % index, size_hint_y= None, height=44) btn.bind(on_release=lambda btn: dropdown.select(btn.text)) dropdown.add_widget(btn) mainbutton = Button(text='hello', size_hint=(None,None)) mainbutton.bind(on_release=dropdown.open) dropdown.bind(on_select=lambda instance, x: setattr(mainbutton,'text',x)) return dropdown
def on_enter(self, *args): super(PanelScreen,self).on_enter(*args) self.entered=True self.selectedCat=None js=JsonStore("titles.json") titles=js.get("titles") drop=DropDown() for t in titles["all"]: btn=MiButton(text=titles["all"][t],size_hint_y=None,height=50,key=t) btn.bind(on_release=lambda btn:drop.select(btn)) drop.add_widget(btn) def set_select(inst,btn): self.drp.text=btn.text self.selectedCat=btn.key drop.bind(on_select=set_select) self.drp.bind(on_release=drop.open)
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
class MainScreen(GridLayout): def __init__(self, **kwargs): self.cols = 2 self.currentMode = 'week' self.calendar = Calendar(self.height-60) super(MainScreen, self).__init__(**kwargs) self.bind(height=self.drawCalendar) self.bind(width=self.drawCalendar) self.drawCalendar() def openScreenButtons(self, instance): if self.openSelectScreen == False: self.openSelectScreen = True self.selectScreen.open(instance) else: self.openSelectScreen = False self.selectScreen.dismiss() def changeSelectText(self, value): self.screenMode = value if value == 'day': self.calendar.setMode('day') self.selectScreenButton.text = CalendarUtils.returnCurrentDate() else: self.calendar.setMode('week') self.selectScreenButton.text = CalendarUtils.returnCurrentMonth() def changeCurrentScreen(self, instance): self.openSelectScreen = False self.selectScreen.dismiss() if instance.text == 'Day mode': self.currentMode = 'day' self.calendar.setMode('day') self.changeSelectText('day') elif instance.text == 'Week mode': self.currentMode = 'week' self.calendar.setMode('week') self.changeSelectText('week') elif instance.text == 'Add activity': mainScreen.current = 'Activities Screen' elif instance.text == 'Help Screen': mainScreen.current = instance.text else: raise ValueError def drawCalendar(self, *l): self.clear_widgets() #Main title design self.leftScreen = GridLayout(rows=2, size_hint_x=None, width=int(3*self.width//5)) self.mainTitle = BoxLayout(background_color=(9, 9, 9, 1), size_hint_y=None, height=60) self.selectScreen = DropDown() self.openSelectScreen = False for option in ['Day mode', 'Week mode', 'Add activity', 'Help Screen']: tempButton = Button(text=option, size_hint_y=None, height=60) tempButton.bind(on_release=self.changeCurrentScreen) self.selectScreen.add_widget(tempButton) self.selectScreenButton = Button(text='Screens', size_hint=(None, None), font_size=16, height=60, width=300) self.selectScreenButton.bind(on_release=self.openScreenButtons) self.changeSelectText(self.currentMode) self.mainTitle.add_widget(self.selectScreenButton) #Initialize Main Calendar self.calendar = Calendar(self.height-60) self.calendar.setMode(self.currentMode) self.mainCalendar = ScrollView() self.mainCalendar.add_widget(self.calendar) #Add the main title and the calendar to the screen self.leftScreen.add_widget(self.mainTitle) self.leftScreen.add_widget(self.mainCalendar) self.add_widget(self.leftScreen) #Initialize homeworks and projects lists self.rightScreen = GridLayout(cols=1) #Change right up screen values Homeworks self.rightScreen.add_widget(Button(text='Homeworks/Projects', font_size=16, size_hint_y=None, height=60)) self.proHome = ScrollView() self.proHomeContent = ProHomeContent(ProHomeContent(self.height-60)) self.proHome.add_widget(self.proHomeContent) self.rightScreen.add_widget(self.proHome) self.add_widget(self.rightScreen)
def build(self): # Basic Window Stuff Window.size = (500, 750) self.icon = "dog.png" self.title = "Super Epic Program" self.my_font = "ComicSansMSBold.ttf" # Keybinds to close, encrypt, decrypt, etc.. Window.bind(on_keyboard=self.on_keyboard) # bind our handler # Just declaring the bool for later use self.is_encrypt = True # button colors self.green = [0, 1, 0, 1] self.blue = [0, 0, 1, 1] self.black = [0, 0, 0, 0] self.white = [1, 1, 1, 1] # layouts in order superBox = BoxLayout(orientation='vertical') HB = BoxLayout(orientation='horizontal', size_hint=(1, 0.3), padding=2) VB = BoxLayout(orientation='vertical') HB2 = BoxLayout(padding=10, spacing=20, orientation='horizontal', size_hint=(1, 0.5)) VB2 = BoxLayout(orientation='vertical') VB3 = BoxLayout(orientation='vertical', size_hint=(1, 0.3)) # First split the top into 4 horizontaly # put empty label at left and right so middle can be for title and input shifts # App title self.title_label = Label(text="SICK LAD", font_name=self.my_font, font_size=20) HB.add_widget(Label()) HB.add_widget(self.title_label) # Create dropdown menu # dont need self for the delow screw what everyone says dropdown = DropDown() # Items in the menu shifts = [ 69420, 12345, 98765, 239234, 34343, 'custom number', 'custom word key' ] for item in shifts: btn = Button(text='%r' % item, size_hint_y=None, height=30) btn.bind(on_release=lambda btn: dropdown.select(btn.text)) dropdown.add_widget(btn) # Need self for the button so the other functions can access its text self.change_shift_button = Button(text='69420', size_hint=(1, 1), font_name=self.my_font, font_size=20) self.change_shift_button.bind(on_release=dropdown.open) dropdown.bind(on_select=lambda instance, x: setattr( self.change_shift_button, 'text', x)) # Add that button HB.add_widget(self.change_shift_button) HB.add_widget(Label()) # The input text self.input_text = TextInput(hint_text="Enter message here", multiline=True) VB.add_widget(self.input_text) # Buttons self.encrypt_btn = Button(text="Encrypt", background_color=self.green, font_size=25, size_hint=(1, 1)) self.decrypt_btn = Button(text="Decrypt", background_color=self.blue, font_size=25, size_hint=(1, 1)) # HB represents the horizontal boxlayout orientation self.encrypt_btn.bind(on_press=self.Crypt) HB2.add_widget(self.encrypt_btn) # there is probably a more efficient way but im used to using booleans to switch things self.decrypt_btn.bind(on_press=self.make_decrypt) self.decrypt_btn.bind(on_press=self.Crypt) HB2.add_widget(self.decrypt_btn) self.output_text = TextInput(hint_text="Output", multiline=True) VB2.add_widget(self.output_text) VB3.add_widget( Label( text= "No joke 100% legit best encryption software on the web (Don't check)" )) # superbox used to again align the orented widgets # this is nesting the layouts in another main layout superBox.add_widget(HB) #title superBox.add_widget(VB) #input superBox.add_widget(HB2) #buttons superBox.add_widget(VB2) #output superBox.add_widget(VB3) #bottom return superBox
class GeneScreen(Screen): 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) def load_genes(self, *args): """Called when drop down is opened""" self.dropdown.clear_widgets() # Clear any packaged buttons del self.dd_btns[:] # Clear drop down button list # Grab relevant genes genes = global_data.groups[global_data.active_group] for gene in genes: btn = CustomButton(text=gene.name, size_hint_y=None, height=self.height/9) btn.bind(on_release=lambda button: self.dropdown.select(button.text)) self.dropdown.add_widget(btn) # Add button to menu self.dd_btns.append(btn) # Store button in delety-list self.dropdown.open(args[0]) def set_gene(self, *args): # Storing which group is selected for use in gene screen global_data.active_gene = args[1] # args[1] - Name of gene def delete(self, *args): def delete_gene(): group = global_data.active_group # Get active group gene = global_data.active_gene # Get active gene # Iterate through genes because we need to check the name of each for index, _gene in enumerate(global_data.groups[group]): if _gene.name == gene: # Delete the gene del global_data.groups[group][index] # Remove from drop down self.dropdown.remove_widget(self.dd_btns[index]) log(f"Gene {gene} deleted.") break group_mngr.save_groups(global_data.groups) # Save the groups global_data.active_gene = '' # No active gene self.dropdown.select('Select a gene') popup.dismiss() if global_data.active_gene != '': # *Deletion Confirmation------------------------------------------- content = BoxLayout(orientation='vertical') content.add_widget(Label(text=f"Delete " f"{global_data.active_gene}?")) # *Confirmation Buttons-------------------------------------------- options = BoxLayout(orientation='horizontal', spacing=2) confirm_btn = CustomButton(text="Delete", # Confirm button size_hint=(.3, .3)) cancel_btn = CustomButton(text="Cancel", # Cancel button size_hint=(.3, .3)) # Add Widgets to container options.add_widget(confirm_btn) options.add_widget(cancel_btn) content.add_widget(options) # *Popup Settings-------------------------------------------------- popup = Popup(title="Delete?", content=content, size_hint=(None, None), size=(400, 400), separator_color=[1., 1., 1., 1.]) confirm_btn.bind(on_press=delete_gene) cancel_btn.bind(on_press=popup.dismiss) popup.open() def switch_screen(*args): if args[1].text == "New": sm.current = 'editgene' elif args[1].text == "Edit": if global_data.active_gene != '': sm.current = 'editgene' def reset_menu(self, *args): # Need to make sure the menu text is defaulted when screen is entered self.dropdown.select('Select a gene') global_data.active_gene = ''
def build(self): # ici on creer le floatlayout parent = FloatLayout() self.painter = MyPaintWidget() self.painter.build() # Bouton clear: clearbtn = Button(text='Clear', font_size=35, size_hint=(0.17, 0.1), pos_hint={'x': .652, 'y': 0.9}) clearbtn.bind(on_press=self.clear_canvas) # Listes : self.liste_trait = [1, 5, 10, 15, 20, 40, 50] self.liste_trait_nom = ["0", "5", "10", "15", "20", '40', '50'] self.liste_taille_nom = ["1", '2', '3', '4', '5', '6', '7', '8', '9', '10'] self.liste_taille = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] self.liste_couleurs = ["Jaune", "Rouge", "Vert", "Bleu", "Violet", "Noir", "Bleu Clair", ] self.liste_RGBA = [[1, 0.8, 0, 1], [1, 0, 0, 1], [0, 1, 0, 1], [0, 0, 1, 1], [0.7, 0, 0.7, 1], [0, 0, 0, 1], [0, 1, 1, 1]] self.liste_couleur = ["Jaune", "Rouge", "Vert", "Bleu", "Violet", "Noir", "Bleu Clair", "Blanc"] self.liste_RGB = [[1, 0.8, 0, 1], [1, 0, 0, 1], [0, 1, 0, 1], [0, 0, 1, 1], [0.7, 0, 0.7, 1], [0, 0, 0, 1], [0, 1, 1, 1], [1, 1, 1, 1]] self.Liste_Boutons_Fond = [] self.Liste_Boutons_couleurs = [] self.Liste_Boutons_tailles = [] self.Liste_Boutons_traits = [] # creation des dropdown: self.Bouton_couleur = Button(text='Couleur', font_size=33, size_hint=(0.18, 0.1), pos_hint={'x': .0, 'y': 0.9}, background_color=[0.9, 0.9, 0.9, 1]) dropdown = DropDown() for index in range(0, len(self.liste_couleurs)): self.Liste_Boutons_couleurs.append(Button()) self.Liste_Boutons_couleurs[index].text = self.liste_couleurs[index] self.Liste_Boutons_couleurs[index].size_hint_y = None self.Liste_Boutons_couleurs[index].height = 60 self.Liste_Boutons_couleurs[index].id = str(index) self.Liste_Boutons_couleurs[index].font_size = 32 self.Liste_Boutons_couleurs[index].bind(on_release=lambda btn: dropdown.select(btn.text)) self.Liste_Boutons_couleurs[index].bind(on_press=self.Couleur) dropdown.add_widget(self.Liste_Boutons_couleurs[index]) self.Bouton_couleur.bind(on_release=dropdown.open) dropdown.bind(on_select=lambda instance, x: setattr(self.Bouton_couleur, 'text', x)) self.Liste_Boutons_couleurs[0].color = self.liste_RGBA[0] self.Liste_Boutons_couleurs[1].color = self.liste_RGBA[1] self.Liste_Boutons_couleurs[2].color = self.liste_RGBA[2] self.Liste_Boutons_couleurs[3].color = self.liste_RGBA[3] self.Liste_Boutons_couleurs[4].color = self.liste_RGBA[4] self.Liste_Boutons_couleurs[5].color = self.liste_RGBA[5] self.Liste_Boutons_couleurs[6].color = self.liste_RGBA[6] self.Bouton_taille = Button(text='Taille', font_size=35, size_hint=(0.15, 0.1), pos_hint={'x': .178, 'y': 0.9}, background_color=[0.9, 0.9, 0.9, 1]) drop_down = DropDown() for index in range(0, len(self.liste_taille_nom)): self.Liste_Boutons_tailles.append(Button()) self.Liste_Boutons_tailles[index].text = self.liste_taille_nom[index] self.Liste_Boutons_tailles[index].size_hint_y = None self.Liste_Boutons_tailles[index].height = 45 self.Liste_Boutons_tailles[index].id = str(index) self.Liste_Boutons_tailles[index].bind(on_release=lambda btn: drop_down.select(btn.text)) self.Liste_Boutons_tailles[index].bind(on_press=self.Taille) self.Liste_Boutons_tailles[index].font_size = 30 drop_down.add_widget(self.Liste_Boutons_tailles[index]) self.Bouton_taille.bind(on_release=drop_down.open) drop_down.bind(on_select=lambda instance, x: setattr(self.Bouton_taille, 'text', x)) self.Bouton_trait = Button(text='Profondeur', font_size=23, size_hint=(0.15, 0.1), pos_hint={'x': .326, 'y': 0.9}, background_color=[0.9, 0.9, 0.9, 1]) dropdown2 = DropDown() for index in range(0, len(self.liste_trait_nom)): self.Liste_Boutons_traits.append(Button()) self.Liste_Boutons_traits[index].text = self.liste_trait_nom[index] self.Liste_Boutons_traits[index].size_hint_y = None self.Liste_Boutons_traits[index].height = 50 self.Liste_Boutons_traits[index].id = str(index) self.Liste_Boutons_traits[index].bind(on_release=lambda btn: dropdown2.select(btn.text)) self.Liste_Boutons_traits[index].bind(on_press=self.Trait) self.Liste_Boutons_traits[index].font_size = 30 dropdown2.add_widget(self.Liste_Boutons_traits[index]) self.Bouton_trait.bind(on_release=dropdown2.open) dropdown2.bind(on_select=lambda instance, x: setattr(self.Bouton_trait, 'text', x)) self.Bouton_ScreenShot = Button(text='ScreenShot', font_size=28, size_hint=(0.18, 0.1), pos_hint={'x': .474, 'y': 0.9}, background_color=[0.7, 0.7, 0.7, 1]) self.Bouton_ScreenShot.bind(on_press=self.photo) self.Bouton_Fond = Button(text='Couleur_Fond', font_size=23, size_hint=(0.18, 0.1), pos_hint={'x': .82, 'y': 0.9}, background_color=[0.9, 0.9, 0.9, 1]) dropdown3 = DropDown() for index in range(0, len(self.liste_couleur)): self.Liste_Boutons_Fond.append(Button()) self.Liste_Boutons_Fond[index].text = self.liste_couleur[index] self.Liste_Boutons_Fond[index].size_hint_y = None self.Liste_Boutons_Fond[index].height = 55 self.Liste_Boutons_Fond[index].id = str(index) self.Liste_Boutons_Fond[index].bind(on_release=lambda btn: dropdown3.select(btn.text)) self.Liste_Boutons_Fond[index].bind(on_press=self.Fonds) self.Liste_Boutons_Fond[index].font_size = 32 dropdown3.add_widget(self.Liste_Boutons_Fond[index]) self.Bouton_Fond.bind(on_release=dropdown3.open) dropdown3.bind(on_select=lambda instance, x: setattr(self.Bouton_Fond, 'text', x)) self.Liste_Boutons_Fond[0].color = self.liste_RGB[0] self.Liste_Boutons_Fond[1].color = self.liste_RGB[1] self.Liste_Boutons_Fond[2].color = self.liste_RGB[2] self.Liste_Boutons_Fond[3].color = self.liste_RGB[3] self.Liste_Boutons_Fond[4].color = self.liste_RGB[4] self.Liste_Boutons_Fond[5].color = self.liste_RGB[5] self.Liste_Boutons_Fond[6].color = self.liste_RGB[6] self.Liste_Boutons_Fond[7].color = self.liste_RGB[7] # ici on integre tout au widget parent.add_widget(self.painter) parent.add_widget(self.Bouton_Fond) parent.add_widget(self.Bouton_taille) parent.add_widget(self.Bouton_couleur) parent.add_widget(self.Bouton_trait) parent.add_widget(self.Bouton_ScreenShot) parent.add_widget(clearbtn) self.size = Window.size self.Fond_Couleur = [1, 1, 1, 1] with parent.canvas.before: self.Fond_couleurs = Color(self.Fond_Couleur) self.rectangle = Rectangle(size=self.size) return parent
class OptionsLay(Screen): """ layout zawierający możliwość zmainy opcji, czyli ścieżki pobierania narazie """ save_btn = ObjectProperty(None) dir_input = ObjectProperty(None) channel_input = ObjectProperty(None) change_file_type_dropdown_main_btn = ObjectProperty(None) def __init__(self, layout_manager, **kwargs): super(OptionsLay, self).__init__(**kwargs) self.maked_dropdown = False self.layout_manager = layout_manager def go_return(self): self.layout_manager.window_manager.transition.direction = 'down' self.layout_manager.window_manager.current = 'menu_lay' def save_options(self): """ zapisuje opcje, jeśli zmieniono kanał to czyści załadowne opcje i blokuje pobieranie, aby uniknąć błędów """ options_dict = JsonOperations.load_json('../data/config.json') options_dict['save_path'] = self.dir_input.text options_dict[ 'file_type'] = self.change_file_type_dropdown_main_btn.text if self.parse_yt_channel_name(): self.format_channel_input() self.check_channel_options(self.channel_input.text) if options_dict['channel'] != self.channel_input.text: self.block_on_change_channel() options_dict['channel'] = self.channel_input.text self.save_btn.text = 'Saved' else: self.save_btn.text = 'Bad channel' JsonOperations.save_json(options_dict, '../data/config.json') Clock.schedule_once(self.change_text_save_btn, 0.8) def change_text_save_btn(self, _): self.save_btn.text = 'Save' def parse_yt_channel_name(self): """ za pomocą zewnętrznej funkcji sprawdza czy podany adres jest poprwany, czyli czy jest po nazwie lub id """ if parse_yt_channel_name(self.channel_input.text): return True return False def format_channel_input(self): """ odcina niepotrzebną końcówkę w adresie """ txt = self.channel_input.text if len(txt.split("/")) != 5: self.channel_input.text = "/".join(txt.split("/")[:5]) @staticmethod def check_channel_options(new_channel): """ jeśli nowego kanału nie ma w bazie ostanich utworów to go dodaje """ last_track_dict = JsonOperations.load_json('../data/last_track.json') if new_channel not in last_track_dict.keys(): last_track_dict[new_channel] = '' JsonOperations.save_json(last_track_dict, '../data/last_track.json') def block_on_change_channel(self): """ czyści liste utworów w layoucie i blokuje pobieranie przy zmianie kanału w opcjach """ self.layout_manager.inst_main_chill_layout.clear_scroll() self.layout_manager.inst_main_chill_layout.un_or_block_btn( list_btn_to_block=[ self.layout_manager.inst_main_chill_layout.new_download_btn, self.layout_manager.inst_main_chill_layout.select_songs_btn ], block=True) def make_options(self): conf_dict = DownloaderOperations.get_all_config() self.dir_input.text = conf_dict['save_path'] self.channel_input.text = conf_dict['channel'] self.change_file_type_dropdown_main_btn.text = conf_dict['file_type'] if not self.maked_dropdown: self.make_dropdown() def make_dropdown(self): self.dropdown = DropDown() self.dropdown.dismiss_on_select = False for ft_name in SUPPORTED_FORMAT_TYPES: dd_btn = Button( text=ft_name, size_hint_y=None, height=50, background_normal='', border=(16, 16, 16, 16), background_color=[0.81640625, 0.3125, 0.43359375, 1]) dd_btn.bind(on_release=self.release_dropdown_button) self.dropdown.add_widget(dd_btn) self.change_file_type_dropdown_main_btn.bind( on_release=self.dropdown.open) self.dropdown.bind(on_select=lambda instance, dd_main_text: setattr( self.change_file_type_dropdown_main_btn, 'text', dd_main_text)) self.maked_dropdown = True def release_dropdown_button(self, instance): self.dropdown.select(instance.text) self.dropdown.dismiss()
class DropDownController(BaseController): """A drop down type controller. The value is selected from a drop down list. """ option_list = StringProperty('') options = ListProperty([]) grey_on_zero = BooleanProperty(False) def sub_setup(self): """Creates the drop down list for the controller.""" self.dropdown = DropDown() self.extra_options = [] self._add_options_from_kivy() self.main_button = [ widget for widget in self.children if isinstance(widget, Button) ][0] for option in self.options: btn = Button(text=option, size_hint_y=None, height=30) btn.bind(on_release=lambda btn: self.dropdown.select(btn.text)) self.dropdown.add_widget(btn) self.main_button.bind(on_release=self.dropdown.open) self.dropdown.bind(on_select=self._select_option) self.dropdown.bind(on_dismiss=self._on_dismiss) def _on_dismiss(self, button): """display selected option if dropdwon is dismissed""" self.display_selected() def _select_option(self, i, option): """Sets controller value to chosen option.""" if option not in [o.name for o in self.extra_options]: self.value = self.options.index(option) else: for extra_option in self.extra_options: if option == extra_option.name: if extra_option.value: self.value = extra_option.value else: try: self.value = extra_option.saved_value except AttributeError: self.value = extra_option.minimum def add_options(self, options): """sets list of options on the dropdown""" self.options = options def _add_options_from_kivy(self): """adds any extra options from kivy file""" for child in self.children: if type(child) == Option: self.extra_options.append(child) self.options.append(child.name) def display_selected(self): """Displays chosen option.""" self.main_button.text = 'Off' self.main_button.state = 'normal' list_options = len(self.options) - len(self.extra_options) if list_options and 0 <= self.value < list_options: self.main_button.text = self.options[self.value] self.main_button.state = 'down' else: for option in self.extra_options: if option.value: if self.value == option.value: self.main_button.text = option.name self.main_button.state = 'down' break elif option.minimum <= self.value <= option.maximum: self.main_button.text = option.name self.main_button.state = 'down' option.saved_value = self.value break if self.main_button.text == 'Off'\ or (self.grey_on_zero and not self.value): self.main_button.state = 'normal'
class DropDownInput(TextInput): def __init__(self, preload=None, preload_attr=None, preload_clean=True, **kwargs): self.multiline = False self.drop_down = DropDown() self.drop_down.bind(on_select=self.on_select) self.bind(on_text_validate=self.add_text) self.preload = preload self.preload_attr = preload_attr self.preload_clean = preload_clean self.not_preloaded = set() super(DropDownInput, self).__init__(**kwargs) self.add_widget(self.drop_down) def add_text(self, *args): if args[0].text not in [ btn.text for btn in self.drop_down.children[0].children if hasattr(btn, "text") ]: btn = Button(text=args[0].text, size_hint_y=None, height=44) self.drop_down.add_widget(btn) btn.bind(on_release=lambda btn: self.drop_down.select(btn.text)) if "preload" not in args: self.not_preloaded.add(btn) def on_select(self, *args): self.text = args[1] if args[1] not in [ btn.text for btn in self.drop_down.children[0].children if hasattr(btn, "text") ]: self.drop_down.append(Button(text=args[1])) # call on_text_validate after selection # to avoid having to select textinput and press enter self.dispatch("on_text_validate") def on_touch_down(self, touch): preloaded = set() if self.preload: for thing in self.preload: if self.preload_attr: # use operator to allow dot access of attributes thing_string = str( operator.attrgetter(self.preload_attr)(thing)) else: thing_string = str(thing) self.add_text(Button(text=thing_string), "preload") preloaded.add(thing_string) # preload_clean removes entries that # are not in the preload source anymore if self.preload_clean is True: added_through_widget = [ btn.text for btn in self.not_preloaded if hasattr(btn, "text") ] for btn in self.drop_down.children[0].children: try: if (btn.text not in preloaded and btn.text not in added_through_widget): self.drop_down.remove_widget(btn) except Exception as ex: pass return super(DropDownInput, self).on_touch_down(touch) def on_touch_up(self, touch): if touch.grab_current == self: self.drop_down.open(self) return super(DropDownInput, self).on_touch_up(touch)
class KivySQLiteApp(App): 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 newTableForm(self): popup=newTableForm(title=_("Create New Table"), me=self) popup.open() def showError(self, text): content=Label(text=text, markup=True) popup = Popup(title=_('Warning !'), content=content) popup.size_hint = (0.7,0.7) popup.open() def fileOpenDialog(self): form = fileOpenForm() form.open() def openDB(self, db_select): self.closeDB() try: self.conn = lite.connect(db_select.selection[0]) except: self.showError(_("Error open db")) return self.cursor = self.conn.cursor() self.update_tables_tree() self.root.ids.new_table_action.disabled=False self.root.ids.delete_table_action.disabled=False def update_tables_tree(self): for node in self.root.ids.table_tree.iterate_all_nodes(): self.root.ids.table_tree.remove_node(node) self.table_dropdown = DropDown() if self.conn: for typ in ('table','view'): self.cursor.execute("SELECT name FROM sqlite_master WHERE type = '%s'" % typ) result=self.cursor.fetchall() if result: tvlabeltext='{0} ({1})'.format( _(typ.title()+'s'), len(result) ) tvlabel=TreeViewLabel(text=tvlabeltext) parent_node=self.root.ids.table_tree.add_node(tvlabel) for tb in result: tvlabel=TreeViewLabel(text=tb[0], markup=True) tvlabel.tbtype=typ tvlabel.tbname=tb[0] tb_node=self.root.ids.table_tree.add_node(tvlabel, parent_node) self.cursor.execute('PRAGMA TABLE_INFO(`%s`)' % tb[0]) #populate dropdown list in browse data tab. if not tb[0]=='sqlite_sequence': btn = Button(text=tb[0], size_hint_y=None, height=20) self.table_dropdown.add_widget(btn) btn.bind(on_release=lambda btn: self.table_dropdown.select(btn.text)) for field in self.cursor.fetchall(): tvlabeltext='[b]{0}[/b] {1}'.format( field[1], field[2] ) tvlabel=TreeViewLabel(text=tvlabeltext, markup=True) self.root.ids.table_tree.add_node(tvlabel, tb_node) self.table_dropdown.bind(on_select=self.set_browse_data_main_button_text) def set_browse_data_main_button_text(self, instance, x): self.root.ids.browse_data_main_button.text=x self.update_data_display_grid(x) def update_data_display_grid(self, table=None): for cx in self.root.ids.data_display_grid.children[:]: self.root.ids.data_display_grid.remove_widget(cx) if table: self.cursor.execute("SELECT rowid, * FROM `%s`" % table) self.root.ids.data_display_grid.cols=len(self.cursor.description)-1 for cn in self.cursor.description[1:]: self.root.ids.data_display_grid.add_widget(Label(text="[b]%s[/b]" % cn[0], markup=True, size_hint=( None, None))) result=self.cursor.fetchmany(20) self.root.ids.data_display_grid.bind(minimum_width=self.root.ids.data_display_grid.setter('width')) for i, r in enumerate(result): for j,c in enumerate(r[1:]): t=TextInput(text=str(c),size_hint= (None, None), size=(200,30), multiline=False) t.tablename=table t.rowid=r[0] t.fieldname=self.cursor.description[j+1][0] t.bind(on_text_validate=self.metin) self.root.ids.data_display_grid.add_widget(t) def metin(self, textinput): self.cursor.execute('UPDATE `%s` SET `%s`="%s" WHERE rowid=%d' % (textinput.tablename, textinput.fieldname, textinput.text,textinput.rowid)) self.conn.commit() def deleteTableDialog(self): tb=self.root.ids.table_tree.selected_node if hasattr(tb,'tbtype'): form = ConfirmPopup(text=_("All data in the table you selected will be deleted!\n Are you sure you want to delete table [b]%s[/b]?") % tb.text) form.bind(on_answer=self.delete_table) form.open() def closeDB(self): if self.conn: self.conn.close() self.conn=None self.update_tables_tree() self.root.ids.delete_table_action.disabled=True self.root.ids.new_table_action.disabled=True def tree_view_expanded(self): pass def delete_table(self, instance, answer): tb=self.root.ids.table_tree.selected_node if hasattr(tb,'tbtype'): if answer=='yes': try: self.cursor.execute('DROP TABLE `%s`' % tb.tbname) except Exception as error: self.showError(_("An error occurred while droping table.\nThe message returned by sqlite engine is:")+"\n"+str(error)) self.update_tables_tree() instance.dismiss() def set_language(self,selectedLanguage): self.t = gettext.translation('kivysqlite', 'language', languages=[selectedLanguage], fallback=True) def get_text(self, *args): return self.t.ugettext(*args)
def build(self): def SecuritySwitcher(option): print(option) SecurityScreen = Screen(name='security') SecurityLayout = BoxLayout(orientation='horizontal') GridLayout(cols=2, rows=5, size_hint_y=None, height=400, row_force_default=True, col_force_default=True, col_default_width=350, row_default_height=45, pos=(75, -90)) SecurityMethod = Label(text="Security Method", color=Black, font_size=25, font_name=DefaultFont, halign='left', disabled=False) SecurityMethodDropDown = DropDown() FingerprintOpButton = Button(text="Fingerprint", color=Black, font_size=40, font_name=DefaultFont, size_hint_y=None, height=10, background_color=Black) FingerprintOpButton.bind(on_press=lambda: SecurityMethodDropDown. select(FingerprintOpButton.text)) PINOpButton = Button(text="PIN", color=White, font_size=40, font_name=DefaultFont, size_hint_y=None, height=10, background_color=Black) PINOpButton.bind( on_press=lambda: SecurityMethodDropDown.select(PINOpButton.text)) PasswordOpButton = Button(text="Password", color=Black, size_hint_y=None, height=10) PINOpButton.bind(on_press=lambda: SecurityMethodDropDown.select( PasswordOpButton.text)) MasterButton = Button(text="Options", size=(30, 30), pos=(0, 0)) MasterButton.bind(on_press=SecurityMethodDropDown.open) SecurityMethodDropDown.add_widget(FingerprintOpButton) SecurityMethodDropDown.add_widget(PINOpButton) SecurityMethodDropDown.add_widget(PasswordOpButton) #SecurityLayout.add_widget(SecurityMethod) SecurityLayout.add_widget(MasterButton) SecurityScreen.add_widget(SecurityLayout) return SecurityScreen
class MainScreen(FloatLayout): def __init__(self, **kwargs): super(MainScreen, self).__init__(**kwargs) self.dropdown = DropDown() self.thread = None self.started = False self.testing_module = '' self.module = { '1': 'Core Module R2.2', '2': 'Core Module R2.3', '3': 'Core Module NR', '4': 'Climate Module', '5': 'PIR Module', '6': 'Button Module', '7': 'LCD Module', '8': 'CO2 Module', '9': 'GPS Module', '10': 'Sensor Module', '11': 'Relay Module', '12': 'Encoder Module', '13': 'Power Module', '14': 'LoRa Module', '15': 'Sigfox Module', '16': '1-Wire Module', '17': 'Infra Grid Module', '18': 'Battery Module', '19': 'Mini Battery Module', '20': 'Temperature Tag', '21': 'Humidity Tag', '22': 'Barometer Tag', '23': 'Lux Meter Tag', '24': 'NFC Tag', '25': 'VOC Tag', '26': 'VOC-LP Tag' } self.testing_sequence = { 'Core Module R2.2': 'CoreModuleR22', 'Core Module R2.3': 'CoreModuleR23', 'Core Module NR': 'CoreModuleNR', 'Climate Module': 'ClimateModule', 'PIR Module': 'PIRModule', 'Button Module': 'ButtonModule', 'LCD Module': 'LCDModule', 'CO2 Module': 'CO2Module', 'GPS Module': 'GPSModule', 'Sensor Module': 'SensorModule', 'Relay Module': 'RelayModule', 'Encoder Module': 'EncoderModule', 'Power Module': 'PowerModule', 'LoRa Module': 'LoRaModule', 'Sigfox Module': 'SigfoxModule', '1-Wire Module': 'OneWireModule', 'Infra Grid Module': 'InfraGridModule', 'Battery Module': 'BatteryModule', 'Mini Battery Module': 'MiniBatteryModule', 'Temperature Tag': 'TemperatureTag', 'Humidity Tag': 'HumidityTag', 'Barometer Tag': 'BarometerTag', 'Lux Meter Tag': 'LuxMeterTag', 'NFC Tag': 'NFCTag', 'VOC Tag': 'VOCTag', 'VOC-LP Tag': 'VOC_LPTag' } self.sign = { '0': ['Status', [1, 1, 1, 1]], '1': ['', [1, 1, 1, 1]], '2': ['', [1, 1, 1, 1]], '3': ['', [1, 1, 1, 1]], '4': ['', [1, 1, 1, 1]], '5': ['', [1, 1, 1, 1]], '6': ['', [1, 1, 1, 1]], '7': ['', [1, 1, 1, 1]], '8': ['', [1, 1, 1, 1]], '9': ['', [1, 1, 1, 1]] } self.data = { '0': ['Waiting for choice module', [1, 1, 1, 1]], '1': ['', [1, 1, 1, 1]], '2': ['', [1, 1, 1, 1]], '3': ['', [1, 1, 1, 1]], '4': ['', [1, 1, 1, 1]], '5': ['', [1, 1, 1, 1]], '6': ['', [1, 1, 1, 1]], '7': ['', [1, 1, 1, 1]], '8': ['', [1, 1, 1, 1]], '9': ['', [1, 1, 1, 1]] } self.status = { '0': ['', [1, 0, 0, 1]], '1': ['', [1, 0, 0, 1]], '2': ['', [1, 0, 0, 1]], '3': ['', [1, 0, 0, 1]], '4': ['', [1, 0, 0, 1]], '5': ['', [1, 0, 0, 1]], '6': ['', [1, 0, 0, 1]], '7': ['', [1, 0, 0, 1]], '8': ['', [1, 0, 0, 1]], '9': ['', [1, 0, 0, 1]] } for x in self.module: btn = Button(text=self.module[x], size_hint_y=None, height=80, font_size=30) btn.bind(on_release=lambda btn: self.dropdown.select(btn.text)) self.dropdown.add_widget(btn) self.mainlabel = Label(text="HARDWARIO Tester", font_size=40, size_hint=(1, 0.2), pos_hint={ 'x': 0, 'y': 0.8 }) self.githublabel = Label(text="github.com/VPetras/bc-tester", font_size=25, size_hint=(1.6, 0.1), pos_hint={ 'x': 0.08, 'y': 0 }) self.mainbutton = Button(text='Choice Modul which you wanna test', font_size=30, size_hint=(0.3, 0.1), pos_hint={ 'x': 0.01, 'y': 0.75 }) self.button = Button(text='end testing', font_size=30, size_hint=(0.3, 0.1), pos_hint={ 'x': 0.35, 'y': 0.01 }) self.button.bind(on_press=self.stop_btn) self.mainbutton.bind(on_release=self.dropdown.open) self.dropdown.bind( on_select=lambda instance, x: setattr(self.mainbutton, 'text', x)) self.dropdown.bind(on_select=self.callback) self.add_widget(self.mainlabel) self.add_widget(self.githublabel) self.add_widget(self.mainbutton) self.add_widget(self.button) self.button.disabled = True self.show() self.update() def runtime_module_test(self): seq = self.testing_sequence[self.testing_module] seq = globals()[seq]() self.sign = seq.sign self.update() while self.started: print("running module test") self.sign = seq.sign self.data = seq.data self.status = seq.status self.update() seq.test0() time.sleep(1) self.sign = seq.sign self.data = seq.data self.status = seq.status self.update() seq.test1() time.sleep(1) self.sign = seq.sign self.data = seq.data self.status = seq.status self.update() seq.test2() time.sleep(1) self.sign = seq.sign self.data = seq.data self.status = seq.status self.update() seq.test3() time.sleep(1) self.sign = seq.sign self.data = seq.data self.status = seq.status self.update() seq.test4() time.sleep(1) self.sign = seq.sign self.data = seq.data self.status = seq.status self.update() time.sleep(1) seq.clean() self.sign = seq.sign self.data = seq.data self.status = seq.status self.update() time.sleep(1) def threaded_program(self): self.mainbutton.disabled = True self.button.disabled = False self.running = True print(self.testing_module) self.runtime_module_test() self.running = False print('thread is gone') self.mainbutton.disabled = False self.button.disabled = True self.erase() def stop(self): print("stoping module test") self.started = False def start(self): if self.started: return print('starting thread') self.started = True self.thread = threading.Thread(target=self.threaded_program, args=()) self.thread.start() def stop_btn(self, x): print(x.text) self.button.disabled = True self.stop() def callback(self, instance, x): for i in range(len(self.module)): if x == self.module[str(i + 1)]: print(self.module[str(i + 1)]) self.testing_module = x self.start() def show(self): self.sign0 = Label(text='', font_size=35, size_hint=(1, 0.2), pos_hint={ 'x': 0.0, 'y': 0.70 }) self.sign1 = Label(text='', font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.0, 'y': 0.65 }) self.sign2 = Label(text='', font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.0, 'y': 0.60 }) self.sign3 = Label(text='', font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.0, 'y': 0.55 }) self.sign4 = Label(text='', font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.0, 'y': 0.50 }) self.sign5 = Label(text='', font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.0, 'y': 0.45 }) self.sign6 = Label(text='', font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.0, 'y': 0.40 }) self.sign7 = Label(text='', font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.0, 'y': 0.35 }) self.sign8 = Label(text='', font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.0, 'y': 0.30 }) self.sign9 = Label(text='', font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.0, 'y': 0.25 }) self.add_widget(self.sign0) self.add_widget(self.sign1) self.add_widget(self.sign2) self.add_widget(self.sign3) self.add_widget(self.sign4) self.add_widget(self.sign5) self.add_widget(self.sign6) self.add_widget(self.sign7) self.add_widget(self.sign8) self.add_widget(self.sign9) self.data0 = Label(text='', color=[1, 0.5, 0, 1], font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.125, 'y': 0.7 }) self.data1 = Label(text='', color=[1, 0.5, 0, 1], font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.125, 'y': 0.65 }) self.data2 = Label(text='', color=[1, 0.5, 0, 1], font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.125, 'y': 0.60 }) self.data3 = Label(text='', color=[1, 0.5, 0, 1], font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.125, 'y': 0.55 }) self.data4 = Label(text='', color=[1, 0.5, 0, 1], font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.125, 'y': 0.50 }) self.data5 = Label(text='', color=[1, 0.5, 0, 1], font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.125, 'y': 0.45 }) self.data6 = Label(text='', color=[1, 0.5, 0, 1], font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.125, 'y': 0.40 }) self.data7 = Label(text='', color=[1, 0.5, 0, 1], font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.125, 'y': 0.35 }) self.data8 = Label(text='', color=[1, 0.5, 0, 1], font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.125, 'y': 0.30 }) self.data9 = Label(text='', color=[1, 0.5, 0, 1], font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.125, 'y': 0.25 }) self.add_widget(self.data0) self.add_widget(self.data1) self.add_widget(self.data2) self.add_widget(self.data3) self.add_widget(self.data4) self.add_widget(self.data5) self.add_widget(self.data6) self.add_widget(self.data7) self.add_widget(self.data8) self.add_widget(self.data9) self.status0 = Label(text='', color=[1, 0, 0, 1], font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.25, 'y': 0.7 }) self.status1 = Label(text='', color=[1, 0, 0, 1], font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.25, 'y': 0.65 }) self.status2 = Label(text='', color=[1, 0, 0, 1], font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.25, 'y': 0.60 }) self.status3 = Label(text='', color=[1, 0, 0, 1], font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.25, 'y': 0.55 }) self.status4 = Label(text='', color=[1, 0, 0, 1], font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.25, 'y': 0.50 }) self.status5 = Label(text='', color=[1, 0, 0, 1], font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.25, 'y': 0.45 }) self.status6 = Label(text='', color=[1, 0, 0, 1], font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.25, 'y': 0.40 }) self.status7 = Label(text='', color=[1, 0, 0, 1], font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.25, 'y': 0.35 }) self.status8 = Label(text='', color=[1, 0, 0, 1], font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.25, 'y': 0.30 }) self.status9 = Label(text='', color=[1, 0, 0, 1], font_size=30, size_hint=(1, 0.2), pos_hint={ 'x': 0.25, 'y': 0.25 }) self.add_widget(self.status0) self.add_widget(self.status1) self.add_widget(self.status2) self.add_widget(self.status3) self.add_widget(self.status4) self.add_widget(self.status5) self.add_widget(self.status6) self.add_widget(self.status7) self.add_widget(self.status8) self.add_widget(self.status9) def update(self): self.sign0.text = self.sign['0'][0] self.sign1.text = self.sign['1'][0] self.sign2.text = self.sign['2'][0] self.sign3.text = self.sign['3'][0] self.sign4.text = self.sign['4'][0] self.sign5.text = self.sign['5'][0] self.sign6.text = self.sign['6'][0] self.sign7.text = self.sign['7'][0] self.sign8.text = self.sign['8'][0] self.sign9.text = self.sign['9'][0] self.data0.text = self.data['0'][0] self.data1.text = self.data['1'][0] self.data2.text = self.data['2'][0] self.data3.text = self.data['3'][0] self.data4.text = self.data['4'][0] self.data5.text = self.data['5'][0] self.data6.text = self.data['6'][0] self.data7.text = self.data['7'][0] self.data8.text = self.data['8'][0] self.data9.text = self.data['9'][0] #for i in range(10): # data = getattr(self, 'data{}'.format(i)) # assert data # data.text = self.data[str(i)] self.status0.text = self.status['0'][0] self.status0.color = self.status['0'][1] self.status1.text = self.status['1'][0] self.status1.color = self.status['1'][1] self.status2.text = self.status['2'][0] self.status2.color = self.status['2'][1] self.status3.text = self.status['3'][0] self.status3.color = self.status['3'][1] self.status4.text = self.status['4'][0] self.status4.color = self.status['4'][1] self.status5.text = self.status['5'][0] self.status5.color = self.status['5'][1] self.status6.text = self.status['6'][0] self.status6.color = self.status['6'][1] self.status7.text = self.status['7'][0] self.status7.color = self.status['7'][1] self.status8.text = self.status['8'][0] self.status8.color = self.status['8'][1] self.status9.text = self.status['9'][0] self.status9.color = self.status['9'][1] def erase(self): for i in range(10): self.sign[str(i)][0] = '' self.data[str(i)][0] = '' self.status[str(i)][0] = '' self.sign['0'][0] = 'Status' self.data['0'][0] = 'Waiting for choice module' self.update()
def select_volume(self, obj): choose_volume_layout = FloatLayout() volumes = win32api.GetLogicalDriveStrings() volumes = volumes.split('\000')[:-1] for i, element in enumerate(volumes): volumes[i] = element.replace('/', '') dropdown = DropDown() for i in range(len(volumes)): # 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=volumes[i], size_hint_y=None, height=20) # 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 main_button = Button(text='Choose the Volume', size_hint=(.7, .3), pos_hint={ 'center_x': .5, 'center_y': .7 }) # 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.). main_button.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(main_button, 'text', x)) connect_btn = Button(text="Confirm selection", size_hint=(.7, .3), pos_hint={ 'center_x': .5, 'center_y': .3 }) choose_volume_layout.add_widget(main_button) choose_volume_layout.add_widget(connect_btn) popup_volume = Popup(title='Volume chooser', content=choose_volume_layout, size_hint=(None, None), size=(300, 200)) popup_volume.open() # Attach close button press with popup.dismiss action connect_btn.bind(on_release=lambda info: self.connect_to_folder( volume=main_button.text))
class NewArmyListPopup(Popup): army_list_name = None def __init__(self, army_list, **kwargs): super(NewArmyListPopup, self).__init__(**kwargs) self.army_list = army_list self.list_name = None self.nation_dropdown = DropDown() for nation in theater_selector_dict.keys(): button = DropDownButton(text=nation) button.bind( on_release=lambda btn: self.nation_dropdown.select(btn.text)) self.nation_dropdown.add_widget(button) self.ids["button_nation_selection"].bind( on_release=self.nation_dropdown.open) self.nation_dropdown.bind(on_select=self.set_nationality) self.theater_dropdown = DropDown() self.ids["button_theater_selector"].bind( on_release=self.theater_dropdown.open) self.theater_dropdown.bind(on_select=self.set_theater_selector) def set_nationality(self, instance, nationality): self.theater_dropdown.dismiss() if nationality != self.ids["button_nation_selection"].text: self.ids["button_nation_selection"].text = nationality self.ids["button_theater_selector"].text = "select" self.theater_dropdown.clear_widgets() for selector in theater_selector_dict[nationality]: button = DropDownButton(text=selector) button.bind(on_release=lambda btn: self.theater_dropdown. select(btn.text)) self.theater_dropdown.add_widget(button) def set_theater_selector(self, instance, theater_selector): self.ids["button_theater_selector"].text = theater_selector def cancel(self): self.dismiss() def ok(self): if self.ids["textinput_name"].text == "": MessagePopup("List With No Name", "Please give your new list a name") elif self.ids["textinput_name"].text in self.army_list["lists"].keys(): MessagePopup( "List already exist", "There already is a army list with the name {}".format( self.ids["textinput_name"].text), ) elif self.ids["button_nation_selection"].text == "select": MessagePopup("No nation selected", "Please select a nation.") elif self.ids["button_theater_selector"].text == "select": MessagePopup("No theater selector selected", "Please select a theater selector") else: self.list_name = self.ids["textinput_name"].text lists_dict = self.army_list["lists"] lists_dict[self.list_name] = default_list_dict["lists"]["default"] lists_dict[self.list_name]["nationality"] = self.ids[ "button_nation_selection"].text lists_dict[self.list_name]["theater_selector"] = self.ids[ "button_theater_selector"].text self.army_list["lists"] = lists_dict self.dismiss()
def addAtom(canv, objLocs, objSize, obj): x = mult * obj.fields["settings(6194)"].fields[ "desktop_settings(612)"].fields["x(17)"] y = height - obj.fields["settings(6194)"].fields[ "desktop_settings(612)"].fields["y(18)"] flag = 0 name = '' if (len(objLocs) < obj.id): for i in range(obj.id - len(objLocs) + 1): objLocs.append((-1, -1)) objSize.append((-1, -1)) nameIn = obj.classname #values if nameIn == 'float_core.decimal_value_atom(289)': name = obj.fields["name(374)"] val = obj.fields["value_type(702)"].fields["default_value(891)"] width = 15 + 6 * len(name) name += '\n' + str(val)[:6] objSize[obj.id] = (width, 40) flag = 1 elif nameIn == 'float_core.boolean_value_atom(87)': name = obj.fields["name(374)"] val = obj.fields["value_type(702)"].fields["default_value(6957)"] width = 15 + 6 * len(name) name += '\n' + str(val) objSize[obj.id] = (width, 40) flag = 1 elif nameIn == 'float_core.indexed_value_atom(180)': name = obj.fields["name(374)"] width = 15 + 6 * len(name) vals = obj.fields["value_type(702)"].fields["items(393)"] dropdown = DropDown() i = 0 for val in vals: btn = Button(text=val.fields["name(651)"], font_size='12sp', size_hint_y=None, height=20) btn.bind(on_release=lambda btn: dropdown.select(btn.text)) dropdown.add_widget(btn) i += 1 objSize[obj.id] = (width, 40) mainbutton = Button(text=name + '\n' + vals[0].fields["name(651)"], font_size='12sp', pos=(x, y - 40), size_hint=(None, None), size=objSize[obj.id]) mainbutton.bind(on_release=dropdown.open) dropdown.bind(on_select=lambda instance, x: setattr( mainbutton, 'text', name + '\n' + x)) canv.add_widget(mainbutton) elif nameIn == 'float_core.integer_value_atom(394)': name = obj.fields["name(374)"] val = obj.fields["value_type(702)"].fields["default_value(6956)"] width = 15 + 6 * len(name) name += '\n' + str(val) objSize[obj.id] = (width, 40) flag = 1 elif nameIn == 'float_common_atoms.constant_value_atom(314)': name = str(obj.fields["constant_value(750)"])[:5] width = 15 + 6 * len(name) objSize[obj.id] = (width, 40) flag = 1 elif nameIn == 'float_common_atoms.constant_integer_value_atom(298)': name = str(obj.fields["constant_value(720)"]) width = 15 + 6 * len(name) objSize[obj.id] = (width, 40) flag = 1 #atoms elif nameIn == 'float_common_atoms.nitro_atom(1721)': name = 'nitro' val = obj.fields["code(6264)"][:19] width = 15 + 6 * len(val) name += '\n' + str(val) objSize[obj.id] = (width, 40) flag = 1 elif nameIn == 'float_common_atoms.mix_atom(301)': name = 'MIX' objSize[obj.id] = (30, 30) flag = 1 elif nameIn == 'float_common_atoms.polyphonic_note_voice_atom(350)': name = 'PolyNoteVoice' objSize[obj.id] = (90, 30) flag = 1 elif nameIn == 'float_common_atoms.note_delay_compensation_atom(1435)': name = 'NoYo' objSize[obj.id] = (30, 30) flag = 1 elif nameIn == 'float_common_atoms.delay_compensation_atom(1371)': name = 'oYo' objSize[obj.id] = (30, 30) flag = 1 elif nameIn == 'float_core.modulation_source_atom(766)': name = obj.fields["name(3639)"] + '\no->' width = 15 + 6 * (len(name) - 4) objSize[obj.id] = (width, 30) flag = 1 elif nameIn == 'float_core.value_led_atom(189)': name = 'led' objSize[obj.id] = (20, 20) flag = 1 #other atoms elif nameIn == 'float_common_atoms.decimal_event_filter_atom(400)': name = 'decFilter' val1 = obj.fields["comparison(842)"] val2 = obj.fields["comparison_value(843)"] width = 15 + 6 * len(name) name += '\n' + str(val1) + '\n' + str(val2) objSize[obj.id] = (width, 60) flag = 1 elif nameIn == 'float_common_atoms.multiplexer_atom(1188)': name = 'MUX' val = obj.fields["inputs(4763)"] objSize[obj.id] = (10 * val + 20, 30) name += ' ' + str(val) flag = 1 elif nameIn == 'float_common_atoms.deinterleave_atom(368)': name = 'L/R' objSize[obj.id] = (30, 30) flag = 1 elif nameIn == 'float_common_atoms.indexed_lookup_table_atom(344)': name = 'lookup' vals = obj.fields["row_data(744)"] length = obj.fields["row_count(743)"] name += '\n' for i in range(length): name += str( vals[i].fields["cells(726)"][0].fields["value(739)"]) + '|' width = 6 * (len(name) - 6) objSize[obj.id] = (width, 40) flag = 1 #math elif nameIn == 'float_common_atoms.constant_add_atom(308)': name = '+' val = obj.fields["constant_value(750)"] name += '\n' + str(val) objSize[obj.id] = (40, 40) flag = 1 elif nameIn == 'float_common_atoms.constant_multiply_atom(303)': name = 'x' val = obj.fields["constant_value(750)"] name += '\n' + str(val)[:5] objSize[obj.id] = (40, 40) flag = 1 elif nameIn == 'float_common_atoms.add_atom(337)': name = '+' objSize[obj.id] = (30, 30) flag = 1 elif nameIn == 'float_common_atoms.multiply_atom(367)': name = 'x' objSize[obj.id] = (30, 30) flag = 1 elif nameIn == 'float_common_atoms.subtract_atom(343)': name = '-' objSize[obj.id] = (30, 30) flag = 1 elif nameIn == 'float_common_atoms.multiply_add_atom(304)': name = 'x+' objSize[obj.id] = (obj.fields["multiplier_pairs(724)"] * 20 + 10, 30) flag = 1 elif nameIn == 'float_common_atoms.sum_atom(305)': name = '+++' val = obj.fields["inputs(725)"] name += str(val) objSize[obj.id] = (val * 10 + 10, 40) flag = 1 #DSP elif nameIn == 'float_common_atoms.svf_filter_atom(578)': name = 'filter' objSize[obj.id] = (30, 30) flag = 1 elif nameIn == 'float_common_atoms.surge_classic_oscillator_atom(491)': name = 'surge osc' objSize[obj.id] = (100, 30) flag = 1 #components elif nameIn == 'float_core.proxy_in_port_component(154)': name = 'IN' #val = obj.fields["port(301)"].fields["decorated_name(499)"] #name += '\n' + val objSize[obj.id] = (30, 30) flag = 1 elif nameIn == 'float_core.proxy_out_port_component(50)': name = 'OUT' #val = obj.fields["port(301)"].fields["decorated_name(499)"] #name += '\n' + val objSize[obj.id] = (30, 30) y -= 300 flag = 1 elif nameIn == 'float_core.nested_device_chain_slot(587)': name = 'nest' val = obj.fields["name(835)"] name += '\n' + val objSize[obj.id] = (40, 40) flag = 1 #everything else else: dot = 0 paren = 0 name = '' num = '' for i in range(len(nameIn)): if nameIn[i] == '(': paren = 1 if dot and not paren: if nameIn[i] == '_': name += ' ' else: name += nameIn[i] elif paren: num += nameIn[i] if nameIn[i] == '.': dot = 1 if not name: name = num width = 8 * len(name) + 16 objSize[obj.id] = (width, 30) flag = 1 if flag: #canv.add_widget(DragButt(text=name, pos = (x,y-objSize[obj.id][1]), font_size='12sp', size_hint=(None, None), size=objSize[obj.id], drag_rectangle=(x, y, objSize[obj.id][0], objSize[obj.id][1]), drag_timeout=10000000, drag_distance=0)) canv.add_widget( Button(text=name, pos=(x, y - objSize[obj.id][1]), font_size='12sp', size_hint=(None, None), size=objSize[obj.id])) objLocs[obj.id] = (x / mult, height - y)
def __init__(self, **kwargs): super(VisualSearchDesigner, self).__init__(**kwargs) with self.canvas.before: Color(.2, .2, .2, 1) self.rect = Rectangle(size=self.size, pos=self.pos) self.bind(size=self._adjustRect, pos=self._adjustRect) label = Label(text='Visual Search', size_hint=(0.895, 0.495), pos_hint={ 'center_x': 0.45, 'center_y': 0.75 }) self.addButton = Button(text='+', size_hint=(0.095, 0.495), pos_hint={ 'center_x': 0.95, 'center_y': 0.75 }) self.mainContrastButton = Button(text='1 Contrast', size_hint=(0.495, 0.495), pos_hint={ 'center_x': 0.25, 'center_y': 0.25 }) self.mainConditionButton = Button(text='24 Stimuli', size_hint=(0.495, 0.495), pos_hint={ 'center_x': 0.75, 'center_y': 0.25 }) self.add_widget(label) self.add_widget(self.addButton) self.add_widget(self.mainContrastButton) self.add_widget(self.mainConditionButton) dropdownContrast = DropDown() for s in ['1 Contrast', '2 Contrasts']: btn = Button(text=s, size_hint_y=None, height=self.mainContrastButton.height / 2) btn.bind(on_release=lambda btn: dropdownContrast.select(btn.text)) dropdownContrast.add_widget(btn) self.mainContrastButton.bind(on_release=dropdownContrast.open) dropdownContrast.bind( on_select=lambda _, x: setattr(self.mainContrastButton, 'text', x)) dropdownCondition = DropDown() for s in [ '6 Stimuli', '12 Stimuli', '24 Stimuli', '48 Stimuli', '64 Stimuli' ]: btn = Button(text=s, size_hint_y=None, height=self.mainConditionButton.height / 2) btn.bind(on_release=lambda btn: dropdownCondition.select(btn.text)) dropdownCondition.add_widget(btn) self.mainConditionButton.bind(on_release=dropdownCondition.open) dropdownCondition.bind(on_select=lambda _, x: setattr( self.mainConditionButton, 'text', x))
class PlotPopup(Popup): '''popup containing the graph''' def __init__(self, x_range, y_range, plot_list, **kwargs): super(PlotPopup, self).__init__(**kwargs) self._plot_list = plot_list self.x_range = list(x_range) self.y_range = [0, y_range[1]] self.legend = DropDown(dismiss_on_select=False) self._color_list = [ [0.2, 1.0, 0, 1], [1, 0, 0.2, 1], [0, 0.2, 1, 1], [0.6, 0, 0.8, 1], [1, 0.4, 0.2, 1], [1, 0.8, 0, 1], [0.8, 1.0, 0.1, 1] ] self.make_graph() self.make_legend() def make_graph(self): '''makes a graph and plots''' colors = itertools_cycle(self._color_list) y_ticks = [0.05, 0.1, 0.2, 0.5, 1, 5, 10] x_ticks = [1, 2, 5, 10, 20, 30, 50, 100, 200, 300, 500, 1000, 2000, 5000] for text_pts in self._plot_list: color_ = next(colors) self.ids['graph'].add_plot(MeshLinePlot(points=text_pts[1], color=color_)) #get numbers for graph ticks x_tick_num = (self.x_range[1]-self.x_range[0])/9. for tick in x_ticks: if x_tick_num < tick: x_tick_num = tick break y_tick_num = (self.y_range[1]-self.y_range[0])/20. for tick in y_ticks: if y_tick_num < tick: y_tick_num = tick break self.x_range[0] -= self.x_range[0] % x_tick_num #adjust font size according to tick numbers current = self.ids['graph'].font_size font_factor = 1. if x_tick_num > 49: font_factor = 0.75 if x_tick_num > 99: font_factor = 0.66 if x_tick_num > 499: font_factor = 0.5 self.ids['graph'].font_size = int(font_factor * current) self.ids['graph'].x_ticks_major = x_tick_num self.ids['graph'].y_ticks_major = y_tick_num self.ids['graph'].xmin = self.x_range[0] self.ids['graph'].ymin = -y_tick_num self.ids['graph'].xmax = self.x_range[1] self.ids['graph'].ymax = self.y_range[1] def make_legend(self): '''created the dropdown menu that's called by 'legend' button''' colors = itertools_cycle(self._color_list) for text, pts in self._plot_list: btn = ListButton(text=text, size_hint=(None, None), height=80, lst=pts, color=next(colors), valign='middle') btn.bind(on_release=self.legend.select) self.legend.add_widget(btn) self.legend.on_select = self.flash_plot self.ids['legend'].bind(on_release=self.legend.open) self.ids['legend'].bind(on_release=self.resize) self.legend.bind(on_dismiss=self.shrink_button) def shrink_button(self, event): '''make legend button small again after dismiss drop down''' self.ids['legend'].width = self.ids['legend'].texture_size[0] def resize(self, *args): '''on release, resize drop down to fit widest button''' widths = [self.ids['legend'].texture_size[0]] for btn in self.legend.children[0].children: #height control for multiline buttons single_line_ht = btn.texture_size[1] lines, remainder = divmod(int(btn.texture_size[0] + 10), int(self.parent.width)) lines += bool(remainder) #make long btn.text multiline split_at, remainder = divmod(len(btn.text), lines) split_at += bool(remainder) new_text_lst = [] copy = btn.text while len(copy) > split_at: new_text_lst.append(copy[:split_at]) copy = copy[split_at:] new_text_lst.append(copy) btn.text = '\n'.join(new_text_lst) btn.width = min(btn.texture_size[0] + 10, self.parent.width) btn.height = max(self.ids['legend'].height, single_line_ht * lines) widths.append(btn.width) self.ids['legend'].width = max(widths) def flash_plot(self, btn, second_time=False, flash_time=0.5): '''on press, highlight selected graph''' for plot in self.ids['graph'].plots: if plot.points == btn.lst: #temp_color = [1, 1, 1, 1] temp_color = [1-val for val in btn.color] temp_color[3] = 1 self.ids['graph'].remove_plot(plot) new_plot = MeshLinePlot(points=btn.lst, color=temp_color) self.ids['graph'].add_plot(new_plot) if second_time: Clock.schedule_once( lambda dt: self._callback(btn, flash_time, second_time=True), flash_time) else: Clock.schedule_once(lambda dt: self._callback(btn, flash_time), flash_time) def _callback(self, btn, flash_time, second_time=False): '''resets graph to original color''' for plot in self.ids['graph'].plots: if plot.points == btn.lst: plot.color = btn.color if not second_time: Clock.schedule_once(lambda dt: self.flash_plot(btn, True), flash_time)
class GameOptionsScreen(Screen): def __init__(self, **kwargs): super(GameOptionsScreen, self).__init__(**kwargs) self.name = 'options' self.home_button = Button(text='home') self.home_button.size_hint = (1 / 8, 1 / 12) self.home_button.pos_hint = {'x': 0.02, 'y': 0.02} self.home_button.background_color = _COLOR_1 self.start_button = Button(text='start', size_hint=(1 / 8, 1 / 12), pos_hint={ 'right': 0.98, 'y': 0.02 }, background_color=_COLOR_1) self.build_num_teams_drop_down() # self.build_question_selection_drop_down() self.add_widget(self.home_button) self.add_widget(self.start_button) def build_num_teams_drop_down(self): MAX_TEAMS = 3 self.main_button = Button() self.main_button.text = "Select Number of Teams" self.main_button.size_hint = (0.4, 0.15) self.main_button.pos_hint = {'center_x': 0.5, 'top': 0.8} self.main_button.font_size = 30 self.main_button.background_color = _COLOR_1 self.drop_down = DropDown() for i in range(MAX_TEAMS): btn = Button(text=f"{i + 1}", size_hint_y=None, height=30) btn.bind(on_press=self.get_team_names) self.drop_down.add_widget(btn) self.main_button.bind(on_release=self.drop_down.open) self.drop_down.bind( on_select=lambda instance, x: setattr(self.main_button, 'text', x)) self.add_widget(self.main_button) def get_team_names(self, instance): self.drop_down.select(instance.text) try: self.team_name_grid.clear_widgets() except: self.team_name_grid = GridLayout() self.add_widget(self.team_name_grid) self.team_name_grid.rows = int(instance.text) self.team_name_grid.size_hint = (0.3, 0.1 * int(instance.text)) self.team_name_grid.pos_hint = {'center_x': 0.5, 'center_y': 0.5} for i in range(int(instance.text)): text = TextInput() text.hint_text = (f"Enter Team {i + 1} name") self.team_name_grid.add_widget(text) def update_team_names(self): children = self.team_name_grid.children self.parent.game_play.team_names = [] self.parent.game_play.teams = [] for child in children: self.parent.game_play.team_names.append(child.text) # make players: for child in children: plyr = player.player(f'{child.text}') self.parent.game_play.teams.append(plyr) self.parent.game_play.number_of_teams = len( self.parent.game_play.teams) def build_question_selection_drop_down(self): ''' need to hook this up to QCA system to query all the questions that are available ''' # Temp list of random names to simulate QCA querry result self.set_list = ['set1', 'set2', 'set3', 'set4', 'set5', 'set6'] self.question_button = Button() self.question_button.text = "Select Question Set" self.question_button.size_hint = (0.4, 0.15) self.question_button.pos_hint = {'center_x': 0.5, 'top': 0.45} self.question_button.font_size = 30 self.question_button.background_color = _COLOR_1 self.question_drop_down = DropDown() for name in self.set_list: btn = Button(text=name, size_hint_y=None, height=30) btn.bind( on_press=lambda btn: self.question_drop_down.select(btn.text)) self.question_drop_down.add_widget(btn) self.question_button.bind(on_release=self.question_drop_down.open) self.question_drop_down.bind(on_select=lambda instance, x: setattr( self.question_button, 'text', x)) self.add_widget(self.question_button)
class GameGridApp(App): def __init__(self, c, r, **kwargs): super().__init__(**kwargs) self.grid = GridLayout(cols=c, rows=r, spacing=2) self.window_container = BoxLayout(orientation="vertical") self.config = BoxLayout(orientation="horizontal", spacing=10, size_hint=(1, 0.08)) self.display = BoxLayout(id="display", orientation="horizontal", spacing=10, size_hint=(1, 0.08)) self.is_playing = None self.time_delay = 0.5 self.current_cell = None self.generationField = None self.scoreField = None self.exploreField = None self.deathField = None self.algoTypeField = None self.world = World.World(c, r) self.start_dropdown = DropDown() self.prepare_config() self.prepare_display() self.load_info_to_grid() self.load_windows() def prepare_config(self): pre = TextInput(id="pre", hint_text="Pretraining...", multiline=False, input_filter="int", background_color=[0 / 255, 203 / 255, 255 / 255, 0.5]) self.config.add_widget(pre) alpha = TextInput( id="alpha", hint_text="α value (=0.2)", multiline=False, input_filter="float", background_color=[0 / 255, 203 / 255, 255 / 255, 0.5]) self.config.add_widget(alpha) self.config.add_widget( Button(text="set α", background_color=[0 / 255, 203 / 255, 255 / 255, 0.5], on_press=lambda x: self.adjust_alpha(alpha.text))) epsilon = TextInput( id="explore", hint_text="ε value (=0.1)", multiline=False, input_filter="float", background_color=[0 / 255, 203 / 255, 255 / 255, 0.5]) self.config.add_widget(epsilon) self.config.add_widget( Button(text="set ε", background_color=[0 / 255, 203 / 255, 255 / 255, 0.5], on_press=lambda x: self.adjust_epsilon(epsilon.text))) gamma = TextInput( id="gamma", hint_text="γ value (=0.9)", multiline=False, input_filter="float", background_color=[0 / 255, 203 / 255, 255 / 255, 0.5]) self.config.add_widget(gamma) self.config.add_widget( Button(text="set γ", background_color=[0 / 255, 203 / 255, 255 / 255, 0.5], on_press=lambda x: self.adjust_gamma(gamma.text))) choose = self.build_dropdown() self.config.add_widget(choose) self.config.add_widget( Button(text="START", background_normal='', background_color=[0 / 255, 140 / 255, 165 / 255, 1], on_press=lambda a: self.reset_and_start( choose.text, pre.text, epsilon.text, alpha.text, gamma. text))) self.config.add_widget( Button(text="PLAY/PAUSE", background_normal="", background_color=[0 / 255, 140 / 255, 165 / 255, 1], on_press=lambda a: self.pause_resume())) def adjust_gamma(self, text): if text is not "": self.world.agent.ai.gamma = float(text) print(self.world.agent.ai.gamma) def adjust_alpha(self, text): if text is not "": self.world.agent.ai.alpha = float(text) def adjust_epsilon(self, text): if text is not "": self.world.agent.ai.epsilon = float(text) print(self.world.agent.ai.epsilon) def build_dropdown(self): sarsa = Button(text="sarsa", height=22, size_hint_y=None, background_normal='', background_color=[0 / 255, 140 / 255, 165 / 255, 1]) sarsa.bind( on_release=lambda btn: self.start_dropdown.select(sarsa.text)) self.start_dropdown.add_widget(sarsa) qlearn = Button(text="qlearn", height=22, size_hint_y=None, background_normal='', background_color=[0 / 255, 140 / 255, 165 / 255, 1]) qlearn.bind( on_release=lambda btn: self.start_dropdown.select(qlearn.text)) self.start_dropdown.add_widget(qlearn) choose_button = Button( text="Choose", background_normal='', background_color=[0 / 255, 140 / 255, 165 / 255, 1]) choose_button.bind(on_release=self.start_dropdown.open) self.start_dropdown.bind( on_select=lambda instance, x: setattr(choose_button, 'text', x)) return choose_button def prepare_display(self): self.display.add_widget(Label(text="algo")) self.algoTypeField = TextInput( id="AlgoType", readonly=True, text="", multiline=False, background_color=[0 / 255, 203 / 255, 255 / 255, 0.5]) self.display.add_widget(self.algoTypeField) self.display.add_widget(Label(text="gen")) self.generationField = TextInput( id="generation", readonly=True, text="0", multiline=False, background_color=[0 / 255, 203 / 255, 255 / 255, 0.5]) self.display.add_widget(self.generationField) self.display.add_widget(Label(text="score")) self.scoreField = TextInput( id="score", readonly=True, text="0", multiline=False, background_color=[0 / 255, 203 / 255, 255 / 255, 0.5]) self.display.add_widget(self.scoreField) self.display.add_widget(Label(text="deaths")) self.deathField = TextInput( id="deaths", readonly=True, text="0", multiline=False, background_color=[0 / 255, 203 / 255, 255 / 255, 0.5]) self.display.add_widget(self.deathField) self.display.add_widget(Label(text="explore")) self.exploreField = (TextInput( id="explore", readonly=True, text="0", multiline=False, background_color=[0 / 255, 203 / 255, 255 / 255, 0.5])) self.display.add_widget(self.exploreField) def load_windows(self): self.window_container.add_widget(self.config) self.window_container.add_widget(self.display) self.window_container.add_widget(self.grid) def reset_and_start(self, agent_type, pretraining, epsilon, alpha, gamma): eps = 0.1 al = 0.2 ga = 0.9 pre = 0 if epsilon is not "": eps = float(epsilon) if alpha is not "": al = float(alpha) if gamma is not "": ga = float(gamma) if pretraining is not "": pre = int(pretraining) if agent_type is not "Choose": if self.is_playing is not None: self.is_playing.cancel() self.generationField.text = "0" self.deathField.text = "0" self.exploreField.text = "0" self.algoTypeField.text = agent_type self.reset_all_qvals() self.world.add_agent(agent_type, eps, al, ga) self.world.do_pretraining(pre) if pre is not 0: self.set_agent_pos(self.world.agent.cell.name) self.generationField.text = str(pre) self.update_all_qvals() threading.Thread(target=self.do_the_loop()).start() def update_display(self): self.deathField.text = str(self.world.agent.deaths) self.scoreField.text = str(self.world.agent.score) self.exploreField.text = str(self.world.agent.ai.explore) def update_callback(self, dt): new_cell_name = self.world.agent.update_status() self.set_agent_pos(new_cell_name) self.update_generation() self.update_display() self.update_all_qvals() def update_generation(self): gen_int = int(self.generationField.text) gen_int += 1 self.generationField.text = str(gen_int) def pause_resume(self): if self.algoTypeField.text is not "": if self.is_playing is None: self.do_the_loop() else: self.is_playing.cancel() self.is_playing = None def do_the_loop(self): self.is_playing = Clock.schedule_interval(self.update_callback, self.time_delay) def update_all_qvals(self): for key, value, in self.world.agent.ai.qvalues: qval = str(self.world.agent.ai.qvalues[key, value]) if len(qval) > 6: qval = qval[:6] + ".." cell = self.find_cell(key) action = value cell.update_qval(action, qval) def reset_all_qvals(self): for cell in self.grid.children: cell.reset_qvals() def find_cell(self, cellname): for cell in self.grid.children: if cell.name is cellname: return cell return None def set_agent_pos(self, newcellname): for agentvalue in self.current_cell.children: if agentvalue.id is "Agent": agentvalue.id = "agentPlaceholder" agentvalue.background_color = [0, 0, 0, 0] for cell in self.grid.children: if cell.name is newcellname: self.current_cell = cell for agentvalue in cell.children: if agentvalue.id is "agentPlaceholder": agentvalue.id = "Agent" agentvalue.background_color = [ 248 / 255, 255 / 255, 0, 1 ] def load_info_to_grid(self): self.world.build_gamegrid() for cell in self.world.gamegrid: cell_id = None if cell.start: cell_id = "start" if cell.goal: cell_id = "goal" if cell.cliff: cell_id = "cliff" if cell.field: cell_id = "normal" grid_cell = GridLabelCellHolder(cell.name, id=cell_id, cols=3, rows=3) if cell.start: self.current_cell = grid_cell self.grid.add_widget(grid_cell) def build(self): return self.window_container
from kivy.uix.dropdown import DropDown from kivy.uix.button import Button dropdown = DropDown() for index in range(10): btn = Button(text='Value %d' % index, size_hint_y=None, height=44) btn.bind(on_release=lambda btn: dropdown.select(btn.text)) dropdown.add_widget(btn) mainbutton = Button(text='Hello', size_hint=(None, None)) mainbutton.bind(on_release=dropdown.open) dropdown.bind(on_select=lambda instance, x: setattr(mainbutton, 'text', x))
def __init__(self, **kwargs): super(UI,self).__init__(**kwargs) # initialize this so that we can access later on self.region = "" # change background color of app Window.clearcolor = (1,1,1,1) # By default, the size_hint is (1, 1), so a Widget will take the full size of the parent # here we want to make the top section narrower top_layout = GridLayout(cols = 3, size_hint_y = 0.2) self.add_widget(top_layout) # add a placeholder image for the bottom section when app is first started # using self so that can access the image source and update later self.wimg = Image(source = 'images/Seeds in a Pot Final Version Updated.png') self.add_widget(self.wimg) # add label and dropdown to top (selection) l1 = MyLabel(text="Select Region", font_size=24, #halign='left', valign='middle', color = (0,0,0,1)) top_layout.add_widget(l1) dropdown = DropDown() # makes use of imported module function region_list = database.get_regionlist(database.create_connection()) # create an option for all the regions possible for index in region_list: btn = Button(text=index, color = (0,0,0,1), size_hint_y=None, height=44, background_normal = '', background_color = (0.7,0.7,0.9,0.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)) dropdown.add_widget(btn) # create a big main button for the dropdown (i think dropdown is somehow binded to it) # i used self.mainbutton here so that set_region can update its text, if not mainbutton will be undefined self.mainbutton = Button(text="Pls select region", color = (0,0,0,1), font_size=18, halign='left', valign='middle', #change the button appearance background_normal = 'images/button_normal.png', background_down = 'images/button_down.png' ) self.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=self.set_region) top_layout.add_widget(self.mainbutton) # add confirm button next to dropdown cfm_btn = Button(text="Confirm", color = (0,0,0,1), font_size = 18, size_hint_x = 0.2, background_normal = 'images/button_normal.png', background_down = 'images/button_down.png') cfm_btn.bind(on_release = self.query) # makes use of imported module function top_layout.add_widget(cfm_btn)
class GroupScreen(Screen): def __init__(self, **kwargs): super(GroupScreen, self).__init__(**kwargs) # Hold the widgets in a container screen_container = BoxLayout(orientation='vertical', padding=[1]) # *Empowered Logo------------------------------------------------------ self.logo = HomeButton() screen_container.add_widget(self.logo) # *Group Selection Title----------------------------------------------- screen_container.add_widget(Label(text='Group Selection', size_hint=(1, .1), color=(0, .1, .25, .75))) # *Dropdown Menu------------------------------------------------------- self.dropdown = DropDown() self.dropdown.bind(on_select=self.set_active_group) # On load, no group is active. global_data.active_group = '' # Store the drop down buttons for easy manipulation self.current_groups = {} # Populate when top button hit self.mainbutton = CustomButton(text='Select a group', size_hint=(1, .2)) # Populate drop down on select self.mainbutton.bind(on_release=self.load_groups) self.dropdown.bind(on_select=lambda instance, x: setattr(self.mainbutton, 'text', x)) # Place on screen screen_container.add_widget(self.mainbutton) # *Group Actions Title------------------------------------------------- # Declarations self.button_container = BoxLayout(orientation='horizontal') # Edit Button self.edit_btn = CustomButton(text="Edit", size_hint=(.3, .3)) self.edit_btn.bind(on_press=self.switch_screen) # New Button self.new_btn = CustomButton(text="New", size_hint=(.3, .3)) self.new_btn.bind(on_press=self.switch_screen) # Delete Button self.delete_btn = CustomButton(text="Delete", size_hint=(.3, .3)) self.delete_btn.bind(on_press=self.delete) # Put buttons in container self.button_container.add_widget(self.edit_btn) self.button_container.add_widget(self.new_btn) self.button_container.add_widget(self.delete_btn) # Add container to screen container screen_container.add_widget(self.button_container) # Package screen container self.add_widget(screen_container) # Make sure drop down menu gets reset self.bind(on_enter=self.reset_menu) def set_active_group(self, *args): # args = (<DropDown obj>, 'Methylation Pathway') # Storing which group is selected for use in gene screen and deletion global_data.active_group = args[1] def switch_screen(self, *args): # Switch screens if args[0].text == "Edit" and global_data.active_group != '': sm.current = 'gene' elif args[0].text == "New": sm.current = 'newgroup' def delete(self, *args): def delete_group(*args): # Get the selected group active_group = global_data.active_group # Delete it from the group dictionary del global_data.groups[active_group] log(f"Group {active_group} deleted.") # Overwrite the existing groups with the modified group dictionary group_mngr.save_groups(global_data.groups) # Clear the selected group global_data.active_group = '' # Remove it from the drop down menu self.dropdown.remove_widget(self.current_groups[active_group]) # Set drop down menu to default self.dropdown.select('Select a group') popup.dismiss() # If a group is selected and delete button hit, confirm deletion if global_data.active_group != '': # *Confirmation Popup---------------------------------------------- content = BoxLayout(orientation='vertical') content.add_widget(Label(text= f"Delete {global_data.active_group}?")) # *Popup buttons--------------------------------------------------- options = BoxLayout(orientation='horizontal', spacing=2) confirm_btn = CustomButton(text="Delete", # Confirm delete button size_hint=(.3, .3)) cancel_btn = CustomButton(text="Cancel", # Cancel delete button size_hint=(.3, .3)) options.add_widget(confirm_btn) options.add_widget(cancel_btn) content.add_widget(options) # *Popup Attributes------------------------------------------------ popup = Popup(title="Delete?", content=content, size_hint=(None, None), size=(400, 400), separator_color=[1., 1., 1., 1.]) confirm_btn.bind(on_press=delete_group) cancel_btn.bind(on_press=popup.dismiss) popup.open() def load_groups(self, *args): self.dropdown.clear_widgets() # Clear any packaged buttons self.current_groups = {} # Clear drop down button list groups = global_data.groups for group in groups: # Iterating through groups and adding a button btn = CustomButton(text=group, # Create button size_hint_y=None, height=44) btn.bind(on_release=lambda button: self.dropdown.select(button.text)) # Bind drop down functionality self.current_groups[group] = btn self.dropdown.add_widget(btn) # Put in drop down menu self.dropdown.open(args[0]) # Called on clicking the default button def reset_menu(self, *args): # Need to make sure the menu text is defaulted when screen is entered self.dropdown.select('Select a group') global_data.active_group = '' global_data.active_gene = ''
class GeneratorScreen(BoxLayout): def __init__(self, **kwargs): def send(instance): self.die_result.text = str( random.randint(1, int(self.mainbutton.text.split('D')[1]))) self.mid.text = ' ' # initial set up of vertical screen setup super(GeneratorScreen, self).__init__(**kwargs) self.orientation = 'vertical' # create title label at top of screen self.main_label = Label(text='\n[b]Easy Peasy Die Roller[/b]\n', markup=True) self.main_label.font_size = 30 self.main_label.size_hint_y = None self.main_label.bind(texture_size=self.main_label.setter('size')) self.add_widget(self.main_label) # create main display for generated backstories self.die_result = ColoredRectangle() self.die_result.text = 'Let\'s Roll!' self.die_result.color = (0, 0, 0, 1) self.die_result.font_size = 60 self.add_widget(self.die_result) # create buffer area using label self.mid = Label(text=' ', size_hint_y=None) self.add_widget(self.mid) self.mid.bind(texture_size=self.mid.setter('size')) # create horizontal box for two side by side buttons self.horizontalBox = BoxLayout(orientation='horizontal', size_hint_y=None) self.add_widget(self.horizontalBox) # add button to copy existing text from die_result field # self.copy = Button(text='\nCopy die_result\n', disabled=True) # self.horizontalBox.add_widget(self.copy) # self.copy.bind(on_press=copy_text) # self.copy.bind(texture_size=self.horizontalBox.setter('size')) # create a dropdown with 10 buttons self.dropdown = DropDown() for index in [2, 4, 6, 8, 10, 12, 20, 100]: # 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='D%d' % index, 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 self.mainbutton = Button(text='Die Options', size_hint=(None, None)) self.horizontalBox.add_widget(self.mainbutton) self.mainbutton.bind(on_release=self.dropdown.open) # 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.). # one last thing, listen for the selection in the dropdown list and # assign the data to the button text. self.dropdown.bind( on_select=lambda instance, x: setattr(self.mainbutton, 'text', x)) self.dropdown.bind(on_select=lambda instance, x: setattr( self.generate, 'disabled', False)) self.dropdown.bind(on_select=lambda instance, x: setattr( self.generate, 'text', 'Roll!')) # add buttom to generate new die_result in field self.generate = Button(text='\nPick a die to begin.\n', disabled=True, font_size=30) self.horizontalBox.add_widget(self.generate) self.generate.bind(on_press=send) # add bottom black buffer zone self.bottom = Label(text=' ', size_hint_y=None) self.add_widget(self.bottom) self.bottom.bind(texture_size=self.bottom.setter('size'))
class SecondaryWindow(Screen): def __init__(self, **kwargs): # GUI from top to bottom, left to right super(SecondaryWindow, self).__init__(**kwargs) self.scroll = ScrollView(size_hint=(1, None), size=(Window.width, Window.height)) self.scroll_btn = None self.scroll_grid = GridLayout(cols=2, spacing=1, size_hint_y=None) self.scroll_grid.bind(minimum_height=self.scroll_grid.setter('height')) with self.canvas: Color(0.2, 0.2, 0.28) Rectangle(size=(Window.width**2, Window.height**2)) self.btn_live_orders = Button(size_hint_y=None, height=40, text="< Current Orders", background_color=[0.45, 0.45, 0.45, 3], on_release=self.changeWindow) self.scroll_grid.add_widget(self.btn_live_orders) self.btn_menu = Button(size_hint_y=None, height=40, text="Menu >", background_color=[0.45, 0.45, 0.45, 3], on_release=self.changeWindow) self.scroll_grid.add_widget(self.btn_menu) self.drp_date = DropDown() self.drp_date_check = str(datetime.date.today()) self.drp_date_btn = Button(size_hint_y=None, height=40, text=f"{self.drp_date_check}", background_color=[0.45, 0.45, 0.45, 3], on_release=self.drp_date.open) self.drp_date_btn_dates = None self.scroll_grid.add_widget(self.drp_date_btn) self.popup = Popup(title='Title', title_align='center', content=Label(text='Text', size=(400, 400), text_size=[380, 380], halign='center', valign='center'), size_hint=(None, None), size=(400, 400)) self.popup_db_list = [] self.dropDown() def dropDown(self): # Always called with __init__ for i in range(len(screen_main.order_database_dates)): self.drp_date_btn_dates = Button( text=f"{screen_main.order_database_dates[i]}", size_hint_y=None, height=44, background_color=[0.45, 0.45, 0.45, 3], on_release=self.checkDate) self.drp_date.add_widget(self.drp_date_btn_dates) def checkDate(self, instance): self.drp_date_check = instance.text self.generateOrders() self.drp_date.dismiss() def changeWindow(self, instance): if 'Menu' in instance.text: sm.current = 'main' sm.transition.direction = 'left' self.reset() elif 'Orders' in instance.text: sm.current = 'tertiary' sm.transition.direction = 'right' self.reset() def reset(self): self.scroll_grid.clear_widgets() self.scroll_grid.add_widget(self.btn_live_orders) self.scroll_grid.add_widget(self.btn_menu) self.scroll_grid.add_widget(self.drp_date_btn) self.popup_db_list.clear() def popupItem(self, instance): num = int(instance.text.split('Order #')[-1]) self.popup.content.text = f"{self.popup_db_list[num - 1]}" self.popup.title = f"Order #{num}" self.popup.open() def generateOrders(self, instance=None, text=None): self.reset() self.drp_date_btn.text = f"{self.drp_date_check}" count = 0 for i in range(len(screen_main.order_database)): if self.drp_date_check == screen_main.order_database[i][:10]: self.scroll_btn = Button(text=f"Order #{(i + 1) - count}", size_hint_y=None, height=40, background_color=[1.8, 0.8, 0, 3], on_release=self.popupItem) self.scroll_grid.add_widget(self.scroll_btn) self.popup_db_list.append(screen_main.order_database[i]) else: count += 1 if len(self.scroll.children) == 0: self.scroll.add_widget(self.scroll_grid) self.add_widget(self.scroll)
class Menu(BoxLayout): """ Class Menu has main buttons for working with application Static method 'bindings' is destined for setting actions with canvas to buttons of menu """ def __init__(self, canvas_, **kwargs): super(Menu, self).__init__(**kwargs) self._dropdown_color = DropDown() self._dropdown_width = DropDown() self.canvas_ = canvas_ self._dropdown_color.add_widget( Button(text='%s' % _colors[0], color=(0, 0, 0, 1), size_hint_y=None, height=44, background_normal='', background_color=(0, 0, 0, 1), on_release=self.change_color)) self._dropdown_color.add_widget( Button(text='%s' % _colors[1], color=(1, 0, 0, 1), size_hint_y=None, height=44, background_normal='', background_color=(1, 0, 0, 1), on_release=self.change_color)) self._dropdown_color.add_widget( Button(text='%s' % _colors[2], color=(0, 1, 0, 1), size_hint_y=None, height=44, background_normal='', background_color=(0, 1, 0, 1), on_release=self.change_color)) self._dropdown_color.add_widget( Button(text='%s' % _colors[3], color=(0, 0, 1, 1), size_hint_y=None, height=44, background_normal='', background_color=(0, 0, 1, 1), on_release=self.change_color)) self._dropdown_color.bind( on_select=lambda instance, x: setattr(self._btn_color, 'text', x)) for i in _widths: self._dropdown_width.add_widget( Button(text=i, size_hint_y=None, height=44, on_release=self.change_width)) self._dropdown_width.bind( on_select=lambda instance, x: setattr(self._btn_width, 'text', x)) self._btn_save = Button(text='Save', font_size=24) self._btn_load = Button(text='Load', font_size=24) self._btn_edit = Button(text='Edit', font_size=24) self._btn_back = Button(text='Back', font_size=24) self._btn_color = Button(text='Color', font_size=24, on_release=self._dropdown_color.open) self._btn_width = Button(text='Width', font_size=24, on_release=self._dropdown_width.open) self._btn_clear = Button(text='Clear', font_size=24) self.add_widget(self._btn_save) self.add_widget(self._btn_load) self.add_widget(self._btn_edit) self.add_widget(self._btn_back) self.add_widget(self._btn_color) self.add_widget(self._btn_width) self.add_widget(self._btn_clear) def bindings(self, save=None, load=None, back=None, clear=None): self._btn_save.bind(on_release=save) self._btn_load.bind(on_release=load) self._btn_back.bind(on_release=back) self._btn_clear.bind(on_release=clear) def change_color(self, instance): self._dropdown_color.select(instance.text) self.canvas_.change_color(instance) def change_width(self, instance): self._dropdown_width.select(instance.text) self.canvas_.change_width(instance) def choose_eraser(self, instance): instance.text = 'Eraser' self.canvas_.pen_color = (1, 1, 1, 1) def empty(self, instance): pass
class ImageApp(App): def __init__(self): super().__init__() self.outer_layout = BoxLayout(padding=10, orientation='vertical') self.first_in_layout = BoxLayout(padding=10, orientation='horizontal', size_hint=(1, 0.5)) self.second_in_layout = BoxLayout(padding=10, orientation='horizontal', size_hint=(1, 0.5)) self.third_in_layout = BoxLayout(padding=10, orientation='horizontal', size_hint=(1, 2)) self.svd_rank_layout = AnchorLayout(anchor_x="right", anchor_y="top") self.svd_number_layout = AnchorLayout(anchor_x="left", anchor_y="top") self.hw_ratio_layout = AnchorLayout(anchor_x="right", anchor_y="top") self.hw_number_layout = AnchorLayout(anchor_x="left", anchor_y="top") self.hw_normalization_layout = AnchorLayout(anchor_x="center", anchor_y="top") self.rgb_layout_1 = AnchorLayout(anchor_x="center", anchor_y="top") self.rgb_layout_2 = AnchorLayout(anchor_x="center", anchor_y="top") self.conv_choice_layout = BoxLayout(padding=0, orientation='vertical') self.conv_dd_layout = AnchorLayout(anchor_x="center", anchor_y="top") self.image_layout = AnchorLayout(anchor_x="center", anchor_y="center") self.reset_layout = AnchorLayout(anchor_x="right", anchor_y="center", size_hint=(0.1, 1)) self.normalization_dropdown = DropDown() self.rgb_dropdown_1 = DropDown() self.rgb_dropdown_2 = DropDown() self.blur_dropdown = DropDown() self.e_det_dropdown = DropDown() self.svd_button = Button(text="SVD", on_press=self.on_svd) self.haar_wavelet_button = Button(text="Haar Wavelet", on_press=self.on_hw) self.convolution_button = Button(text="Image Convolution", on_press=self.on_conv) self.reset_button = Button(text="Reset", on_press=self.reset, size_hint_y=None, height=40) self.normalization_button = Button(text="Normalization", size_hint=(0.6, 0.6)) self.rgb_button_1 = Button(text="RGB", size_hint=(0.6, 0.6)) self.rgb_button_2 = Button(text="RGB", size_hint=(0.6, 0.6)) self.blur_button = Button(text="Blur", on_press=self.on_blur) self.sharpen_button = Button(text="Sharpen", on_press=self.on_sharpen) self.e_det_button = Button(text="Edge Detection", on_press=self.on_e_det) self.type_button_1 = Button(text="Type", size_hint=(0.6, 0.6)) self.type_button_2 = Button(text="Type", size_hint=(0.6, 0.6)) self.yes_button_1 = Button(text="Yes", size_hint_y=None, height=25, on_press=self.normalization_true) self.yes_button_1.bind(on_release=lambda btn: self. normalization_dropdown.select(btn.text)) self.normalization_dropdown.add_widget(self.yes_button_1) self.no_button_1 = Button(text="No", size_hint_y=None, height=25, on_press=self.normalization_false) self.no_button_1.bind(on_release=lambda btn: self. normalization_dropdown.select(btn.text)) self.normalization_dropdown.add_widget(self.no_button_1) self.yes_button_2 = Button(text="Yes", size_hint_y=None, height=25, on_press=self.svd_rgb_true) self.yes_button_2.bind( on_release=lambda btn: self.rgb_dropdown_1.select(btn.text)) self.rgb_dropdown_1.add_widget(self.yes_button_2) self.no_button_2 = Button(text="No", size_hint_y=None, height=25, on_press=self.svd_rgb_false) self.no_button_2.bind( on_release=lambda btn: self.rgb_dropdown_1.select(btn.text)) self.rgb_dropdown_1.add_widget(self.no_button_2) self.yes_button_3 = Button(text="Yes", size_hint_y=None, height=25, on_press=self.hw_rgb_true) self.yes_button_3.bind( on_release=lambda btn: self.rgb_dropdown_2.select(btn.text)) self.rgb_dropdown_2.add_widget(self.yes_button_3) self.no_button_3 = Button(text="No", size_hint_y=None, height=25, on_press=self.hw_rgb_false) self.no_button_3.bind( on_release=lambda btn: self.rgb_dropdown_2.select(btn.text)) self.rgb_dropdown_2.add_widget(self.no_button_3) self.regular_button = Button(text="Regular Blur", size_hint_y=None, height=25, on_press=self.blur_true) self.regular_button.bind( on_release=lambda btn: self.blur_dropdown.select(btn.text)) self.blur_dropdown.add_widget(self.regular_button) self.gaussian_button = Button(text="Gaussian Blur", size_hint_y=None, height=25, on_press=self.blur_false) self.gaussian_button.bind( on_release=lambda btn: self.blur_dropdown.select(btn.text)) self.blur_dropdown.add_widget(self.gaussian_button) self.normalization_button.bind( on_release=self.normalization_dropdown.open) self.normalization_dropdown.bind(on_select=lambda ins, x: setattr( self.normalization_button, 'text', x)) self.rgb_button_1.bind(on_release=self.rgb_dropdown_1.open) self.rgb_dropdown_1.bind( on_select=lambda ins, x: setattr(self.rgb_button_1, 'text', x)) self.rgb_button_2.bind(on_release=self.rgb_dropdown_2.open) self.rgb_dropdown_2.bind( on_select=lambda ins, x: setattr(self.rgb_button_2, 'text', x)) self.vertical_e_button = Button(text="Vertical Edges", size_hint_y=None, height=25, on_press=self.e_det_true) self.vertical_e_button.bind( on_release=lambda btn: self.e_det_dropdown.select(btn.text)) self.e_det_dropdown.add_widget(self.vertical_e_button) self.horizontal_e_button = Button(text="Horizontal Edges", size_hint_y=None, height=25, on_press=self.e_det_false) self.horizontal_e_button.bind( on_release=lambda btn: self.e_det_dropdown.select(btn.text)) self.e_det_dropdown.add_widget(self.horizontal_e_button) self.type_button_1.bind(on_release=self.blur_dropdown.open) self.blur_dropdown.bind( on_select=lambda ins, x: setattr(self.type_button_1, 'text', x)) self.type_button_2.bind(on_release=self.e_det_dropdown.open) self.e_det_dropdown.bind( on_select=lambda ins, x: setattr(self.type_button_2, 'text', x)) self.rank_label = Label(text="Enter rank:", size_hint=(0.5, 0.5)) self.ratio_label = Label(text="Enter ratio:", size_hint=(0.5, 0.5)) self.rank_input = TextInput(multiline=False, size_hint=(0.4, 0.4)) self.rank_input.bind(text=self.rank_input_f) self.ratio_input = TextInput(multiline=False, size_hint=(0.4, 0.4)) self.ratio_input.bind(text=self.ratio_input_f) self.file_chooser = FileChooserIconView(on_submit=self.submit_file) self.mode = None self.svd_rank = None self.svd_rgb = None self.hw_rgb = None self.hw_normalization = None self.hw_ratio = None self.conv_mode = None self.blur_mode = None self.e_det_mode = None self.num = 0 def on_svd(self, ins): self.second_in_layout.clear_widgets() self.second_in_layout.add_widget(self.svd_rank_layout) self.second_in_layout.add_widget(self.svd_number_layout) self.second_in_layout.add_widget(self.rgb_layout_1) self.mode = 0 def on_hw(self, ins): self.second_in_layout.clear_widgets() self.second_in_layout.add_widget(self.hw_ratio_layout) self.second_in_layout.add_widget(self.hw_number_layout) self.second_in_layout.add_widget(self.hw_normalization_layout) self.second_in_layout.add_widget(self.rgb_layout_2) self.mode = 1 def on_conv(self, ins): self.second_in_layout.clear_widgets() self.second_in_layout.add_widget(self.conv_choice_layout) self.second_in_layout.add_widget(self.conv_dd_layout) self.mode = 2 def on_blur(self, ins): self.conv_dd_layout.clear_widgets() self.conv_dd_layout.add_widget(self.type_button_1) self.conv_mode = 0 def on_sharpen(self, ins): self.conv_dd_layout.clear_widgets() self.conv_mode = 1 def on_e_det(self, ins): self.conv_dd_layout.clear_widgets() self.conv_dd_layout.add_widget(self.type_button_2) self.conv_mode = 2 def reset(self, ins): self.third_in_layout.clear_widgets() self.third_in_layout.add_widget(self.file_chooser) def normalization_true(self, ins): self.hw_normalization = True def normalization_false(self, ins): self.hw_normalization = False def hw_rgb_true(self, ins): self.hw_rgb = True def hw_rgb_false(self, ins): self.hw_rgb = False def svd_rgb_true(self, ins): self.svd_rgb = True def svd_rgb_false(self, ins): self.svd_rgb = False def blur_true(self, ins): self.blur_mode = True def blur_false(self, ins): self.blur_mode = False def e_det_true(self, ins): self.e_det_mode = True def e_det_false(self, ins): self.e_det_mode = False def rank_input_f(self, ins, text): try: self.svd_rank = int(text) except ValueError: self.svd_rank = None def ratio_input_f(self, ins, text): try: self.hw_ratio = float(text) except ValueError: self.hw_ratio = None def submit_file(self, ins, filepath, touch): try: filepath = filepath[0] except IndexError(): return None if filepath.endswith(".png") or filepath.endswith(".jpg"): if self.mode == 0: if None in (self.svd_rank, self.svd_rgb): return None elif self.mode == 1: if None in (self.hw_ratio, self.hw_rgb, self.hw_normalization): return None elif self.mode == 2: if self.conv_mode is None: return None elif self.conv_mode == 0: if self.blur_mode is None: return None elif self.conv_mode == 2: if self.e_det_mode is None: return None else: return None if self.mode == 0: try: self.num += 1 rank_approx.approx(filepath, f"output{self.num}.png", self.svd_rank, rgb=self.svd_rgb) image = Image(source=f"output{self.num}.png") self.image_layout.clear_widgets() self.third_in_layout.clear_widgets() self.image_layout.add_widget(image) self.third_in_layout.add_widget(self.image_layout) self.third_in_layout.add_widget(self.reset_layout) except Exception(): self.third_in_layout.clear_widgets() self.third_in_layout.add_widget(self.file_chooser) elif self.mode == 1: try: self.num += 1 haar_wavelet.compress(filepath, f"output{self.num}.png", ratio=self.hw_ratio, rgb=self.hw_rgb, normalization=self.hw_normalization) image = Image(source=f"output{self.num}.png") self.image_layout.clear_widgets() self.third_in_layout.clear_widgets() self.image_layout.add_widget(image) self.third_in_layout.add_widget(self.image_layout) self.third_in_layout.add_widget(self.reset_layout) except Exception(): self.third_in_layout.clear_widgets() self.third_in_layout.add_widget(self.file_chooser) elif self.mode == 2: try: self.num += 1 if self.conv_mode == 0: image_convolution.blur(filepath, self.blur_mode, f"output{self.num}.png") elif self.conv_mode == 1: image_convolution.sharpen(filepath, f"output{self.num}.png") elif self.conv_mode == 2: image_convolution.edge_detection( filepath, self.e_det_mode, f"output{self.num}.png") image = Image(source=f"output{self.num}.png") self.image_layout.clear_widgets() self.third_in_layout.clear_widgets() self.image_layout.add_widget(image) self.third_in_layout.add_widget(self.image_layout) self.third_in_layout.add_widget(self.reset_layout) except Exception(): self.third_in_layout.clear_widgets() self.third_in_layout.add_widget(self.file_chooser) def build(self): self.first_in_layout.add_widget(self.svd_button) self.first_in_layout.add_widget(self.haar_wavelet_button) self.first_in_layout.add_widget(self.convolution_button) self.third_in_layout.add_widget(self.file_chooser) self.outer_layout.add_widget(self.first_in_layout) self.outer_layout.add_widget(self.second_in_layout) self.outer_layout.add_widget(self.third_in_layout) self.svd_rank_layout.add_widget(self.rank_label) self.svd_number_layout.add_widget(self.rank_input) self.hw_ratio_layout.add_widget(self.ratio_label) self.hw_number_layout.add_widget(self.ratio_input) self.hw_normalization_layout.add_widget(self.normalization_button) self.rgb_layout_1.add_widget(self.rgb_button_1) self.rgb_layout_2.add_widget(self.rgb_button_2) self.conv_choice_layout.add_widget(self.blur_button) self.conv_choice_layout.add_widget(self.sharpen_button) self.conv_choice_layout.add_widget(self.e_det_button) self.reset_layout.add_widget(self.reset_button) return self.outer_layout
class tableField(Popup): def __init__(self,**kwargs): self.myparent=kwargs['myparent'] super(tableField,self).__init__(**kwargs) self.fi=-1 if kwargs.has_key('fi'): self.fi=kwargs['fi'] self.ids.field_pk.disabled=False self.ids.field_ai.disabled=False self.dropdown = DropDown() for typ in TYPES: btn = Button(text=typ, size_hint_y=None, height=20) self.dropdown.add_widget(btn) btn.bind(on_release=lambda btn: self.dropdown.select(btn.text)) self.dropdown.bind(on_select=lambda instance, x: setattr(self.ids.field_type, 'text', x)) for f in self.myparent.fields: if f[4]: self.ids.field_pk.disabled=True self.ids.field_ai.disabled=True break if self.fi > -1: self.ids.field_name.text=self.myparent.fields[self.fi][0] self.ids.field_type.text=self.myparent.fields[self.fi][1] self.ids.field_not.active=self.myparent.fields[self.fi][2] self.ids.field_pk.active=self.myparent.fields[self.fi][3] self.ids.field_ai.active=self.myparent.fields[self.fi][4] if self.ids.field_ai.active: self.ids.field_pk.disabled=False self.ids.field_ai.disabled=False def add_field(self): field_name=self.ids.field_name.text field_type=self.ids.field_type.text field_not=self.ids.field_not.active field_pk=self.ids.field_pk.active field_ai=self.ids.field_ai.active #if this is auto increment field, then make pk is false for others. if field_ai: field_pk=True for f in self.myparent.fields: f[3]=False #check if field name exists f_exist=False if self.fi == -1: for f in self.myparent.fields: if f[0]==field_name: f_exist=True break if field_type==_('Select Type') or not field_name: popup = Popup(title=_('Warning !'), content=Label(text=_("You should write field name and select type")), size_hint = (0.5,0.4) ) popup.open() elif f_exist: popup = Popup(title=_('Warning !'), content=Label(text=_("This field name already exists")), size_hint = (0.5,0.4) ) popup.open() else: ft=[field_name, field_type, field_not, field_pk, field_ai] if self.fi == -1: self.myparent.fields.append(ft) else: self.myparent.fields[self.fi]=ft self.dismiss() self.myparent.update_list()
def __init__(self, **kwargs): super(Screen2, self).__init__(**kwargs) file_name = 'C:/Users/1995h/PycharmProjects/hackthon/egg.jpg' # Loads the image into memory with io.open(file_name, 'rb') as image_file: content = image_file.read() image = types.Image(content=content) # Performs label detection on the image file response = client.label_detection(image=image) labels = response.label_annotations mainlayout = BoxLayout(orientation='vertical', padding=15, spacing=15) wimg = Image(source=file_name) mainlayout.add_widget(wimg) layout = BoxLayout() dropdown1 = DropDown() for inglabel in labels: btn = Button(text='%s' % inglabel.description, size_hint_y=None, height=44) btn.bind(on_release=lambda btn: dropdown1.select(btn.text)) dropdown1.add_widget(btn) # create a big main button labelinput = TextInput(size_hint_y=None, height=44) labelinput.bind(on_double_tap=lambda labelinput: dropdown1.select(labelinput.text)) dropdown1.add_widget(labelinput) mainbutton1.bind(on_release=dropdown1.open) dropdown1.bind(on_select=lambda instance, x: setattr(mainbutton1, 'text', x)) layout.add_widget(mainbutton1) layout.add_widget(textinput) dropdown2 = DropDown() btn2 = Button(text='oz', size_hint_y=None, height=44) btn2.bind(on_release=lambda btn2: dropdown2.select(btn2.text)) dropdown2.add_widget(btn2) btn3 = Button(text='g', size_hint_y=None, height=44) btn3.bind(on_release=lambda btn3: dropdown2.select(btn3.text)) dropdown2.add_widget(btn3) btn4 = Button(text='fl oz', size_hint_y=None, height=44) btn4.bind(on_release=lambda btn4: dropdown2.select(btn4.text)) dropdown2.add_widget(btn4) btn5 = Button(text='# of items', size_hint_y=None, height=44) btn5.bind(on_release=lambda btn5: dropdown2.select(btn5.text)) dropdown2.add_widget(btn5) # create a big main button mainbutton2 = Button(text='Units') mainbutton2.bind(on_release=dropdown2.open) dropdown2.bind(on_select=lambda instance, x: setattr(mainbutton2, 'text', x)) layout.add_widget(mainbutton2) mainlayout.add_widget(layout) sendbtn = Button(text="Add Ingredient") sendbtn.bind(on_press=self.changer) mainlayout.add_widget(sendbtn) self.add_widget(mainlayout)
def display_matching_tiles(self): # Check if Wang Tiles Map in Place if self.wang_tiles_map: self.wang_tiles_map.disable_user_interaction() else: print('Wang Tiles Map does not exist!') return popup_content = FloatLayout(size_hint=(1, 1), pos_hint={ 'center_x': 0.5, 'center_y': 0.5 }) if len(self.wang_tiles_map.tiles.keys()) < 1: print('No tiles found in Wang Tiles Map!') print('Tiles:', self.wang_tiles_map.tiles) return # Add Widgets popup = MatchingTiles(content=popup_content) main_tile = Label(pos_hint={ 'x': 0, 'top': 1.0 }, size_hint=(None, None), size=(200, 33), text='_', markup=True, valign='middle', halign='left') main_tile.text_size = main_tile.size with main_tile.canvas: main_tile_rect = Rectangle(pos=(main_tile.pos[0] + 25, main_tile.pos[1]), size=(self.displayed_size, self.displayed_size)) self.bind(pos=partial(self.update_lbl_rect, main_tile, main_tile_rect), size=partial(self.update_lbl_rect, main_tile, main_tile_rect)) grid = GridLayout(rows=4, spacing=0, size_hint=(None, 1.0), pos_hint={ 'x': 0.0, 'y': 0.0 }) north_lbl = Label(text='North\nMatches:', pos_hint={ 'x': 0, 'top': 0.8 }, size_hint=(0.25, 0.2)) east_lbl = Label(text='East\nMatches:', pos_hint={ 'x': 0, 'top': 0.6 }, size_hint=(0.25, 0.2)) south_lbl = Label(text='South\natches:', pos_hint={ 'x': 0, 'top': 0.4 }, size_hint=(0.25, 0.2)) west_lbl = Label(text='West\nMatches:', pos_hint={ 'x': 0, 'top': 0.2 }, size_hint=(0.25, 0.2)) popup_content.add_widget(north_lbl) popup_content.add_widget(east_lbl) popup_content.add_widget(south_lbl) popup_content.add_widget(west_lbl) north_box = BoxLayout(size_hint=(1, 0.25), orientation='horizontal') east_box = BoxLayout(size_hint=(1, 0.25), orientation='horizontal') south_box = BoxLayout(size_hint=(1, 0.25), orientation='horizontal') west_box = BoxLayout(size_hint=(1, 0.25), orientation='horizontal') grid.bind(minimum_width=grid.setter('width')) scrollview = ScrollView(size_hint=(0.8, 0.8), size=popup.size, do_scroll_x=True, do_scroll_y=False, pos_hint={ 'x': 0.2, 'y': 0 }) scrollview.add_widget(grid) popup_content.add_widget(scrollview) # Modify Specific Tile Probability layout_change_prob = FloatLayout(size_hint=(1, None), size=(self.parent.width, 51), pos_hint={ 'x': 0.0, 'top': 0.9 }) lbl_prob = Label(pos_hint={ 'x': 0, 'top': 0.9 }, size_hint=(None, None), size=(200, 33), text='_', markup=True, valign='middle', halign='left') lbl_prob.text_size = lbl_prob.size with lbl_prob.canvas: lbl_prob_rect = Rectangle(pos=(lbl_prob.pos[0] + 25, lbl_prob.pos[1]), size=(self.displayed_size, self.displayed_size)) self.bind(pos=partial(self.update_lbl_rect, lbl_prob, lbl_prob_rect), size=partial(self.update_lbl_rect, lbl_prob, lbl_prob_rect)) input_prob = DecimalNumericInput(size_hint=(0.25, 1.0), pos_hint={ 'center_y': 0.5, 'right': 0.9 }) btn_change_prob = MyButton(pos_hint={ 'center_y': 0.5, 'right': 1.0 }, size_hint=(0.1, 1), text='Modify') # btn_change_prob.bind(on_press=partial(self.change_tile_probability, lbl_prob, main_tile.text, input_prob.text)) # lbl, origin_tile, tile, index, new_value layout_change_prob.add_widget(input_prob) layout_change_prob.add_widget(lbl_prob) layout_change_prob.add_widget(btn_change_prob) popup_content.add_widget(layout_change_prob) # Spinner to Select Specific Tile # spinner = Spinner( # pos_hint={'right': 1.0, 'top': 1.0}, # size_hint=(None, None), # size=(100, 33), # values=sorted(self.wang_tiles_map.tiles.keys()) # ) # spinner.bind(text=partial(self._update_match_spinner, main_tile, main_tile_rect, grid, north_box, east_box, south_box, west_box, btn_change_prob, input_prob, lbl_prob, lbl_prob_rect)) dropdown = DropDown( # pos_hint={'right': 1.0, 'top': 1.0}, size_hint=(None, None), size=(100, 33), ) for val in sorted(self.wang_tiles_map.tiles.keys()): lbl_drop = Button(text=val, size_hint_y=None, height=44) with lbl_drop.canvas: lbl_drop_rect = Rectangle(pos=(lbl_drop.pos[0] + 10, lbl_drop.pos[1]), size=(self.displayed_size, self.displayed_size)) grid.bind(pos=partial(self.update_lbl_rect, lbl_drop, lbl_drop_rect), size=partial(self.update_lbl_rect, lbl_drop, lbl_drop_rect)) lbl_drop_rect.texture = self.wang_tiles_map.tiles[val] lbl_drop.bind( on_release=lambda lbl_drop: dropdown.select(lbl_drop.text)) dropdown.add_widget(lbl_drop) Clock.schedule_once( partial(self.update_lbl_rect, lbl_drop, lbl_drop_rect), .05) dropdown.bind(on_select=partial( self._update_match_spinner, main_tile, main_tile_rect, grid, north_box, east_box, south_box, west_box, btn_change_prob, input_prob, lbl_prob, lbl_prob_rect)) dropdownbtn = Button(text='Tiles!', pos_hint={ 'right': 1.0, 'top': 1.0 }, size_hint=(None, None), size=(100, 33)) dropdownbtn.bind(on_release=dropdown.open) dropdown.bind( on_select=lambda instance, x: setattr(dropdownbtn, 'text', x)) popup_content.add_widget(main_tile) # popup_content.add_widget(spinner) popup_content.add_widget(dropdown) popup_content.add_widget(dropdownbtn) popup.bind(on_dismiss=self.wang_tiles_map.enable_user_interaction) popup.open() Clock.schedule_once( partial(self.update_lbl_rect, main_tile, main_tile_rect), 0.05) Clock.schedule_once( partial(self.update_lbl_rect, lbl_prob, lbl_prob_rect), 0.05)
def build(self): layout = GridLayout(cols=4) self.label1 = Label(text="Age") layout.add_widget(self.label1) self.age_taste = TextInput(text='', multiline=False) layout.add_widget(self.age_taste) self.label2 = Label(text="Gender") layout.add_widget(self.label2) dropdown_gender = DropDown() btn_male = Button(text='Male', size_hint_y=None, height=30) btn_male.bind( on_release=lambda btn: dropdown_gender.select(btn_male.text)) dropdown_gender.add_widget(btn_male) btn_female = Button(text='Female', size_hint_y=None, height=30) btn_female.bind( on_release=lambda btn: dropdown_gender.select(btn_female.text)) dropdown_gender.add_widget(btn_female) button_gender.bind(on_release=dropdown_gender.open) dropdown_gender.bind( on_select=lambda instance, x: setattr(button_gender, 'text', x)) layout.add_widget(button_gender) self.label3 = Label(text="Income") layout.add_widget(self.label3) self.income_taste = TextInput(text='', multiline=False) layout.add_widget(self.income_taste) self.label4 = Label(text="Budget") layout.add_widget(self.label4) self.budget_taste = TextInput(text='', multiline=False) layout.add_widget(self.budget_taste) self.label5 = Label(text="Recent Visit") layout.add_widget(self.label5) dropdown_rv1 = DropDown() btn_plain_rv1 = Button(text='Plain', size_hint_y=None, height=30) btn_plain_rv1.bind( on_release=lambda btn: dropdown_rv1.select(btn_plain_rv1.text)) dropdown_rv1.add_widget(btn_plain_rv1) btn_beach_rv1 = Button(text='Beach', size_hint_y=None, height=30) btn_beach_rv1.bind( on_release=lambda btn: dropdown_rv1.select(btn_beach_rv1.text)) dropdown_rv1.add_widget(btn_beach_rv1) btn_desert_rv1 = Button(text='Desert', size_hint_y=None, height=30) btn_desert_rv1.bind( on_release=lambda btn: dropdown_rv1.select(btn_desert_rv1.text)) dropdown_rv1.add_widget(btn_desert_rv1) btn_hill_rv1 = Button(text='Hill', size_hint_y=None, height=30) btn_hill_rv1.bind( on_release=lambda btn: dropdown_rv1.select(btn_hill_rv1.text)) dropdown_rv1.add_widget(btn_hill_rv1) button_rv1.bind(on_release=dropdown_rv1.open) dropdown_rv1.bind( on_select=lambda instance, x: setattr(button_rv1, 'text', x)) layout.add_widget(button_rv1) self.label6 = Label(text="Recent Visit") layout.add_widget(self.label6) dropdown_rv2 = DropDown() btn_plain_rv2 = Button(text='Plain', size_hint_y=None, height=30) btn_plain_rv2.bind( on_release=lambda btn: dropdown_rv2.select(btn_plain_rv2.text)) dropdown_rv2.add_widget(btn_plain_rv2) btn_beach_rv2 = Button(text='Beach', size_hint_y=None, height=30) btn_beach_rv2.bind( on_release=lambda btn: dropdown_rv2.select(btn_beach_rv2.text)) dropdown_rv2.add_widget(btn_beach_rv2) btn_desert_rv2 = Button(text='Desert', size_hint_y=None, height=30) btn_desert_rv2.bind( on_release=lambda btn: dropdown_rv2.select(btn_desert_rv2.text)) dropdown_rv2.add_widget(btn_desert_rv2) btn_hill_rv2 = Button(text='Hill', size_hint_y=None, height=30) btn_hill_rv2.bind( on_release=lambda btn: dropdown_rv2.select(btn_hill_rv2.text)) dropdown_rv2.add_widget(btn_hill_rv2) button_rv2.bind(on_release=dropdown_rv2.open) dropdown_rv2.bind( on_select=lambda instance, x: setattr(button_rv2, 'text', x)) layout.add_widget(button_rv2) self.label7 = Label(text="Foreign") layout.add_widget(self.label7) dropdown_foreign = DropDown() btn_yes = Button(text='Yes', size_hint_y=None, height=30) btn_yes.bind( on_release=lambda btn: dropdown_foreign.select(btn_yes.text)) dropdown_foreign.add_widget(btn_yes) btn_no = Button(text='No', size_hint_y=None, height=30) btn_no.bind( on_release=lambda btn: dropdown_foreign.select(btn_no.text)) dropdown_foreign.add_widget(btn_no) button_foreign.bind(on_release=dropdown_foreign.open) dropdown_foreign.bind( on_select=lambda instance, x: setattr(button_foreign, 'text', x)) layout.add_widget(button_foreign) self.label8 = Label(text="Purpose") layout.add_widget(self.label8) dropdown_purpose = DropDown() btn_edu = Button(text='Education', size_hint_y=None, height=30) btn_edu.bind( on_release=lambda btn: dropdown_purpose.select(btn_edu.text)) dropdown_purpose.add_widget(btn_edu) btn_work = Button(text='Work', size_hint_y=None, height=30) btn_work.bind( on_release=lambda btn: dropdown_purpose.select(btn_work.text)) dropdown_purpose.add_widget(btn_work) btn_recreation = Button(text='Recreation', size_hint_y=None, height=30) btn_recreation.bind(on_release=lambda btn: dropdown_purpose.select( btn_recreation.text)) dropdown_purpose.add_widget(btn_recreation) button_purpose.bind(on_release=dropdown_purpose.open) dropdown_purpose.bind( on_select=lambda instance, x: setattr(button_purpose, 'text', x)) layout.add_widget(button_purpose) self.label9 = Label(text="Eating Habit") layout.add_widget(self.label9) dropdown_eating = DropDown() btn_veg = Button(text='Vegetarian', size_hint_y=None, height=30) btn_veg.bind( on_release=lambda btn: dropdown_eating.select(btn_veg.text)) dropdown_eating.add_widget(btn_veg) btn_nveg = Button(text='Non-Vegetarian', size_hint_y=None, height=30) btn_nveg.bind( on_release=lambda btn: dropdown_eating.select(btn_nveg.text)) dropdown_eating.add_widget(btn_nveg) button_eating.bind(on_release=dropdown_eating.open) dropdown_eating.bind( on_select=lambda instance, x: setattr(button_eating, 'text', x)) layout.add_widget(button_eating) self.label10 = Label(text="Stay") layout.add_widget(self.label10) dropdown_stay = DropDown() btn_dormitory = Button(text='Dormitory', size_hint_y=None, height=30) btn_dormitory.bind( on_release=lambda btn: dropdown_stay.select(btn_dormitory.text)) dropdown_stay.add_widget(btn_dormitory) btn_hostel = Button(text='Hostel', size_hint_y=None, height=30) btn_hostel.bind( on_release=lambda btn: dropdown_stay.select(btn_hostel.text)) dropdown_stay.add_widget(btn_hostel) btn_hotel3 = Button(text='Hotel 3*', size_hint_y=None, height=30) btn_hotel3.bind( on_release=lambda btn: dropdown_stay.select(btn_hotel3.text)) dropdown_stay.add_widget(btn_hotel3) btn_hotel4 = Button(text='Hotel 4*', size_hint_y=None, height=30) btn_hotel4.bind( on_release=lambda btn: dropdown_stay.select(btn_hotel4.text)) dropdown_stay.add_widget(btn_hotel4) btn_hotel5 = Button(text='Hotel 5*', size_hint_y=None, height=30) btn_hotel5.bind( on_release=lambda btn: dropdown_stay.select(btn_hotel5.text)) dropdown_stay.add_widget(btn_hotel5) button_stay.bind(on_release=dropdown_stay.open) dropdown_stay.bind( on_select=lambda instance, x: setattr(button_stay, 'text', x)) layout.add_widget(button_stay) # self.label = Label(text="") # layout.add_widget(self.label) # self.label = Label(text="") # layout.add_widget(self.label) btn_lr = Button(text="Logical Regression") btn_lr.bind(on_press=self.buttonClicked_LR) layout.add_widget(btn_lr) self.lr_taste = TextInput(text='', multiline=False) layout.add_widget(self.lr_taste) btn_dt = Button(text="Decision Tree") btn_dt.bind(on_press=self.buttonClicked_DT) layout.add_widget(btn_dt) self.dt_taste = TextInput(text='', multiline=False) layout.add_widget(self.dt_taste) btn_svm = Button(text="SVM") btn_svm.bind(on_press=self.buttonClicked_SVM) layout.add_widget(btn_svm) self.svm_taste = TextInput(text='', multiline=False) layout.add_widget(self.svm_taste) btn_rf = Button(text="Random Forest") btn_rf.bind(on_press=self.buttonClicked_RF) layout.add_widget(btn_rf) self.rf_taste = TextInput(text='', multiline=False) layout.add_widget(self.rf_taste) self.label12 = Label(text="Email") layout.add_widget(self.label12) self.email = TextInput(text='', multiline=False) layout.add_widget(self.email) btn_best_tt = Button(text="Partner") btn_best_tt.bind(on_press=self.buttonClicked_TT) layout.add_widget(btn_best_tt) self.tt_taste = TextInput(text='', multiline=False) layout.add_widget(self.tt_taste) return layout
class DropDownButton(Button): """ Base class for dropdown containing buttons. Assumes dropdown container doesn't contain *boxes* with buttons, and that all buttons result in dropdown being closed. """ 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 container_child_height(self): return self.container_buttons_height_ratio * self.height @property def container_children(self): return self.dropdown.container.children @property def first_button(self): return self.container_children[-1] def on_release(self, *args): super(DropDownButton, self).on_release(*args) for btn in self.container_children: btn.height = self.container_child_height() @staticmethod def content_button(): """ Returns instance of Button after applying specific params. :return: (Button instance) """ return Button(size_hint_y=None,) def bind_to_on_release_and_add_container(self, btn): btn.bind(on_release=self.apply_on_release_effects) btn.bind(on_release=self.dropdown.dismiss) self.dropdown.add_widget(btn) # Abstract def add_dropdown_contents(self, *args): raise NotImplementedError # Abstract def apply_on_release_effects(self, btn): """ Applies all `on_release` effects of a dropdown child excluding `dismiss`. :param btn: button instance :return: (None) """ raise NotImplementedError # Abstract def set_initial_dropdown_selection(self): raise NotImplementedError
class AnnualTrendsClientGrid(GridLayout): def __init__(self, **kwargs): super(AnnualTrendsClientGrid, self).__init__(**kwargs) self.cols = 1 self.inside = GridLayout(padding=[30, 2, 30, 2], spacing=2) self.inside.cols = 1 self.inside.add_widget( Label(text="Domain: ", size_hint_y=None, height=32)) self.dropdown = DropDown() result_set = [] for domain in CassandraHelper.get_all_domains().current_rows: result_set.append(domain.domain) result_set.sort() domains = set(result_set) for domain in domains: btn = Button(text=domain, size_hint_y=None, height=32) btn.bind(on_release=lambda btn: self.dropdown.select(btn.text)) self.dropdown.add_widget(btn) self.mainbutton = Button(text='Select domain', size_hint_y=None, height=35) self.mainbutton.bind(on_release=self.dropdown.open) self.dropdown.bind( on_select=lambda instance, x: setattr(self.mainbutton, 'text', x)) self.inside.add_widget(self.mainbutton) self.inside.add_widget( Label(text="Year to investigate trending topics: ", size_hint_y=None, height=32)) self.year = TextInput(multiline=False, size_hint_y=None, height=32) self.inside.add_widget(self.year) self.inside.add_widget( Label(text="Top k topics: ", size_hint_y=None, height=32)) self.k = TextInput(multiline=False, size_hint_y=None, height=32) self.k.text = "10" self.inside.add_widget(self.k) self.btnGetTopk = Button(text="Get top k topics", size_hint_y=None, height=35) self.btnGetTopk.bind(on_press=self.visualize_trending_topics) self.inside.add_widget(self.btnGetTopk) self.inside.add_widget( Label(text="Topic to visualize trend:", size_hint_y=None, height=32)) self.topic = TextInput(multiline=False, size_hint_y=None, height=32) self.inside.add_widget(self.topic) self.btnVisualizeTrend = Button( text="Visualize topic trend from 2015 to 2019", size_hint_y=None, height=35) self.btnVisualizeTrend.bind(on_press=self.visualize_annual_tag_trend) self.inside.add_widget(self.btnVisualizeTrend) self.add_widget(self.inside) def visualize_trending_topics(self, instance): year = int(self.year.text) k = int(self.k.text) domain = self.mainbutton.text tags = CassandraHelper.get_annual_trend_tag_by_year(domain, year) if tags[0].tags: all_tags = tags[0].tags.items() all_tags = sorted(all_tags, key=lambda x: x[1]) all_tags.reverse() all_tags = all_tags[0:k] x_pos = np.arange(len(all_tags)) plt.bar(x_pos, [x[1] for x in all_tags], align='center', alpha=0.5) plt.xticks(x_pos, [x[0] for x in all_tags]) plt.ylabel('Usage') plt.title('Top ' + str(k) + ' Topics') plt.show() else: print("No topics found for the given domain and year.") def visualize_annual_tag_trend(self, instance): domain = self.mainbutton.text tag = self.topic.text years = {2015: 0, 2016: 0, 2017: 0, 2018: 0, 2019: 0} for year in years: tags = CassandraHelper.get_annual_trend_tag_by_year(domain, year) if tags[0].tags.get(tag): years[year] = tags[0].tags.get(tag) years = sorted(years.items(), key=lambda x: x[0]) x_pos = np.arange(len(years)) years_x = [x[0] for x in years] years_x[-1] = "2019\ntill Aug" plt.plot(x_pos, [x[1] for x in years]) plt.xticks(x_pos, years_x) plt.ylabel('Usage') plt.xlabel('Year') plt.title('Topic Trend - ' + tag) plt.show()