Fixed agenda view getting stuck when there are not enough events

This reverts commit 6146fc7c2d.

.gitignore

@@ -0,0 +1,21 @@
+################################################################################
+# This .gitignore file was automatically created by Microsoft(R) Visual Studio.
+################################################################################
+
+/.vs
+/Calendar/settings.py
+/Calendar/__pycache__/settings.cpython-36.pyc
+/Calendar/__pycache__
+/Calendar/design_exported.png
+/design_exported.png
+/Calendar/icon_positions_locations.pyc
+/Calendar/DebugInterface.pyc
+/Calendar/DebugConsole.pyc
+/Calendar/DataSourceInterface.pyc
+/Calendar/CalendarInterface.pyc
+/Calendar/CalendarEvent.pyc
+/Calendar/design_exported_old.png
+/Calendar/settings_dev.py
+/Calendar/settings_pers.py
+/.vscode
+/Calendar/images/

2-Colour-support/beta-converter.py

@@ -1,78 +0,0 @@
-"""
-This is a python image converter specific for the E-Paper-Calendar
-on github by aceisace from the link below.
-(https://github.com/aceisace/E-Paper-Calendar-with-iCal-sync-and-live-weather)
-
-It will convert the 3-colour .bmp's to 2-colour .bmp's so that they can be
-used even with the 2-Colour 7.5" E-Paper Display from waveshare.
-
-Please use with caution. If the input and output paths are the same, the
-convertr will overwrite all .bmp files. It's highly recommended to make a
-backup of the entire 'Calendar" folder first.
-
-Copyright by Ace-Laboratory
-"""
-
-"""
-Info: These path contain the bmps that require converting.
-1) /home/pi/E-Paper-Master/Calendar/months/
-3) /home/pi/E-Paper-Master/Calendar/other/
-"""
-path = '/home/pi/E-Paper-Master/Calendar/'
-#--------------only change the following two lines-----------------#
-input_path_1 =  path+'other/'
-output_path_1 = path+'other/'
-input_path_2 =  path+'months/'
-output_path_2 = path+'months/'
-#-----------------no need to change anything below-----------------#
-
-import glob, os, errno
-from PIL import Image
-import PIL.ImageOps
-
-imagenames_1 = []
-imagenames_2 = []
-
-print('opening the specified directory...')
-
-os.chdir(input_path_1) #folder containg files
-for files in glob.glob('*.bmp'): #find bmp files
-    imagenames_1.append(files) #add these files to a list
-print('Found these files:', imagenames_1) #print this list
-
-os.chdir(input_path_2) #folder containg files
-for files in glob.glob('*.bmp'): #find bmp files
-    imagenames_2.append(files) #add these files to a list
-print('Found these files:', imagenames_2) #print this list
-
-# 0 is black, 255 is white, 127 is red.
-# The following will convert the 'red' parts to white parts.
-thresh = 100 # any value below 127 works.
-fn = lambda x : 255 if x > thresh else 0
-
-try:
-    print('checking if the first output path exists...')
-    os.makedirs(output_path_1)
-except OSError as e:
-    print('Oh, the first output path exists already. Assuming you know what you are doing.')
-    print('Will attempt to overwrite all .bmp files')
-    if e.errno != errno.EEXIST:
-        raise
-        
-try:
-    print('checking if the second output path exists...')
-    os.makedirs(output_path_2)
-except OSError as e:
-    print('Oh, the second output path exists already. Assuming you know what you are doing.')
-    print('Will attempt to overwrite all .bmp files')
-    if e.errno != errno.EEXIST:
-        raise
-        
-print('attempting to convert images...')   
-for files in imagenames_1:
-    ((Image.open(input_path_1+files)).convert('L').point(fn, mode='1').save(output_path_1+files))
-for files in imagenames_2:
-    ((Image.open(input_path_2+files)).convert('L').point(fn, mode='1').save(output_path_2+files))
-
-print('All done!')
-print('The bmp have been converted. Good luck!')

2-colour/calibration.py

@@ -1,31 +0,0 @@
-"""
-Calibration module for the 2-Colour E-Paper Calendar display. Running this script
-helps to 'flush' all the pixels and retain the colour on the display.
-"""
-import epd7in5
-from PIL import Image, ImageDraw, ImageFont
-EPD_WIDTH = 640
-EPD_HEIGHT = 384
-epd = epd7in5.EPD()
-
-def calibration():
-    for i in range(2):
-        epd.init()
-        black = Image.new('1', (EPD_WIDTH, EPD_HEIGHT), 0)
-        print('calibrating black...')
-        ImageDraw.Draw(black)
-        epd.display_frame(epd.get_frame_buffer(black))
-        
-        white = Image.new('1', (EPD_WIDTH, EPD_HEIGHT), 255)
-        ImageDraw.Draw(white)
-        print('calibrating white...')
-        epd.display_frame(epd.get_frame_buffer(white))
-        epd.sleep()
-    print('Cycle complete!')
-
-def main():
-    for i in range(1):
-        calibration()
-
-if __name__ == '__main__':
-    main()

2-colour/epd7in5.py

@@ -1,181 +0,0 @@
-import epdif
-from PIL import Image
-import RPi.GPIO as GPIO
-
-# Display resolution
-EPD_WIDTH       = 640
-EPD_HEIGHT      = 384
-
-# EPD7IN5 commands
-PANEL_SETTING                               = 0x00
-POWER_SETTING                               = 0x01
-POWER_OFF                                   = 0x02
-POWER_OFF_SEQUENCE_SETTING                  = 0x03
-POWER_ON                                    = 0x04
-POWER_ON_MEASURE                            = 0x05
-BOOSTER_SOFT_START                          = 0x06
-DEEP_SLEEP                                  = 0x07
-DATA_START_TRANSMISSION_1                   = 0x10
-DATA_STOP                                   = 0x11
-DISPLAY_REFRESH                             = 0x12
-IMAGE_PROCESS                               = 0x13
-LUT_FOR_VCOM                                = 0x20
-LUT_BLUE                                    = 0x21
-LUT_WHITE                                   = 0x22
-LUT_GRAY_1                                  = 0x23
-LUT_GRAY_2                                  = 0x24
-LUT_RED_0                                   = 0x25
-LUT_RED_1                                   = 0x26
-LUT_RED_2                                   = 0x27
-LUT_RED_3                                   = 0x28
-LUT_XON                                     = 0x29
-PLL_CONTROL                                 = 0x30
-TEMPERATURE_SENSOR_COMMAND                  = 0x40
-TEMPERATURE_CALIBRATION                     = 0x41
-TEMPERATURE_SENSOR_WRITE                    = 0x42
-TEMPERATURE_SENSOR_READ                     = 0x43
-VCOM_AND_DATA_INTERVAL_SETTING              = 0x50
-LOW_POWER_DETECTION                         = 0x51
-TCON_SETTING                                = 0x60
-TCON_RESOLUTION                             = 0x61
-SPI_FLASH_CONTROL                           = 0x65
-REVISION                                    = 0x70
-GET_STATUS                                  = 0x71
-AUTO_MEASUREMENT_VCOM                       = 0x80
-READ_VCOM_VALUE                             = 0x81
-VCM_DC_SETTING                              = 0x82
-
-class EPD:
-    def __init__(self):
-        self.reset_pin = epdif.RST_PIN
-        self.dc_pin = epdif.DC_PIN
-        self.busy_pin = epdif.BUSY_PIN
-        self.width = EPD_WIDTH
-        self.height = EPD_HEIGHT
-
-    def digital_write(self, pin, value):
-        epdif.epd_digital_write(pin, value)
-
-    def digital_read(self, pin):
-        return epdif.epd_digital_read(pin)
-
-    def delay_ms(self, delaytime):
-        epdif.epd_delay_ms(delaytime)
-
-    def send_command(self, command):
-        self.digital_write(self.dc_pin, GPIO.LOW)
-        # the parameter type is list but not int
-        # so use [command] instead of command
-        epdif.spi_transfer([command])
-
-    def send_data(self, data):
-        self.digital_write(self.dc_pin, GPIO.HIGH)
-        # the parameter type is list but not int
-        # so use [data] instead of data
-        epdif.spi_transfer([data])
-
-    def init(self):
-        if (epdif.epd_init() != 0):
-            return -1
-        self.reset()
-
-        self.send_command(POWER_SETTING)
-        self.send_data(0x37)
-        self.send_data(0x00)
-
-        self.send_command(PANEL_SETTING)
-        self.send_data(0xCF)
-        self.send_data(0x08)
-
-        self.send_command(BOOSTER_SOFT_START)
-        self.send_data(0xc7)
-        self.send_data(0xcc)
-        self.send_data(0x28)
-
-        self.send_command(POWER_ON)
-        self.wait_until_idle()
-
-        self.send_command(PLL_CONTROL)
-        self.send_data(0x3c)
-
-        self.send_command(TEMPERATURE_CALIBRATION)
-        self.send_data(0x00)
-
-        self.send_command(VCOM_AND_DATA_INTERVAL_SETTING)
-        self.send_data(0x77)
-
-        self.send_command(TCON_SETTING)
-        self.send_data(0x22)
-
-        self.send_command(TCON_RESOLUTION)
-        self.send_data(0x02)     #source 640
-        self.send_data(0x80)
-        self.send_data(0x01)     #gate 384
-        self.send_data(0x80)
-
-        self.send_command(VCM_DC_SETTING)
-        self.send_data(0x1E)      #decide by LUT file
-
-        self.send_command(0xe5)           #FLASH MODE
-        self.send_data(0x03)
-
-    def wait_until_idle(self):
-        while(self.digital_read(self.busy_pin) == 0):      # 0: busy, 1: idle
-            self.delay_ms(100)
-
-    def reset(self):
-        self.digital_write(self.reset_pin, GPIO.LOW)         # module reset
-        self.delay_ms(200)
-        self.digital_write(self.reset_pin, GPIO.HIGH)
-        self.delay_ms(200)    
-
-    def get_frame_buffer(self, image):
-        buf = [0x00] * int(self.width * self.height / 8)
-        # Set buffer to value of Python Imaging Library image.
-        # Image must be in mode 1.
-        image_monocolor = image.convert('1')
-        imwidth, imheight = image_monocolor.size
-        if imwidth != self.width or imheight != self.height:
-            raise ValueError('Image must be same dimensions as display \
-                ({0}x{1}).' .format(self.width, self.height))
-
-        pixels = image_monocolor.load()
-        for y in range(self.height):
-            for x in range(self.width):
-                # Set the bits for the column of pixels at the current position.
-                if pixels[x, y] != 0:
-                    buf[int((x + y * self.width) / 8)] |= 0x80 >> (x % 8)
-        return buf
-
-    def display_frame(self, frame_buffer):
-        self.send_command(DATA_START_TRANSMISSION_1)
-        for i in range(0, 30720):
-            temp1 = frame_buffer[i]
-            j = 0
-            while (j < 8):
-                if(temp1 & 0x80):
-                    temp2 = 0x03
-                else:
-                    temp2 = 0x00
-                temp2 = (temp2 << 4) & 0xFF
-                temp1 = (temp1 << 1) & 0xFF
-                j += 1
-                if(temp1 & 0x80):
-                    temp2 |= 0x03
-                else:
-                    temp2 |= 0x00
-                temp1 = (temp1 << 1) & 0xFF
-                self.send_data(temp2)
-                j += 1
-        self.send_command(DISPLAY_REFRESH)
-        self.delay_ms(100)
-        self.wait_until_idle()
-
-    def sleep(self):
-        self.send_command(POWER_OFF)
-        self.wait_until_idle()
-        self.send_command(DEEP_SLEEP)
-        self.send_data(0xa5)
-
-### END OF FILE ###
-

2-colour/epdif.py

@@ -1,37 +0,0 @@
-import spidev
-import RPi.GPIO as GPIO
-import time
-
-# Pin definition
-RST_PIN         = 17
-DC_PIN          = 25
-CS_PIN          = 8
-BUSY_PIN        = 24
-
-# SPI device, bus = 0, device = 0
-SPI = spidev.SpiDev(0, 0)
-
-def epd_digital_write(pin, value):
-    GPIO.output(pin, value)
-
-def epd_digital_read(pin):
-    return GPIO.input(BUSY_PIN)
-
-def epd_delay_ms(delaytime):
-    time.sleep(delaytime / 1000.0)
-
-def spi_transfer(data):
-    SPI.writebytes(data)
-
-def epd_init():
-    GPIO.setmode(GPIO.BCM)
-    GPIO.setwarnings(False)
-    GPIO.setup(RST_PIN, GPIO.OUT)
-    GPIO.setup(DC_PIN, GPIO.OUT)
-    GPIO.setup(CS_PIN, GPIO.OUT)
-    GPIO.setup(BUSY_PIN, GPIO.IN)
-    SPI.max_speed_hz = 2000000
-    SPI.mode = 0b00
-    return 0;
-
-### END OF FILE ###

2-colour/stable.py

@@ -1,248 +0,0 @@
-"""
-E-Paper Software (main script) adapted for the 2-colour E-Paper display
-A full and detailed breakdown for this code can be found in the wiki.
-If you have any questions, feel free to open an issue at Github.
-
-Copyright by Ace-Laboratory
-"""
-
-# url refers to the iCal url. It's the link you can copy when you click on
-# 'export' Calendar in Google or Yahoo (and many more online) Calendars
-
-# api-key refers to your openweathermap api key. It can be generated for free
-# when you sign up for an account and consists of a bunch of numbers and letters
-
-# location refers to the city you live in. You api key will be used to grab live
-# weather data for this city. Use the format below (city-name, country code)
-
-# week_starts_on refers to the day on which the week starts on in your country.
-# Choose between Monday and Sunday.
-
-""" To quickly get started, fill in the following details:"""
-
-url = "https://calendar.google.com/calendar/ical/en.usa%23holiday%40group.v.calendar.google.com/public/basic.ics"
-api_key = ""
-location = "California, US"
-week_starts_on = "Monday"
-
-"""That's all. The software will do the rest. You don't need to modify anything below this."""
-
-import epd7in5
-from PIL import Image, ImageDraw, ImageFont, ImageOps #image operations
-import calendar,  pyowm #calendar and openweathermap wrapper
-from ics import Calendar, Event #icalendar parser
-from datetime import datetime #time operations
-from time import sleep #more time operations
-from urllib.request import urlopen #allows url to be 'read'
-import arrow #icalendar parser compatible dates
-from calibration import calibration
-
-epd = epd7in5.EPD() #required
-
-if (week_starts_on == "Monday"):
-    calendar.setfirstweekday(calendar.MONDAY)
-    
-if (week_starts_on == "Sunday"):
-    calendar.setfirstweekday(calendar.Sunday)
-
-c = Calendar(urlopen(url).read().decode('UTF-8'))
-e = Event()
-open = Image.open
-EPD_WIDTH = 640
-EPD_HEIGHT = 384
-
-path = '/home/pi/E-Paper-Master/Calendar/'
-wpath = path+'weather-icons/'
-mpath = path+'months/'
-dpath = path+'days/'
-font = ImageFont.truetype(path+'Assistant-Bold.ttf', 18)
-
-weekday =               open(path+'other/weekday.bmp')
-eventicon =             open(path+'other/event.bmp')
-dateicon =              open(path+'other/today.bmp')
-tempicon =              open(path+'other/temp-icon.bmp')
-humicon =               open(path+'other/hum-icon.bmp')
-weekmon =               open(path+'other/week-mon.bmp')
-weeksun =               open(path+'other/week-sun.bmp')
-bar =                   open(path+'other/bar.bmp')
-
-wiconplace = (570, 219)
-tempplace = (605, 310)
-humplace = (572, 308)
-monthplace = (443, 0)
-weekplace = (415,0)
-barplace = (555, 0)
-
-weekdaysmon = {'Mon': (416,3), 'Tue': (416,57), 'Wed': (416,111), 'Thu': (416,165), 'Fri': (416,219), 'Sat': (416,273), 'Sun':(416,327)}
-weekdayssun = {'Sun': (416,3), 'Mon': (416,57), 'Tue': (416,111), 'Wed': (416,165), 'Thu': (416,219), 'Fri': (416,273), 'Sat':(416,327)}
-
-positions = {'a1': (351, 3), 'a2': (351, 57), 'a3': (351, 111), 'a4': (351, 165),  'a5': (351, 219), 'a6': (351, 273), 'a7': (351, 327),
-'b1': (284, 3), 'b2': (284, 57), 'b3': (284, 111), 'b4': (284, 165), 'b5': (284, 219), 'b6': (284, 273), 'b7': (284, 327),
-'c1': (217, 3), 'c2': (217, 57), 'c3': (217, 111), 'c4': (217, 165), 'c5': (217, 219), 'c6': (217, 273), 'c7': (217, 327),
-'d1': (150, 3), 'd2': (150, 57), 'd3': (150, 111), 'd4': (150, 165), 'd5': (150, 219), 'd6': (150, 273), 'd7': (150, 327),
-'e1': (83, 3), 'e2': (83, 57), 'e3': (83, 111), 'e4': (83, 165), 'e5': (83, 219), 'e6': (83, 273), 'e7': (83, 327),
-'f1': (16, 3), 'f2': (16, 57), 'f3': (16, 111), 'f4': (16, 165), 'f5': (16, 219), 'f6': (16, 273), 'f7': (16, 327)}
-
-weathericons = {'01d': 'wi-day-sunny', '02d':'wi-day-cloudy', '03d': 'wi-cloudy',
-'04d': 'wi-cloudy-windy', '09d': 'wi-showers', '10d':'wi-rain',
-'11d':'wi-thunderstorm', '13d':'wi-snow', '50d': 'wi-fog',
-'01n': 'wi-night-clear', '02n':'wi-night-cloudy',
-'03n': 'wi-night-cloudy', '04n': 'wi-night-cloudy',
-'09n': 'wi-night-showers', '10n':'wi-night-rain',
-'11n':'wi-night-thunderstorm', '13n':'wi-night-snow',
-'50n': 'wi-night-alt-cloudy-windy'}
-
-def main():
-    while True:
-        
-        time = datetime.now()
-        hour = int(time.strftime("%-H"))
-        
-        for i in range(1):
-            if hour is 0:
-                calibration()
-            if hour is 12:
-                calibration()
-            if hour is 18:
-                calibration()
-
-            epd.init()
-            image = Image.new('1', (EPD_WIDTH, EPD_HEIGHT), 255)
-            draw = (ImageDraw.Draw(image)).bitmap
-            
-            #background image
-            draw(monthplace, Image.open(mpath+str(time.strftime("%B"))+'.bmp'))
-
-            if calendar.firstweekday() == 0:
-                #print('Your week starts on Monday') #->debug
-                draw(weekplace, weekmon)
-                
-            if calendar.firstweekday() == 6:
-                #print('Your week starts on Sunday') #->debug
-                draw(weekplace, weeksun)
-            
-            draw(barplace, bar) 
-
-            cal = calendar.monthcalendar(time.year, time.month)
-
-            for i in cal[0]:
-                draw(positions['a'+str(cal[0].index(i)+1)] ,open(dpath+str(i)+'.bmp'))
-            for i in cal[1]:
-                draw(positions['b'+str(cal[1].index(i)+1)] ,open(dpath+str(i)+'.bmp'))
-            for i in cal[2]:
-                draw(positions['c'+str(cal[2].index(i)+1)] ,open(dpath+str(i)+'.bmp'))
-            for i in cal[3]:
-                draw(positions['d'+str(cal[3].index(i)+1)] ,open(dpath+str(i)+'.bmp'))
-            for i in cal[4]:
-                draw(positions['e'+str(cal[4].index(i)+1)] ,open(dpath+str(i)+'.bmp'))
-            try:
-                for i in cal[5]:
-                    draw(positions['f'+str(cal[5].index(i)+1)] ,Image.open(dpath+str(i)+'.bmp'))
-            except IndexError:
-                pass
-            
-            # openweathermap api
-            owm = pyowm.OWM(api_key)
-            observation = owm.weather_at_place(location)
-            weather = observation.get_weather()
-            weathericon = weather.get_weather_icon_name()
-            Temperature = str(int(weather.get_temperature(unit='celsius')['temp']))
-            Humidity = str(weather.get_humidity())
-            #print('temp: '+Temperature +'°C') #->debug
-            #print('humidity: '+Humidity+'%') #->debug
-            #print(weathericon)              #->debug
-            
-            #weather icon handler
-            draw(wiconplace, open(wpath+weathericons[weathericon]+'.bmp'))
-
-            # date writing function
-            space1=Image.new('1', (115,25), color=255)
-            measure1= ImageDraw.Draw(space1)
-            date = ImageDraw.Draw(space1)
-            date.text((2, 3), (time.strftime('%a %-d %b %y')),  font=font, fill=0)
-            rotate1 = space1.rotate(270,  expand=1)
-            image.paste(rotate1, (595,20))
-
-            # temperature writing function
-            space2 = Image.new('1', (50,35), color=255)
-            measure2= ImageDraw.Draw(space2)
-            temperature = ImageDraw.Draw(space2)
-            temperature.text((2, 8), (Temperature + " °C"),  fill=0 ,font=font)
-            rotate2 = space2.rotate(270,  expand=1)
-            image.paste(rotate2, (605,334))
-
-            # humidity writing function
-            space3 = Image.new('1', (50,35), color=255)
-            measure3= ImageDraw.Draw(space3)
-            humidity = ImageDraw.Draw(space3)
-            humidity.text((4, 8), (Humidity +'%'),  fill=0 ,font=font)
-            rotate3 = space3.rotate(270,  expand=1)
-            image.paste(rotate3, (570,334))
-
-            # weekday handler
-            if calendar.firstweekday() == 0:
-                draw(weekdaysmon[(time.strftime("%a"))], weekday)
-                
-            if calendar.firstweekday() == 6:
-                draw(weekdayssun[(time.strftime("%a"))], weekday)
-            
-            print('It is currently:',time.strftime('%a %-d %b %y')) #--debug
-            print('The current time is:', time.strftime('%H:%M')) #--debug
-    
-            elist = []
-            for events in c.events:
-                if str(time.year) in str((events.begin).format('YYYY')):
-                    if str(time.month) in str((events.begin).format('M')):
-                        elist.append(int((events.begin).format('D')))
-
-            print('In this month, you have',len(elist),'Events')
-            
-            for x in elist:
-                if x in cal[0]:
-                    draw(positions['a'+str(cal[0].index(x)+1)] ,eventicon)
-                if x in cal[1]:
-                    draw(positions['b'+str(cal[1].index(x)+1)] ,eventicon)
-                if x in cal[2]:
-                    draw(positions['c'+str(cal[2].index(x)+1)] ,eventicon)
-                if x in cal[3]:
-                    draw(positions['d'+str(cal[3].index(x)+1)] ,eventicon)
-                if x in cal[4]:
-                    draw(positions['e'+str(cal[4].index(x)+1)] ,eventicon)
-                try:
-                    if x in cal[5]:
-                        draw(positions['f'+str(cal[5].index(x)+1)] ,eventicon)
-                except IndexError:
-                    pass
-
-            today = time.day
-            if today in cal[0]:
-                draw(positions['a'+str(cal[0].index(today)+1)] ,dateicon)
-            if today in cal[1]:
-                draw(positions['b'+str(cal[1].index(today)+1)] ,dateicon)
-            if today in cal[2]:
-                draw(positions['c'+str(cal[2].index(today)+1)] ,dateicon)
-            if today in cal[3]:
-                draw(positions['d'+str(cal[3].index(today)+1)] ,dateicon)
-            if today in cal[4]:
-                draw(positions['e'+str(cal[4].index(today)+1)] ,dateicon)
-            try:
-                if today in cal[5]:
-                    draw(positions['f'+str(cal[5].index(today)+1)] ,dateicon)
-            except IndexError:
-                    pass
-
-            draw(tempplace, tempicon)
-            draw(humplace, humicon)
-            epd.display_frame(epd.get_frame_buffer(image))
-
-            # delete the list so deleted events can be removed from the list
-            del elist[:]
-            epd.sleep()
-            
-            for i in range(1):
-                nexthour = ((60 - int(time.strftime("%-M")))*60) - (int(time.strftime("%-S")))
-                sleep(nexthour)
-
-if __name__ == '__main__':
-    main()
-    

Calendar/AgendaListDesign.py

@@ -0,0 +1,101 @@
+from DesignEntity import DesignEntity
+from Assets import defaultfontsize, colors, defaultfont, path
+from datetime import datetime, date, timedelta
+from TableDesign import TableDesign
+from PIL import ImageDraw, ImageFont
+from TextFormatter import date_summary_str, event_prefix_str
+from settings import line_thickness
+
+separator_width = line_thickness
+
+
+class AgendaListDesign (DesignEntity):
+    '''Lists upcoming events in chronological order and groups them by days'''
+
+    def __init__(self, size, calendar, line_spacing=0, col_spacing=8, text_size=defaultfontsize, start_date=date.today(), always_add_start_row=True, day_limit_foresight=91):
+        super(AgendaListDesign, self).__init__(size)
+        self.calendar = calendar
+        self.line_spacing = line_spacing
+        self.col_spacing = col_spacing
+        self.text_size = text_size
+        self.day_limit_foresight = day_limit_foresight
+        self.start_dt = date(start_date.year, start_date.month, start_date.day)
+        self.always_add_start_row = always_add_start_row
+
+    def __finish_image__(self):
+        self.__calculate_parameter__()
+        self.__create_infos_events__()
+        self.__draw_infos__()
+        self.__draw_lines__()
+
+    def __calculate_parameter__(self):
+        self.__line_height__ = self.line_spacing + self.__get_text_height__()
+        self.__event_number__ = int(int(self.size[1]) // self.__line_height__)
+        self.__date_fontsize__ = self.text_size
+        self.__date_linespace__ = self.line_spacing
+
+    def __create_infos_events__(self):
+        self.infos = []
+        self.cell_props = []
+        fetch_day = self.start_dt
+        days_foresight = 0
+        while len(self.infos) < self.__event_number__ and days_foresight < self.day_limit_foresight:
+            day_events = self.calendar.get_day_events(fetch_day)
+            fetch_day_added_once = False
+            for event in day_events:
+                row = [""]
+                if fetch_day_added_once is False:
+                    row.append(date_summary_str(fetch_day))
+                    fetch_day_added_once = True
+                else:
+                    row.append("")
+
+                row.append(event_prefix_str(event, fetch_day))
+                row.append(event.title)
+                self.cell_props.append(self.__get_row_props__(event))
+
+                self.infos.append(row)
+            fetch_day = fetch_day + timedelta(1)
+            days_foresight = days_foresight + 1
+
+        if self.infos[0][1] != date_summary_str(self.start_dt) and self.always_add_start_row:
+            row = ["", date_summary_str(self.start_dt), "", ""]
+            props = self.__get_row_props__()
+            self.infos.insert(0, row)
+            self.cell_props.insert(0, props)
+
+    def __draw_infos__(self):
+        table = TableDesign(self.size, self.infos, fontsize=self.__date_fontsize__,
+                            line_spacing=self.__date_linespace__, col_spacing=self.col_spacing, cell_properties=self.cell_props)
+        self.draw_design(table)
+
+    def __draw_lines__(self):
+        for i, (_, date, _, _) in enumerate(self.infos[1:]):
+            if date is not "":
+                self.__draw_line__(i + 1)
+
+    def __draw_line__(self, index):
+        ypos = index * self.__line_height__ - self.line_spacing / 2
+        pos = (0, ypos)
+        positions = [pos, (self.size[0], ypos)]
+
+        ImageDraw.Draw(self.__image__).line(
+            positions, fill=colors["fg"], width=separator_width)
+
+    def __get_row_props__(self, event=None):
+        color = colors["fg"]
+        bg_color = colors["bg"]
+        default_cell = {
+            "color": color,
+            "background_color": bg_color
+        }
+        if event is not None and event.highlight:
+            color = colors["hl"]
+        cell = {
+            "color": color,
+            "background_color": bg_color
+        }
+        return [default_cell, default_cell, cell, cell]
+
+    def __get_text_height__(self):
+        return ImageFont.truetype(path + defaultfont, self.text_size).font.height

Calendar/AgendaListPanel.py

@@ -0,0 +1,90 @@
+from PanelDesign import PanelDesign
+from AgendaListDesign import AgendaListDesign
+from WeatherHeaderDesign import WeatherHeaderDesign
+from settings import general_settings, line_thickness
+from PIL import ImageDraw
+from Assets import colors
+from RssPostListDesign import RssPostListDesign
+from CryptoListDesign import CryptoListDesign
+
+agenda_ypadding = 5
+weatherheader_height = 0.113
+seperator_width = line_thickness
+infolist_size = (1, 0.24)
+infolist_padding = 0
+
+
+class AgendaListPanel (PanelDesign):
+    '''Lists upcoming events in chronological order and groups them by days'''
+
+    def __init__(self, size):
+        super(AgendaListPanel, self).__init__(size)
+        self.weather_size = (0, 0)
+        self.info_size = (0, 0)
+        if general_settings["weather-info"]:
+            self.weather_size = (
+                self.size[0], self.size[1] * weatherheader_height)
+
+    def add_weather(self, weather):
+        self.weather = weather
+
+    def add_calendar(self, calendar):
+        self.calendar = calendar
+
+    def add_rssfeed(self, rss):
+        if general_settings["info-area"] != "rss":
+            return
+
+        self.info_size = self.__abs_pos__(infolist_size)
+        pos = (0, self.size[1] - self.info_size[1] + infolist_padding)
+
+        list = RssPostListDesign(self.info_size, rss)
+        list.pos = pos
+        self.draw_design(list)
+
+        self.__draw_seperator__(1-infolist_size[1], colors["fg"])
+
+    def add_tasks(self, tasks):
+        pass
+
+    def add_crypto(self, crypto):
+        if general_settings["info-area"] != "crypto":
+            return
+
+        self.info_size = self.__abs_pos__(infolist_size)
+        pos = (0, self.size[1] - self.info_size[1] + infolist_padding)
+
+        list = CryptoListDesign(self.info_size, crypto)
+        height = list.get_estimated_height()
+        list.pos = (pos[0], pos[1] + (self.info_size[1] - height))
+        self.draw_design(list)
+
+        self.info_size = (self.size[0], height)
+        self.__draw_seperator__(list.pos[1] / self.size[1], colors["fg"])
+
+    def __finish_panel__(self):
+        self.__draw_calendar__()
+        if general_settings["weather-info"]:
+            self.__draw_weather__()
+
+    def __draw_seperator__(self, height, color):
+        ImageDraw.Draw(self.__image__).line([self.__abs_pos__(
+            (0, height)), self.__abs_pos__((1, height))], fill=color, width=seperator_width)
+
+    def __abs_pos__(self, pos, size=None):
+        if size is None:
+            size = self.size
+        return (int(pos[0] * size[0]), int(pos[1] * size[1]))
+
+    def __draw_calendar__(self):
+        size = (self.size[0], self.size[1] - self.weather_size[1] -
+                self.info_size[1] - agenda_ypadding)
+
+        agenda = AgendaListDesign(size, self.calendar)
+        agenda.pos = (0, agenda_ypadding + self.weather_size[1])
+        self.draw_design(agenda)
+
+    def __draw_weather__(self):
+        header = WeatherHeaderDesign(self.weather_size, self.weather)
+        self.draw_design(header)
+        self.__draw_seperator__(weatherheader_height, colors["hl"])

Calendar/Assets.py

@@ -0,0 +1,95 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+from PIL import Image, ImageFont
+from settings import font_boldness, font_size
+import os
+im_open = Image.open
+
+path = os.path.dirname(os.path.abspath(__file__)).replace("\\", "/")
+if path != "" and path[-1] != "/":
+    path += "/"
+
+wpath = path+'weather-icons/'
+opath = path+'other/'
+fpath = 'fonts/'
+
+tempicon = im_open(opath+'temperature.jpeg')
+humicon = im_open(opath+'humidity.jpeg')
+no_response = im_open(opath+'cloud-no-response.jpeg')
+sunriseicon = im_open(opath+'wi-sunrise.jpeg')
+sunseticon = im_open(opath+'wi-sunset.jpeg')
+windicon = im_open(opath+'wi-strong-wind.jpeg')
+
+fonts = {
+    "extralight": fpath + "Assistant-ExtraLight.otf",
+    "light": fpath + "Assistant-Light.otf",
+    "regular": fpath + "Assistant-Regular.otf",
+    "semibold": fpath + "Assistant-SemiBold.otf",
+    "bold": fpath + "Assistant-Bold.otf",
+    "extrabold": fpath + "Assistant-ExtraBold.otf"
+}
+
+defaultfont = fonts[font_boldness]
+defaultfontsize = int(font_size)
+
+weathericons = {
+    '01d': 'wi-day-sunny', '02d': 'wi-day-cloudy', '03d': 'wi-cloudy',
+    '04d': 'wi-cloudy-windy', '09d': 'wi-showers', '10d': 'wi-rain',
+    '11d': 'wi-thunderstorm', '13d': 'wi-snow', '50d': 'wi-fog',
+    '01n': 'wi-night-clear', '02n': 'wi-night-cloudy',
+    '03n': 'wi-night-cloudy', '04n': 'wi-night-cloudy',
+    '09n': 'wi-night-showers', '10n': 'wi-night-rain',
+    '11n': 'wi-night-thunderstorm', '13n': 'wi-night-snow',
+    '50n': 'wi-night-alt-cloudy-windy'}
+
+colors = {
+    "hl": "red",
+    "fg": "black",
+    "bg": "white"
+}
+
+supported_img_formats = [
+    "BMP",
+    "DIB",
+    "EPS",
+    "GIF",
+    "ICNS",
+    "ICO",
+    "IM",
+    "JPG",
+    "JPEG",
+    "J2K",
+    "J2P",
+    "JPX",
+    "MSP",
+    "PCX",
+    "PNG",
+    "PPM",
+    "SGI",
+    "SPI",
+    "TGA",
+    "TIFF",
+    "WEBP",
+    "XBM",
+    "BLP",
+    "CUR",
+    "DCX",
+    "DDS",
+    "FLI",
+    "FLC",
+    "FPX",
+    "FTEX",
+    "GBR",
+    "GD",
+    "IMT",
+    "IPTC",
+    "NAA",
+    "MCIDAS",
+    "MIC",
+    "MPO",
+    "PCD",
+    "PIXAR",
+    "PSD",
+    "WAL",
+    "XPM",
+]

Calendar/BoxDesign.py

@@ -0,0 +1,23 @@
+from DesignEntity import DesignEntity
+from PIL import ImageDraw, ImageOps
+
+
+class BoxDesign (DesignEntity):
+    """Redefinition of ImageDraw.Draw.Rectangle"""
+
+    def __init__(self, size, fill=None, outline=None, width=0):
+        super(BoxDesign, self).__init__((size[0]+1, size[1]+1), mask=True)
+        self.size = size
+        self.__define_corners__()
+        self.fill = fill
+        self.outline = outline
+        self.width = width
+
+    def __define_corners__(self):
+        topleft = (0, 0)
+        bottomright = self.size
+        self.corners = [topleft, bottomright]
+
+    def __finish_image__(self):
+        ImageDraw.Draw(self.__image__).rectangle(
+            self.corners, fill=self.fill, outline=self.outline, width=self.width)

Calendar/CalendarEvent.py

@@ -0,0 +1,24 @@
+class CalendarEvent (object):
+    """Defines a calendar event, independent of any implementation"""
+
+    def __init__(self):
+        self.begin_datetime = None
+        self.end_datetime = None
+        self.duration = None
+        self.allday = None
+        self.multiday = None
+        self.rrule = None
+
+        self.title = None
+        self.description = None
+        self.attendees = []
+        self.highlight = None
+
+        self.calendar_name = None
+        self.calendar_url = None
+
+        self.location = None
+        self.fetch_datetime = None
+
+    def __repr__(self):
+        return self.title

Calendar/CalendarInterface.py

@@ -0,0 +1,182 @@
+from DataSourceInterface import DataSourceInterface
+from datetime import datetime, timezone, timedelta, date
+from dateutil.rrule import rrulestr
+from dateutil.parser import parse
+import calendar
+from CalendarEvent import CalendarEvent
+
+
+class CalendarInterface (DataSourceInterface):
+    """Interface for fetching and processing calendar event information."""
+
+    def __init__(self):
+        self.events = []
+        self.excluded_urls = []
+
+    def reload(self):
+        if self.is_available() == False:
+            return
+        self.events = self.__get_events__()
+        self.events = self.__sort_events__(self.events)
+
+    def exclude_calendars(self, urls=[]):
+        self.excluded_urls = urls
+
+    def __sort_events__(self, events):
+        events.sort(key=lambda x: x.begin_datetime)
+        return events
+
+    def __sort_event_types__(self, events):
+        multiday = [ev for ev in events if ev.multiday]
+        allday = [ev for ev in events if ev.allday and ev.multiday == False]
+        timed = [ev for ev in events if ev.allday ==
+                 False and ev.multiday == False]
+        return multiday + allday + timed
+
+    def __get_events__(self):
+        raise NotImplementedError("Functions needs to be implemented")
+
+    def get_upcoming_events(self, timespan=None, start_time=None):
+        if timespan is None:
+            timespan = timedelta(31)
+        if start_time == None:
+            local_tzinfo = datetime.now(timezone.utc).astimezone().tzinfo
+            start_time = datetime.now(local_tzinfo)
+        return self.__get_events_in_range__(start_time, timespan)
+
+    def get_today_events(self):
+        return self.get_day_events(date.today())
+
+    def get_day_events(self, day):
+        if type(day) is not type(date.today()):
+            raise TypeError(
+                "get_day_events only takes date-objects as parameters, not \"%s\"" % str(type(day)))
+        local_tzinfo = datetime.now(timezone.utc).astimezone().tzinfo
+        day_start = datetime(day.year, day.month, day.day,
+                             0, 0, 0, 0, local_tzinfo)
+        return self.__get_events_in_range__(day_start, timedelta(1))
+
+    def get_month_events(self, month=-1, year=-1):
+        if month < 0:
+            month = datetime.now().month
+        if year < 0:
+            year = datetime.now().year
+
+        local_tzinfo = datetime.now(timezone.utc).astimezone().tzinfo
+        month_start = datetime(year, month, 1, 0, 0, 0, 0, local_tzinfo)
+        month_days = calendar.monthrange(
+            month_start.year, month_start.month)[1]
+        return self.__get_events_in_range__(month_start, timedelta(month_days))
+
+    def __get_events_in_range__(self, start, duration):
+        if self.events is None:
+            return []
+
+        if start.tzinfo is None:
+            raise TypeError("start datetime needs to be timezone-aware")
+
+        events_in_range = []
+        for event in self.events:
+            # Is excluded?
+            if event.calendar_url in self.excluded_urls:
+                continue
+
+            event_occurrence = self.__get_if_event_in_range__(
+                event, start, duration)
+            if event_occurrence:
+                events_in_range.extend(event_occurrence)
+
+        events_in_range = self.__sort_events__(events_in_range)
+        return self.__sort_event_types__(events_in_range)
+
+    def __get_if_event_in_range__(self, event, start, duration):
+        '''Returns list or None'''
+        if event is None:
+            return None
+
+        if event.rrule is None:
+            return self.__is_onetime_in_range__(event, start, duration)
+        else:
+            return self.__is_repeating_in_range__(event, start, duration)
+
+    def __is_onetime_in_range__(self, event, start, duration):
+        if event.begin_datetime > start:
+            first_start = start
+            first_duration = duration
+            second_start = event.begin_datetime
+        else:
+            first_start = event.begin_datetime
+            first_duration = event.duration
+            second_start = start
+
+        if (second_start - first_start) < first_duration:
+            return [event]
+        else:
+            return None
+
+    def __is_repeating_in_range__(self, event, start, duration):
+        end = start + duration
+        occurrences = []
+
+        try:
+            r_string = ""
+            r_string = self.__add_timezoneawarness__(event.rrule)
+            rule = rrulestr(r_string, dtstart=event.begin_datetime)
+            for occurrence in rule:
+                if occurrence - end > timedelta(0):
+                    return occurrences
+                merged_event = self.__merge_event_data__(
+                    event, start=occurrence)
+                if self.__is_onetime_in_range__(merged_event, start, duration):
+                    occurrences.append(merged_event)
+            return occurrences
+        except Exception as ex:
+            print("\"is_repeating_in_range\" failed while processing: dtstart="+str(event.begin_datetime) +
+                  " dtstart.tzinfo="+str(event.begin_datetime.tzinfo)+" rrule="+r_string)
+            raise ex
+
+    def __merge_event_data__(self, event, start=None):
+        merged_event = CalendarEvent()
+        
+        merged_event.begin_datetime = event.begin_datetime
+        merged_event.end_datetime = event.end_datetime
+        merged_event.duration = event.duration
+        merged_event.allday = event.allday
+        merged_event.multiday = event.multiday
+        merged_event.rrule = event.rrule
+
+        merged_event.title = event.title
+        merged_event.description = event.description
+        merged_event.attendees = event.attendees
+        merged_event.highlight = event.highlight
+
+        merged_event.calendar_name = event.calendar_name
+        merged_event.calendar_url = event.calendar_url
+
+        merged_event.location = event.location
+        merged_event.fetch_datetime = event.fetch_datetime
+        
+        if start is not None:
+            merged_event.begin_datetime = start
+            merged_event.end_datetime = start + event.duration
+
+        return merged_event
+
+    def __add_timezoneawarness__(self, rrule):
+        """UNTIL must be specified in UTC when DTSTART is timezone-aware (which it is)"""
+        if "UNTIL" not in rrule:
+            return rrule
+
+        timezone_str = "T000000Z"
+        until_template = "UNTIL=YYYYMMDD"
+
+        until_index = rrule.index("UNTIL")
+
+        tz_index = until_index + len(until_template)
+        if until_index < 0 or (tz_index < len(rrule) and rrule[tz_index] is "T"):
+            return rrule
+
+        if tz_index == len(rrule):
+            return rrule + timezone_str
+        else:
+            return rrule[:tz_index] + timezone_str + rrule[tz_index:]

Calendar/CryptoCoin.py

@@ -0,0 +1,10 @@
+class CryptoCoin(object):
+    def __init__(self):
+        self.name = None
+        self.symbol = None
+        self.price = None
+        self.day_change = None
+        self.currency = None
+        self.datetime = None
+
+        self.fetch_datetime = None

Calendar/CryptoInterface.py

@@ -0,0 +1,17 @@
+from DataSourceInterface import DataSourceInterface
+
+
+class CryptoInterface(DataSourceInterface):
+    def __init__(self):
+        self.crypto_coins = []
+
+    def reload(self):
+        if self.is_available() == False:
+            return
+        self.crypto_coins = self.__get_coins__()
+
+    def __get_coins__(self):
+        raise NotImplementedError("Function needs to be implemented")
+
+    def get_coins(self):
+        return self.crypto_coins

Calendar/CryptoListDesign.py

@@ -0,0 +1,39 @@
+from DesignEntity import DesignEntity
+from TableDesign import TableDesign
+from Assets import defaultfontsize
+from GeckoCrypto import GeckoCrypto
+from settings import crypto_coins
+
+xpadding = 5
+
+
+class CryptoListDesign (DesignEntity):
+    def __init__(self, size, crypto, text_size=defaultfontsize):
+        super(CryptoListDesign, self).__init__(size)
+        self.crypto = crypto
+        self.text_size = text_size
+        self.matrix = self.__get_matrix__()
+
+    def __finish_image__(self):
+        col_spacing = 10
+        if len(self.matrix) > 0:
+            col_spacing = (self.size[0] / len(self.matrix[0])) * 0.5
+
+        table_design = TableDesign(self.size, matrix=self.matrix, col_spacing=col_spacing,
+                                   fontsize=self.text_size, mask=False, truncate_rows=True)
+        table_design.pos = (xpadding, 0)
+        self.draw_design(table_design)
+
+    def __get_matrix__(self):
+        matrix = []
+        coins = self.crypto.get_coins()
+        for coin in coins:
+            row = [coin.symbol.upper(), coin.name, coin.currency + " " +
+                   str(coin.price), "% " + str(coin.day_change)]
+            matrix.append(row)
+        return matrix
+
+    def get_estimated_height(self):
+        line_height = self.text_size * 1.25
+        height = line_height * len(self.matrix)
+        return height

Calendar/DataSourceInterface.py

@@ -0,0 +1,8 @@
+class DataSourceInterface (object):
+    """Interface for child interfaces that fetch data."""
+
+    def is_available(self):
+        raise NotImplementedError("Functions needs to be implemented")
+
+    def reload(self):
+        raise NotImplementedError("Functions needs to be implemented")

Calendar/DayBoxDesign.py

@@ -0,0 +1,33 @@
+from DesignEntity import DesignEntity
+from SingelDayEventListDesign import SingelDayEventListDesign
+from TextDesign import TextDesign
+
+header_height = 0.2
+
+
+class DayBoxDesign (DesignEntity):
+    """Represents a day with its events in a box."""
+
+    def __init__(self, size, date):
+        super(DayBoxDesign, self).__init__(size)
+        self.date = date
+
+    def add_calendar(self, calendar):
+        self.calendar = calendar
+
+    def __finish_image__(self):
+        self.__draw_header__()
+        self.__draw_events__()
+
+    def __draw_header__(self):
+        pass
+
+    def __draw_events__(self):
+        events = self.calendar.get_day_events(self.date)
+
+        pos = (0, self.size[1] * header_height)
+        size = (self.size[0], self.size[1] - pos[1])
+
+        event_list = SingelDayEventListDesign(size, events)
+        event_list.pos = pos
+        self.draw_design(event_list)

Calendar/DayFocusListPanel.py

@@ -0,0 +1,151 @@
+from datetime import date, datetime, timedelta, timezone
+from settings import line_thickness, general_settings
+from DayHeaderDesign import DayHeaderDesign
+from HourListDesign import HourListDesign
+from DayRowDesign import DayRowDesign
+from PanelDesign import PanelDesign
+from Assets import colors
+from PIL import ImageDraw
+
+HEADER_SIZE = (1, 0.2)
+HOURLIST_HEIGHT = 0.3
+HOURLIST_SIZE = (1, HOURLIST_HEIGHT)
+DAYLIST_YPOS = HEADER_SIZE[1] + HOURLIST_SIZE[1]
+DAYLIST_HEIGHT = 1 - HEADER_SIZE[1] - HOURLIST_SIZE[1]
+DAYLIST_SIZE = (1, DAYLIST_HEIGHT)
+HOURS_COUNT = 6
+DAYROW_MIN_FORMAT = 40 / 384
+DAYROW_MAX_FORMAT = 60 / 384
+PANEL_LINE_THICKNESS = line_thickness
+
+
+class DayFocusListPanel (PanelDesign):
+    """Shows Day-View for today and a short Day-List for
+    the upcoming days."""
+
+    def __init__(self, size):
+        super(DayFocusListPanel, self).__init__(size)
+        self.hours_count = HOURS_COUNT
+        self.__init_modules__()
+
+    def __abs_co__(self, coordinates):
+        return (int(coordinates[0] * self.size[0]), int(coordinates[1] * self.size[1]))
+
+    def __init_modules__(self):
+        self.__init_header__()
+        self.__init_hourlist__()
+        self.__init_daylist__()
+
+    def __init_header__(self):
+        self.__header__ = DayHeaderDesign(
+            self.__abs_co__(HEADER_SIZE), date.today())
+        self.__header__.pos = (0, 0)
+
+    def __init_hourlist__(self):
+        start, end = self.__get_current_hour_range__()
+        size = self.__abs_co__(HOURLIST_SIZE)
+
+        self.__hourlist__ = HourListDesign(size, start, end)
+        self.__hourlist__.pos = (0, self.__header__.size[1])
+
+    def __init_daylist__(self):
+        self.__daylist_rows__ = []
+        self.__calc_dayrow_size__()
+        self.__create_day_rows__()
+
+    def __calc_dayrow_size__(self):
+        max_area_height = DAYLIST_HEIGHT * self.size[1]
+        max_row_number = max_area_height / (DAYROW_MIN_FORMAT * self.size[0])
+        min_row_number = max_area_height / (DAYROW_MAX_FORMAT * self.size[0])
+        average_row_number = (max_row_number + min_row_number) / 2
+        self.dayrow_count = round(average_row_number)
+        row_height = max_area_height / self.dayrow_count
+        self.dayrow_size = (1, row_height / self.size[1])
+
+    def __create_day_rows__(self):
+        following_days = self.__get_following_days__()
+        for i, date in enumerate(following_days):
+            row = DayRowDesign(self.__abs_co__(self.dayrow_size), date)
+            row.pos = self.__get_day_row_pos__(i)
+            self.__daylist_rows__.append(row)
+
+    def __get_following_days__(self):
+        following_days = []
+        for i in range(self.dayrow_count):
+            following_days.append(date.today() + timedelta(days=i + 1))
+        return following_days
+
+    def __get_day_row_pos__(self, i):
+        ypos = self.size[1] * DAYLIST_YPOS
+        down_shift = i * self.dayrow_size[1] * self.size[1]
+        return (0, int(ypos + down_shift))
+
+    def __finish_panel__(self):
+        self.draw_design(self.__header__)
+        self.draw_design(self.__hourlist__)
+
+        for row in self.__daylist_rows__:
+            self.draw_design(row)
+        self.__draw_daylist_lines__()
+
+    def __draw_daylist_lines__(self):
+        positions = []
+        for i in range(len(self.__daylist_rows__)):
+            positions.append(self.__get_day_row_pos__(i)[1])
+        for ypos in positions:
+            line_start = (0, ypos)
+            line_end = (self.size[0], ypos)
+            ImageDraw.Draw(self.__image__).line(
+                [line_start, line_end], fill=colors["fg"], width=PANEL_LINE_THICKNESS)
+
+    def __get_current_hour_range__(self):
+        start_hour = datetime.now().hour
+        additional_hours = self.hours_count - 1
+
+        if start_hour + additional_hours > 23:
+            start_hour = 23 - additional_hours
+
+        return start_hour, start_hour + additional_hours
+
+    def add_weather(self, weather):
+        self.__header__.add_weather(weather)
+
+    def add_calendar(self, calendar):
+        allday_ev, timed_ev = self.__split_events__(
+            calendar.get_today_events())
+        self.__header__.add_events(allday_ev)
+        self.__hourlist__.add_events(timed_ev)
+
+        self.__add_calendar_daylist__(calendar)
+
+    def __split_events__(self, events):
+        allday_ev = []
+        timed_ev = []
+
+        for event in events:
+            if event.allday:
+                allday_ev.append(event)
+            elif event.multiday:
+                if self.__is_today__(event.begin_datetime):
+                    timed_ev.append(event)
+                elif self.__is_today__(event.end_datetime):
+                    timed_ev.append(event)
+                else:
+                    allday_ev.append(event)
+            else:
+                timed_ev.append(event)
+        return allday_ev, timed_ev
+
+    def __is_today__(self, dt):
+        today = date.today()
+        return dt.day == today.day and \
+            dt.month == today.month and \
+            dt.year == today.year
+
+    def __add_calendar_daylist__(self, calendar):
+        calendar.exclude_calendars(general_settings["extra-excluded-urls"])
+
+        for row in self.__daylist_rows__:
+            row.add_calendar(calendar)
+
+        calendar.exclude_calendars()

Calendar/DayHeaderDesign.py

@@ -0,0 +1,154 @@
+from DesignEntity import DesignEntity
+from PIL import ImageDraw
+from TextDesign import TextDesign
+from WeatherColumnDesign import WeatherColumnDesign
+from datetime import date, timedelta, datetime, timezone
+from SingelDayEventListDesign import SingelDayEventListDesign
+from Assets import fonts, colors, defaultfontsize
+from settings import general_settings
+from BoxDesign import BoxDesign
+
+numberbox_ypos = 0.15
+numberbox_height = 1 - 2 * numberbox_ypos
+number_height = numberbox_height * 0.83
+number_boxypos = 0.17
+month_height = numberbox_height / 4
+monthbox_xpadding = 0.013
+monthbox_ypadding = -0.05
+monthbox_width = 1 - numberbox_ypos - monthbox_xpadding
+weathercolumn_y_size = (0.4, 1)
+weekday_height = numberbox_height * 0.19
+weekdaybox_height = (weekday_height / numberbox_height) * 1.5
+eventlist_static_fontsize = defaultfontsize
+eventlist_xpadding = monthbox_xpadding
+eventlist_ypadding = 0.01
+
+numberbox_font_color = colors["bg"]
+numberbox_background_color = colors["hl"]
+weekday_font = fonts["bold"]
+
+
+class DayHeaderDesign (DesignEntity):
+    """Detailed and big view of a given date."""
+
+    def __init__(self, size, date):
+        super(DayHeaderDesign, self).__init__(size)
+        self.weather_column_width = 0
+        self.date = date
+
+    def add_weather(self, weather):
+        if general_settings["weather-info"] == False:
+            return
+
+        forecast = weather.get_forecast_in_days(
+            self.date.day - date.today().day)
+        self.weather_column_width = weathercolumn_y_size[0] * self.size[1]
+        size = (self.weather_column_width,
+                weathercolumn_y_size[1] * self.size[1])
+        pos = (self.size[0] - size[0], 0)
+
+        design = WeatherColumnDesign(size, forecast)
+        design.pos = pos
+        self.draw_design(design)
+
+    def add_calendar(self, calendar):
+        local_tzinfo = datetime.now(timezone.utc).astimezone().tzinfo
+        now = datetime.now(local_tzinfo)
+        time_until_tomorrow = (datetime(
+            now.year, now.month, now.day, 0, 0, 0, 0, local_tzinfo) + timedelta(1)) - now
+        self.__draw_event_list__(
+            calendar.get_upcoming_events(time_until_tomorrow, now))
+
+    def add_events(self, events):
+        self.__draw_event_list__(events)
+
+    def add_rssfeed(self, rss):
+        pass
+
+    def add_crypto(self, crypto):
+        pass
+
+    def __finish_image__(self):
+        self.__draw_number_square__()
+        self.__draw_month__()
+
+    def __draw_event_list__(self, events):
+        box_ypos = numberbox_ypos * self.size[1]
+        box_xpos = numberbox_ypos * self.size[1]
+        box_height = numberbox_height * self.size[1]
+        xpadding = eventlist_xpadding * self.size[0]
+        ypadding = eventlist_ypadding * self.size[1]
+        monthbox_height = (monthbox_ypadding + month_height) * self.size[1]
+        pos = (box_xpos + box_height + xpadding,
+               box_ypos + monthbox_height + ypadding)
+        size = (self.size[0] - pos[0] - self.weather_column_width,
+                self.size[1] - pos[1] - box_ypos)
+        fontsize = eventlist_static_fontsize
+
+        rel_dates = [self.date for _ in range(len(events))]
+        event_list = SingelDayEventListDesign(
+            size, events, fontsize, event_prefix_rel_dates=rel_dates)
+        event_list.pos = pos
+        self.draw_design(event_list)
+
+    def __draw_month__(self):
+        font_size = int(month_height * self.size[1])
+        xpadding = int(monthbox_xpadding * self.size[0])
+        ypadding = int(monthbox_ypadding * self.size[1])
+        box_ypos = int(numberbox_ypos * self.size[1])
+        box_height = int(numberbox_height * self.size[1])
+        box_pos = (box_ypos + box_height + xpadding, box_ypos + ypadding)
+        box_size = (int(monthbox_width * self.size[0]), box_height)
+
+        month_name = self.date.strftime("%B")
+        month = TextDesign(box_size, text=month_name, fontsize=font_size)
+        month.pos = box_pos
+        self.draw_design(month)
+
+    def __draw_number_square__(self):
+        box_height = numberbox_height * self.size[1]
+        box_ypos = numberbox_ypos * self.size[1]
+        box_pos = (box_ypos, box_ypos)
+        box_size = (box_height, box_height)
+
+        box = BoxDesign(box_size, fill=numberbox_background_color)
+        box.pos = box_pos
+        self.draw_design(box)
+
+        self.__draw_today_number__()
+        self.__draw_weekday__()
+
+    def __draw_today_number__(self):
+        font_size = number_height * self.size[1]
+        box_height = numberbox_height * self.size[1]
+        box_ypos = numberbox_ypos * self.size[1]
+        ypadding = number_boxypos * box_height
+        size = (box_height, box_height - ypadding)
+        pos = (box_ypos, box_ypos + ypadding)
+
+        day_text = self.__get_day_text__()
+        number = TextDesign(size, text=day_text, background_color=numberbox_background_color,
+                            color=numberbox_font_color, fontsize=font_size, horizontalalignment="center", verticalalignment="center")
+        number.pos = pos
+        number.mask = False
+        self.draw_design(number)
+
+    def __draw_weekday__(self):
+        font_size = weekday_height * self.size[1]
+        box_height = numberbox_height * self.size[1]
+        size = (box_height, weekdaybox_height * box_height)
+        box_ypos = numberbox_ypos * self.size[1]
+        pos = (box_ypos, box_ypos)
+
+        week_day_name = self.date.strftime("%A")
+        week_day = TextDesign(size, text=week_day_name, background_color=numberbox_background_color, color=numberbox_font_color,
+                              fontsize=font_size, horizontalalignment="center", verticalalignment="center", font=weekday_font)
+        week_day.pos = pos
+        week_day.mask = False
+        self.draw_design(week_day)
+
+    def __abs_co__(self, coordinates):
+        return (int(coordinates[0] * self.size[0]), int(coordinates[1] * self.size[1]))
+
+    def __get_day_text__(self):
+        return str(self.date.day)

Calendar/DayListPanel.py

@@ -0,0 +1,140 @@
+from PanelDesign import PanelDesign
+from Assets import colors
+from settings import general_settings
+import calendar as callib
+from datetime import datetime, timedelta, date
+from PIL import ImageDraw
+from TextDesign import TextDesign
+from DayHeaderDesign import DayHeaderDesign
+from DayRowDesign import DayRowDesign
+from RssPostListDesign import RssPostListDesign
+from CryptoListDesign import CryptoListDesign
+from settings import line_thickness
+from math import ceil
+
+todayheader_pos = (0, 0)
+todayheader_size = (1, 0.25)
+lines_thickness = line_thickness
+infoarea_replacedrowscount = 3
+
+dayrowsarea_ypos = todayheader_size[1]
+dayrowsarea_height = 1 - todayheader_size[1]
+dayrow_min_format = 50 / 384
+dayrow_max_format = 70 / 384
+rss_y_padding = 5
+crypto_y_padding = 5
+
+
+class DayListPanel (PanelDesign):
+    """Overview that focuses on the current day and
+    lists following days in a list below."""
+
+    def __init__(self, size):
+        super(DayListPanel, self).__init__(size)
+        self.__day_rows__ = []
+        self.__calc_dayrow_size__()
+        self.__first_render__()
+
+    def __first_render__(self):
+        self.__draw_today_header__()
+        self.__draw_day_rows__()
+
+    def add_weather(self, weather):
+        for row in self.__day_rows__:
+            row.add_weather(weather)
+
+    def add_calendar(self, calendar):
+        for row in self.__day_rows__:
+            row.add_calendar(calendar)
+
+    def add_rssfeed(self, rss):
+        for row in self.__day_rows__:
+            row.add_rssfeed(rss)
+        if general_settings["info-area"] is "rss":
+            self.__day_rows__ = self.__day_rows__[:-infoarea_replacedrowscount]
+            self.__draw_rss_infoarea__(rss)
+
+    def add_crypto(self, crypto):
+        if general_settings["info-area"] is "crypto":
+            self.__draw_crypto_infoarea__(crypto)
+
+    def add_tasks(self, tasks):
+        pass
+
+    def __draw_rss_infoarea__(self, rss):
+        height = infoarea_replacedrowscount * \
+            self.dayrow_size[1] * self.size[1] - rss_y_padding
+        ypos = self.size[1] - height
+        size = (self.size[0], height)
+        pos = (0, ypos)
+
+        design = RssPostListDesign(size, rss)
+        design.pos = pos
+        self.draw_design(design)
+
+    def __draw_crypto_infoarea__(self, crypto):
+        height = infoarea_replacedrowscount * \
+            self.dayrow_size[1] * self.size[1] - crypto_y_padding
+        ypos = self.size[1] - height
+        size = (self.size[0], height)
+        pos = (0, ypos)
+
+        design = CryptoListDesign(size, crypto)
+        acutal_height = design.get_estimated_height()
+        design.pos = (pos[0], pos[1] + (height - acutal_height))
+        self.draw_design(design)
+
+        replaced_rows = ceil(
+            acutal_height / (self.dayrow_size[1] * self.size[1]))
+        self.__day_rows__ = self.__day_rows__[:-replaced_rows]
+
+    def __draw_day_rows__(self):
+        following_days = self.__get_following_days__()
+        for i, date in enumerate(following_days):
+            row = DayRowDesign(self.__abs_co__(self.dayrow_size), date)
+            row.pos = self.__get_day_row_pos__(i)
+            self.__day_rows__.append(row)
+
+    def __get_day_row_pos__(self, i):
+        ypos = self.size[1] * dayrowsarea_ypos
+        down_shift = i * self.dayrow_size[1] * self.size[1]
+        return (0, int(ypos + down_shift))
+
+    def __calc_dayrow_size__(self):
+        max_area_height = dayrowsarea_height * self.size[1]
+        max_row_number = max_area_height / (dayrow_min_format * self.size[0])
+        min_row_number = max_area_height / (dayrow_max_format * self.size[0])
+        average_row_number = (max_row_number + min_row_number) / 2
+        self.dayrow_count = round(average_row_number)
+        row_height = max_area_height / self.dayrow_count
+        self.dayrow_size = (1, row_height / self.size[1])
+
+    def __get_following_days__(self):
+        following_days = []
+        for i in range(self.dayrow_count):
+            following_days.append(date.today() + timedelta(days=i + 1))
+        return following_days
+
+    def __draw_today_header__(self):
+        header = DayHeaderDesign(self.__abs_co__(
+            todayheader_size), date.today())
+        header.pos = self.__abs_co__(todayheader_pos)
+        self.__day_rows__.append(header)
+
+    def __draw_lines__(self):
+        positions = []
+        for i in range(len(self.__day_rows__)):
+            positions.append(self.__get_day_row_pos__(i)[1])
+        for ypos in positions:
+            line_start = (0, ypos)
+            line_end = (self.size[0], ypos)
+            ImageDraw.Draw(self.__image__).line(
+                [line_start, line_end], fill=colors["fg"], width=lines_thickness)
+
+    def __finish_panel__(self):
+        for design in self.__day_rows__:
+            self.draw_design(design)
+        self.__draw_lines__()
+
+    def __abs_co__(self, coordinates):
+        return (int(coordinates[0] * self.size[0]), int(coordinates[1] * self.size[1]))

Calendar/DayRowDesign.py

@@ -0,0 +1,123 @@
+from PIL import ImageDraw, Image
+from TextDesign import TextDesign
+from settings import week_starts_on, owm_paid_subscription, general_settings
+from DesignEntity import DesignEntity
+from datetime import datetime
+from Assets import weathericons, wpath, fonts, colors, defaultfontsize
+from SingelDayEventListDesign import SingelDayEventListDesign
+
+daynumber_y_size = (1, 0.60)
+weekday_y_size = (daynumber_y_size[0], 1 - daynumber_y_size[1])
+weekday_ypos = daynumber_y_size[1]
+daynumber_fontsize = daynumber_y_size[1] * 0.85
+daynumber_ypadding = 0.1
+weekday_fontsize = weekday_y_size[1] * 0.65
+weathericon_ypos = 0.1
+weathericon_height = 1 - 2 * weathericon_ypos
+eventlist_xpadding = 5
+eventlist_ypos = 0.02
+eventlist_y_fontsize = 0.2
+
+font = fonts["light"]
+
+
+class DayRowDesign (DesignEntity):
+    """Detailed view of a given date."""
+
+    def __init__(self, size, date):
+        super(DayRowDesign, self).__init__(size)
+        self.__init_image__()
+        self.date = date
+
+    def add_weather(self, weather):
+        if weather.is_available is False:
+            return
+        self.__draw_forecast__(weather)
+
+    def add_calendar(self, calendar):
+        self.__draw_event_list__(calendar)
+
+    def add_rssfeed(self, rss):
+        pass
+
+    def __draw_event_list__(self, calendar):
+        number_width = daynumber_y_size[0] * self.size[1]
+        ypos = eventlist_ypos * self.size[1]
+        weather_width = 0
+        if owm_paid_subscription and general_settings["weather-info"]:
+            weather_width = weathericon_height * self.size[1]
+        pos = (number_width + eventlist_xpadding, ypos)
+        size = (self.size[0] - pos[0] - weather_width, self.size[1] - pos[1])
+        fontsize = eventlist_y_fontsize * self.size[1]
+
+        events = calendar.get_day_events(self.date)
+        rel_dates = [self.date for _ in range(len(events))]
+        event_list = SingelDayEventListDesign(
+            size, events, fontsize, event_prefix_rel_dates=rel_dates)
+        event_list.pos = pos
+        self.draw_design(event_list)
+
+    def __draw_forecast__(self, weather):
+        forecast = weather.get_forecast_in_days(
+            self.date.day - datetime.today().day)
+
+        if forecast is None:
+            return
+
+        height = int(weathericon_height * self.size[1])
+        size = (height, height)
+        ypos = weathericon_ypos * self.size[1]
+        pos = (self.size[0] - ypos - size[0], ypos)
+        icon = Image.open(wpath + weathericons[forecast.icon] + ".jpeg")
+        resized_icon = icon.resize(size, resample=Image.LANCZOS)
+        self.draw(resized_icon, pos)
+
+    def __finish_image__(self):
+        self.__draw_weekday__()
+        self.__draw_day_number__()
+
+    def __draw_weekday__(self):
+        font_size = int(weekday_fontsize * self.size[1])
+        size = (weekday_y_size[0] * self.size[1],
+                weekday_y_size[1] * self.size[1])
+        ypos = weekday_ypos * self.size[1]
+        pos = (0, ypos)
+
+        color = self.__get_day_color__()
+        week_day_name = self.date.strftime("%a")
+
+        week_day = TextDesign(size, text=week_day_name, font=font, color=color,
+                              fontsize=font_size, horizontalalignment="center", verticalalignment="top")
+        week_day.pos = pos
+        week_day.mask = False
+        self.draw_design(week_day)
+
+    def __draw_day_number__(self):
+        font_size = int(daynumber_fontsize * self.size[1])
+        ypadding = daynumber_ypadding * self.size[1]
+        size = (daynumber_y_size[0] * self.size[1],
+                daynumber_y_size[1] * self.size[1])
+        pos = (0, ypadding)
+
+        day_text = self.__get_day_text__()
+        color = self.__get_day_color__()
+
+        number = TextDesign(size, text=day_text, font=font, color=color,
+                            fontsize=font_size, horizontalalignment="center", verticalalignment="bottom")
+        number.pos = pos
+        self.draw_design(number)
+
+    def __abs_co__(self, coordinates):
+        return (int(coordinates[0] * self.size[0]), int(coordinates[1] * self.size[1]))
+
+    def __get_day_text__(self):
+        return str(self.date.day)
+
+    def __get_day_color__(self):
+        """Depending on week_starts_on"""
+        if week_starts_on == "Monday" and self.date.strftime("%w") == "0":
+            return colors["hl"]
+        elif week_starts_on == "Sunday" and self.date.strftime("%w") == "6":
+            return colors["hl"]
+        else:
+            return colors["fg"]

Calendar/DayViewPanel.py

@@ -0,0 +1,155 @@
+from PanelDesign import PanelDesign
+from datetime import datetime, timedelta, date
+from DayHeaderDesign import DayHeaderDesign
+from HourListDesign import HourListDesign
+from settings import general_settings
+from RssPostListDesign import RssPostListDesign
+from PIL import ImageDraw
+from Assets import colors
+from EventListDesign import EventListDesign
+from CryptoListDesign import CryptoListDesign
+
+
+header_size = (1, 0.2)
+hourlist_size = (1, 1 - header_size[1])
+default_shownhours_count = 12
+
+infoarea_replaced_hours = 4
+infoarea_borderline_width = 1
+infoarea_padding = 5
+
+
+class DayViewPanel (PanelDesign):
+    """Overview that focuses on the current day and
+    shows a timeline split into hours."""
+
+    def __init__(self, size):
+        super(DayViewPanel, self).__init__(size)
+        self.shownhours_count = default_shownhours_count
+        if general_settings["info-area"] not in ["", "empty"]:
+            self.shownhours_count -= infoarea_replaced_hours
+        self.__first_render__()
+
+    def __first_render__(self):
+        self.__init_header__()
+        self.__init_hourlist__()
+
+    def add_weather(self, weather):
+        self.__header__.add_weather(weather)
+
+    def add_calendar(self, calendar):
+        allday_ev, timed_ev = self.__split_events__(
+            calendar.get_today_events())
+        self.__header__.add_events(allday_ev)
+        self.__hourlist__.add_events(timed_ev)
+
+        if general_settings["info-area"] == "events":
+            self.__draw_event_list__(calendar)
+            self.__draw_infoarea_line__()
+
+    def add_rssfeed(self, rss):
+        if general_settings["info-area"] == "rss":
+            self.__draw_rss_feed__(rss)
+            self.__draw_infoarea_line__()
+
+    def add_crypto(self, crypto):
+        if general_settings["info-area"] == "crypto":
+            self.__draw_crypto_feed__(crypto)
+            self.__draw_infoarea_line__()
+
+    def __draw_infoarea_line__(self):
+        height = infoarea_replaced_hours * self.__hourlist__.row_size[1]
+        ypos = self.size[1] - height
+
+        line_start = (0, ypos)
+        line_end = (self.size[0], ypos)
+        ImageDraw.Draw(self.__image__).line(
+            [line_start, line_end], fill=colors["fg"], width=infoarea_borderline_width)
+
+    def __draw_rss_feed__(self, rss):
+        height = infoarea_replaced_hours * \
+            self.__hourlist__.row_size[1] - infoarea_padding
+        size = (self.size[0], height)
+        pos = (0, self.size[1] - size[1])
+
+        rss = RssPostListDesign(size, rss)
+        rss.pos = pos
+        self.draw_design(rss)
+
+    def __draw_crypto_feed__(self, crypto):
+        height = infoarea_replaced_hours * \
+            self.__hourlist__.row_size[1] - infoarea_padding
+        size = (self.size[0], height)
+        pos = (0, self.size[1] - size[1])
+
+        crypto = CryptoListDesign(size, crypto)
+        acutal_height = crypto.get_estimated_height()
+        crypto.pos = (pos[0], pos[1] + (height - acutal_height))
+        self.draw_design(crypto)
+
+    def __draw_event_list__(self, calendar):
+        height = infoarea_replaced_hours * \
+            self.__hourlist__.row_size[1] - infoarea_padding
+        size = (self.size[0], height)
+        pos = (0, self.size[1] - size[1])
+
+        events = EventListDesign(size, calendar.get_upcoming_events())
+        events.pos = pos
+        self.draw_design(events)
+
+    def add_tasks(self, tasks):
+        pass
+
+    def __finish_panel__(self):
+        self.draw_design(self.__header__)
+        self.draw_design(self.__hourlist__)
+
+    def __init_header__(self):
+        self.__header__ = DayHeaderDesign(
+            self.__abs_co__(header_size), date.today())
+        self.__header__.pos = (0, 0)
+
+    def __init_hourlist__(self):
+        start, end = self.__get_current_hour_range__()
+        size = self.__abs_co__(hourlist_size)
+        size = (size[0], size[1] * self.shownhours_count /
+                default_shownhours_count)
+
+        self.__hourlist__ = HourListDesign(size, start, end)
+        self.__hourlist__.pos = (0, self.__header__.size[1])
+
+    def __get_current_hour_range__(self):
+        start_hour = datetime.now().hour
+        additional_hours = self.shownhours_count - 1
+
+        if start_hour + additional_hours > 23:
+            start_hour = 23 - additional_hours
+
+        return start_hour, start_hour + additional_hours
+
+    def __abs_co__(self, coordinates):
+        return (int(coordinates[0] * self.size[0]), int(coordinates[1] * self.size[1]))
+
+    def __split_events__(self, events):
+        allday_ev = []
+        timed_ev = []
+
+        for event in events:
+            if event.allday:
+                allday_ev.append(event)
+            elif event.multiday:
+                if self.__is_today__(event.begin_datetime):
+                    timed_ev.append(event)
+                elif self.__is_today__(event.end_datetime):
+                    timed_ev.append(event)
+                else:
+                    allday_ev.append(event)
+            else:
+                timed_ev.append(event)
+        return allday_ev, timed_ev
+
+    def __is_today__(self, dt):
+        today = date.today()
+        return dt.day == today.day and \
+            dt.month == today.month and \
+            dt.year == today.year

Calendar/DebugConsole.py

@@ -0,0 +1,65 @@
+from DebugInterface import DebugInterface
+from Assets import weathericons
+from datetime import datetime
+import traceback
+
+
+class DebugConsole (DebugInterface):
+    """Defines concrete console export of debug objects"""
+
+    def print_event(self, event):
+        print("\nCalendarEvent:")
+        print("---------------------")
+        print('Begin datetime: ' + str(event.begin_datetime))
+        print('End datetime: ' + str(event.end_datetime))
+        print('Duration: ' + str(event.duration))
+        print('All day: ' + str(event.allday))
+        print('Multi-day: ' + str(event.multiday))
+        print('RRULE: ' + str(event.rrule))
+        print('Title: ' + str(event.title))
+        print('Description: ' + str(event.description))
+        print('Attendees: ' + str(event.attendees))
+        print('Highlight: ' + str(event.highlight))
+        print('Calendar name: ' + str(event.calendar_name))
+        print('Location: ' + str(event.location))
+        print('Fetch datetime: ' + str(event.fetch_datetime))
+
+    def print_forecast(self, forecast):
+        print("\nWeatherForecast:")
+        print("---------------------")
+        print('Air temperature: ' + str(forecast.air_temperature))
+        print('Air humidity: ' + str(forecast.air_humidity))
+        print('Air pressure: ' + str(forecast.air_pressure))
+        print('Rain probability: ' + str(forecast.rain_probability))
+        print('Rain amount: ' + str(forecast.rain_amount))
+        print('Snow amount: ' + str(forecast.snow_amount))
+        print('Sunrise-time: ' + str(forecast.sunrise))
+        print('Sunset time: ' + str(forecast.sunset))
+        print('Moon phase: ' + str(forecast.moon_phase))
+        print('Wind speed: ' + str(forecast.wind_speed))
+        print('Cloudiness: ' + str(forecast.clouds))
+        print('Icon code: ' + str(forecast.icon))
+        print('weather-icon name: ' + str(weathericons[forecast.icon]))
+        print('Short description: ' + str(forecast.short_description))
+        print('Detailed description: ' + str(forecast.detailed_description))
+        print('Units: ' + str(forecast.units))
+        print('Datetime: ' + str(forecast.datetime))
+        print('Location: ' + str(forecast.location))
+        print('Fetch datetime: ' + str(forecast.fetch_datetime))
+
+    def print_line(self, content):
+        if content is None:
+            return
+        print(str(content))
+
+    def print_err(self, exception, msg=""):
+        if exception is None:
+            return
+
+        content = "[ERR: "
+        content += datetime.now().strftime("")
+        content += "]\n" + str(exception)
+        content += "\n" + str(msg) + "\n"
+        traceback.print_exc()
+
+        self.print_line(str(content))

Calendar/DebugInterface.py

@@ -0,0 +1,14 @@
+class DebugInterface (object):
+    """Defines general interface for debugging operations"""
+
+    def print_event(self, event):
+        raise NotImplementedError("Functions needs to be implemented")
+
+    def print_forecast(self, forecast):
+        raise NotImplementedError("Functions needs to be implemented")
+
+    def print_line(self, content):
+        raise NotImplementedError("Functions needs to be implemented")
+
+    def print_err(self, exception, msg=""):
+        raise NotImplementedError("Functions needs to be implemented")

Calendar/DesignEntity.py

@@ -0,0 +1,61 @@
+from PIL import Image, ImageOps, ImageDraw
+from Assets import colors
+
+masking_threshold = 200
+
+
+class DesignEntity (object):
+    """General entity that can be drawn on to a panel design or
+    other design entities."""
+
+    def __init__(self, size, mask=False, invert_mask=False, color_key=False):
+        self.size = size
+        # Are dimensions >= 0?
+        if self.size[0] < 0:
+            self.size = (0, self.size[1])
+        if self.size[1] < 0:
+            self.size = (self.size[0], 0)
+        
+        self.pos = (0, 0)
+        self.mask = mask
+        self.invert_mask = invert_mask
+        self.__init_image__()
+        self.__finished_image__ = False
+        self.color_key = color_key
+
+    def __init_image__(self, color=colors["bg"]):
+        rounded_size = (int(self.size[0]), int(self.size[1]))
+        self.__image__ = Image.new('RGBA', rounded_size, color=color)
+
+    def get_image(self):
+        if self.__finished_image__ is False:
+            self.__finish_image__()
+            self.__finished_image__ = True
+        return self.__image__
+
+    def draw(self, subimage, pos, mask=False, invert_mask=False, color_key=False):
+        rounded_pos = (int(pos[0]), int(pos[1]))
+        img_mask = None
+        if mask:
+            img_mask = self.__get_mask__(
+                subimage, invert_mask=invert_mask, color_key=color_key)
+        self.__image__.paste(subimage, rounded_pos, mask=img_mask)
+
+    def draw_design(self, entity):
+        self.draw(entity.get_image(), entity.pos, entity.mask,
+                  entity.invert_mask, entity.color_key)
+
+    def draw_image(self, path, pos):
+        self.draw(Image.open(path), pos)
+
+    def __finish_image__(self):
+        pass
+
+    def __get_mask__(self, image, invert_mask, color_key):
+        mask = image.convert('L')
+        if color_key:
+            mask = mask.point(lambda p: 0 if p <
+                              masking_threshold else 255, '1').convert('L')
+        if invert_mask:
+            mask = ImageOps.invert(mask)
+        return ImageOps.invert(mask)

Calendar/Dictionary.py

@@ -0,0 +1,99 @@
+default_language = "en"
+
+'''Characters following '*' are placeholders and will be replaced by some number/text/etc.'''
+
+'''Events'''
+more_events = {
+    'en': '+ *0 more',
+    'de': '+ *0 weitere'
+}
+multiday_events = {
+    'en': 'Multi-day',
+    'de': 'Mehrtägig'
+}
+allday_events = {
+    'en': 'All-day',
+    'de': 'Ganztägig'
+}
+
+'''Weather'''
+rain_weather = {
+    'en': 'Rain',
+    'de': 'Regen'
+}
+clear_weather = {
+    'en': 'Clear',
+    'de': 'Klar'
+}
+clouds_weather = {
+    'en': 'Clouds',
+    'de': 'Wolken'
+}
+thunderstorm_weather = {
+    'en': 'Thunderstorm',
+    'de': 'Gewitter'
+}
+drizzle_weather = {
+    'en': 'Drizzle',
+    'de': 'Niesel'
+}
+snow_weather = {
+    'en': 'Snow',
+    'de': 'Schnee'
+}
+mist_weather = {
+    'en': 'Mist',
+    'de': 'Nebel'
+}
+smoke_weather = {
+    'en': 'Smoke',
+    'de': 'Rauch'
+}
+haze_weather = {
+    'en': 'Haze',
+    'de': 'Nebel'
+}
+dust_weather = {
+    'en': 'Dust',
+    'de': 'Staub'
+}
+fog_weather = {
+    'en': 'Fog',
+    'de': 'Nebel'
+}
+sand_weather = {
+    'en': 'Sand',
+    'de': 'Sand'
+}
+ash_weather = {
+    'en': 'Ash',
+    'de': 'Asche'
+}
+squall_weather = {
+    'en': 'Squall',
+    'de': 'Sturm'
+}
+tornado_weather = {
+    'en': 'Tornado',
+    'de': 'Tornado'
+}
+dictionary_collection = [
+    rain_weather,
+    clear_weather,
+    dust_weather,
+    squall_weather,
+    tornado_weather,
+    clouds_weather,
+    thunderstorm_weather,
+    smoke_weather,
+    ash_weather,
+    sand_weather,
+    fog_weather,
+    haze_weather,
+    mist_weather,
+    drizzle_weather,
+    snow_weather,
+    more_events,
+    allday_events,
+    multiday_events
+]

Calendar/DictionaryMapper.py

@@ -0,0 +1,29 @@
+from Dictionary import default_language
+from settings import language
+
+'''Takes a collection of phrases and outputs the necessary text
+according to the language and inserts parameters.'''
+
+
+def get_text(dictionary, *params):
+    text = dictionary[default_language]
+    if language in dictionary.keys():
+        text = dictionary[language]
+
+    return __insert_params__(text, params)
+
+
+def __insert_params__(text, params):
+    index = 0
+    while '*%d' % index in text and index < len(params):
+        splitted = text.split('*%d' % index)
+        text = splitted[0] + str(params[index]) + splitted[1]
+        index += 1
+    while '*' in text:
+        splitted = text.split('*%d' % index)
+        if len(splitted) > 1:
+            text = splitted[0] + splitted[1].lstrip(' ')
+        else:
+            text = splitted[0].rsplit(' ')
+        index += 1
+    return text

Calendar/DisplayAdapter.py

@@ -0,0 +1,12 @@
+class DisplayAdapter (object):
+    """Interface for CalendarDesign output channels."""
+
+    def __init__(self, width, height):
+        self.width = width
+        self.height = height
+
+    def render(self, design):
+        raise NotImplementedError("Functions needs to be implemented")
+
+    def calibrate(self):
+        raise NotImplementedError("Functions needs to be implemented")

Calendar/E-Paper.py

@@ -0,0 +1,135 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+"""
+E-Paper Software (main script) for the 3-colour and 2-Colour E-Paper display
+A full and detailed breakdown for this code can be found in the wiki.
+If you have any questions, feel free to open an issue at Github.
+
+Copyright by aceisace
+"""
+from datetime import datetime
+from time import sleep
+from Assets import path
+from LoopTimer import LoopTimer
+import locale
+from DebugConsole import DebugConsole
+from settings import datetime_encoding, language, render_to_display, render_to_file, display_colours, location, api_key, owm_paid_subscription, choosen_design, ical_urls, highlighted_ical_urls, rss_feeds, update_interval, calibrate_hours, crypto_coins, max_loop_count, run_on_hour
+from MonthOvPanel import MonthOvPanel
+from DayListPanel import DayListPanel
+from DayViewPanel import DayViewPanel
+from DayFocusListPanel import DayFocusListPanel
+from MonthViewPanel import MonthViewPanel
+from AgendaListPanel import AgendaListPanel
+from ImageFramePanel import ImageFramePanel
+import OwmForecasts
+import IcalEvents
+import RssParserPosts
+import GeckoCrypto
+
+all_locales = locale.locale_alias
+if language.lower() not in all_locales.keys():
+    raise Exception(
+        "The locale for \"%s\" is currently not supported! If you need support, please open an issue on github." % language)
+locale.setlocale(locale.LC_ALL, "%s.%s" % (
+    all_locales[language.lower()].split('.')[0], datetime_encoding))
+
+debug = DebugConsole()
+output_adapters = []
+
+if render_to_file:
+    import ImageFileAdapter
+    epd = ImageFileAdapter.ImageFileAdapter(path)
+    output_adapters.append(epd)
+
+if render_to_display:
+    if display_colours == "bwr":
+        import Epd7in5bAdapter
+        epd = Epd7in5bAdapter.Epd7in5bAdapter()
+        output_adapters.append(epd)
+    elif display_colours == "bw":
+        import Epd7in5Adapter
+        epd = Epd7in5Adapter.Epd7in5Adapter()
+        output_adapters.append(epd)
+
+available_panels = {
+    "day-list": DayListPanel,
+    "month-overview": MonthOvPanel,
+    "day-view": DayViewPanel,
+    "day-focus-list": DayFocusListPanel,
+    "agenda-list": AgendaListPanel,
+    "month-view": MonthViewPanel,
+    "image-frame": ImageFramePanel,
+}
+
+loop_timer = LoopTimer(
+    update_interval, run_on_hour=run_on_hour, max_loop_count=max_loop_count)
+
+"""Main loop starts from here"""
+
+
+def main():
+    owm = OwmForecasts.OwmForecasts(
+        location, api_key, paid_api=owm_paid_subscription)
+    events_cal = IcalEvents.IcalEvents(ical_urls, highlighted_ical_urls)
+    rss = RssParserPosts.RssParserPosts(rss_feeds)
+    crypto = GeckoCrypto.GeckoCrypto(crypto_coins)
+
+    while True:
+        loop_timer.begin_loop()
+        start_time = loop_timer.get_current()[0]
+
+        if start_time.hour in calibrate_hours and loop_timer.is_new_hour_loop():
+            debug.print_line("Calibrating outputs")
+            for output in output_adapters:
+                output.calibrate()
+
+        if choosen_design in available_panels.keys():
+            design = available_panels[choosen_design]((epd.width, epd.height))
+        else:
+            raise ImportError(
+                "choosen_design must be valid (" + choosen_design + ")")
+
+        debug.print_line("Fetching weather information from open weather map")
+        owm.reload()
+        design.add_weather(owm)
+
+        debug.print_line('Fetching events from your calendar')
+        events_cal.reload()
+        design.add_calendar(events_cal)
+
+        debug.print_line('Fetching posts from your rss-feeds')
+        rss.reload()
+        design.add_rssfeed(rss)
+
+        debug.print_line('Fetching crypto prices from coin gecko')
+        crypto.reload()
+        design.add_crypto(crypto)
+
+        debug.print_line("\nStarting to render")
+        for i, output in enumerate(output_adapters):
+            try:
+                output.render(design)
+                debug.print_line(str(i + 1) + " of " +
+                                 str(len(output_adapters)) + " rendered")
+            except BaseException as ex:
+                debug.print_err(ex, "Failed to render output " +
+                                str(i + 1) + " of " + str(len(output_adapters)))
+
+        debug.print_line("=> Finished rendering" + "\n")
+
+        loop_timer.end_loop()
+
+        if loop_timer.was_last_loop():
+            debug.print_line("Maximum loop count " +
+                             str(loop_timer.loop_count) + " reached, exiting.")
+            return
+
+        sleep_time = loop_timer.time_until_next()
+        debug.print_line("This loop took " +
+                         str(loop_timer.get_last_duration()) + " to execute.")
+        debug.print_line("Sleeping " + str(sleep_time) + " until next loop.")
+        sleep(sleep_time.total_seconds())
+
+
+if __name__ == '__main__':
+    main()