Giter VIP home page Giter VIP logo

taskplanner's Introduction

taskplanner

task planning tool

GitHub version Build status

screenshot1

A tool that lets you organize tasks in lanes and keeps track of time spent in tasks. The tasks are yours. No account, no login, no cloud, no internet.

Features

  • Kanban-style board that lets you move tasks between user-definable lanes
  • Create tasks with short descriptive text
  • Add tasks to other tasks to create sub-tasks
  • Add links to local files or URLs to websites to tasks
  • Track time spent with a task
  • Generate weekly time-sheet reports
  • Add properties such as due date, priority, estimated duration to tasks
  • Automatically sort taks based on property values
  • Customizable user interface via CSS
  • plugin-based support for saving/loading different file formats
  • plugin-based support for generating reports
  • everything is kept 100% offline. noCloud™-technology

Requirements

  • Qt 5 (built using Qt 5.9.8, might work with older versions)
  • IDE with CMake-Support (big thanks to ballessay for porting the whole thing to CMake)
  • C++11 compliant compiler

CSS documentation

The look of the application can be changed via stylesheet. If there's a file called "stylesheet.css" in the application executable directory, the application will load it at startup.

If a stylesheet from any other location should be used, it can be loaded via "Tools->Options->Stylesheet…". Once selected, the new stylesheet is loaded and its path is stored in the application settings from where it will be reloaded automatically on the next restart.

Example

Shown below are only custom classes and named objects. Available css properties and styling of any other Qt classes can be looked up in the official Qt documentation here.

MainWindow {
  /* the application main window */
}

MainWindow #frame {
  /* the central widget of the main window, without 
     toolbar, statusbar, menu */
}

WindowTitleMenuBar {
  /* the window title bar, containing menus, title, 
     maximize, minimize and close buttons */
}

OverlayWidget {
  /* the overlay class used to show 'popup' dialogs
     such as the report view or the about dialog */
}

OverlayWidget > #pClose {
  /* the close button of the overlay. QPushButton. */  
}

#ReportDialog #report {
  /* the OverlayWidget showing the report */
}

#AboutDialog {
  /* the OverlayWidget showing app information */
}

#AboutDialog #pContents {
  /* centered content of the about dialog */
}

#AboutDialog #pAppIcon {
  /* the application icon in the about dialog */
}

#AboutDialog #pAppName {
  /* the application name in the about dialog */
}

#AboutDialog #pCopyright {
  /* the copyright notice in the about dialog */
}

#pInsertTask {
  /* the OverlayWidget that is showin when inserting a new task */
}

#pInsertTask TaskWidget {
  /* the task widget preview shown in the "insert task" dialog */
}

#pInsertTask #pOk{
  /* the ok QPushButton in the "insert task" dialog */
}

#pInsertTask #pCancel {
  /* the cancel QPushButton in the "insert task" dialog */
}

DecoratedLabel {
  /* a label class with two custom properties to finetune
     text rendering. */
  /* property to determine whether text should show a dropshadow */
  qproperty-drawShadow: false; 
  /* property to determine whether text should show an outline */
  qproperty-drawOutline: false;
}

EditableLabel {
  /* any label that is editable via double-click.
     Inherits DecoratedLabel. */
}

GroupWidget {
  /* the lane in which task widgets are kept */
}

GroupWidget > #pTitle {
  /* the title of a group widget. EditableLabel. */
}

GroupWidget > #pAddTask {
  /* the + button that adds a new task to the group. */
}

GroupWidget > #pSortTasks {
  /* the "sort" button that adds a new task to the group. */
}

TaskWidget,
TaskWidget[expanded=true],
TaskWidget[expanded=false] {
  /* the task widget class */
}

TaskWidget #pShadow {
  /* the application main window */
}

TaskWidget #pFrame {
  /* a frame around the content of a task widget that can 
     be used to display a drop shadow or border effect */
}

TaskWidget #pTitle {
  /* the title of a task widget. EditableLabel. */
}

TaskWidget #pLinks {
  /* the area that displays links stuck to a task widget. QFrame. */
}

TaskWidget #pDescription {
  /* the label that holds the description of a task. EditableLabel. */
}

TaskWidget #pShowDetails {
  /* the "expand/collapse" button of a task widget. QPushButton. */
}

TaskWidget #pStartStop {
  /* the "start/stop time tracking" button of a task widget. QPushButton. */
}

TaskWidget #pProperties {
  /* a QFrame around all the properties of a task widget. */
}

TaskWidget #pDynamicProperties {
  /* a QFrame that contains links, description and a separator.
     Child of #pProperties. */
}

TaskWidget #pSeparator {
  /* a horizontal line that separates description from links */
}

TaskWidget #pPropertyFrame {
  /* a QFrame containing label and value of a property. */
}

TaskWidget #[property_name]_label {
  /* the label area of a property */
}

TaskWidget #[property_name]_value {
  /* the display area of the value of a property */
}

TaskWidgetOverlay,
TaskWidgetOverlay[autoPriority="10"]{
  /* the overlay of a task widget. 
     can be used to mark a task widget based on its autoPriority.
     autoPriority values range from 0 to 10
  */
  /* TaskWidgetOverlay has the custom property "background" 
     that can be used to change the background color.
     Any other css properties should work too, but 
     if the background-property (below) is used, the app
     smoothly blends colors into each other */
  qproperty-background: rgba(255, 255, 255, 0);
}

LinkWidget,
LinkWidget[isFile=true],
LinkWidget[isFile=false] {
  /* a widget used to display a link. Inherits QFrame. */
}

LinkWidget #pIcon {
  /* the icon used to symbolize a link. If the link points
     to an accessible file, its icon will be displayed.
     If the link is not a file, #pIcon can be used to display
     a custom "link" icon.
  */
}

ToolBarInfoDisplay {
  /* an area in the toolbar that displays various information. */
}

TaskListWidget {
  /* the list of tasks within a group widget or the list of sub-tasks
     within a task widget. Inherits QFrame. */
}

taskplanner's People

Contributors

schoebey avatar ballessay avatar

Watchers

 avatar  avatar

taskplanner's Issues

performance: when loading a file, create task widgets of subtasks on-demand

If a task is collapsed, its subtasks don't need to be created upon loading the file. Instead, some sort of proxy could be inserted that gets replaced by the correct widget as soon as its parent is expanded.

This would be especially beneficial when loading large documents with hundreds/thousands of hierarchically organized tasks.

date/time entry

date and time entries are inconsistent:

  • when entering a due date "at 17:00", it is rejected.
  • When entering "2019-08-12 17:00", it is accepted and displayed as "at 17:00".

Any values that are generated for display have to be accepted as valid input.

search doesn't update properly

when searching for a term, its results aren't updated if tasks are edited/added/a delete undone.

When certain actions are performed, the search controller needs to be notified in order to be able to refresh its search results.

  • text change in task
  • new task
  • undo on deleted/modified task

memleak in tasks with favicons

if a task has an attached url whose favicon gets displayed, memory consumption grows unbounded. Removing the task gets rid of the excess memory (which suggests its not a leak per se) and stabilizes memory consumption.

show images in tasks

if the user pastes a link to an image, show a preview to that image in the task.
Optionally, if the complete image data is pasted, embed the image in the task and save it in the file.

checkable items within a task

a task might consist of several steps, but instead of creating subtasks, add checkboxes to visualize their state.

scrollbar on windows looks ugly

default windows style scrollbar should be replaced by a transient (mac-style) scrollbar that disappears when not in use. If too much hassle, a narrower, more style-conforming scrollbar would be nice.

Search: flags

  • case sensitivity
  • match whole words only
  • regular expression

show time tracked for a certain task

add the option to show time fragments that have already been recorded for a certain task.

e.g. via context menu show -> tracked time -> overlay

add a 'statistics' submenu entry

just for fun:
in the ? -> statistics or ? -> about menus
show statistics like

  • how many tasks are there?
  • what's the task with the deepest nesting (and how deep/how many children)?
  • what's the oldest task and how old is it?

add tags

  • let the user define a set of tags (with optional color for each tag)
  • show the tags i.e. in the toolbar
  • let the user drag&drop tags to tasks
  • when creating report sheets, show tags there as well

this serves as a different approach to categorizing tasks than to simply add them as sub tasks to "category super tasks".
When organizing tasks in super tasks, sorting becomes more or less obsolete since the most pressing tasks don't necessarily show up at the very top of the list.

changing the search term takes forever in large documents

searching for a string within a document with several thousand (sometimes deeply) nested tasks taskes forever.

The reason for this is that any tasks that match the search term that haven't been visualized yet are being created on-demand.
When typing a new search term, the first character entered will match with almost every task in existence, resulting in the creation of its widget.

This should be addressed by only highlighting search terms in existing widgets and only creating the non-existing ones whenever the search-cursor "jumps" to such a task.

UnitTests

libtaskmanager should be unit tested

infinite wait in search

there's a potential infinite-loop when preparing to highlight all matches.
while trying to get to the first parent widget of a task that has been created, the parent task isn't being updated, resulting in an infinite loop:

while (nullptr == pTaskWidget)
{
  vWidgetsToReconstruct.push_front(id);
  id = pTask->parentTask();

  if (-1 == id) { break; }
  pTaskWidget = m_pWidgetManager->taskWidget(id);
  }

should be

while (nullptr == pTaskWidget)
{
  vWidgetsToReconstruct.push_front(id);
  id = pTask->parentTask();
  pTask = m_pTaskManager->task(id);

  if (-1 == id) { break; }
  pTaskWidget = m_pWidgetManager->taskWidget(id);
}

show booked time in tooltip

when hovering over a task, display a tooltip that shows time spent with that task.

multiple views could be available:

  • cumulative time spent
  • time spent per day
  • all logged time fragments

time tracking keeps intervals open

Sometimes tasks that are being tracked aren't properly finalized when switching to another task, leaving them with a start time but no stop time.
This results in the task having a wrong time delta. Usually, the broken entry is immediately followed by a 'correct' one that has both start and stop time set correctly.

create task_manager library

the task_manager functionality has to be separated into a library in order to successfully create plugins that access task_manager functions

qt.svg missing

No rule to make target '../../taskplanner/application/resources/qt.svg', needed by 'qrc_resource.cpp'. Stop.

Log time with task subsequently

It should be possible to - while time tracking of another task is running - log time with a different task.

Example:

  • Task T1 is being tracked.
  • Task T0 is not being tracked, the user has done some work but forgot to enable tracking
  • Using a menu entry, it should be possible to enter start/stop time for that task
  • The system should automatically insert new stop markers for the task that was being tracked at the beginning of the new time segment
  • The system should automatically insert a new start marker for the task that was being tracked at the end of the new time segment
T1: |-------------------------------------------------|
->
T0:               |----|
T1: |-------------|    |------------------------------|

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.