431 lines
16 KiB
Python
Executable File
431 lines
16 KiB
Python
Executable File
"""
|
|
Inkycal Calendar Module
|
|
Copyright by aceinnolab
|
|
"""
|
|
|
|
# pylint: disable=logging-fstring-interpolation
|
|
|
|
import calendar as cal
|
|
|
|
from inkycal.custom import *
|
|
from inkycal.modules.template import inkycal_module
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class Calendar(inkycal_module):
|
|
"""Calendar class
|
|
Create monthly calendar and show events from given iCalendars
|
|
"""
|
|
|
|
name = "Calendar - Show monthly calendar with events from iCalendars"
|
|
|
|
optional = {
|
|
"week_starts_on": {
|
|
"label": "When does your week start? (default=Monday)",
|
|
"options": ["Monday", "Sunday"],
|
|
"default": "Monday",
|
|
},
|
|
"show_events": {
|
|
"label": "Show parsed events? (default = True)",
|
|
"options": [True, False],
|
|
"default": True,
|
|
},
|
|
"ical_urls": {
|
|
"label": "iCalendar URL/s, separate multiple ones with a comma",
|
|
},
|
|
"ical_files": {
|
|
"label": "iCalendar filepaths, separated with a comma",
|
|
},
|
|
"date_format": {
|
|
"label": "Use an arrow-supported token for custom date formatting "
|
|
+ "see https://arrow.readthedocs.io/en/stable/#supported-tokens, e.g. D MMM",
|
|
"default": "D MMM",
|
|
},
|
|
"time_format": {
|
|
"label": "Use an arrow-supported token for custom time formatting "
|
|
+ "see https://arrow.readthedocs.io/en/stable/#supported-tokens, e.g. HH:mm",
|
|
"default": "HH:mm",
|
|
},
|
|
}
|
|
|
|
def __init__(self, config):
|
|
"""Initialize inkycal_calendar module"""
|
|
|
|
super().__init__(config)
|
|
config = config['config']
|
|
|
|
self.ical = None
|
|
self.month_events = None
|
|
self._upcoming_events = None
|
|
self._days_with_events = None
|
|
|
|
# optional parameters
|
|
self.week_start = config['week_starts_on']
|
|
self.show_events = config['show_events']
|
|
self.date_format = config["date_format"]
|
|
self.time_format = config['time_format']
|
|
self.language = config['language']
|
|
|
|
if config['ical_urls'] and isinstance(config['ical_urls'], str):
|
|
self.ical_urls = config['ical_urls'].split(',')
|
|
else:
|
|
self.ical_urls = config['ical_urls']
|
|
|
|
if config['ical_files'] and isinstance(config['ical_files'], str):
|
|
self.ical_files = config['ical_files'].split(',')
|
|
else:
|
|
self.ical_files = config['ical_files']
|
|
|
|
# additional configuration
|
|
self.timezone = get_system_tz()
|
|
self.num_font = ImageFont.truetype(
|
|
fonts['NotoSans-SemiCondensed'], size=self.fontsize
|
|
)
|
|
|
|
# give an OK message
|
|
print(f'{__name__} loaded')
|
|
|
|
@staticmethod
|
|
def flatten(values):
|
|
"""Flatten the values."""
|
|
return [x for y in values for x in y]
|
|
|
|
def generate_image(self):
|
|
"""Generate image for this module"""
|
|
|
|
# Define new image size with respect to padding
|
|
im_width = int(self.width - (2 * self.padding_left))
|
|
im_height = int(self.height - (2 * self.padding_top))
|
|
im_size = im_width, im_height
|
|
events_height = 0
|
|
|
|
logger.info(f'Image size: {im_size}')
|
|
|
|
# Create an image for black pixels and one for coloured pixels
|
|
im_black = Image.new('RGB', size=im_size, color='white')
|
|
im_colour = Image.new('RGB', size=im_size, color='white')
|
|
|
|
# Allocate space for month-names, weekdays etc.
|
|
month_name_height = int(im_height * 0.10)
|
|
text_bbox_height = self.font.getbbox("hg")
|
|
weekdays_height = int((abs(text_bbox_height[3]) + abs(text_bbox_height[1])) * 1.25)
|
|
logger.debug(f"month_name_height: {month_name_height}")
|
|
logger.debug(f"weekdays_height: {weekdays_height}")
|
|
|
|
if self.show_events:
|
|
logger.debug("Allocating space for events")
|
|
calendar_height = int(im_height * 0.6)
|
|
events_height = (
|
|
im_height - month_name_height - weekdays_height - calendar_height
|
|
)
|
|
logger.debug(f'calendar-section size: {im_width} x {calendar_height} px')
|
|
logger.debug(f'events-section size: {im_width} x {events_height} px')
|
|
else:
|
|
logger.debug("Not allocating space for events")
|
|
calendar_height = im_height - month_name_height - weekdays_height
|
|
logger.debug(f'calendar-section size: {im_width} x {calendar_height} px')
|
|
|
|
# Create a 7x6 grid and calculate icon sizes
|
|
calendar_rows, calendar_cols = 6, 7
|
|
icon_width = im_width // calendar_cols
|
|
icon_height = calendar_height // calendar_rows
|
|
logger.debug(f"icon_size: {icon_width}x{icon_height}px")
|
|
|
|
# Calculate spacings for calendar area
|
|
x_spacing_calendar = int((im_width % calendar_cols) / 2)
|
|
y_spacing_calendar = int((im_height % calendar_rows) / 2)
|
|
|
|
logger.debug(f"x_spacing_calendar: {x_spacing_calendar}")
|
|
logger.debug(f"y_spacing_calendar :{y_spacing_calendar}")
|
|
|
|
# Calculate positions for days of month
|
|
grid_start_y = month_name_height + weekdays_height + y_spacing_calendar
|
|
grid_start_x = x_spacing_calendar
|
|
|
|
grid_coordinates = [
|
|
(grid_start_x + icon_width * x, grid_start_y + icon_height * y)
|
|
for y in range(calendar_rows)
|
|
for x in range(calendar_cols)
|
|
]
|
|
|
|
weekday_pos = [
|
|
(grid_start_x + icon_width * _, month_name_height)
|
|
for _ in range(calendar_cols)
|
|
]
|
|
|
|
now = arrow.now(tz=self.timezone)
|
|
|
|
# Set week-start of calendar to specified week-start
|
|
if self.week_start == "Monday":
|
|
cal.setfirstweekday(cal.MONDAY)
|
|
week_start = now.shift(days=-now.weekday())
|
|
else:
|
|
cal.setfirstweekday(cal.SUNDAY)
|
|
week_start = now.shift(days=-now.isoweekday())
|
|
|
|
# Write the name of current month
|
|
write(
|
|
im_black,
|
|
(0, 0),
|
|
(im_width, month_name_height),
|
|
str(now.format('MMMM', locale=self.language)),
|
|
font=self.font,
|
|
autofit=True,
|
|
)
|
|
|
|
# Set up week-names in local language and add to main section
|
|
weekday_names = [
|
|
week_start.shift(days=+_).format('ddd', locale=self.language)
|
|
for _ in range(7)
|
|
]
|
|
logger.debug(f'weekday names: {weekday_names}')
|
|
|
|
for index, weekday in enumerate(weekday_pos):
|
|
write(
|
|
im_black,
|
|
weekday,
|
|
(icon_width, weekdays_height),
|
|
weekday_names[index],
|
|
font=self.font,
|
|
autofit=True,
|
|
fill_height=0.9,
|
|
)
|
|
|
|
# Create a calendar template and flatten (remove nesting)
|
|
calendar_flat = self.flatten(cal.monthcalendar(now.year, now.month))
|
|
# logger.debug(f" calendar_flat: {calendar_flat}")
|
|
|
|
# Map days of month to co-ordinates of grid -> 3: (row2_x,col3_y)
|
|
grid = {}
|
|
for i in calendar_flat:
|
|
if i != 0:
|
|
grid[i] = grid_coordinates[calendar_flat.index(i)]
|
|
# logger.debug(f"grid:{grid}")
|
|
|
|
# remove zeros from calendar since they are not required
|
|
calendar_flat = [num for num in calendar_flat if num != 0]
|
|
|
|
# ensure all numbers have the same size
|
|
fontsize_numbers = int(min(icon_width, icon_height) * 0.5)
|
|
number_font = ImageFont.truetype(self.font.path, fontsize_numbers)
|
|
|
|
# Add the numbers on the correct positions
|
|
for number in calendar_flat:
|
|
if number != int(now.day):
|
|
write(
|
|
im_black,
|
|
grid[number],
|
|
(icon_width, icon_height),
|
|
str(number),
|
|
font=number_font,
|
|
)
|
|
|
|
# Draw a red/black circle with the current day of month in white
|
|
icon = Image.new('RGBA', (icon_width, icon_height))
|
|
current_day_pos = grid[int(now.day)]
|
|
x_circle, y_circle = int(icon_width / 2), int(icon_height / 2)
|
|
radius = int(icon_width * 0.2)
|
|
ImageDraw.Draw(icon).ellipse(
|
|
(
|
|
x_circle - radius,
|
|
y_circle - radius,
|
|
x_circle + radius,
|
|
y_circle + radius,
|
|
),
|
|
fill='black',
|
|
outline=None,
|
|
)
|
|
write(
|
|
icon,
|
|
(0, 0),
|
|
(icon_width, icon_height),
|
|
str(now.day),
|
|
font=self.num_font,
|
|
fill_height=0.5,
|
|
colour='white',
|
|
)
|
|
im_colour.paste(icon, current_day_pos, icon)
|
|
|
|
# If events should be loaded and shown...
|
|
if self.show_events:
|
|
|
|
# If this month requires 5 instead of 6 rows, increase event section height
|
|
if len(cal.monthcalendar(now.year, now.month)) == 5:
|
|
events_height += icon_height
|
|
|
|
# If this month requires 4 instead of 6 rows, increase event section height
|
|
elif len(cal.monthcalendar(now.year, now.month)) == 4:
|
|
events_height += icon_height * 2
|
|
|
|
# import the ical-parser
|
|
# pylint: disable=import-outside-toplevel
|
|
from inkycal.modules.ical_parser import iCalendar
|
|
|
|
# find out how many lines can fit at max in the event section
|
|
line_spacing = 2
|
|
text_bbox_height = self.font.getbbox("hg")
|
|
line_height = text_bbox_height[3] + line_spacing
|
|
max_event_lines = events_height // (line_height + line_spacing)
|
|
|
|
# generate list of coordinates for each line
|
|
events_offset = im_height - events_height
|
|
event_lines = [
|
|
(0, events_offset + int(events_height / max_event_lines * _))
|
|
for _ in range(max_event_lines)
|
|
]
|
|
|
|
# logger.debug(f"event_lines {event_lines}")
|
|
|
|
# timeline for filtering events within this month
|
|
month_start = arrow.get(now.floor('month'))
|
|
month_end = arrow.get(now.ceil('month'))
|
|
|
|
# fetch events from given iCalendars
|
|
self.ical = iCalendar()
|
|
parser = self.ical
|
|
|
|
if self.ical_urls:
|
|
parser.load_url(self.ical_urls)
|
|
if self.ical_files:
|
|
parser.load_from_file(self.ical_files)
|
|
|
|
# Filter events for full month (even past ones) for drawing event icons
|
|
month_events = parser.get_events(month_start, month_end, self.timezone)
|
|
parser.sort()
|
|
self.month_events = month_events
|
|
|
|
# Initialize days_with_events as an empty list
|
|
days_with_events = []
|
|
|
|
# Handle multi-day events by adding all days between start and end
|
|
for event in month_events:
|
|
|
|
# Convert start and end dates to arrow objects with timezone
|
|
start = arrow.get(event['begin'].date(), tzinfo=self.timezone)
|
|
end = arrow.get(event['end'].date(), tzinfo=self.timezone)
|
|
|
|
# Use arrow's range function for generating dates
|
|
for day in arrow.Arrow.range('day', start, end):
|
|
day_num = int(day.format('D')) # get day number using arrow's format method
|
|
if day_num not in days_with_events:
|
|
days_with_events.append(day_num)
|
|
|
|
# remove duplicates (more than one event in a single day)
|
|
days_with_events = sorted(set(days_with_events))
|
|
self._days_with_events = days_with_events
|
|
|
|
# Draw a border with specified parameters around days with events
|
|
for days in days_with_events:
|
|
if days in grid:
|
|
draw_border(
|
|
im_colour,
|
|
grid[days],
|
|
(icon_width, icon_height),
|
|
radius=6,
|
|
)
|
|
|
|
# Filter upcoming events until 4 weeks in the future
|
|
parser.clear_events()
|
|
upcoming_events = parser.get_events(now, now.shift(weeks=4), self.timezone)
|
|
self._upcoming_events = upcoming_events
|
|
|
|
# delete events which won't be able to fit (more events than lines)
|
|
upcoming_events = upcoming_events[:max_event_lines]
|
|
|
|
# Check if any events were found in the given timerange
|
|
if upcoming_events:
|
|
|
|
# Find out how much space (width) the date format requires
|
|
lang = self.language
|
|
|
|
date_width = int(max((
|
|
self.font.getlength(events['begin'].format(self.date_format, locale=lang))
|
|
for events in upcoming_events)) * 1.1
|
|
)
|
|
|
|
time_width = int(max((
|
|
self.font.getlength(events['begin'].format(self.time_format, locale=lang))
|
|
for events in upcoming_events)) * 1.1
|
|
)
|
|
|
|
text_bbox_height = self.font.getbbox("hg")
|
|
line_height = text_bbox_height[3] + line_spacing
|
|
|
|
event_width_s = im_width - date_width - time_width
|
|
event_width_l = im_width - date_width
|
|
|
|
# Display upcoming events below calendar TODO: not used?
|
|
# tomorrow = now.shift(days=1).floor('day')
|
|
# in_two_days = now.shift(days=2).floor('day')
|
|
|
|
cursor = 0
|
|
for event in upcoming_events:
|
|
if cursor < len(event_lines):
|
|
event_duration = (event['end'] - event['begin']).days
|
|
if event_duration > 1:
|
|
# Format the duration using Arrow's localization
|
|
days_translation = arrow.get().shift(days=event_duration).humanize(only_distance=True,
|
|
locale=lang)
|
|
the_name = f"{event['title']} ({days_translation})"
|
|
else:
|
|
the_name = event['title']
|
|
the_date = event['begin'].format(self.date_format, locale=lang)
|
|
the_time = event['begin'].format(self.time_format, locale=lang)
|
|
# logger.debug(f"name:{the_name} date:{the_date} time:{the_time}")
|
|
|
|
if now < event['end']:
|
|
write(
|
|
im_colour,
|
|
event_lines[cursor],
|
|
(date_width, line_height),
|
|
the_date,
|
|
font=self.font,
|
|
alignment='left',
|
|
)
|
|
|
|
# Check if event is all day
|
|
if parser.all_day(event):
|
|
write(
|
|
im_black,
|
|
(date_width, event_lines[cursor][1]),
|
|
(event_width_l, line_height),
|
|
the_name,
|
|
font=self.font,
|
|
alignment='left',
|
|
)
|
|
else:
|
|
write(
|
|
im_black,
|
|
(date_width, event_lines[cursor][1]),
|
|
(time_width, line_height),
|
|
the_time,
|
|
font=self.font,
|
|
alignment='left',
|
|
)
|
|
|
|
write(
|
|
im_black,
|
|
(date_width + time_width, event_lines[cursor][1]),
|
|
(event_width_s, line_height),
|
|
the_name,
|
|
font=self.font,
|
|
alignment='left',
|
|
)
|
|
cursor += 1
|
|
else:
|
|
symbol = '- '
|
|
|
|
while self.font.getlength(symbol) < im_width * 0.9:
|
|
symbol += ' -'
|
|
write(
|
|
im_black,
|
|
event_lines[0],
|
|
(im_width, line_height),
|
|
symbol,
|
|
font=self.font,
|
|
)
|
|
|
|
# return the images ready for the display
|
|
return im_black, im_colour
|