I just found that using the Minimal theme I was able to decorate my task into so much more than just tasks, but it posed a little problem in getting an overview of which tasks where left to be done across files. I thought about asking in the Help category, but I wanted to do some research first. This post is that research and result of this.
My starting point was that I wanted to get a list of tasks, and filter out those not started and/or incomplete. I didn’t want to see all which were either completed already or just decorated for other purposes.
My two main tools to achieve this result was a simple dataview task query, and the output from $=dv.span(dv.current().file.lists (where you could drop the file.lists part to get all information). I then made a sample file, and extended it until I found the solution. This file is shown below:
---
Tags: uniqueTag
---
Some sample tasks of the various types:
- [x] completed task
- [/] incomplete task
- [ ] not started
- [>] Migrated
- [<] Scheduled
- [-] cancelled task
- [u] It's going up
- [d] ... or down
Here are my various attempts at getting
a list of those tasks.
## All tasks
```dataview
task from #uniqueTag
```
## Uncompleted tasks?
```dataview
task from #uniqueTag
where !completed
```
Includes all the extra tasks, as well.
## text contains "k"?
```dataview
task from #uniqueTag
where !completed
and contains(text, "k")
```
No go, as it only checked the actual text of the task
## Using status
```dataview
task from #uniqueTag
where status = " " or status = "/"
```
By looking into the _All info_ shown below,
I found that the actual text between the brackets
was stored in the `status` field, and then I can
combine whichever set of these that I wanted.
# All info
`$=dv.span(dv.current().file.lists)`
The top part of this renders as:
Hopefully this post/approach could help other figure out how to manipulate a task list according to their specific needs, based on available info from dv.current() or within a DQL TASK query.
Just to re-iterate a little on this, but doing markup like the following:
- [k] (term:: DNA) – (definition:: deoxyribonucleic acid)
- [p] Task decoration is a pro concept!
Which using Minimal theme (and a little custom on inline fields), would render as:
This has at least the following benefits related to inline fields, and linkage in general:
Any inline fields within a task is contained or grouped together with fields in the same task. So in the first line the term (“DNA”) is linked together with its definition. This not the case if you just put these fields in page outside of lists/tasks
They got a simple visual marker, making them stand out just a little in the text, helping they to focus on them whether they’re term definitions, pros and cons, or other elements you’d like to focus on. In my personal vault, I use this to showcase walking trips, disc golf trips, appointments, phone calls, and what not
They’re easily customisable through CSS, so you can add your own statuses (with icons)
Since they’re tasks they present a direct backlink to their definitions, as all tasks do
(With a little extra CSS, aka pointer-events: none, you can disable the tasks status changing, whilst keeping other functionality)
(With Tasks plugin, you’re able to set up cycles of statuses which rotate within a given set. E.g. if you’ve got a workout set of statuses, you could set them up to cycle those statuses (and you can query them as that group)
Some of the statuses provided by Minimal theme are related to BuJo (Bullet Journaling), in an electronic way. So you could easily mark tasks as to do , partially done /, complete x, cancelled -, scheduled <, and migrated >. This elevates any task organisation a lot in my opinion!
IMO they’re also not as ugly as using tags to mark the task, but you can still search for them using the status="?" very easily.
I’ve been using the list item construct because it never occurred to me to use the task ones so creatively. Thanks for sharing – going to be moving to this
With this approach, do you think it would be unwise to mix-and-match with file-scoped definitions (e.g., atomic notes with yaml frontmatter)? Would the dataview queries get really intimidating?
