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