1#include "fastfetch.h"
2#include "common/settings.h"
3#include "common/library.h"
4#include "common/thread.h"
5#include "common/io.h"
6#include "common/debug.h"
7
8#include <string.h>
9
10#ifdef FF_HAVE_GIO
11 #include <gio/gio.h>
12
13typedef struct GVariantGetters {
14 FF_LIBRARY_SYMBOL(g_variant_dup_string)
15 FF_LIBRARY_SYMBOL(g_variant_get_boolean)
16 FF_LIBRARY_SYMBOL(g_variant_get_int32)
17 FF_LIBRARY_SYMBOL(g_variant_unref)
18} GVariantGetters;
19
20static FFvariant getGVariantValue(GVariant* variant, FFvarianttype type, const GVariantGetters* variantGetters) {
21 FFvariant result;
22
23 if (variant == nullptr) {
24 result = FF_VARIANT_NULL;
25 } else if (type == FF_VARIANT_TYPE_STRING) {
26 result = (FFvariant) { .strValue = variantGetters->ffg_variant_dup_string(variant, nullptr) }; // Dup string, so that variant itself can be freed
27 } else if (type == FF_VARIANT_TYPE_BOOL) {
28 result = (FFvariant) { .boolValue = (bool) variantGetters->ffg_variant_get_boolean(variant), .boolValueSet = true };
29 } else if (type == FF_VARIANT_TYPE_INT) {
30 result = (FFvariant) { .intValue = variantGetters->ffg_variant_get_int32(variant) };
31 } else {
32 result = FF_VARIANT_NULL;
33 }
34
35 if (variant) {
36 variantGetters->ffg_variant_unref(variant);
37 }
38
39 return result;
40}
41
42typedef struct GSettingsData {
43 FF_LIBRARY_SYMBOL(g_settings_schema_source_lookup)
44 FF_LIBRARY_SYMBOL(g_settings_schema_has_key)
45 FF_LIBRARY_SYMBOL(g_settings_new_full)
46 FF_LIBRARY_SYMBOL(g_settings_get_value)
47 FF_LIBRARY_SYMBOL(g_settings_get_user_value)
48 FF_LIBRARY_SYMBOL(g_settings_get_default_value)
49 FF_LIBRARY_SYMBOL(g_settings_schema_source_get_default)
50 GSettingsSchemaSource* schemaSource;
51 GVariantGetters variantGetters;
52
53 bool inited;
54} GSettingsData;
55
56static const GSettingsData* getGSettingsData(void) {
57 static GSettingsData data;
58
59 if (!data.inited) {
60 data.inited = true;
61 FF_LIBRARY_LOAD(libgsettings, nullptr, "libgio-2.0" FF_LIBRARY_EXTENSION, 1);
62 FF_LIBRARY_LOAD_SYMBOL_VAR(libgsettings, data, g_settings_schema_source_lookup, nullptr)
63 FF_LIBRARY_LOAD_SYMBOL_VAR(libgsettings, data, g_settings_schema_has_key, nullptr)
64 FF_LIBRARY_LOAD_SYMBOL_VAR(libgsettings, data, g_settings_new_full, nullptr)
65 FF_LIBRARY_LOAD_SYMBOL_VAR(libgsettings, data, g_settings_get_value, nullptr)
66 FF_LIBRARY_LOAD_SYMBOL_VAR(libgsettings, data, g_settings_get_user_value, nullptr)
67 FF_LIBRARY_LOAD_SYMBOL_VAR(libgsettings, data, g_settings_get_default_value, nullptr)
68 FF_LIBRARY_LOAD_SYMBOL_VAR(libgsettings, data, g_settings_schema_source_get_default, nullptr)
69
70 FF_LIBRARY_LOAD_SYMBOL_VAR(libgsettings, data.variantGetters, g_variant_dup_string, nullptr)
71 FF_LIBRARY_LOAD_SYMBOL_VAR(libgsettings, data.variantGetters, g_variant_get_boolean, nullptr)
72 FF_LIBRARY_LOAD_SYMBOL_VAR(libgsettings, data.variantGetters, g_variant_get_int32, nullptr)
73 FF_LIBRARY_LOAD_SYMBOL_VAR(libgsettings, data.variantGetters, g_variant_unref, nullptr);
74
75 data.schemaSource = data.ffg_settings_schema_source_get_default();
76 if (data.schemaSource) {
77 libgsettings = nullptr;
78 }
79 }
80 if (!data.schemaSource) {
81 return nullptr;
82 }
83
84 return &data;
85}
86
87FFvariant ffSettingsGetGSettings(const char* schemaName, const char* path, const char* key, FFvarianttype type) {
88 const GSettingsData* data = getGSettingsData();
89 if (data == nullptr) {
90 return FF_VARIANT_NULL;
91 }
92
93 GSettingsSchema* schema = data->ffg_settings_schema_source_lookup(data->schemaSource, schemaName, true);
94 if (schema == nullptr) {
95 return FF_VARIANT_NULL;
96 }
97
98 if (data->ffg_settings_schema_has_key(schema, key) == false) {
99 return FF_VARIANT_NULL;
100 }
101
102 GSettings* settings = data->ffg_settings_new_full(schema, nullptr, path);
103 if (settings == nullptr) {
104 return FF_VARIANT_NULL;
105 }
106
107 GVariant* variant = data->ffg_settings_get_value(settings, key);
108 if (variant != nullptr) {
109 return getGVariantValue(variant, type, &data->variantGetters);
110 }
111
112 variant = data->ffg_settings_get_user_value(settings, key);
113 if (variant != nullptr) {
114 return getGVariantValue(variant, type, &data->variantGetters);
115 }
116
117 variant = data->ffg_settings_get_default_value(settings, key);
118 return getGVariantValue(variant, type, &data->variantGetters);
119}
120#else // FF_HAVE_GIO
121FFvariant ffSettingsGetGSettings(const char* schemaName, const char* path, const char* key, FFvarianttype type) {
122 FF_UNUSED(schemaName, path, key, type)
123 return FF_VARIANT_NULL;
124}
125#endif // FF_HAVE_GIO
126
127#ifdef FF_HAVE_DCONF
128 #include <dconf.h>
129
130typedef struct DConfData {
131 FF_LIBRARY_SYMBOL(dconf_client_read_full)
132 FF_LIBRARY_SYMBOL(dconf_client_new)
133 GVariantGetters variantGetters;
134 DConfClient* client;
135
136 bool inited;
137} DConfData;
138
139static const DConfData* getDConfData(void) {
140 static DConfData data;
141
142 if (!data.inited) {
143 data.inited = true;
144
145 FF_LIBRARY_LOAD(libdconf, nullptr, "libdconf" FF_LIBRARY_EXTENSION, 2);
146 FF_LIBRARY_LOAD_SYMBOL_VAR(libdconf, data, dconf_client_read_full, nullptr)
147 FF_LIBRARY_LOAD_SYMBOL_VAR(libdconf, data, dconf_client_new, nullptr)
148 FF_LIBRARY_LOAD_SYMBOL_VAR(libdconf, data.variantGetters, g_variant_dup_string, nullptr)
149 FF_LIBRARY_LOAD_SYMBOL_VAR(libdconf, data.variantGetters, g_variant_get_boolean, nullptr)
150 FF_LIBRARY_LOAD_SYMBOL_VAR(libdconf, data.variantGetters, g_variant_get_int32, nullptr)
151 FF_LIBRARY_LOAD_SYMBOL_VAR(libdconf, data.variantGetters, g_variant_unref, nullptr)
152
153 data.client = data.ffdconf_client_new();
154 if (data.client) {
155 libdconf = nullptr;
156 }
157 }
158 if (!data.client) {
159 return nullptr;
160 }
161
162 return &data;
163}
164
165FFvariant ffSettingsGetDConf(const char* key, FFvarianttype type) {
166 const DConfData* data = getDConfData();
167 if (data == nullptr) {
168 return FF_VARIANT_NULL;
169 }
170
171 GVariant* variant = data->ffdconf_client_read_full(data->client, key, DCONF_READ_FLAGS_NONE, nullptr);
172 if (variant != nullptr) {
173 return getGVariantValue(variant, type, &data->variantGetters);
174 }
175
176 variant = data->ffdconf_client_read_full(data->client, key, DCONF_READ_USER_VALUE, nullptr);
177 if (variant != nullptr) {
178 return getGVariantValue(variant, type, &data->variantGetters);
179 }
180
181 variant = data->ffdconf_client_read_full(data->client, key, DCONF_READ_DEFAULT_VALUE, nullptr);
182 return getGVariantValue(variant, type, &data->variantGetters);
183}
184#else // FF_HAVE_DCONF
185FFvariant ffSettingsGetDConf(const char* key, FFvarianttype type) {
186 FF_UNUSED(key, type)
187 return FF_VARIANT_NULL;
188}
189#endif // FF_HAVE_DCONF
190
191FFvariant ffSettingsGetGnome(const char* dconfKey, const char* gsettingsSchemaName, const char* gsettingsPath, const char* gsettingsKey, FFvarianttype type) {
192 FFvariant gsettings = ffSettingsGetGSettings(gsettingsSchemaName, gsettingsPath, gsettingsKey, type);
193
194 if (
195 (type == FF_VARIANT_TYPE_BOOL && gsettings.boolValueSet) ||
196 (type != FF_VARIANT_TYPE_BOOL && gsettings.strValue != nullptr)) {
197 return gsettings;
198 }
199
200 return ffSettingsGetDConf(dconfKey, type);
201}
202
203#ifdef FF_HAVE_DBUS
204 #include "common/dbus.h"
205
206FFvariant ffSettingsGetXFConf(const char* channelName, const char* propertyName, FFvarianttype type) {
207 FF_DBUS_AUTO_DESTROY_DATA FFDBusData dbus = {};
208 if (ffDBusLoadData(DBUS_BUS_SESSION, &dbus) != nullptr) {
209 return FF_VARIANT_NULL;
210 }
211
212 DBusMessage* reply = ffDBusGetMethodReply(&dbus, "org.xfce.Xfconf", "/org/xfce/Xfconf", "org.xfce.Xfconf", "GetProperty", channelName, propertyName);
213 if (!reply) {
214 return FF_VARIANT_NULL;
215 }
216
217 DBusMessageIter rootIterator;
218 if (!dbus.lib->ffdbus_message_iter_init(reply, &rootIterator)) {
219 dbus.lib->ffdbus_message_unref(reply);
220 return FF_VARIANT_NULL;
221 }
222
223 if (type == FF_VARIANT_TYPE_INT) {
224 int64_t value;
225 if (ffDBusGetInt(&dbus, &rootIterator, &value)) {
226 dbus.lib->ffdbus_message_unref(reply);
227 return (FFvariant) { .intValue = (int32_t) value };
228 }
229 dbus.lib->ffdbus_message_unref(reply);
230 return FF_VARIANT_NULL;
231 }
232
233 if (type == FF_VARIANT_TYPE_STRING) {
234 FFstrbuf value = ffStrbufCreate();
235 if (ffDBusGetString(&dbus, &rootIterator, &value)) {
236 dbus.lib->ffdbus_message_unref(reply);
237 return (FFvariant) { .strValue = value.chars }; // Leaks value.chars
238 }
239 dbus.lib->ffdbus_message_unref(reply);
240 return FF_VARIANT_NULL;
241 }
242
243 if (type == FF_VARIANT_TYPE_BOOL) {
244 bool value;
245 if (ffDBusGetBool(&dbus, &rootIterator, &value)) {
246 dbus.lib->ffdbus_message_unref(reply);
247 return (FFvariant) { .boolValue = value, .boolValueSet = true };
248 }
249 }
250
251 dbus.lib->ffdbus_message_unref(reply);
252 return FF_VARIANT_NULL;
253}
254
255 #define FF_DBUS_ITER_CONTINUE(dbus, iterator) \
256 { \
257 if (!(dbus).lib->ffdbus_message_iter_next(iterator)) \
258 break; \
259 continue; \
260 }
261
262FFvariant ffSettingsGetXFConfFirstMatch(const char* channelName, const char* propertyPrefix, FFvarianttype type, void* data, FFTestXfconfPropCallback* cb) {
263 FF_DBUS_AUTO_DESTROY_DATA FFDBusData dbus = {};
264 if (ffDBusLoadData(DBUS_BUS_SESSION, &dbus) != nullptr) {
265 return FF_VARIANT_NULL;
266 }
267
268 DBusMessage* reply = ffDBusGetMethodReply(&dbus, "org.xfce.Xfconf", "/org/xfce/Xfconf", "org.xfce.Xfconf", "GetAllProperties", channelName, propertyPrefix);
269 if (!reply) {
270 return FF_VARIANT_NULL;
271 }
272
273 DBusMessageIter rootIterator;
274 if (!dbus.lib->ffdbus_message_iter_init(reply, &rootIterator)) {
275 dbus.lib->ffdbus_message_unref(reply);
276 return FF_VARIANT_NULL;
277 }
278
279 DBusMessageIter arrayIterator;
280 dbus.lib->ffdbus_message_iter_recurse(&rootIterator, &arrayIterator);
281
282 while (true) {
283 if (dbus.lib->ffdbus_message_iter_get_arg_type(&arrayIterator) != DBUS_TYPE_DICT_ENTRY) {
284 FF_DBUS_ITER_CONTINUE(dbus, &arrayIterator)
285 }
286
287 DBusMessageIter dictIterator;
288 dbus.lib->ffdbus_message_iter_recurse(&arrayIterator, &dictIterator);
289
290 const char* key;
291 dbus.lib->ffdbus_message_iter_get_basic(&dictIterator, &key);
292
293 if (cb(data, key)) {
294 FF_DBUS_ITER_CONTINUE(dbus, &arrayIterator)
295 }
296 dbus.lib->ffdbus_message_iter_next(&dictIterator);
297
298 if (type == FF_VARIANT_TYPE_INT) {
299 int64_t value;
300 if (ffDBusGetInt(&dbus, &dictIterator, &value)) {
301 dbus.lib->ffdbus_message_unref(reply);
302 return (FFvariant) { .intValue = (int32_t) value };
303 }
304 dbus.lib->ffdbus_message_unref(reply);
305 return FF_VARIANT_NULL;
306 }
307
308 if (type == FF_VARIANT_TYPE_STRING) {
309 FFstrbuf value = ffStrbufCreate();
310 if (ffDBusGetString(&dbus, &dictIterator, &value)) {
311 dbus.lib->ffdbus_message_unref(reply);
312 return (FFvariant) { .strValue = value.chars }; // Leaks value.chars
313 }
314 dbus.lib->ffdbus_message_unref(reply);
315 return FF_VARIANT_NULL;
316 }
317
318 if (type == FF_VARIANT_TYPE_BOOL) {
319 bool value;
320 if (ffDBusGetBool(&dbus, &dictIterator, &value)) {
321 dbus.lib->ffdbus_message_unref(reply);
322 return (FFvariant) { .boolValue = value, .boolValueSet = true };
323 }
324 }
325
326 dbus.lib->ffdbus_message_unref(reply);
327 return FF_VARIANT_NULL;
328 }
329
330 dbus.lib->ffdbus_message_unref(reply);
331 return FF_VARIANT_NULL;
332}
333#else // FF_HAVE_DBUS
334FFvariant ffSettingsGetXFConf(const char* channelName, const char* propertyName, FFvarianttype type) {
335 FF_UNUSED(channelName, propertyName, type)
336 return FF_VARIANT_NULL;
337}
338FFvariant ffSettingsGetXFConfFirstMatch(const char* channelName, const char* propertyPrefix, FFvarianttype type, void* data, FFTestXfconfPropCallback* cb) {
339 FF_UNUSED(channelName, propertyPrefix, type, data, cb);
340 return FF_VARIANT_NULL;
341}
342#endif // FF_HAVE_DBUS
343
344#ifdef FF_HAVE_SQLITE3
345 #include <sqlite3.h>
346
347typedef struct SQLiteData {
348 FF_LIBRARY_SYMBOL(sqlite3_open_v2)
349 FF_LIBRARY_SYMBOL(sqlite3_prepare_v2)
350 FF_LIBRARY_SYMBOL(sqlite3_step)
351 FF_LIBRARY_SYMBOL(sqlite3_data_count)
352 FF_LIBRARY_SYMBOL(sqlite3_column_int)
353 FF_LIBRARY_SYMBOL(sqlite3_column_text)
354 FF_LIBRARY_SYMBOL(sqlite3_finalize)
355 FF_LIBRARY_SYMBOL(sqlite3_close)
356
357 bool inited;
358} SQLiteData;
359
360static const SQLiteData* getSQLiteData(void) {
361 static SQLiteData data;
362
363 if (!data.inited) {
364 data.inited = true;
365 FF_LIBRARY_LOAD(libsqlite, nullptr, "libsqlite3" FF_LIBRARY_EXTENSION, 1);
366 FF_LIBRARY_LOAD_SYMBOL_VAR(libsqlite, data, sqlite3_open_v2, nullptr)
367 FF_LIBRARY_LOAD_SYMBOL_VAR(libsqlite, data, sqlite3_prepare_v2, nullptr)
368 FF_LIBRARY_LOAD_SYMBOL_VAR(libsqlite, data, sqlite3_step, nullptr)
369 FF_LIBRARY_LOAD_SYMBOL_VAR(libsqlite, data, sqlite3_data_count, nullptr)
370 FF_LIBRARY_LOAD_SYMBOL_VAR(libsqlite, data, sqlite3_column_int, nullptr)
371 FF_LIBRARY_LOAD_SYMBOL_VAR(libsqlite, data, sqlite3_column_text, nullptr)
372 FF_LIBRARY_LOAD_SYMBOL_VAR(libsqlite, data, sqlite3_finalize, nullptr)
373 FF_LIBRARY_LOAD_SYMBOL_VAR(libsqlite, data, sqlite3_close, nullptr)
374 libsqlite = nullptr;
375 }
376
377 if (!data.ffsqlite3_close) {
378 return nullptr;
379 }
380
381 return &data;
382}
383
384typedef struct FFSQLite3Bundle {
385 const SQLiteData* data;
386 sqlite3* db;
387 sqlite3_stmt* stmt;
388} FFSQLite3Bundle;
389static void destroySQLite3Bundle(FFSQLite3Bundle* bundle) {
390 if (!bundle->data) {
391 return;
392 }
393 if (bundle->stmt) {
394 bundle->data->ffsqlite3_finalize(bundle->stmt);
395 bundle->stmt = nullptr;
396 }
397 if (bundle->db) {
398 bundle->data->ffsqlite3_close(bundle->db);
399 bundle->db = nullptr;
400 }
401}
402
403static bool prepareSQLite3Statement(const char* dbPath, const char* query, FFSQLite3Bundle* bundle) {
404 if (!ffPathExists(dbPath, FF_PATHTYPE_FILE)) {
405 return false;
406 }
407
408 const SQLiteData* data = bundle->data = getSQLiteData();
409 if (data == nullptr) {
410 FF_DEBUG("Failed to load SQLite3 library");
411 return false;
412 }
413
414 // Read-only WAL databases may require a -shm or lock file during prepare, which is not
415 // possible when the database directory is not writable. immutable=1 avoids those files.
416 FF_STRBUF_AUTO_DESTROY pathImmutable = ffStrbufCreateStatic("file:");
417 ffStrbufAppendS(&pathImmutable, dbPath);
418 ffStrbufAppendS(&pathImmutable, "?immutable=1");
419
420 int ret = data->ffsqlite3_open_v2(pathImmutable.chars, &bundle->db, SQLITE_OPEN_READONLY | SQLITE_OPEN_NOMUTEX | SQLITE_OPEN_URI, nullptr);
421 if (ret != SQLITE_OK) {
422 FF_DEBUG("Failed to open SQLite3 database: %s (%d)", dbPath, ret);
423 return false;
424 }
425
426 ret = data->ffsqlite3_prepare_v2(bundle->db, query, (int) strlen(query), &bundle->stmt, nullptr);
427 if (ret != SQLITE_OK) {
428 FF_DEBUG("Failed to prepare SQLite3 statement: %s (%d)", query, ret);
429 return false;
430 }
431
432 ret = data->ffsqlite3_step(bundle->stmt);
433 if (ret != SQLITE_ROW) {
434 FF_DEBUG("Failed to step SQLite3 statement: %s (%d)", query, ret);
435 return false;
436 }
437
438 ret = data->ffsqlite3_data_count(bundle->stmt);
439 if (ret < 1) {
440 FF_DEBUG("No data returned for SQLite3 statement: %s", query);
441 return false;
442 }
443
444 return true;
445}
446
447int ffSettingsGetSQLite3Int(const char* dbPath, const char* query) {
448 [[gnu::cleanup(destroySQLite3Bundle)]] FFSQLite3Bundle bundle = {};
449 if (!prepareSQLite3Statement(dbPath, query, &bundle)) {
450 return 0;
451 }
452
453 return bundle.data->ffsqlite3_column_int(bundle.stmt, 0);
454}
455
456bool ffSettingsGetSQLite3String(const char* dbPath, const char* query, FFstrbuf* result) {
457 [[gnu::cleanup(destroySQLite3Bundle)]] FFSQLite3Bundle bundle = {};
458 if (!prepareSQLite3Statement(dbPath, query, &bundle)) {
459 return false;
460 }
461
462 ffStrbufSetS(result, (const char*) bundle.data->ffsqlite3_column_text(bundle.stmt, 0));
463
464 return true;
465}
466#else // FF_HAVE_SQLITE3
467int ffSettingsGetSQLite3Int(const char*, const char*) {
468 return 0;
469}
470bool ffSettingsGetSQLite3String(const char*, const char*, FFstrbuf*) {
471 return false;
472}
473#endif // FF_HAVE_SQLITE3
474
475#ifdef __ANDROID__
476 #include <sys/system_properties.h>
477bool ffSettingsGetAndroidProperty(const char* propName, FFstrbuf* result) {
478 ffStrbufEnsureFree(result, PROP_VALUE_MAX);
479 int len = __system_property_get(propName, result->chars + result->length);
480 if (len <= 0) {
481 return false;
482 }
483 result->length += (uint32_t) len;
484 result->chars[result->length] = '\0';
485 return true;
486}
487#elif defined(__FreeBSD__)
488 #include <kenv.h>
489bool ffSettingsGetFreeBSDKenv(const char* propName, FFstrbuf* result) {
490 // https://wiki.ghostbsd.org/index.php/Kenv
491 ffStrbufEnsureFree(result, KENV_MVALLEN);
492 int len = kenv(KENV_GET, propName, result->chars + result->length, KENV_MVALLEN);
493 if (len <= 1) {
494 return false; // number of bytes copied, including NUL terminator
495 }
496 result->length += (uint32_t) len - 1;
497 return true;
498}
499#endif
500
501#ifdef FF_HAVE_EET
502 #pragma GCC diagnostic push
503 #pragma GCC diagnostic ignored "-Wconversion"
504 #pragma GCC diagnostic ignored "-Wsign-conversion"
505 #pragma GCC diagnostic ignored "-Wfloat-conversion"
506 #include <Eet.h>
507 #pragma GCC diagnostic pop
508
509typedef struct E_Font_Default {
510 char* text_class;
511 char* font;
512 int size;
513} E_Font_Default;
514
515typedef struct E_Config {
516 char* theme_default_border_style;
517 char* icon_theme;
518 int use_e_cursor;
519 int cursor_size;
520 char* desktop_default_background;
521 Eina_List* font_defaults;
522} E_Config; // Must be the same name as the top level struct in e.cfg
523
524 #define FF_EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(klass, type) \
525 (ffeet_eina_file_data_descriptor_class_set(klass, sizeof(*(klass)), #type, sizeof(type)))
526 #define FF_EET_DATA_DESCRIPTOR_ADD_BASIC(edd, struct_type, member, type) \
527 do { \
528 struct_type ___ett; \
529 ffeet_data_descriptor_element_add(edd, #member, type, EET_G_UNKNOWN, (char*) (&(___ett.member)) - (char*) (&(___ett)), 0, /* 0, */ nullptr, nullptr); \
530 } while (0)
531 #define FF_EET_DATA_DESCRIPTOR_ADD_LIST(edd, struct_type, member, subtype) \
532 do { \
533 struct_type ___ett; \
534 ffeet_data_descriptor_element_add(edd, #member, EET_T_UNKNOW, EET_G_LIST, (char*) (&(___ett.member)) - (char*) (&(___ett)), 0, /* 0, */ nullptr, subtype); \
535 } while (0)
536
537bool ffSettingsGetEnlightenmentProperty(ffEnlightenmentSettings* result) {
538 FF_LIBRARY_LOAD(libeet, false, "libeet" FF_LIBRARY_EXTENSION, 1);
539 FF_LIBRARY_LOAD_SYMBOL(libeet, eet_init, false);
540 FF_LIBRARY_LOAD_SYMBOL(libeet, eet_open, false);
541 FF_LIBRARY_LOAD_SYMBOL(libeet, eet_data_descriptor_file_new, false);
542 FF_LIBRARY_LOAD_SYMBOL(libeet, eet_data_read, false);
543 FF_LIBRARY_LOAD_SYMBOL(libeet, eet_close, false);
544 FF_LIBRARY_LOAD_SYMBOL(libeet, eet_shutdown, false);
545 FF_LIBRARY_LOAD_SYMBOL(libeet, eet_data_descriptor_free, false);
546 FF_LIBRARY_LOAD_SYMBOL(libeet, eet_eina_file_data_descriptor_class_set, false);
547 FF_LIBRARY_LOAD_SYMBOL(libeet, eet_data_descriptor_element_add, false);
548
549 if (ffeet_init() == 0) {
550 return false;
551 }
552
553 FF_STRBUF_AUTO_DESTROY fileName = ffStrbufCreateCopy(&instance.state.platform.homeDir);
554 ffStrbufAppendS(&fileName, ".e/e/config/standard/e.cfg");
555
556 Eet_File* ef = ffeet_open(fileName.chars, EET_FILE_MODE_READ);
557 if (!ef) {
558 ffeet_shutdown();
559 return false;
560 }
561
562 Eet_Data_Descriptor_Class fontDdc;
563 FF_EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(&fontDdc, E_Font_Default);
564 Eet_Data_Descriptor* fontDdd = ffeet_data_descriptor_file_new(&fontDdc);
565 if (!fontDdd) {
566 ffeet_close(ef);
567 ffeet_shutdown();
568 return false;
569 }
570 FF_EET_DATA_DESCRIPTOR_ADD_BASIC(fontDdd, E_Font_Default, text_class, EET_T_STRING);
571 FF_EET_DATA_DESCRIPTOR_ADD_BASIC(fontDdd, E_Font_Default, font, EET_T_STRING);
572 FF_EET_DATA_DESCRIPTOR_ADD_BASIC(fontDdd, E_Font_Default, size, EET_T_INT);
573
574 Eet_Data_Descriptor_Class eddc;
575 FF_EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(&eddc, E_Config);
576 Eet_Data_Descriptor* edd = ffeet_data_descriptor_file_new(&eddc);
577 if (!edd) {
578 ffeet_data_descriptor_free(fontDdd);
579 ffeet_close(ef);
580 ffeet_shutdown();
581 return false;
582 }
583
584 FF_EET_DATA_DESCRIPTOR_ADD_BASIC(edd, E_Config, theme_default_border_style, EET_T_STRING);
585 FF_EET_DATA_DESCRIPTOR_ADD_BASIC(edd, E_Config, icon_theme, EET_T_STRING);
586 FF_EET_DATA_DESCRIPTOR_ADD_BASIC(edd, E_Config, use_e_cursor, EET_T_INT);
587 FF_EET_DATA_DESCRIPTOR_ADD_BASIC(edd, E_Config, cursor_size, EET_T_INT);
588 FF_EET_DATA_DESCRIPTOR_ADD_BASIC(edd, E_Config, desktop_default_background, EET_T_STRING);
589 FF_EET_DATA_DESCRIPTOR_ADD_LIST(edd, E_Config, font_defaults, fontDdd);
590
591 E_Config* parsed = ffeet_data_read(ef, edd, "config");
592
593 if (parsed) {
594 // TODO: find a better method to get the main theme name
595 result->theme = parsed->theme_default_border_style;
596 result->icon_theme = parsed->icon_theme;
597 result->use_e_cursor = !!parsed->use_e_cursor;
598 result->cursor_size = parsed->cursor_size;
599 result->desktop_default_background = parsed->desktop_default_background;
600
601 E_Font_Default* firstFont = eina_list_data_get(parsed->font_defaults);
602 if (firstFont) {
603 result->font = firstFont->font;
604 }
605 }
606
607 ffeet_close(ef);
608 ffeet_data_descriptor_free(edd);
609 ffeet_data_descriptor_free(fontDdd);
610 if (!parsed) {
611 // We don't shutdown eet so that `result->*` are not freed
612 ffeet_shutdown();
613 }
614
615 return !!parsed;
616}
617#else
618bool ffSettingsGetEnlightenmentProperty([[maybe_unused]] ffEnlightenmentSettings* result) {
619 return false;
620}
621#endif