A note-taking application is a standalone application designed for recording and searching short, ad-hoc notes. Typically they are used by people as an informal way of organizing information for their own consumption e.g. code snippets, recipes, daily journal notes.
Although there are many different designs, the focus of every note-taking application is storing and managing text notes. Common features include adding, editing, deleting notes, as well as ways to organize or search them.
Example: Apple Notes.
There are even command-line applications which attempt to solve the same issue. For example, here’s Terminal Velocity on Linux, optimized for very quick note entry, for users who are accustomed to working from a terminal.
There are four specific deliverables for this project:
- Core infrastructure
- Console application
- GUI application
- Web service
- Your source code should be stored in your team’s GitLab repository.
- You must use issues in GitLab to track your work.
- You must use a Gradle project, with the project structure provided in-class.
- You are expected to write unit tests for all of your code, and add appropriate code comments.
- You are also expected to produce some form of installer, so that a user (or TA) could install and run your application without needing to build it from source!
- We will examine your source code! You should strive for well-structured and readable code.
Your first application should be a console application that launches the notes application. You can add support for additional arguments if you wish.
Your main application is a desktop application. You are expected to implement the following standard desktop functionality:
- A top-level menu bar that lists major functions, and indicates the hotkeys for each feature (e.g. File, Edit, View menu and submenus).
- Toolbars that let the user control settings and modes that apply to the application e.g. a Bold button that can be used to embolden text, and reflects the state of selected text.
- Window resizing, so that the user can resize and reposition the application. You should save the window size and position on exit, and restore that size and position when they relaunch it.
- Minimize/mazimize buttons function as expected.
- Undo-redo support for actions in the user interface.
- Cut-copy-paste text.
In addition to the platform requirements, you should support the following features:
- Create, edit, delete a note (using both keyboard and point-click).
- Group related notes together e.g. folders or tags. Support add/delete and rename groups, and move notes between groups.
- Display a list of notes by title, and allow sorting the list by title, modified date or created date.
- Search notes, either by title or body contents, and display the matching notes.
- Rich text support for the note body, including bold, italics, underlining and changing colour of text.
- Support for bulleted lists, including the ability to apply or remove bullets from a block of selected text.
- Save local application settings (e.g. window size and position) on the local system where the application is installed.
- Note data should be stored remotely and shared across application instances.
- Your application should work equally well on Windows, Linux or macOS.
You will need to build a web service so your main data can be served remotely.
- A user should be able to launch multiple instances of the application, and have the instances load and use this remote data.
- Your application should communicate with the web service using HTTP protocol.
- Data should be saved so that if the web service is stopped and restarted, the data will persist.
The requirements above represent the minimal set of requirements for this project. Here we’ve listed some other ideas that might be interesting to implement! Pick-and-choose, or brainstorm your own.
- Image support, so that users can drag-drop images into a note, and resize them.
- Diagramming, so that the user can drag-drop and manipulate simple shapes within a note e.g. box and arrow diagrams.
- Support light and dark themes. The user should be able to set their preference in a Settings dialog and this setting should persist.
Here’s an incomplete list of similar applications. Use these to get a sense of what features you might want to consider, or some design approaches.