int autocomplete_directory(struct bContext *C, char *str, void *UNUSED(arg_v))
{
SpaceFile *sfile = CTX_wm_space_file(C);
int match = AUTOCOMPLETE_NO_MATCH;
/* search if str matches the beginning of name */
if (str[0] && sfile->files) {
char dirname[FILE_MAX];
DIR *dir;
struct dirent *de;
BLI_split_dir_part(str, dirname, sizeof(dirname));
dir = opendir(dirname);
if (dir) {
AutoComplete *autocpl = autocomplete_begin(str, FILE_MAX);
while ((de = readdir(dir)) != NULL) {
if (strcmp(".", de->d_name) == 0 || strcmp("..", de->d_name) == 0) {
/* pass */
}
else {
char path[FILE_MAX];
BLI_stat_t status;
BLI_join_dirfile(path, sizeof(path), dirname, de->d_name);
if (BLI_stat(path, &status) == 0) {
if (S_ISDIR(status.st_mode)) { /* is subdir */
autocomplete_do_name(autocpl, path);
}
}
}
}
closedir(dir);
match = autocomplete_end(autocpl, str);
if (match) {
if (match == AUTOCOMPLETE_FULL_MATCH) {
BLI_add_slash(str);
}
else {
BLI_strncpy(sfile->params->dir, str, sizeof(sfile->params->dir));
}
}
}
}
return match;
}
void WM_file_autoexec_init(const char *filepath)
{
if (G.f & G_SCRIPT_OVERRIDE_PREF) {
return;
}
if (G.f & G_SCRIPT_AUTOEXEC) {
char path[FILE_MAX];
BLI_split_dir_part(filepath, path, sizeof(path));
if (BKE_autoexec_match(path)) {
G.f &= ~G_SCRIPT_AUTOEXEC;
}
}
}
void ImagesExporter::operator()(Material *ma, Object *ob)
{
int a;
for (a = 0; a < MAX_MTEX; a++) {
MTex *mtex = ma->mtex[a];
if (mtex && mtex->tex && mtex->tex->ima) {
Image *image = mtex->tex->ima;
std::string name(id_name(image));
name = translate_id(name);
char rel[FILE_MAX];
char abs[FILE_MAX];
char src[FILE_MAX];
char dir[FILE_MAX];
BLI_split_dir_part(this->export_settings->filepath, dir, sizeof(dir));
BKE_rebase_path(abs, sizeof(abs), rel, sizeof(rel), G.main->name, image->name, dir);
if (abs[0] != '\0') {
// make absolute source path
BLI_strncpy(src, image->name, sizeof(src));
BLI_path_abs(src, G.main->name);
// make dest directory if it doesn't exist
BLI_make_existing_file(abs);
if (BLI_copy(src, abs) != 0) {
fprintf(stderr, "Cannot copy image to file's directory.\n");
}
}
if (find(mImages.begin(), mImages.end(), name) == mImages.end()) {
COLLADASW::Image img(COLLADABU::URI(COLLADABU::URI::nativePathToUri(rel)), name, name); /* set name also to mNameNC. This helps other viewers import files exported from Blender better */
img.add(mSW);
mImages.push_back(name);
}
}
}
}
void BLI_init_program_path(const char *argv0)
{
bli_where_am_i(bprogname, sizeof(bprogname), argv0);
BLI_split_dir_part(bprogname, bprogdir, sizeof(bprogdir));
}
/**
* Produce image export path.
*
* Returns:
* 0 if image filename is empty or if destination path
* matches image path (i.e. both are the same file).
* 2 if source is identical to destination.
* 1 if rebase was successful
* -------------------------------------------------------------
* Hint: Trailing slash in dest_dir is optional.
*
* Logic:
*
* - if an image is "below" current .blend file directory:
* rebuild the same dir structure in dest_dir
*
* Example:
* src : //textures/foo/bar.png
* dest: [dest_dir]/textures/foo/bar.png.
*
* - if an image is not "below" current .blend file directory,
* disregard it's path and copy it into the destination
* directory.
*
* Example:
* src : //../foo/bar.png becomes
* dest: [dest_dir]/bar.png.
*
* This logic ensures that all image paths are relative and
* that a user gets his images in one place. It'll also provide
* consistent behavior across exporters.
* IMPORTANT NOTE: If base_dir contains an empty string, then
* this function returns wrong results!
* XXX: test on empty base_dir and return an error ?
*/
int BLI_rebase_path(char *abs, size_t abs_len, char *rel, size_t rel_len, const char *base_dir, const char *src_dir, const char *dest_dir)
{
char path[FILE_MAX];
char dir[FILE_MAX];
char base[FILE_MAX];
char blend_dir[FILE_MAX]; /* directory, where current .blend file resides */
char dest_path[FILE_MAX];
char rel_dir[FILE_MAX];
int len;
if (abs)
abs[0] = 0;
if (rel)
rel[0] = 0;
BLI_split_dir_part(base_dir, blend_dir, sizeof(blend_dir));
if (src_dir[0] == '\0')
return BLI_REBASE_NO_SRCDIR;
BLI_strncpy(path, src_dir, sizeof(path));
/* expand "//" in filename and get absolute path */
BLI_path_abs(path, base_dir);
/* get the directory part */
BLI_split_dirfile(path, dir, base, sizeof(dir), sizeof(base));
len = strlen(blend_dir);
rel_dir[0] = 0;
/* if image is "below" current .blend file directory */
if (!BLI_path_ncmp(path, blend_dir, len)) {
/* if image is _in_ current .blend file directory */
if (BLI_path_cmp(dir, blend_dir) == 0) {
BLI_join_dirfile(dest_path, sizeof(dest_path), dest_dir, base);
}
/* "below" */
else {
/* rel = image_path_dir - blend_dir */
BLI_strncpy(rel_dir, dir + len, sizeof(rel_dir));
BLI_join_dirfile(dest_path, sizeof(dest_path), dest_dir, rel_dir);
BLI_join_dirfile(dest_path, sizeof(dest_path), dest_path, base);
}
}
/* image is out of current directory */
else {
BLI_join_dirfile(dest_path, sizeof(dest_path), dest_dir, base);
}
if (abs)
BLI_strncpy(abs, dest_path, abs_len);
if (rel) {
strncat(rel, rel_dir, rel_len);
strncat(rel, base, rel_len);
}
/* return 2 if (src == dest) */
if (BLI_path_cmp(path, dest_path) == 0) {
// if (G.debug & G_DEBUG) printf("%s and %s are the same file\n", path, dest_path);
return BLI_REBASE_IDENTITY;
}
return BLI_REBASE_OK;
}
/**
* \note RNA_struct_property_is_set_ex is used here because we want
* the previously used settings to be used here rather then overriding them */
short ED_fileselect_set_params(SpaceFile *sfile)
{
FileSelectParams *params;
wmOperator *op = sfile->op;
/* create new parameters if necessary */
if (!sfile->params) {
sfile->params = MEM_callocN(sizeof(FileSelectParams), "fileselparams");
/* set path to most recently opened .blend */
BLI_split_dirfile(G.main->name, sfile->params->dir, sfile->params->file, sizeof(sfile->params->dir), sizeof(sfile->params->file));
sfile->params->filter_glob[0] = '\0';
/* set the default thumbnails size */
sfile->params->thumbnail_size = 128;
}
params = sfile->params;
/* set the parameters from the operator, if it exists */
if (op) {
PropertyRNA *prop;
const bool is_files = (RNA_struct_find_property(op->ptr, "files") != NULL);
const bool is_filepath = (RNA_struct_find_property(op->ptr, "filepath") != NULL);
const bool is_filename = (RNA_struct_find_property(op->ptr, "filename") != NULL);
const bool is_directory = (RNA_struct_find_property(op->ptr, "directory") != NULL);
const bool is_relative_path = (RNA_struct_find_property(op->ptr, "relative_path") != NULL);
BLI_strncpy_utf8(params->title, RNA_struct_ui_name(op->type->srna), sizeof(params->title));
if ((prop = RNA_struct_find_property(op->ptr, "filemode"))) {
params->type = RNA_property_int_get(op->ptr, prop);
}
else {
params->type = FILE_SPECIAL;
}
if (is_filepath && RNA_struct_property_is_set_ex(op->ptr, "filepath", false)) {
char name[FILE_MAX];
RNA_string_get(op->ptr, "filepath", name);
if (params->type == FILE_LOADLIB) {
BLI_strncpy(params->dir, name, sizeof(params->dir));
sfile->params->file[0] = '\0';
}
else {
BLI_split_dirfile(name, sfile->params->dir, sfile->params->file, sizeof(sfile->params->dir), sizeof(sfile->params->file));
}
}
else {
if (is_directory && RNA_struct_property_is_set_ex(op->ptr, "directory", false)) {
RNA_string_get(op->ptr, "directory", params->dir);
sfile->params->file[0] = '\0';
}
if (is_filename && RNA_struct_property_is_set_ex(op->ptr, "filename", false)) {
RNA_string_get(op->ptr, "filename", params->file);
}
}
if (params->dir[0]) {
BLI_cleanup_dir(G.main->name, params->dir);
BLI_path_abs(params->dir, G.main->name);
}
if (is_directory == true && is_filename == false && is_filepath == false && is_files == false) {
params->flag |= FILE_DIRSEL_ONLY;
}
else {
params->flag &= ~FILE_DIRSEL_ONLY;
}
params->filter = 0;
if ((prop = RNA_struct_find_property(op->ptr, "filter_blender")))
params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_BLENDER : 0;
if ((prop = RNA_struct_find_property(op->ptr, "filter_backup")))
params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_BLENDER_BACKUP : 0;
if ((prop = RNA_struct_find_property(op->ptr, "filter_image")))
params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_IMAGE : 0;
if ((prop = RNA_struct_find_property(op->ptr, "filter_movie")))
params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_MOVIE : 0;
if ((prop = RNA_struct_find_property(op->ptr, "filter_python")))
params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_PYSCRIPT : 0;
if ((prop = RNA_struct_find_property(op->ptr, "filter_font")))
params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_FTFONT : 0;
if ((prop = RNA_struct_find_property(op->ptr, "filter_sound")))
params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_SOUND : 0;
if ((prop = RNA_struct_find_property(op->ptr, "filter_text")))
params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_TEXT : 0;
if ((prop = RNA_struct_find_property(op->ptr, "filter_folder")))
params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_FOLDER : 0;
if ((prop = RNA_struct_find_property(op->ptr, "filter_btx")))
params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_BTX : 0;
if ((prop = RNA_struct_find_property(op->ptr, "filter_collada")))
params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_COLLADA : 0;
if ((prop = RNA_struct_find_property(op->ptr, "filter_glob"))) {
RNA_property_string_get(op->ptr, prop, params->filter_glob);
params->filter |= (FILE_TYPE_OPERATOR | FILE_TYPE_FOLDER);
}
else {
params->filter_glob[0] = '\0';
}
if (params->filter != 0) {
if (U.uiflag & USER_FILTERFILEEXTS) {
params->flag |= FILE_FILTER;
}
else {
params->flag &= ~FILE_FILTER;
}
}
if (U.uiflag & USER_HIDE_DOT) {
params->flag |= FILE_HIDE_DOT;
}
else {
params->flag &= ~FILE_HIDE_DOT;
}
if (params->type == FILE_LOADLIB) {
params->flag |= RNA_boolean_get(op->ptr, "link") ? FILE_LINK : 0;
params->flag |= RNA_boolean_get(op->ptr, "autoselect") ? FILE_AUTOSELECT : 0;
params->flag |= RNA_boolean_get(op->ptr, "active_layer") ? FILE_ACTIVELAY : 0;
}
if ((prop = RNA_struct_find_property(op->ptr, "display_type"))) {
params->display = RNA_property_enum_get(op->ptr, prop);
}
if (params->display == FILE_DEFAULTDISPLAY) {
if (U.uiflag & USER_SHOW_THUMBNAILS) {
if (params->filter & (FILE_TYPE_IMAGE | FILE_TYPE_MOVIE))
params->display = FILE_IMGDISPLAY;
else
params->display = FILE_SHORTDISPLAY;
}
else {
params->display = FILE_SHORTDISPLAY;
}
}
if (is_relative_path) {
if ((prop = RNA_struct_find_property(op->ptr, "relative_path"))) {
if (!RNA_property_is_set_ex(op->ptr, prop, false)) {
RNA_property_boolean_set(op->ptr, prop, (U.flag & USER_RELPATHS) != 0);
}
}
}
}
else {
/* default values, if no operator */
params->type = FILE_UNIX;
params->flag |= FILE_HIDE_DOT;
params->flag &= ~FILE_DIRSEL_ONLY;
params->display = FILE_SHORTDISPLAY;
params->filter = 0;
params->filter_glob[0] = '\0';
}
/* operator has no setting for this */
params->sort = FILE_SORT_ALPHA;
params->active_file = -1;
/* initialize the list with previous folders */
if (!sfile->folders_prev)
sfile->folders_prev = folderlist_new();
if (!sfile->params->dir[0]) {
if (G.main->name[0]) {
BLI_split_dir_part(G.main->name, sfile->params->dir, sizeof(sfile->params->dir));
}
else {
const char *doc_path = BKE_appdir_folder_default();
if (doc_path) {
BLI_strncpy(sfile->params->dir, doc_path, sizeof(sfile->params->dir));
}
}
}
folderlist_pushdir(sfile->folders_prev, sfile->params->dir);
/* switching thumbnails needs to recalc layout [#28809] */
if (sfile->layout) {
sfile->layout->dirty = true;
}
return 1;
}
static int get_sequence_len(char *filename, int *ofs)
{
int frame;
int numdigit;
if (!BLI_path_frame_get(filename, &frame, &numdigit)) {
return 1;
}
char path[FILE_MAX];
BLI_path_abs(filename, G.main->name);
BLI_split_dir_part(filename, path, FILE_MAX);
if (path[0] == '\0') {
/* The filename had no path, so just use the blend file path. */
BLI_split_dir_part(G.main->name, path, FILE_MAX);
}
DIR *dir = opendir(path);
if (dir == NULL) {
fprintf(stderr, "Error opening directory '%s': %s\n",
path, errno ? strerror(errno) : "unknown error");
return -1;
}
const char *ext = ".abc";
const char *basename = BLI_path_basename(filename);
const int len = strlen(basename) - (numdigit + strlen(ext));
ListBase frames;
BLI_listbase_clear(&frames);
struct dirent *fname;
while ((fname = readdir(dir)) != NULL) {
/* do we have the right extension? */
if (!strstr(fname->d_name, ext)) {
continue;
}
if (!STREQLEN(basename, fname->d_name, len)) {
continue;
}
CacheFrame *cache_frame = MEM_callocN(sizeof(CacheFrame), "abc_frame");
BLI_path_frame_get(fname->d_name, &cache_frame->framenr, &numdigit);
BLI_addtail(&frames, cache_frame);
}
closedir(dir);
BLI_listbase_sort(&frames, cmp_frame);
CacheFrame *cache_frame = frames.first;
if (cache_frame) {
int frame_curr = cache_frame->framenr;
(*ofs) = frame_curr;
while (cache_frame && (cache_frame->framenr == frame_curr)) {
++frame_curr;
cache_frame = cache_frame->next;
}
BLI_freelistN(&frames);
return frame_curr - (*ofs);
}
return 1;
}
static int get_sequence_len(char *filename, int *ofs)
{
int frame;
int numdigit;
if (!BLI_path_frame_get(filename, &frame, &numdigit)) {
return 1;
}
char path[FILE_MAX];
BLI_split_dir_part(filename, path, FILE_MAX);
DIR *dir = opendir(path);
const char *ext = ".abc";
const char *basename = BLI_path_basename(filename);
const int len = strlen(basename) - (numdigit + strlen(ext));
ListBase frames;
BLI_listbase_clear(&frames);
struct dirent *fname;
while ((fname = readdir(dir)) != NULL) {
/* do we have the right extension? */
if (!strstr(fname->d_name, ext)) {
continue;
}
if (!STREQLEN(basename, fname->d_name, len)) {
continue;
}
CacheFrame *cache_frame = MEM_callocN(sizeof(CacheFrame), "abc_frame");
BLI_path_frame_get(fname->d_name, &cache_frame->framenr, &numdigit);
BLI_addtail(&frames, cache_frame);
}
closedir(dir);
BLI_listbase_sort(&frames, cmp_frame);
CacheFrame *cache_frame = frames.first;
if (cache_frame) {
int frame_curr = cache_frame->framenr;
(*ofs) = frame_curr;
while (cache_frame && (cache_frame->framenr == frame_curr)) {
++frame_curr;
cache_frame = cache_frame->next;
}
BLI_freelistN(&frames);
return frame_curr - (*ofs);
}
return 1;
}
void ImagesExporter::export_UV_Image(Image *image, bool use_copies)
{
std::string name(id_name(image));
std::string translated_name(translate_id(name));
bool not_yet_exported = find(mImages.begin(), mImages.end(), translated_name) == mImages.end();
if (not_yet_exported) {
ImBuf *imbuf = BKE_image_acquire_ibuf(image, NULL, NULL);
if (!imbuf) {
fprintf(stderr, "Collada export: image does not exist:\n%s\n", image->name);
return;
}
bool is_dirty = (imbuf->userflags & IB_BITMAPDIRTY) != 0;
ImageFormatData imageFormat;
BKE_imbuf_to_image_format(&imageFormat, imbuf);
short image_source = image->source;
bool is_generated = image_source == IMA_SRC_GENERATED;
bool is_packed = image->packedfile != NULL;
char export_path[FILE_MAX];
char source_path[FILE_MAX];
char export_dir[FILE_MAX];
char export_file[FILE_MAX];
// Destination folder for exported assets
BLI_split_dir_part(this->export_settings->filepath, export_dir, sizeof(export_dir));
if (is_generated || is_dirty || use_copies || is_packed) {
// make absolute destination path
BLI_strncpy(export_file, name.c_str(), sizeof(export_file));
BKE_image_path_ensure_ext_from_imformat(export_file, &imageFormat);
BLI_join_dirfile(export_path, sizeof(export_path), export_dir, export_file);
// make dest directory if it doesn't exist
BLI_make_existing_file(export_path);
}
if (is_generated || is_dirty || is_packed) {
// This image in its current state only exists in Blender memory.
// So we have to export it. The export will keep the image state intact,
// so the exported file will not be associated with the image.
if (BKE_imbuf_write_as(imbuf, export_path, &imageFormat, true) == 0) {
fprintf(stderr, "Collada export: Cannot export image to:\n%s\n", export_path);
return;
}
BLI_strncpy(export_path, export_file, sizeof(export_path));
}
else {
// make absolute source path
BLI_strncpy(source_path, image->name, sizeof(source_path));
BLI_path_abs(source_path, G.main->name);
BLI_cleanup_path(NULL, source_path);
if (use_copies) {
// This image is already located on the file system.
// But we want to create copies here.
// To move images into the same export directory.
// Note: If an image is already located in the export folder,
// then skip the copy (as it would result in a file copy error).
if (BLI_path_cmp(source_path, export_path) != 0) {
if (BLI_copy(source_path, export_path) != 0) {
fprintf(stderr, "Collada export: Cannot copy image:\n source:%s\ndest :%s\n", source_path, export_path);
return;
}
}
BLI_strncpy(export_path, export_file, sizeof(export_path));
}
else {
// Do not make any copies, but use the source path directly as reference
// to the original image
BLI_strncpy(export_path, source_path, sizeof(export_path));
}
}
COLLADASW::Image img(COLLADABU::URI(COLLADABU::URI::nativePathToUri(export_path)), translated_name, translated_name); /* set name also to mNameNC. This helps other viewers import files exported from Blender better */
img.add(mSW);
fprintf(stdout, "Collada export: Added image: %s\n", export_file);
mImages.push_back(translated_name);
BKE_image_release_ibuf(image, imbuf, NULL);
}
}
