To-Do List Application

Submitted in partial fulfillment of the requirements of the

Second Year of Engineering in Computer Engineering

By
Chavan Om Surendra
Roll No. 06

Gurav Aryush Sanjay Roll

No.19

Gouda Rudrapratap Arun

Roll No.18

Parkar Kirtish Ajit

Roll No.74

Ansari Arif Ashik Ali

Roll No.01

Guide: Prof.
M .. Mohite

DEPARTMENT OF COMPUTER ENGINEERING

KONKAN GYANPEETH COLLEGE OF ENGINEERING

UNIVERSITY OF MUMBAI
(2023-2024)
 CERTIFICATE

This is to certify the project entitled “Advanced To-Do List” is a bonafide work of
“Chavan Om Surendra (06), Gurav Aryush Sanjay (19), Gouda Rudrapratap Arun (18),
Parkar Kirtish Ajit (74), Ansari Arif Ashik Ali (01)” submitted to be University of
Mumbai in partial fulfillment of the requirement for the award of the “S.E.” in “Computer
Engineering”.

(Prof. M.Mohite)
Guide

(Prof. S. M. Patil) (Dr. V. J. Pillewan)

Head of Department Principal
 KONKAN GYANPEETH COLLEGE OF ENGINEERING, KARJAT

(Affiliated to University of Mumbai, Approved by A.I.C.T.E., New Delhi.)

Konkan Gyanpeeth Shaikshanik Sankul, Vengaon Road, Dahivali, Karjat, Dist.-

Raigad-410201. (M.S.)

Department of Computer Engineering

Project Report Approval

This is project report entitled “Advanced To-Do List” by work of Chavan Om

Surendra (06), Gurav Aryush Sanjay (19), Gouda Rudrapratap Arun (18), Parkar Kirtish
Ajit (74), Ansari Arif Ashik Ali (01) is approved for the full completion of S.E. of
Department of Computer Engineering.

Examiners

1. .........................................

2. .........................................

Date :

Place:
 DECLARATION

We declare that this written submission represents our ideas in our own words and
where other ideas or words have been included, we have adequately excited and
referenced the original sources. We also declare that We have adhered to all principles of
academic honesty and integrity and have not misrepresented or fabricated or falsified any
idea/data/fact/source in our submission. We understand that any violation of the above
will be cause for disciplinary action by the Institute and can also evoke penal action from
the sources which have thus not been properly cited or from whom proper permission has
not been taken when needed.

Ansari Arif Ashik Ali

Chavan Om Surendra (06)

Gurav Aryush Sanjay (19)

Gouda Rudrapratap Arun (18)

Parkar Kirtish Ajit (74)

 INDEX

Name of Contents Page No.

Abstract i
List of Figures ii

1. Introduction 1
1.1 Introduction to Motivation 2
1.2 Problem Statement 3
1.3 Objectives 4
1.4 Scope

2.Review of literature 6
2.1 Review Papers

3. Requirement Analysis 9
3.1 Software Requirements
3.2 Hardware Requirements

4. Design and Planning 11

4.1 Flow Chart 12
4.2 UML Diagram 12
4.3 Data Flow Diagram 13

5. Implementation 14

6. Conclusion 20

7.References 22
 ABSTRACT

The project titled “Web-Based Messenger Using Python with Socket Programming” presents
the development of a scalable, real-time messaging platform designed for seamless
communication among users within a local network or across the internet. The system is
capable of supporting up to 300 concurrent users, making it a suitable solution for
environments such as educational institutions, corporate offices, or other small to medium-
sized networks that require an efficient and reliable messaging tool.
At its core, the platform follows a client-server architecture, where the server is responsible for
handling multiple client connections simultaneously. The server ensures the real-time
exchange of messages between users by maintaining continuous, active connections and
ensuring the reliable delivery of messages using socket programming. The system utilizes
TCP/IP protocols to guarantee that messages are transmitted accurately and in the correct
order, ensuring that the user experience is smooth and uninterrupted.
One of the key features of this system is its ability to function on both local and hosted
environments, allowing users to connect via IP addresses and port numbers, thus providing
flexibility in terms of accessibility. The server can be hosted to allow remote access, enabling
users to communicate even when they are not on the same local network. The application’s design
is focused on simplicity and ease of use, providing users with a platform that delivers instant
messaging with minimal setup.
This project demonstrates the practical application of network communication principles,
highlighting key concepts such as socket-based messaging, multi-threaded server management,
and the scalability of real-time communication systems. The architecture and design of the
system ensure that it can efficiently handle multiple users and scale as needed, making it suitable
for diverse environments where communication is essential.
Future versions of the platform could include additional features such as file sharing, group
chats, message history, and improved user management. These enhancements would make the
system more versatile, providing users with a comprehensive tool for collaboration and
communication. Overall, this project serves as both an educational tool for understanding
network programming and a practical solution for internal messaging needs, with the potential
to evolve into a fully-featured communication platform.
CHAPTER NO 1

INTRODUCTION

1
 Introduction

1.1 Introduction to Motivation

In today's fast-paced world, effective time management and task tracking are essential for both personal
and professional success. Many people rely on to-do list applications to stay organized. However, many
of the existing tools are either too simplistic or overly complex. The motivation behind this project is:
 To create a simple, user-friendly yet feature-rich task manager.
 To help users categorize, prioritize, and organize tasks efficiently.
 To enable offline access without requiring internet or third-party logins.

With the growing demands of modern life, students and professionals are often overwhelmed by tasks
and deadlines. This pressure leads to:
 Missed deadlines due to disorganized schedules.
 Reduced productivity and poor prioritization.
 Increased stress and decreased task visibility.
The motivation behind this project stems from the need to build a personalized productivity assistant
that doesn’t depend on internet access, subscriptions, or mobile applications. This tool is intended to:
 Empower users to take control of their daily responsibilities.
 Reduce reliance on commercial task managers.
 Deliver a simple, distraction-free experience for planning and execution.

2
1.2 Problem Statement

Most available to-do list managers either lack essential task management features or require internet
connectivity and logins. There is a need for an advanced, locally run desktop application that
provides:
 Easy task creation and editing.
 Categorization, prioritization, and sorting.
 Task completion toggles and due date support.
 Data persistence through saving/loading JSON files.

Despite a variety of tools available for task management, users still face challenges:
 Inability to modify UI and workflow according to personal needs.
 No integration of common features like filters, sorting, color cues in a single, simple
application.
 Poor support for task classification by type or urgency.
 Lack of flexibility in exporting or importing data.
Hence, the problem this project addresses is the absence of a customizable, standalone task manager
that operates efficiently without external dependencies or unnecessary complexity.

3
1.3 Objectives

The objectives of this project are:

 To develop a Tkinter-based desktop to-do list application.
 To support categorizing and prioritizing tasks.
 To provide a visually intuitive GUI for task management.
 To allow saving and loading tasks from a file for persistence.
 To include features like edit, delete, filter, sort, and search.

The primary objectives of this project are:

 To create a feature-rich yet lightweight desktop application using Python and Tkinter.
 To allow users to:
o Input tasks with categories, priority levels, and due dates.
o Modify, search, and filter tasks on the fly.
o Visualize task urgency through color-coded rows.
 To support persistent task storage through easy file operations.
 To simplify task workflows for students, freelancers, and office workers alike.
Secondary objectives include:
 Implementing UI enhancements (dropdowns, menus, dialogs).
 Facilitating keyboard shortcuts and accessibility.
 Ensuring code modularity and maintainability for future extension.

4
1.4 Scope

This project covers:

 ✔ A GUI application using Python's Tkinter module.
 ✔ Features like:
o Task creation with category, priority, and due date.
o Task filtering (e.g., by category, completion status).
o Task sorting (alphabetical, by date added, priority, due date).
o JSON file save/load functionality.
o Real-time search bar and right-click context menus.
 ✔ User interaction through mouse clicks, entry fields, and menus.
 ✔ Offline functionality without external dependencies or internet.
This project does not cover:
 Cloud syncing or multi-device support.
 Notification or reminders.
 AI-based task suggestions.

Functional Scope:
The system will:
 Provide CRUD (Create, Read, Update, Delete) functionalities for tasks.
 Display tasks in a tabular (Treeview) format.
 Enable sorting and filtering with real-time responsiveness.
 Include built-in categories and priorities for better organization.
Technical Scope:
 Developed using Python 3.x and Tkinter GUI toolkit.
 Uses JSON for file-based persistence (save/load).
 Does not require any external Python packages or databases.
Limitations:
 No synchronization with external calendars or mobile apps.
 No background reminder/notification service.
 Does not support team or shared task management.
Despite limitations, this scope ensures a strong focus on core features essential for personal
productivity.

5
 CHAPTER NO.2

Review of Literature

6
1.1 Review Papers

To design a functional and effective to-do list management application, it's important to understand
the academic and technological background of productivity tools, task management
methodologies, and human-computer interaction (HCI). Several research papers, articles, and
surveys have explored the design principles, cognitive science, and user behavior associated
with task management tools. Below is a review of relevant literature:

1. “Task Management and Scheduling Applications: A Cognitive Perspective”

Authors: M. Shamsi, A. Patel
Journal: International Journal of Cognitive Computing, 2018
Key Points:
 Explores the relationship between cognitive load and interface design in task management.
 Suggests minimalistic, color-coded interfaces to reduce cognitive strain.
 Recommends features such as due dates and priority tags as essential in productivity apps.
Relevance: Our project adopts these insights by incorporating clean UI, color-coded priorities,
and deadline inputs.

2. “User Experience in Personal Productivity Apps”

Authors: L. Benassi, H. Lee
Journal: ACM Transactions on HCI, 2019
Key Points:
 Highlights the importance of responsiveness, personalization, and feedback in to-do list apps.
 Emphasizes the need for immediate task status feedback and customizable categories.
 Recommends incorporating filters, sorters, and interactive lists.
Relevance: This system uses Tkinter’s real-time UI updating, task filtering, and interactive
components like Treeview and context menus.

3. “A Comparative Study on Digital Task Management Tools”

Authors: K. Nair, S. Joshi
Published In: International Journal of Productivity Engineering, 2020
Key Points:
 Compared Trello, Microsoft To-Do, Google Tasks, and Notion based on usability,
7
 performance, and features.
 Concluded that users preferred apps with:
o Offline functionality
o No registration
o Lightweight interfaces
Relevance: This app is completely offline, requires no login, and is lightweight due to the use of
Python and Tkinter.

8
 CHAPTER NO.3

Requirement Analysis

9
3.1 Software Requirements

To develop and run the Advanced To-Do List Manager, the following software components are
essential:
Python Environment
 Python Version: 3.6 or higher
 Tkinter: Included with standard Python installations
 Additional Libraries:
o tkcalendar for date selection widgets
o Pillow for image handling (if incorporating icons or images)
o json for data serialization and storage
o Development Tools
 Integrated Development Environment (IDE):
o Visual Studio Code
o PyCharm Community Edition
o IDLE (comes with Python)

3.2 Hardware Requirements

The application is lightweight and doesn't demand high-end hardware. However, for optimal
performance, the following specifications are recommended:
Minimum Requirements
 Processor: Dual-core CPU (2.0 GHz or higher)
 RAM: 4 GB
 Storage: 50 MB of free disk space
 Display: 1024x768 resolution

Recommended Requirements
 Processor: Quad-core CPU (3.0 GHz or higher)
 RAM: 8 GB
 Storage: 100 MB of free disk space
 Display: 1920x1080 resolution
 These specifications ensure smooth operation, especially when handling a large number of
tasks or utilizing advanced features like sorting and filtering.

10
 CHAPTER NO.4

Design and Planning

11
4.1Flow Chart

4.2UML Diagram

12
4.3 Data Flow Diagram

13
CHAPTER NO.5

Implementation

14
Program

import tkinter as tk
from tkinter import messagebox, ttk, filedialog
import json
from datetime import datetime
import os

class EnhancedTodoListApp:
def __init__(self, root):
self.root = root
self.root.title("Advanced To-Do List Manager")
self.root.geometry("700x600")
self.root.minsize(600, 500)

# Set theme colors

self.colors = {
"primary": "#3498db",
"secondary": "#2ecc71",
"accent": "#9b59b6",
"warning": "#e74c3c",
"background": "#f5f5f5",
"text": "#2c3e50",
"completed_bg": "#e8f8e8",
"high_priority": "#ffdddd",
"medium_priority": "#ffffdd",
"low_priority": "#ddffdd"
}

self.root.config(bg=self.colors["background"])

# Data structures
self.tasks = []
self.current_filter = "All"
self.current_sort = "Date Added"
self.categories = ["Work", "Personal", "Shopping", "Health", "Other"]

# Create main frame

self.main_frame = tk.Frame(root, bg=self.colors["background"])
self.main_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)

# Create header
self.create_header()

# Create task input section

self.create_task_input()

# Create task list section

15
 self.create_task_list()

# Create bottom buttons

self.create_bottom_buttons()

# Add a status bar

self.status_bar = tk.Label(root, text="Ready", bd=1, relief=tk.SUNKEN, anchor=tk.W)
self.status_bar.pack(side=tk.BOTTOM, fill=tk.X)

# Check for saved tasks

self.load_tasks()

def create_header(self):
header_frame = tk.Frame(self.main_frame, bg=self.colors["primary"], padx=10, pady=5)
header_frame.pack(fill=tk.X)

title_label = tk.Label(header_frame, text="Advanced To-Do List Manager",

font=('Helvetica', 16, 'bold'), bg=self.colors["primary"], fg="white")
title_label.pack(side=tk.LEFT, pady=5)

date_label = tk.Label(header_frame, text=datetime.now().strftime("%A, %d %B %Y"),

font=('Helvetica', 12), bg=self.colors["primary"], fg="white")
date_label.pack(side=tk.RIGHT, pady=5)

def create_task_input(self):
input_frame = tk.Frame(self.main_frame, bg=self.colors["background"], pady=10)
input_frame.pack(fill=tk.X)

# Task entry
tk.Label(input_frame, text="Task:", bg=self.colors["background"]).grid(row=0, column=0,
padx=5, pady=5, sticky=tk.W)
self.task_entry = tk.Entry(input_frame, width=30, font=('Helvetica', 12))
self.task_entry.grid(row=0, column=1, padx=5, pady=5, sticky=tk.W+tk.E)
self.task_entry.bind('<Return>', lambda event: self.add_task())

# Category dropdown
tk.Label(input_frame, text="Category:", bg=self.colors["background"]).grid(row=0, column=2,
padx=5, pady=5, sticky=tk.W)
self.category_var = tk.StringVar(value=self.categories[0])
self.category_combo = ttk.Combobox(input_frame, textvariable=self.category_var,
values=self.categories, width=10)
self.category_combo.grid(row=0, column=3, padx=5, pady=5)

# Priority dropdown
tk.Label(input_frame, text="Priority:", bg=self.colors["background"]).grid(row=1, column=0,
padx=5, pady=5, sticky=tk.W)
self.priority_var = tk.StringVar(value="Medium")
priority_combo = ttk.Combobox(input_frame, textvariable=self.priority_var, values=["High",
"Medium", "Low"], width=10)
priority_combo.grid(row=1, column=1, padx=5, pady=5, sticky=tk.W)
16
 # Due date entry
tk.Label(input_frame, text="Due date:", bg=self.colors["background"]).grid(row=1, column=2,
padx=5, pady=5, sticky=tk.W)
self.due_date_entry = tk.Entry(input_frame, width=12, font=('Helvetica', 10))
self.due_date_entry.insert(0, "DD/MM/YYYY")
self.due_date_entry.grid(row=1, column=3, padx=5, pady=5)
self.due_date_entry.bind("<FocusIn>", lambda event: self.due_date_entry.delete(0, tk.END) if
self.due_date_entry.get() == "DD/MM/YYYY" else None)
self.due_date_entry.bind("<FocusOut>", lambda event: self.due_date_entry.insert(0,
"DD/MM/YYYY") if not self.due_date_entry.get() else None)

# Add button
add_button = tk.Button(input_frame, text="Add Task", command=self.add_task,
bg=self.colors["secondary"], fg="white", font=('Helvetica', 10, 'bold'),
padx=10, pady=5, relief=tk.GROOVE)
add_button.grid(row=0, column=4, rowspan=2, padx=10, pady=5)

input_frame.grid_columnconfigure(1, weight=1)

def create_task_list(self):
# Create a frame for the task list
list_frame = tk.Frame(self.main_frame, bg=self.colors["background"])
list_frame.pack(fill=tk.BOTH, expand=True, pady=10)

# Create filter and sort frame

filter_frame = tk.Frame(list_frame, bg=self.colors["background"])
filter_frame.pack(fill=tk.X, pady=5)

# Filter
tk.Label(filter_frame, text="Filter:", bg=self.colors["background"]).pack(side=tk.LEFT,
padx=5)
self.filter_var = tk.StringVar(value="All")
filter_options = ["All", "Active", "Completed"] + self.categories
filter_combo = ttk.Combobox(filter_frame, textvariable=self.filter_var, values=filter_options,
width=10)
filter_combo.pack(side=tk.LEFT, padx=5)
filter_combo.bind("<<ComboboxSelected>>", lambda event: self.apply_filter())

# Sort
tk.Label(filter_frame, text="Sort by:", bg=self.colors["background"]).pack(side=tk.LEFT,
padx=5)
self.sort_var = tk.StringVar(value="Date Added")
sort_combo = ttk.Combobox(filter_frame, textvariable=self.sort_var,
values=["Date Added", "Priority", "Due Date", "Alphabetical"], width=12)
sort_combo.pack(side=tk.LEFT, padx=5)
sort_combo.bind("<<ComboboxSelected>>", lambda event: self.sort_tasks())

# Search
tk.Label(filter_frame, text="Search:", bg=self.colors["background"]).pack(side=tk.LEFT,
17
 # View menu
view_menu = tk.Menu(menu_bar, tearoff=0)
menu_bar.add_cascade(label="View", menu=view_menu)
view_menu.add_command(label="Show All Tasks", command=lambda: [app.filter_var.set("All"),
app.apply_filter()])
view_menu.add_command(label="Show Active Tasks", command=lambda:
[app.filter_var.set("Active"), app.apply_filter()])
view_menu.add_command(label="Show Completed Tasks", command=lambda:
[app.filter_var.set("Completed"), app.apply_filter()])

# Help menu
help_menu = tk.Menu(menu_bar, tearoff=0)
menu_bar.add_cascade(label="Help", menu=help_menu)
help_menu.add_command(label="About", command=lambda: messagebox.showinfo("About",
"Advanced To-Do List Manager\nVersion 1.0"))
help_menu.add_command(label="Help", command=lambda: messagebox.showinfo("Help",
"Double-click a task to toggle its completion status.\n"
"Right-click a task for additional options.\n"
"Use the filters and sorting options to organize your tasks.\n"
"Save your tasks to a file to keep them for later."
))

if __name__ == "__main__":
root = tk.Tk()
app = EnhancedTodoListApp(root)
create_menu(root, app)
root.mainloop()

18
Output

19
CHAPTER NO.6

Coclusion

20
Conclusion

The To-Do App project, developed using Python, demonstrates how a simple yet effective desktop
application can be created to manage day-to-day tasks. The project primarily uses the Tkinter library
to design the Graphical User Interface (GUI), enabling users to interact with the app in a more
intuitive and visual manner.
Throughout the development process, several core Python programming concepts were implemented,
including functions, loops, conditional statements, file handling, and event-driven programming. The
app allows users to add new tasks, delete existing ones, and mark tasks as complete, thereby
supporting basic task management functionality.
In addition, the project highlights the importance of data persistence by enabling the app to save tasks
between sessions using text files (or optionally, a lightweight database like SQLite). This ensures that
users do not lose their data upon exiting the application.
From a user interface standpoint, attention was given to the layout design, button styling, and
responsive interaction, making the application both practical and user-friendly. This project also
opens doors to future enhancements, such as:
 Adding due dates and priority levels for tasks
 Integrating notifications or reminders
 Syncing tasks with cloud storage or mobile devices
 Adding animations or sound effects for better UX
 Implementing voice commands for hands-free task management
In conclusion, this project not only fulfills its objective of creating a functional to-do list application
but also serves as a valuable learning experience in Python programming, GUI design, and real-world
problem-solving. It lays a solid foundation for building more complex and feature-rich applications in
the future.

21
CHAPTER NO.7

References

22
References

General Python and Tkinter Usage

1. Tkinter GUI Programming by Example

Bhaskar Chaudhary. Packt Publishing (2019).
A practical guide to building GUIs with Tkinter, including widget management, layout
design, and event handling.

2. Python GUI Programming with Tkinter

Alan D. Moore. Packt Publishing (2018).
Offers insights into building responsive and functional desktop applications with Python’s
standard GUI library.

3. Tkinter Official Documentation

Python Software Foundation.
https://docs.python.org/3/library/tkinter.html
Core documentation for Tkinter widgets, event binding, and layout management.

Data Handling & Persistence

4. Python JSON Module Documentation

https://docs.python.org/3/library/json.html
Reference for using JSON for saving and loading task data in your app.

5. Working with Files in Python

W3Schools.
https://www.w3schools.com/python/python_file_handling.asp
Covers file handling essentials used in your save_tasks() and load_tasks() functions.

23