def generatePDF(self):
        try:
            i = max(self.lPaid + self.lUnpaid)
        except:
            i = 0

        downloadFile(FILENAME)

        numberOfPermissions = simpledialog.askinteger('Antal', 'Hur många tillstånd?')

        while numberOfPermissions != None and numberOfPermissions % 3 != 0:
            tk.messagebox.showinfo('Fel', 'Måste vara jämt delbart med tre!')
            numberOfPermissions = simpledialog.askinteger('Antal', 'Hur många tillstånd?')

        if numberOfPermissions:
            self.updateListOfUnpaid(i, numberOfPermissions)
            fileName = creatPermissionPDF(self.apartmentNumber, i+1, numberOfPermissions)

            updateFile_PaidUnpaid(self.apartmentNumber, self.dPaid_dates, self.lUnpaid)

            if self.checkButtonVal.get():
                sendEmail(fileName, self.lEmail, 'Parkeringstillstånd', 'Här kommer dina parkeringstillstånd!')

            else:
                webbrowser.open_new(r'%s' % fileName)

    def reserve_Button(self):
        # Input the information
        input_id_value = simpledialog.askinteger("test", "Please enter customer ID: ")
        Input_Date_value = simpledialog.askstring("test","Please enter date for reservation: ") 
        Input_Time_value = simpledialog.askstring("test","Please enter time for reservation: ")
        InputService_value = simpledialog.askstring("test","Which services do you want?")
        length_value = simpledialog.askinteger("test", "For how long?")

        ServiceObject = eval(InputService_value)
        ServiceObject.reserve(input_id_value, Input_Date_value, Input_Time_value, length_value, InputService_value)

 def set_child_cap():
     """Requests new child cap from the user."""
     child_split = list(lnp.settings.childcap.split(':'))
     child_split.append('0')  # In case syntax is invalid
     v = simpledialog.askinteger(
         "Settings", "Absolute cap on babies + children:",
         initialvalue=child_split[0])
     if v is not None:
         v2 = simpledialog.askinteger(
             "Settings", "Max percentage of children in fort:\n"
             "(lowest of the two values will be used as the cap)",
             initialvalue=child_split[1])
         if v2 is not None:
             df.set_option('childcap', str(v)+':'+str(v2))
             binding.update()

 def parameterSelected(self, selectPos):
   """Callback when a parameter is selected"""
   tmParamExtraction = self.tmParamExtractions[selectPos]
   name = tmParamExtraction.name
   descr = tmParamExtraction.descr
   paramType = tmParamExtraction.valueType
   value = self.tmParamValues[selectPos]
   if paramType == UTIL.DU.BITS or paramType == UTIL.DU.SBITS or \
      paramType == UTIL.DU.UNSIGNED or paramType == UTIL.DU.SIGNED:
     answer = simpledialog.askinteger("Integer Parameter",
                                      descr + ": " + name,
                                      parent=self,
                                      initialvalue=value)
   elif paramType == UTIL.DU.BYTES or paramType == UTIL.DU.FLOAT or \
        paramType == UTIL.DU.TIME or paramType == UTIL.DU.STRING:
     answer = simpledialog.askstring("String Parameter",
                                     descr + ": " + name,
                                     parent=self,
                                     initialvalue=value)
   else:
     answer = None
   if answer == None:
     return
   # new parameter value entered --> update param value entry and list
   newValue = answer
   self.tmParamValues[selectPos] = newValue
   text = tmParamExtraction.descr + ": " + tmParamExtraction.name + " = " + str(newValue)
   self.parametersListbox.list().delete(selectPos)
   self.parametersListbox.list().insert(selectPos, text)

 def paramClicked(self, param, nodeID):
   """callback when a Param node is clicked"""
   innerTree = self.tree()
   if param.isReadOnly():
     return
   nodeKey = innerTree.item(nodeID, "text")
   nodeValues = innerTree.item(nodeID, "value")
   name = nodeValues[0]
   value = nodeValues[1]
   paramType = param.getParamType()
   if paramType == UTIL.DU.BITS or paramType == UTIL.DU.SBITS or \
      paramType == UTIL.DU.UNSIGNED or paramType == UTIL.DU.SIGNED:
     answer = simpledialog.askinteger("Integer Parameter",
                                      nodeKey + ": " + name,
                                      parent=self,
                                      initialvalue=value)
   elif paramType == UTIL.DU.BYTES or paramType == UTIL.DU.FLOAT or \
        paramType == UTIL.DU.TIME or paramType == UTIL.DU.STRING:
     answer = simpledialog.askstring("String Parameter",
                                     nodeKey + ": " + name,
                                     parent=self,
                                     initialvalue=value)
   else:
     answer = None
   if answer == None:
     return
   # new parameter value entered --> update param object and tree
   newValue = answer
   param.value = newValue
   innerTree.set(nodeID, 1, newValue)

def inputdata():
	x = tkSimpleDialog.askinteger("Input","Multiplier")
	if x:
		tkMessageBox.showwarning("Yes",x)
		listbox.insert(END, x)
	else:
		tkMessageBox.showwarning("No","You did it wrong")

    def delete_rode(self, event):
        if Rodstable.count == 0:
            showerror('Ошибка удаления', 'В таблице не осталось заполненных полей')
            return

        number_to_del = askinteger('', 'Введите № стержня:', parent=self)
        if number_to_del not in Rodstable.dict_items:
            showwarning('Предупреждение', 'Вы пытаетесь удалить стержень, которого '
                                          'не существует', parent=self)
            return

        self.clear_table()

        Rodstable.dict_items.pop(number_to_del)
        Rodstable.count -= 1
        for item in Rodstable.dict_items:
            if item > number_to_del:
                Rodstable.dict_items[item - 1] = (Rodstable.dict_items[item][0],
                                                  Rodstable.dict_items[item][1],
                                                  Rodstable.dict_items[item][2],
                                                  Rodstable.dict_items[item][3],
                                                  Rodstable.dict_items[item][4])
                Rodstable.dict_items.pop(item)

        self.fill_table()

 def plotRate(Kn, K1, KnSD, K1SD, CONC, antib):
     Kn1=Kn/K1
     SDkn1=(Kn/K1)*np.sqrt(((KnSD/Kn)**2)+((K1SD/K1)**2))
     
     fig=plt.figure()
     ax = fig.add_subplot(111)
     ax.errorbar(CONC, Kn1,yerr=SDkn1,color='g',label='$'+str('wt')+str(antib)+'- %s$' % str('Kn/K1'))
     ax.legend(fontsize=16)
     #ax.set_xlim([-1,max()]) 
     ax.set_ylim([0.001,1.5])
     if x_ax==True:
         xe=simpledialog.askinteger('X_lim','set_xlim')
     else:
         xe=max(conc[str(ant)])
     ax.set_xlim([0,xe])
     
     ax.set_yscale('linear',fontsize=16)
     ax.set_xscale('linear',fontsize=16)
     ax.tick_params(axis='x', labelsize=14)
     ax.tick_params(axis='y', labelsize=14)
     plt.ylabel('Kn/K1',fontsize=16)
     plt.xlabel('Conc '+str(antib)+ ' (microM)',fontsize=16)
     ax.grid(True) 
     #fig.savefig(str(antib)+str(n1)+':'+str(n2)+'.pdf')
     return fig

 def set_pop_cap(self):
     """Requests new population cap from the user."""
     v = simpledialog.askinteger(
         "Settings", "Population cap:",
         initialvalue=self.lnp.settings.popcap, parent=self.root)
     if v is not None:
         self.lnp.set_option('popcap', v)
         self.update_displays()

 def set_graze_coef():
     """Requests new graze coefficient from the user."""
     v = simpledialog.askinteger(
         "Settings", "Graze coefficient:",
         initialvalue=lnp.settings.grazeCoef)
     if v is not None:
         df.set_option('grazeCoef', str(v))
         binding.update()

 def set_pop_cap(self):
     """Requests new population cap from the user."""
     v = simpledialog.askinteger(
         "Settings", "Population cap:",
         initialvalue=self.lnp.settings.popcap)
     if v is not None:
         self.lnp.set_option('popcap', str(v))
         binding.update()

 def set_strict_pop_cap():
     """Requests new strict population cap from the user."""
     v = simpledialog.askinteger(
         "Settings", "Strict population cap:",
         initialvalue=lnp.settings.strictPopcap)
     if v is not None:
         df.set_option('strictPopcap', str(v))
         binding.update()

    def getN_NumMines(self, **kwargs):
        """
		gets N and num_mines {from the user in text mode|from the kwargs in test mode}
	"""
        if self.app_type == 'text':
            N = int(input('Please input the size of board (e.g., 16): '))
            num_mines = int(input('Please input the number of mines (e.g., 15): '))
            return N, num_mines
        elif self.app_type == 'test':
            N = kwargs['N']
            num_mines = kwargs['num_mines']
            return N, num_mines
        elif self.app_type == 'gui':
            master = kwargs['master']
            master.withdraw()
            N = simpledialog.askinteger('Minesweeper','Enter Size of Map:',minvalue=1,maxvalue=25)#TODO: check min/max
            num_mines = simpledialog.askinteger('Minesweeper','Enter Number of Mines:',minvalue=1, maxvalue=N*N-1) #TODO: check min/max
            return N, num_mines

def gotoQuestion():
  global socket, running
  if running:
    questionNo = simpledialog.askinteger("Go to question...", "Question Number:")
    if questionNo:
      disableButton()
      network.sendMessage('gotoQu', questionNo, socket)
  else:
    messagebox.showerror("Error", "Server has not Started Running Yet!")

 def node_modify(self, event):
     i = self.get_node_at_coord(event.x, event.y)
     if not i:
         return
     weight = simpledialog.askinteger("Weight", "Enter weight of node {}".format(i),
                                      initialvalue=self.nodes[i]['weight'])
     if weight:
         self.nodes[i]['weight'] = weight
     self.redraw()

 def line_modify(self, event):
     start, end = self.get_line_at_coord(event.x, event.y)
     if not start:
         return
     weight = simpledialog.askinteger("Weight", "Enter weight of connection {}-{}".format(start, end),
                                      initialvalue=self.connections[(start, end)])
     if weight:
         self.connections[(start, end)] = weight
     self.redraw()

    def AvailableTimeForService_Button(self):
        InputService_value = simpledialog.askstring("test","Which services do you want?")
        Start_Date_value = simpledialog.askstring("test","Please enter start date: ") 
        Start_Time_value = simpledialog.askstring("test","Please enter start time: ")
        End_Date_value = simpledialog.askstring("test","Please enter end date: ") 
        End_Time_value = simpledialog.askstring("test","Please enter end time: ")
        length_value = simpledialog.askinteger("test", "For how long?")

        AvailableTimeForServiceInstance = AvailableTimeForService(Start_Date_value, Start_Time_value,End_Date_value, End_Time_value, InputService_value, length_value)

def rand_board():
    global board
    global step
    global openfile
    density = tkd.askinteger('Density', 'enter a cell density between 0 and 100')
    create_random_board(density)
    step = 1
    openfile = 'empty_board.gol'
    display_board(board)

 def insertClicked(self,root):
   listName = "personnel"
   selection = self.view.tree1.selection()
   if len(selection) > 0:
     listName = self.view.tree1.item(selection[0])['text']
   idt = tkSimpleDialog.askinteger(title = 'personnel ID',prompt = 'input personnel ID:',minvalue = 1)
   name = tkSimpleDialog.askstring(title = 'name',prompt = "input personnel's name:")
   gender = tkSimpleDialog.askstring(title = 'gender',prompt = "input personnel's gender:",initialvalue="male")
   age = tkSimpleDialog.askinteger(title = 'age',prompt = "input personnel's age:",initialvalue=20,minvalue = 0)
   nationality = tkSimpleDialog.askstring(title = 'nationality',prompt = "input personnel's nationality:",initialvalue="China")
   phone = tkSimpleDialog.askstring(title = 'phone number',prompt = "input personnel's phone number:",initialvalue="0")
   if name == "":
     tkMessageBox.showerror("Error","invalid input, personnel's name can not be empty")
     return
   if True == self.service.insert(listName, idt, name, gender, age, nationality, phone):
     #dictres = selectByIdt(listName,idt)
     self.loadDetails(root)
   else:
     tkMessageBox.showerror("Error","Sorry, this personnel ID may already exist in database")

 def reset_board(self):
     probability = tkdialogs.askinteger("Probability",
                                        "Enter a probability of a cell being alive, ranging from 0 to 100\n"
                                        "\tTo get an empty board use the '0' value")
     if probability is None or probability < 0 or probability > 100: # None is returned if 'Cancel' is pressed
         return
     self.board.board = board.BoardFactory.generate_randomized_board_field(h_size=self.board.horizontal_size,
                                                                           v_size=self.board.vertical_size,
                                                                           probability=probability)
     self.board.update_observers()   # update all observers over changed board manually