1 /* gtd-storage.h
2  *
3  * Copyright (C) 2015-2020 Georges Basile Stavracas Neto <georges.stavracas@gmail.com>
4  *
5  * This program is free software: you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation, either version 3 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
17  */
18 
19 #ifndef GTD_PROVIDER_H
20 #define GTD_PROVIDER_H
21 
22 #include "gtd-object.h"
23 #include "gtd-types.h"
24 
25 #include <gio/gio.h>
26 #include <glib.h>
27 
28 G_BEGIN_DECLS
29 
30 #define GTD_TYPE_PROVIDER (gtd_provider_get_type ())
31 
32 G_DECLARE_INTERFACE (GtdProvider, gtd_provider, GTD, PROVIDER, GtdObject)
33 
34 struct _GtdProviderInterface
35 {
36   GTypeInterface parent;
37 
38   /* Information */
39   const gchar*       (*get_id)                                   (GtdProvider        *provider);
40 
41   const gchar*       (*get_name)                                 (GtdProvider        *provider);
42 
43   const gchar*       (*get_provider_type)                        (GtdProvider        *provider);
44 
45   const gchar*       (*get_description)                          (GtdProvider        *provider);
46 
47   gboolean           (*get_enabled)                              (GtdProvider        *provider);
48 
49   void               (*refresh)                                  (GtdProvider        *provider);
50 
51   /* Customs */
52   GIcon*             (*get_icon)                                 (GtdProvider        *provider);
53 
54   /* Tasks */
55   void               (*create_task)                              (GtdProvider        *provider,
56                                                                   GtdTaskList        *list,
57                                                                   const gchar        *title,
58                                                                   GDateTime          *due_date,
59                                                                   GCancellable       *cancellable,
60                                                                   GAsyncReadyCallback callback,
61                                                                   gpointer            user_data);
62 
63   GtdTask*           (*create_task_finish)                       (GtdProvider        *self,
64                                                                   GAsyncResult       *result,
65                                                                   GError            **error);
66 
67   void               (*update_task)                              (GtdProvider        *provider,
68                                                                   GtdTask            *task,
69                                                                   GCancellable       *cancellable,
70                                                                   GAsyncReadyCallback callback,
71                                                                   gpointer            user_data);
72 
73   gboolean           (*update_task_finish)                       (GtdProvider        *self,
74                                                                   GAsyncResult       *result,
75                                                                   GError            **error);
76 
77   void               (*remove_task)                              (GtdProvider        *provider,
78                                                                   GtdTask            *task,
79                                                                   GCancellable       *cancellable,
80                                                                   GAsyncReadyCallback callback,
81                                                                   gpointer            user_data);
82 
83   gboolean           (*remove_task_finish)                       (GtdProvider        *self,
84                                                                   GAsyncResult       *result,
85                                                                   GError            **error);
86 
87   /* Task lists */
88   void               (*create_task_list)                         (GtdProvider        *provider,
89                                                                   const gchar        *name,
90                                                                   GCancellable       *cancellable,
91                                                                   GAsyncReadyCallback callback,
92                                                                   gpointer            user_data);
93 
94   gboolean           (*create_task_list_finish)                  (GtdProvider        *self,
95                                                                   GAsyncResult       *result,
96                                                                   GError            **error);
97 
98   void               (*update_task_list)                         (GtdProvider        *provider,
99                                                                   GtdTaskList        *list,
100                                                                   GCancellable       *cancellable,
101                                                                   GAsyncReadyCallback callback,
102                                                                   gpointer            user_data);
103 
104   gboolean           (*update_task_list_finish)                  (GtdProvider        *self,
105                                                                   GAsyncResult       *result,
106                                                                   GError            **error);
107 
108   void               (*remove_task_list)                         (GtdProvider        *provider,
109                                                                   GtdTaskList        *list,
110                                                                   GCancellable       *cancellable,
111                                                                   GAsyncReadyCallback callback,
112                                                                   gpointer            user_data);
113 
114   gboolean           (*remove_task_list_finish)                  (GtdProvider        *self,
115                                                                   GAsyncResult       *result,
116                                                                   GError            **error);
117 
118   GList*             (*get_task_lists)                           (GtdProvider        *provider);
119 
120   GtdTaskList*       (*get_inbox)                                (GtdProvider        *provider);
121 };
122 
123 const gchar*         gtd_provider_get_id                         (GtdProvider        *provider);
124 
125 const gchar*         gtd_provider_get_name                       (GtdProvider        *provider);
126 
127 const gchar*         gtd_provider_get_provider_type              (GtdProvider        *provider);
128 
129 const gchar*         gtd_provider_get_description                (GtdProvider        *provider);
130 
131 gboolean             gtd_provider_get_enabled                    (GtdProvider        *provider);
132 
133 void                 gtd_provider_refresh                        (GtdProvider        *provider);
134 
135 GIcon*               gtd_provider_get_icon                       (GtdProvider        *provider);
136 
137 void                 gtd_provider_create_task                    (GtdProvider        *provider,
138                                                                   GtdTaskList        *list,
139                                                                   const gchar        *title,
140                                                                   GDateTime          *due_date,
141                                                                   GCancellable       *cancellable,
142                                                                   GAsyncReadyCallback callback,
143                                                                   gpointer            user_data);
144 
145 GtdTask*             gtd_provider_create_task_finish             (GtdProvider        *self,
146                                                                   GAsyncResult       *result,
147                                                                   GError            **error);
148 
149 void                 gtd_provider_update_task                    (GtdProvider        *provider,
150                                                                   GtdTask            *task,
151                                                                   GCancellable       *cancellable,
152                                                                   GAsyncReadyCallback callback,
153                                                                   gpointer            user_data);
154 
155 gboolean             gtd_provider_update_task_finish             (GtdProvider        *self,
156                                                                   GAsyncResult       *result,
157                                                                   GError            **error);
158 
159 void                 gtd_provider_remove_task                    (GtdProvider        *provider,
160                                                                   GtdTask            *task,
161                                                                   GCancellable       *cancellable,
162                                                                   GAsyncReadyCallback callback,
163                                                                   gpointer            user_data);
164 
165 gboolean             gtd_provider_remove_task_finish             (GtdProvider        *self,
166                                                                   GAsyncResult       *result,
167                                                                   GError            **error);
168 
169 void                 gtd_provider_create_task_list               (GtdProvider        *provider,
170                                                                   const gchar        *name,
171                                                                   GCancellable       *cancellable,
172                                                                   GAsyncReadyCallback callback,
173                                                                   gpointer            user_data);
174 
175 gboolean             gtd_provider_create_task_list_finish        (GtdProvider        *self,
176                                                                   GAsyncResult       *result,
177                                                                   GError            **error);
178 
179 void                 gtd_provider_update_task_list               (GtdProvider        *provider,
180                                                                   GtdTaskList        *list,
181                                                                   GCancellable       *cancellable,
182                                                                   GAsyncReadyCallback callback,
183                                                                   gpointer            user_data);
184 
185 gboolean             gtd_provider_update_task_list_finish        (GtdProvider        *self,
186                                                                   GAsyncResult       *result,
187                                                                   GError            **error);
188 
189 void                 gtd_provider_remove_task_list               (GtdProvider        *provider,
190                                                                   GtdTaskList        *list,
191                                                                   GCancellable       *cancellable,
192                                                                   GAsyncReadyCallback callback,
193                                                                   gpointer            user_data);
194 
195 gboolean             gtd_provider_remove_task_list_finish        (GtdProvider        *self,
196                                                                   GAsyncResult       *result,
197                                                                   GError            **error);
198 
199 GList*               gtd_provider_get_task_lists                 (GtdProvider        *provider);
200 
201 GtdTaskList*         gtd_provider_get_inbox                      (GtdProvider        *provider);
202 
203 gint                 gtd_provider_compare                        (GtdProvider        *a,
204                                                                   GtdProvider        *b);
205 
206 G_END_DECLS
207 
208 #endif /* GTD_PROVIDER_H */
209