forked from enlightenment/efl
Marcel Hollerbach
parent
c4f33c67a8
commit
8c7ba8c3a3
|
|
@ -54,11 +54,6 @@ efl_eolian_files = \
|
|||
lib/efl/interfaces/efl_pack_layout.eo \
|
||||
lib/efl/interfaces/efl_pack_linear.eo \
|
||||
lib/efl/interfaces/efl_pack_table.eo \
|
||||
lib/efl/interfaces/efl_vpath.eo \
|
||||
lib/efl/interfaces/efl_vpath_manager.eo \
|
||||
lib/efl/interfaces/efl_vpath_file.eo \
|
||||
lib/efl/interfaces/efl_vpath_core.eo \
|
||||
lib/efl/interfaces/efl_vpath_file_core.eo \
|
||||
lib/efl/interfaces/efl_ui_base.eo \
|
||||
lib/efl/interfaces/efl_ui_direction.eo \
|
||||
lib/efl/interfaces/efl_ui_drag.eo \
|
||||
|
|
@ -122,10 +117,6 @@ lib/efl/interfaces/efl_interfaces_main.c \
|
|||
lib/efl/interfaces/efl_model_common.c \
|
||||
lib/efl/interfaces/efl_gfx_path.c \
|
||||
lib/efl/interfaces/efl_gfx_shape.c \
|
||||
lib/efl/interfaces/efl_vpath_file.c \
|
||||
lib/efl/interfaces/efl_vpath_manager.c \
|
||||
lib/efl/interfaces/efl_vpath_core.c \
|
||||
lib/efl/interfaces/efl_vpath_file_core.c \
|
||||
lib/efl/interfaces/efl_input_device.c \
|
||||
lib/efl/interfaces/efl_io_closer.c \
|
||||
lib/efl/interfaces/efl_io_positioner.c \
|
||||
|
|
|
|||
|
|
@ -62,12 +62,6 @@ typedef struct _Efl_Text_Annotate_Annotation Efl_Text_Annotate_Annotation;
|
|||
|
||||
#include <Efl_Model_Common.h>
|
||||
|
||||
#include "interfaces/efl_vpath_file.eo.h"
|
||||
#include "interfaces/efl_vpath.eo.h"
|
||||
#include "interfaces/efl_vpath_core.eo.h"
|
||||
#include "interfaces/efl_vpath_manager.eo.h"
|
||||
#include "interfaces/efl_vpath_file_core.eo.h"
|
||||
|
||||
/* Data types */
|
||||
#include "interfaces/efl_gfx_types.eot.h"
|
||||
#include "interfaces/efl_ui_types.eot.h"
|
||||
|
|
|
|||
|
|
@ -46,8 +46,6 @@
|
|||
#include "interfaces/efl_canvas.eo.c"
|
||||
#include "interfaces/efl_canvas_pointer.eo.c"
|
||||
|
||||
#include "interfaces/efl_vpath.eo.c"
|
||||
|
||||
#include "interfaces/efl_screen.eo.c"
|
||||
|
||||
/* Packing & containers */
|
||||
|
|
|
|||
|
|
@ -1,31 +0,0 @@
|
|||
interface Efl.Vpath
|
||||
{
|
||||
[[ VPath is the EFL "Virtual Path" system that maps paths and downloads
|
||||
|
||||
You can provide virtual paths common in unix shells like:
|
||||
"~/file.jpg"
|
||||
"~username/file.png"
|
||||
And also other extended paths like:
|
||||
"(:cache:)/file.png"
|
||||
"(:videos:)/file.mp4"
|
||||
...
|
||||
And in future:
|
||||
"file:///blah.jpg"
|
||||
"http://blah.com/file.jpg"
|
||||
"https://blahblah.com/file.jpg"
|
||||
"ssh://blahblah.com:~/file.jpg"
|
||||
...
|
||||
|
||||
@since 1.18
|
||||
]]
|
||||
eo_prefix: efl_vpath;
|
||||
methods {
|
||||
fetch {
|
||||
[[ Fetch a new Vpath File object from the Vpath system ]]
|
||||
params {
|
||||
path: string; [[ The input virtual file path to fetch ]]
|
||||
}
|
||||
return: Efl.Vpath.File @owned; [[ An object representing the file ]]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,436 +0,0 @@
|
|||
#include "config.h"
|
||||
#include "Efl.h"
|
||||
|
||||
#ifdef HAVE_GETPWENT
|
||||
# include <sys/types.h>
|
||||
# include <pwd.h>
|
||||
#endif
|
||||
|
||||
#include <sys/stat.h>
|
||||
#include <sys/types.h>
|
||||
#include <fcntl.h>
|
||||
#include <sys/stat.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#define MY_CLASS EFL_VPATH_CORE_CLASS
|
||||
|
||||
typedef struct _Efl_Vpath_Core_Data Efl_Vpath_Core_Data;
|
||||
|
||||
struct _Efl_Vpath_Core_Data
|
||||
{
|
||||
Eina_Spinlock lock;
|
||||
Eina_Hash *meta;
|
||||
};
|
||||
|
||||
static Efl_Vpath_Core *vpath_core = NULL;
|
||||
|
||||
EOLIAN static Efl_Object *
|
||||
_efl_vpath_core_efl_object_constructor(Eo *obj, Efl_Vpath_Core_Data *pd)
|
||||
{
|
||||
char buf[PATH_MAX], bufhome[PATH_MAX];
|
||||
const char *home, *s;
|
||||
|
||||
if (vpath_core) return NULL;
|
||||
obj = efl_constructor(efl_super(obj, MY_CLASS));
|
||||
pd->meta = eina_hash_string_superfast_new
|
||||
((Eina_Free_Cb)eina_stringshare_del);
|
||||
eina_spinlock_new(&(pd->lock));
|
||||
|
||||
vpath_core = obj;
|
||||
|
||||
// $HOME / ~/ etc.
|
||||
home = eina_environment_home_get();
|
||||
if (!home)
|
||||
{
|
||||
/* Windows does not have getuid(), but home can't be NULL */
|
||||
#ifdef HAVE_GETEUID
|
||||
uid_t uid = geteuid();
|
||||
struct stat st;
|
||||
|
||||
snprintf(bufhome, sizeof(bufhome), "/tmp/%i", (int)uid);
|
||||
if (mkdir(bufhome, S_IRUSR | S_IWUSR | S_IXUSR) < 0)
|
||||
{
|
||||
if (errno != EEXIST)
|
||||
{
|
||||
if (stat("/tmp", &st) == 0) home = "/tmp";
|
||||
else home = "/";
|
||||
}
|
||||
}
|
||||
if (stat(bufhome, &st) == 0) home = bufhome;
|
||||
else
|
||||
{
|
||||
if (stat("/tmp", &st) == 0) home = "/tmp";
|
||||
else home = "/";
|
||||
}
|
||||
#else
|
||||
home = "/";
|
||||
#endif
|
||||
}
|
||||
efl_vpath_core_meta_set(obj, "home", home);
|
||||
// tmp dir - system wide
|
||||
s = eina_environment_tmp_get();
|
||||
efl_vpath_core_meta_set(obj, "tmp", s);
|
||||
|
||||
# if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
|
||||
# define ENV_HOME_SET(_env, _dir, _meta) \
|
||||
if ((getuid() != geteuid()) || (!(s = getenv(_env)))) { \
|
||||
snprintf(buf, sizeof(buf), "%s/"_dir, home); s = buf; \
|
||||
} efl_vpath_core_meta_set(obj, _meta, s);
|
||||
#else
|
||||
# define ENV_HOME_SET(_env, _dir, _meta) \
|
||||
if (!(s = getenv(_env))) { \
|
||||
snprintf(buf, sizeof(buf), "%s/"_dir, home); s = buf; \
|
||||
} efl_vpath_core_meta_set(obj, _meta, s);
|
||||
#endif
|
||||
// $XDG_DATA_HOME defines the base directory relative to which user
|
||||
// specific data files should be stored. If $XDG_DATA_HOME is either
|
||||
// not set or empty, a default equal to $HOME/.local/share should be
|
||||
// used.
|
||||
ENV_HOME_SET("XDG_DATA_HOME", ".local/share", "data");
|
||||
// $XDG_CONFIG_HOME defines the base directory relative to which user
|
||||
// specific configuration files should be stored. If $XDG_CONFIG_HOME
|
||||
// is either not set or empty, a default equal to $HOME/.config should
|
||||
// be used.
|
||||
ENV_HOME_SET("XDG_CONFIG_HOME", ".config", "config");
|
||||
// $XDG_CACHE_HOME defines the base directory relative to which
|
||||
// user specific non-essential data files should be stored. If
|
||||
// $XDG_CACHE_HOME is either not set or empty, a default equal to
|
||||
// $HOME/.cache should be used.
|
||||
ENV_HOME_SET("XDG_CACHE_HOME", ".cache", "cache");
|
||||
// $XDG_RUNTIME_DIR defines the base directory relative to which
|
||||
// user-specific non-essential runtime files and other file objects
|
||||
// (such as sockets, named pipes, ...) should be stored. The
|
||||
// directory MUST be owned by the user, and he MUST be the only one
|
||||
// having read and write access to it. Its Unix access mode MUST
|
||||
// be 0700.
|
||||
#if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
|
||||
if ((getuid() != geteuid()) || (!(s = getenv("XDG_RUNTIME_DIR"))))
|
||||
#else
|
||||
if (!(s = getenv("XDG_RUNTIME_DIR")))
|
||||
#endif
|
||||
{
|
||||
struct stat st;
|
||||
uid_t uid;
|
||||
|
||||
#if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
|
||||
uid = getuid();
|
||||
if (setuid(geteuid()) != 0)
|
||||
{
|
||||
fprintf(stderr,
|
||||
"FATAL: Cannot setuid - errno=%i\n",
|
||||
errno);
|
||||
abort();
|
||||
}
|
||||
#endif
|
||||
// fallback - make ~/.run
|
||||
snprintf(buf, sizeof(buf), "%s/.run", home);
|
||||
if (mkdir(buf, S_IRUSR | S_IWUSR | S_IXUSR) == 0) s = buf;
|
||||
else
|
||||
{
|
||||
if (errno == EEXIST)
|
||||
{
|
||||
if (stat(buf, &st) == 0)
|
||||
{
|
||||
// some sanity checks - but not for security
|
||||
if (!(st.st_mode & S_IFDIR))
|
||||
{
|
||||
// fatal - exists but is not a dir
|
||||
fprintf(stderr,
|
||||
"FATAL: run dir '%s' exists but not a dir\n",
|
||||
buf);
|
||||
abort();
|
||||
}
|
||||
#if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
|
||||
if (st.st_uid != geteuid())
|
||||
{
|
||||
// fatal - run dir doesn't belong to user
|
||||
fprintf(stderr,
|
||||
"FATAL: run dir '%s' not owned by uid %i\n",
|
||||
buf, (int)geteuid());
|
||||
abort();
|
||||
}
|
||||
#endif
|
||||
// we're ok
|
||||
s = buf;
|
||||
}
|
||||
else
|
||||
{
|
||||
// fatal - we cant create our run dir in ~/
|
||||
fprintf(stderr,
|
||||
"FATAL: Cannot verify run dir '%s' errno=%i\n",
|
||||
buf, errno);
|
||||
abort();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// fatal - we cant create our run dir in ~/
|
||||
fprintf(stderr,
|
||||
"FATAL: Cannot create run dir '%s' - errno=%i\n",
|
||||
buf, errno);
|
||||
abort();
|
||||
}
|
||||
}
|
||||
#if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
|
||||
if (setreuid(uid, geteuid()) != 0)
|
||||
{
|
||||
fprintf(stderr,
|
||||
"FATAL: Cannot setreuid - errno=%i\n",
|
||||
errno);
|
||||
abort();
|
||||
};
|
||||
#endif
|
||||
}
|
||||
if (!s) s = (char *)efl_vpath_core_meta_get(obj, "tmp");
|
||||
efl_vpath_core_meta_set(obj, "run", s);
|
||||
// https://www.freedesktop.org/wiki/Software/xdg-user-dirs/
|
||||
// https://wiki.archlinux.org/index.php/Xdg_user_directories
|
||||
// ^^^^ we don't handle:
|
||||
// /etc/xdg/user-dirs.conf
|
||||
// /etc/xdg/user-dirs.defaults
|
||||
// (:config:)/user-dirs.conf
|
||||
// (:config:)/user-dirs.defaults
|
||||
|
||||
// $XDG_DESKTOP_DIR="$HOME/Desktop"
|
||||
ENV_HOME_SET("XDG_DESKTOP_DIR", "Desktop", "desktop");
|
||||
// $XDG_DOCUMENTS_DIR="$HOME/Documents"
|
||||
ENV_HOME_SET("XDG_DOCUMENTS_DIR", "Documents", "documents");
|
||||
// $XDG_DOWNLOAD_DIR="$HOME/Downloads"
|
||||
ENV_HOME_SET("XDG_DOWNLOAD_DIR", "Downloads", "downloads");
|
||||
// $XDG_MUSIC_DIR="$HOME/Music"
|
||||
ENV_HOME_SET("XDG_MUSIC_DIR", "Music", "music");
|
||||
// $XDG_PICTURES_DIR="$HOME/Pictures"
|
||||
ENV_HOME_SET("XDG_PICTURES_DIR", "Pictures", "pictures");
|
||||
// $XDG_PUBLICSHARE_DIR="$HOME/Public"
|
||||
ENV_HOME_SET("XDG_PUBLIC_DIR", "Public", "public");
|
||||
// $XDG_TEMPLATES_DIR="$HOME/.Templates"
|
||||
ENV_HOME_SET("XDG_TEMPLATES_DIR", ".Templates", "templates");
|
||||
// $XDG_VIDEOS_DIR="$HOME/Videos"
|
||||
ENV_HOME_SET("XDG_VIDEOS_DIR", "Videos", "videos");
|
||||
|
||||
// Add ~/Applications for user-installed apps
|
||||
ENV_HOME_SET("E_APPS_DIR", "Applications", "apps");
|
||||
|
||||
// XXX: do the below ... later
|
||||
//
|
||||
// FHS FOR APP:
|
||||
// app.dir = PREFIX
|
||||
// app.bin = PREFIX/bin
|
||||
// app.lib = PREFIX/lib
|
||||
// app.data = PREFIX/share/APPNAME
|
||||
// app.locale = PREFIX/share/locale
|
||||
//
|
||||
// XXX: figure out how to merge these with XDG/FHS?
|
||||
// Tizen:
|
||||
// App Dir Structure:
|
||||
// bin Executable binary pathOwner: Read
|
||||
// lib Library pathOwner: Read
|
||||
// data Used to store private data of an application.
|
||||
// res Used to read resource files that are delivered with the application package.
|
||||
// shared Parent directory of the data, res, and trusted sub-directories. Files in this directory cannot be delivered with the application package.Owner: Read
|
||||
// shared/data Used to share data with other applications.
|
||||
// shared/res Used to share resources with other applications. The resource files are delivered with the application package.
|
||||
// shared/trusted Used to share data with family of trusted applications. The family applications signed with the same certificate can access data in the shared/trusted directory.
|
||||
//
|
||||
// XXX: figure out how to merge these with XDG?
|
||||
// Media/...vvv
|
||||
// Images Used for Image data.Read and Write
|
||||
// Sounds Used for Sound data.
|
||||
// Videos Used for Video data.
|
||||
// Cameras Used for Camera pictures.
|
||||
// Downloads Used for Downloaded data.
|
||||
// Music Used for Music data.
|
||||
// Documents Used for Documents.
|
||||
// Others Used for other types.
|
||||
// System Ringtones Used for System default ringtones.Read
|
||||
//
|
||||
// $TZ_SYS_HOME=/home
|
||||
// $TZ_SYS_DB=/var/db
|
||||
// $TZ_SYS_CONFIG=/var/kdb
|
||||
// $TZ_SYS_CONFIG_VOLATILE=/run/kdb
|
||||
// $TZ_SYS_APP=/usr/apps
|
||||
// $TZ_SYS_DESKTOP_APP=/usr/share/applications
|
||||
//
|
||||
// $TS_USER_DB=<user_homeid>/.tizen/db
|
||||
// $TZ_USER_CONFIG=<user_home_dir>/.tizen/kdb
|
||||
// $TZ_USER_APP=<user_home_dir>/.tizen/apps
|
||||
// $TZ_USER_DESKTOP_APP=<user_home_dir>/.tizen/desktop
|
||||
// $TZ_USER_DOCUMENTS=<user_home_dir>/Documents
|
||||
// $TZ_USER_PICTURES=<user_home_dir>/Pictures
|
||||
// $TZ_USER_VIDEOS=<user_home_dir>/Videos
|
||||
// $TZ_USER_MUSIC=<user_home_dir>/Music
|
||||
// $TZ_USER_DOWNLOADS=<user_home_dir>/Downloads
|
||||
// $TZ_USER_PUBLIC=<user_home_dir>/Public
|
||||
return obj;
|
||||
}
|
||||
|
||||
EOLIAN static void
|
||||
_efl_vpath_core_efl_object_destructor(Eo *obj, Efl_Vpath_Core_Data *pd)
|
||||
{
|
||||
eina_hash_free(pd->meta);
|
||||
pd->meta = NULL;
|
||||
eina_spinlock_free(&(pd->lock));
|
||||
if (vpath_core == obj) vpath_core = NULL;
|
||||
efl_destructor(efl_super(obj, MY_CLASS));
|
||||
}
|
||||
|
||||
EOLIAN static Efl_Vpath_Core *
|
||||
_efl_vpath_core_core_get(Eo *obj EINA_UNUSED, void *pd EINA_UNUSED)
|
||||
{
|
||||
// no locks here as we expect efl to init this early in main "thread"
|
||||
if (!vpath_core) vpath_core = efl_add(EFL_VPATH_CORE_CLASS, NULL);
|
||||
return vpath_core;
|
||||
}
|
||||
|
||||
EOLIAN static const char *
|
||||
_efl_vpath_core_meta_get(Eo *obj EINA_UNUSED, Efl_Vpath_Core_Data *pd, const char *key)
|
||||
{
|
||||
const char *meta;
|
||||
|
||||
if (!key) return NULL;
|
||||
eina_spinlock_take(&(pd->lock));
|
||||
meta = eina_hash_find(pd->meta, key);
|
||||
eina_spinlock_release(&(pd->lock));
|
||||
return meta;
|
||||
}
|
||||
|
||||
EOLIAN static void
|
||||
_efl_vpath_core_meta_set(Eo *obj EINA_UNUSED, Efl_Vpath_Core_Data *pd, const char *key, const char *path)
|
||||
{
|
||||
if (!key) return;
|
||||
eina_spinlock_take(&(pd->lock));
|
||||
if (path) eina_hash_add(pd->meta, key, eina_stringshare_add(path));
|
||||
else eina_hash_del(pd->meta, key, NULL);
|
||||
eina_spinlock_release(&(pd->lock));
|
||||
}
|
||||
|
||||
EOLIAN static Efl_Vpath_File *
|
||||
_efl_vpath_core_efl_vpath_fetch(Eo *obj, Efl_Vpath_Core_Data *pd EINA_UNUSED, const char *path)
|
||||
{
|
||||
Efl_Vpath_File_Core *file;
|
||||
|
||||
file = efl_add(EFL_VPATH_FILE_CORE_CLASS, obj);
|
||||
efl_vpath_file_path_set(file, path);
|
||||
// XXX: implement parse of path then look up in hash if not just create
|
||||
// object where path and result are the same and return that with
|
||||
// path set and result set to resolved path - return obj handler calls
|
||||
// "do" on object to get the result inside fetched or failed callback.
|
||||
// if it's a url then we need a new classs that overrides the do and
|
||||
// begins a fetch and on finish calls the event cb or when wait is called
|
||||
if (path)
|
||||
{
|
||||
/* FIXME: not working for WIndows */
|
||||
// /* <- full path
|
||||
if (path[0] == '/')
|
||||
{
|
||||
efl_vpath_file_result_set(file, path);
|
||||
return file;
|
||||
}
|
||||
// .*
|
||||
if (path[0] == '.')
|
||||
{
|
||||
// .[/]* <- current dir relative
|
||||
if ((path[1] == '/') || (path[1] == 0))
|
||||
{
|
||||
efl_vpath_file_result_set(file, path);
|
||||
return file;
|
||||
}
|
||||
// ..[/]* <- parent dir relative
|
||||
if ((path[1] == '.') && ((path[2] == '/') || (path[2] == 0)))
|
||||
{
|
||||
efl_vpath_file_result_set(file, path);
|
||||
return file;
|
||||
}
|
||||
}
|
||||
// ~* ...
|
||||
if (path[0] == '~')
|
||||
{
|
||||
// ~/ <- home directory
|
||||
if (path[1] == '/')
|
||||
{
|
||||
char buf[PATH_MAX];
|
||||
const char *home = efl_vpath_core_meta_get(obj, "home");
|
||||
|
||||
if (home)
|
||||
{
|
||||
snprintf(buf, sizeof(buf), "%s%s", home, path + 1);
|
||||
efl_vpath_file_result_set(file, buf);
|
||||
return file;
|
||||
}
|
||||
}
|
||||
#ifdef HAVE_GETPWENT
|
||||
// ~username/ <- homedir of user "username"
|
||||
else
|
||||
{
|
||||
const char *p;
|
||||
struct passwd pwent, *pwent2 = NULL;
|
||||
char *name, buf[PATH_MAX], pwbuf[8129];
|
||||
|
||||
for (p = path + 1; *p; p++)
|
||||
{
|
||||
if (*p =='/') break;
|
||||
}
|
||||
name = alloca(p - path);
|
||||
strncpy(name, path + 1, p - path - 1);
|
||||
name[p - path - 1] = 0;
|
||||
if (!getpwnam_r(name, &pwent, pwbuf, sizeof(pwbuf), &pwent2))
|
||||
{
|
||||
if ((pwent2) && (pwent.pw_dir))
|
||||
{
|
||||
snprintf(buf, sizeof(buf), "%s%s", pwent.pw_dir, p);
|
||||
efl_vpath_file_result_set(file, buf);
|
||||
return file;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif /* HAVE_GETPWENT */
|
||||
}
|
||||
// (:xxx:)/* ... <- meta hash table
|
||||
if ((path[0] == '(') && (path[1] == ':'))
|
||||
{
|
||||
const char *p, *meta;
|
||||
char *name, buf[PATH_MAX];
|
||||
Eina_Bool found = EINA_FALSE;
|
||||
|
||||
for (p = path + 2; *p; p++)
|
||||
{
|
||||
if ((p[0] ==':') && (p[1] == ')') && (p[2] == '/'))
|
||||
{
|
||||
found = EINA_TRUE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (found)
|
||||
{
|
||||
name = alloca(p - path);
|
||||
strncpy(name, path + 2, p - path - 2);
|
||||
name[p - path - 2] = 0;
|
||||
eina_spinlock_take(&(pd->lock));
|
||||
meta = eina_hash_find(pd->meta, name);
|
||||
eina_spinlock_release(&(pd->lock));
|
||||
if (meta)
|
||||
{
|
||||
snprintf(buf, sizeof(buf), "%s%s", meta, p + 2);
|
||||
efl_vpath_file_result_set(file, buf);
|
||||
return file;
|
||||
}
|
||||
}
|
||||
}
|
||||
// XXX: handle file:// urls locally...
|
||||
// XXX: if its a remote url or zip file etc. where we need to
|
||||
// keep tmp file around then we need to set keep to true
|
||||
// efl_vpath_file_keept_set(file, EINA_TRUE);
|
||||
|
||||
// file:/// <- local file path uri
|
||||
// file://localhost/ <- local file path uri
|
||||
// file://hostname/ <- remove file path uri
|
||||
// XXX: %c4,%17,%fe etc. are bytes escaped
|
||||
// http://www.ietf.org/rfc/rfc2396.txt
|
||||
// http://www.ietf.org/rfc/rfc1738.txt
|
||||
// http://equinox-project.org/spec/file-uri-spec.txt
|
||||
// http://en.wikipedia.org/wiki/File_URI_scheme
|
||||
}
|
||||
return file;
|
||||
}
|
||||
|
||||
#include "interfaces/efl_vpath_core.eo.c"
|
||||
|
|
@ -1,33 +0,0 @@
|
|||
class Efl.Vpath.Core (Efl.Object, Efl.Vpath)
|
||||
{
|
||||
[[ Core EFL implementation of a Vpath system
|
||||
|
||||
@since 1.18
|
||||
]]
|
||||
eo_prefix: efl_vpath_core;
|
||||
methods {
|
||||
core_get @class {
|
||||
[[ This gets the global EFL Core Vpath class - only 1 - singleton ]]
|
||||
return: Efl.Vpath.Core; [[ Get the singleton core vpath ]]
|
||||
}
|
||||
meta_set {
|
||||
[[ A Meta key is a mapping from a virtual path to a real one ]]
|
||||
params {
|
||||
key: string; [[ The magic path key being looked up ]]
|
||||
path: string; [[ The real path the key maps to ]]
|
||||
}
|
||||
}
|
||||
meta_get {
|
||||
[[ This returns the real path set for a Meta key, or NULL if not ]]
|
||||
params {
|
||||
key: string; [[ The magic path key being looked up ]]
|
||||
}
|
||||
return: string; [[Real file path]]
|
||||
}
|
||||
}
|
||||
implements {
|
||||
Efl.Object.constructor;
|
||||
Efl.Object.destructor;
|
||||
Efl.Vpath.fetch;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,74 +0,0 @@
|
|||
#include "config.h"
|
||||
#include "Efl.h"
|
||||
|
||||
#define MY_CLASS EFL_VPATH_FILE_CLASS
|
||||
|
||||
typedef struct _Efl_Vpath_File_Data Efl_Vpath_File_Data;
|
||||
|
||||
struct _Efl_Vpath_File_Data
|
||||
{
|
||||
const char *path;
|
||||
const char *result;
|
||||
Eina_Bool called : 1;
|
||||
Eina_Bool keep : 1;
|
||||
};
|
||||
|
||||
EOLIAN static void
|
||||
_efl_vpath_file_path_set(Eo *obj EINA_UNUSED, Efl_Vpath_File_Data *pd, const char *path)
|
||||
{
|
||||
eina_stringshare_replace(&(pd->path), path);
|
||||
}
|
||||
|
||||
EOLIAN static const char *
|
||||
_efl_vpath_file_path_get(Eo *obj EINA_UNUSED, Efl_Vpath_File_Data *pd)
|
||||
{
|
||||
return pd->path;
|
||||
}
|
||||
|
||||
EOLIAN static void
|
||||
_efl_vpath_file_result_set(Eo *obj EINA_UNUSED, Efl_Vpath_File_Data *pd, const char *path)
|
||||
{
|
||||
eina_stringshare_replace(&(pd->result), path);
|
||||
}
|
||||
|
||||
EOLIAN static const char *
|
||||
_efl_vpath_file_result_get(Eo *obj EINA_UNUSED, Efl_Vpath_File_Data *pd)
|
||||
{
|
||||
return pd->result;
|
||||
}
|
||||
|
||||
EOLIAN static void
|
||||
_efl_vpath_file_keep_set(Eo *obj EINA_UNUSED, Efl_Vpath_File_Data *pd, Eina_Bool keep)
|
||||
{
|
||||
pd->keep = keep;
|
||||
}
|
||||
|
||||
EOLIAN static Eina_Bool
|
||||
_efl_vpath_file_keep_get(Eo *obj EINA_UNUSED, Efl_Vpath_File_Data *pd)
|
||||
{
|
||||
return pd->keep;
|
||||
}
|
||||
|
||||
EOLIAN static Eina_Bool
|
||||
_efl_vpath_file_do(Eo *obj EINA_UNUSED, Efl_Vpath_File_Data *pd)
|
||||
{
|
||||
if (pd->called) return EINA_FALSE;
|
||||
pd->called = EINA_TRUE;
|
||||
efl_event_callback_call(obj, EFL_VPATH_FILE_EVENT_FETCHED, NULL);
|
||||
return EINA_TRUE;
|
||||
}
|
||||
|
||||
EOLIAN static void
|
||||
_efl_vpath_file_wait(Eo *obj EINA_UNUSED, Efl_Vpath_File_Data *pd EINA_UNUSED)
|
||||
{
|
||||
if (!pd->called)
|
||||
{
|
||||
pd->called = EINA_TRUE;
|
||||
if (pd->result)
|
||||
efl_event_callback_call(obj, EFL_VPATH_FILE_EVENT_FETCHED, NULL);
|
||||
else
|
||||
efl_event_callback_call(obj, EFL_VPATH_FILE_EVENT_FAILED, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
#include "interfaces/efl_vpath_file.eo.c"
|
||||
|
|
@ -1,55 +0,0 @@
|
|||
class Efl.Vpath.File (Efl.Object)
|
||||
{
|
||||
[[ VPath File is an actual representation of a downloaded/mapped vpath file
|
||||
|
||||
Keep this object around for as long as you need to use the file as it
|
||||
may have been downloaded and kept as a local temporary file and
|
||||
deletion may remove it.
|
||||
|
||||
When you have a Vpath File object for the first time, call the do()
|
||||
method on it to actually begin/do the mapping. From here the
|
||||
fetched or failed event callbacks will be called, inside of which or
|
||||
afterwards you can fetch the resulting local file path by getting the
|
||||
result property.
|
||||
|
||||
@since 1.18
|
||||
]]
|
||||
eo_prefix: efl_vpath_file;
|
||||
methods {
|
||||
@property path {
|
||||
[[ The original source path provided to lookup/fetch from ]]
|
||||
set {}
|
||||
get {}
|
||||
values {
|
||||
path: string; [[ The input virtual path to a file ]]
|
||||
}
|
||||
}
|
||||
@property result {
|
||||
[[ The resulting real local file path to open/read ]]
|
||||
set {}
|
||||
get {}
|
||||
values {
|
||||
path: string; [[ The resulting destination file ]]
|
||||
}
|
||||
}
|
||||
@property keep {
|
||||
[[ If this object has to be kept for the usage of the result ]]
|
||||
set {}
|
||||
get {}
|
||||
values {
|
||||
keep: bool; [[ If the object neerds tobe kept around ]]
|
||||
}
|
||||
}
|
||||
do {
|
||||
[[ Actually begin the resolving here - emit event now or do later ]]
|
||||
return: bool; [[ Result callback already called ]]
|
||||
}
|
||||
wait {
|
||||
[[ If not fetched yet, wait until it is and call result cb ]]
|
||||
}
|
||||
}
|
||||
events {
|
||||
fetched; [[ File successfully mapped/fetched ]]
|
||||
failed; [[ File fetch or mapping failed ]]
|
||||
}
|
||||
}
|
||||
|
|
@ -1,66 +0,0 @@
|
|||
#include "config.h"
|
||||
#include "Efl.h"
|
||||
|
||||
#define MY_CLASS EFL_VPATH_FILE_CORE_CLASS
|
||||
|
||||
typedef struct _Efl_Vpath_File_Core_Data Efl_Vpath_File_Core_Data;
|
||||
|
||||
struct _Efl_Vpath_File_Core_Data
|
||||
{
|
||||
int dummy;
|
||||
};
|
||||
|
||||
EOLIAN static Efl_Object *
|
||||
_efl_vpath_file_core_efl_object_constructor(Eo *obj, Efl_Vpath_File_Core_Data *pd)
|
||||
{
|
||||
obj = efl_constructor(efl_super(obj, MY_CLASS));
|
||||
pd->dummy = 0;
|
||||
return obj;
|
||||
}
|
||||
|
||||
EOLIAN static void
|
||||
_efl_vpath_file_core_efl_object_destructor(Eo *obj, Efl_Vpath_File_Core_Data *pd)
|
||||
{
|
||||
pd->dummy = 0;
|
||||
efl_destructor(efl_super(obj, MY_CLASS));
|
||||
}
|
||||
|
||||
EOLIAN static Eina_Bool
|
||||
_efl_vpath_file_core_efl_vpath_file_do(Eo *obj, Efl_Vpath_File_Core_Data *pd)
|
||||
{
|
||||
const char *path;
|
||||
|
||||
if (efl_vpath_file_result_get(obj))
|
||||
return efl_vpath_file_do(efl_super(obj, MY_CLASS));
|
||||
// vpath core didn't find a match, so it'ss likely a protocol like
|
||||
// http:// etc. etc. so deal with that here
|
||||
path = efl_vpath_file_path_get(obj);
|
||||
if (path)
|
||||
{
|
||||
if ((!strncasecmp(path, "http://", 7)) ||
|
||||
(!strncasecmp(path, "https://", 8)))
|
||||
{
|
||||
// XXX: handle urls --- need a loop object
|
||||
}
|
||||
}
|
||||
// ...
|
||||
pd->dummy = 0;
|
||||
|
||||
// not a magic path - just set result to path
|
||||
efl_vpath_file_result_set(obj, efl_vpath_file_path_get(obj));
|
||||
return efl_vpath_file_do(efl_super(obj, MY_CLASS));
|
||||
}
|
||||
|
||||
EOLIAN static void
|
||||
_efl_vpath_file_core_efl_vpath_file_wait(Eo *obj, Efl_Vpath_File_Core_Data *pd)
|
||||
{
|
||||
if (efl_vpath_file_result_get(obj))
|
||||
{
|
||||
efl_vpath_file_do(efl_super(obj, MY_CLASS));
|
||||
return;
|
||||
}
|
||||
pd->dummy = 0;
|
||||
// XXX: not found yet, so do what is necessary
|
||||
}
|
||||
|
||||
#include "interfaces/efl_vpath_file_core.eo.c"
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
class Efl.Vpath.File.Core (Efl.Vpath.File)
|
||||
{
|
||||
[[ Core EFL implementation of a Vpath File
|
||||
|
||||
@since 1.18
|
||||
]]
|
||||
eo_prefix: efl_vpath_file_core;
|
||||
implements {
|
||||
Efl.Object.constructor;
|
||||
Efl.Object.destructor;
|
||||
Efl.Vpath.File.do;
|
||||
Efl.Vpath.File.wait;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,88 +0,0 @@
|
|||
#include "config.h"
|
||||
#include "Efl.h"
|
||||
|
||||
#define MY_CLASS EFL_VPATH_MANAGER_CLASS
|
||||
|
||||
typedef struct _Efl_Vpath_Manager_Data Efl_Vpath_Manager_Data;
|
||||
typedef struct _Efl_Vpath_Manager_Entry Efl_Vpath_Manager_Entry;
|
||||
|
||||
struct _Efl_Vpath_Manager_Data
|
||||
{
|
||||
Eina_List *list;
|
||||
};
|
||||
|
||||
struct _Efl_Vpath_Manager_Entry
|
||||
{
|
||||
Efl_Vpath *vpath;
|
||||
int priority;
|
||||
};
|
||||
|
||||
static Efl_Vpath_Manager_Data vpath_manager =
|
||||
{
|
||||
NULL
|
||||
};
|
||||
|
||||
EOLIAN static Efl_Vpath_File *
|
||||
_efl_vpath_manager_fetch(Eo *obj EINA_UNUSED, void *pd EINA_UNUSED, const char *path)
|
||||
{
|
||||
Efl_Vpath_Manager_Entry *entry;
|
||||
Eina_List *l;
|
||||
Efl_Vpath_File *file;
|
||||
|
||||
EINA_LIST_FOREACH(vpath_manager.list, l, entry)
|
||||
{
|
||||
file = efl_vpath_fetch(entry->vpath, path);
|
||||
if (file) return file;
|
||||
}
|
||||
file = efl_add(EFL_VPATH_FILE_CLASS, NULL);
|
||||
if (file)
|
||||
{
|
||||
efl_vpath_file_path_set(file, path);
|
||||
efl_vpath_file_result_set(file, path);
|
||||
}
|
||||
return file;
|
||||
}
|
||||
|
||||
static int
|
||||
_register_sort_cb(Efl_Vpath_Manager_Entry *e1, Efl_Vpath_Manager_Entry *e2)
|
||||
{
|
||||
// sort higher numbers first in list
|
||||
return (e2->priority - e1->priority);
|
||||
}
|
||||
|
||||
static void
|
||||
_cb_vpath_del(void *data, const Efl_Event *event)
|
||||
{
|
||||
efl_vpath_manager_unregister(EFL_VPATH_MANAGER_CLASS, event->object);
|
||||
efl_event_callback_del(event->object, EFL_EVENT_DEL, _cb_vpath_del, data);
|
||||
}
|
||||
|
||||
EOLIAN static void
|
||||
_efl_vpath_manager_register(Eo *obj, void *pd EINA_UNUSED, int priority, Efl_Vpath *vpath)
|
||||
{
|
||||
Efl_Vpath_Manager_Entry *entry = malloc(sizeof(Efl_Vpath_Manager_Entry));
|
||||
entry->vpath = vpath;
|
||||
entry->priority = priority;
|
||||
efl_event_callback_add(vpath, EFL_EVENT_DEL, _cb_vpath_del, obj);
|
||||
vpath_manager.list = eina_list_sorted_insert
|
||||
(vpath_manager.list, EINA_COMPARE_CB(_register_sort_cb), entry);
|
||||
}
|
||||
|
||||
EOLIAN static void
|
||||
_efl_vpath_manager_unregister(Eo *obj EINA_UNUSED, void *pd EINA_UNUSED, Efl_Vpath *vpath)
|
||||
{
|
||||
Efl_Vpath_Manager_Entry *entry;
|
||||
Eina_List *l;
|
||||
|
||||
EINA_LIST_FOREACH(vpath_manager.list, l, entry)
|
||||
{
|
||||
if (entry->vpath == vpath)
|
||||
{
|
||||
vpath_manager.list = eina_list_remove_list(vpath_manager.list, l);
|
||||
free(entry);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#include "interfaces/efl_vpath_manager.eo.c"
|
||||
|
|
@ -1,30 +0,0 @@
|
|||
class Efl.Vpath.Manager (Efl.Object)
|
||||
{
|
||||
[[ Vpath Manager manages multiple VPath objects that remap/download
|
||||
|
||||
@since 1.18
|
||||
]]
|
||||
eo_prefix: efl_vpath_manager;
|
||||
methods {
|
||||
fetch @class {
|
||||
[[ This class function fetches a Vpath File given an input path ]]
|
||||
params {
|
||||
path: string; [[ The input virtual file path to fetch ]]
|
||||
}
|
||||
return: Efl.Vpath.File @owned; [[ An object representing the file ]]
|
||||
}
|
||||
register @class {
|
||||
[[Register a vpath with the manager ]]
|
||||
params {
|
||||
priority: int; [[ Search order - higher values tried first ]]
|
||||
vpath: Efl.Vpath @nonull; [[ A Vpath implementation object ]]
|
||||
}
|
||||
}
|
||||
unregister @class {
|
||||
[[ Unregister a vpath from the manager ]]
|
||||
params {
|
||||
vpath: Efl.Vpath @nonull; [[ A Vpath implementation object ]]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue