class readApp(qtBasics, readUi):
__fileIO = fileIO()
__story = []
__sepa = ";~sepa~;"
quitSignalExit = QtCore.pyqtSignal(int)
def __init__(self, x, y, columnCount):
readUi.__init__(self, x, y, columnCount)
qtBasics.__init__(self)
def initUi(self, xPos, yPos):
self.move(xPos, yPos)
self.tableWidget.itemDoubleClicked.connect(self.openLink)
self.tableWidget.setRowCount(0)
def addStoryToTable(self, singleStory):
numOfRows = self.tableWidget.rowCount()
qtStory = QTableWidgetItem(singleStory.getTitle())
self.tableWidget.insertRow(numOfRows)
self.tableWidget.setItem(numOfRows, 0, qtStory)
def fillTable(self, file):
self.__story = []
self.tableWidget.setRowCount(0)
for i, singleStory in enumerate(
self.__fileIO.simpleRead(file,
multiLine=True,
separator=self.__sepa)):
self.__story.append(story(singleStory[0], singleStory[1]))
self.addStoryToTable(self.__story[i])
def openLink(self, item):
self.__story[item.row()].openLink()
def __init__(self):
self.__time = clockDate()
self.__calendar = mycalendar(6.5, 0, 10)
self.__news = news(.5, 6, 32)
self.__events = events(.5, 1.2, 32)
self.__weather = weather(13, 0, 12)
self.__config = config()
self.__fileIO = fileIO()
self.__socketServer = socketServer()
self.__initFoldersAndFiles = initFoldersAndFiles()
self.__gpio = gpioInterface()
self.__initFoldersAndFiles.initAllFolders()
self.__initFoldersAndFiles.initAllFiles()
pygame.init()
pygame.display.set_caption("Smart Mirror")
pygame.time.set_timer(pygame.USEREVENT + 1, 5000)
self.__config.setColor()
self.__gpio.setBrightness()
self.__fonts = self.__config.getAllFonts()
self.__clock = pygame.time.Clock()
self.__screen = pygame.display.set_mode((1024, 600), pygame.FULLSCREEN)
pygame.mouse.set_visible(False)
self.__run = True
self.__newsIndex = 0
self.__eventsIndex = 0
self.addJobs()
class sleepTimerApp(qtBasics, sleepTimerUi):
__fileIO = fileIO()
__sleepFile = "data/configFiles/sleepTimer.txt"
quitSignalExit = QtCore.pyqtSignal(int)
quitSignalAccept = QtCore.pyqtSignal(int)
def __init__(self, x, y):
sleepTimerUi.__init__(self, x, y)
qtBasics.__init__(self)
self.__text = ""
self.applyButton.clicked.connect(self.applyClicked)
self.disableCheckBox1.clicked.connect(self.toggleSleep)
self.disableCheckBox2.clicked.connect(self.toggleWake)
def applyClicked(self):
self.writeToFile()
self.setVisible(False)
self.quitSignalAccept.emit(1)
def writeToFile(self):
self.__text = str(self.sleepTimeEdit.text()) + "\n" + str(
self.wakeTimeEdit.text()) + "\n" + str(
self.spinBox.value()) + "\n" + str(
self.disableCheckBox1.isChecked()) + "\n" + str(
self.disableCheckBox2.isChecked())
self.__fileIO.simpleWrite(self.__sleepFile, self.__text)
def readFromFile(self):
text = self.__fileIO.simpleRead(self.__sleepFile, multiLine=True)
time = text[0].split(":")
self.sleepTimeEdit.setTime(QtCore.QTime(int(time[0]), int(time[1])))
time = text[1].split(":")
self.wakeTimeEdit.setTime(QtCore.QTime(int(time[0]), int(time[1])))
self.spinBox.setValue(int(text[2]))
if (text[3] in "True"):
self.disableCheckBox1.setChecked(True)
else:
self.disableCheckBox1.setChecked(False)
if (text[4] in "True"):
self.disableCheckBox2.setChecked(True)
else:
self.disableCheckBox2.setChecked(False)
self.toggleSleep()
self.toggleWake()
def toggleSleep(self):
if (self.disableCheckBox1.isChecked()):
self.wakeTimeEdit.setEnabled(False)
self.sleepTimeEdit.setEnabled(False)
else:
self.wakeTimeEdit.setEnabled(True)
self.sleepTimeEdit.setEnabled(True)
def toggleWake(self):
if (self.disableCheckBox2.isChecked()):
self.spinBox.setEnabled(False)
else:
self.spinBox.setEnabled(True)
def __init__(self, xOffset=0, yOffset=0, move=0):
self.__xOffset = xOffset
self.__yOffset = yOffset
self.__move = move
self.__fileIO = fileIO()
self.__text = []
self.__drawFlag = True
def __init__(self):
self.__listenFlag = True
self.__runFlag = True
self.__eventFlag = False
self.__configFlag = False
self.__weatherFlag = False
self.__newsFlag = False
self.__weatherGetFlag = False
self.__serverBound = False
self.__fileIO = fileIO()
self.__server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
def __init__( self ): self.__listenFlag = True self.__runFlag = True self.__eventFlag = False self.__configFlag = False self.__weatherFlag = False self.__newsFlag = False self.__weatherGetFlag = False self.__fileIO = fileIO( ) self.__server = socket.socket( socket.AF_INET, socket.SOCK_STREAM ) self.__server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.__server.bind(( self.__ip, self.__port )) self.__server.listen( 5 ) delay = 0.1 listenThread = threading.Thread( target=self.listenForClient, args=(delay,)) listenThread.start( )
class country:
__sepa = ";~sepa~;"
__fileIO = fileIO()
__country = None
__ID = ''
__listOfIDs = ['ww', 'rs', 'gb', 'us', 'ru', 'gr', 'ch'] # ww-world wide
__listOfCountryNames = [
'World Wide', 'Serbia', 'United Kingdom', 'United States', 'Russia',
'Greece', 'China'
]
def __init__(self, country):
self.__country = country
self.__ID = self.__listOfIDs[self.__country.currentIndex()]
self.__country.currentIndexChanged.connect(self.setID)
def setID(self):
self.__ID = self.__listOfIDs[self.__country.currentIndex()]
def getID(self):
return self.__ID
def getCountryName(self):
return self.__country.itemText(self.__country.currentIndex())
def getCountryBox(self):
return self.__country
def writeToFile(self, file):
self.__fileIO.simpleWrite(
file,
self.getCountryName() + self.__sepa + self.__ID)
def readFromFile(self, file):
name = self.__fileIO.simpleRead(file, separator=self.__sepa)[0]
self.__country.setCurrentIndex(self.__country.findText(name))
class newsList:
__separator = ";~sepa~;"
__fileIO = fileIO()
def __init__(self, label, table1, table2):
self.__sources = table1
self.__category = table2
self.__country = label
def updateTables(self, sourceFile, categoryFile):
self.updateList(sourceFile, self.__category)
self.updateList(categoryFile, self.__sources)
def updateList(self, file, qtList):
qtList.clear()
for item in self.__fileIO.simpleRead(file, multiLine=True):
qtList.addItem(item)
def updateCountry(self, countryFile):
self.__country.setText(
self.__fileIO.simpleRead(countryFile,
separator=self.__separator)[0])
class event: __hour = "00" __minute = "00" __text = "" __fileIO = fileIO( ) __separator = ";~sepa~;" def __init__( self, hour, minute, text ): self.__hour = str( hour ) self.__minute = str( minute ) self.__text = text def getTime( self ): return self.__hour + ":" + self.__minute def getText( self ): return self.__text def addLeadingZero( self ): if( len( self.__hour ) == 1 ): self.__hour = "0" + self.__hour if( len( self.__minute ) == 1 ): self.__minute = "0" + self.__minute def formatForFile( self ): self.addLeadingZero( ) return self.__hour + ":" + self.__minute + self.__separator + self.__text def formatForTable( self ): self.addLeadingZero( ) return [ self.__hour + ":" + self.__minute, self.__text ] def writeToFile( self, file ): self.__fileIO.simpleWrite( file, self.formatForFile( ), newLine=True, clearContents=False )
class story: __sepa = ";~sepa~;" __fileIO = fileIO( ) def __init__( self, link, title ): self.__link = link self.__title = title def getLink( self ): return self.__link def getTitle( self ): return self.__title def setLink( self, link ): self.__link = link def setTitle( self, title ): self.__title = title def writeToFile( self, file ): self.__fileIO.simpleWrite( file, self.__link + self.__sepa + self.__title, newLine=True, clearContents=False ) def openLink( self ): webbrowser.open( self.__link )
class config:
__white = (255, 255, 255)
__red = (255, 0, 0)
__color = ( 0, 255, 255 )
__colorInv = __red
__colorFile = "data/configFiles/colorFile.txt"
__brightnessFile = "data/configFiles/brightnessFile.txt"
__fontFile = "data/configFiles/fontFile.txt"
__speedFile = "data/configFiles/speedFile.txt"
__viewFile = "data/configFiles/viewFile.txt"
__sleepFile = "data/configFiles/sleepTimer.txt"
__fileIO = fileIO( )
def __init__( self ):
#self.__vcgencmd = Vcgencmd( )
self.__valChange = ["", "", ""]
self.__fonts = [0] *8
self.__cSize = 0
self.__scheduler = BackgroundScheduler( )
self.__scheduler.start( )
self.__sleepF1 = True
self.__sleepF2 = True
def setColor( self ):
color, colorInv = self.__fileIO.simpleRead( self.__colorFile, separator=":" )
self.__color = [int( color[ i : i +2 ], 16 ) for i in range( 1, len(color) -1, 2 )]
self.__colorInv = [int( colorInv[ i : i +2 ], 16 ) for i in range( 1, len(colorInv) -1, 2 )]
if( self.__color == self.__white ):
self.__colorInv = self.__red
return self.__color, self.__colorInv
def setBrightness( self ):
brightness = self.__fileIO.simpleRead( self.__brightnessFile )
if( sys.platform == "linux" or sys.platform == "linux2" ):
import os
os.system( 'xbacklight -set ' + brightness )
elif( sys.platform == "win32" ):
import wmi
wmi.WMI( namespace='wmi' ).WmiMonitorBrightnessMethods( )[0].WmiSetBrightness( int( brightness ), 1 )
def setSleepTime( self ):
sleep = self.__fileIO.simpleRead( self.__sleepFile, multiLine=True )
if( len( sleep ) > 4 ):
if( self.__valChange[0] != sleep[0] or self.__valChange[1] != sleep[1] ):
try:
self.__sleepF1 = True
self.__scheduler.remove_job( 'dpoff' )
self.__scheduler.remove_job( 'dpon' )
except:
print( "IN config::setSleepTime: jobs dont exist!" )
if( self.__valChange[2] != sleep[2] ):
try:
self.__sleepF2 = True
self.__scheduler.remove_job( "dim" )
except:
print( "IN config::setSleepTime: jobs dont exist!" )
if( sleep[3] in "False" and self.__sleepF1 ):
self.__sleepF1 = False
hr = int( sleep[0].split(":")[0] )
mi = int( sleep[0].split(":")[1] )
self.__scheduler.add_job( lambda: self.__vcgencmd.display_power_off( 2 ), "cron", hour=hr, minute=mi, id='dpoff' )
#self.__scheduler.add_job( lambda: self.displayOffTest(hr), "cron", hour=hr, minute=mi, id='dpoff' )
hr = int( sleep[1].split(":")[0] )
mi = int( sleep[1].split(":")[1] )
self.__scheduler.add_job( lambda: self.__vcgencmd.display_power_on( 2 ), "cron", hour=hr, minute=mi, id='dpon')
#self.__scheduler.add_job( lambda: self.displayOnTest(hr), "cron", hour=hr, minute=mi, id='dpon' )
elif( sleep[3] in "True" and not self.__sleepF1 ):
self.__sleepF1 = True
self.__scheduler.remove_job( 'dpoff' )
self.__scheduler.remove_job( 'dpon' )
self.__vcgencmd.display_power_on( 2 )
#print( "Display on: " )
if( sleep[4] in "False" and self.__sleepF2 ):
self.__sleepF2 = False
self.__scheduler.add_job( lambda: self.__vcgencmd.display_power_off( 2 ), "interval", minutes=int( sleep[2] ), id='dim' )
#self.__scheduler.add_job( lambda: self.displayOffTest(int(sleep[2])), "interval", minutes=int( sleep[2] ), id='dim' )
elif( sleep[4] in "True" and not self.__sleepF2 ):
self.__sleepF2 = True
self.__scheduler.remove_job( 'dim' )
self.__vcgencmd.display_power_on( 2 )
#print( "Display on: " )
self.__valChange = [sleep[0], sleep[1], sleep[2]]
print( self.__scheduler.print_jobs( ))
def displayOffTest( self, hr ):
print( "Display off: ", hr )
def displayOnTest( self, hr ):
print( "Display on: ", hr )
def readFontFromFile( self ):
font = self.__fileIO.simpleRead( self.__fontFile, multiLine=True )
font[ 0 ] = font[ 0 ].split( "," )[ 0 ]
font[ 1 ] = int( font[ 1 ])
if( len( font ) == 2 ):
font.append( False )
font.append( False )
elif( len( font ) == 3 ):
if( 'Bold' in font[ 2 ]):
font[ 2 ] = True
font.append( False )
else:
font[ 2 ] = False
font.append( True )
elif( len( font ) == 4 ):
font[ 2 ] = True
font[ 3 ] = True
return font
def getFont( self, index ):
return self.__fonts[index]
def setCSize( self, size ):
self.__cSize = size
def getSpeed( self ):
speed = self.__fileIO.simpleRead( self.__speedFile )
if( "Non" in speed ):
return 0
else:
return int( speed ) *1000
def getView( self ):
return self.__fileIO.simpleRead( self.__viewFile, multiLine=True )[0]
def getAllFonts( self ):
fontName, fontSize, bold, italic = self.readFontFromFile( )
try:
self.__fonts[0] = pygame.font.SysFont( fontName, fontSize + self.__cSize, bold=bold, italic=italic )#calendar
self.__fonts[1] = pygame.font.SysFont( fontName, fontSize + 0 , bold=bold, italic=italic )#date
self.__fonts[2] = pygame.font.SysFont( fontName, fontSize + 32 , bold=bold, italic=italic )#time
self.__fonts[3] = pygame.font.SysFont( fontName, fontSize -12 , bold=bold, italic=italic )#events
self.__fonts[4] = pygame.font.SysFont( fontName, fontSize - 12 , bold=bold, italic=italic )#news
self.__fonts[5] = pygame.font.SysFont( fontName, fontSize - 4, bold=bold, italic=italic )#weather
self.__fonts[6] = pygame.font.SysFont( fontName, fontSize - 12 , bold=bold, italic=italic )#hour
self.__fonts[7] = pygame.font.SysFont( fontName, fontSize - 18 , bold=bold, italic=italic )#hour
except:
self.__fonts[0] = pygame.font.Font( fontName, fontSize , bold=bold, italic=italic )
self.__fonts[1] = pygame.font.Font( fontName, fontSize + 0 , bold=bold, italic=italic )
self.__fonts[2] = pygame.font.Font( fontName, fontSize + 32 , bold=bold, italic=italic )
self.__fonts[3] = pygame.font.Font( fontName, fontSize -12 , bold=bold, italic=italic )
self.__fonts[4] = pygame.font.Font( fontName, fontSize - 12 , bold=bold, italic=italic )
self.__fonts[5] = pygame.font.Font( fontName, fontSize - 4 , bold=bold, italic=italic )
self.__fonts[6] = pygame.font.Font( fontName, fontSize - 12 , bold=bold, italic=italic )
self.__fonts[7] = pygame.font.Font( fontName, fontSize - 18 , bold=bold, italic=italic )
return self.__fonts
def __init__(self, progressBar):
self.__newsapi = NewsApiClient(api_key=self.__apiKey)
self.__fileIO = fileIO()
self.__progressBar = progressBar
class checkBoxHandler:
__allCheckBox = None
__checkBox = []
__fileIO = fileIO()
__numOfChecked = 0
def __init__(self, allCheckBox, checkBox):
self.__allCheckBox = allCheckBox
self.__checkBox = checkBox
self.__allCheckBox.clicked.connect(self.setAllCheckBoxState)
for i in range(len(self.__checkBox)):
self.__checkBox[i].clicked.connect(
lambda _, box=self.__checkBox[i]: self.setCheckBoxState(box))
def getCheckBoxLen(self):
cbLen = 0
for box in self.__checkBox:
if (len(box.text())):
cbLen += 1
print(cbLen, " LEN")
return cbLen
def getCheckBoxNames(self):
selected = []
for checkBox in self.__checkBox:
if (checkBox.isChecked()):
selected.append(checkBox.text())
return selected
def setCheckBoxName(self, index, name):
self.__checkBox[index].setText(name)
def setCheckBoxState(self, checkBox):
if (checkBox.isChecked()):
self.__numOfChecked += 1
else:
self.__numOfChecked -= 1
self.checkTriState()
def setAllCheckBoxState(self):
state = self.__allCheckBox.isChecked()
if (state == 1): #Dont want tri state from click
state = 2
self.__allCheckBox.setCheckState(state)
if (state == 2 or state == 0):
for checkBox in self.__checkBox:
checkBox.setChecked(state)
if (state):
self.__numOfChecked = self.getCheckBoxLen()
else:
self.__numOfChecked = 0
def checkTriState(self):
state = 0 # false
if (self.__numOfChecked == self.getCheckBoxLen()):
state = 2 # true
elif (self.__numOfChecked > 0
and self.__numOfChecked < self.getCheckBoxLen()):
state = 1 # tri
self.setTriState(state)
def setTriState(self, state): # 0-false 1-triState 2-True
self.__allCheckBox.setCheckState(state)
def checkIfSet(self, index):
return self.__checkBox[index].isChecked()
def changeCheckBox(self, listOfNewText):
for checkBox in self.__checkBox:
checkBox.hide()
checkBox.setText("")
checkBox.setChecked(False)
for i, text in enumerate(listOfNewText):
self.__checkBox[i].setText(text)
self.__checkBox[i].show()
self.__numOfChecked = i
self.setTriState(False)
def writeCheckedToFile(self, file):
self.__fileIO.conditionalQtWrite(file,
self.__checkBox,
newLine=True,
clearContents=True)
def readCheckedFromFile(self, file):
self.__numOfChecked = self.__fileIO.conditionalQtRead(
file, self.__checkBox)
print(self.__numOfChecked)
self.checkTriState()
class weather(drawPygame):
__apiKey = "axtloV8pqzpCuvRImrZgGhASPTbDSphV"
#__iconPath = "/home/pi/SmartMirror/data/weather/icons/"
__iconPath = "/home/pi/SmartMirror/icons/"
__weatherFile = "/home/pi/SmartMirror/data/weather/weather.txt"
__weatherDataFile = "/home/pi/SmartMirror/data/weather/weatherData.txt"
__fileIO = fileIO()
def __init__(self, xOffset, yOffset, move):
super().__init__(xOffset, yOffset, move)
pygame.init()
self.__weather = []
self.__data = []
self.__metricSymbol = "True"
def saveWeatherFormat(self, weather):
self.__data = []
for hour in weather:
hourlyData = hour['DateTime'].split("T")[1] + "~" + str(
hour['WeatherIcon']) + "~" + str(
hour['PrecipitationProbability']) + "~" + str(
hour['Temperature']['Value'])
self.__data.append(hourlyData)
def getWeather(self):
weatherConfig = self.__fileIO.simpleRead(self.__weatherFile,
multiLine=True)
if (weatherConfig[0] in "Celsius"):
self.__metricSymbol = "True"
else:
self.__metricSymbol = "False"
city = weatherConfig[1]
try:
url = "http://dataservice.accuweather.com/locations/v1/cities/RS/search?apikey= " + self.__apiKey + "&q=" + city
result = requests.get(url).json()
url = "http://dataservice.accuweather.com/forecasts/v1/hourly/12hour/" + result[
0]['Key'] + "?apikey= " + self.__apiKey + "&metric=" + self.__metricSymbol
weather = requests.get(url).json()
self.saveWeatherFormat(weather)
except:
print(datetime.now().strftime("%H:%M:%S"),
"IN weather::getWeather: Error getting new weather")
def renderText(self, color, colorInv, hFont, font, defFont):
self.__hour = []
self.__icon = []
self.__perc = []
self.__temp = []
#self.__data = ["00:11:11" + "~" + str( 1 ) + "~" + str( 20 ) + "~" + str( 20 ),"01:11:11" + "~" + str( 1 ) + "~" + str( 20 ) + "~" + str( 20 ),"02:11:11" + "~" + str( 1 ) + "~" + str( 20 ) + "~" + str( 20 ),"03:11:11" + "~" + str( 1 ) + "~" + str( 20 ) + "~" + str( 20 ),"04:11:11" + "~" + str( 1 ) + "~" + str( 20 ) + "~" + str( 20 ),"05:11:11" + "~" + str( 1 ) + "~" + str( 20 ) + "~" + str( 20 ),"06:11:11" + "~" + str( 1 ) + "~" + str( 20 ) + "~" + str( 20 ),"07:11:11" + "~" + str( 1 ) + "~" + str( 20 ) + "~" + str( 20 ),"08:11:11" + "~" + str( 1 ) + "~" + str( 20 ) + "~" + str( 20 ),"09:11:11" + "~" + str( 1 ) + "~" + str( 20 ) + "~" + str( 20 ),"10:11:11" + "~" + str( 1 ) + "~" + str( 20 ) + "~" + str( 20 ),"11:11:11" + "~" + str( 1 ) + "~" + str( 20 ) + "~" + str( 20 ),"12:11:11" + "~" + str( 1 ) + "~" + str( 20 ) + "~" + str( 20 )]
for t in self.__data:
hour, icon, perc, temp = t.split("~")
self.__hour.append(
hFont.render(
hour.split(":")[0] + ":" + hour.split(":")[1], True,
colorInv))
self.__perc.append(font.render(perc + "%", True, color))
self.__temp.append(
font.render(str(round(float(temp))), True, color))
if (self.__metricSymbol == "True"):
self.__metric = defFont.render('\u2103', True, color) #*C
else:
self.__metric = defFont.render('\u2109', True, color) #*F
self.__icon.append(
pygame.image.load(self.__iconPath + icon + ".png"))
def drawText(self, screen, numOfHours, everyNumOfHours, numOfColumns):
if (super().getDrawFlag() and len(self.__data)):
x = 0
z = 0
for j, i in enumerate(range(0, numOfHours, everyNumOfHours)):
if (not j % numOfColumns and j != 0):
x += 1
z = 0
screen.blit(self.__hour[i],
(super().getXoffset() * super().getStep() +
super().getStep() * 1.6 + z *
(3 * super().getStep() - super().getMove()),
super().getYoffset() * super().getStep() + x *
(1.7 * super().getStep() - super().getMove())))
screen.blit(self.__perc[i],
(super().getXoffset() * super().getStep() +
super().getStep() * .5 + z *
(3 * super().getStep() - super().getMove()),
super().getYoffset() * super().getStep() +
super().getStep() * .66 + x *
(1.7 * super().getStep() - super().getMove())))
screen.blit(self.__temp[i],
(super().getXoffset() * super().getStep() +
super().getStep() * .5 + z *
(3 * super().getStep() - super().getMove()),
super().getYoffset() * super().getStep() + x *
(1.7 * super().getStep() - super().getMove())))
screen.blit(self.__metric,
(super().getXoffset() * super().getStep() +
super().getStep() * .5 + z *
(3 * super().getStep() - super().getMove()) +
self.__temp[i].get_width() + 2,
super().getYoffset() * super().getStep() + x *
(1.7 * super().getStep() - super().getMove()) +
(self.__temp[i].get_height() / 2 -
self.__metric.get_height() / 2)))
screen.blit(self.__icon[i],
(super().getXoffset() * super().getStep() +
super().getStep() * 1.4 + z *
(3 * super().getStep() - super().getMove()),
super().getYoffset() * super().getStep() +
super().getStep() * .5 + x *
(1.7 * super().getStep() - super().getMove())))
z += 1
class config:
__white = (255, 255, 255)
__red = (255, 0, 0)
__color = (0, 255, 255)
__colorInv = __red
__colorFile = "/home/pi/SmartMirror/data/configFiles/colorFile.txt"
__brightnessFile = "/home/pi/SmartMirror/data/configFiles/brightnessFile.txt"
__fontFile = "/home/pi/SmartMirror/data/configFiles/fontFile.txt"
__speedFile = "/home/pi/SmartMirror/data/configFiles/speedFile.txt"
__viewFile = "/home/pi/SmartMirror/data/configFiles/viewFile.txt"
__sleepFile = "/home/pi/SmartMirror/data/configFiles/sleepTimer.txt"
__fileIO = fileIO()
__defFontName = "Serif"
def __init__(self):
self.__vcgencmd = Vcgencmd()
self.__pwm = pigpio.pi()
self.__valChange = ["None", "None", "None"]
self.__fonts = [0] * 8
self.__cSize = 0
self.__scheduler = BackgroundScheduler()
self.__scheduler.start()
self.__sleepF1 = True
self.__sleepF2 = True
self.__stayOffFlag = False
def getStayOffFlag(self):
return self.__stayOffFlag
def setStayOffFlag(self, state):
self.__stayOffFlag = state
def restartDim(self):
sleep = self.__fileIO.simpleRead(self.__sleepFile, multiLine=True)
try:
self.__scheduler.reschedule_job("dim",
trigger='interval',
minutes=int(sleep[2]))
except:
print(datetime.now().strftime("%H:%M:%S"),
"IN config::restartDim: cannot reschedule job!")
return -1
def setColor(self):
color, colorInv = self.__fileIO.simpleRead(self.__colorFile,
separator=":")
self.__color = [
int(color[i:i + 2], 16) for i in range(1,
len(color) - 1, 2)
]
self.__colorInv = [
int(colorInv[i:i + 2], 16) for i in range(1,
len(colorInv) - 1, 2)
]
if (self.__color == self.__white):
self.__colorInv = self.__red
return self.__color, self.__colorInv
def setSleepTime(self):
sleep = self.__fileIO.simpleRead(self.__sleepFile, multiLine=True)
if (len(sleep) > 4):
if (self.__valChange[0] != sleep[0]
or self.__valChange[1] != sleep[1]):
try:
self.__sleepF1 = True
self.__scheduler.remove_job('dpoff')
self.__scheduler.remove_job('dpon')
except:
print(datetime.now().strftime("%H:%M:%S"),
"IN config::setSleepTime: jobs dont exist!")
if (self.__valChange[2] != sleep[2]):
try:
self.__sleepF2 = True
self.__scheduler.remove_job("dim")
except:
print(datetime.now().strftime("%H:%M:%S"),
"IN config::setSleepTime: jobs dont exist!")
if (sleep[3] in "False" and self.__sleepF1):
self.__sleepF1 = False
hr = int(sleep[0].split(":")[0])
mi = int(sleep[0].split(":")[1])
self.__scheduler.add_job(self.displayOff,
"cron",
hour=hr,
minute=mi,
id='dpoff')
hr = int(sleep[1].split(":")[0])
mi = int(sleep[1].split(":")[1])
self.__scheduler.add_job(self.displayOn,
"cron",
hour=hr,
minute=mi,
id='dpon')
elif (sleep[3] in "True" and not self.__sleepF1):
self.__sleepF1 = True
self.__scheduler.remove_job('dpoff')
self.__scheduler.remove_job('dpon')
self.__vcgencmd.display_power_on(2)
if (sleep[4] in "False" and self.__sleepF2):
self.__sleepF2 = False
self.__scheduler.add_job(
lambda: self.__pwm.set_PWM_dutycycle(18, 0),
'interval',
minutes=int(sleep[2]),
id='dim')
elif (sleep[4] in "True" and not self.__sleepF2):
self.__sleepF2 = True
self.__scheduler.remove_job('dim')
self.__vcgencmd.display_power_on(2)
self.__pwm.set_PWM_dutycycle(
18, int(self.__fileIO.simpleRead(self.__brightnessFile)))
self.displayOn()
self.__valChange = [sleep[0], sleep[1], sleep[2]]
def displayOn(self):
self.__vcgencmd.display_power_on(2)
brightness = self.__fileIO.simpleRead(self.__brightnessFile)
self.__pwm.set_PWM_dutycycle(18, int(brightness))
self.__stayOffFlag = False
def displayOff(self):
self.__pwm.set_PWM_dutycycle(18, 0)
self.__stayOffFlag = True
def readFontFromFile(self):
font = self.__fileIO.simpleRead(self.__fontFile, multiLine=True)
font[0] = font[0].split(",")[0]
font[1] = int(font[1])
if (len(font) == 2):
font.append(False)
font.append(False)
elif (len(font) == 3):
if ('Bold' in font[2]):
font[2] = True
font.append(False)
else:
font[2] = False
font.append(True)
elif (len(font) == 4):
font[2] = True
font[3] = True
return font
def getFont(self, index):
return self.__fonts[index]
def getDefFont(self):
return self.__defFont
def getMetFont(self):
return self.__metFont
def setCSize(self, size):
self.__cSize = size
def getSpeed(self):
speed = self.__fileIO.simpleRead(self.__speedFile)
if ("Non" in speed):
return 0
else:
return int(speed) * 1000
def getView(self):
return self.__fileIO.simpleRead(self.__viewFile, multiLine=True)[0]
def getAllFonts(self):
fontName, fontSize, bold, italic = self.readFontFromFile()
try:
self.__defFont = pygame.font.SysFont(self.__defFontName,
fontSize - 12,
bold=bold,
italic=italic)
self.__metFont = pygame.font.SysFont(self.__defFontName,
fontSize - 4,
bold=bold,
italic=italic)
self.__fonts[0] = pygame.font.SysFont(fontName,
fontSize + self.__cSize,
bold=bold,
italic=italic) #calendar
self.__fonts[1] = pygame.font.SysFont(fontName,
fontSize + 0,
bold=bold,
italic=italic) #date
self.__fonts[2] = pygame.font.SysFont(fontName,
fontSize + 32,
bold=bold,
italic=italic) #time
self.__fonts[3] = pygame.font.SysFont(fontName,
fontSize - 12,
bold=bold,
italic=italic) #events
self.__fonts[4] = pygame.font.SysFont(fontName,
fontSize - 12,
bold=bold,
italic=italic) #news
self.__fonts[5] = pygame.font.SysFont(fontName,
fontSize - 4,
bold=bold,
italic=italic) #weather
self.__fonts[6] = pygame.font.SysFont(fontName,
fontSize - 12,
bold=bold,
italic=italic) #hour
self.__fonts[7] = pygame.font.SysFont(fontName,
fontSize - 18,
bold=bold,
italic=italic) #hour
except:
self.__defFont = pygame.font.Font(self.__defFontName,
fontSize - 12,
bold=bold,
italic=italic)
self.__metFont = pygame.font.Font(self.__defFontName,
fontSize - 4,
bold=bold,
italic=italic)
self.__fonts[0] = pygame.font.Font(fontName,
fontSize,
bold=bold,
italic=italic)
self.__fonts[1] = pygame.font.Font(fontName,
fontSize + 0,
bold=bold,
italic=italic)
self.__fonts[2] = pygame.font.Font(fontName,
fontSize + 32,
bold=bold,
italic=italic)
self.__fonts[3] = pygame.font.Font(fontName,
fontSize - 12,
bold=bold,
italic=italic)
self.__fonts[4] = pygame.font.Font(fontName,
fontSize - 12,
bold=bold,
italic=italic)
self.__fonts[5] = pygame.font.Font(fontName,
fontSize - 4,
bold=bold,
italic=italic)
self.__fonts[6] = pygame.font.Font(fontName,
fontSize - 12,
bold=bold,
italic=italic)
self.__fonts[7] = pygame.font.Font(fontName,
fontSize - 18,
bold=bold,
italic=italic)
return self.__fonts
class app(ui):
#__eventFile = "data/configFiles/eventFile.txt"
__fontFile = "data/configFiles/fontFile.txt"
__colorFile = "data/configFiles/colorFile.txt"
__brightnessFile = "data/configFiles/brightnessFile.txt"
__radioFile = "data/weather/radioFile.txt"
__cityFile = "data/weather/cityFile.txt"
__weatherFile = "data/weather/weather.txt"
__dummyFile = "data/events/dummy.txt"
__newsStoryFile = "data/news/newsStory.txt"
__countryFile = "data/news/countryFile.txt"
__sourcesFile = "data/news/sorucesFile.txt"
__categoryFile = "data/news/categoryFile.txt"
__fileIO = fileIO( )
def __init__( self, x, y ):#x805, y573
import sys
self.app = QtWidgets.QApplication( sys.argv )
super( ).__init__( x, y )
self.initUi( )
sys.exit( self.app.exec_( ))
def initUi( self ):
self.__socketClient = socketClient( '127.0.0.1', 8080 )
self.__initFoldersAndFiles = initFoldersAndFiles( )
self.__newsApp = newsApp( 367, 259, 200 )
self.__readApp = readApp( 797, 392, 1 )
self.__newsList = newsList( self.countryLabel, self.sourceListWidget, self.newsListWidget )
self.__events = eventHandler( self.eventTableWidget, self.hourComboBox, self.minuteSpinBox,
self.addEventButton, self.removeEventButton, self.lineEdit, self.dateLabel)
self.__initFoldersAndFiles.initAllFolders( )
self.__initFoldersAndFiles.initAllFiles( )
self.__newsApp.initUi( )
self.__readApp.initUi( super( ).x( ), super( ).y( ))
self.__run_threads = True
self.__thread = threading.Thread(target=self.__socketClient.checkIfConnected, args =(5, self.pingLabel, lambda : self.__run_threads, ))
self.__thread.start( )
#Move Main Window
screenRes = QtWidgets.QDesktopWidget( ).screenGeometry(-1)
moveX = screenRes.width( ) - self.width() - 40
moveY = screenRes.height( ) - self.height() - 100
self.setDate( )
self.readFontAndSize( )
self.readBrightness( )
self.readColor( )
self.readWeather( )
self.connectWidgets( )
super( ).move( moveX, moveY )
super( ).setVisible( True )
def connectWidgets( self ):
self.__newsApp.quitSignalAccept.connect( self.updateNews )
self.__newsApp.quitSignalCancel.connect( self.enableWindow )
self.__newsApp.quitSignalExit.connect( self.enableWindow )
self.__readApp.quitSignalExit.connect( self.enableWindow )
#Font
self.fontComboBox.currentFontChanged.connect( self.writeFontAndSize )
self.fontSizeSpinBox.valueChanged.connect( self.writeFontAndSize )
self.boldCheckBox.clicked.connect( self.writeFontAndSize )
self.italicCheckBox.clicked.connect( self.writeFontAndSize )
#
self.colorChangeButton.clicked.connect( self.changeColor )
self.calendarWidget.clicked.connect( self.setDate )
self.brightnessSlider.sliderReleased.connect( self.writeBrightness )
self.editNewsButton.clicked.connect( self.editNews )
self.readNewsButton.clicked.connect( self.readNews )
self.submitButton.clicked.connect( self.writeWeather )
def writeFontAndSize( self ):
self.__fileIO.conditionalWrite( self.__fontFile,
self.__fileIO.formListOfDictionary([ True, True, self.boldCheckBox.isChecked( ), self.italicCheckBox.isChecked( )],
[ self.fontComboBox.currentFont( ).toString( ), self.fontSizeSpinBox.value( ), "Bold", "Italic" ]),
separator='\n' )
self.sendToServer( self.__fontFile )
def writeBrightness( self ):
self.__fileIO.simpleWrite( self.__brightnessFile, str( self.brightnessSlider.value( )))
self.sendToServer( self.__brightnessFile )
def writeWeather( self ):
self.__fileIO.conditionalQtWrite( self.__weatherFile, [self.celsiusRadioButton, self.fahrenheitRadioButton])
self.__fileIO.simpleWrite( self.__weatherFile, "\n" + self.cityLineEdit.text( ), clearContents=False )
self.sendToServer( self.__weatherFile )
def writeColor( self, text ):
self.__fileIO.simpleWrite( self.__colorFile, text )
self.sendToServer( self.__colorFile )
def readFontAndSize( self ):
fontInit = self.__fileIO.conditionalQtRead( self.__fontFile, [ self.boldCheckBox, self.italicCheckBox ], returnText=True )
self.fontComboBox.setCurrentFont( QtGui.QFont( fontInit[0] ))
self.fontSizeSpinBox.setValue( int( fontInit[1] ))
def readBrightness( self ):
self.brightnessSlider.setValue( int( self.__fileIO.simpleRead( self.__brightnessFile, force=True )))
def readWeather( self ):
text = self.__fileIO.conditionalQtRead( self.__weatherFile, [ self.celsiusRadioButton, self.fahrenheitRadioButton ], force=True, returnText=True)
self.cityLineEdit.setText( text[1] )
def readColor( self ):
self.colorChangeButton.setStyleSheet( "QWidget { background-color: %s ; color: %s }"% tuple( self.__fileIO.simpleRead( self.__colorFile, force=True, separator=":" )))
def changeColor( self ):
color = QColorDialog( ).getColor( )
if color.isValid( ):
r, g, b, _ = color.getRgb( )
rgbHexa = '#%02x%02x%02x' % (abs( r - 255 ), abs( g - 255 ), abs( b - 255 ))
self.colorChangeButton.setStyleSheet( "QWidget { background-color: %s ; color: %s }"% (color.name( ), rgbHexa))
self.writeColor( color.name( ) + ":" + rgbHexa )
def setDate( self ):
dayOfWeek, month, day, year = self.calendarWidget.selectedDate( ).toString( ).split( " " )
self.__events.setLabel( day + ". " + month + " " + year + ". (" + dayOfWeek + ")" )
path = "data/events/" + str( year ) + "/" + str( month ) + "/" + day + ".txt"
self.__events.setPath( path )
def editNews( self ):
self.setEnabled( False )
self.__newsApp.refresh( )
self.__newsApp.show( super( ).x( ), super( ).y( ))
def readNews( self ):
self.setEnabled( False )
self.__readApp.fillTable( self.__newsStoryFile )
self.__readApp.show( super( ).x( ), super( ).y( ))
def enableWindow( self ):
self.setEnabled( True )
def updateNews( self ):
self.enableWindow( )
self.__newsList.updateTables( self.__sourcesFile, self.__categoryFile )
self.__newsList.updateCountry( self.__countryFile )
self.sendToServer( self.__newsStoryFile )
def closeEvent( self, event ):
self.__run_threads = False
def sendToServer( self, file ):
try:
thread = threading.Thread( target=self.__socketClient.sendToServer, args =( file, 0.1 ))
thread.start( )
except:
print( "Unable to send file <", file, ">" )
class news(drawPygame):
__newsFile = "data/news/newsStory.txt"
__countryFile = "data/news/countryFile.txt"
__categoryFile = "data/news/categoryFile.txt"
__sourcesFile = "data/news/sourcesFile.txt"
__apiKey = '4135e2a067ea41d19f8013a073ffc10f'
__fileIO = fileIO()
def __init__(self, xOffset, yOffset, move):
self.__newsapi = NewsApiClient(self.__apiKey)
super().__init__(xOffset, yOffset, move)
self.__text = []
def getText(self):
return self.__text
def getNews(self):
category = self.__fileIO.simpleRead(self.__categoryFile,
multiLine=True)
if (len(category)):
self.__text = self.getCategoryNews()
else:
self.__text = self.getSourceNews()
def getCategoryNews(self):
country = self.__fileIO.simpleRead(self.__countryFile,
separator=";~sepa~;")[1]
category = self.__fileIO.simpleRead(self.__categoryFile,
multiLine=True)
news = ''
if ("ww" in country):
for i in range(len(category)):
news += self.__newsapi.get_top_headlines(
category=category[i].lower(), language="en")
else:
for i in range(len(category)):
news = self.__newsapi.get_top_headlines(
category=category[i].lower(), country=country)
return self.getTitle(news['articles'])
def getSourceNews(self):
sourceList = self.__fileIO.simpleRead(self.__sourcesFile)
news = self.__newsapi.get_everything(sources=','.join(sourceList))
return self.getTitle(news['articles'])
def getTitle(self, articles):
title = []
for story in articles:
title.append(story['title'])
return title
def getNewsFromFile(self):
news = self.__fileIO.simpleRead(self.__newsFile,
multiLine=True,
separator=";~sepa~;")
self.__text = [i[1] for i in news]
class gpioInterface:
__displayFlag = False
__viewFlag = False
__viewOptions = [
"Default", "Default+", "Calendar+Events", "Calendar+Weather",
"Calendar+Weather+Events", "Calendar+Weather+Events+"
]
__viewCnt = 0
__fileIO = fileIO()
__viewFile = "/home/pi/SmartMirror/data/configFiles/viewFile.txt"
__brightnessFile = "/home/pi/SmartMirror/data/configFiles/brightnessFile.txt"
def __init__(self):
self.__vcgencmd = Vcgencmd()
GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup(11, GPIO.IN, pull_up_down=GPIO.PUD_UP) #PIR data
GPIO.setup(15, GPIO.IN, pull_up_down=GPIO.PUD_UP) #View change button
GPIO.setup(13, GPIO.IN,
pull_up_down=GPIO.PUD_UP) #Display on/off button
GPIO.setup(5, GPIO.IN, pull_up_down=GPIO.PUD_UP) #power up/down button
self.__pwm = pigpio.pi()
GPIO.add_event_detect(15,
GPIO.FALLING,
callback=self.viewChange,
bouncetime=250)
GPIO.add_event_detect(13,
GPIO.FALLING,
callback=self.displayToggle,
bouncetime=500)
GPIO.add_event_detect(5,
GPIO.FALLING,
callback=self.shutdown,
bouncetime=2000)
def getViewFlag(self):
return self.__viewFlag
def setViewFlag(self, state):
self.__viewFlag = state
def setDisplayFlag(self, state):
self.__displaFlag = state
def pirSensor(self):
if (not self.__displayFlag):
if (GPIO.input(11)):
return 1
else:
return 0
def displayToggle(self, channel):
if (self.__displayFlag):
self.__displayFlag = False
#self.__vcgencmd.display_power_on( 2 )
self.setBrightness()
else:
self.__displayFlag = True
#self.__vcgencmd.display_power_off( 2 )
self.__pwm.set_PWM_dutycycle(18, 0)
def viewChange(self, channel):
if (self.__viewCnt >= len(self.__viewOptions) - 1):
self.__viewCnt = 0
else:
self.__viewCnt += 1
print(self.__viewCnt)
self.__fileIO.simpleWrite(self.__viewFile,
self.__viewOptions[self.__viewCnt])
self.__viewFlag = True
def shutdown(self, channel):
self.__pwm.write(18, 0)
print("SHUTDOWN")
time.sleep(1)
os.system("sudo shutdown -h now")
def setBrightness(self):
brightness = self.__fileIO.simpleRead(self.__brightnessFile)
self.__pwm.set_PWM_dutycycle(18, int(brightness))
self.__displayFlag = False
class eventHandler:
__fileIO = fileIO()
__events = []
__eventCount = 0
__separator = ";~sepa~;"
__path = ''
def __init__(self, table, hour, minute, add, remove, text, label, ip,
port):
self.__table = table
self.__hour = hour
self.__minute = minute
self.__add = add
self.__remove = remove
self.__text = text
self.__label = label
self.__socketClient = socketClient(ip, port)
#Focus Line Edit
self.__text.setFocus()
self.__add.clicked.connect(self.addClicked)
self.__text.returnPressed.connect(self.__add.click) #Enter
self.__remove.clicked.connect(self.removeClicked)
def getPath(self):
return self.__path
def getHour(self):
return self.__hour.currentIndex()
def getMinute(self):
return self.__minute.value()
def getTableHour(self, i):
return int(self.__table.item(i, 0).text().split(":")[0])
def getTableMinute(self, i):
return int(self.__table.item(i, 0).text().split(":")[1])
def getText(self):
eventText = str(self.__text.text())
self.__text.setText("")
return eventText
def getTextLen(self):
return len(str(self.__text.text()))
def setLabel(self, date):
self.__label.setText(date)
def setPath(self, path):
self.__path = path
if (self.__fileIO.fileExists(path)):
self.readFromFile()
else:
self.clearContents()
def clearContents(self):
for i in range(len(self.__events), 0, -1):
self.__table.removeRow(i - 1)
del self.__events[i - 1]
def addEvent(self, i):
self.__table.insertRow(i)
time, text = self.__events[i].formatForTable()
if ("ogledalce" in text):
text = "Vi o svemoguci gospodaru"
self.__table.setItem(i, 0, QTableWidgetItem(time))
self.__table.setItem(i, 1, QTableWidgetItem(text))
self.updateTableConfig()
def addClicked(self):
if (self.getTextLen()):
self.__events.append(
event(self.getHour(), self.getMinute(), self.getText()))
index = self.sort()
self.addEvent(index)
self.writeToFile()
def sort(self):
newTime = self.__events[-1].formatForTable()[0]
for i, e in enumerate(self.__events):
time = e.formatForTable()[0]
if (e.getTime() > newTime):
self.__events.insert(i,
self.__events.pop(len(self.__events) - 1))
return i
return i
def removeClicked(self):
if (len(self.__events) > 0):
curRow = self.__table.currentRow()
if ((curRow == -1)):
curRow = 0
self.__table.removeRow(curRow)
del self.__events[curRow]
self.__fileIO.removeNthLine(self.__path, curRow)
self.sendToServer(self.__path)
def updateTableConfig(self):
self.__table.resizeRowsToContents()
self.__table.scrollToBottom()
def writeToFile(self): #not used
self.__fileIO.makePath(self.__path)
self.__fileIO.clearFile(self.__path)
for e in self.__events:
e.writeToFile(self.__path)
self.sendToServer(self.__path)
def readFromFile(self):
self.__events.clear()
self.__table.setRowCount(0) #clear table
events = self.__fileIO.simpleRead(self.__path,
multiLine=True,
separator=self.__separator)
print("Reading from event file")
for e in events:
hour, minute = e[0].split(":")
self.__events.append(event(hour, minute, e[1]))
self.addEvent(len(self.__events) - 1)
def clearFile(self):
self.__fileIO.clearFile(self.__path)
def sendToServer(self, file):
try:
thread = threading.Thread(target=self.__socketClient.sendToServer,
args=(file, 0.1))
thread.start()
except:
print("Unable to send file <", file, ">")
class newsApp(qtBasics, newsUi):
quitSignalAccept = QtCore.pyqtSignal(int)
quitSignalCancel = QtCore.pyqtSignal(int)
quitSignalExit = QtCore.pyqtSignal(int)
__countryFile = "data/news/countryFile.txt"
__sourcesFile = "data/news/sorucesFile.txt"
__categoryFile = "data/news/categoryFile.txt"
__newsStoryFile = "data/news/newsStory.txt"
__fileIO = fileIO()
def __init__(self, x, y, sourceCount): #367, 259 xy
newsUi.__init__(self, x, y, sourceCount)
qtBasics.__init__(self)
self.__category = checkBoxHandler(self.allCheckBox,
self.categoryCheckBox)
self.__source = checkBoxHandler(self.allCheckBox2, self.sourceCheckBox)
self.__country = country(self.comboBox)
self.__apinews = newsApiHandler(self.progressBar)
def initUi(self):
#Connect
self.buttonBox.button(
QtWidgets.QDialogButtonBox.Apply).clicked.connect(
self.applyClicked)
self.buttonBox.button(
QtWidgets.QDialogButtonBox.Cancel).clicked.connect(
self.cancelClicked)
self.__country.getCountryBox().currentIndexChanged.connect(
self.countryChange)
self.__country.setID()
self.countryChange()
self.__country.readFromFile(self.__countryFile)
self.__category.readCheckedFromFile(self.__categoryFile)
self.__source.readCheckedFromFile(self.__sourcesFile)
def applyClicked(self):
self.buttonBox.hide()
self.__apinews.newNewsRequest(self.__newsStoryFile)
self.__category.writeCheckedToFile(self.__categoryFile)
self.__source.writeCheckedToFile(self.__sourcesFile)
self.__country.writeToFile(self.__countryFile)
categoryNames = self.__category.getCheckBoxNames()
sourceNames = self.__source.getCheckBoxNames()
if (len(categoryNames) > 0):
self.__apinews.pullCategory(categoryNames)
self.__apinews.shuffleStory()
self.__apinews.writeToFile(self.__newsStoryFile)
elif (len(sourceNames) > 0):
self.__apinews.pullSource(sourceNames)
self.__apinews.shuffleStory()
self.__apinews.writeToFile(self.__newsStoryFile)
self.buttonBox.show()
self.quitSignalAccept.emit(1)
self.setVisible(False)
def cancelClicked(self):
self.quitSignalCancel.emit(1)
self.setVisible(False)
def countryChange(self):
sourceNames = []
self.__apinews.setCountryID(self.__country.getID())
for names in self.__apinews.pullSourceNames():
sourceNames.append(names['id'])
if (len(sourceNames)):
self.label_2.hide() # no sources available label
else:
self.label_2.show()
self.__source.changeCheckBox(sourceNames)
def setCountryName(self): #call this in applyClicked
self.__country.writeToFile(self.__countryFile)
def refresh(self):
self.__country.readFromFile(self.__countryFile)
self.__source.readCheckedFromFile(self.__sourcesFile)
class mycalendar(drawPygame):
__rectPos = 0
__fileIO = fileIO()
def __init__(self, xOffset, yOffset, move):
super().__init__(xOffset, yOffset, move)
self.__text = []
self.__month = []
self.__eventCount = []
self.__count = []
self.__renderFlag = True
def renderText(self, color, font, dateToRender):
date = clockDate()
if (dateToRender == 0):
mnt = date.getCurMonth()
else:
mnt = date.getNthMonth(dateToRender)
self.__month = date.formatForPygame(mnt)
self.__text = []
for i, m in enumerate(self.__month):
self.__text.append(font.render(m, True, color))
try:
m = int(m)
except:
continue
if (m == int(date.getDate().split(".")[0])):
self.__rectPos = i
def renderEventCount(self, color, font, file):
while (not self.__renderFlag):
time.sleep(0.001)
self.__renderFlag = False
self.__eventCount = []
self.__count = []
for i in range(len(self.__month)):
fileToOpen = file + self.__month[i].strip() + ".txt"
self.__count.append(self.__fileIO.getNumOfLines(fileToOpen))
self.__eventCount.append(
font.render(str(self.__count[i]), True, color))
def drawText(self, screen, colorInv):
if (super().getDrawFlag()):
j = 0
z = 0
while (len(self.__text) > len(self.__count)):
print(len(self.__text), " <> ", len(self.__count))
time.sleep(0.001)
for i in range(len(self.__text)):
if (not i % 7 and i != 0):
j += 1
z = 0
screen.blit(self.__text[i],
(super().getStep() * super().getXoffset() + z *
(super().getStep() - super().getMove()),
super().getStep() * super().getYoffset() + j *
(super().getStep() - super().getMove())))
try:
if (j > 0 and self.__month[i] != ""
and self.__count[i] > 0):
screen.blit(
self.__eventCount[i],
((super().getStep() * super().getXoffset() + z *
(super().getStep() - super().getMove())) +
super().getStep() - super().getMove() - 22,
(super().getStep() * super().getYoffset() + j *
(super().getStep() - super().getMove()) +
super().getStep() - super().getMove() - 18)))
except:
print("self.__month[i] = ",
len(self.__month), "\nself.__count[i] = ",
len(self.__count), "\nself.__text = ",
len(self.__text))
if (i == self.__rectPos):
pygame.draw.rect(
screen, colorInv,
pygame.Rect(
super().getStep() * super().getXoffset() - 4 + z *
(super().getStep() - super().getMove()),
super().getStep() * super().getYoffset() + j *
(super().getStep() - super().getMove()),
super().getStep() - super().getMove(),
super().getStep() - super().getMove()), 1)
z += 1
self.__renderFlag = True
