├── .gitignore
├── HaikuToDo
    ├── Start.cpp
    ├── Application.hpp
    ├── Application.cpp
    ├── TaskSync.hpp
    ├── Task.hpp
    ├── TaskManager.hpp
    ├── TaskFS.hpp
    ├── TaskSQL.hpp
    ├── Internet.hpp
    ├── MainWindow.hpp
    ├── TaskGoogle.hpp
    ├── CreateCategory.hpp
    ├── Category.hpp
    ├── AddTask.hpp
    ├── TaskSQL.cpp
    ├── TaskFS.cpp
    ├── MainWindow.cpp
    └── TaskGoogle.cpp
├── README.md
├── CMakeLists.txt
├── LICENSE
└── Doxyfile


/.gitignore:
--------------------------------------------------------------------------------
1 | build
2 | docs
3 | 


--------------------------------------------------------------------------------
/HaikuToDo/Start.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * HaikuToDo
 3 |  *
 4 |  */
 5 | 
 6 | #include "Application.hpp"
 7 | 
 8 | int
 9 | main(int argc, char** argv)
10 | {
11 | 	HaikuToDo app;
12 | 	app.Run();
13 | 	return 0;
14 | }
15 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | HaikuToDo
 2 | =========
 3 | HaikuToDo is a TODO application for Haiku written for GCI 2014
 4 | 
 5 | ## Compiling
 6 | 
 7 | ```sh
 8 | mkdir build && cd build
 9 | cmake .. && make
10 | ./HaikuToDo
11 | ```
12 | 


--------------------------------------------------------------------------------
/HaikuToDo/Application.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef APPLICATION_HPP
 2 | #define APPLICATION_HPP
 3 | 
 4 | #include <Application.h>
 5 | 
 6 | #include "MainWindow.hpp"
 7 | 
 8 | class HaikuToDo : public BApplication{
 9 | 	public:
10 | 				HaikuToDo();
11 | 				~HaikuToDo();
12 | 		void	ReadyToRun();	
13 | };
14 | 
15 | #endif
16 | 


--------------------------------------------------------------------------------
/HaikuToDo/Application.cpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * HaikuToDo
 3 |  *
 4 |  */
 5 | 
 6 | #include "Application.hpp"
 7 | 
 8 | HaikuToDo::HaikuToDo() : BApplication("application/haiku-todo")
 9 | {
10 | 	
11 | }
12 | 
13 | HaikuToDo::~HaikuToDo()
14 | {
15 | 	
16 | }
17 | 
18 | void
19 | HaikuToDo::ReadyToRun()
20 | {
21 | 	MainWindow* window=new MainWindow();
22 | 	window->Show();
23 | }
24 | 


--------------------------------------------------------------------------------
/HaikuToDo/TaskSync.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef TASKSYNC_HPP
 2 | #define TASKSYNC_HPP
 3 | 
 4 | #include <InterfaceKit.h>
 5 | #include <vector>
 6 | #include "Category.hpp"
 7 | #include "Task.hpp"
 8 | 
 9 | const int32 SYNC_CATEGORIES=800;
10 | 
11 | class TaskSync {
12 | 	public:
13 | 							TaskSync(){};
14 | 							~TaskSync(){};
15 | 		virtual bool		Login(){};
16 | 		virtual void		NextStep(BString code){};
17 | 		virtual	BList*		GetCategories(){};
18 | 		virtual	BList*		GetTasks(Category* category){};
19 | };
20 | 
21 | #endif
22 | 


--------------------------------------------------------------------------------
/HaikuToDo/Task.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef TASK_HPP
 2 | #define TASK_HPP
 3 | 
 4 | #include <InterfaceKit.h>
 5 | 
 6 | class Task : public BStringItem{
 7 | 	public:
 8 | 		Task(const char* text,const char* details,const char* category,bool completed) : 
 9 | 			BStringItem(text),
10 | 			details(details),
11 | 			category(category),
12 | 			completed(completed)
13 | 		{
14 | 			
15 | 		}
16 | 		
17 | 		const char*
18 | 		GetDetails()
19 | 		{
20 | 			return details.String();
21 | 		}
22 | 		
23 | 		bool
24 | 		GetCompleted()
25 | 		{
26 | 			return completed;
27 | 		}
28 | 		
29 | 		const char*
30 | 		GetCategory()
31 | 		{
32 | 			return category.String();
33 | 		}
34 | 	private:
35 | 		BString details;
36 | 		bool completed;
37 | 		BString category;
38 | };
39 | 
40 | #endif
41 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | PROJECT(HaikuToDo C CXX)
 2 | CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 3 | 
 4 | SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
 5 | 
 6 | OPTION(BUILD_SQLITE "Build with SQLite" OFF)
 7 | 
 8 | SET(HAIKU_TO_DO_SRC
 9 | "HaikuToDo/Application.cpp"
10 | "HaikuToDo/MainWindow.cpp"
11 | "HaikuToDo/Start.cpp"
12 | "HaikuToDo/TaskGoogle.cpp"
13 | )
14 | IF(BUILD_SQLITE)
15 | 	LIST(APPEND HAIKU_TO_DO_SRC "HaikuToDo/TaskSQL.cpp")
16 | ELSE()
17 | 	LIST(APPEND HAIKU_TO_DO_SRC "HaikuToDo/TaskFS.cpp")
18 | ENDIF()
19 | 
20 | ADD_EXECUTABLE(HaikuToDo ${HAIKU_TO_DO_SRC})
21 | TARGET_LINK_LIBRARIES(HaikuToDo be root tracker netapi network shared)
22 | IF(BUILD_SQLITE)
23 | 	ADD_DEFINITIONS(-DBUILD_SQLITE)
24 | 	TARGET_LINK_LIBRARIES(HaikuToDo sqlite3)
25 | ENDIF()
26 | 


--------------------------------------------------------------------------------
/HaikuToDo/TaskManager.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef TASK_MANAGER_HPP
 2 | #define TASK_MANAGER_HPP
 3 | 
 4 | class TaskManager{
 5 | 	public:
 6 | 		TaskManager()
 7 | 		{
 8 | 			
 9 | 		}
10 | 		~TaskManager()
11 | 		{
12 | 			
13 | 		}
14 | 		virtual void	LoadTasks(const char* category, BListView* tasks){}
15 | 		virtual	void	LoadCategories(BListView* categories){}
16 | 		virtual bool 	AddCategory(const char* name, const char* filename){}
17 | 		virtual	bool	AddTask(const char* title, const char* description,
18 | 							const char* category){}
19 | 		virtual	bool	RemoveTask(const char* title, const char* description,
20 | 							const char* category){}
21 | 		virtual bool	MarkAsComplete(const char* title, const char* description,
22 | 							const char* category){}
23 | };
24 | 
25 | #endif
26 | 
27 | 
28 | 


--------------------------------------------------------------------------------
/HaikuToDo/TaskFS.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef TASKFS_HPP
 2 | #define TASKFS_HPP
 3 | 
 4 | #include <FindDirectory.h>
 5 | #include <StorageKit.h>
 6 | #include <InterfaceKit.h>
 7 | #include "TaskManager.hpp"
 8 | 
 9 | class TaskFS : public TaskManager{
10 | 	public:
11 | 				TaskFS();
12 | 				~TaskFS();
13 | 		void	LoadTasks(const char* category,BListView* tasks);
14 | 		void	LoadCategories(BListView* categories);
15 | 		bool	AddCategory(const char* name, const char* filename);
16 | 		bool	AddTask(const char* title, const char* description, const char* category);
17 | 		bool	RemoveTask(const char* title, const char* description, const char* category);
18 | 		bool	MarkAsComplete(const char* title, const char* description, const char* category);
19 | 	private:
20 | 		BAlert* error;
21 | 		BString categories;
22 | 		BString tasks;
23 | 		int volume;
24 | };
25 | 
26 | #endif
27 | 


--------------------------------------------------------------------------------
/HaikuToDo/TaskSQL.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef TASKSQL_HPP
 2 | #define TASKSQL_HPP
 3 | 
 4 | #include <FindDirectory.h>
 5 | #include <StorageKit.h>
 6 | #include <InterfaceKit.h>
 7 | #include <sqlite3.h>
 8 | #include <iostream>
 9 | #include <cstdlib>
10 | #include "TaskManager.hpp"
11 | 
12 | 
13 | 	
14 | 
15 | class TaskSQL : public TaskManager{
16 | 	public:
17 | 					TaskSQL();
18 | 					~TaskSQL();
19 | 			void	LoadTasks(const char* category,BListView* tasks);
20 | 			void	LoadCategories(BListView* categories);
21 | 			bool	AddCategory(const char* name, const char* filename);
22 | 			bool	AddTask(const char* title, const char* description, const char* category);
23 | 			bool	RemoveTask(const char* title, const char* description, const char* category);
24 | 			bool	MarkAsComplete(const char* title, const char* description, const char* category);
25 | 	private:
26 | 		sqlite3* 	db;
27 | 		BAlert*		error;
28 | };
29 | #endif
30 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014-2015 Adrián Arroyo Calle
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/HaikuToDo/Internet.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef INTERNET_HPP
 2 | #define INTERNET_HPP
 3 | 
 4 | #include <NetworkKit.h>
 5 | #include <UrlRequest.h>
 6 | #include <UrlSynchronousRequest.h>
 7 | #include <UrlProtocolRoster.h>
 8 | #include <HttpHeaders.h>
 9 | #include <HttpRequest.h>
10 | #include <private/shared/Json.h>
11 | 
12 | class SynchronousListener: public BUrlProtocolListener
13 | {
14 |  public:
15 |  virtual ~SynchronousListener() {};
16 |  void DataReceived(BUrlRequest*, const char* data, off_t position,
17 |  ssize_t size) {
18 |  result.WriteAt(position, data, size);
19 |  }
20 |  BMallocIO result;
21 | };
22 | 
23 | class HaikuHTTP {
24 | 	public:
25 | 		static BString GET(BString urlString,BHttpForm* form = NULL)
26 | 		{
27 | 			BUrl url(urlString);
28 | 			SynchronousListener listener;
29 | 			BHttpRequest req(url,true,"HTTP",&listener);
30 | 			if(form != NULL)
31 | 			{
32 | 				req.AdoptPostFields(form);
33 | 			}
34 | 			req.Run();
35 | 			while(req.IsRunning()) snooze(100);
36 | 			
37 | 			size_t bufsize = listener.result.BufferLength();
38 | 			char* buf = (char*)malloc(bufsize);
39 | 			memcpy(buf, listener.result.Buffer(), bufsize);	
40 | 			BString response(buf);
41 | 			
42 | 			return response;
43 | 		}
44 | };
45 | 
46 | #endif
47 | 


--------------------------------------------------------------------------------
/HaikuToDo/MainWindow.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef MAIN_WINDOW_HPP
 2 | #define MAIN_WINDOW_HPP
 3 | 
 4 | #include <Window.h>
 5 | #include <InterfaceKit.h>
 6 | #include <Application.h>
 7 | #include <SupportDefs.h>
 8 | #include <Layout.h>
 9 | #include <LayoutItem.h>
10 | 
11 | #include "TaskGoogle.hpp"
12 | 
13 | #ifdef BUILD_SQLITE
14 | #include "TaskSQL.hpp"
15 | #else
16 | #include "TaskFS.hpp"
17 | #endif
18 | 
19 | class MainWindow : public BWindow{
20 | 	public:
21 | 						MainWindow();
22 | 						~MainWindow();
23 | 	private:
24 | 		bool 			QuitRequested();
25 | 		void			MessageReceived(BMessage* msg);
26 | 		BView* 			tasks;
27 | 		BView* 			taskdetail;
28 | 		BListView*		categories;
29 | 		BListView* 		tasklist;
30 | 		BStringView*	taskTitle;
31 | 		BTextView*	 	taskDescription;
32 | 		BCheckBox* 		taskCompleted;
33 | 		BButton* 		taskEdit;
34 | 		BButton*		taskAdd;
35 | 		BButton*		taskRemove;
36 | 		BPicture*		taskImage;
37 | 		BButton*		googleTasks;
38 | 		TaskManager*	manager;
39 | 		TaskSync*		sync;
40 | 		
41 | };
42 | 
43 | const uint32 ITEM_SELECTED=1;
44 | const uint32 COMPLETED_TASK=2;
45 | const uint32 TASK_ADD=3;
46 | const uint32 TASK_REMOVE=4;
47 | const uint32 RELOAD=5;
48 | const uint32 CHANGE_CATEGORY=6;
49 | const uint32 RELOAD_CATEGORIES=7;
50 | const uint32 LOGIN_GTASKS=950;
51 | 
52 | #endif
53 | 


--------------------------------------------------------------------------------
/HaikuToDo/TaskGoogle.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef TASKGOOGLE_HPP
 2 | #define TASKGOOGLE_HPP
 3 | 
 4 | #include "TaskSync.hpp"
 5 | #include <InterfaceKit.h>
 6 | #include "MainWindow.hpp"
 7 | #include <iostream>
 8 | #include <vector>
 9 | #include "Category.hpp"
10 | #include "Task.hpp"
11 | 
12 | #define CLIENT_SECRET "WyyNzE2JO-HUQqL5RG2VYzz2"
13 | #define CLIENT_ID "318709342848-0h9712v3kbpcv1r7oc8krdrfu22ohlld.apps.googleusercontent.com"
14 | #define REDIRECT_URI "urn:ietf:wg:oauth:2.0:oob"
15 | 
16 | class TaskGoogle : public TaskSync{
17 | 	public:
18 | 									TaskGoogle();
19 | 									~TaskGoogle();
20 | 		status_t					LoadToken();
21 | 		bool						Login();
22 | 		void						Sync();
23 | 		void						NextStep(BString code);
24 | 		BList*						GetCategories();
25 | 		BList*						GetTasks(Category* category);
26 | 	private:
27 | 		BString token;
28 | 		BString refresh_token;
29 | 		BList* categories;
30 | 		BList* tasks;
31 | };
32 | 
33 | const int32 LOGIN_CODE=700;
34 | 
35 | class LoginDialog : public BWindow{
36 | 	public:
37 | 		LoginDialog(TaskSync* auth) : BWindow(BRect(100,100,300,300),"Login code",B_MODAL_WINDOW,0)
38 | 			, auth(auth)
39 | 		{
40 | 			BView* main=new BView(Bounds(),NULL,B_FOLLOW_ALL_SIDES,B_WILL_DRAW);
41 | 			main->SetViewColor(220,220,220);
42 | 
43 | 			code=new BTextControl(BRect(10,10,200,100),"Code","Code: ","",NULL);
44 | 			main->AddChild(code);
45 | 
46 | 			login=new BButton(BRect(10,110,200,200),NULL,"Login",new BMessage(LOGIN_CODE));
47 | 			main->AddChild(login);
48 | 
49 | 			AddChild(main);
50 | 		}
51 | 		~LoginDialog()
52 | 		{
53 | 
54 | 		}
55 | 	private:
56 | 		void
57 | 		MessageReceived(BMessage* msg)
58 | 		{
59 | 			switch(msg->what)
60 | 			{
61 | 				case LOGIN_CODE:
62 | 				{
63 | 					BString code(code->Text());
64 | 					std::cout << "Google Code is " << code << std::endl;
65 | 					auth->NextStep(code);
66 | 					Quit();
67 | 					break;
68 | 				}
69 | 				/*case CANCEL:
70 | 				{
71 | 					Quit();
72 | 				}*/
73 | 				default:
74 | 					BWindow::MessageReceived(msg);
75 | 			}
76 | 		}
77 | 		BTextControl* code;
78 | 		BButton* login;
79 | 		TaskSync* auth;
80 | };
81 | 
82 | #endif
83 | 


--------------------------------------------------------------------------------
/HaikuToDo/CreateCategory.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef CREATE_CATEGORY_HPP
 2 | #define CREATE_CATEGORY_HPP
 3 | 
 4 | #include "AddTask.hpp"
 5 | 
 6 | const int32 ICON_SELECTED=600;
 7 | 
 8 | class CreateCategory : public BWindow{
 9 | 	public:
10 | 		CreateCategory(TaskManager* manager) : BWindow(BRect(100,100,300,300),"Create category"
11 | 			,B_MODAL_WINDOW,0), manager(manager)
12 | 		{
13 | 			BView* main=new BView(Bounds(),"Main",B_FOLLOW_ALL_SIDES,B_WILL_DRAW);
14 | 			BGroupLayout* layout=new BGroupLayout(B_VERTICAL);
15 | 			main->SetViewColor(220,220,220);
16 | 			main->SetLayout(layout);
17 | 			
18 | 			name=new BTextControl(NULL,"Name:","",NULL);
19 | 			layout->AddView(name);
20 | 			
21 | 			selectfile=new BButton(NULL,"Select icon",new BMessage(SELECT_ICON));
22 | 			layout->AddView(selectfile);
23 | 			
24 | 			save=new BButton(NULL,"Save",new BMessage(SAVE_CATEGORY));
25 | 			layout->AddView(save);
26 | 			
27 | 			cancel=new BButton(NULL,"Cancel",new BMessage(CANCEL));
28 | 			layout->AddView(cancel);
29 | 			
30 | 			AddChild(main);
31 | 		}
32 | 		~CreateCategory()
33 | 		{
34 | 			
35 | 		}
36 | 	private:
37 | 		void
38 | 		MessageReceived(BMessage* msg)
39 | 		{
40 | 			switch(msg->what)
41 | 			{
42 | 				case SELECT_ICON:
43 | 				{
44 | 					BFilePanel* panel=new BFilePanel(B_OPEN_PANEL,
45 | 						new BMessenger(this),NULL,B_FILE_NODE,false,
46 | 						new BMessage(ICON_SELECTED),NULL,true);
47 | 					panel->Show();
48 | 					break;
49 | 				}
50 | 				case ICON_SELECTED:
51 | 				{
52 | 					if(msg->HasRef("refs"))
53 | 					{
54 | 						entry_ref ref;
55 | 						if(msg->FindRef("refs",0,&ref) == B_OK)
56 | 						{
57 | 							BEntry entry(&ref,true);
58 | 							BPath path;
59 | 							entry.GetPath(&path);
60 | 							filename=BString(path.Path());
61 | 							selectfile->SetLabel(filename);
62 | 						}
63 | 					}
64 | 					break;
65 | 				}
66 | 				case SAVE_CATEGORY:
67 | 				{
68 | 					manager->AddCategory(name->Text(),filename.String());
69 | 					int32 count=be_app->CountWindows();
70 | 					for(int32 i=0;i<count;i++)
71 | 					{
72 | 						be_app->WindowAt(i)->PostMessage(new BMessage(RELOAD_CATEGORIES));
73 | 					}
74 | 				}
75 | 				case CANCEL:
76 | 				{
77 | 					Quit();
78 | 				}
79 | 			}
80 | 		}
81 | 		
82 | 		BTextControl* 	name;
83 | 		BButton*		selectfile;
84 | 		BButton*		save;
85 | 		BButton*		cancel;
86 | 		BString 		filename;
87 | 		TaskManager*	manager;
88 | };
89 | 
90 | #endif
91 | 


--------------------------------------------------------------------------------
/HaikuToDo/Category.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef CATEGORY_HPP
 2 | #define CATEGORY_HPP
 3 | 
 4 | #include <InterfaceKit.h>
 5 | #include <ControlLook.h>
 6 | #include <IconUtils.h>
 7 | #include <vector>
 8 | 
 9 | class Category : public BListItem{
10 | 	public:
11 | 		Category(const char* name, const char* filepath, const char* idcat=BString("NULL")) :
12 | 		 name(name), id(idcat)
13 | 		{
14 | 			icon=new BBitmap(BRect(0,0,15,15),B_RGBA32);
15 | 			if(strcmp(filepath,"MIME_DATABASE")!=0)
16 | 			{
17 | 				BFile iconPath(filepath,B_READ_ONLY);
18 | 				if(iconPath.InitCheck() != B_OK)
19 | 					return;
20 | 				off_t file_size=0;
21 | 				iconPath.GetSize(&file_size);
22 | 				std::cout << "Get size: " << file_size << std::endl;
23 | 				//void* buffer=malloc(file_size*sizeof(char)+10);
24 | 				char buffer[file_size+1024];
25 | 				iconPath.Read(buffer,file_size);
26 | 				if(BIconUtils::GetVectorIcon((uint8*)buffer,sizeof(buffer),icon)!=B_OK)
27 | 				{
28 | 					std::cerr << "Error while loading vector icon " << std::endl;
29 | 				}
30 | 				//free(buffer);
31 | 				std::cout << "Readed vector icon" << std::endl;
32 | 			}else{
33 | 				BNode iconPath("/boot/system/data/mime_db/text/plain");
34 | 				BIconUtils::GetVectorIcon(&iconPath,"META:ICON",icon);
35 | 			}
36 | 		}
37 | 		
38 | 		~Category()
39 | 		{
40 | 			
41 | 		}
42 | 		
43 | 		const char*
44 | 		GetName()
45 | 		{
46 | 			return name.String();
47 | 		}
48 | 		
49 | 		const char*
50 | 		GetID()
51 | 		{
52 | 			return id.String();
53 | 		}
54 | 	private:
55 | 		void DrawItem(BView* owner, BRect frame, bool complete)
56 | 		{
57 | 			float iconSize=icon->Bounds().Width();
58 | 			//float iconSize=frame.bottom;
59 | 			if(IsSelected() || complete)
60 | 			{
61 | 				rgb_color color;
62 | 				if(IsSelected())
63 | 				{
64 | 					color=ui_color(B_LIST_SELECTED_BACKGROUND_COLOR);
65 | 				}else{
66 | 					color=owner->ViewColor();
67 | 				}
68 | 				owner->SetHighColor(color);
69 | 				owner->FillRect(frame);
70 | 			}
71 | 			owner->MovePenTo(frame.left+iconSize+8,frame.bottom-2);
72 | 			owner->SetHighColor(ui_color(B_LIST_ITEM_TEXT_COLOR));
73 | 			owner->DrawString(name);
74 | 			
75 | 
76 | 			
77 | 			BRect iconFrame(frame.left-be_control_look->DefaultLabelSpacing(),
78 | 					frame.top,
79 | 					frame.left + iconSize -1 + be_control_look->DefaultLabelSpacing(),
80 | 					frame.top + iconSize -1
81 | 			);
82 | 			owner->SetDrawingMode(B_OP_OVER);
83 | 			owner->DrawBitmap(icon,iconFrame);
84 | 			owner->SetDrawingMode(B_OP_COPY);
85 | 			
86 | 		}
87 | 		BString name;
88 | 		BBitmap* icon;
89 | 		BString id;
90 | 	
91 | };
92 | 
93 | #endif
94 | 


--------------------------------------------------------------------------------
/HaikuToDo/AddTask.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef ADDTASK_HPP
  2 | #define ADDTASK_HPP
  3 | 
  4 | const int32 SAVE_TASK=10;
  5 | const int32 CANCEL=200;
  6 | const int32 CREATE_CATEGORY=300;
  7 | const int32 SAVE_CATEGORY=400;
  8 | const int32 SELECT_ICON=500;
  9 | 
 10 | #include <InterfaceKit.h>
 11 | #include <Layout.h>
 12 | #include <LayoutItem.h>
 13 | #include <LayoutBuilder.h>
 14 | #ifdef BUILD_SQLITE
 15 | #include "TaskSQL.hpp"
 16 | #else
 17 | #include "TaskFS.hpp"
 18 | #endif
 19 | #include "MainWindow.hpp"
 20 | #include "CreateCategory.hpp"
 21 | #include "Category.hpp"
 22 | 
 23 | 
 24 | 
 25 | class AddTask : public BWindow{
 26 | 	public:
 27 | 		AddTask(TaskManager* manager) : BWindow(BRect(100,100,450,500),
 28 | 			"Add a task",B_MODAL_WINDOW,B_NOT_MINIMIZABLE| B_NOT_RESIZABLE),
 29 | 			manager(manager)
 30 | 		{
 31 | 			BView* main=new BView(Bounds(),"Main view",B_FOLLOW_ALL_SIDES,B_WILL_DRAW);
 32 | 			main->SetViewColor(220,220,220);
 33 | 			
 34 | 			BGridLayout* layout=new BGridLayout();
 35 | 			main->SetLayout(layout);
 36 | 			
 37 | 			title=new BTextControl("Title","Title: ","",NULL);
 38 | 			layout->AddView(title,0,0,8,1);
 39 | 			
 40 | 			description=new BTextView("Description");
 41 | 			BScrollView* scroll=new BScrollView("Description scroll",description,0,false,true);
 42 | 			layout->AddView(scroll,0,1,8,3);
 43 | 			
 44 | 			categories=new BListView("Categories",B_SINGLE_SELECTION_LIST);
 45 | 			manager->LoadCategories(categories);
 46 | 			BScrollView* scrollCategories=new BScrollView(NULL,categories,0,false,true);
 47 | 			layout->AddView(scrollCategories,0,4,8,2);
 48 | 			
 49 | 			save=new BButton(NULL,"Save task",new BMessage(SAVE_TASK));
 50 | 			layout->AddView(save,0,6,4,1);
 51 | 			
 52 | 			cancel=new BButton(NULL,"Cancel",new BMessage(CANCEL));
 53 | 			layout->AddView(cancel,4,6,2,1);
 54 | 			
 55 | 			createCategory=new BButton(NULL,"Create category",new BMessage(CREATE_CATEGORY));
 56 | 			layout->AddView(createCategory,6,6,2,1);
 57 | 			
 58 | 			layout->SetInsets(10.0f,10.0f,10.0f,10.0f);
 59 | 			
 60 | 			
 61 | 			AddChild(main);
 62 | 		}
 63 | 		~AddTask()
 64 | 		{
 65 | 			
 66 | 		}
 67 | 	private:
 68 | 		void
 69 | 		MessageReceived(BMessage* msg)
 70 | 		{
 71 | 			switch(msg->what)
 72 | 			{
 73 | 				case SAVE_TASK:
 74 | 				{
 75 | 					BString category("ALL");
 76 | 					int32 selection=categories->CurrentSelection();
 77 | 					if(selection>=0)
 78 | 					{
 79 | 						Category* cat=dynamic_cast<Category*>(categories->ItemAt(selection));
 80 | 						category=cat->GetName();
 81 | 					}
 82 | 					bool rc=manager->AddTask(title->Text(),description->Text(),category);
 83 | 					if(!rc)
 84 | 					{
 85 | 						BAlert* error=new BAlert("SAVING ERROR",
 86 | 							"Oops, we can't save that in database",
 87 | 							"OK",NULL,NULL,B_WIDTH_AS_USUAL, B_OFFSET_SPACING,
 88 | 							 B_STOP_ALERT);
 89 | 						error->Go();
 90 | 					}
 91 | 					//SEND RELOAD MESSAGE
 92 | 					int32 count=be_app->CountWindows();
 93 | 					for(int32 i=0;i<count;i++)
 94 | 					{
 95 | 						be_app->WindowAt(i)->PostMessage(new BMessage(RELOAD));
 96 | 					}
 97 | 				}
 98 | 				case CANCEL:
 99 | 				{
100 | 					Quit();
101 | 				}
102 | 				case CREATE_CATEGORY:
103 | 				{
104 | 					CreateCategory* create=new CreateCategory(manager);
105 | 					create->Show();
106 | 					PostMessage(new BMessage(RELOAD));
107 | 				}
108 | 				case RELOAD_CATEGORIES:
109 | 				{
110 | 					categories->MakeEmpty();
111 | 					manager->LoadCategories(categories);
112 | 				}
113 | 				default:
114 | 					BWindow::MessageReceived(msg);
115 | 			}
116 | 		}
117 | 		BTextControl*	title;
118 | 		BTextView*		description;
119 | 		BButton*		save;
120 | 		BButton*		cancel;
121 | 		BListView*		categories;
122 | 		BButton*		createCategory;
123 | 		TaskManager*	manager;
124 | };
125 | 
126 | #endif
127 | 


--------------------------------------------------------------------------------
/HaikuToDo/TaskSQL.cpp:
--------------------------------------------------------------------------------
  1 | #include "TaskSQL.hpp"
  2 | #include <InterfaceKit.h>
  3 | #include "Task.hpp"
  4 | #include "Category.hpp"
  5 | 
  6 | TaskSQL::TaskSQL()
  7 | {
  8 | 	const char* init_sentence=""
  9 | 	"CREATE TABLE IF NOT EXISTS HaikuToDo("
 10 | 	"TITLE TEXT UNIQUE,"
 11 | 	"DESCRIPTION TEXT,"
 12 | 	"CATEGORY TEXT,"
 13 | 	"FINISHED INTEGER);";
 14 | 	const char* init_sentence2=""
 15 | 	"CREATE TABLE IF NOT EXISTS Categories("
 16 | 	"NAME TEXT,"
 17 | 	"PICTURE TEXT);";
 18 | 	int result;
 19 | 	BPath path;
 20 | 	error=new BAlert("SQLITE ERROR",
 21 | 		"There was a SQLite error, an elf might touched the code!",
 22 | 		"OK", NULL, NULL,
 23 | 		B_WIDTH_AS_USUAL, B_OFFSET_SPACING, B_STOP_ALERT
 24 | 	);
 25 | 	if(find_directory(B_USER_SETTINGS_DIRECTORY,&path)==B_OK)
 26 | 	{
 27 | 		path.Append("HaikuToDo.db");
 28 | 		std::cout << "Path is " << path.Path() << std::endl;
 29 | 		result=sqlite3_open(path.Path(),&db);
 30 | 		if(result!=SQLITE_OK)
 31 | 		{
 32 | 			error->Go();
 33 | 			exit(2);
 34 | 		}
 35 | 		result=sqlite3_exec(db,init_sentence,0,0,0);
 36 | 		if(result!=SQLITE_OK)
 37 | 		{
 38 | 			error->Go();
 39 | 			exit(2);
 40 | 		}
 41 | 		result=sqlite3_exec(db,init_sentence2,0,0,0);
 42 | 		if(result!=SQLITE_OK)
 43 | 		{
 44 | 			error->Go();
 45 | 			exit(2);
 46 | 		}
 47 | 	}else{
 48 | 		error->Go();
 49 | 		exit(2);
 50 | 	}
 51 | }
 52 | 
 53 | TaskSQL::~TaskSQL()
 54 | {
 55 | 	sqlite3_close(db);
 56 | }
 57 | 
 58 | void
 59 | TaskSQL::LoadTasks(const char* category,BListView* tasks)
 60 | {
 61 | 	BString load_tasks("SELECT * FROM HaikuToDo");
 62 | 	if(strcmp("ALL",category)==0)
 63 | 	{
 64 | 		load_tasks.Append(";");
 65 | 	}else{
 66 | 		load_tasks.Append(" WHERE CATEGORY=\"");
 67 | 		load_tasks.Append(category);
 68 | 		load_tasks.Append("\";");
 69 | 	}
 70 | 	sqlite3_stmt* next;
 71 | 	if(sqlite3_prepare(db,load_tasks.String(),strlen(load_tasks.String()),&next,0)==SQLITE_OK)
 72 | 	{
 73 | 		while(sqlite3_step(next)==SQLITE_ROW)
 74 | 		{
 75 | 			const char* title=reinterpret_cast<const char*>(sqlite3_column_text(next,0));
 76 | 			const char* description=reinterpret_cast<const char*>(sqlite3_column_text(next,1));
 77 | 			const char* category=reinterpret_cast<const char*>(sqlite3_column_text(next,2));
 78 | 			bool finished=(bool)sqlite3_column_int(next,3);
 79 | 			tasks->AddItem(new Task(title,description,category,finished));
 80 | 		}
 81 | 	}else{
 82 | 		error->Go();
 83 | 	}
 84 | }
 85 | 
 86 | void
 87 | TaskSQL::LoadCategories(BListView* categories)
 88 | {
 89 | 	BString load_categories("SELECT * FROM Categories;");
 90 | 	
 91 | 	sqlite3_stmt* next;
 92 | 	if(sqlite3_prepare(db,load_categories.String(),strlen(load_categories.String()),&next,0)==SQLITE_OK)
 93 | 	{
 94 | 		while(sqlite3_step(next)==SQLITE_ROW)
 95 | 		{
 96 | 			const char* category=reinterpret_cast<const char*>(sqlite3_column_text(next,0));
 97 | 			const char* path=reinterpret_cast<const char*>(sqlite3_column_text(next,1));
 98 | 			categories->AddItem(new Category(category,path));
 99 | 		}
100 | 	}else
101 | 	{
102 | 		error->Go();
103 | 	}
104 | }
105 | 
106 | bool
107 | TaskSQL::AddCategory(const char* name, const char* filename)
108 | {
109 | 	BString insert_sentence("INSERT INTO Categories VALUES(\"");
110 | 	insert_sentence.Append(name);
111 | 	insert_sentence.Append("\",\"");
112 | 	insert_sentence.Append(filename);
113 | 	insert_sentence.Append("\");");
114 | 	
115 | 	char* error;
116 | 	
117 | 	if(sqlite3_exec(db,insert_sentence.String(),0,0,&error)!=SQLITE_OK)
118 | 	{
119 | 		std::cerr << "ERROR: " << error << std::endl;
120 | 		return false; 
121 | 	}else{
122 | 		return true;
123 | 	}
124 | }
125 | 
126 | bool
127 | TaskSQL::AddTask(const char* title, const char* description, const char* category)
128 | {
129 | 	BString insert_sentence("INSERT INTO HaikuToDo VALUES(\"");
130 | 	insert_sentence.Append(title);
131 | 	insert_sentence.Append("\",\"");
132 | 	insert_sentence.Append(description);
133 | 	insert_sentence.Append("\",\"");
134 | 	insert_sentence.Append(category);
135 | 	insert_sentence.Append("\",0);");
136 | 	
137 | 	char* error;
138 | 	
139 | 	if(sqlite3_exec(db,insert_sentence.String(),0,0,&error)!=SQLITE_OK)
140 | 	{
141 | 		std::cerr << "ERROR: " << error << std::endl;
142 | 		return false;
143 | 	}else{
144 | 		return true;
145 | 	}
146 | 	
147 | }
148 | 
149 | bool
150 | TaskSQL::RemoveTask(const char* title, const char* description, const char* category)
151 | {
152 | 	BString remove_sentence("DELETE FROM HaikuToDo WHERE TITLE=\"");
153 | 	remove_sentence.Append(title);
154 | 	remove_sentence.Append("\";");
155 | 	
156 | 	char* error;
157 | 	
158 | 	if(sqlite3_exec(db,remove_sentence.String(),0,0,&error)==SQLITE_OK)
159 | 	{
160 | 		return true;
161 | 	}else{
162 | 		std::cerr << "ERROR: " << error << std::endl;
163 | 		return false;
164 | 	}
165 | }
166 | 
167 | bool
168 | TaskSQL::MarkAsComplete(const char* title, const char* description, const char* category)
169 | {
170 | 	BString update_sentence("UPDATE HaikuToDo SET FINISHED=1 WHERE TITLE=\"");
171 | 	update_sentence.Append(title);
172 | 	update_sentence.Append("\";");
173 | 	
174 | 	char* error;
175 | 	
176 | 	if(sqlite3_exec(db,update_sentence.String(),0,0,&error)==SQLITE_OK)
177 | 	{
178 | 		return true;
179 | 	}else{
180 | 		std::cerr << "ERROR: " << error << std::endl;
181 | 	}
182 | }
183 | 
184 | 
185 | 


--------------------------------------------------------------------------------
/HaikuToDo/TaskFS.cpp:
--------------------------------------------------------------------------------
  1 | #include "TaskFS.hpp"
  2 | #include <iostream>
  3 | #include "Task.hpp"
  4 | #include "Category.hpp"
  5 | #include <cstdlib>
  6 | #include <TypeConstants.h>
  7 | #include <posix/sys/stat.h>
  8 | #include <kernel/fs_index.h>
  9 | 
 10 | TaskFS::TaskFS()
 11 | {
 12 | 	error=new BAlert("FileSystem error",
 13 | 		"There was an error in the BeFS backend",
 14 | 		"OK",NULL,NULL,B_WIDTH_AS_USUAL,B_OFFSET_SPACING, B_STOP_ALERT);
 15 | 	BPath path;
 16 | 	if(find_directory(B_USER_SETTINGS_DIRECTORY,&path)!=B_OK)
 17 | 	{
 18 | 		error->Go();
 19 | 		exit(2);
 20 | 	}
 21 | 	BDirectory storage;
 22 | 	BDirectory tasksDir;
 23 | 	BDirectory categoriesDir;
 24 | 	BDirectory settings(path.Path());
 25 | 	settings.CreateDirectory("HaikuToDo",&storage);
 26 | 	storage.CreateDirectory("Tasks",&tasksDir);
 27 | 	storage.CreateDirectory("Categories",&categoriesDir);
 28 | 	path.Append("HaikuToDo");
 29 | 	BPath taskPath=path;
 30 | 	taskPath.Append("Tasks");
 31 | 	BPath categoriesPath=path;
 32 | 	categoriesPath.Append("Categories");
 33 | 	tasks=BString(taskPath.Path());
 34 | 	categories=BString(categoriesPath.Path());
 35 | 
 36 | 	struct stat st;
 37 | 	settings.GetStat(&st);
 38 | 
 39 | 	volume=st.st_dev;
 40 | 
 41 | 	fs_create_index(st.st_dev,"HAIKU_TO_DO:Category",B_STRING_TYPE,0);
 42 | 
 43 | }
 44 | 
 45 | TaskFS::~TaskFS()
 46 | {
 47 | 
 48 | }
 49 | 
 50 | void
 51 | TaskFS::LoadTasks(const char* category, BListView* tasksList)
 52 | {
 53 | 	BString predicate("HAIKU_TO_DO:Category=**");
 54 | 	if(strcmp(category,"ALL")==0)
 55 | 		predicate.Append("**");
 56 | 	else
 57 | 		predicate.Append(category);
 58 | 	BQuery query;
 59 | 	BVolume volume;
 60 | 	BVolumeRoster volumeRoster;
 61 | 	while(volumeRoster.GetNextVolume(&volume)==B_OK)
 62 | 	{
 63 | 		if(volume.KnowsQuery())
 64 | 		{
 65 | 			query.Clear();
 66 | 			query.SetVolume(&volume);
 67 | 			query.SetPredicate(predicate.String());
 68 | 			status_t rc=query.Fetch();
 69 | 			if(rc!=B_OK)
 70 | 			{
 71 | 				error->Go();
 72 | 			}
 73 | 			BEntry entry;
 74 | 			while(query.GetNextEntry(&entry)==B_OK)
 75 | 			{
 76 | 				char name[8192];
 77 | 				entry.GetName(name);
 78 | 				BFile file(&entry,B_READ_ONLY);
 79 | 				off_t file_size=0;
 80 | 				file.GetSize(&file_size);
 81 | 				char buffer[file_size+1024];
 82 | 				file.Read(buffer,file_size);
 83 | 				bool finished;
 84 | 				file.ReadAttr("HAIKU_TO_DO:Finished",B_BOOL_TYPE,0,&finished,sizeof(bool));
 85 | 				Task* tk=new Task((const char*)name,(const char*)buffer,"ALL",finished);
 86 | 				tasksList->AddItem(tk);
 87 | 			}
 88 | 		}
 89 | 	}
 90 | 
 91 | }
 92 | 
 93 | void
 94 | TaskFS::LoadCategories(BListView* categoriesList)
 95 | {
 96 | 		BDirectory dir(categories);
 97 | 		int32 entries=dir.CountEntries();
 98 | 		for(int32 i=0;i<entries;i++)
 99 | 		{
100 | 			char name[8192];
101 | 			BEntry entry;
102 | 			dir.GetNextEntry(&entry);
103 | 			entry.GetName(name);
104 | 			BFile file(&entry,B_READ_ONLY);
105 | 			off_t file_size=0;
106 | 			file.GetSize(&file_size);
107 | 			char buffer[file_size+1024];
108 | 			file.Read(buffer,file_size);
109 | 			Category* cat=new Category((const char*)name,(const char*)buffer);
110 | 			categoriesList->AddItem(cat);
111 | 		}
112 | }
113 | 
114 | bool
115 | TaskFS::AddCategory(const char* name, const char* filename)
116 | {
117 | 	BString filn(filename);
118 | 	BDirectory dir(categories);
119 | 	BFile file;
120 | 	dir.CreateFile(name,&file);
121 | 	file.Write(filn,filn.Length());
122 | }
123 | 
124 | bool
125 | TaskFS::AddTask(const char* title, const char* description, const char* category)
126 | {
127 | 	BString desc(description);
128 | 	BDirectory dir(tasks);
129 | 	BFile file;
130 | 	dir.CreateFile(title,&file);
131 | 	file.Write(desc,desc.Length());
132 | 	file.WriteAttrString("HAIKU_TO_DO:Category",new BString(category));
133 | 	bool finished=false;
134 | 	file.WriteAttr("HAIKU_TO_DO:Finished",B_BOOL_TYPE,0,&finished,sizeof(bool));
135 | }
136 | 
137 | bool
138 | TaskFS::RemoveTask(const char* title, const char* description, const char* category)
139 | {
140 | 	BString predicate("(HAIKU_TO_DO:Category=**)&&(name=");
141 | 	predicate.Append(title);
142 | 	predicate.Append(")");
143 | 
144 | 	BQuery query;
145 | 	BVolume volume;
146 | 	BVolumeRoster volumeRoster;
147 | 	while(volumeRoster.GetNextVolume(&volume)==B_OK)
148 | 	{
149 | 		if(volume.KnowsQuery())
150 | 		{
151 | 			query.Clear();
152 | 			query.SetVolume(&volume);
153 | 			query.SetPredicate(predicate.String());
154 | 			status_t rc=query.Fetch();
155 | 			if(rc!=B_OK)
156 | 			{
157 | 				error->Go();
158 | 			}
159 | 			BEntry entry;
160 | 			while(query.GetNextEntry(&entry)==B_OK)
161 | 			{
162 | 				entry.Remove();
163 | 			}
164 | 		}
165 | 	}
166 | }
167 | 
168 | bool
169 | TaskFS::MarkAsComplete(const char* title, const char* description, const char* category)
170 | {
171 | 	BString predicate("(HAIKU_TO_DO:Category=**)&&(name=");
172 | 	predicate.Append(title);
173 | 	predicate.Append(")");
174 | 
175 | 	BQuery query;
176 | 	BVolume volume;
177 | 	BVolumeRoster volumeRoster;
178 | 	while(volumeRoster.GetNextVolume(&volume)==B_OK)
179 | 	{
180 | 		if(volume.KnowsQuery())
181 | 		{
182 | 			query.Clear();
183 | 			query.SetVolume(&volume);
184 | 			query.SetPredicate(predicate.String());
185 | 			status_t rc=query.Fetch();
186 | 			if(rc!=B_OK)
187 | 			{
188 | 				error->Go();
189 | 			}
190 | 			BEntry entry;
191 | 			while(query.GetNextEntry(&entry)==B_OK)
192 | 			{
193 | 				BFile file(&entry,B_READ_ONLY);
194 | 				bool finished=true;
195 | 				file.WriteAttr("HAIKU_TO_DO:Finished",B_BOOL_TYPE,0,&finished,sizeof(bool));
196 | 			}
197 | 		}
198 | 	}
199 | }
200 | 
201 | 


--------------------------------------------------------------------------------
/HaikuToDo/MainWindow.cpp:
--------------------------------------------------------------------------------
  1 | #include "MainWindow.hpp"
  2 | #include "Task.hpp"
  3 | #include "AddTask.hpp"
  4 | #include "Category.hpp"
  5 | #include "TaskGoogle.hpp"
  6 | #include "TaskSync.hpp"
  7 | 
  8 | #include <Layout.h>
  9 | #include <LayoutBuilder.h>
 10 | #include <LayoutItem.h>
 11 | 
 12 | #define CATEGORY_ALL_ICON "MIME_DATABASE"
 13 | 
 14 | MainWindow::MainWindow()
 15 | 	: BWindow(BRect(50,50,600+50,400+50),"HaikuToDo",B_TITLED_WINDOW,0)
 16 | {
 17 | 	#ifdef BUILD_SQLITE
 18 | 	manager=new TaskSQL();
 19 | 	#else
 20 | 	manager=new TaskFS();
 21 | 	#endif
 22 | 	//DOING TESTS WITH GOOGLE TASKS
 23 | 	sync=new TaskGoogle();
 24 | 	//sync->Login();
 25 | 	//SEND MESSAGE WHEN LOADED
 26 | 	//END DOING TESTS
 27 | 	BView* main=new BView(Bounds(),"Main View",B_FOLLOW_ALL_SIDES,B_WILL_DRAW);
 28 | 	main->SetViewColor(220,220,220);
 29 | 	//BGroupLayout* grid=new BGroupLayout(B_HORIZONTAL);
 30 | 	BGridLayout* grid=new BGridLayout();
 31 | 	main->SetLayout(grid);
 32 | 
 33 | 	/* Categories View */
 34 | 	BGridLayout* categoriesLayout=new BGridLayout();
 35 | 	grid->AddItem(categoriesLayout,0,0);
 36 | 
 37 | 	taskAdd=new BButton("Add task","Add task",new BMessage(TASK_ADD));
 38 | 	categoriesLayout->AddView(taskAdd,1,1,2,1);
 39 | 
 40 | 	categories=new BListView("Categories list",B_SINGLE_SELECTION_LIST);
 41 | 	categories->SetSelectionMessage(new BMessage(CHANGE_CATEGORY));
 42 | 
 43 | 	BScrollView* scrollCategories=new BScrollView("Scroll categories"
 44 | 		,categories, 0, false, true);
 45 | 	categoriesLayout->AddView(scrollCategories,1,3,6,5);
 46 | 
 47 | 	googleTasks=new BButton("Google Tasks","Google Tasks",new BMessage(LOGIN_GTASKS));
 48 | 	categoriesLayout->AddView(googleTasks,1,8,2,1);
 49 | 
 50 | 	categories->AddItem(new Category("ALL",CATEGORY_ALL_ICON));
 51 | 	manager->LoadCategories(categories);
 52 | 
 53 | 	categoriesLayout->SetInsets(10.0f,10.0f,10.0f,10.0f);
 54 | 
 55 | 
 56 | 	/* List View */
 57 | 	BGridLayout* listLayout=new BGridLayout();
 58 | 	grid->AddItem(listLayout,1,0);
 59 | 
 60 | 	taskRemove=new BButton("Remove task","Remove task",new BMessage(TASK_REMOVE));
 61 | 	listLayout->AddView(taskRemove,1,1,2,1);
 62 | 
 63 | 	tasklist=new BListView("Tasks list",B_SINGLE_SELECTION_LIST);
 64 | 	tasklist->SetSelectionMessage(new BMessage(ITEM_SELECTED));
 65 | 
 66 | 	BScrollView* scrollTasks=new BScrollView("Scroll tasks", tasklist,0
 67 | 		,false, true);
 68 | 	listLayout->AddView(scrollTasks,1,3,6,5);
 69 | 	listLayout->SetInsets(0.0f,10.0f,0.0f, 10.0f);
 70 | 
 71 | 	/* Task View */
 72 | 	BGroupLayout* taskLayout=new BGroupLayout(B_VERTICAL);
 73 | 	grid->AddItem(taskLayout,2,0);
 74 | 
 75 | 	taskTitle=new BStringView("Task title","No task selected");
 76 | 
 77 | 	BFont font;
 78 | 	taskTitle->GetFont(&font);
 79 | 	font.SetSize(font.Size()*1.7);
 80 | 	taskTitle->SetFont(&font,B_FONT_SIZE | B_FONT_FLAGS);
 81 | 
 82 | 	taskLayout->AddView(taskTitle);//,1,1,6,2);
 83 | 
 84 | 	taskDescription=new BTextView("Task description");
 85 | 	taskDescription->MakeEditable(false);
 86 | 	taskDescription->SetViewColor(220,220,220);
 87 | 	taskLayout->AddView(taskDescription);//,1,4//,5,3);
 88 | 
 89 | 	taskCompleted=new BCheckBox("Task completed","Finished",new BMessage(COMPLETED_TASK));
 90 | 	taskLayout->AddView(taskCompleted);//,1,8,5,1);
 91 | 
 92 | 
 93 | 	taskLayout->SetInsets(10.0f,10.0f,10.0f,10.0f);
 94 | 
 95 | 	grid->SetMaxColumnWidth(0,300.0f);
 96 | 	grid->SetMaxColumnWidth(1,300.0f);
 97 | 	grid->SetMinColumnWidth(2,300.0f);
 98 | 
 99 | 	AddChild(main);
100 | 
101 | 	manager->LoadTasks("ALL",tasklist);
102 | }
103 | 
104 | MainWindow::~MainWindow()
105 | {
106 | 
107 | }
108 | 
109 | bool
110 | MainWindow::QuitRequested()
111 | {
112 | 	be_app_messenger.SendMessage(B_QUIT_REQUESTED);
113 | 	return BWindow::QuitRequested();
114 | }
115 | 
116 | void
117 | MainWindow::MessageReceived(BMessage* msg)
118 | {
119 | 	switch(msg->what)
120 | 	{
121 | 		case ITEM_SELECTED:
122 | 		{
123 | 			int32 taskSelection=tasklist->CurrentSelection();
124 | 			if(taskSelection>=0)
125 | 			{
126 | 				Task* item=dynamic_cast<Task*>(tasklist->ItemAt(taskSelection));
127 | 				SetTitle(item->Text());
128 | 				taskTitle->SetText(item->Text());
129 | 				taskDescription->SetText(item->GetDetails());
130 | 				taskCompleted->SetValue(item->GetCompleted());
131 | 			}
132 | 			break;
133 | 		}
134 | 		case COMPLETED_TASK:
135 | 		{
136 | 			//ASK FOR REMOVE TASK
137 | 			int32 taskSelection=tasklist->CurrentSelection();
138 | 			if(taskSelection>=0)
139 | 			{
140 | 				Task* item=dynamic_cast<Task*>(tasklist->ItemAt(taskSelection));
141 | 				manager->MarkAsComplete(item->Text(),item->GetDetails(),item->GetCategory());
142 | 				PostMessage(new BMessage(RELOAD));
143 | 			}
144 | 			break;
145 | 		}
146 | 		case TASK_ADD:
147 | 		{
148 | 			AddTask* add=new AddTask(manager);
149 | 			add->Show();
150 | 
151 | 			break;
152 | 		}
153 | 		case SYNC_CATEGORIES:
154 | 		{
155 | 			BList* cats=sync->GetCategories();
156 | 			categories->AddList(cats);
157 | 			break;
158 | 		}
159 | 		case LOGIN_GTASKS:
160 | 		{
161 | 			std::cout << "Login one time" << std::endl;
162 | 			sync->Login();
163 | 			break;
164 | 		}
165 | 		case RELOAD:
166 | 		{
167 | 			std::cout << "Reload started" << std::endl;
168 | 			tasklist->MakeEmpty();
169 | 			int32 selection=categories->CurrentSelection();
170 | 			if(selection>=0)
171 | 			{
172 | 				Category* item=dynamic_cast<Category*>(categories->ItemAt(selection));
173 | 				if(strcmp(item->GetID(),"NULL")==0)
174 | 				{
175 | 					manager->LoadTasks(item->GetName(),tasklist);
176 | 				}else{
177 | 					tasklist->AddList(sync->GetTasks(item));
178 | 				}
179 | 
180 | 			}else{
181 | 				manager->LoadTasks("ALL",tasklist);
182 | 			}
183 | 			break;
184 | 		}
185 | 		case RELOAD_CATEGORIES:
186 | 		{
187 | 			categories->MakeEmpty();
188 | 			categories->AddItem(new Category("ALL",CATEGORY_ALL_ICON));
189 | 			manager->LoadCategories(categories);
190 | 			break;
191 | 		}
192 | 		case TASK_REMOVE:
193 | 		{
194 | 			int32 taskSelection=tasklist->CurrentSelection();
195 | 			if(taskSelection>=0)
196 | 			{
197 | 				Task* item=dynamic_cast<Task*>(tasklist->ItemAt(taskSelection));
198 | 				manager->RemoveTask(item->Text(),item->GetDetails(),item->GetCategory());
199 | 				PostMessage(new BMessage(RELOAD));
200 | 			}
201 | 			break;
202 | 		}
203 | 		case CHANGE_CATEGORY:
204 | 		{
205 | 			PostMessage(new BMessage(RELOAD));
206 | 		}
207 | 		default:
208 | 			BWindow::MessageReceived(msg);
209 | 	}
210 | }
211 | 


--------------------------------------------------------------------------------
/HaikuToDo/TaskGoogle.cpp:
--------------------------------------------------------------------------------
  1 | #include "TaskSync.hpp"
  2 | #include "TaskGoogle.hpp"
  3 | #include <NetworkKit.h>
  4 | #include <UrlRequest.h>
  5 | #include <UrlSynchronousRequest.h>
  6 | #include <UrlProtocolRoster.h>
  7 | #include <HttpHeaders.h>
  8 | #include <HttpRequest.h>
  9 | #include <private/shared/Json.h>
 10 | #include <iostream>
 11 | #include "Internet.hpp"
 12 | #include <string>
 13 | #include <sstream>
 14 | #include <app/Roster.h>
 15 | #include <Key.h>
 16 | #include <KeyStore.h>
 17 | 
 18 | TaskGoogle::TaskGoogle()
 19 | {
 20 | 	categories=new BList(20);
 21 | 	tasks=new BList(20);
 22 | }
 23 | 
 24 | TaskGoogle::~TaskGoogle()
 25 | {
 26 | 
 27 | }
 28 | 
 29 | status_t
 30 | TaskGoogle::LoadToken()
 31 | {
 32 | 	BPasswordKey key;
 33 | 	BKeyStore keyStore;
 34 | 	if(keyStore.GetKey("HaikuToDo",B_KEY_TYPE_PASSWORD,"refresh_token",key) == B_OK) {
 35 | 		refresh_token=key.Password();
 36 | 		return B_OK;
 37 | 	}
 38 | 	return B_ERROR;
 39 | }
 40 | 
 41 | bool
 42 | TaskGoogle::Login()
 43 | {
 44 | 	if(LoadToken() == B_OK) {
 45 | 		// We have a refresh token, now check if it works
 46 | 		BHttpForm* form=new BHttpForm();
 47 | 		form->AddString("refresh_token",refresh_token);
 48 | 		form->AddString("client_id",CLIENT_ID);
 49 | 		form->AddString("client_secret",CLIENT_SECRET);
 50 | 		form->AddString("grant_type","refresh_token");
 51 | 		form->SetFormType(B_HTTP_FORM_URL_ENCODED);
 52 | 		BString endpoint("https://www.googleapis.com/oauth2/v4/token");
 53 | 		BString response(HaikuHTTP::GET(endpoint,form));
 54 | 		BMessage refreshJson;
 55 | 		BPrivate::BJson::Parse(response, refreshJson);
 56 | 		token = BString(refreshJson.GetString("access_token","NOT_FOUND"));
 57 | 		if(token.Compare("NOT_FOUND") == 0)
 58 | 		{
 59 | 			// token was invalid. remove and restart
 60 | 			BKeyStore keyStore;
 61 | 			keyStore.RemoveKeyring("HaikuToDo");
 62 | 		}else{
 63 | 			// everything is OK
 64 | 			Sync();
 65 | 			return true;
 66 | 		}
 67 | 	}
 68 | 	BString endpoint("https://accounts.google.com/o/oauth2/auth");
 69 | 	endpoint.Append("?response_type=code");
 70 | 	endpoint.Append("&client_id=");
 71 | 	endpoint.Append(CLIENT_ID);
 72 | 	endpoint.Append("&redirect_uri=");
 73 | 	endpoint.Append(REDIRECT_URI);
 74 | 	endpoint.Append("&scope=https://www.googleapis.com/auth/tasks");
 75 | 	endpoint.Append("&access_type=offline");
 76 | 	std::cout << endpoint.String() << std::endl;
 77 | 	const char *args[] = { endpoint.String(), 0 };
 78 | 	be_roster->Launch("application/x-vnd.Be.URL.http",1,const_cast<char **>(args));
 79 | 
 80 | 	LoginDialog* login=new LoginDialog(this);
 81 | 	login->Show();
 82 | }
 83 | 
 84 | void
 85 | TaskGoogle::NextStep(BString code)
 86 | {
 87 | 	BHttpForm* form=new BHttpForm();
 88 | 	form->AddString("code",code);
 89 | 	form->AddString("client_id",CLIENT_ID);
 90 | 	form->AddString("client_secret",CLIENT_SECRET);
 91 | 	form->AddString("grant_type","authorization_code");
 92 | 	form->AddString("redirect_uri",REDIRECT_URI);
 93 | 	form->SetFormType(B_HTTP_FORM_URL_ENCODED);
 94 | 
 95 | 	BString oauth2("https://www.googleapis.com/oauth2/v3/token");
 96 | 	BString tokenResponse(HaikuHTTP::GET(oauth2,form));
 97 | 
 98 | 	BMessage tokenJson;
 99 | 	BPrivate::BJson::Parse(tokenResponse, tokenJson);
100 | 	tokenJson.PrintToStream();
101 | 
102 | 	token=BString(tokenJson.GetString("access_token","NOT_FOUND"));
103 | 	refresh_token = BString(tokenJson.GetString("refresh_token","NOT_FOUND"));
104 | 
105 | 	// save refresh_token
106 | 	BPasswordKey key(refresh_token, B_KEY_PURPOSE_WEB, "refresh_token");
107 | 	BKeyStore keyStore;
108 | 	keyStore.AddKeyring("HaikuToDo");
109 | 	keyStore.AddKey("HaikuToDo", key);
110 | 	Sync();
111 | }
112 | 
113 | void
114 | TaskGoogle::Sync()
115 | {
116 | 	BString listUrlString("https://www.googleapis.com/tasks/v1/users/@me/lists?access_token=");
117 | 	listUrlString.Append(token);
118 | 
119 | 	BString listsResponse(HaikuHTTP::GET(listUrlString));
120 | 
121 | 	BMessage listsJson;
122 | 	std::cout << listsResponse << std::endl;
123 | 	BPrivate::BJson::Parse(listsResponse, listsJson);
124 | 	listsJson.PrintToStream();
125 | 
126 | 	BMessage userLists;
127 | 	if(listsJson.FindMessage("items",0,&userLists)!=B_OK)
128 | 	{
129 | 		std::cerr << "ERROR: 'items' not found" << std::endl;
130 | 	}
131 | 
132 | 
133 | 	int32 lists=userLists.CountNames(B_ANY_TYPE);
134 | 	std::cout << "Lists found: " << lists << std::endl;
135 | 
136 | 	for(int32 currentList=0;currentList<lists;currentList++)
137 | 	{
138 | 		std::ostringstream ss;
139 | 		ss << currentList;
140 | 		BMessage userList;
141 | 		if(userLists.FindMessage(ss.str().c_str(),&userList)!=B_OK)
142 | 		{
143 | 			std::cerr << "ERROR: No '0' list found " << std::endl;
144 | 		}
145 | 		userList.PrintToStream();
146 | 		const char* title;
147 | 		const char* id;
148 | 		if(userList.FindString("title",&title)!=B_OK)
149 | 		{
150 | 			std::cerr << "ERROR: No 'title' found " << std::endl;
151 | 		}
152 | 		userList.FindString("id",&id);
153 | 		Category* cat=new Category(title,"MIME_DATABASE",id);
154 | 		categories->AddItem(cat);
155 | 		this->GetTasks(cat);
156 | 	}
157 | 
158 | 	//DISPATCH SYNC_CATEGORIES
159 | 
160 | 	int32 count=be_app->CountWindows();
161 | 	for(int32 i=0;i<count;i++)
162 | 	{
163 | 		be_app->WindowAt(i)->PostMessage(new BMessage(SYNC_CATEGORIES));
164 | 	}
165 | 
166 | }
167 | 
168 | BList*
169 | TaskGoogle::GetCategories()
170 | {
171 | 	return categories;
172 | }
173 | 
174 | BList*
175 | TaskGoogle::GetTasks(Category* cat)
176 | {
177 | 	//DO HTTP CONNECTION TO GOOGLE
178 | 	BList* tks=new BList(20);
179 | 
180 | 	BString id=cat->GetID();
181 | 	std::cout << "ID: " << id.String() << std::endl;
182 | 	BString url("https://www.googleapis.com/tasks/v1/lists/");
183 | 	url.Append(id);
184 | 	url.Append("/tasks?access_token=");
185 | 	url.Append(token);
186 | 
187 | 	BString response(HaikuHTTP::GET(url));
188 | 	std::cout << response.String() << std::endl;
189 | 	BMessage taskJson;
190 | 	BPrivate::BJson::Parse(response, taskJson);
191 | 	taskJson.PrintToStream();
192 | 
193 | 	BMessage items;
194 | 	taskJson.FindMessage("items",&items);
195 | 	int32 lists=items.CountNames(B_ANY_TYPE);
196 | 	std::cout << "Lists found: " << lists << std::endl;
197 | 
198 | 	for(int32 currentTask=0;currentTask<lists;currentTask++)
199 | 	{
200 | 		std::ostringstream ss;
201 | 		ss << currentTask;
202 | 		BMessage task;
203 | 		if(items.FindMessage(ss.str().c_str(),&task)!=B_OK)
204 | 		{
205 | 			std::cerr << "ERROR: No '0' list found " << std::endl;
206 | 		}
207 | 		task.PrintToStream();
208 | 		const char* title;
209 | 		const char* taskId;
210 | 		const char* notes;
211 | 		const char* status;
212 | 		task.FindString("title",&title);
213 | 		task.FindString("id",&taskId);
214 | 		task.FindString("notes",&notes);
215 | 		task.FindString("status",&status);
216 | 		Task* tk=new Task(title,notes,id.String(),false);
217 | 		tks->AddItem(tk);
218 | 	}
219 | 
220 | 
221 | 	return tks;
222 | }
223 | 


--------------------------------------------------------------------------------
/Doxyfile:
--------------------------------------------------------------------------------
   1 | # Doxyfile 1.7.6.1
   2 | 
   3 | # This file describes the settings to be used by the documentation system
   4 | # doxygen (www.doxygen.org) for a project.
   5 | #
   6 | # All text after a hash (#) is considered a comment and will be ignored.
   7 | # The format is:
   8 | #       TAG = value [value, ...]
   9 | # For lists items can also be appended using:
  10 | #       TAG += value [value, ...]
  11 | # Values that contain spaces should be placed between quotes (" ").
  12 | 
  13 | #---------------------------------------------------------------------------
  14 | # Project related configuration options
  15 | #---------------------------------------------------------------------------
  16 | 
  17 | # This tag specifies the encoding used for all characters in the config file
  18 | # that follow. The default is UTF-8 which is also the encoding used for all
  19 | # text before the first occurrence of this tag. Doxygen uses libiconv (or the
  20 | # iconv built into libc) for the transcoding. See
  21 | # http://www.gnu.org/software/libiconv for the list of possible encodings.
  22 | 
  23 | DOXYFILE_ENCODING      = UTF-8
  24 | 
  25 | # The PROJECT_NAME tag is a single word (or sequence of words) that should
  26 | # identify the project. Note that if you do not use Doxywizard you need
  27 | # to put quotes around the project name if it contains spaces.
  28 | 
  29 | PROJECT_NAME           = "HaikuToDo"
  30 | 
  31 | # The PROJECT_NUMBER tag can be used to enter a project or revision number.
  32 | # This could be handy for archiving the generated documentation or
  33 | # if some version control system is used.
  34 | 
  35 | PROJECT_NUMBER         = 1.1
  36 | 
  37 | # Using the PROJECT_BRIEF tag one can provide an optional one line description
  38 | # for a project that appears at the top of each page and should give viewer
  39 | # a quick idea about the purpose of the project. Keep the description short.
  40 | 
  41 | PROJECT_BRIEF          = "Task manager for Haiku"
  42 | 
  43 | # With the PROJECT_LOGO tag one can specify an logo or icon that is
  44 | # included in the documentation. The maximum height of the logo should not
  45 | # exceed 55 pixels and the maximum width should not exceed 200 pixels.
  46 | # Doxygen will copy the logo to the output directory.
  47 | 
  48 | PROJECT_LOGO           =
  49 | 
  50 | # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
  51 | # base path where the generated documentation will be put.
  52 | # If a relative path is entered, it will be relative to the location
  53 | # where doxygen was started. If left blank the current directory will be used.
  54 | 
  55 | OUTPUT_DIRECTORY       = docs
  56 | 
  57 | # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
  58 | # 4096 sub-directories (in 2 levels) under the output directory of each output
  59 | # format and will distribute the generated files over these directories.
  60 | # Enabling this option can be useful when feeding doxygen a huge amount of
  61 | # source files, where putting all generated files in the same directory would
  62 | # otherwise cause performance problems for the file system.
  63 | 
  64 | CREATE_SUBDIRS         = NO
  65 | 
  66 | # The OUTPUT_LANGUAGE tag is used to specify the language in which all
  67 | # documentation generated by doxygen is written. Doxygen will use this
  68 | # information to generate all constant output in the proper language.
  69 | # The default language is English, other supported languages are:
  70 | # Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
  71 | # Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,
  72 | # Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English
  73 | # messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian,
  74 | # Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak,
  75 | # Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
  76 | 
  77 | OUTPUT_LANGUAGE        = English
  78 | 
  79 | # If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
  80 | # include brief member descriptions after the members that are listed in
  81 | # the file and class documentation (similar to JavaDoc).
  82 | # Set to NO to disable this.
  83 | 
  84 | BRIEF_MEMBER_DESC      = YES
  85 | 
  86 | # If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
  87 | # the brief description of a member or function before the detailed description.
  88 | # Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
  89 | # brief descriptions will be completely suppressed.
  90 | 
  91 | REPEAT_BRIEF           = YES
  92 | 
  93 | # This tag implements a quasi-intelligent brief description abbreviator
  94 | # that is used to form the text in various listings. Each string
  95 | # in this list, if found as the leading text of the brief description, will be
  96 | # stripped from the text and the result after processing the whole list, is
  97 | # used as the annotated text. Otherwise, the brief description is used as-is.
  98 | # If left blank, the following values are used ("$name" is automatically
  99 | # replaced with the name of the entity): "The $name class" "The $name widget"
 100 | # "The $name file" "is" "provides" "specifies" "contains"
 101 | # "represents" "a" "an" "the"
 102 | 
 103 | ABBREVIATE_BRIEF       =
 104 | 
 105 | # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
 106 | # Doxygen will generate a detailed section even if there is only a brief
 107 | # description.
 108 | 
 109 | ALWAYS_DETAILED_SEC    = NO
 110 | 
 111 | # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
 112 | # inherited members of a class in the documentation of that class as if those
 113 | # members were ordinary class members. Constructors, destructors and assignment
 114 | # operators of the base classes will not be shown.
 115 | 
 116 | INLINE_INHERITED_MEMB  = NO
 117 | 
 118 | # If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
 119 | # path before files name in the file list and in the header files. If set
 120 | # to NO the shortest path that makes the file name unique will be used.
 121 | 
 122 | FULL_PATH_NAMES        = YES
 123 | 
 124 | # If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
 125 | # can be used to strip a user-defined part of the path. Stripping is
 126 | # only done if one of the specified strings matches the left-hand part of
 127 | # the path. The tag can be used to show relative paths in the file list.
 128 | # If left blank the directory from which doxygen is run is used as the
 129 | # path to strip.
 130 | 
 131 | STRIP_FROM_PATH        =
 132 | 
 133 | # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
 134 | # the path mentioned in the documentation of a class, which tells
 135 | # the reader which header file to include in order to use a class.
 136 | # If left blank only the name of the header file containing the class
 137 | # definition is used. Otherwise one should specify the include paths that
 138 | # are normally passed to the compiler using the -I flag.
 139 | 
 140 | STRIP_FROM_INC_PATH    =
 141 | 
 142 | # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
 143 | # (but less readable) file names. This can be useful if your file system
 144 | # doesn't support long names like on DOS, Mac, or CD-ROM.
 145 | 
 146 | SHORT_NAMES            = NO
 147 | 
 148 | # If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
 149 | # will interpret the first line (until the first dot) of a JavaDoc-style
 150 | # comment as the brief description. If set to NO, the JavaDoc
 151 | # comments will behave just like regular Qt-style comments
 152 | # (thus requiring an explicit @brief command for a brief description.)
 153 | 
 154 | JAVADOC_AUTOBRIEF      = NO
 155 | 
 156 | # If the QT_AUTOBRIEF tag is set to YES then Doxygen will
 157 | # interpret the first line (until the first dot) of a Qt-style
 158 | # comment as the brief description. If set to NO, the comments
 159 | # will behave just like regular Qt-style comments (thus requiring
 160 | # an explicit \brief command for a brief description.)
 161 | 
 162 | QT_AUTOBRIEF           = NO
 163 | 
 164 | # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
 165 | # treat a multi-line C++ special comment block (i.e. a block of //! or ///
 166 | # comments) as a brief description. This used to be the default behaviour.
 167 | # The new default is to treat a multi-line C++ comment block as a detailed
 168 | # description. Set this tag to YES if you prefer the old behaviour instead.
 169 | 
 170 | MULTILINE_CPP_IS_BRIEF = NO
 171 | 
 172 | # If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
 173 | # member inherits the documentation from any documented member that it
 174 | # re-implements.
 175 | 
 176 | INHERIT_DOCS           = YES
 177 | 
 178 | # If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
 179 | # a new page for each member. If set to NO, the documentation of a member will
 180 | # be part of the file/class/namespace that contains it.
 181 | 
 182 | SEPARATE_MEMBER_PAGES  = NO
 183 | 
 184 | # The TAB_SIZE tag can be used to set the number of spaces in a tab.
 185 | # Doxygen uses this value to replace tabs by spaces in code fragments.
 186 | 
 187 | TAB_SIZE               = 8
 188 | 
 189 | # This tag can be used to specify a number of aliases that acts
 190 | # as commands in the documentation. An alias has the form "name=value".
 191 | # For example adding "sideeffect=\par Side Effects:\n" will allow you to
 192 | # put the command \sideeffect (or @sideeffect) in the documentation, which
 193 | # will result in a user-defined paragraph with heading "Side Effects:".
 194 | # You can put \n's in the value part of an alias to insert newlines.
 195 | 
 196 | ALIASES                =
 197 | 
 198 | # This tag can be used to specify a number of word-keyword mappings (TCL only).
 199 | # A mapping has the form "name=value". For example adding
 200 | # "class=itcl::class" will allow you to use the command class in the
 201 | # itcl::class meaning.
 202 | 
 203 | TCL_SUBST              =
 204 | 
 205 | # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
 206 | # sources only. Doxygen will then generate output that is more tailored for C.
 207 | # For instance, some of the names that are used will be different. The list
 208 | # of all members will be omitted, etc.
 209 | 
 210 | OPTIMIZE_OUTPUT_FOR_C  = NO
 211 | 
 212 | # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
 213 | # sources only. Doxygen will then generate output that is more tailored for
 214 | # Java. For instance, namespaces will be presented as packages, qualified
 215 | # scopes will look different, etc.
 216 | 
 217 | OPTIMIZE_OUTPUT_JAVA   = NO
 218 | 
 219 | # Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
 220 | # sources only. Doxygen will then generate output that is more tailored for
 221 | # Fortran.
 222 | 
 223 | OPTIMIZE_FOR_FORTRAN   = NO
 224 | 
 225 | # Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
 226 | # sources. Doxygen will then generate output that is tailored for
 227 | # VHDL.
 228 | 
 229 | OPTIMIZE_OUTPUT_VHDL   = NO
 230 | 
 231 | # Doxygen selects the parser to use depending on the extension of the files it
 232 | # parses. With this tag you can assign which parser to use for a given extension.
 233 | # Doxygen has a built-in mapping, but you can override or extend it using this
 234 | # tag. The format is ext=language, where ext is a file extension, and language
 235 | # is one of the parsers supported by doxygen: IDL, Java, Javascript, CSharp, C,
 236 | # C++, D, PHP, Objective-C, Python, Fortran, VHDL, C, C++. For instance to make
 237 | # doxygen treat .inc files as Fortran files (default is PHP), and .f files as C
 238 | # (default is Fortran), use: inc=Fortran f=C. Note that for custom extensions
 239 | # you also need to set FILE_PATTERNS otherwise the files are not read by doxygen.
 240 | 
 241 | EXTENSION_MAPPING      =
 242 | 
 243 | # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
 244 | # to include (a tag file for) the STL sources as input, then you should
 245 | # set this tag to YES in order to let doxygen match functions declarations and
 246 | # definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
 247 | # func(std::string) {}). This also makes the inheritance and collaboration
 248 | # diagrams that involve STL classes more complete and accurate.
 249 | 
 250 | BUILTIN_STL_SUPPORT    = YES
 251 | 
 252 | # If you use Microsoft's C++/CLI language, you should set this option to YES to
 253 | # enable parsing support.
 254 | 
 255 | CPP_CLI_SUPPORT        = NO
 256 | 
 257 | # Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.
 258 | # Doxygen will parse them like normal C++ but will assume all classes use public
 259 | # instead of private inheritance when no explicit protection keyword is present.
 260 | 
 261 | SIP_SUPPORT            = NO
 262 | 
 263 | # For Microsoft's IDL there are propget and propput attributes to indicate getter
 264 | # and setter methods for a property. Setting this option to YES (the default)
 265 | # will make doxygen replace the get and set methods by a property in the
 266 | # documentation. This will only work if the methods are indeed getting or
 267 | # setting a simple type. If this is not the case, or you want to show the
 268 | # methods anyway, you should set this option to NO.
 269 | 
 270 | IDL_PROPERTY_SUPPORT   = YES
 271 | 
 272 | # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
 273 | # tag is set to YES, then doxygen will reuse the documentation of the first
 274 | # member in the group (if any) for the other members of the group. By default
 275 | # all members of a group must be documented explicitly.
 276 | 
 277 | DISTRIBUTE_GROUP_DOC   = NO
 278 | 
 279 | # Set the SUBGROUPING tag to YES (the default) to allow class member groups of
 280 | # the same type (for instance a group of public functions) to be put as a
 281 | # subgroup of that type (e.g. under the Public Functions section). Set it to
 282 | # NO to prevent subgrouping. Alternatively, this can be done per class using
 283 | # the \nosubgrouping command.
 284 | 
 285 | SUBGROUPING            = YES
 286 | 
 287 | # When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and
 288 | # unions are shown inside the group in which they are included (e.g. using
 289 | # @ingroup) instead of on a separate page (for HTML and Man pages) or
 290 | # section (for LaTeX and RTF).
 291 | 
 292 | INLINE_GROUPED_CLASSES = NO
 293 | 
 294 | # When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and
 295 | # unions with only public data fields will be shown inline in the documentation
 296 | # of the scope in which they are defined (i.e. file, namespace, or group
 297 | # documentation), provided this scope is documented. If set to NO (the default),
 298 | # structs, classes, and unions are shown on a separate page (for HTML and Man
 299 | # pages) or section (for LaTeX and RTF).
 300 | 
 301 | INLINE_SIMPLE_STRUCTS  = NO
 302 | 
 303 | # When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
 304 | # is documented as struct, union, or enum with the name of the typedef. So
 305 | # typedef struct TypeS {} TypeT, will appear in the documentation as a struct
 306 | # with name TypeT. When disabled the typedef will appear as a member of a file,
 307 | # namespace, or class. And the struct will be named TypeS. This can typically
 308 | # be useful for C code in case the coding convention dictates that all compound
 309 | # types are typedef'ed and only the typedef is referenced, never the tag name.
 310 | 
 311 | TYPEDEF_HIDES_STRUCT   = NO
 312 | 
 313 | # The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
 314 | # determine which symbols to keep in memory and which to flush to disk.
 315 | # When the cache is full, less often used symbols will be written to disk.
 316 | # For small to medium size projects (<1000 input files) the default value is
 317 | # probably good enough. For larger projects a too small cache size can cause
 318 | # doxygen to be busy swapping symbols to and from disk most of the time
 319 | # causing a significant performance penalty.
 320 | # If the system has enough physical memory increasing the cache will improve the
 321 | # performance by keeping more symbols in memory. Note that the value works on
 322 | # a logarithmic scale so increasing the size by one will roughly double the
 323 | # memory usage. The cache size is given by this formula:
 324 | # 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
 325 | # corresponding to a cache size of 2^16 = 65536 symbols.
 326 | 
 327 | SYMBOL_CACHE_SIZE      = 0
 328 | 
 329 | # Similar to the SYMBOL_CACHE_SIZE the size of the symbol lookup cache can be
 330 | # set using LOOKUP_CACHE_SIZE. This cache is used to resolve symbols given
 331 | # their name and scope. Since this can be an expensive process and often the
 332 | # same symbol appear multiple times in the code, doxygen keeps a cache of
 333 | # pre-resolved symbols. If the cache is too small doxygen will become slower.
 334 | # If the cache is too large, memory is wasted. The cache size is given by this
 335 | # formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range is 0..9, the default is 0,
 336 | # corresponding to a cache size of 2^16 = 65536 symbols.
 337 | 
 338 | LOOKUP_CACHE_SIZE      = 0
 339 | 
 340 | #---------------------------------------------------------------------------
 341 | # Build related configuration options
 342 | #---------------------------------------------------------------------------
 343 | 
 344 | # If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
 345 | # documentation are documented, even if no documentation was available.
 346 | # Private class members and static file members will be hidden unless
 347 | # the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
 348 | 
 349 | EXTRACT_ALL            = YES
 350 | 
 351 | # If the EXTRACT_PRIVATE tag is set to YES all private members of a class
 352 | # will be included in the documentation.
 353 | 
 354 | EXTRACT_PRIVATE        = YES
 355 | 
 356 | # If the EXTRACT_STATIC tag is set to YES all static members of a file
 357 | # will be included in the documentation.
 358 | 
 359 | EXTRACT_STATIC         = YES
 360 | 
 361 | # If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
 362 | # defined locally in source files will be included in the documentation.
 363 | # If set to NO only classes defined in header files are included.
 364 | 
 365 | EXTRACT_LOCAL_CLASSES  = YES
 366 | 
 367 | # This flag is only useful for Objective-C code. When set to YES local
 368 | # methods, which are defined in the implementation section but not in
 369 | # the interface are included in the documentation.
 370 | # If set to NO (the default) only methods in the interface are included.
 371 | 
 372 | EXTRACT_LOCAL_METHODS  = NO
 373 | 
 374 | # If this flag is set to YES, the members of anonymous namespaces will be
 375 | # extracted and appear in the documentation as a namespace called
 376 | # 'anonymous_namespace{file}', where file will be replaced with the base
 377 | # name of the file that contains the anonymous namespace. By default
 378 | # anonymous namespaces are hidden.
 379 | 
 380 | EXTRACT_ANON_NSPACES   = NO
 381 | 
 382 | # If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
 383 | # undocumented members of documented classes, files or namespaces.
 384 | # If set to NO (the default) these members will be included in the
 385 | # various overviews, but no documentation section is generated.
 386 | # This option has no effect if EXTRACT_ALL is enabled.
 387 | 
 388 | HIDE_UNDOC_MEMBERS     = NO
 389 | 
 390 | # If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
 391 | # undocumented classes that are normally visible in the class hierarchy.
 392 | # If set to NO (the default) these classes will be included in the various
 393 | # overviews. This option has no effect if EXTRACT_ALL is enabled.
 394 | 
 395 | HIDE_UNDOC_CLASSES     = NO
 396 | 
 397 | # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
 398 | # friend (class|struct|union) declarations.
 399 | # If set to NO (the default) these declarations will be included in the
 400 | # documentation.
 401 | 
 402 | HIDE_FRIEND_COMPOUNDS  = NO
 403 | 
 404 | # If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
 405 | # documentation blocks found inside the body of a function.
 406 | # If set to NO (the default) these blocks will be appended to the
 407 | # function's detailed documentation block.
 408 | 
 409 | HIDE_IN_BODY_DOCS      = NO
 410 | 
 411 | # The INTERNAL_DOCS tag determines if documentation
 412 | # that is typed after a \internal command is included. If the tag is set
 413 | # to NO (the default) then the documentation will be excluded.
 414 | # Set it to YES to include the internal documentation.
 415 | 
 416 | INTERNAL_DOCS          = NO
 417 | 
 418 | # If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
 419 | # file names in lower-case letters. If set to YES upper-case letters are also
 420 | # allowed. This is useful if you have classes or files whose names only differ
 421 | # in case and if your file system supports case sensitive file names. Windows
 422 | # and Mac users are advised to set this option to NO.
 423 | 
 424 | CASE_SENSE_NAMES       = YES
 425 | 
 426 | # If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
 427 | # will show members with their full class and namespace scopes in the
 428 | # documentation. If set to YES the scope will be hidden.
 429 | 
 430 | HIDE_SCOPE_NAMES       = NO
 431 | 
 432 | # If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
 433 | # will put a list of the files that are included by a file in the documentation
 434 | # of that file.
 435 | 
 436 | SHOW_INCLUDE_FILES     = YES
 437 | 
 438 | # If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen
 439 | # will list include files with double quotes in the documentation
 440 | # rather than with sharp brackets.
 441 | 
 442 | FORCE_LOCAL_INCLUDES   = NO
 443 | 
 444 | # If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
 445 | # is inserted in the documentation for inline members.
 446 | 
 447 | INLINE_INFO            = YES
 448 | 
 449 | # If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
 450 | # will sort the (detailed) documentation of file and class members
 451 | # alphabetically by member name. If set to NO the members will appear in
 452 | # declaration order.
 453 | 
 454 | SORT_MEMBER_DOCS       = YES
 455 | 
 456 | # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
 457 | # brief documentation of file, namespace and class members alphabetically
 458 | # by member name. If set to NO (the default) the members will appear in
 459 | # declaration order.
 460 | 
 461 | SORT_BRIEF_DOCS        = NO
 462 | 
 463 | # If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen
 464 | # will sort the (brief and detailed) documentation of class members so that
 465 | # constructors and destructors are listed first. If set to NO (the default)
 466 | # the constructors will appear in the respective orders defined by
 467 | # SORT_MEMBER_DOCS and SORT_BRIEF_DOCS.
 468 | # This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO
 469 | # and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.
 470 | 
 471 | SORT_MEMBERS_CTORS_1ST = NO
 472 | 
 473 | # If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the
 474 | # hierarchy of group names into alphabetical order. If set to NO (the default)
 475 | # the group names will appear in their defined order.
 476 | 
 477 | SORT_GROUP_NAMES       = NO
 478 | 
 479 | # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
 480 | # sorted by fully-qualified names, including namespaces. If set to
 481 | # NO (the default), the class list will be sorted only by class name,
 482 | # not including the namespace part.
 483 | # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
 484 | # Note: This option applies only to the class list, not to the
 485 | # alphabetical list.
 486 | 
 487 | SORT_BY_SCOPE_NAME     = NO
 488 | 
 489 | # If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to
 490 | # do proper type resolution of all parameters of a function it will reject a
 491 | # match between the prototype and the implementation of a member function even
 492 | # if there is only one candidate or it is obvious which candidate to choose
 493 | # by doing a simple string match. By disabling STRICT_PROTO_MATCHING doxygen
 494 | # will still accept a match between prototype and implementation in such cases.
 495 | 
 496 | STRICT_PROTO_MATCHING  = NO
 497 | 
 498 | # The GENERATE_TODOLIST tag can be used to enable (YES) or
 499 | # disable (NO) the todo list. This list is created by putting \todo
 500 | # commands in the documentation.
 501 | 
 502 | GENERATE_TODOLIST      = YES
 503 | 
 504 | # The GENERATE_TESTLIST tag can be used to enable (YES) or
 505 | # disable (NO) the test list. This list is created by putting \test
 506 | # commands in the documentation.
 507 | 
 508 | GENERATE_TESTLIST      = YES
 509 | 
 510 | # The GENERATE_BUGLIST tag can be used to enable (YES) or
 511 | # disable (NO) the bug list. This list is created by putting \bug
 512 | # commands in the documentation.
 513 | 
 514 | GENERATE_BUGLIST       = YES
 515 | 
 516 | # The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
 517 | # disable (NO) the deprecated list. This list is created by putting
 518 | # \deprecated commands in the documentation.
 519 | 
 520 | GENERATE_DEPRECATEDLIST= YES
 521 | 
 522 | # The ENABLED_SECTIONS tag can be used to enable conditional
 523 | # documentation sections, marked by \if sectionname ... \endif.
 524 | 
 525 | ENABLED_SECTIONS       =
 526 | 
 527 | # The MAX_INITIALIZER_LINES tag determines the maximum number of lines
 528 | # the initial value of a variable or macro consists of for it to appear in
 529 | # the documentation. If the initializer consists of more lines than specified
 530 | # here it will be hidden. Use a value of 0 to hide initializers completely.
 531 | # The appearance of the initializer of individual variables and macros in the
 532 | # documentation can be controlled using \showinitializer or \hideinitializer
 533 | # command in the documentation regardless of this setting.
 534 | 
 535 | MAX_INITIALIZER_LINES  = 30
 536 | 
 537 | # Set the SHOW_USED_FILES tag to NO to disable the list of files generated
 538 | # at the bottom of the documentation of classes and structs. If set to YES the
 539 | # list will mention the files that were used to generate the documentation.
 540 | 
 541 | SHOW_USED_FILES        = YES
 542 | 
 543 | # If the sources in your project are distributed over multiple directories
 544 | # then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy
 545 | # in the documentation. The default is NO.
 546 | 
 547 | SHOW_DIRECTORIES       = NO
 548 | 
 549 | # Set the SHOW_FILES tag to NO to disable the generation of the Files page.
 550 | # This will remove the Files entry from the Quick Index and from the
 551 | # Folder Tree View (if specified). The default is YES.
 552 | 
 553 | SHOW_FILES             = YES
 554 | 
 555 | # Set the SHOW_NAMESPACES tag to NO to disable the generation of the
 556 | # Namespaces page.
 557 | # This will remove the Namespaces entry from the Quick Index
 558 | # and from the Folder Tree View (if specified). The default is YES.
 559 | 
 560 | SHOW_NAMESPACES        = YES
 561 | 
 562 | # The FILE_VERSION_FILTER tag can be used to specify a program or script that
 563 | # doxygen should invoke to get the current version for each file (typically from
 564 | # the version control system). Doxygen will invoke the program by executing (via
 565 | # popen()) the command <command> <input-file>, where <command> is the value of
 566 | # the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file
 567 | # provided by doxygen. Whatever the program writes to standard output
 568 | # is used as the file version. See the manual for examples.
 569 | 
 570 | FILE_VERSION_FILTER    =
 571 | 
 572 | # The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
 573 | # by doxygen. The layout file controls the global structure of the generated
 574 | # output files in an output format independent way. The create the layout file
 575 | # that represents doxygen's defaults, run doxygen with the -l option.
 576 | # You can optionally specify a file name after the option, if omitted
 577 | # DoxygenLayout.xml will be used as the name of the layout file.
 578 | 
 579 | LAYOUT_FILE            =
 580 | 
 581 | # The CITE_BIB_FILES tag can be used to specify one or more bib files
 582 | # containing the references data. This must be a list of .bib files. The
 583 | # .bib extension is automatically appended if omitted. Using this command
 584 | # requires the bibtex tool to be installed. See also
 585 | # http://en.wikipedia.org/wiki/BibTeX for more info. For LaTeX the style
 586 | # of the bibliography can be controlled using LATEX_BIB_STYLE. To use this
 587 | # feature you need bibtex and perl available in the search path.
 588 | 
 589 | CITE_BIB_FILES         =
 590 | 
 591 | #---------------------------------------------------------------------------
 592 | # configuration options related to warning and progress messages
 593 | #---------------------------------------------------------------------------
 594 | 
 595 | # The QUIET tag can be used to turn on/off the messages that are generated
 596 | # by doxygen. Possible values are YES and NO. If left blank NO is used.
 597 | 
 598 | QUIET                  = NO
 599 | 
 600 | # The WARNINGS tag can be used to turn on/off the warning messages that are
 601 | # generated by doxygen. Possible values are YES and NO. If left blank
 602 | # NO is used.
 603 | 
 604 | WARNINGS               = YES
 605 | 
 606 | # If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
 607 | # for undocumented members. If EXTRACT_ALL is set to YES then this flag will
 608 | # automatically be disabled.
 609 | 
 610 | WARN_IF_UNDOCUMENTED   = YES
 611 | 
 612 | # If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
 613 | # potential errors in the documentation, such as not documenting some
 614 | # parameters in a documented function, or documenting parameters that
 615 | # don't exist or using markup commands wrongly.
 616 | 
 617 | WARN_IF_DOC_ERROR      = YES
 618 | 
 619 | # The WARN_NO_PARAMDOC option can be enabled to get warnings for
 620 | # functions that are documented, but have no documentation for their parameters
 621 | # or return value. If set to NO (the default) doxygen will only warn about
 622 | # wrong or incomplete parameter documentation, but not about the absence of
 623 | # documentation.
 624 | 
 625 | WARN_NO_PARAMDOC       = NO
 626 | 
 627 | # The WARN_FORMAT tag determines the format of the warning messages that
 628 | # doxygen can produce. The string should contain the $file, $line, and $text
 629 | # tags, which will be replaced by the file and line number from which the
 630 | # warning originated and the warning text. Optionally the format may contain
 631 | # $version, which will be replaced by the version of the file (if it could
 632 | # be obtained via FILE_VERSION_FILTER)
 633 | 
 634 | WARN_FORMAT            = "$file:$line: $text"
 635 | 
 636 | # The WARN_LOGFILE tag can be used to specify a file to which warning
 637 | # and error messages should be written. If left blank the output is written
 638 | # to stderr.
 639 | 
 640 | WARN_LOGFILE           =
 641 | 
 642 | #---------------------------------------------------------------------------
 643 | # configuration options related to the input files
 644 | #---------------------------------------------------------------------------
 645 | 
 646 | # The INPUT tag can be used to specify the files and/or directories that contain
 647 | # documented source files. You may enter file names like "myfile.cpp" or
 648 | # directories like "/usr/src/myproject". Separate the files or directories
 649 | # with spaces.
 650 | 
 651 | INPUT                  = HaikuToDo
 652 | 
 653 | # This tag can be used to specify the character encoding of the source files
 654 | # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
 655 | # also the default input encoding. Doxygen uses libiconv (or the iconv built
 656 | # into libc) for the transcoding. See http://www.gnu.org/software/libiconv for
 657 | # the list of possible encodings.
 658 | 
 659 | INPUT_ENCODING         = UTF-8
 660 | 
 661 | # If the value of the INPUT tag contains directories, you can use the
 662 | # FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
 663 | # and *.h) to filter out the source-files in the directories. If left
 664 | # blank the following patterns are tested:
 665 | # *.c *.cc *.cxx *.cpp *.c++ *.d *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh
 666 | # *.hxx *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.dox *.py
 667 | # *.f90 *.f *.for *.vhd *.vhdl
 668 | 
 669 | FILE_PATTERNS          =
 670 | 
 671 | # The RECURSIVE tag can be used to turn specify whether or not subdirectories
 672 | # should be searched for input files as well. Possible values are YES and NO.
 673 | # If left blank NO is used.
 674 | 
 675 | RECURSIVE              = YES
 676 | 
 677 | # The EXCLUDE tag can be used to specify files and/or directories that should be
 678 | # excluded from the INPUT source files. This way you can easily exclude a
 679 | # subdirectory from a directory tree whose root is specified with the INPUT tag.
 680 | # Note that relative paths are relative to the directory from which doxygen is
 681 | # run.
 682 | 
 683 | EXCLUDE                =
 684 | 
 685 | # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
 686 | # directories that are symbolic links (a Unix file system feature) are excluded
 687 | # from the input.
 688 | 
 689 | EXCLUDE_SYMLINKS       = NO
 690 | 
 691 | # If the value of the INPUT tag contains directories, you can use the
 692 | # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
 693 | # certain files from those directories. Note that the wildcards are matched
 694 | # against the file with absolute path, so to exclude all test directories
 695 | # for example use the pattern */test/*
 696 | 
 697 | EXCLUDE_PATTERNS       =
 698 | 
 699 | # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
 700 | # (namespaces, classes, functions, etc.) that should be excluded from the
 701 | # output. The symbol name can be a fully qualified name, a word, or if the
 702 | # wildcard * is used, a substring. Examples: ANamespace, AClass,
 703 | # AClass::ANamespace, ANamespace::*Test
 704 | 
 705 | EXCLUDE_SYMBOLS        =
 706 | 
 707 | # The EXAMPLE_PATH tag can be used to specify one or more files or
 708 | # directories that contain example code fragments that are included (see
 709 | # the \include command).
 710 | 
 711 | EXAMPLE_PATH           =
 712 | 
 713 | # If the value of the EXAMPLE_PATH tag contains directories, you can use the
 714 | # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
 715 | # and *.h) to filter out the source-files in the directories. If left
 716 | # blank all files are included.
 717 | 
 718 | EXAMPLE_PATTERNS       =
 719 | 
 720 | # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
 721 | # searched for input files to be used with the \include or \dontinclude
 722 | # commands irrespective of the value of the RECURSIVE tag.
 723 | # Possible values are YES and NO. If left blank NO is used.
 724 | 
 725 | EXAMPLE_RECURSIVE      = NO
 726 | 
 727 | # The IMAGE_PATH tag can be used to specify one or more files or
 728 | # directories that contain image that are included in the documentation (see
 729 | # the \image command).
 730 | 
 731 | IMAGE_PATH             =
 732 | 
 733 | # The INPUT_FILTER tag can be used to specify a program that doxygen should
 734 | # invoke to filter for each input file. Doxygen will invoke the filter program
 735 | # by executing (via popen()) the command <filter> <input-file>, where <filter>
 736 | # is the value of the INPUT_FILTER tag, and <input-file> is the name of an
 737 | # input file. Doxygen will then use the output that the filter program writes
 738 | # to standard output.
 739 | # If FILTER_PATTERNS is specified, this tag will be
 740 | # ignored.
 741 | 
 742 | INPUT_FILTER           =
 743 | 
 744 | # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
 745 | # basis.
 746 | # Doxygen will compare the file name with each pattern and apply the
 747 | # filter if there is a match.
 748 | # The filters are a list of the form:
 749 | # pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
 750 | # info on how filters are used. If FILTER_PATTERNS is empty or if
 751 | # non of the patterns match the file name, INPUT_FILTER is applied.
 752 | 
 753 | FILTER_PATTERNS        =
 754 | 
 755 | # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
 756 | # INPUT_FILTER) will be used to filter the input files when producing source
 757 | # files to browse (i.e. when SOURCE_BROWSER is set to YES).
 758 | 
 759 | FILTER_SOURCE_FILES    = NO
 760 | 
 761 | # The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
 762 | # pattern. A pattern will override the setting for FILTER_PATTERN (if any)
 763 | # and it is also possible to disable source filtering for a specific pattern
 764 | # using *.ext= (so without naming a filter). This option only has effect when
 765 | # FILTER_SOURCE_FILES is enabled.
 766 | 
 767 | FILTER_SOURCE_PATTERNS =
 768 | 
 769 | #---------------------------------------------------------------------------
 770 | # configuration options related to source browsing
 771 | #---------------------------------------------------------------------------
 772 | 
 773 | # If the SOURCE_BROWSER tag is set to YES then a list of source files will
 774 | # be generated. Documented entities will be cross-referenced with these sources.
 775 | # Note: To get rid of all source code in the generated output, make sure also
 776 | # VERBATIM_HEADERS is set to NO.
 777 | 
 778 | SOURCE_BROWSER         = YES
 779 | 
 780 | # Setting the INLINE_SOURCES tag to YES will include the body
 781 | # of functions and classes directly in the documentation.
 782 | 
 783 | INLINE_SOURCES         = NO
 784 | 
 785 | # Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
 786 | # doxygen to hide any special comment blocks from generated source code
 787 | # fragments. Normal C and C++ comments will always remain visible.
 788 | 
 789 | STRIP_CODE_COMMENTS    = YES
 790 | 
 791 | # If the REFERENCED_BY_RELATION tag is set to YES
 792 | # then for each documented function all documented
 793 | # functions referencing it will be listed.
 794 | 
 795 | REFERENCED_BY_RELATION = NO
 796 | 
 797 | # If the REFERENCES_RELATION tag is set to YES
 798 | # then for each documented function all documented entities
 799 | # called/used by that function will be listed.
 800 | 
 801 | REFERENCES_RELATION    = NO
 802 | 
 803 | # If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
 804 | # and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
 805 | # functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
 806 | # link to the source code.
 807 | # Otherwise they will link to the documentation.
 808 | 
 809 | REFERENCES_LINK_SOURCE = YES
 810 | 
 811 | # If the USE_HTAGS tag is set to YES then the references to source code
 812 | # will point to the HTML generated by the htags(1) tool instead of doxygen
 813 | # built-in source browser. The htags tool is part of GNU's global source
 814 | # tagging system (see http://www.gnu.org/software/global/global.html). You
 815 | # will need version 4.8.6 or higher.
 816 | 
 817 | USE_HTAGS              = NO
 818 | 
 819 | # If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
 820 | # will generate a verbatim copy of the header file for each class for
 821 | # which an include is specified. Set to NO to disable this.
 822 | 
 823 | VERBATIM_HEADERS       = YES
 824 | 
 825 | #---------------------------------------------------------------------------
 826 | # configuration options related to the alphabetical class index
 827 | #---------------------------------------------------------------------------
 828 | 
 829 | # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
 830 | # of all compounds will be generated. Enable this if the project
 831 | # contains a lot of classes, structs, unions or interfaces.
 832 | 
 833 | ALPHABETICAL_INDEX     = YES
 834 | 
 835 | # If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
 836 | # the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
 837 | # in which this list will be split (can be a number in the range [1..20])
 838 | 
 839 | COLS_IN_ALPHA_INDEX    = 5
 840 | 
 841 | # In case all classes in a project start with a common prefix, all
 842 | # classes will be put under the same header in the alphabetical index.
 843 | # The IGNORE_PREFIX tag can be used to specify one or more prefixes that
 844 | # should be ignored while generating the index headers.
 845 | 
 846 | IGNORE_PREFIX          =
 847 | 
 848 | #---------------------------------------------------------------------------
 849 | # configuration options related to the HTML output
 850 | #---------------------------------------------------------------------------
 851 | 
 852 | # If the GENERATE_HTML tag is set to YES (the default) Doxygen will
 853 | # generate HTML output.
 854 | 
 855 | GENERATE_HTML          = YES
 856 | 
 857 | # The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
 858 | # If a relative path is entered the value of OUTPUT_DIRECTORY will be
 859 | # put in front of it. If left blank `html' will be used as the default path.
 860 | 
 861 | HTML_OUTPUT            = html
 862 | 
 863 | # The HTML_FILE_EXTENSION tag can be used to specify the file extension for
 864 | # each generated HTML page (for example: .htm,.php,.asp). If it is left blank
 865 | # doxygen will generate files with .html extension.
 866 | 
 867 | HTML_FILE_EXTENSION    = .html
 868 | 
 869 | # The HTML_HEADER tag can be used to specify a personal HTML header for
 870 | # each generated HTML page. If it is left blank doxygen will generate a
 871 | # standard header. Note that when using a custom header you are responsible
 872 | #  for the proper inclusion of any scripts and style sheets that doxygen
 873 | # needs, which is dependent on the configuration options used.
 874 | # It is advised to generate a default header using "doxygen -w html
 875 | # header.html footer.html stylesheet.css YourConfigFile" and then modify
 876 | # that header. Note that the header is subject to change so you typically
 877 | # have to redo this when upgrading to a newer version of doxygen or when
 878 | # changing the value of configuration settings such as GENERATE_TREEVIEW!
 879 | 
 880 | HTML_HEADER            =
 881 | 
 882 | # The HTML_FOOTER tag can be used to specify a personal HTML footer for
 883 | # each generated HTML page. If it is left blank doxygen will generate a
 884 | # standard footer.
 885 | 
 886 | HTML_FOOTER            =
 887 | 
 888 | # The HTML_STYLESHEET tag can be used to specify a user-defined cascading
 889 | # style sheet that is used by each HTML page. It can be used to
 890 | # fine-tune the look of the HTML output. If the tag is left blank doxygen
 891 | # will generate a default style sheet. Note that doxygen will try to copy
 892 | # the style sheet file to the HTML output directory, so don't put your own
 893 | # style sheet in the HTML output directory as well, or it will be erased!
 894 | 
 895 | HTML_STYLESHEET        =
 896 | 
 897 | # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
 898 | # other source files which should be copied to the HTML output directory. Note
 899 | # that these files will be copied to the base HTML output directory. Use the
 900 | # $relpath$ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
 901 | # files. In the HTML_STYLESHEET file, use the file name only. Also note that
 902 | # the files will be copied as-is; there are no commands or markers available.
 903 | 
 904 | HTML_EXTRA_FILES       =
 905 | 
 906 | # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output.
 907 | # Doxygen will adjust the colors in the style sheet and background images
 908 | # according to this color. Hue is specified as an angle on a colorwheel,
 909 | # see http://en.wikipedia.org/wiki/Hue for more information.
 910 | # For instance the value 0 represents red, 60 is yellow, 120 is green,
 911 | # 180 is cyan, 240 is blue, 300 purple, and 360 is red again.
 912 | # The allowed range is 0 to 359.
 913 | 
 914 | HTML_COLORSTYLE_HUE    = 220
 915 | 
 916 | # The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of
 917 | # the colors in the HTML output. For a value of 0 the output will use
 918 | # grayscales only. A value of 255 will produce the most vivid colors.
 919 | 
 920 | HTML_COLORSTYLE_SAT    = 100
 921 | 
 922 | # The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to
 923 | # the luminance component of the colors in the HTML output. Values below
 924 | # 100 gradually make the output lighter, whereas values above 100 make
 925 | # the output darker. The value divided by 100 is the actual gamma applied,
 926 | # so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2,
 927 | # and 100 does not change the gamma.
 928 | 
 929 | HTML_COLORSTYLE_GAMMA  = 80
 930 | 
 931 | # If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
 932 | # page will contain the date and time when the page was generated. Setting
 933 | # this to NO can help when comparing the output of multiple runs.
 934 | 
 935 | HTML_TIMESTAMP         = YES
 936 | 
 937 | # If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes,
 938 | # files or namespaces will be aligned in HTML using tables. If set to
 939 | # NO a bullet list will be used.
 940 | 
 941 | HTML_ALIGN_MEMBERS     = YES
 942 | 
 943 | # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
 944 | # documentation will contain sections that can be hidden and shown after the
 945 | # page has loaded. For this to work a browser that supports
 946 | # JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox
 947 | # Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).
 948 | 
 949 | HTML_DYNAMIC_SECTIONS  = NO
 950 | 
 951 | # If the GENERATE_DOCSET tag is set to YES, additional index files
 952 | # will be generated that can be used as input for Apple's Xcode 3
 953 | # integrated development environment, introduced with OSX 10.5 (Leopard).
 954 | # To create a documentation set, doxygen will generate a Makefile in the
 955 | # HTML output directory. Running make will produce the docset in that
 956 | # directory and running "make install" will install the docset in
 957 | # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
 958 | # it at startup.
 959 | # See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
 960 | # for more information.
 961 | 
 962 | GENERATE_DOCSET        = NO
 963 | 
 964 | # When GENERATE_DOCSET tag is set to YES, this tag determines the name of the
 965 | # feed. A documentation feed provides an umbrella under which multiple
 966 | # documentation sets from a single provider (such as a company or product suite)
 967 | # can be grouped.
 968 | 
 969 | DOCSET_FEEDNAME        = "Doxygen generated docs"
 970 | 
 971 | # When GENERATE_DOCSET tag is set to YES, this tag specifies a string that
 972 | # should uniquely identify the documentation set bundle. This should be a
 973 | # reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen
 974 | # will append .docset to the name.
 975 | 
 976 | DOCSET_BUNDLE_ID       = org.doxygen.Project
 977 | 
 978 | # When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely identify
 979 | # the documentation publisher. This should be a reverse domain-name style
 980 | # string, e.g. com.mycompany.MyDocSet.documentation.
 981 | 
 982 | DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
 983 | 
 984 | # The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.
 985 | 
 986 | DOCSET_PUBLISHER_NAME  = Publisher
 987 | 
 988 | # If the GENERATE_HTMLHELP tag is set to YES, additional index files
 989 | # will be generated that can be used as input for tools like the
 990 | # Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
 991 | # of the generated HTML documentation.
 992 | 
 993 | GENERATE_HTMLHELP      = NO
 994 | 
 995 | # If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
 996 | # be used to specify the file name of the resulting .chm file. You
 997 | # can add a path in front of the file if the result should not be
 998 | # written to the html output directory.
 999 | 
1000 | CHM_FILE               =
1001 | 
1002 | # If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
1003 | # be used to specify the location (absolute path including file name) of
1004 | # the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
1005 | # the HTML help compiler on the generated index.hhp.
1006 | 
1007 | HHC_LOCATION           =
1008 | 
1009 | # If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
1010 | # controls if a separate .chi index file is generated (YES) or that
1011 | # it should be included in the master .chm file (NO).
1012 | 
1013 | GENERATE_CHI           = NO
1014 | 
1015 | # If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING
1016 | # is used to encode HtmlHelp index (hhk), content (hhc) and project file
1017 | # content.
1018 | 
1019 | CHM_INDEX_ENCODING     =
1020 | 
1021 | # If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
1022 | # controls whether a binary table of contents is generated (YES) or a
1023 | # normal table of contents (NO) in the .chm file.
1024 | 
1025 | BINARY_TOC             = NO
1026 | 
1027 | # The TOC_EXPAND flag can be set to YES to add extra items for group members
1028 | # to the contents of the HTML help documentation and to the tree view.
1029 | 
1030 | TOC_EXPAND             = NO
1031 | 
1032 | # If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
1033 | # QHP_VIRTUAL_FOLDER are set, an additional index file will be generated
1034 | # that can be used as input for Qt's qhelpgenerator to generate a
1035 | # Qt Compressed Help (.qch) of the generated HTML documentation.
1036 | 
1037 | GENERATE_QHP           = NO
1038 | 
1039 | # If the QHG_LOCATION tag is specified, the QCH_FILE tag can
1040 | # be used to specify the file name of the resulting .qch file.
1041 | # The path specified is relative to the HTML output folder.
1042 | 
1043 | QCH_FILE               =
1044 | 
1045 | # The QHP_NAMESPACE tag specifies the namespace to use when generating
1046 | # Qt Help Project output. For more information please see
1047 | # http://doc.trolltech.com/qthelpproject.html#namespace
1048 | 
1049 | QHP_NAMESPACE          = org.doxygen.Project
1050 | 
1051 | # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
1052 | # Qt Help Project output. For more information please see
1053 | # http://doc.trolltech.com/qthelpproject.html#virtual-folders
1054 | 
1055 | QHP_VIRTUAL_FOLDER     = doc
1056 | 
1057 | # If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to
1058 | # add. For more information please see
1059 | # http://doc.trolltech.com/qthelpproject.html#custom-filters
1060 | 
1061 | QHP_CUST_FILTER_NAME   =
1062 | 
1063 | # The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the
1064 | # custom filter to add. For more information please see
1065 | # <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">
1066 | # Qt Help Project / Custom Filters</a>.
1067 | 
1068 | QHP_CUST_FILTER_ATTRS  =
1069 | 
1070 | # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
1071 | # project's
1072 | # filter section matches.
1073 | # <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">
1074 | # Qt Help Project / Filter Attributes</a>.
1075 | 
1076 | QHP_SECT_FILTER_ATTRS  =
1077 | 
1078 | # If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
1079 | # be used to specify the location of Qt's qhelpgenerator.
1080 | # If non-empty doxygen will try to run qhelpgenerator on the generated
1081 | # .qhp file.
1082 | 
1083 | QHG_LOCATION           =
1084 | 
1085 | # If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files
1086 | #  will be generated, which together with the HTML files, form an Eclipse help
1087 | # plugin. To install this plugin and make it available under the help contents
1088 | # menu in Eclipse, the contents of the directory containing the HTML and XML
1089 | # files needs to be copied into the plugins directory of eclipse. The name of
1090 | # the directory within the plugins directory should be the same as
1091 | # the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before
1092 | # the help appears.
1093 | 
1094 | GENERATE_ECLIPSEHELP   = NO
1095 | 
1096 | # A unique identifier for the eclipse help plugin. When installing the plugin
1097 | # the directory name containing the HTML and XML files should also have
1098 | # this name.
1099 | 
1100 | ECLIPSE_DOC_ID         = org.doxygen.Project
1101 | 
1102 | # The DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs)
1103 | # at top of each HTML page. The value NO (the default) enables the index and
1104 | # the value YES disables it. Since the tabs have the same information as the
1105 | # navigation tree you can set this option to NO if you already set
1106 | # GENERATE_TREEVIEW to YES.
1107 | 
1108 | DISABLE_INDEX          = NO
1109 | 
1110 | # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
1111 | # structure should be generated to display hierarchical information.
1112 | # If the tag value is set to YES, a side panel will be generated
1113 | # containing a tree-like index structure (just like the one that
1114 | # is generated for HTML Help). For this to work a browser that supports
1115 | # JavaScript, DHTML, CSS and frames is required (i.e. any modern browser).
1116 | # Windows users are probably better off using the HTML help feature.
1117 | # Since the tree basically has the same information as the tab index you
1118 | # could consider to set DISABLE_INDEX to NO when enabling this option.
1119 | 
1120 | GENERATE_TREEVIEW      = NO
1121 | 
1122 | # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values
1123 | # (range [0,1..20]) that doxygen will group on one line in the generated HTML
1124 | # documentation. Note that a value of 0 will completely suppress the enum
1125 | # values from appearing in the overview section.
1126 | 
1127 | ENUM_VALUES_PER_LINE   = 4
1128 | 
1129 | # By enabling USE_INLINE_TREES, doxygen will generate the Groups, Directories,
1130 | # and Class Hierarchy pages using a tree view instead of an ordered list.
1131 | 
1132 | USE_INLINE_TREES       = NO
1133 | 
1134 | # If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
1135 | # used to set the initial width (in pixels) of the frame in which the tree
1136 | # is shown.
1137 | 
1138 | TREEVIEW_WIDTH         = 250
1139 | 
1140 | # When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open
1141 | # links to external symbols imported via tag files in a separate window.
1142 | 
1143 | EXT_LINKS_IN_WINDOW    = NO
1144 | 
1145 | # Use this tag to change the font size of Latex formulas included
1146 | # as images in the HTML documentation. The default is 10. Note that
1147 | # when you change the font size after a successful doxygen run you need
1148 | # to manually remove any form_*.png images from the HTML output directory
1149 | # to force them to be regenerated.
1150 | 
1151 | FORMULA_FONTSIZE       = 10
1152 | 
1153 | # Use the FORMULA_TRANPARENT tag to determine whether or not the images
1154 | # generated for formulas are transparent PNGs. Transparent PNGs are
1155 | # not supported properly for IE 6.0, but are supported on all modern browsers.
1156 | # Note that when changing this option you need to delete any form_*.png files
1157 | # in the HTML output before the changes have effect.
1158 | 
1159 | FORMULA_TRANSPARENT    = YES
1160 | 
1161 | # Enable the USE_MATHJAX option to render LaTeX formulas using MathJax
1162 | # (see http://www.mathjax.org) which uses client side Javascript for the
1163 | # rendering instead of using prerendered bitmaps. Use this if you do not
1164 | # have LaTeX installed or if you want to formulas look prettier in the HTML
1165 | # output. When enabled you also need to install MathJax separately and
1166 | # configure the path to it using the MATHJAX_RELPATH option.
1167 | 
1168 | USE_MATHJAX            = NO
1169 | 
1170 | # When MathJax is enabled you need to specify the location relative to the
1171 | # HTML output directory using the MATHJAX_RELPATH option. The destination
1172 | # directory should contain the MathJax.js script. For instance, if the mathjax
1173 | # directory is located at the same level as the HTML output directory, then
1174 | # MATHJAX_RELPATH should be ../mathjax. The default value points to the
1175 | # mathjax.org site, so you can quickly see the result without installing
1176 | # MathJax, but it is strongly recommended to install a local copy of MathJax
1177 | # before deployment.
1178 | 
1179 | MATHJAX_RELPATH        = http://www.mathjax.org/mathjax
1180 | 
1181 | # The MATHJAX_EXTENSIONS tag can be used to specify one or MathJax extension
1182 | # names that should be enabled during MathJax rendering.
1183 | 
1184 | MATHJAX_EXTENSIONS     =
1185 | 
1186 | # When the SEARCHENGINE tag is enabled doxygen will generate a search box
1187 | # for the HTML output. The underlying search engine uses javascript
1188 | # and DHTML and should work on any modern browser. Note that when using
1189 | # HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
1190 | # (GENERATE_DOCSET) there is already a search function so this one should
1191 | # typically be disabled. For large projects the javascript based search engine
1192 | # can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
1193 | 
1194 | SEARCHENGINE           = YES
1195 | 
1196 | # When the SERVER_BASED_SEARCH tag is enabled the search engine will be
1197 | # implemented using a PHP enabled web server instead of at the web client
1198 | # using Javascript. Doxygen will generate the search PHP script and index
1199 | # file to put on the web server. The advantage of the server
1200 | # based approach is that it scales better to large projects and allows
1201 | # full text search. The disadvantages are that it is more difficult to setup
1202 | # and does not have live searching capabilities.
1203 | 
1204 | SERVER_BASED_SEARCH    = NO
1205 | 
1206 | #---------------------------------------------------------------------------
1207 | # configuration options related to the LaTeX output
1208 | #---------------------------------------------------------------------------
1209 | 
1210 | # If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
1211 | # generate Latex output.
1212 | 
1213 | GENERATE_LATEX         = NO
1214 | 
1215 | # The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
1216 | # If a relative path is entered the value of OUTPUT_DIRECTORY will be
1217 | # put in front of it. If left blank `latex' will be used as the default path.
1218 | 
1219 | LATEX_OUTPUT           = latex
1220 | 
1221 | # The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
1222 | # invoked. If left blank `latex' will be used as the default command name.
1223 | # Note that when enabling USE_PDFLATEX this option is only used for
1224 | # generating bitmaps for formulas in the HTML output, but not in the
1225 | # Makefile that is written to the output directory.
1226 | 
1227 | LATEX_CMD_NAME         = latex
1228 | 
1229 | # The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
1230 | # generate index for LaTeX. If left blank `makeindex' will be used as the
1231 | # default command name.
1232 | 
1233 | MAKEINDEX_CMD_NAME     = makeindex
1234 | 
1235 | # If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
1236 | # LaTeX documents. This may be useful for small projects and may help to
1237 | # save some trees in general.
1238 | 
1239 | COMPACT_LATEX          = NO
1240 | 
1241 | # The PAPER_TYPE tag can be used to set the paper type that is used
1242 | # by the printer. Possible values are: a4, letter, legal and
1243 | # executive. If left blank a4wide will be used.
1244 | 
1245 | PAPER_TYPE             = a4
1246 | 
1247 | # The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
1248 | # packages that should be included in the LaTeX output.
1249 | 
1250 | EXTRA_PACKAGES         =
1251 | 
1252 | # The LATEX_HEADER tag can be used to specify a personal LaTeX header for
1253 | # the generated latex document. The header should contain everything until
1254 | # the first chapter. If it is left blank doxygen will generate a
1255 | # standard header. Notice: only use this tag if you know what you are doing!
1256 | 
1257 | LATEX_HEADER           =
1258 | 
1259 | # The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for
1260 | # the generated latex document. The footer should contain everything after
1261 | # the last chapter. If it is left blank doxygen will generate a
1262 | # standard footer. Notice: only use this tag if you know what you are doing!
1263 | 
1264 | LATEX_FOOTER           =
1265 | 
1266 | # If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
1267 | # is prepared for conversion to pdf (using ps2pdf). The pdf file will
1268 | # contain links (just like the HTML output) instead of page references
1269 | # This makes the output suitable for online browsing using a pdf viewer.
1270 | 
1271 | PDF_HYPERLINKS         = YES
1272 | 
1273 | # If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
1274 | # plain latex in the generated Makefile. Set this option to YES to get a
1275 | # higher quality PDF documentation.
1276 | 
1277 | USE_PDFLATEX           = YES
1278 | 
1279 | # If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
1280 | # command to the generated LaTeX files. This will instruct LaTeX to keep
1281 | # running if errors occur, instead of asking the user for help.
1282 | # This option is also used when generating formulas in HTML.
1283 | 
1284 | LATEX_BATCHMODE        = NO
1285 | 
1286 | # If LATEX_HIDE_INDICES is set to YES then doxygen will not
1287 | # include the index chapters (such as File Index, Compound Index, etc.)
1288 | # in the output.
1289 | 
1290 | LATEX_HIDE_INDICES     = NO
1291 | 
1292 | # If LATEX_SOURCE_CODE is set to YES then doxygen will include
1293 | # source code with syntax highlighting in the LaTeX output.
1294 | # Note that which sources are shown also depends on other settings
1295 | # such as SOURCE_BROWSER.
1296 | 
1297 | LATEX_SOURCE_CODE      = NO
1298 | 
1299 | # The LATEX_BIB_STYLE tag can be used to specify the style to use for the
1300 | # bibliography, e.g. plainnat, or ieeetr. The default style is "plain". See
1301 | # http://en.wikipedia.org/wiki/BibTeX for more info.
1302 | 
1303 | LATEX_BIB_STYLE        = plain
1304 | 
1305 | #---------------------------------------------------------------------------
1306 | # configuration options related to the RTF output
1307 | #---------------------------------------------------------------------------
1308 | 
1309 | # If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
1310 | # The RTF output is optimized for Word 97 and may not look very pretty with
1311 | # other RTF readers or editors.
1312 | 
1313 | GENERATE_RTF           = NO
1314 | 
1315 | # The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
1316 | # If a relative path is entered the value of OUTPUT_DIRECTORY will be
1317 | # put in front of it. If left blank `rtf' will be used as the default path.
1318 | 
1319 | RTF_OUTPUT             = rtf
1320 | 
1321 | # If the COMPACT_RTF tag is set to YES Doxygen generates more compact
1322 | # RTF documents. This may be useful for small projects and may help to
1323 | # save some trees in general.
1324 | 
1325 | COMPACT_RTF            = NO
1326 | 
1327 | # If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
1328 | # will contain hyperlink fields. The RTF file will
1329 | # contain links (just like the HTML output) instead of page references.
1330 | # This makes the output suitable for online browsing using WORD or other
1331 | # programs which support those fields.
1332 | # Note: wordpad (write) and others do not support links.
1333 | 
1334 | RTF_HYPERLINKS         = NO
1335 | 
1336 | # Load style sheet definitions from file. Syntax is similar to doxygen's
1337 | # config file, i.e. a series of assignments. You only have to provide
1338 | # replacements, missing definitions are set to their default value.
1339 | 
1340 | RTF_STYLESHEET_FILE    =
1341 | 
1342 | # Set optional variables used in the generation of an rtf document.
1343 | # Syntax is similar to doxygen's config file.
1344 | 
1345 | RTF_EXTENSIONS_FILE    =
1346 | 
1347 | #---------------------------------------------------------------------------
1348 | # configuration options related to the man page output
1349 | #---------------------------------------------------------------------------
1350 | 
1351 | # If the GENERATE_MAN tag is set to YES (the default) Doxygen will
1352 | # generate man pages
1353 | 
1354 | GENERATE_MAN           = NO
1355 | 
1356 | # The MAN_OUTPUT tag is used to specify where the man pages will be put.
1357 | # If a relative path is entered the value of OUTPUT_DIRECTORY will be
1358 | # put in front of it. If left blank `man' will be used as the default path.
1359 | 
1360 | MAN_OUTPUT             = man
1361 | 
1362 | # The MAN_EXTENSION tag determines the extension that is added to
1363 | # the generated man pages (default is the subroutine's section .3)
1364 | 
1365 | MAN_EXTENSION          = .3
1366 | 
1367 | # If the MAN_LINKS tag is set to YES and Doxygen generates man output,
1368 | # then it will generate one additional man file for each entity
1369 | # documented in the real man page(s). These additional files
1370 | # only source the real man page, but without them the man command
1371 | # would be unable to find the correct page. The default is NO.
1372 | 
1373 | MAN_LINKS              = NO
1374 | 
1375 | #---------------------------------------------------------------------------
1376 | # configuration options related to the XML output
1377 | #---------------------------------------------------------------------------
1378 | 
1379 | # If the GENERATE_XML tag is set to YES Doxygen will
1380 | # generate an XML file that captures the structure of
1381 | # the code including all documentation.
1382 | 
1383 | GENERATE_XML           = NO
1384 | 
1385 | # The XML_OUTPUT tag is used to specify where the XML pages will be put.
1386 | # If a relative path is entered the value of OUTPUT_DIRECTORY will be
1387 | # put in front of it. If left blank `xml' will be used as the default path.
1388 | 
1389 | XML_OUTPUT             = xml
1390 | 
1391 | # The XML_SCHEMA tag can be used to specify an XML schema,
1392 | # which can be used by a validating XML parser to check the
1393 | # syntax of the XML files.
1394 | 
1395 | XML_SCHEMA             =
1396 | 
1397 | # The XML_DTD tag can be used to specify an XML DTD,
1398 | # which can be used by a validating XML parser to check the
1399 | # syntax of the XML files.
1400 | 
1401 | XML_DTD                =
1402 | 
1403 | # If the XML_PROGRAMLISTING tag is set to YES Doxygen will
1404 | # dump the program listings (including syntax highlighting
1405 | # and cross-referencing information) to the XML output. Note that
1406 | # enabling this will significantly increase the size of the XML output.
1407 | 
1408 | XML_PROGRAMLISTING     = YES
1409 | 
1410 | #---------------------------------------------------------------------------
1411 | # configuration options for the AutoGen Definitions output
1412 | #---------------------------------------------------------------------------
1413 | 
1414 | # If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
1415 | # generate an AutoGen Definitions (see autogen.sf.net) file
1416 | # that captures the structure of the code including all
1417 | # documentation. Note that this feature is still experimental
1418 | # and incomplete at the moment.
1419 | 
1420 | GENERATE_AUTOGEN_DEF   = NO
1421 | 
1422 | #---------------------------------------------------------------------------
1423 | # configuration options related to the Perl module output
1424 | #---------------------------------------------------------------------------
1425 | 
1426 | # If the GENERATE_PERLMOD tag is set to YES Doxygen will
1427 | # generate a Perl module file that captures the structure of
1428 | # the code including all documentation. Note that this
1429 | # feature is still experimental and incomplete at the
1430 | # moment.
1431 | 
1432 | GENERATE_PERLMOD       = NO
1433 | 
1434 | # If the PERLMOD_LATEX tag is set to YES Doxygen will generate
1435 | # the necessary Makefile rules, Perl scripts and LaTeX code to be able
1436 | # to generate PDF and DVI output from the Perl module output.
1437 | 
1438 | PERLMOD_LATEX          = NO
1439 | 
1440 | # If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
1441 | # nicely formatted so it can be parsed by a human reader.
1442 | # This is useful
1443 | # if you want to understand what is going on.
1444 | # On the other hand, if this
1445 | # tag is set to NO the size of the Perl module output will be much smaller
1446 | # and Perl will parse it just the same.
1447 | 
1448 | PERLMOD_PRETTY         = YES
1449 | 
1450 | # The names of the make variables in the generated doxyrules.make file
1451 | # are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
1452 | # This is useful so different doxyrules.make files included by the same
1453 | # Makefile don't overwrite each other's variables.
1454 | 
1455 | PERLMOD_MAKEVAR_PREFIX =
1456 | 
1457 | #---------------------------------------------------------------------------
1458 | # Configuration options related to the preprocessor
1459 | #---------------------------------------------------------------------------
1460 | 
1461 | # If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
1462 | # evaluate all C-preprocessor directives found in the sources and include
1463 | # files.
1464 | 
1465 | ENABLE_PREPROCESSING   = YES
1466 | 
1467 | # If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
1468 | # names in the source code. If set to NO (the default) only conditional
1469 | # compilation will be performed. Macro expansion can be done in a controlled
1470 | # way by setting EXPAND_ONLY_PREDEF to YES.
1471 | 
1472 | MACRO_EXPANSION        = NO
1473 | 
1474 | # If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
1475 | # then the macro expansion is limited to the macros specified with the
1476 | # PREDEFINED and EXPAND_AS_DEFINED tags.
1477 | 
1478 | EXPAND_ONLY_PREDEF     = NO
1479 | 
1480 | # If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
1481 | # pointed to by INCLUDE_PATH will be searched when a #include is found.
1482 | 
1483 | SEARCH_INCLUDES        = YES
1484 | 
1485 | # The INCLUDE_PATH tag can be used to specify one or more directories that
1486 | # contain include files that are not input files but should be processed by
1487 | # the preprocessor.
1488 | 
1489 | INCLUDE_PATH           =
1490 | 
1491 | # You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
1492 | # patterns (like *.h and *.hpp) to filter out the header-files in the
1493 | # directories. If left blank, the patterns specified with FILE_PATTERNS will
1494 | # be used.
1495 | 
1496 | INCLUDE_FILE_PATTERNS  =
1497 | 
1498 | # The PREDEFINED tag can be used to specify one or more macro names that
1499 | # are defined before the preprocessor is started (similar to the -D option of
1500 | # gcc). The argument of the tag is a list of macros of the form: name
1501 | # or name=definition (no spaces). If the definition and the = are
1502 | # omitted =1 is assumed. To prevent a macro definition from being
1503 | # undefined via #undef or recursively expanded use the := operator
1504 | # instead of the = operator.
1505 | 
1506 | PREDEFINED             =
1507 | 
1508 | # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
1509 | # this tag can be used to specify a list of macro names that should be expanded.
1510 | # The macro definition that is found in the sources will be used.
1511 | # Use the PREDEFINED tag if you want to use a different macro definition that
1512 | # overrules the definition found in the source code.
1513 | 
1514 | EXPAND_AS_DEFINED      =
1515 | 
1516 | # If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
1517 | # doxygen's preprocessor will remove all references to function-like macros
1518 | # that are alone on a line, have an all uppercase name, and do not end with a
1519 | # semicolon, because these will confuse the parser if not removed.
1520 | 
1521 | SKIP_FUNCTION_MACROS   = YES
1522 | 
1523 | #---------------------------------------------------------------------------
1524 | # Configuration::additions related to external references
1525 | #---------------------------------------------------------------------------
1526 | 
1527 | # The TAGFILES option can be used to specify one or more tagfiles.
1528 | # Optionally an initial location of the external documentation
1529 | # can be added for each tagfile. The format of a tag file without
1530 | # this location is as follows:
1531 | #
1532 | # TAGFILES = file1 file2 ...
1533 | # Adding location for the tag files is done as follows:
1534 | #
1535 | # TAGFILES = file1=loc1 "file2 = loc2" ...
1536 | # where "loc1" and "loc2" can be relative or absolute paths or
1537 | # URLs. If a location is present for each tag, the installdox tool
1538 | # does not have to be run to correct the links.
1539 | # Note that each tag file must have a unique name
1540 | # (where the name does NOT include the path)
1541 | # If a tag file is not located in the directory in which doxygen
1542 | # is run, you must also specify the path to the tagfile here.
1543 | 
1544 | TAGFILES               =
1545 | 
1546 | # When a file name is specified after GENERATE_TAGFILE, doxygen will create
1547 | # a tag file that is based on the input files it reads.
1548 | 
1549 | GENERATE_TAGFILE       =
1550 | 
1551 | # If the ALLEXTERNALS tag is set to YES all external classes will be listed
1552 | # in the class index. If set to NO only the inherited external classes
1553 | # will be listed.
1554 | 
1555 | ALLEXTERNALS           = NO
1556 | 
1557 | # If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
1558 | # in the modules index. If set to NO, only the current project's groups will
1559 | # be listed.
1560 | 
1561 | EXTERNAL_GROUPS        = YES
1562 | 
1563 | # The PERL_PATH should be the absolute path and name of the perl script
1564 | # interpreter (i.e. the result of `which perl').
1565 | 
1566 | PERL_PATH              = /usr/bin/perl
1567 | 
1568 | #---------------------------------------------------------------------------
1569 | # Configuration options related to the dot tool
1570 | #---------------------------------------------------------------------------
1571 | 
1572 | # If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
1573 | # generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
1574 | # or super classes. Setting the tag to NO turns the diagrams off. Note that
1575 | # this option also works with HAVE_DOT disabled, but it is recommended to
1576 | # install and use dot, since it yields more powerful graphs.
1577 | 
1578 | CLASS_DIAGRAMS         = YES
1579 | 
1580 | # You can define message sequence charts within doxygen comments using the \msc
1581 | # command. Doxygen will then run the mscgen tool (see
1582 | # http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the
1583 | # documentation. The MSCGEN_PATH tag allows you to specify the directory where
1584 | # the mscgen tool resides. If left empty the tool is assumed to be found in the
1585 | # default search path.
1586 | 
1587 | MSCGEN_PATH            =
1588 | 
1589 | # If set to YES, the inheritance and collaboration graphs will hide
1590 | # inheritance and usage relations if the target is undocumented
1591 | # or is not a class.
1592 | 
1593 | HIDE_UNDOC_RELATIONS   = YES
1594 | 
1595 | # If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
1596 | # available from the path. This tool is part of Graphviz, a graph visualization
1597 | # toolkit from AT&T and Lucent Bell Labs. The other options in this section
1598 | # have no effect if this option is set to NO (the default)
1599 | 
1600 | HAVE_DOT               = NO
1601 | 
1602 | # The DOT_NUM_THREADS specifies the number of dot invocations doxygen is
1603 | # allowed to run in parallel. When set to 0 (the default) doxygen will
1604 | # base this on the number of processors available in the system. You can set it
1605 | # explicitly to a value larger than 0 to get control over the balance
1606 | # between CPU load and processing speed.
1607 | 
1608 | DOT_NUM_THREADS        = 0
1609 | 
1610 | # By default doxygen will use the Helvetica font for all dot files that
1611 | # doxygen generates. When you want a differently looking font you can specify
1612 | # the font name using DOT_FONTNAME. You need to make sure dot is able to find
1613 | # the font, which can be done by putting it in a standard location or by setting
1614 | # the DOTFONTPATH environment variable or by setting DOT_FONTPATH to the
1615 | # directory containing the font.
1616 | 
1617 | DOT_FONTNAME           = Helvetica
1618 | 
1619 | # The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs.
1620 | # The default size is 10pt.
1621 | 
1622 | DOT_FONTSIZE           = 10
1623 | 
1624 | # By default doxygen will tell dot to use the Helvetica font.
1625 | # If you specify a different font using DOT_FONTNAME you can use DOT_FONTPATH to
1626 | # set the path where dot can find it.
1627 | 
1628 | DOT_FONTPATH           =
1629 | 
1630 | # If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
1631 | # will generate a graph for each documented class showing the direct and
1632 | # indirect inheritance relations. Setting this tag to YES will force the
1633 | # CLASS_DIAGRAMS tag to NO.
1634 | 
1635 | CLASS_GRAPH            = YES
1636 | 
1637 | # If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
1638 | # will generate a graph for each documented class showing the direct and
1639 | # indirect implementation dependencies (inheritance, containment, and
1640 | # class references variables) of the class with other documented classes.
1641 | 
1642 | COLLABORATION_GRAPH    = YES
1643 | 
1644 | # If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
1645 | # will generate a graph for groups, showing the direct groups dependencies
1646 | 
1647 | GROUP_GRAPHS           = YES
1648 | 
1649 | # If the UML_LOOK tag is set to YES doxygen will generate inheritance and
1650 | # collaboration diagrams in a style similar to the OMG's Unified Modeling
1651 | # Language.
1652 | 
1653 | UML_LOOK               = NO
1654 | 
1655 | # If set to YES, the inheritance and collaboration graphs will show the
1656 | # relations between templates and their instances.
1657 | 
1658 | TEMPLATE_RELATIONS     = NO
1659 | 
1660 | # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
1661 | # tags are set to YES then doxygen will generate a graph for each documented
1662 | # file showing the direct and indirect include dependencies of the file with
1663 | # other documented files.
1664 | 
1665 | INCLUDE_GRAPH          = YES
1666 | 
1667 | # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
1668 | # HAVE_DOT tags are set to YES then doxygen will generate a graph for each
1669 | # documented header file showing the documented files that directly or
1670 | # indirectly include this file.
1671 | 
1672 | INCLUDED_BY_GRAPH      = YES
1673 | 
1674 | # If the CALL_GRAPH and HAVE_DOT options are set to YES then
1675 | # doxygen will generate a call dependency graph for every global function
1676 | # or class method. Note that enabling this option will significantly increase
1677 | # the time of a run. So in most cases it will be better to enable call graphs
1678 | # for selected functions only using the \callgraph command.
1679 | 
1680 | CALL_GRAPH             = NO
1681 | 
1682 | # If the CALLER_GRAPH and HAVE_DOT tags are set to YES then
1683 | # doxygen will generate a caller dependency graph for every global function
1684 | # or class method. Note that enabling this option will significantly increase
1685 | # the time of a run. So in most cases it will be better to enable caller
1686 | # graphs for selected functions only using the \callergraph command.
1687 | 
1688 | CALLER_GRAPH           = NO
1689 | 
1690 | # If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
1691 | # will generate a graphical hierarchy of all classes instead of a textual one.
1692 | 
1693 | GRAPHICAL_HIERARCHY    = YES
1694 | 
1695 | # If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES
1696 | # then doxygen will show the dependencies a directory has on other directories
1697 | # in a graphical way. The dependency relations are determined by the #include
1698 | # relations between the files in the directories.
1699 | 
1700 | DIRECTORY_GRAPH        = YES
1701 | 
1702 | # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
1703 | # generated by dot. Possible values are svg, png, jpg, or gif.
1704 | # If left blank png will be used. If you choose svg you need to set
1705 | # HTML_FILE_EXTENSION to xhtml in order to make the SVG files
1706 | # visible in IE 9+ (other browsers do not have this requirement).
1707 | 
1708 | DOT_IMAGE_FORMAT       = png
1709 | 
1710 | # If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
1711 | # enable generation of interactive SVG images that allow zooming and panning.
1712 | # Note that this requires a modern browser other than Internet Explorer.
1713 | # Tested and working are Firefox, Chrome, Safari, and Opera. For IE 9+ you
1714 | # need to set HTML_FILE_EXTENSION to xhtml in order to make the SVG files
1715 | # visible. Older versions of IE do not have SVG support.
1716 | 
1717 | INTERACTIVE_SVG        = NO
1718 | 
1719 | # The tag DOT_PATH can be used to specify the path where the dot tool can be
1720 | # found. If left blank, it is assumed the dot tool can be found in the path.
1721 | 
1722 | DOT_PATH               =
1723 | 
1724 | # The DOTFILE_DIRS tag can be used to specify one or more directories that
1725 | # contain dot files that are included in the documentation (see the
1726 | # \dotfile command).
1727 | 
1728 | DOTFILE_DIRS           =
1729 | 
1730 | # The MSCFILE_DIRS tag can be used to specify one or more directories that
1731 | # contain msc files that are included in the documentation (see the
1732 | # \mscfile command).
1733 | 
1734 | MSCFILE_DIRS           =
1735 | 
1736 | # The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
1737 | # nodes that will be shown in the graph. If the number of nodes in a graph
1738 | # becomes larger than this value, doxygen will truncate the graph, which is
1739 | # visualized by representing a node as a red box. Note that doxygen if the
1740 | # number of direct children of the root node in a graph is already larger than
1741 | # DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
1742 | # that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
1743 | 
1744 | DOT_GRAPH_MAX_NODES    = 50
1745 | 
1746 | # The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
1747 | # graphs generated by dot. A depth value of 3 means that only nodes reachable
1748 | # from the root by following a path via at most 3 edges will be shown. Nodes
1749 | # that lay further from the root node will be omitted. Note that setting this
1750 | # option to 1 or 2 may greatly reduce the computation time needed for large
1751 | # code bases. Also note that the size of a graph can be further restricted by
1752 | # DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
1753 | 
1754 | MAX_DOT_GRAPH_DEPTH    = 0
1755 | 
1756 | # Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
1757 | # background. This is disabled by default, because dot on Windows does not
1758 | # seem to support this out of the box. Warning: Depending on the platform used,
1759 | # enabling this option may lead to badly anti-aliased labels on the edges of
1760 | # a graph (i.e. they become hard to read).
1761 | 
1762 | DOT_TRANSPARENT        = NO
1763 | 
1764 | # Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
1765 | # files in one run (i.e. multiple -o and -T options on the command line). This
1766 | # makes dot run faster, but since only newer versions of dot (>1.8.10)
1767 | # support this, this feature is disabled by default.
1768 | 
1769 | DOT_MULTI_TARGETS      = NO
1770 | 
1771 | # If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
1772 | # generate a legend page explaining the meaning of the various boxes and
1773 | # arrows in the dot generated graphs.
1774 | 
1775 | GENERATE_LEGEND        = YES
1776 | 
1777 | # If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
1778 | # remove the intermediate dot files that are used to generate
1779 | # the various graphs.
1780 | 
1781 | DOT_CLEANUP            = YES
1782 | 


--------------------------------------------------------------------------------