/*****************************************************************************
* get_session_directory_from_entry()
*****************************************************************************/
char *
get_session_directory_from_entry(GtkEntry *entry)
{
SESSION *session = get_current_session();
const char *name = NULL;
char *tmpname;
char directory[PATH_MAX];
/* get name from entry widget */
if (entry != NULL) {
name = gtk_entry_get_text(GTK_ENTRY(entry));
}
if ((name == NULL) || (name[0] == '\0')) {
/* if entry is empty, get current session directory */
tmpname = get_session_name_from_directory(session->directory);
/* build the directory name from the session name */
snprintf(directory, PATH_MAX, "%s/%s", user_session_dir, tmpname);
/* free up mem */
free(tmpname);
}
else {
/* build the directory from the session name */
snprintf(directory, PATH_MAX, "%s/%s", user_session_dir, name);
}
/* return a copy */
tmpname = strdup(directory);
return tmpname;
}
MenuIndex get_current_session_from_time() {
time_t now = time(NULL);
struct tm *tm_now = localtime(&now);
MenuIndex current = {.section = 0, .row = 0};
if (tm_now->tm_mon != event_month - 1 || tm_now->tm_mday != event_day) {
return current;
}
for(int ts_idx=0; ts_idx<schedule.num_slots; ts_idx++) {
TimeSlot *ts = &schedule.slots[ts_idx];
if (tm_now->tm_hour < ts->start_hour) {
break;
} else if(tm_now->tm_hour == ts->start_hour && tm_now->tm_min < ts->start_min) {
break;
}
current.section = ts_idx;
}
return current;
}
MenuIndex get_current_session_from_args() {
int args = launch_get_args();
MenuIndex current = {.section = args / 10, .row = args % 10};
return current;
}
MenuIndex get_current_session() {
#ifdef PBL_COLOR
if (launch_reason() == APP_LAUNCH_TIMELINE_ACTION && launch_get_args() > 0) {
return get_current_session_from_args();
}
#endif
return get_current_session_from_time();
}
static void main_window_load(Window *window) {
Layer *window_layer = window_get_root_layer(window);
GRect bounds = layer_get_frame(window_layer);
menu_schedule = menu_layer_create(bounds);
#ifdef PBL_COLOR
menu_layer_set_normal_colors(menu_schedule, ROW_BG_COLOR, ROW_FG_COLOR);
menu_layer_set_highlight_colors(menu_schedule, HIGHLIGHT_BG_COLOR, HIGHLIGHT_FG_COLOR);
#endif
menu_layer_set_callbacks(menu_schedule, NULL, (MenuLayerCallbacks) {
.get_num_sections = menu_get_num_sections_callback,
.get_num_rows = menu_get_num_rows_callback,
.get_header_height = menu_get_header_height_callback,
.get_cell_height = menu_get_height_callback,
.draw_header = menu_draw_header_callback,
.draw_row = menu_draw_row_callback,
.select_click = menu_select_callback,
});
menu_layer_set_click_config_onto_window(menu_schedule, window);
MenuIndex idx = get_current_session();
menu_layer_set_selected_index(menu_schedule, idx, MenuRowAlignCenter, false);
layer_add_child(window_layer, menu_layer_get_layer(menu_schedule));
}
/*****************************************************************************
* update_gui_session_modified()
*****************************************************************************/
void
update_gui_session_modified(void)
{
SESSION *session = get_current_session();
if ((session_modified_label != NULL) &&
(session->modified != show_session_modified)) {
gtk_label_set_text(GTK_LABEL(session_modified_label),
modified_label_text[session->modified]);
show_session_modified = session->modified;
}
}
int
main ()
{
char *session_id;
g_type_init ();
session_id = get_current_session ();
g_print ("%s\n", session_id);
get_seats ();
g_free (session_id);
}
/*****************************************************************************
* update_gui_session_name()
*****************************************************************************/
void
update_gui_session_name(void)
{
SESSION *session = get_current_session();
char *name = "";
if ((session_entry != NULL) && (GTK_IS_ENTRY(session_entry))) {
if (session->name != NULL) {
name = session->name;
}
gtk_entry_set_text(GTK_ENTRY(session_entry), name);
session_name_changed = 0;
}
}
/*****************************************************************************
* on_session_save_activate()
*****************************************************************************/
void
on_session_save_activate(GtkWidget *UNUSED(widget), gpointer data)
{
SESSION *session = get_current_session();
char *directory = (char *) data;
/* if no directory was provided, use the current session directory */
if ((directory == NULL) || (directory[0] == '\0')) {
if ((session->directory != NULL) && (session->directory[0] != '\0')) {
directory = get_session_directory_from_entry(GTK_ENTRY(session_entry));
session->directory = directory;
}
else {
directory = session->directory;
}
}
/* if we still don't have a directory, run the save-as dialog */
if (directory == NULL) {
run_session_save_as_dialog(NULL, NULL);
}
/* save the session with the given directory */
else {
switch (setting_bank_mem_mode) {
case BANK_MEM_AUTOSAVE:
/* save session without overwrite protection */
if (save_session(directory, session_io_start) == 0) {
update_gui_session_name();
save_session_bank();
}
break;
case BANK_MEM_WARN:
case BANK_MEM_PROTECT:
/* save session with overwrite protection */
if (!check_session_overwrite(directory)) {
if (save_session(directory, session_io_start) == 0) {
update_gui_session_name();
save_session_bank();
}
}
break;
}
}
}
/*****************************************************************************
* midi_select_program()
*****************************************************************************/
void
midi_select_program(unsigned int part_num, unsigned int prog_num)
{
SESSION *session = get_current_session();
PATCH *patch;
if (!setting_ignore_midi_program_change) {
patch = set_active_patch(visible_sess_num, part_num, prog_num);
init_patch_state(patch);
PHASEX_DEBUG(DEBUG_CLASS_MIDI_EVENT,
"\n*** MIDI Program Change: part=%d prog=%d (%d)\n\n",
(part_num + 1), prog_num, (prog_num + 1));
visible_prog_num[part_num] = prog_num;
session_bank[visible_sess_num].prog_num[part_num] = prog_num;
if ((part_num == visible_part_num)) {
pending_visible_patch = patch;
}
session->modified = 1;
}
}
/*****************************************************************************
* param_midi_update()
*
* Handle synth engine patch state updates for cc events received via midi.
*****************************************************************************/
void
param_midi_update(PARAM *param, int cc_val)
{
SESSION *session = get_current_session();
unsigned int id = param->info->id;
/* ignore midi updates for locked params */
if (!param->info->locked) {
/* update param value */
if (param->value.cc_val != cc_val) {
param->value.cc_prev = param->value.cc_val;
param->value.cc_val = cc_val;
param->value.int_val = cc_val + param->info->cc_offset;
param->updated = 1;
param->patch->modified = 1;
session->modified = 1;
/* update engine state */
cb_info[id].update_patch_state(param);
}
}
}
/*****************************************************************************
* on_save_session()
*****************************************************************************/
void
on_save_session(GtkWidget *UNUSED(widget), gpointer data)
{
SESSION *session = get_current_session();
GtkEntry *entry = GTK_ENTRY(data);
const char *name;
char directory[PATH_MAX] = "\0";
/* get name from entry widget */
name = gtk_entry_get_text(GTK_ENTRY(entry));
/* rebuild the directory and select directory as best as possible */
if ((session->parent_dir != NULL) && (session->parent_dir[0] != '\0')) {
if ((name != NULL) && (name[0] != '\0')) {
snprintf(directory, PATH_MAX, "%s/%s", session->parent_dir, name);
}
else {
snprintf(directory, PATH_MAX, "%s/Untitled-%04d",
session->parent_dir, visible_sess_num);
}
}
else {
if ((name != NULL) && (name[0] != '\0')) {
snprintf(directory, PATH_MAX, "%s/%s", user_session_dir, name);
}
else {
snprintf(directory, PATH_MAX, "%s/Untitled-%04d", user_session_dir, visible_sess_num);
}
}
/* if the patch is still untitled, run the save as dialog */
if (strncmp(directory, "Untitled", 8) == 0) {
run_session_save_as_dialog(NULL, directory);
}
/* otherwise, just save it */
else {
on_session_save_activate(NULL, directory);
}
}
/*****************************************************************************
* select_session()
*****************************************************************************/
void
select_session(GtkWidget *widget, gpointer data)
{
SESSION *session = get_current_session();
PATCH *patch;
GtkWidget *dialog;
GtkWidget *label;
GtkEntry *entry = NULL;
char *directory = NULL;
gint response;
int need_select = 1;
unsigned int sess_num;
unsigned int part_num;
/* called as a gui callback */
/* the widgets we need to reference are callback args */
if (data == NULL) {
entry = GTK_ENTRY(session_entry);
}
else {
entry = GTK_ENTRY(data);
}
/* get name from entry widget or strip current patch directory */
directory = get_session_directory_from_entry(entry);
/* get session number from spin button if called from gui */
sess_num = (unsigned int)(gtk_adjustment_get_value(GTK_ADJUSTMENT(widget))) - 1;
/* only continue if we're really changing the session number */
if (sess_num != visible_sess_num) {
/* whether or not to save depends on memory mode */
switch (setting_bank_mem_mode) {
case BANK_MEM_AUTOSAVE:
/* no canceling in autosave mode */
need_select = 1;
/* save current session if modified */
if (session->modified) {
on_session_save_activate(NULL, directory);
}
break;
case BANK_MEM_WARN:
/* this is set now, and may be canceled */
need_select = 1;
/* if modified, warn about losing current patch and give option to save */
if (session->modified) {
/* create dialog with buttons */
dialog = gtk_dialog_new_with_buttons("WARNING: Session Modified",
GTK_WINDOW(main_window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
"Ignore Changes",
GTK_RESPONSE_NO,
"Save and Select New",
GTK_RESPONSE_YES,
NULL);
gtk_window_set_wmclass(GTK_WINDOW(dialog), "phasex", "phasex-dialog");
gtk_window_set_role(GTK_WINDOW(dialog), "verify-save");
/* Alert message */
label = gtk_label_new("The current session has not been saved "
"since patches were last modified. Save "
"now before selecting new session?");
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_misc_set_padding(GTK_MISC(label), 8, 8);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), label);
//widget_set_custom_font (dialog);
gtk_widget_show_all(dialog);
/* Run the dialog */
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_YES:
/* save session and set flag to select session from bank */
on_session_save_activate(NULL, NULL);
need_select = 1;
break;
case GTK_RESPONSE_NO:
/* don't save, but still set flag to select new */
need_select = 1;
break;
case GTK_RESPONSE_CANCEL:
/* set spin button back to
current session and don't
select new */
gtk_adjustment_set_value(GTK_ADJUSTMENT(session_adj), (visible_sess_num + 1));
need_select = 0;
break;
}
/* all finished with dialog now */
gtk_widget_destroy(dialog);
}
break;
case BANK_MEM_PROTECT:
/* explicitly don't save */
need_select = 1;
break;
}
/* free name, now that we're done with it */
if (directory != NULL) {
free(directory);
}
}
else if (widget != NULL) {
need_select = 0;
}
/* select session specified by spinbutton or init new session */
if (need_select) {
visible_sess_num = sess_num;
session_io_start = sess_num;
session = get_session(sess_num);
session_load_in_progress = 1;
/* place current session name into session entry */
update_gui_session_name();
for (part_num = 0; part_num < MAX_PARTS; part_num++) {
visible_prog_num[part_num] = session->prog_num[part_num];
/* set active patch for this part in engine */
patch = set_active_patch(sess_num, part_num, session->prog_num[part_num]);
init_patch_state(patch);
/* GUI changes for visible part only */
if (part_num == visible_part_num) {
update_gui_patch(patch, 0);
}
}
update_gui_session_modified();
session_load_in_progress = 0;
}
}
/*****************************************************************************
* run_session_save_as_dialog()
*****************************************************************************/
void
run_session_save_as_dialog(GtkWidget *UNUSED(widget), gpointer data)
{
SESSION *session = get_current_session();
char *directory = (char *) data;
char *session_dir;
DIR_LIST *pdir = session_dir_list;
GError *error;
/* create dialog if needed */
if (session_save_dialog == NULL) {
create_session_save_dialog();
}
/* add all session dirs as shortcut folders */
while (pdir != NULL) {
if ((!pdir->save_shortcut)) {
error = NULL;
gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(session_save_dialog),
pdir->name, &error);
if (error != NULL) {
PHASEX_ERROR("Error %d: %s\n", error->code, error->message);
g_error_free(error);
}
pdir->save_shortcut = 1;
}
pdir = pdir->next;
}
/* set filename and current directory */
if ((directory == NULL) || (*directory == '\0')) {
directory = session->directory;
}
/* if we have a directory, and it's not the sessiondump, set and select it */
if ((directory != NULL) && (strcmp(directory, user_session_dump_dir) != 0)) {
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(session_save_dialog), directory);
}
/* if there is no filename, try to set the current directory */
else if ((session->parent_dir != NULL) && (* (session->parent_dir) != '\0')) {
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(session_save_dialog),
session->parent_dir);
}
else {
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(session_save_dialog),
user_session_dir);
}
/* set position in session bank to save session */
/* session_io_start should already be set properly at this point. */
gtk_spin_button_set_value(GTK_SPIN_BUTTON(session_save_start_spin), (session_io_start + 1));
/* run the dialog and save if necessary */
if (gtk_dialog_run(GTK_DIALOG(session_save_dialog)) == GTK_RESPONSE_ACCEPT) {
session_dir = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(session_save_dialog));
session_io_start =
(unsigned int) gtk_spin_button_get_value(GTK_SPIN_BUTTON(session_save_start_spin)) - 1;
/* hide dialog and save session */
gtk_widget_hide(session_save_dialog);
switch (setting_bank_mem_mode) {
case BANK_MEM_AUTOSAVE:
/* save session without overwrite protection */
if (save_session(session_dir, session_io_start) == 0) {
update_gui_session_name();
save_session_bank();
}
break;
case BANK_MEM_WARN:
case BANK_MEM_PROTECT:
/* save session with overwrite protection */
if (!check_session_overwrite(session_dir)) {
if (save_session(session_dir, session_io_start) == 0) {
update_gui_session_name();
save_session_bank();
}
}
break;
}
g_free(session_dir);
}
else {
/* save this widget for next time */
gtk_widget_hide(session_save_dialog);
}
}
/*****************************************************************************
* run_session_load_dialog()
*
* Callback for running the 'Load Session' dialog from the main menu.
*****************************************************************************/
void
run_session_load_dialog(GtkWidget *UNUSED(widget), gpointer UNUSED(data))
{
SESSION *session = get_current_session();
PATCH *patch;
DIR_LIST *pdir = session_dir_list;
char *directory;
GSList *file_list;
GSList *cur;
GError *error;
unsigned int sess_num = session_io_start;
unsigned int part_num;
/* create dialog if needed */
if (session_load_dialog == NULL) {
create_session_load_dialog();
}
gtk_widget_show(session_load_dialog);
/* add all session directories to shortcuts */
while (pdir != NULL) {
if (!pdir->load_shortcut) {
error = NULL;
gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(session_load_dialog),
pdir->name, &error);
if (error != NULL) {
PHASEX_ERROR("Error %d: %s\n", error->code, error->message);
g_error_free(error);
}
pdir->load_shortcut = 1;
}
pdir = pdir->next;
}
/* set filename and current directory */
if ((session->directory != NULL) && (* (session->directory) != '\0')) {
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(session_load_dialog), session->directory);
}
else if ((session->parent_dir != NULL) && (* (session->parent_dir) != '\0')) {
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(session_load_dialog),
session->parent_dir);
}
else {
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(session_load_dialog),
user_session_dir);
}
/* set position in patch bank to start loading patches */
session_io_start = visible_sess_num;
gtk_adjustment_set_value(GTK_ADJUSTMENT(session_io_start_adj), (session_io_start + 1));
/* run the dialog and load if necessary */
if (gtk_dialog_run(GTK_DIALOG(session_load_dialog)) == GTK_RESPONSE_ACCEPT) {
/* get list of selected files from chooser */
file_list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(session_load_dialog));
if (file_list != NULL) {
session_io_start =
(unsigned int) gtk_adjustment_get_value(GTK_ADJUSTMENT(session_io_start_adj)) - 1;
/* read in each session and increment session bank slot number */
sess_num = session_io_start;
session_load_in_progress = 1;
cur = file_list;
while (cur != NULL) {
directory = (char *) cur->data;
if (load_session(directory, sess_num) == 0) {
if (sess_num == visible_sess_num) {
for (part_num = 0; part_num < MAX_PARTS; part_num++) {
visible_prog_num[part_num] = 0;
patch = set_active_patch(visible_sess_num, part_num, 0);
init_patch_state(patch);
if (part_num == visible_part_num) {
update_gui_patch(patch, 0);
}
}
}
sess_num++;
}
if (sess_num >= SESSION_BANK_SIZE) {
break;
}
cur = g_slist_next(cur);
}
session_load_in_progress = 0;
g_slist_free(file_list);
update_gui_patch_name();
update_gui_session_name();
save_session_bank();
}
}
/* save this widget for next time */
gtk_widget_hide(session_load_dialog);
}
/*****************************************************************************
* on_load_session()
*
* Handler for the 'Load Session' button in the navbar.
*****************************************************************************/
void
on_load_session(GtkWidget *UNUSED(widget), gpointer data)
{
SESSION *session = get_current_session();
PATCH *patch;
GtkEntry *entry = GTK_ENTRY(data);
GtkWidget *dialog;
GtkWidget *label;
const char *name;
char directory[PATH_MAX];
gint response;
int need_load = 0;
unsigned int part_num;
/* build directory from entry widget and current session directory */
name = gtk_entry_get_text(entry);
if (session->parent_dir == NULL) {
snprintf(directory, PATH_MAX, "%s/%s", user_session_dir, name);
}
else {
snprintf(directory, PATH_MAX, "%s/%s", session->parent_dir, name);
}
/* handle saving of current session based on mem mode */
switch (setting_bank_mem_mode) {
case BANK_MEM_AUTOSAVE:
/* save current session if modified */
if (session->modified) {
on_session_save_activate(NULL, NULL);
}
need_load = 1;
break;
case BANK_MEM_WARN:
/* if modified, warn about losing current session */
if (session->modified) {
/* create dialog with buttons */
dialog = gtk_dialog_new_with_buttons("WARNING: Session Modified",
GTK_WINDOW(main_window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
"Ignore Changes",
GTK_RESPONSE_NO,
"Save and Load New",
GTK_RESPONSE_YES,
NULL);
gtk_window_set_wmclass(GTK_WINDOW(dialog), "phasex", "phasex-dialog");
gtk_window_set_role(GTK_WINDOW(dialog), "verify-save");
/* Alert message */
label = gtk_label_new("The current session has not been saved since it "
"was last modified. Save now before loading new "
"session?");
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_misc_set_padding(GTK_MISC(label), 8, 8);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), label);
//widget_set_custom_font (dialog);
gtk_widget_show_all(dialog);
/* Run the dialog */
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_YES:
/* save session and get ready to load a new one */
on_session_save_activate(NULL, NULL);
need_load = 1;
break;
case GTK_RESPONSE_NO:
/* no save, only set flag to load new session */
need_load = 1;
break;
case GTK_RESPONSE_CANCEL:
/* find old session name and revert text in entry */
if ((session->name == NULL) && (session->directory != NULL)) {
session->name = get_session_name_from_directory(session->directory);
}
update_gui_session_name();
/* cancel out on loading new session */
need_load = 0;
break;
}
gtk_widget_destroy(dialog);
}
/* if not modified, just load new session */
else {
need_load = 1;
}
break;
case BANK_MEM_PROTECT:
/* explicitly don't save in protect mode */
need_load = 1;
break;
}
/* load session specified by entry or assign an Untitled name */
if (need_load) {
session_load_in_progress = 1;
if ((need_load = load_session(directory, visible_sess_num)) != 0) {
snprintf(directory, PATH_MAX, "%s/%s", user_session_dir, name);
need_load = load_session(directory, visible_sess_num);
}
for (part_num = 0; part_num < MAX_PARTS; part_num++) {
visible_prog_num[part_num] = 0;
patch = set_active_patch(visible_sess_num, part_num, 0);
init_patch_state(patch);
if (part_num == visible_part_num) {
update_gui_patch(patch, 0);
}
}
if (session->name == NULL) {
sprintf(directory, "Untitled-%04d", visible_sess_num);
session->name = strdup(directory);
}
session->modified = 0;
session_load_in_progress = 0;
update_gui_patch(NULL, 0);
save_session_bank();
}
}
