efl

1
#ifdef HAVE_CONFIG_H
2
# include <config.h>
3
#endif
4

5
#include "eldbus_model_private.h"
6

7
#include <Ecore.h>
8
#include <Eina.h>
9
#include <Eldbus.h>
10

11
#define MY_CLASS ELDBUS_MODEL_CLASS
12
#define MY_CLASS_NAME "Eldbus_Model"
13

14
static void
15
eldbus_model_connect_do(Eldbus_Model_Data *pd)
16
{
17
   if (pd->type == ELDBUS_CONNECTION_TYPE_ADDRESS)
18
     {
19
        if (pd->private)
20
          pd->connection = eldbus_address_connection_get(pd->address);
21
        else
22
          pd->connection = eldbus_private_address_connection_get(pd->address);
23
     }
24
   else
25
     {
26
        if (pd->private)
27
          pd->connection = eldbus_private_connection_get(pd->type);
28
        else
29
          pd->connection = eldbus_connection_get(pd->type);
30
     }
31

32
   // TODO: Register for disconnection event
33
   if (!pd->connection)
34
     {
35
        DBG("Unable to setup a connection [%i - %s] %i",
36
            pd->type, pd->address, pd->private);
37
     }
38
}
39

40
static void
41
_eldbus_model_connect(Eo *obj EINA_UNUSED,
42
                      Eldbus_Model_Data *pd,
43
                      Eldbus_Connection_Type type,
44
                      const char *address,
45
                      Eina_Bool priv)
46
{
47
   pd->type = type;
48
   pd->address = eina_stringshare_add(address);
49
   pd->private = priv;
50
}
51

52
static void
53
_eldbus_model_connection_set(Eo *obj EINA_UNUSED,
54
                             Eldbus_Model_Data *pd,
55
                             Eldbus_Connection *dbus)
56
{
57
   Eldbus_Connection *tounref = pd->connection;
58

59
   eldbus_connection_ref(dbus);
60
   pd->connection = NULL;
61
   if (tounref) eldbus_connection_unref(tounref);
62
   pd->connection = dbus;
63
}
64

65
static Eldbus_Connection *
66
_eldbus_model_connection_get(const Eo *obj EINA_UNUSED, Eldbus_Model_Data *pd)
67
{
68
   return pd->connection;
69
}
70

71
static Efl_Object *
72
_eldbus_model_efl_object_finalize(Eo *obj, Eldbus_Model_Data *pd)
73
{
74
   if (!pd->connection) eldbus_model_connect_do(pd);
75
   if (!pd->connection) return NULL;
76

77
   return efl_finalize(efl_super(obj, ELDBUS_MODEL_CLASS));
78
}
79

80
static void
81
_eldbus_model_efl_object_invalidate(Eo *obj, Eldbus_Model_Data *pd)
82
{
83
   Eldbus_Connection *connection = pd->connection;
84

85
   pd->connection = NULL;
86
   if (connection) eldbus_connection_unref(connection);
87

88
   efl_invalidate(efl_super(obj, MY_CLASS));
89
}
90

91
static void
92
_eldbus_model_efl_object_destructor(Eo *obj, Eldbus_Model_Data *pd)
93
{
94
   eina_stringshare_del(pd->unique_name);
95
   pd->unique_name = NULL;
96

97
   eina_stringshare_del(pd->address);
98
   pd->address = NULL;
99

100
   efl_destructor(efl_super(obj, MY_CLASS));
101
}
102

103
static const char *
104
_eldbus_model_address_get(const Eo *obj EINA_UNUSED, Eldbus_Model_Data *pd)
105
{
106
   return pd->address;
107
}
108

109
static Eina_Bool
110
_eldbus_model_private_get(const Eo *obj EINA_UNUSED, Eldbus_Model_Data *pd)
111
{
112
   return pd->private;
113
}
114

115
static Eldbus_Connection_Type
116
_eldbus_model_type_get(const Eo *obj EINA_UNUSED, Eldbus_Model_Data *pd)
117
{
118
   return pd->type;
119
}
120

121
static Eina_Future *
122
_eldbus_model_efl_model_property_set(Eo *obj,
123
                                     Eldbus_Model_Data *pd EINA_UNUSED,
124
                                     const char *property,
125
                                     Eina_Value *value EINA_UNUSED)
126
{
127
   Eina_Error err = EFL_MODEL_ERROR_READ_ONLY;
128

129
   if (!eina_streq(property, UNIQUE_NAME_PROPERTY))
130
     err = EFL_MODEL_ERROR_NOT_FOUND;
131
   return efl_loop_future_rejected(obj, err);
132
}
133

134
static Eina_Value *
135
_eldbus_model_efl_model_property_get(const Eo *obj,
136
                                     Eldbus_Model_Data *pd,
137
                                     const char *property)
138
{
139
   DBG("(%p): property=%s", obj, property);
140

141
   if (!eina_streq(property, UNIQUE_NAME_PROPERTY)) goto on_error;
142

143
   if (!pd->connection) eldbus_model_connect_do(pd);
144

145
   if (pd->unique_name == NULL)
146
     {
147
        const char *unique_name;
148

149
        unique_name = eldbus_connection_unique_name_get(pd->connection);
150
        if (!unique_name) goto on_error;
151
        pd->unique_name = eina_stringshare_add(unique_name);
152
     }
153

154
   return eina_value_string_new(pd->unique_name);
155

156
 on_error:
157
   return eina_value_error_new(EFL_MODEL_ERROR_NOT_FOUND);
158
}
159

160
static Eina_Iterator *
161
_eldbus_model_efl_model_properties_get(const Eo *obj EINA_UNUSED,
162
                                       Eldbus_Model_Data *pd EINA_UNUSED)
163
{
164
   char *unique[] = { UNIQUE_NAME_PROPERTY };
165

166
   return EINA_C_ARRAY_ITERATOR_NEW(unique);
167
}
168

169
static Efl_Object *
170
_eldbus_model_efl_model_child_add(Eo *obj EINA_UNUSED,
171
                                  Eldbus_Model_Data *pd EINA_UNUSED)
172
{
173
   return NULL;
174
}
175

176
static void
177
_eldbus_model_efl_model_child_del(Eo *obj EINA_UNUSED,
178
                                  Eldbus_Model_Data *pd EINA_UNUSED,
179
                                  Efl_Object *child EINA_UNUSED)
180
{
181
}
182

183
static Eina_Future *
184
_eldbus_model_efl_model_children_slice_get(Eo *obj EINA_UNUSED,
185
                                           Eldbus_Model_Data *pd EINA_UNUSED,
186
                                           unsigned int start EINA_UNUSED,
187
                                           unsigned int count EINA_UNUSED)
188
{
189
   return efl_loop_future_rejected(obj,
190
                               EFL_MODEL_ERROR_NOT_SUPPORTED);
191
}
192

193
static unsigned int
194
_eldbus_model_efl_model_children_count_get(const Eo *obj EINA_UNUSED,
195
                                           Eldbus_Model_Data *pd EINA_UNUSED)
196
{
197
   return 0;
198
}
199

200
#include "eldbus_model.eo.c"
201