task.h

Go to the documentation of this file.

//Name: classes.h
//Created: 30.4.2006.
//Author: Danko Komlen

//Time saver main classes


#ifndef _CLASSES_H_
#define _CLASSES_H_

enum task_type {
        ttGENERIC=1,
        ttDOCUMENT,
        ttMEETING,
        ttDESIGN,
        ttPRESENTATION,
        ttTRAVEL,
        ttFUN,
};//task_type

enum task_status {
        tsRUNNING=1,
        tsPAUSED,
        tsNOTRUNNING,
        tsEXCEDED,
        tsCOMPLETED
};//task_status

//BEGIN Class declaration
class c_task {
        private:
                wxString name;
                task_type type;
                wxString notes;
                wxString command;

                wxDateTime started;
                int duration;
                int sec;
                int time;
                task_status status;
        public:
                bool msg_showed;        
        
                c_task(wxString name);
                c_task(wxString name, task_type type, wxString notes,wxString command, int duration);

                wxString *get_name();
                task_type get_type();
                wxString get_str_type();
                wxString *get_notes();
                int get_duration();
                wxDateTime get_started();
                task_status get_status();
                wxString get_str_status();
                wxString *get_command();
                int get_time();
        
                void set_name(wxString nam);
                void set_type(task_type typ);
                void set_notes(wxString note);
                void set_duration(int duratio);
                void set_started(wxDateTime starte);
                void set_status(task_status statu);
                void set_command(wxString comm);
                void inc_time();
                void reset();
                void save(wxTextOutputStream *text_out);
                void load(wxTextInputStream *text_in);
};//c_task

class c_session {
        private:
                
                int task_count;
                void rebuild_list();
        public:

                c_session();
                c_task *task[10];
                
                void new_task(wxString name);
                void new_task(wxString name, task_type type, wxString notes, wxString command, int duration);
                void del_task(int task_number);
                void delete_all_tasks();
                
                void save(wxTextOutputStream *text_out);
                void load(wxTextInputStream *text_in);
                int get_task_count();
        protected:
                
                
};//c_session
//END Class declaration

//BEGIN Class Members


//BEGIN c_task
 
c_task::c_task (wxString name) {
        msg_showed = false;
        set_name (name);
        set_type (ttGENERIC);
        set_notes (wxT(""));
        set_command (wxT(""));
        set_duration (10);
        time = 0;
        sec = 0;
        set_started (wxDateTime::Now());
        set_status (tsNOTRUNNING);
}//c_task cstr default

c_task::c_task(wxString name, task_type type, wxString notes, wxString command, int duration){
        msg_showed = false;
        set_name (name);
        set_type (type);
        set_notes (notes);
        set_duration (duration);
        set_command (command);
        time = 0;
        sec = 0;
        set_started (wxDateTime::Now());
        set_status (tsNOTRUNNING);
}//c_task cstr

//GET FUNCTIONS
wxString  *c_task::get_name(){
        return &name;
}//c_task::get_name

task_type c_task::get_type(){
        return type;
}//c_task::get_type

wxString *c_task::get_notes(){
        return &notes;
}//c_task::get_notes

int c_task::get_duration(){
        return duration;
}//c_task::get_duration

wxDateTime c_task::get_started(){
        return started;
}//c_task::get_started

task_status c_task::get_status(){
        return status;
}//c_task::get_status

wxString *c_task::get_command(){
        return &command;
}

wxString c_task::get_str_type() {
        switch (type) {
        case (ttGENERIC): return (_T("Generic")); break;
        case (ttDOCUMENT): return (_T("Document")); break;
        case (ttMEETING): return (_T("Meeting")); break;
        case (ttDESIGN): return (_T("Design")); break;
        case (ttPRESENTATION): return (_T("Presentation")); break;
        case (ttTRAVEL): return (_T("Travel")); break;
        case (ttFUN): return (_T("Fun")); break;
        }
}//c_task::get_str_type()

wxString c_task::get_str_status() {
        switch (status) {

        case (tsRUNNING): return (_T("running")); break;
        case (tsPAUSED): return (_T("paused")); break;
        case (tsNOTRUNNING): return (_T("not running")); break;
        case (tsEXCEDED): return (_T("exceded")); break;
        case (tsCOMPLETED): return (_T("completed")); break;
        
        }
}//c_task::get_str_status()

int c_task::get_time() {
        return time * 60 + sec;
}//get_time
//SET FUNCTIONS
void c_task::set_name(wxString nam){
        name = nam;
}//c_task::set_name

void c_task::set_type(task_type typ){
        type = typ;
}//c_task::set_type

void c_task::set_notes(wxString note){
        notes = note; 
}//c_task::set_notes

void c_task::set_duration(int duratio){
        duration = duratio;
}//c_task::set_duration

void c_task::set_started(wxDateTime starte){
        started = starte;
}//c_task::set_started

void c_task::set_status(task_status statu){
        status = statu;
}//c_task::set_status

void c_task::set_command(wxString comm){
        command = comm;
}//c_task::set_command

void c_task::inc_time(){
        
        ++sec;
        if (sec >= 60) {++time;sec =0;}
        if (time >= duration) {set_status(tsEXCEDED);}
}//inc_time

void c_task::reset(){
        time = 0;
        sec = 0;
        msg_showed = false;
}//reset

void c_task::save(wxTextOutputStream *text_out){


        *text_out << name<<endl;
        *text_out << (int) type << endl;
        *text_out << notes<<endl;
        *text_out << command<<endl;
        *text_out << started.Format()<<endl;
        *text_out << duration<<endl;
        *text_out << sec<<endl;
        *text_out << time<<endl;
        *text_out << (int) status<<endl;


}//save

void c_task::load(wxTextInputStream *text_in){
int a;
wxString date_time;
        name = text_in->ReadString();
        *text_in >> a;
        type = (task_type) a;
        notes = text_in->ReadString();
        command = text_in->ReadString();
        date_time = text_in->ReadString();
        started.ParseFormat(date_time);
        *text_in >> duration;
        *text_in >> sec;
        *text_in >> time;
        *text_in >> a;
        status = (task_status) a;

}//open
//END c_task0

//BEGIN c_session
c_session::c_session() {
        task_count =0;
}//c_session cstr
void c_session::new_task (wxString name){
++task_count;
task[task_count] = new c_task(name);
        
}//c_session::new_task

void c_session::new_task (wxString name, task_type type, wxString notes, wxString command, int duration){
        ++task_count;
        task[task_count] = new c_task(name, type,notes,command,duration);
        
}//c_session::new_task

int c_session::get_task_count() {
        return task_count;
}//get_task_count

void c_session::rebuild_list() {

        for (int i=1;i<=task_count;++i){
                if (task[i] == NULL) {
                        for (int j=i;j<task_count;++j){
                                task[j] = task[j+1];
                        }//for
                        task[task_count] == NULL;
                        --task_count;
                }//if
        }//for
}//rebuild_list

void c_session::del_task(int task_number){
        task[task_number] = NULL;
        //task[task_number] = task[task_count];
rebuild_list();
}//del_task

void c_session::delete_all_tasks(){
for (int i=1;i<=task_count;++i) {
        delete task[i];
}//for

}//delete_all_tasks
void c_session::save(wxTextOutputStream *text_out) {
*text_out << task_count<<endl;
        for (int i=1;i<=task_count;++i) {
                task[i]->save(text_out);
        }//for
}//save
void c_session::load(wxTextInputStream *text_in){
delete_all_tasks();
*text_in >> task_count;
        for (int i=1;i<=task_count;++i) {
                task[i] = new c_task(_T(""));
                task[i]->load(text_in);
        }//for
}//open

//END Class Members
#endif //_CLASSES_H_ 

---