void autocomplete_directory(struct bContext *C, char *str, void *arg_v)
{
char tmp[FILE_MAX];
SpaceFile *sfile= CTX_wm_space_file(C);
/* search if str matches the beginning of name */
if(str[0] && sfile->files) {
AutoComplete *autocpl= autocomplete_begin(str, FILE_MAX);
int nentries = filelist_numfiles(sfile->files);
int i;
for(i= 0; i<nentries; ++i) {
struct direntry* file = filelist_file(sfile->files, i);
const char* dir = filelist_dir(sfile->files);
if (file && S_ISDIR(file->type)) {
// BLI_make_file_string(G.sce, tmp, dir, file->relname);
BLI_join_dirfile(tmp, dir, file->relname);
autocomplete_do_name(autocpl,tmp);
}
}
autocomplete_end(autocpl, str);
if (BLI_exists(str)) {
BLI_add_slash(str);
} else {
BLI_make_exist(str);
}
}
}
static void file_panel_category(const bContext *C, Panel *pa, FSMenuCategory category, short *nr, int icon, int allow_delete)
{
SpaceFile *sfile = CTX_wm_space_file(C);
uiBlock *block;
uiBut *but;
uiLayout *box, *col;
struct FSMenu *fsmenu = fsmenu_get();
int i, nentries = fsmenu_get_nentries(fsmenu, category);
/* reset each time */
*nr = -1;
/* hide if no entries */
if (nentries == 0)
return;
/* layout */
uiLayoutSetAlignment(pa->layout, UI_LAYOUT_ALIGN_LEFT);
block = uiLayoutGetBlock(pa->layout);
box = uiLayoutBox(pa->layout);
col = uiLayoutColumn(box, TRUE);
for (i = 0; i < nentries; ++i) {
char dir[FILE_MAX];
char temp[FILE_MAX];
uiLayout *layout = uiLayoutRow(col, FALSE);
char *entry;
entry = fsmenu_get_entry(fsmenu, category, i);
/* set this list item as active if we have a match */
if (sfile->params) {
if (BLI_path_cmp(sfile->params->dir, entry) == 0) {
*nr = i;
}
}
/* create nice bookmark name, shows last directory in the full path currently */
BLI_strncpy(temp, entry, FILE_MAX);
BLI_add_slash(temp);
BLI_getlastdir(temp, dir, FILE_MAX);
BLI_del_slash(dir);
if (dir[0] == 0)
BLI_strncpy(dir, entry, FILE_MAX);
/* create list item */
but = uiDefIconTextButS(block, LISTROW, 0, icon, dir, 0, 0, UI_UNIT_X * 10, UI_UNIT_Y, nr, 0, i, 0, 0, entry);
uiButSetFunc(but, file_panel_cb, entry, NULL);
uiButClearFlag(but, UI_BUT_UNDO); /* skip undo on screen buttons */
uiButSetFlag(but, UI_ICON_LEFT | UI_TEXT_LEFT);
/* create delete button */
if (allow_delete && fsmenu_can_save(fsmenu, category, i)) {
uiBlockSetEmboss(block, UI_EMBOSSN);
uiItemIntO(layout, "", ICON_X, "FILE_OT_delete_bookmark", "index", i);
uiBlockSetEmboss(block, UI_EMBOSS);
}
}
}
int file_directory_exec(bContext *C, wmOperator *UNUSED(unused))
{
SpaceFile *sfile= CTX_wm_space_file(C);
if(sfile->params) {
file_expand_directory(C);
if (!BLI_exists(sfile->params->dir)) {
BLI_recurdir_fileops(sfile->params->dir);
}
/* special case, user may have pasted a fulepath into the directory */
if(BLI_exists(sfile->params->dir) && BLI_is_dir(sfile->params->dir) == 0) {
char path[sizeof(sfile->params->dir)];
BLI_strncpy(path, sfile->params->dir, sizeof(path));
BLI_split_dirfile(path, sfile->params->dir, sfile->params->file);
}
BLI_cleanup_dir(G.main->name, sfile->params->dir);
BLI_add_slash(sfile->params->dir);
file_change_dir(C, 1);
WM_event_add_notifier(C, NC_SPACE|ND_SPACE_FILE_LIST, NULL);
}
return OPERATOR_FINISHED;
}
static int file_browse_exec(bContext *C, wmOperator *op)
{
FileBrowseOp *fbo = op->customdata;
ID *id;
char *str, path[FILE_MAX];
const char *path_prop = RNA_struct_find_property(op->ptr, "directory") ? "directory" : "filepath";
if (RNA_struct_property_is_set(op->ptr, path_prop) == 0 || fbo == NULL)
return OPERATOR_CANCELLED;
str = RNA_string_get_alloc(op->ptr, path_prop, NULL, 0);
/* add slash for directories, important for some properties */
if (RNA_property_subtype(fbo->prop) == PROP_DIRPATH) {
int is_relative = RNA_boolean_get(op->ptr, "relative_path");
id = fbo->ptr.id.data;
BLI_strncpy(path, str, FILE_MAX);
BLI_path_abs(path, id ? ID_BLEND_PATH(G.main, id) : G.main->name);
if (BLI_is_dir(path)) {
/* do this first so '//' isnt converted to '//\' on windows */
BLI_add_slash(path);
if (is_relative) {
BLI_strncpy(path, str, FILE_MAX);
BLI_path_rel(path, G.main->name);
str = MEM_reallocN(str, strlen(path) + 2);
BLI_strncpy(str, path, FILE_MAX);
}
else {
str = MEM_reallocN(str, strlen(str) + 2);
}
}
else {
char * const lslash = (char *)BLI_last_slash(str);
if (lslash) lslash[1] = '\0';
}
}
RNA_property_string_set(&fbo->ptr, fbo->prop, str);
RNA_property_update(C, &fbo->ptr, fbo->prop);
MEM_freeN(str);
/* special, annoying exception, filesel on redo panel [#26618] */
{
wmOperator *redo_op = WM_operator_last_redo(C);
if (redo_op) {
if (fbo->ptr.data == redo_op->ptr->data) {
ED_undo_operator_repeat(C, redo_op);
}
}
}
MEM_freeN(op->customdata);
return OPERATOR_FINISHED;
}
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;
}
int BLI_has_parent(char *path)
{
int len;
int slashes = 0;
BLI_clean(path);
len = BLI_add_slash(path) - 1;
while (len >= 0) {
if ((path[len] == '\\') || (path[len] == '/'))
slashes++;
len--;
}
return slashes > 1;
}
static int file_browse_exec(bContext *C, wmOperator *op)
{
FileBrowseOp *fbo= op->customdata;
ID *id;
char *base, *str, path[FILE_MAX];
const char *path_prop= RNA_struct_find_property(op->ptr, "directory") ? "directory" : "filepath";
if (RNA_property_is_set(op->ptr, path_prop)==0 || fbo==NULL)
return OPERATOR_CANCELLED;
str= RNA_string_get_alloc(op->ptr, path_prop, NULL, 0);
/* add slash for directories, important for some properties */
if(RNA_property_subtype(fbo->prop) == PROP_DIRPATH) {
char name[FILE_MAX];
id = fbo->ptr.id.data;
base = (id && id->lib)? id->lib->filepath: G.main->name;
BLI_strncpy(path, str, FILE_MAX);
BLI_path_abs(path, base);
if(BLI_is_dir(path)) {
str = MEM_reallocN(str, strlen(str)+2);
BLI_add_slash(str);
}
else
BLI_splitdirstring(str, name);
}
RNA_property_string_set(&fbo->ptr, fbo->prop, str);
RNA_property_update(C, &fbo->ptr, fbo->prop);
MEM_freeN(str);
/* special, annoying exception, filesel on redo panel [#26618] */
{
wmOperator *redo_op= WM_operator_last_redo(C);
if(redo_op) {
if(fbo->ptr.data == redo_op->ptr->data) {
ED_undo_operator_repeat(C, redo_op);
}
}
}
MEM_freeN(op->customdata);
return OPERATOR_FINISHED;
}
static FileSelect file_select_do(bContext *C, int selected_idx, bool do_diropen)
{
FileSelect retval = FILE_SELECT_NOTHING;
SpaceFile *sfile = CTX_wm_space_file(C);
FileSelectParams *params = ED_fileselect_get_params(sfile);
int numfiles = filelist_numfiles(sfile->files);
struct direntry *file;
/* make the selected file active */
if ((selected_idx >= 0) &&
(selected_idx < numfiles) &&
(file = filelist_file(sfile->files, selected_idx)))
{
params->active_file = selected_idx;
if (S_ISDIR(file->type)) {
if (do_diropen == false) {
params->file[0] = '\0';
retval = FILE_SELECT_DIR;
}
/* the path is too long and we are not going up! */
else if (strcmp(file->relname, "..") && strlen(params->dir) + strlen(file->relname) >= FILE_MAX) {
// XXX error("Path too long, cannot enter this directory");
}
else {
if (strcmp(file->relname, "..") == 0) {
/* avoids /../../ */
BLI_parent_dir(params->dir);
}
else {
BLI_cleanup_dir(G.main->name, params->dir);
strcat(params->dir, file->relname);
BLI_add_slash(params->dir);
}
file_change_dir(C, 0);
retval = FILE_SELECT_DIR;
}
}
else {
if (file->relname) {
BLI_strncpy(params->file, file->relname, FILE_MAXFILE);
}
retval = FILE_SELECT_FILE;
}
}
return retval;
}
int BLI_parent_dir(char *path)
{
static char parent_dir[]= {'.', '.', SEP, '\0'}; /* "../" or "..\\" */
char tmp[FILE_MAXDIR+FILE_MAXFILE+4];
BLI_strncpy(tmp, path, sizeof(tmp)-4);
BLI_add_slash(tmp);
strcat(tmp, parent_dir);
BLI_cleanup_dir(NULL, tmp);
if (!BLI_testextensie(tmp, parent_dir)) {
BLI_strncpy(path, tmp, sizeof(tmp));
return 1;
} else {
return 0;
}
}
/* simple appending of filename to dir, does not check for valid path! */
void BLI_join_dirfile(char *string, const size_t maxlen, const char *dir, const char *file)
{
int sl_dir;
if(string != dir) /* compare pointers */
BLI_strncpy(string, dir, maxlen);
if (!file)
return;
sl_dir= BLI_add_slash(string);
if (sl_dir <FILE_MAX) {
BLI_strncpy(string + sl_dir, file, maxlen - sl_dir);
}
}
/**
* Gets the temp directory when blender first runs.
* If the default path is not found, use try $TEMP
*
* Also make sure the temp dir has a trailing slash
*
* \param fullname The full path to the temp directory
* \param maxlen The size of the fullname buffer
* \param userdir Directory specified in user preferences
*/
static void BLI_where_is_temp(char *fullname, const size_t maxlen, char *userdir)
{
fullname[0] = '\0';
if (userdir && BLI_is_dir(userdir)) {
BLI_strncpy(fullname, userdir, maxlen);
}
#ifdef WIN32
if (fullname[0] == '\0') {
const char *tmp = getenv("TEMP"); /* Windows */
if (tmp && BLI_is_dir(tmp)) {
BLI_strncpy(fullname, tmp, maxlen);
}
}
#else
/* Other OS's - Try TMP and TMPDIR */
if (fullname[0] == '\0') {
const char *tmp = getenv("TMP");
if (tmp && BLI_is_dir(tmp)) {
BLI_strncpy(fullname, tmp, maxlen);
}
}
if (fullname[0] == '\0') {
const char *tmp = getenv("TMPDIR");
if (tmp && BLI_is_dir(tmp)) {
BLI_strncpy(fullname, tmp, maxlen);
}
}
#endif
if (fullname[0] == '\0') {
BLI_strncpy(fullname, "/tmp/", maxlen);
}
else {
/* add a trailing slash if needed */
BLI_add_slash(fullname);
#ifdef WIN32
if (userdir && userdir != fullname) {
BLI_strncpy(userdir, fullname, maxlen); /* also set user pref to show %TEMP%. /tmp/ is just plain confusing for Windows users. */
}
#endif
}
}
void BLI_cleanup_dir(const char *relabase, char *dir)
{
BLI_cleanup_path(relabase, dir);
BLI_add_slash(dir);
}
/* return path for restart */
static char *wm_main_playanim_intern(int argc, const char **argv)
{
struct ImBuf *ibuf = NULL;
static char filepath[FILE_MAX]; /* abused to return dropped file path */
GHOST_TUns32 maxwinx, maxwiny;
int i;
/* This was done to disambiguate the name for use under c++. */
struct anim *anim = NULL;
int start_x = 0, start_y = 0;
int sfra = -1;
int efra = -1;
int totblock;
PlayState ps = {0};
/* ps.doubleb = TRUE;*/ /* UNUSED */
ps.go = TRUE;
ps.direction = TRUE;
ps.next_frame = 1;
ps.once = FALSE;
ps.turbo = FALSE;
ps.pingpong = FALSE;
ps.noskip = FALSE;
ps.sstep = FALSE;
ps.wait2 = FALSE;
ps.stopped = FALSE;
ps.picture = NULL;
ps.dropped_file[0] = 0;
ps.zoom = 1.0f;
/* resetmap = FALSE */
ps.fstep = 1;
ps.fontid = -1;
while (argc > 1) {
if (argv[1][0] == '-') {
switch (argv[1][1]) {
case 'm':
fromdisk = TRUE;
break;
case 'p':
if (argc > 3) {
start_x = atoi(argv[2]);
start_y = atoi(argv[3]);
argc -= 2;
argv += 2;
}
else {
printf("too few arguments for -p (need 2): skipping\n");
}
break;
case 'f':
if (argc > 3) {
double fps = atof(argv[2]);
double fps_base = atof(argv[3]);
if (fps == 0.0) {
fps = 1;
printf("invalid fps,"
"forcing 1\n");
}
swaptime = fps_base / fps;
argc -= 2;
argv += 2;
}
else {
printf("too few arguments for -f (need 2): skipping\n");
}
break;
case 's':
sfra = MIN2(MAXFRAME, MAX2(1, atoi(argv[2]) ));
argc--;
argv++;
break;
case 'e':
efra = MIN2(MAXFRAME, MAX2(1, atoi(argv[2]) ));
argc--;
argv++;
break;
case 'j':
ps.fstep = MIN2(MAXFRAME, MAX2(1, atoi(argv[2])));
swaptime *= ps.fstep;
argc--;
argv++;
break;
default:
printf("unknown option '%c': skipping\n", argv[1][1]);
break;
}
argc--;
argv++;
}
else {
break;
}
}
if (argc > 1) {
BLI_strncpy(filepath, argv[1], sizeof(filepath));
}
else {
BLI_current_working_dir(filepath, sizeof(filepath));
BLI_add_slash(filepath);
}
if (IMB_isanim(filepath)) {
/* OCIO_TODO: support different input color spaces */
anim = IMB_open_anim(filepath, IB_rect, 0, NULL);
if (anim) {
ibuf = IMB_anim_absolute(anim, 0, IMB_TC_NONE, IMB_PROXY_NONE);
IMB_close_anim(anim);
anim = NULL;
}
}
else if (!IMB_ispic(filepath)) {
printf("%s: '%s' not an image file\n", __func__, filepath);
exit(1);
}
if (ibuf == NULL) {
/* OCIO_TODO: support different input color space */
ibuf = IMB_loadiffname(filepath, IB_rect, NULL);
}
if (ibuf == NULL) {
printf("%s: '%s' couldn't open\n", __func__, filepath);
exit(1);
}
#if 0 //XXX25
#if !defined(WIN32) && !defined(__APPLE__)
if (fork()) exit(0);
#endif
#endif //XXX25
{
GHOST_EventConsumerHandle consumer = GHOST_CreateEventConsumer(ghost_event_proc, &ps);
g_WS.ghost_system = GHOST_CreateSystem();
GHOST_AddEventConsumer(g_WS.ghost_system, consumer);
playanim_window_open("Blender:Anim", start_x, start_y, ibuf->x, ibuf->y);
/* unified matrix, note it affects offset for drawing */
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0f, 1.0f, 0.0f, 1.0f, -1.0f, 1.0f);
glMatrixMode(GL_MODELVIEW);
}
GHOST_GetMainDisplayDimensions(g_WS.ghost_system, &maxwinx, &maxwiny);
//GHOST_ActivateWindowDrawingContext(g_WS.ghost_window);
/* initialize the font */
BLF_init(11, 72);
ps.fontid = BLF_load_mem("monospace", (unsigned char *)datatoc_bmonofont_ttf, datatoc_bmonofont_ttf_size);
BLF_size(ps.fontid, 11, 72);
ps.ibufx = ibuf->x;
ps.ibufy = ibuf->y;
ps.win_x = ps.ibufx;
ps.win_y = ps.ibufy;
if (maxwinx % ibuf->x) maxwinx = ibuf->x * (1 + (maxwinx / ibuf->x));
if (maxwiny % ibuf->y) maxwiny = ibuf->y * (1 + (maxwiny / ibuf->y));
glClearColor(0.1, 0.1, 0.1, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
GHOST_SwapWindowBuffers(g_WS.ghost_window);
if (sfra == -1 || efra == -1) {
/* one of the frames was invalid, just use all images */
sfra = 1;
efra = MAXFRAME;
}
build_pict_list(&ps, filepath, (efra - sfra) + 1, ps.fstep, ps.fontid);
for (i = 2; i < argc; i++) {
BLI_strncpy(filepath, argv[i], sizeof(filepath));
build_pict_list(&ps, filepath, (efra - sfra) + 1, ps.fstep, ps.fontid);
}
IMB_freeImBuf(ibuf);
ibuf = NULL;
pupdate_time();
ptottime = 0;
/* newly added in 2.6x, without this images never get freed */
#define USE_IMB_CACHE
while (ps.go) {
if (ps.pingpong)
ps.direction = -ps.direction;
if (ps.direction == 1) {
ps.picture = picsbase.first;
}
else {
ps.picture = picsbase.last;
}
if (ps.picture == NULL) {
printf("couldn't find pictures\n");
ps.go = FALSE;
}
if (ps.pingpong) {
if (ps.direction == 1) {
ps.picture = ps.picture->next;
}
else {
ps.picture = ps.picture->prev;
}
}
if (ptottime > 0.0) ptottime = 0.0;
while (ps.picture) {
int hasevent;
#ifndef USE_IMB_CACHE
if (ibuf != NULL && ibuf->ftype == 0) IMB_freeImBuf(ibuf);
#endif
if (ps.picture->ibuf) {
ibuf = ps.picture->ibuf;
}
else if (ps.picture->anim) {
ibuf = IMB_anim_absolute(ps.picture->anim, ps.picture->frame, IMB_TC_NONE, IMB_PROXY_NONE);
}
else if (ps.picture->mem) {
/* use correct colorspace here */
ibuf = IMB_ibImageFromMemory((unsigned char *) ps.picture->mem, ps.picture->size,
ps.picture->IB_flags, NULL, ps.picture->name);
}
else {
/* use correct colorspace here */
ibuf = IMB_loadiffname(ps.picture->name, ps.picture->IB_flags, NULL);
}
if (ibuf) {
#ifdef USE_IMB_CACHE
ps.picture->ibuf = ibuf;
#endif
BLI_strncpy(ibuf->name, ps.picture->name, sizeof(ibuf->name));
/* why only windows? (from 2.4x) - campbell */
#ifdef _WIN32
GHOST_SetTitle(g_WS.ghost_window, ps.picture->name);
#endif
while (pupdate_time()) PIL_sleep_ms(1);
ptottime -= swaptime;
playanim_toscreen(&ps, ps.picture, ibuf, ps.fontid, ps.fstep);
} /* else delete */
else {
printf("error: can't play this image type\n");
exit(0);
}
if (ps.once) {
if (ps.picture->next == NULL) {
ps.wait2 = TRUE;
}
else if (ps.picture->prev == NULL) {
ps.wait2 = TRUE;
}
}
ps.next_frame = ps.direction;
while ( (hasevent = GHOST_ProcessEvents(g_WS.ghost_system, 0)) || ps.wait2 != 0) {
if (hasevent) {
GHOST_DispatchEvents(g_WS.ghost_system);
}
/* Note, this still draws for mousemoves on pause */
if (ps.wait2) {
if (hasevent) {
if (ibuf) {
while (pupdate_time()) PIL_sleep_ms(1);
ptottime -= swaptime;
playanim_toscreen(&ps, ps.picture, ibuf, ps.fontid, ps.fstep);
}
}
}
if (!ps.go) {
break;
}
}
ps.wait2 = ps.sstep;
if (ps.wait2 == 0 && ps.stopped == 0) {
ps.stopped = TRUE;
}
pupdate_time();
if (ps.picture && ps.next_frame) {
/* always at least set one step */
while (ps.picture) {
ps.picture = playanim_step(ps.picture, ps.next_frame);
if (ps.once && ps.picture != NULL) {
if (ps.picture->next == NULL) {
ps.wait2 = TRUE;
}
else if (ps.picture->prev == NULL) {
ps.wait2 = TRUE;
}
}
if (ps.wait2 || ptottime < swaptime || ps.turbo || ps.noskip) break;
ptottime -= swaptime;
}
if (ps.picture == NULL && ps.sstep) {
ps.picture = playanim_step(ps.picture, ps.next_frame);
}
}
if (ps.go == FALSE) {
break;
}
}
}
ps.picture = picsbase.first;
anim = NULL;
while (ps.picture) {
if (ps.picture && ps.picture->anim && (anim != ps.picture->anim)) {
// to prevent divx crashes
anim = ps.picture->anim;
IMB_close_anim(anim);
}
if (ps.picture->ibuf) {
IMB_freeImBuf(ps.picture->ibuf);
}
if (ps.picture->mem) {
MEM_freeN(ps.picture->mem);
}
ps.picture = ps.picture->next;
}
/* cleanup */
#ifndef USE_IMB_CACHE
if (ibuf) IMB_freeImBuf(ibuf);
#endif
BLI_freelistN(&picsbase);
#if 0 // XXX25
free_blender();
#else
/* we still miss freeing a lot!,
* but many areas could skip initialization too for anim play */
BLF_exit();
#endif
GHOST_DisposeWindow(g_WS.ghost_system, g_WS.ghost_window);
/* early exit, IMB and BKE should be exited only in end */
if (ps.dropped_file[0]) {
BLI_strncpy(filepath, ps.dropped_file, sizeof(filepath));
return filepath;
}
IMB_exit();
BKE_images_exit();
totblock = MEM_get_memory_blocks_in_use();
if (totblock != 0) {
/* prints many bAKey, bArgument's which are tricky to fix */
#if 0
printf("Error Totblock: %d\n", totblock);
MEM_printmemlist();
#endif
}
return NULL;
}
/**
* Gets the temp directory when blender first runs.
* If the default path is not found, use try $TEMP
*
* Also make sure the temp dir has a trailing slash
*
* \param fullname The full path to the temporary temp directory
* \param basename The full path to the persistent temp directory (may be NULL)
* \param maxlen The size of the fullname buffer
* \param userdir Directory specified in user preferences
*/
static void BLI_where_is_temp(char *fullname, char *basename, const size_t maxlen, char *userdir)
{
/* Clear existing temp dir, if needed. */
BKE_tempdir_session_purge();
fullname[0] = '\0';
if (basename) {
basename[0] = '\0';
}
if (userdir && BLI_is_dir(userdir)) {
BLI_strncpy(fullname, userdir, maxlen);
}
#ifdef WIN32
if (fullname[0] == '\0') {
const char *tmp = getenv("TEMP"); /* Windows */
if (tmp && BLI_is_dir(tmp)) {
BLI_strncpy(fullname, tmp, maxlen);
}
}
#else
/* Other OS's - Try TMP and TMPDIR */
if (fullname[0] == '\0') {
const char *tmp = getenv("TMP");
if (tmp && BLI_is_dir(tmp)) {
BLI_strncpy(fullname, tmp, maxlen);
}
}
if (fullname[0] == '\0') {
const char *tmp = getenv("TMPDIR");
if (tmp && BLI_is_dir(tmp)) {
BLI_strncpy(fullname, tmp, maxlen);
}
}
#endif
if (fullname[0] == '\0') {
BLI_strncpy(fullname, "/tmp/", maxlen);
}
else {
/* add a trailing slash if needed */
BLI_add_slash(fullname);
#ifdef WIN32
if (userdir && userdir != fullname) {
BLI_strncpy(userdir, fullname, maxlen); /* also set user pref to show %TEMP%. /tmp/ is just plain confusing for Windows users. */
}
#endif
}
/* Now that we have a valid temp dir, add system-generated unique sub-dir. */
if (basename) {
/* 'XXXXXX' is kind of tag to be replaced by mktemp-familly by an uuid. */
char *tmp_name = BLI_strdupcat(fullname, "blender_XXXXXX");
const size_t ln = strlen(tmp_name) + 1;
if (ln <= maxlen) {
#ifdef WIN32
if (_mktemp_s(tmp_name, ln) == 0) {
BLI_dir_create_recursive(tmp_name);
}
#else
mkdtemp(tmp_name);
#endif
}
if (BLI_is_dir(tmp_name)) {
BLI_strncpy(basename, fullname, maxlen);
BLI_strncpy(fullname, tmp_name, maxlen);
BLI_add_slash(fullname);
}
else {
printf("Warning! Could not generate a temp file name for '%s', falling back to '%s'\n", tmp_name, fullname);
}
MEM_freeN(tmp_name);
}
}