You will create a Markdown editor: a text editor with features that support that markup language, including syntax highlighting, headings, and bulleted lists.
Here’s a screenshot of Typora, my preferred editor.
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 can launch the markdown editor with the document indicated on the command line. For example:
Usage: mdown [filename]
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).
- Hotkeys/keyboard shortcuts for major functionality.
- 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:
- You should support basic Markdown syntax, including headings, bold, italics, and so on. This includes syntax highlighting for these elements, and hotkeys to apply formatting (e.g. CMD-B to bold selected text).
- Users should be able to open an existing markdown file (extensions .md or .markdown), close the current file, save or save-as with appropriate dialogs.
- It should be possible to have multiple markdown files open simultaneously (in different windows or different tabs).
- You should support light and dark themes, and the user should be able to set their preference in a Settings dialog. These settings should persist across sections and files.
- Provide two view modes: raw markdown syntax (as above), or formatted text. You could do this as two panes that exist side-by-side (e.g. VS Code, or MarkdownPad) or as a mode so that the user can switch between the two different views (Typora).
- Save application settings in the cloud so that they are preserved across sessions. See below.
- Your application should work equally well on Windows, Linux or macOS.
You will need to build a web service so your data can be shared across multiple systems.
- A user should be able to launch multiple instances of the application, and have the instances load and use this remote data. You should determine what data is appropriate to save in this fashion.
- 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.
- Add themes! Dark, Light, Solarized etc.
- Stylize the toolbars e.g. a fancy VS Code style, expanding toolbar.
- Support editing both in raw markdown or formatted text (similar to Typora, where you can mode-switch but edit in either mode).
- Save files in the cloud, instead of just settings. [ed. this would likely mean the ability to import files, browse, and delete from the cloud as well].
- Open multiple files in tabs instead of windows.
- Export as HTML.
- Export as PDF.