/* fill_ffblk:
* Helper function to fill in an al_ffblk structure.
*/
static void fill_ffblk(struct al_ffblk *info)
{
struct FF_DATA *ff_data = (struct FF_DATA *) info->ff_data;
if (get_filename_encoding() != U_UNICODE) {
info->attrib = ff_data->data.a.attrib;
info->time = ff_data->data.a.time_write;
info->size = ff_data->data.a.size;
do_uconvert(ff_data->data.a.name, U_ASCII, info->name, U_CURRENT,
sizeof(info->name));
}
else {
info->attrib = ff_data->data.w.attrib;
info->time = ff_data->data.w.time_write;
info->size = ff_data->data.w.size;
do_uconvert((const char*)ff_data->data.w.name, U_UNICODE, info->name,
U_CURRENT, sizeof(info->name));
}
}
/* convert a string from 8-bit ASCII to the current format */
int eof_convert_extended_ascii(char * buffer, int size)
{
char * workbuffer = NULL;
if(!eof_ucode_table)
{
return 0;
}
workbuffer = malloc((size_t)size);
if(!workbuffer)
{
return 0;
}
memcpy(workbuffer, buffer, (size_t)size);
do_uconvert(workbuffer, U_ASCII_CP, buffer, U_CURRENT, size);
free(workbuffer);
return 1;
}
/* be_midi_init:
* Initializes the BeOS MIDI driver.
*/
extern "C" int be_midi_init(int input, int voices)
{
char tmp[256], tmp2[128], tmp3[128] = EMPTY_STRING;
char *sound = uconvert_ascii("sound", tmp);
int mode, freq, quality, reverb;
synth_mode sm = B_BIG_SYNTH;
interpolation_mode im = B_2_POINT_INTERPOLATION;
char *reverb_name[] =
{ "no", "closet", "garage", "ballroom", "cavern", "dungeon" };
if (input) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Input is not supported"));
return -1;
}
_be_midisynth = new BMidiSynth();
if (!_be_midisynth) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Not enough memory"));
return -1;
}
/* Checks if instruments are available */
mode = CLAMP(0, get_config_int(sound, uconvert_ascii("be_midi_quality", tmp), 1), 1);
if (mode)
sm = B_BIG_SYNTH;
else
sm = B_LITTLE_SYNTH;
if ((be_synth->LoadSynthData(sm) != B_OK) ||
(!be_synth->IsLoaded())) {
delete _be_midisynth;
_be_midisynth = NULL;
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Can not load MIDI instruments data file"));
return -1;
}
/* Sets up synthetizer and loads instruments */
_be_midisynth->EnableInput(true, true);
/* Prevents other apps from changing instruments on the fly */
_be_midisynth->FlushInstrumentCache(true);
/* Reverberation is cool */
reverb = CLAMP(0, get_config_int(sound, uconvert_ascii("be_midi_reverb", tmp), 0), 5);
if (reverb) {
be_synth->SetReverb((reverb_mode)reverb);
be_synth->EnableReverb(true);
}
else
be_synth->EnableReverb(false);
/* Sets sampling rate and sample interpolation method */
freq = get_config_int(sound, uconvert_ascii("be_midi_freq", tmp), 22050);
quality = CLAMP(0, get_config_int(sound, uconvert_ascii("be_midi_interpolation", tmp), 1), 2);
be_synth->SetSamplingRate(freq);
switch (quality) {
case 0:
im = B_DROP_SAMPLE;
break;
case 1:
im = B_2_POINT_INTERPOLATION;
do_uconvert("fast", U_ASCII, tmp3, U_CURRENT, sizeof(tmp3));
break;
case 2:
im = B_LINEAR_INTERPOLATION;
do_uconvert("linear", U_ASCII, tmp3, U_CURRENT, sizeof(tmp3));
break;
}
be_synth->SetInterpolation(im);
/* Sets up driver description */
uszprintf(be_midi_driver_desc, sizeof(be_midi_driver_desc),
uconvert_ascii("BeOS %s quality synth, %s %d kHz, %s reverberation", tmp),
uconvert_ascii(mode ? "high" : "low", tmp2), tmp3,
(be_synth->SamplingRate() / 1000), reverb_name[reverb]);
midi_beos.desc = be_midi_driver_desc;
return 0;
}
/* al_findfirst:
* Initiates a directory search.
*/
int al_findfirst(AL_CONST char *pattern, struct al_ffblk *info, int attrib)
{
struct FF_DATA *ff_data;
struct stat s;
int actual_attrib;
char tmp[1024];
char *p;
/* allocate ff_data structure */
ff_data = _AL_MALLOC(sizeof(struct FF_DATA));
if (!ff_data) {
*allegro_errno = ENOMEM;
return -1;
}
memset(ff_data, 0, sizeof *ff_data);
info->ff_data = (void *) ff_data;
/* if the pattern contains no wildcard, we use stat() */
if (!ustrpbrk(pattern, uconvert("?*", U_ASCII, tmp, U_CURRENT, sizeof(tmp)))) {
/* start the search */
errno = *allegro_errno = 0;
if (stat(uconvert(pattern, U_CURRENT, tmp, U_UTF8, sizeof(tmp)), &s) == 0) {
/* get file attributes */
actual_attrib = ff_get_attrib(ff_get_filename(uconvert(pattern, U_CURRENT, tmp, U_UTF8, sizeof(tmp))), &s);
/* does it match ? */
if ((actual_attrib & ~attrib) == 0) {
info->attrib = actual_attrib;
info->time = s.st_mtime;
info->size = s.st_size; /* overflows at 2GB */
ff_data->size = s.st_size;
ustrzcpy(info->name, sizeof(info->name), get_filename(pattern));
return 0;
}
}
_AL_FREE(ff_data);
info->ff_data = NULL;
*allegro_errno = (errno ? errno : ENOENT);
return -1;
}
ff_data->attrib = attrib;
do_uconvert(pattern, U_CURRENT, ff_data->dirname, U_UTF8, sizeof(ff_data->dirname));
p = ff_get_filename(ff_data->dirname);
_al_sane_strncpy(ff_data->pattern, p, sizeof(ff_data->pattern));
if (p == ff_data->dirname)
_al_sane_strncpy(ff_data->dirname, "./", FF_MAXPATHLEN);
else
*p = 0;
/* nasty bodge, but gives better compatibility with DOS programs */
if (strcmp(ff_data->pattern, "*.*") == 0)
_al_sane_strncpy(ff_data->pattern, "*", FF_MAXPATHLEN);
/* start the search */
errno = *allegro_errno = 0;
ff_data->dir = opendir(ff_data->dirname);
if (!ff_data->dir) {
*allegro_errno = (errno ? errno : ENOENT);
_AL_FREE(ff_data);
info->ff_data = NULL;
return -1;
}
if (al_findnext(info) != 0) {
al_findclose(info);
return -1;
}
return 0;
}
/* _unix_get_executable_name:
* Return full path to the current executable, use proc fs if available.
*/
void _unix_get_executable_name(char *output, int size)
{
#ifdef ALLEGRO_HAVE_SV_PROCFS_H
struct prpsinfo psinfo;
int fd;
#endif
char linkname[1024];
char filename[1024];
struct stat finfo;
FILE *pipe;
pid_t pid;
int len;
#ifdef ALLEGRO_HAVE_GETEXECNAME
{
const char *s = getexecname();
if (s) {
if (s[0] == '/') { /* Absolute path */
do_uconvert (s, U_ASCII, output, U_CURRENT, size);
return;
}
else { /* Not an absolute path */
if (_find_executable_file(s, output, size))
return;
}
}
}
#endif
/* We need the PID in order to query procfs */
pid = getpid();
/* Try a Linux-like procfs */
/* get symolic link to executable from proc fs */
sprintf (linkname, "/proc/%d/exe", (int)pid);
if (stat (linkname, &finfo) == 0) {
len = readlink (linkname, filename, sizeof(filename)-1);
if (len>-1) {
filename[len] = '\0';
do_uconvert (filename, U_ASCII, output, U_CURRENT, size);
return;
}
}
/* Use System V procfs calls if available */
#ifdef ALLEGRO_HAVE_SV_PROCFS_H
sprintf (linkname, "/proc/%d/exe", (int)pid);
fd = open(linkname, O_RDONLY);
if (!fd == -1) {
ioctl(fd, PIOCPSINFO, &psinfo);
close(fd);
/* Use argv[0] directly if we can */
#ifdef ALLEGRO_HAVE_PROCFS_ARGCV
if (psinfo.pr_argv && psinfo.pr_argc) {
if (_find_executable_file(psinfo.pr_argv[0], output, size))
return;
}
else
#endif
{
/* Emulate it */
/* We use the pr_psargs field to find argv[0]
* This is better than using the pr_fname field because we need
* the additional path information that may be present in argv[0]
*/
/* Skip other args */
char *s = strchr(psinfo.pr_psargs, ' ');
if (s) s[0] = '\0';
if (_find_executable_file(psinfo.pr_psargs, output, size))
return;
}
/* Try the pr_fname just for completeness' sake if argv[0] fails */
if (_find_executable_file(psinfo.pr_fname, output, size))
return;
}
#endif
/* Last resort: try using the output of the ps command to at least find */
/* the name of the file if not the full path */
uszprintf (linkname, sizeof(linkname), "ps -p %d", (int)pid);
do_uconvert (linkname, U_CURRENT, filename, U_ASCII, size);
pipe = popen(filename, "r");
if (pipe) {
/* The first line of output is a header */
fgets(linkname, sizeof(linkname), pipe);
/* The information we want is in the last column; find it */
len = strlen(linkname);
while (linkname[len] != ' ' && linkname[len] != '\t')
len--;
/* The second line contains the info we want */
fgets(linkname, sizeof(linkname), pipe);
pclose(pipe);
/* Treat special cases: filename between [] and - for login shell */
if (linkname[len] == '-')
len++;
if (linkname[len] == '[' && linkname[strlen(linkname)] == ']') {
len++;
linkname[strlen(linkname)] = '\0';
}
/* Now, the filename should be in the last column */
_al_sane_strncpy (filename, linkname+len+1, strlen(linkname)-len+1);
if (_find_executable_file(filename, output, size))
return;
/* Just return the output from ps... */
do_uconvert (filename, U_ASCII, output, U_CURRENT, size);
return;
}
#ifdef ALLEGRO_WITH_MAGIC_MAIN
/* Try the captured argv[0] */
if (_find_executable_file(__crt0_argv[0], output, size))
return;
#endif
/* Give up; return empty string */
do_uconvert ("", U_ASCII, output, U_CURRENT, size);
}
/* _find_executable_file:
* Helper function: searches path and current directory for executable.
* Returns 1 on succes, 0 on failure.
*/
static int _find_executable_file(const char *filename, char *output, int size)
{
char *path;
/* If filename has an explicit path, search current directory */
if (strchr (filename, '/')) {
if (filename[0] == '/') {
/* Full path; done */
do_uconvert (filename, U_ASCII, output, U_CURRENT, size);
return 1;
}
else {
struct stat finfo;
char pathname[1024];
int len;
/* Prepend current directory */
getcwd(pathname, sizeof(pathname));
len = strlen(pathname);
pathname[len] = '/';
_al_sane_strncpy (pathname+len+1, filename, strlen(filename));
if ((stat(pathname, &finfo)==0) && (!S_ISDIR (finfo.st_mode))) {
do_uconvert (pathname, U_ASCII, output, U_CURRENT, size);
return 1;
}
}
}
/* If filename has no explicit path, but we do have $PATH, search there */
else if ((path = getenv("PATH"))) {
char *start = path, *end = path, *buffer = NULL, *temp;
struct stat finfo;
while (*end) {
end = strchr (start, ':');
if (!end) end = strchr (start, '\0');
/* Resize `buffer' for path component, slash, filename and a '\0' */
temp = _AL_REALLOC (buffer, end - start + 1 + strlen (filename) + 1);
if (temp) {
buffer = temp;
_al_sane_strncpy (buffer, start, end - start);
*(buffer + (end - start)) = '/';
_al_sane_strncpy (buffer + (end - start) + 1, filename, end - start + 1 + strlen (filename) + 1);
if ((stat(buffer, &finfo)==0) && (!S_ISDIR (finfo.st_mode))) {
do_uconvert (buffer, U_ASCII, output, U_CURRENT, size);
_AL_FREE (buffer);
return 1;
}
} /* else... ignore the failure; `buffer' is still valid anyway. */
start = end + 1;
}
/* Path search failed */
_AL_FREE (buffer);
}
return 0;
}
int raine_file_select_ex( char *message, char *path, char *ext, int size,int width, int height)
{
char buf[512];
int ret;
char *p;
if (width == -1)
width = 305;
#ifdef HAVE_DIR_LIST
if (height == -1)
height = 161;
#else
if (height == -1)
height = 189;
#endif
/* for fs_dlist_proc() */
ASSERT(size >= 4 * uwidth_max(U_CURRENT));
ustrcpy(updir, empty_string);
file_selector[FS_MESSAGE].dp = (char *)message;
file_selector[FS_EDIT].d1 = size/uwidth_max(U_CURRENT) - 1;
file_selector[FS_EDIT].dp = path;
file_selector[FS_OK].dp = (void*)raine_get_config_text("OK");
file_selector[FS_CANCEL].dp = (void*)raine_get_config_text("Cancel");
fext = ext;
if (!ugetc(path)) {
if (!getcwd(buf, sizeof(buf)))
buf[0]=0;
do_uconvert(buf, U_ASCII, path, U_CURRENT, size);
fix_filename_case(path);
fix_filename_slashes(path);
put_backslash(path);
}
clear_keybuf();
do {
} while (gui_mouse_b());
stretch_dialog(file_selector, width, height);
centre_dialog(file_selector);
// Stupid correction of the allegro colors...
file_selector[FS_FILES].fg = CGUI_COL_TEXT_1;
file_selector[FS_FILES].bg = CGUI_BOX_COL_MIDDLE;
#ifdef HAVE_DIR_LIST /* not all platforms need a directory list */
file_selector[FS_DISKS].fg = CGUI_COL_TEXT_1;
file_selector[FS_DISKS].bg = CGUI_BOX_COL_MIDDLE;
#endif
ret = do_dialog(file_selector, FS_EDIT);
if (ret == FS_CANCEL)
return FALSE;
p = get_extension(path);
if ((!ugetc(p)) && (ext) && (!ustrpbrk(ext, uconvert_ascii(" ,;", NULL)))) {
p += usetc(p, '.');
ustrcpy(p, ext);
}
return TRUE;
}
ALLEGRO_PATH *_al_unix_get_path(int id)
{
switch (id) {
case ALLEGRO_TEMP_PATH: {
/* Check: TMP, TMPDIR, TEMP or TEMPDIR */
char *envs[] = { "TMP", "TMPDIR", "TEMP", "TEMPDIR", NULL};
uint32_t i = 0;
for (; envs[i] != NULL; ++i) {
char *tmp = getenv(envs[i]);
if (tmp) {
return al_create_path(tmp);
}
}
/* next try: /tmp /var/tmp /usr/tmp */
char *paths[] = { "/tmp/", "/var/tmp/", "/usr/tmp/", NULL };
for (i=0; paths[i] != NULL; ++i) {
ALLEGRO_FS_ENTRY *fse = al_create_fs_entry(paths[i]);
bool found = al_fs_entry_is_directory(fse);
al_destroy_fs_entry(fse);
if (found) {
return al_create_path(paths[i]);
}
}
/* Give up? */
return NULL;
} break;
case ALLEGRO_PROGRAM_PATH: {
ALLEGRO_PATH *exe = get_executable_name();
al_set_path_filename(exe, NULL);
return exe;
} break;
case ALLEGRO_SYSTEM_DATA_PATH: {
ALLEGRO_PATH *sys_data_path = NULL;
/* FIXME: make this a compile time define, or a allegro cfg option? or both */
sys_data_path = al_create_path("/usr/share/");
al_append_path_component(sys_data_path, al_get_orgname());
al_append_path_component(sys_data_path, al_get_appname());
return sys_data_path;
} break;
#if 0
case ALLEGRO_USER_DATA_PATH: {
int32_t ret = 0;
uint32_t path_len = 0, ptr_len = 0, prog_len = 0;
char path[PATH_MAX] = "", *ptr = NULL;
char prog[PATH_MAX] = "";
if (_unix_find_home(path, PATH_MAX) != 0) {
return NULL;
}
strncat(path, "/.", 2);
path_len = strlen(path);
/* get exe name */
/* FIXME:
This really aught to get the "Program" name from somewhere, say a config var? Or a function al_set_program_name()?
making a ~/.test_program dir for a exe named "test_program" might not be what people have in mind.
*/
get_executable_name(prog, PATH_MAX);
ptr = strrchr(prog, '/');
if (!ptr) {
al_set_errno(EINVAL);
return NULL;
}
*ptr = '\0';
ptr++;
ptr_len = strlen(ptr);
//
strncat(path, ptr, ptr_len+1);
//*(ptr-1) = '/';
do_uconvert(path, U_ASCII, dir, U_UTF8, strlen(path)+1);
} break;
#endif
case ALLEGRO_USER_SETTINGS_PATH:
case ALLEGRO_USER_DATA_PATH: {
ALLEGRO_PATH *local_path = NULL;
local_path = _unix_find_home();
if (!local_path)
return NULL;
al_append_path_component(local_path, ".config");
al_append_path_component(local_path, al_get_orgname());
al_append_path_component(local_path, al_get_appname());
return local_path;
} break;
case ALLEGRO_USER_HOME_PATH:
return _unix_find_home();
case ALLEGRO_SYSTEM_SETTINGS_PATH: {
ALLEGRO_PATH *sys_path;
/* FIXME: make this a compile time define, or something */
sys_path = al_create_path("/etc/");
al_append_path_component(sys_path, al_get_orgname());
al_append_path_component(sys_path, al_get_appname());
return sys_path;
} break;
case ALLEGRO_EXENAME_PATH:
return get_executable_name();
break;
default:
return NULL;
}
return NULL;
}
extern "C" void be_sys_set_window_title(AL_CONST char *name)
{
do_uconvert(name, U_CURRENT, wnd_title, U_UTF8, WND_TITLE_SIZE);
if (_be_window)
_be_window->SetTitle(wnd_title);
}
/* be_sys_init:
*/
extern "C" int be_sys_init(void)
{
int32 cookie;
thread_info info;
struct utsname os_name;
char path[MAXPATHLEN];
cookie = 0;
if (get_next_thread_info(0, &cookie, &info) == B_OK) {
main_thread_id = info.thread;
}
else {
goto cleanup;
}
_be_mouse_view_attached = create_sem(0, "waiting for mouse view attach...");
if (_be_mouse_view_attached < 0) {
goto cleanup;
}
_be_sound_stream_lock = create_sem(1, "audiostream lock");
if (_be_sound_stream_lock < 0) {
goto cleanup;
}
system_started = create_sem(0, "starting system driver...");
if(system_started < 0) {
goto cleanup;
}
system_thread_id = spawn_thread(system_thread, SYS_THREAD_NAME,
SYS_THREAD_PRIORITY, NULL);
if (system_thread_id < 0) {
goto cleanup;
}
resume_thread(system_thread_id);
acquire_sem(system_started);
delete_sem(system_started);
uname(&os_name);
os_type = OSTYPE_BEOS;
os_multitasking = TRUE;
chdir(app_path);
_be_sys_get_executable_name(path, sizeof(path));
path[sizeof(path)-1] = '\0';
do_uconvert(get_filename(path), U_CURRENT, wnd_title, U_UTF8, WND_TITLE_SIZE);
return 0;
cleanup: {
be_sys_exit();
return 1;
}
}
