#include #include #include "scripting/scheme-callbacks.h" #include "command/commandfuncs.h" #include "command/grace.h" #include "command/lilydirectives.h" #include "command/lyric.h" #include "command/measure.h" #include "command/object.h" #include "command/processstaffname.h" #include "command/select.h" #include "command/score.h" #include "command/scorelayout.h" #include "core/cache.h" #include "core/utils.h" #include "core/menusystem.h" #include "core/view.h" #include "core/graphicseditor.h" #include "core/keymapio.h" #include "audio/pitchentry.h" #include "command/lilydirectives.h" #include "audio/playback.h" #include "audio/audiointerface.h" #include "audio/midirecord.h" #include "export/audiofile.h" #include "export/guidedimportmidi.h" #include "export/print.h" #include "export/file.h" #include "export/exportmidi.h" #include "export/exportmusicxml.h" #include "ui/markup.h" #include "ui/keysigdialog.h" #include "ui/virtualkeyboard.h" #include "ui/texteditors.h" #include "ui/mousing.h" #include "printview/svgview.h" #include "printview/printview.h" #include "printview/markupview.h" #include "display/calculatepositions.h" #include "display/displayanimation.h" #include "source/source.h" #include "source/sourceaudio.h" #include "scripting/scheme_cb.h" SCM scheme_call_callback (SCM optional, callback_function callback) { gboolean query = FALSE; DenemoScriptParam param; GString *gstr = NULL; size_t length; char *str = NULL; if (scm_is_string (optional)) { str = scm_to_locale_stringn (optional, &length); gstr = g_string_new_len (str, length); if (!strncmp ("query", str, 5)) query = TRUE; } param.string = gstr; param.status = FALSE; callback (NULL, ¶m); if (param.status && query) return scm_from_locale_string (gstr->str); if (gstr) g_string_free (gstr, TRUE); return SCM_BOOL (param.status); } SCM ReturnValue = SCM_BOOL_F; static void set_return_value (SCM val) { ReturnValue = val; } static gboolean scm_is_list (SCM scm) { return scm_is_true (scm_list_p (scm)); } SCM scheme_popup_menu (SCM list) { GtkWidget *menu = gtk_menu_new (); set_return_value (SCM_BOOL_F); if (scm_is_list (list)) { gint i; gint length = scm_to_int (scm_length (list)); for (i = 0; i < length; i++) { SCM el = scm_list_ref (list, scm_from_int (i)); if (scm_is_pair (el)) { gchar *label = NULL; gchar *tooltip = NULL; SCM sym; //g_debug("Note that %d is value and %d stringp\n", scm_pair_p(el), scm_string_p(el)); if (scm_is_string (scm_car (el))) { label = scm_to_locale_string (scm_car (el)); sym = scm_cdr (el); } else if (scm_is_pair (scm_car (el))) { label = scm_to_locale_string (scm_caar (el)); tooltip = scm_to_locale_string (scm_cdar (el)); sym = scm_cdr (el); } if (label) { GtkWidget *item = gtk_menu_item_new_with_label (label); if (tooltip) gtk_widget_set_tooltip_text (item, tooltip); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); g_signal_connect_swapped (G_OBJECT (item), "activate", G_CALLBACK (set_return_value), sym); } else { set_return_value (SCM_BOOL_F); break; } } else if (scm_is_string (el)) { GtkWidget *item = gtk_menu_item_new_with_label (scm_to_locale_string (el)); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); g_signal_connect_swapped (G_OBJECT (item), "activate", G_CALLBACK (set_return_value), el); } else { set_return_value (SCM_BOOL_F); break; } } gtk_widget_show_all (menu); g_signal_connect (menu, "selection-done", gtk_main_quit, NULL); gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, 0, gtk_get_current_event_time ()); gtk_main (); } return ReturnValue; } static void toggle_value (gboolean * value) { *value = !*value; } void check_all (GtkWidget * button) { GList *children = gtk_container_get_children ((GtkContainer *) gtk_widget_get_parent (button)); for (; children; children = children->next) { GtkWidget *child = children->data; if (GTK_IS_CHECK_BUTTON (child)) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (child), TRUE); } } void uncheck_all (GtkWidget * button) { GList *children = gtk_container_get_children ((GtkContainer *) gtk_widget_get_parent (button)); for (; children; children = children->next) { GtkWidget *child = children->data; if (GTK_IS_CHECK_BUTTON (child)) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (child), FALSE); } } SCM scheme_check_boxes (SCM list, SCM title) { gchar *thetitle = scm_is_string (title) ? scm_to_locale_string (title) : _("Set Values"); GtkWidget *dialog = gtk_dialog_new_with_buttons (thetitle, GTK_WINDOW (Denemo.window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL); GtkWidget *content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); if (scm_is_list (list)) { gint i; gint length = scm_to_int (scm_length (list)); gboolean *status; status = (gint *) g_malloc0 (length * sizeof (gboolean)); GtkWidget *button = gtk_button_new_with_label (_("Check all")); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (check_all), NULL); gtk_container_add (GTK_CONTAINER (content_area), button); button = gtk_button_new_with_label (_("Un-check all")); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (uncheck_all), NULL); gtk_container_add (GTK_CONTAINER (content_area), button); scm_reverse (list); for (i = 0; i < length; i++) { SCM el = scm_list_ref (list, scm_from_int (i)); if (scm_is_pair (el)) { gchar *label = NULL; if (scm_is_string (scm_car (el))) { label = scm_to_locale_string (scm_car (el)); status[i] = scm_is_true (scm_cdr (el)); } if (label) { GtkWidget *item = gtk_check_button_new_with_label (label); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (item), status[i]); gtk_container_add (GTK_CONTAINER (content_area), item); g_signal_connect_swapped (G_OBJECT (item), "toggled", G_CALLBACK (toggle_value), &status[i]); } else { return SCM_BOOL_F; } } } gtk_widget_show_all (dialog); gint result = gtk_dialog_run (GTK_DIALOG (dialog)); switch (result) { case GTK_RESPONSE_ACCEPT: for (i = 0; i < length; i++) { scm_list_set_x (list, scm_from_int (i), scm_cons (scm_car (scm_list_ref (list, scm_from_int (i))), scm_from_bool (status[i]))); } g_free (status); break; default: gtk_widget_destroy (dialog); return SCM_BOOL_F; } gtk_widget_destroy (dialog); } return list; } static gchar *get_toggle_name (gchar *window) { switch (*window) { case 'p': if (*(window+1)=='l') return TogglePlaybackControls_STRING; else return TogglePrintView_STRING; case 'c': return ToggleCommandManager_STRING; case 's': return ToggleScript_STRING; case 'l': return ToggleLilyText_STRING; case 'm': return ToggleMidiInControls_STRING; } return NULL; } //make toggling view checkboxes available from Scheme SCM scheme_set_view_visibility (SCM win, SCM show) { if (scm_is_string (win)) { gchar *window = get_toggle_name (scm_to_locale_string (win)); if (window) { set_toggle (window, scm_is_true (show)); return SCM_BOOL_T; } } return SCM_BOOL_F; } SCM scheme_get_view_visibility (SCM win) { if (scm_is_string (win)) { gchar *window = get_toggle_name (scm_to_locale_string (win)); if (window) return scm_from_bool (get_toggle (window)); } return SCM_BOOL_F; } SCM scheme_create_palette_button (SCM palette, SCM lbl, SCM tltp, SCM scrp) { SCM ret; gchar *name = scm_to_locale_string (palette); gchar *label = scm_to_locale_string (lbl); gchar *tooltip = scm_to_locale_string (tltp); gchar *script = scm_to_locale_string (scrp); DenemoPalette *pal = create_palette (name, FALSE, TRUE); ret = palette_add_button (pal, label, tooltip, script) ? SCM_BOOL_T : SCM_BOOL_F; gtk_widget_show (gtk_widget_get_parent (pal->box)); free (name); free (label); free (tooltip); free (script); return ret; } SCM scheme_set_palette_shape (SCM palette, SCM horizontal, SCM limit) { gchar *name = scm_to_locale_string (palette); gboolean horiz = scm_is_true (horizontal); gint lim = scm_to_int (limit); DenemoPalette *pal = create_palette (name, FALSE, horiz); free (name); if (lim > 0) { pal->limit = lim; pal->rows = horiz; repack_palette (pal); return SCM_BOOL_T; } return SCM_BOOL_F; } SCM scheme_show_palettes (SCM option, SCM show) { if (scm_is_true (option)) { gchar *name; if (scm_is_string (option)) { name = scm_to_locale_string (option); DenemoPalette *pal = get_palette (name); if (pal == NULL) { mergePalette ((const gchar *) name); pal = get_palette (name); } if (pal) { if (!scm_is_false (show)) { gtk_widget_show (gtk_widget_get_parent (pal->box)); gtk_widget_show_all (pal->box); } else { gtk_widget_hide (pal->box); gtk_widget_hide (gtk_widget_get_parent (pal->box)); } return SCM_BOOL_T; } else { return SCM_BOOL_F; } } else { name = choose_palette_by_name (FALSE, TRUE); if (name) { DenemoPalette *pal = get_palette (name); if (pal) { gtk_widget_show (gtk_widget_get_parent (pal->box)); gtk_widget_show_all (pal->box); return SCM_BOOL_T; } else { return SCM_BOOL_F; } } } } else { if (Denemo.palettes) { GList *g; for (g = Denemo.palettes; g; g = g->next) { DenemoPalette *pal = (DenemoPalette *) g->data; if (!scm_is_false (show)) { gtk_widget_show (gtk_widget_get_parent (pal->box)); gtk_widget_show_all (pal->box); } else { gtk_widget_hide (pal->box); gtk_widget_hide (gtk_widget_get_parent (pal->box)); } } return SCM_BOOL_T; } else return SCM_BOOL_F; } return SCM_BOOL_F; } SCM scheme_select_palette (SCM aname) { gchar *name = NULL; if (scm_is_string (aname)) name = scm_to_locale_string (aname); else if (!SCM_UNBNDP (aname)) name = choose_palette_by_name (FALSE, FALSE); if (name) { DenemoPalette *pal = get_palette (name); if (pal) Denemo.currentpalette = pal; } if (Denemo.currentpalette) return scm_from_locale_string (Denemo.currentpalette->name); return SCM_BOOL_F; } static gint flash_input_cursor (void) { if (Denemo.input_filters->len > 0) { if (g_str_has_suffix (Denemo.input_filters->str, "|")) g_string_truncate (Denemo.input_filters, Denemo.input_filters->len - 1); else g_string_append_c (Denemo.input_filters, '|'); } write_input_status (); return TRUE; } static void choose_palette (GtkWidget * button) { GtkWidget *win = gtk_widget_get_toplevel (button); gchar *name = choose_palette_by_name (FALSE, FALSE); if (name) { DenemoPalette *pal = get_palette (name); if (pal) { Denemo.currentpalette = pal; gtk_window_set_title (GTK_WINDOW (win), pal->name); } } } static gboolean check_character (GtkWidget * entry, GdkEventKey * event, GtkWidget * dialog) { if (event->keyval == GDK_KEY_Tab) { choose_palette (entry); return TRUE; } if (event->keyval == GDK_KEY_Return) { gtk_dialog_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT); return TRUE; } return FALSE; } static gchar * label_entry (gchar * wlabel, gchar * direction) { GtkWidget *dialog; GtkWidget *entry; GtkWidget *label; gchar *entry_string; GString *string; entry = gtk_entry_new (); dialog = gtk_dialog_new (); gtk_window_set_title ((GtkWindow *) dialog, wlabel); gtk_window_set_transient_for ((GtkWindow *) dialog, GTK_WINDOW (Denemo.window)); gtk_window_set_destroy_with_parent ((GtkWindow *) dialog, TRUE); g_signal_connect (G_OBJECT (entry), "key-press-event", G_CALLBACK (check_character), dialog); label = gtk_label_new (direction); GtkWidget *content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); gtk_container_add (GTK_CONTAINER (content_area), label); gtk_container_add (GTK_CONTAINER (content_area), entry); label = gtk_label_new (_("Use to switch palette\nto activate")); gtk_container_add (GTK_CONTAINER (content_area), label); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE); gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (Denemo.window)); gtk_window_set_keep_above (GTK_WINDOW (dialog), TRUE); gtk_widget_show_all (dialog); gtk_widget_grab_focus (entry); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) { entry_string = (gchar *) gtk_entry_get_text (GTK_ENTRY (entry)); string = g_string_new (entry_string); gtk_widget_destroy (dialog); return g_string_free (string, FALSE); } else { gtk_widget_destroy (dialog); return NULL; } return NULL; } SCM scheme_activate_palette_button (void) { GdkEventKey event; GString *input = g_string_new (""); SCM ret = SCM_BOOL_F; gint id = 0; if (Denemo.palettes) { DenemoPalette *pal = Denemo.currentpalette; if (pal == NULL) pal = (DenemoPalette *) Denemo.palettes->data; gchar *str = label_entry (pal->name, _("Key in (part of) label")); pal = Denemo.currentpalette; if (str) { g_string_assign (input, str); g_free (str); if (input->len && palette_action_button (pal, input->str)) { ret = SCM_BOOL_T; } else { infodialog (_("No such label")); gtk_widget_show (gtk_widget_get_parent (pal->box)); gtk_widget_show_all (pal->box); } } } return ret; } SCM scheme_get_offset (void) { #ifndef USE_EVINCE g_debug ("This feature requires denemo to be built with evince"); #else gdouble offsetx, offsety; if (get_offset (&offsetx, &offsety)) { offsetx *= 100; offsety *= 100; offsetx = floor (offsetx); offsety = floor (offsety); offsetx /= 100; offsety /= 100; return scm_cons (scm_from_double (offsetx), scm_from_double (offsety)); } #endif return SCM_BOOL_F; } SCM scheme_get_control_point (SCM pt) { #ifndef USE_EVINCE g_debug ("This feature requires denemo to be built with evince"); #else if (scm_is_integer (pt)) { gint which = scm_to_int (pt); if (which > 0 && which < 5) return SCM_BOOL (get_control_point (which)); } #endif return SCM_BOOL_F; } static void prec (gdouble * val) { *val = round ((*val) * 100.0) / 100; } SCM scheme_get_curve (void) { #ifndef USE_EVINCE g_debug ("This feature requires denemo to be built with evince"); #else gdouble x1, y1, x2, y2, x3, y3, x4, y4; if (get_curve (&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) { prec (&x1); prec (&y1); prec (&x2); prec (&y2); prec (&x3); prec (&y3); prec (&x4); prec (&y4); return scm_list_n (scm_cons (scm_from_double (x1), scm_from_double (y1)), scm_cons (scm_from_double (x2), scm_from_double (y2)), scm_cons (scm_from_double (x3), scm_from_double (y3)), scm_cons (scm_from_double (x4), scm_from_double (y4)), SCM_UNDEFINED); } #endif return SCM_BOOL_F; } SCM scheme_get_positions (SCM is_slur) { #ifndef USE_EVINCE g_debug ("This feature requires denemo to be built with evince"); #else gdouble neary, fary; if (get_positions (&neary, &fary, scm_is_true (is_slur) ? Slur : Beam)) { return scm_cons (scm_from_double (neary), scm_from_double (fary)); } #endif return SCM_BOOL_F; } SCM scheme_get_new_target (void) { #ifndef USE_EVINCE g_debug ("This feature requires denemo to be built with evince"); return SCM_BOOL_F; #else return scm_from_bool (get_new_target ()); #endif } SCM scheme_get_new_point (void) { #ifndef USE_EVINCE g_debug ("This feature requires denemo to be built with evince"); return SCM_BOOL_F; #else return scm_from_bool (get_new_point ()); #endif } SCM scheme_get_reference_point (void) { #ifndef USE_EVINCE g_debug ("This feature requires denemo to be built with evince"); return SCM_BOOL_F; #else return scm_from_bool (get_reference_point ()); #endif } SCM scheme_get_target_info (void) { DenemoMovement *si = Denemo.project->movement; if (Denemo.project->movement->currentobject == NULL) return SCM_BOOL_F; SCM type = SCM_BOOL_F, grob = SCM_BOOL_F, tag = SCM_BOOL_F; switch (si->target.type) { case TARGET_NONE: type = SCM_BOOL_F; break; case TARGET_OBJECT: type = scm_from_locale_string ("Object"); break; case TARGET_CHORD: type = scm_from_locale_string ("Chord"); break; case TARGET_NOTE: type = scm_from_locale_string ("Note"); break; case TARGET_SLUR: type = scm_from_locale_string ("Slur"); break; case TARGET_TIE: type = scm_from_locale_string ("Tie"); break; case TARGET_CRESC: type = scm_from_locale_string ("Cresc"); break; case TARGET_DIM: type = scm_from_locale_string ("Dim"); break; default: g_warning ("Unknown target type %d", si->target.type); type = SCM_BOOL_F; break; } if (si->target.type == TARGET_NOTE) { DenemoObject *obj = si->currentobject->data; if (obj->type == CHORD) { chord *thechord = ((chord *) ((DenemoObject *) obj->object)); if (thechord->figure) grob = scm_from_locale_string ("BassFigure"); } } if (si->target.directivenum || (si->target.type == TARGET_OBJECT)) { DenemoDirective *directive = NULL; DenemoObject *obj = si->currentobject->data; if (si->target.type == TARGET_CHORD) { if (obj->type == CHORD) { GList *directives = ((chord *) ((DenemoObject *) obj->object))->directives; if (directives) { directive = (DenemoDirective *) g_list_nth_data (directives, si->target.directivenum - 1); } } } else if (si->target.type == TARGET_NOTE) { if (obj->type == CHORD) { directive = get_note_directive_number (si->target.directivenum); } } else if (si->target.type == TARGET_OBJECT) { if (obj->type == LILYDIRECTIVE) directive = (DenemoDirective *) obj->object; } if (directive) { if (directive->grob) { grob = scm_from_locale_string (directive->grob->str); } else grob = SCM_BOOL_F; } if (directive && directive->tag) { tag = scm_from_locale_string (directive->tag->str); } } return scm_list_n (type, grob, tag, SCM_UNDEFINED); } //FIXME inelegant! static gint interpret_lilypond_notename (gchar * x, gint * mid_c_offset, gint * enshift) { //g_debug("Mid c offset of %d\n", *x-'c'); gchar *c; gint octave = -1; /* middle c is c' */ gint accs = 0; for (c = x + 1; *c; c++) { if (*c == 'i' && *(c + 1) == 's') { accs++; c++; } else if (*c == 'e' && *(c + 1) == 's') { accs--; c++; } else if (*c == ',') { octave--; } else if (*c == '\'') { octave++; } } if (*x == 'a' || *x == 'b') octave++; *mid_c_offset = *x - 'c' + 7 * octave; *enshift = accs; return *mid_c_offset; } static gint lilypond_to_enshift (gchar * enshift_name) { gint enshift = 0; gchar *c; for (c = enshift_name; *c; c++) { if (*c == 'i' && *(c + 1) == 's') { enshift++; c++; } else if (*c == 'e' && *(c + 1) == 's') { enshift--; c++; } } return enshift; } /* execute init script local dir for menupath or fallback on system dir */ SCM scheme_execute_init (gchar * menupath) { GList *dirs = NULL; dirs = g_list_append (dirs, g_build_filename (get_user_data_dir (TRUE), COMMANDS_DIR, "menus", menupath, NULL)); dirs = g_list_append (dirs, g_build_filename (get_system_data_dir (), COMMANDS_DIR, "menus", menupath, NULL)); gchar *path = find_path_for_file (INIT_SCM, dirs); if (path) { g_message ("About to load from %s", path); eval_file_with_catch (path); //ret = scm_c_primitive_load(filename); } return SCM_BOOL (TRUE); } void execute_init_scripts (gchar * menupath) { (void) scheme_execute_init (menupath); } /* called by a script if it requires initialization the initialization script is expected to be in init.scm in the menupath of the action that invoked the script*/ SCM scheme_initialize_script (SCM action_name) { SCM ret = SCM_BOOL_T; char *name = scm_to_locale_string (action_name); gint idx = lookup_command_from_name (Denemo.map, name); command_row *row = NULL; if (keymap_get_command_row (Denemo.map, &row, idx)) ret = scheme_execute_init (row->menupath); if (name) free (name); return ret; } /* pass in a path (from below menus) to a command script. Loads the command from .denemo or system * if it can be found * It is used at startup in .denemo files like ReadingNoteNames.denemo * which executes (d-LoadCommand "MainMenu/Educational/ReadingNoteNames") * to ensure that the command it needs is in the command set. */ SCM scheme_load_command (SCM command) { gboolean ret; char *name; name = scm_to_locale_string (command); GList *files = NULL; files = g_list_append (files, g_build_filename (get_user_data_dir (TRUE), COMMANDS_DIR, "menus", name, NULL)); files = g_list_append (files, g_build_filename (get_user_data_dir (TRUE), "download", COMMANDS_DIR, name, NULL)); files = g_list_append (files, g_build_filename (get_system_data_dir (), COMMANDS_DIR, name, NULL)); ret = load_command_from_file_list (files); if (name) free (name); return SCM_BOOL (ret); } SCM scheme_activate_menu_item (SCM menupath) { if (scm_is_string (menupath)) { char *item; item = scm_to_locale_string (menupath); if (item) { gboolean ret = activate_action (item) ? TRUE : FALSE; free (item); return SCM_BOOL (ret); } } return SCM_BOOL_F; } SCM scheme_hide_buttons (SCM hide) { SCM ret = SCM_BOOL_F; GtkWidget *widget = Denemo.project->buttonbox; if (GTK_IS_CONTAINER (widget)) { ret = SCM_BOOL_T; if (scm_is_false (hide)) gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_show, NULL); else gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_hide, NULL); } return ret; } SCM scheme_destroy_buttons (void) { SCM ret = SCM_BOOL_F; GtkWidget *widget = Denemo.project->buttonbox; if (GTK_IS_CONTAINER (widget)) { gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_destroy, NULL); ret = SCM_BOOL_T; } return ret; } SCM scheme_system (SCM command) { if (scm_is_string (command)) { gchar *cmd = scm_to_locale_string (command); gint val = system (cmd); //g_print ("Command is %s system() call returning %d\n", cmd, val); if (val>256) val >>=8;//some stdlib.h versions munge the return value - we exit with 8 bit values only //g_print ("after conversion returning %d\n", val); return scm_from_int (val); } return SCM_BOOL_F; } /* hide all menus, leaving only the score titles, used for educational games */ SCM scheme_hide_menus (SCM hide) { if (Denemo.project->view != DENEMO_MENU_VIEW) { set_toggle (ToggleScoreTitles_STRING, FALSE); ToggleReduceToDrawingArea (NULL, NULL); return SCM_BOOL (TRUE); } gboolean show = FALSE; if (scm_is_false (hide)) show = TRUE; if (!Denemo.non_interactive) { toggle_to_drawing_area (show); set_toggle (ToggleScoreTitles_STRING, FALSE); } return SCM_BOOL (TRUE); } SCM scheme_hide_window (SCM hide) { gboolean show = FALSE; gboolean showing = gtk_widget_get_visible (Denemo.window); if (scm_is_false (hide)) show = TRUE; if (show) gtk_widget_show (Denemo.window); else gtk_widget_hide (Denemo.window); return SCM_BOOL (showing == show); } SCM scheme_activate_object (void) { activate_right_click (Denemo.keyboard_state); GString *modname = mouse_shortcut_name (Denemo.keyboard_state, GESTURE_PRESS, FALSE); gint command_idx = lookup_command_for_keybinding_name (Denemo.map, modname->str); if (command_idx>=0) execute_callback_from_idx (Denemo.map, command_idx); g_string_free (modname, TRUE); return SCM_BOOL_T; } /* when a script calls a command which is itself a script it comes through here */ SCM scheme_script_callback (SCM script, SCM params) { char *name = NULL; SCM ret = SCM_BOOL_F; if (scm_is_string (script)) { name = scm_to_locale_string (script); gint idx = lookup_command_from_name (Denemo.map, name); if (name) { if (!is_action_name_builtin (name)) { gchar *paramvar = g_strdup_printf ("%s::params", name); scm_c_define (paramvar, params); gchar *text = get_scheme_from_idx (idx); if (text) { //undo is a queue so this is the end :) stage_undo (Denemo.project->movement, ACTION_STAGE_END); ret = SCM_BOOL (!call_out_to_guile (text)); stage_undo (Denemo.project->movement, ACTION_STAGE_START); } else if (!Denemo.non_interactive) { DenemoAction *action = lookup_action_from_name (name); ret = SCM_BOOL (activate_script (action, NULL)); } else g_warning ("Could not execute %s script", name); scm_c_define (paramvar, SCM_BOOL_F); g_free (paramvar); } if (name) free (name); } } return ret; } void create_scheme_function_for_script (gchar * name) { gchar *proc = g_strdup_printf ("(d-%s #:optional params)", name); gchar *value = g_strdup_printf ("(d-ScriptCallback \"%s\" params)", name); gchar *def = g_strdup_printf ("(define %s::params #f) (define* %s %s)", name, proc, value); //g_debug("Defining %s\n", def); call_out_to_guile (def); g_free (proc); g_free (value); g_free (def); // define_scheme_literal_variable(proc, value, "A scheme procedure to call the script of that name"); } SCM scheme_swap_display_and_source (void) { gint root_x, root_y, sx, sy; if (Denemo.project->source_scale) { gtk_window_get_position (GTK_WINDOW (Denemo.window), &root_x, &root_y); if (move_source_window (root_x, root_y)) gtk_window_move (GTK_WINDOW (Denemo.window), Denemo.project->source_x, Denemo.project->source_y); else return SCM_BOOL_F; write_status (Denemo.project); return SCM_BOOL_T; } return SCM_BOOL_F; } SCM scheme_debug_object (SCM optional) { DenemoObject *curObj; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data)) return SCM_BOOL (FALSE); g_print ("*************\nType = %d\nbasic_durinticks = %d\ndurinticks - %d\nstarttickofnextnote = %d\n***********\n", curObj->type, curObj->basic_durinticks, curObj->durinticks, curObj->starttickofnextnote); return SCM_BOOL (TRUE); } SCM scheme_display_object (void) { DenemoObject *curObj; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data)) return SCM_BOOL (FALSE); display_current_object (); return SCM_BOOL (TRUE); } SCM scheme_get_editing_time (void) { SCM ret; gchar *edit_time = time_spent_editing (); ret = scm_from_locale_string (edit_time); g_free (edit_time); return ret; } SCM scheme_set_editing_time (SCM secs) { if (scm_is_integer (secs)) { gint time = scm_to_int (secs); Denemo.project->total_edit_time = time; reset_editing_timer (); return SCM_BOOL_T; } return SCM_BOOL_F; } SCM scheme_clear_print_history (void) { if (Denemo.project->printhistory==NULL) Denemo.project->printhistory = g_string_new(""); else g_string_assign (Denemo.project->printhistory, ""); return SCM_BOOL_T; } SCM scheme_destroy_scheme_init (void) { if (confirm (_("Destroying Customized Buttons"), _("Remove buttons and other customized scheme on startup?"))) { destroy_local_scheme_init (); return SCM_BOOL_T; } return SCM_BOOL_F; } SCM scheme_append_scheme_text (SCM script) { if (scm_is_string (script)) { gchar *text = scm_to_locale_string (script); appendSchemeText (text); return SCM_BOOL_T; } return SCM_BOOL_F; } SCM scheme_get_scheme_text (void) { return scm_from_locale_string (get_script_view_text()); } SCM scheme_load_keybindings (SCM name) { char *filename; if (scm_is_string (name)) { filename = scm_to_locale_string (name); if (load_xml_keybindings (filename) || load_xml_keybindings (g_build_filename (get_user_data_dir (TRUE), COMMANDS_DIR, filename, NULL)) || load_xml_keybindings (g_build_filename (get_system_data_dir (), COMMANDS_DIR, filename, NULL))) return SCM_BOOL_T; } return SCM_BOOL_F; } SCM scheme_save_keybindings (SCM name) { char *filename; if (scm_is_string (name)) { filename = scm_to_locale_string (name); if (save_xml_keybindings (filename) == 0) { if (filename) free (filename); return SCM_BOOL_T; } } return SCM_BOOL_F; } SCM scheme_clear_keybindings (SCM optional) { keymap_clear_bindings (Denemo.map); return SCM_BOOL_T; } SCM scheme_load_commandset (SCM name) { char *filename; SCM ret = SCM_BOOL_F; if (scm_is_string (name)) { filename = scm_to_locale_string (name); if (load_commands_from_xml (filename) == 0) ret = SCM_BOOL_T; if (load_xml_keybindings (filename)) ret = SCM_BOOL_T; if (filename) free (filename); } return ret; } SCM scheme_push_clipboard (SCM optional) { push_clipboard (); return SCM_BOOL_T; } SCM scheme_pop_clipboard (SCM num) { gint count = 0; if (scm_is_integer (num)) count = scm_to_int (num); if (pop_clipboard (count)) return SCM_BOOL_T; else return SCM_BOOL_F; } SCM scheme_delete_selection (SCM optional) { if ((!Denemo.project->movement) || (!Denemo.project->movement->markstaffnum)) return SCM_BOOL_F; delete_selection (); return SCM_BOOL_T; } SCM scheme_set_thumbnail_selection (SCM optional) { if ((!Denemo.project->movement) || (!Denemo.project->movement->markstaffnum)) return SCM_BOOL_F; if (Denemo.project->movement == Denemo.project->movements->data) { memcpy (&Denemo.project->thumbnail, &Denemo.project->movement->selection, sizeof (DenemoSelection)); return SCM_BOOL_T; } return SCM_BOOL_F; } SCM scheme_set_newbie (SCM optional) { SCM ret = SCM_BOOL (Denemo.prefs.newbie); if (scm_is_true (optional)) { Denemo.prefs.tooltip_timeout = 1000; Denemo.prefs.tooltip_browse_timeout = 700; Denemo.prefs.tooltip_browse_mode_timeout = 1000; Denemo.prefs.learning = 1; Denemo.prefs.newbie = 1; } else { Denemo.prefs.tooltip_timeout = Denemo.prefs.tooltip_browse_timeout = 2000; Denemo.prefs.newbie = 0; gtk_widget_set_tooltip_text (Denemo.scorearea, NULL); } return ret; } SCM scheme_get_checksum (SCM str) { SCM ret = SCM_BOOL_F; if (scm_is_string (str)) { gchar *chk; gchar *thestring = scm_to_locale_string (str); chk = g_compute_checksum_for_string (G_CHECKSUM_MD5, thestring, -1); ret = scm_from_locale_string (chk); g_free (chk); } return ret; } SCM scheme_create_thumbnail (SCM optional, SCM filename) { #ifndef USE_EVINCE g_debug ("This feature requires denemo to be built with evince"); return SCM_BOOL_F; #else gchar *path = scm_is_string (filename) ? scm_to_locale_string (filename) : NULL; gboolean ret; if ((!SCM_UNBNDP (optional)) && scm_is_true (optional)) ret = create_thumbnail (TRUE, path); else ret = create_thumbnail (FALSE, path); return SCM_BOOL (ret); #endif } SCM scheme_exit (SCM optional) { exit (0); } SCM scheme_create_layout (SCM name) { SCM ret = SCM_BOOL_F; if (scm_is_string (name)) { gchar *layout_name = scm_to_locale_string (name); Denemo.pending_layout_id = get_layout_id_for_name (layout_name); signal_structural_change (Denemo.project); select_layout (1, NULL, NULL); ret = scm_from_bool (create_custom_scoreblock (layout_name, TRUE)); (void)selected_scoreblock (); //FIXME this is needed to make Accompanist's score work Denemo.pending_layout_id = 0; } return ret; } SCM scheme_set_pending_layout (SCM name) { if (scm_is_string (name)) { gchar *layout_name = scm_to_locale_string (name); Denemo.pending_layout_id = get_layout_id_for_name ((guchar *) layout_name); } else Denemo.pending_layout_id = 0; return scm_from_int ((guint)Denemo.pending_layout_id); } SCM scheme_delete_layout (SCM name) { if (scm_is_string (name)) { gchar *layout_name = scm_to_locale_string (name); return scm_from_bool (delete_custom_scoreblock (layout_name)); } return SCM_BOOL_F; } SCM scheme_lilypond_for_part (void) { gint save = Denemo.project->movement->markstaffnum; Denemo.project->movement->markstaffnum = 0; if (!select_custom_layout_for_name (((DenemoStaff *) (Denemo.project->movement->currentstaff->data))->lily_name->str)) generate_lilypond_part (); Denemo.project->movement->markstaffnum = save; return SCM_BOOL_T; } SCM scheme_typeset_part (void) { #ifndef USE_EVINCE g_debug ("This feature requires denemo to be built with evince"); return SCM_BOOL_F; #else typeset_part (); return SCM_BOOL_T; #endif } SCM scheme_typeset_current_movement (void) { #ifndef USE_EVINCE g_debug ("This feature requires denemo to be built with evince"); return SCM_BOOL_F; #else typeset_current_movement (); return SCM_BOOL_T; #endif } SCM scheme_reduce_layout_to_lilypond (void) { make_scoreblock_editable (); return SCM_BOOL_T; } SCM scheme_get_current_staff_layout_id (void) { guint id; if (((DenemoStaff *) (Denemo.project->movement->currentstaff->data))->voicecontrol == DENEMO_PRIMARY) { id = get_layout_id_for_name (((DenemoStaff *) (Denemo.project->movement->currentstaff->data))->lily_name->str); return scm_from_int (id); } return SCM_BOOL_F; } SCM scheme_get_layout_id (void) { DenemoScoreblock *sb = (DenemoScoreblock *) selected_scoreblock (); if (sb) return scm_from_int (sb->id); return SCM_BOOL_F; } SCM scheme_select_layout_id (SCM the_id) { if (scm_is_integer (the_id)) { gint id = scm_to_int (the_id); return SCM_BOOL (select_layout_id (id)); } return SCM_BOOL_F; } SCM scheme_select_default_layout (void) { select_default_scoreblock (); return SCM_BOOL_T; } SCM scheme_get_layout_name (void) { DenemoScoreblock *sb = (DenemoScoreblock *) selected_scoreblock (); if (sb && sb->name) return scm_from_locale_string (sb->name); return SCM_BOOL_F; } SCM scheme_select_next_layout (void) { DenemoScoreblock *sb = (DenemoScoreblock *) get_next_scoreblock (); return sb ? SCM_BOOL_T : SCM_BOOL_F; } SCM scheme_select_first_layout (void) { DenemoScoreblock *sb = (DenemoScoreblock *) get_first_scoreblock (); return sb ? SCM_BOOL_T : SCM_BOOL_F; } SCM scheme_select_next_custom_layout (void) { return SCM_BOOL (iterate_custom_layout (FALSE)); } SCM scheme_select_first_custom_layout (void) { return SCM_BOOL (iterate_custom_layout (TRUE)); } SCM scheme_get_include_criterion (void) { if (Denemo.project->criterion) return scm_cons (scm_from_locale_string (Denemo.project->criterion->name), scm_from_int (Denemo.project->criterion->id)); else return SCM_BOOL_F; } SCM scheme_set_include_criterion (SCM value) { GList *g; gchar *name = NULL; if (scm_is_string (value)) { name = scm_to_locale_string (value); name = g_strconcat (" ", name, NULL);//inclusion criteria have leading space } if (name) for (g=Denemo.project->criteria; g; g=g->next) { DenemoInclusionCriterion *condition = g->data; if (!strcmp (name, condition->name)) { set_condition (condition); return SCM_BOOL_T; } } else set_condition (NULL); return SCM_BOOL_F; } SCM scheme_get_include_criteria (void) { GList *g; SCM ret = scm_list_n (SCM_UNDEFINED); for (g=Denemo.project->criteria; g; g=g->next) { DenemoInclusionCriterion *condition = g->data; ret = scm_cons (scm_cons (scm_from_locale_string (condition->name), scm_from_int (condition->id)), ret); } return ret; } static gchar *is_inclusion_criterion (gint id) { GList *g; for (g=Denemo.project->criteria; g; g=g->next) { DenemoInclusionCriterion *condition = g->data; if (condition->id == id) return condition->name; } return NULL; } SCM scheme_create_include_criterion (SCM aname) { gchar *name = NULL; if (scm_is_string (aname)) name = g_strconcat (" ", scm_to_locale_string (aname), NULL); if (name == NULL || !is_inclusion_criterion (get_layout_id_for_name (name))) create_new_inclusion_criterion (name?name + 1 : NULL);//skip space g_free (name); return scheme_get_include_criteria (); } SCM scheme_get_include_criteria_on_directive (SCM tagname, SCM typename) { GList *h, *g; SCM ret = scm_list_n (SCM_UNDEFINED); DenemoDirective *directive = NULL; GList *curObj = Denemo.project->movement->currentobject; DenemoObject *theobj = curObj?(DenemoObject *) curObj->data : NULL; if (scm_is_string (tagname) && scm_is_string (typename)) { gchar *tag = scm_to_locale_string (tagname); gchar *type = scm_to_locale_string (typename); if (!strcmp (type, "clef")) { if (theobj && theobj->type == CLEF); directive = get_clef_directive (tag); } else if (!strcmp (type, "timesig")) { if (theobj && theobj->type == TIMESIG) directive = get_timesig_directive (tag); } else if (!strcmp (type, "keysig")) { if (theobj && theobj->type == KEYSIG) directive = get_keysig_directive (tag); } else if (!strcmp (type, "note")) { if (theobj && theobj->type == CHORD) directive = get_note_directive (tag); } else if (!strcmp (type, "chord")) { if (theobj && theobj->type == CHORD) directive = get_chord_directive (tag); } else if (!strcmp (type, "standalone")) { if (theobj && theobj->type == LILYDIRECTIVE) directive = (DenemoDirective*)theobj->object; //tag is assumed correct from caller } else if (!strcmp (type, "scoreheader")) { directive = get_scoreheader_directive (tag); } else if (!strcmp (type, "paper")) { directive = get_paper_directive (tag); } else if (!strcmp (type, "layout")) { directive = get_layout_directive (tag); } else if (!strcmp (type, "movementcontrol")) { directive = get_movementcontrol_directive (tag); } else if (!strcmp (type, "header")) { directive = get_header_directive (tag); } else if (!strcmp (type, "score")) { directive = get_score_directive (tag); } else if (!strcmp (type, "staff")) { directive = get_staff_directive (tag); } else if (!strcmp (type, "voice")) { directive = get_voice_directive (tag); } if (directive) { for (h = directive->layouts;h;h=h->next) { gchar *name = is_inclusion_criterion (GPOINTER_TO_INT(h->data)); if (name) ret = scm_cons (scm_from_locale_string (name), ret); } return ret; } } return SCM_BOOL_F; } SCM scheme_get_id_for_name (SCM layout_name) { if (scm_is_string (layout_name)) { gchar* lay = scm_to_locale_string (layout_name); guint id = get_layout_id_for_name (lay); return scm_from_int (id); } return SCM_BOOL_F; } SCM scheme_get_filename (void) { if (Denemo.project && Denemo.project->filename && Denemo.project->filename->len && strcmp ("Unnamed", Denemo.project->filename->str)) return scm_from_locale_string (Denemo.project->filename->str); return SCM_BOOL_F; } SCM scheme_clear_filename (void) { if (Denemo.project && Denemo.project->filename) { set_project_filename (Denemo.project, ""); return SCM_BOOL_T; } else return SCM_BOOL_F; } SCM scheme_select_tab (SCM index) { if (scm_is_integer (index)) { gint num = scm_to_int (index); gtk_notebook_set_current_page (GTK_NOTEBOOK (Denemo.notebook), num); } return scm_from_int (gtk_notebook_get_current_page (GTK_NOTEBOOK (Denemo.notebook))); } /* compare objects at the cursor in the two passed tabs. If move is true * move the cursor to the next object before doing the comparison. * If move fails on both tabs return #f * If it fails on one tab only return a pair (error-message #f) * Otherwise (if there is no move or it succeeds on both) call compare_objects * to find any mis-matching objects. * If it returns NULL - all objects match and end of staff reached, return #f * else return a pair (error-message #t) */ SCM scheme_compare_objects (SCM index1, SCM index2, SCM move) { SCM ret = SCM_BOOL_F; DenemoMovement *si; gboolean skip = scm_is_true (move); if (scm_is_integer (index1) && scm_is_integer (index2)) { gint original_index = gtk_notebook_get_current_page (GTK_NOTEBOOK (Denemo.notebook)); gint num1 = scm_to_int (index1); gint num2 = scm_to_int (index2); gtk_notebook_set_current_page (GTK_NOTEBOOK (Denemo.notebook), num1);//sets Denemo.project to new value si = Denemo.project->movement; gint move1 = TRUE; if (skip) move1 = cursor_to_next_object (FALSE, FALSE); GList *curobj1 = si->currentobject; GList *curmeasure1 = si->currentmeasure; gint curmeasurenum1 = si->currentmeasurenum; gint curobjnum1 = si->cursor_x; gtk_notebook_set_current_page (GTK_NOTEBOOK (Denemo.notebook), num2); si = Denemo.project->movement; gint move2 = TRUE; if (skip) move2 = cursor_to_next_object (FALSE, FALSE); GList *curobj2 = si->currentobject; GList *curmeasure2 = si->currentmeasure; gint curmeasurenum2 = si->currentmeasurenum; gint curobjnum2 = si->cursor_x; if ((!move1) && (!move2)) { ret = SCM_BOOL_F; } else { if ((!move1) || (!move2)) { ret = scm_cons (scm_from_locale_string (_("Extra Objects in one staff")), SCM_BOOL_F); } else { gchar *status = compare_objects (curmeasure1, curobj1, &curmeasurenum1, &curobjnum1, curmeasure2, curobj2, &curmeasurenum2, &curobjnum2); if (status) { ret = scm_cons (scm_from_locale_string (status), SCM_BOOL_T); g_free (status); gtk_notebook_set_current_page (GTK_NOTEBOOK (Denemo.notebook), num1); goto_movement_staff_obj (NULL, -1, -1, curmeasurenum1, curobjnum1+1, 0); gtk_notebook_set_current_page (GTK_NOTEBOOK (Denemo.notebook), num2); goto_movement_staff_obj (NULL, -1, -1, curmeasurenum2, curobjnum2+1, 0); } else ret = SCM_BOOL_F; gtk_notebook_set_current_page (GTK_NOTEBOOK (Denemo.notebook), original_index); } } } return ret; } SCM scheme_compare_objects_at_cursor (SCM index1, SCM index2) { if (scm_is_integer (index1) && scm_is_integer (index2)) { gint original_index = gtk_notebook_get_current_page (GTK_NOTEBOOK (Denemo.notebook)); gint num1 = scm_to_int (index1); gint num2 = scm_to_int (index2); gtk_notebook_set_current_page (GTK_NOTEBOOK (Denemo.notebook), num1); DenemoObject *obj1 = (DenemoObject *)Denemo.project->movement->currentobject?(DenemoObject *)Denemo.project->movement->currentobject->data:NULL; gtk_notebook_set_current_page (GTK_NOTEBOOK (Denemo.notebook), num2); DenemoObject *obj2 = (DenemoObject *)Denemo.project->movement->currentobject?(DenemoObject *)Denemo.project->movement->currentobject->data:NULL; gchar *compare = compare_two_objects (obj1, obj2, ""); gtk_notebook_set_current_page (GTK_NOTEBOOK (Denemo.notebook), original_index); if (compare) { SCM ret; ret = scm_from_locale_string (compare); g_free (compare); return ret; }; } return SCM_BOOL_F; } //looks for a difference in current staffs in the passed tabs (not the music in the staff) moves to the staff below if move is not #f SCM scheme_difference_of_staffs (SCM index1, SCM index2, SCM move) { if (scm_is_integer (index1) && scm_is_integer (index2)) { gint original_index = gtk_notebook_get_current_page (GTK_NOTEBOOK (Denemo.notebook)); gint num1 = scm_to_int (index1); gint num2 = scm_to_int (index2); gtk_notebook_set_current_page (GTK_NOTEBOOK (Denemo.notebook), num1); DenemoStaff *staff1 = (DenemoStaff *)Denemo.project->movement->currentstaff->data; if (scm_is_true (move)) movetostaffdown (NULL, NULL); gtk_notebook_set_current_page (GTK_NOTEBOOK (Denemo.notebook), num2); DenemoStaff *staff2 = (DenemoStaff *)Denemo.project->movement->currentstaff->data; if (scm_is_true (move)) movetostaffdown (NULL, NULL); gchar *compare = difference_of_staffs (staff1, staff2); gtk_notebook_set_current_page (GTK_NOTEBOOK (Denemo.notebook), original_index); if (compare) { SCM ret; ret = scm_from_locale_string (compare); g_free (compare); return ret; } } return SCM_BOOL_F; } SCM scheme_difference_of_projects (SCM index1, SCM index2) { if (scm_is_integer (index1) && scm_is_integer (index2)) { gint original_index = gtk_notebook_get_current_page (GTK_NOTEBOOK (Denemo.notebook)); gint num1 = scm_to_int (index1); gint num2 = scm_to_int (index2); gtk_notebook_set_current_page (GTK_NOTEBOOK (Denemo.notebook), num1); DenemoProject *p1 = Denemo.project; gtk_notebook_set_current_page (GTK_NOTEBOOK (Denemo.notebook), num2); DenemoProject *p2 = Denemo.project; //DenemoLilyControl *lc1 = p1->lilycontrol; there are papersize etc which i'm ignoring... //DenemoLilyControl *lc2 = p2->lilycontrol; gchar *compare = difference_of_directive_lists (p1->lilycontrol.directives, p2->lilycontrol.directives); if (!compare) compare = difference_of_directive_lists (p1->scoreheader.directives, p2->scoreheader.directives); if (!compare) compare = difference_of_directive_lists (p1->paper.directives, p2->paper.directives); #if 0 if (!compare) { gchar *text = _("Paper Directive: "); compare = difference_of_directive_list (p1->paper.directives, p2->paper.directives); if (compare) { text = strdup_printf ("%s %s", compare); g_free (compare); compare = text; } } #endif gtk_notebook_set_current_page (GTK_NOTEBOOK (Denemo.notebook), original_index); if (compare) { SCM ret; ret = scm_from_locale_string (compare); g_free (compare); return ret; } } return SCM_BOOL_F; } SCM scheme_wakeup (void) { while (gtk_events_pending ()) gtk_main_iteration (); return SCM_BOOL_T; } SCM scheme_difference_of_movements (SCM index1, SCM index2) { if (scm_is_integer (index1) && scm_is_integer (index2)) { gint original_index = gtk_notebook_get_current_page (GTK_NOTEBOOK (Denemo.notebook)); gint num1 = scm_to_int (index1); gint num2 = scm_to_int (index2); gtk_notebook_set_current_page (GTK_NOTEBOOK (Denemo.notebook), num1); DenemoMovement *mv1 = Denemo.project->movement; gtk_notebook_set_current_page (GTK_NOTEBOOK (Denemo.notebook), num2); DenemoMovement *mv2 = Denemo.project->movement; //DenemoLilyControl *lc1 = mv1->lilycontrol; there are papersize etc which i'm ignoring... //DenemoLilyControl *lc2 = mv2->lilycontrol; gchar *compare = difference_of_directive_lists (mv1->movementcontrol.directives, mv2->movementcontrol.directives); if (!compare) compare = difference_of_directive_lists (mv1->header.directives, mv2->header.directives); if (!compare) compare = difference_of_directive_lists (mv1->layout.directives, mv2->layout.directives); #if 0 if (!compare) { gchar *text = _("Paper Directive: "); compare = difference_of_directive_list (mv1->paper.directives, mv2->paper.directives); if (compare) { text = strdup_printf ("%s %s", compare); g_free (compare); compare = text; } } #endif gtk_notebook_set_current_page (GTK_NOTEBOOK (Denemo.notebook), original_index); if (compare) { SCM ret; ret = scm_from_locale_string (compare); g_free (compare); return ret; } } return SCM_BOOL_F; } SCM scheme_path_from_filename (SCM filepath) { SCM ret = SCM_BOOL_F; if (scm_is_string (filepath)) { char *temp = scm_to_locale_string (filepath); gchar *dirname = g_path_get_dirname (temp); free (temp); ret = scm_from_locale_string (dirname); g_free (dirname); } return ret; } SCM scheme_filename_from_path (SCM filepath) { SCM ret = SCM_BOOL_F; if (scm_is_string (filepath)) { char *temp = scm_to_locale_string (filepath); gchar *dirname = g_path_get_basename (temp); free (temp); ret = scm_from_locale_string (dirname); g_free (dirname); } return ret; } SCM scheme_file_exists (SCM filepath) { SCM ret = SCM_BOOL_F; if (scm_is_string (filepath)) { char *temp = scm_to_locale_string (filepath); return SCM_BOOL (g_file_test (temp, G_FILE_TEST_EXISTS)); } return ret; } static SCM scheme_choose_file_or_directory (SCM title, SCM startdir, SCM list, gboolean dir) { gchar *thetitle = g_strdup (_("Choose File")); gchar *thedir = get_project_dir (); GList *exts = NULL; gchar *filename; SCM ret = SCM_BOOL_F; if (scm_is_string (title)) { char *temp = scm_to_locale_string (title); thetitle = g_strdup (temp); free (temp); } if (scm_is_string (startdir)) { char *temp = scm_to_locale_string (startdir); g_free (thedir); thedir = g_strdup (temp); free (temp); } if (scm_is_list (list)) { gint length = scm_to_int (scm_length (list)); int i; for (i = 0; i < length; i++) { SCM glob = scm_list_ref (list, scm_from_int (i)); if (scm_is_string (glob)) { char *extension = scm_to_locale_string (glob); exts = g_list_append (exts, g_strdup (extension)); free (extension); } } } if(dir) filename = choose_directory (thetitle, thedir, exts); else filename = choose_file (thetitle, thedir, exts); g_free (thetitle); g_free (thedir); g_list_free_full (exts, g_free); if (filename) ret = scm_from_locale_string (filename); g_free (filename); return ret; } SCM scheme_choose_file (SCM title, SCM startdir, SCM list) { return scheme_choose_file_or_directory(title, startdir, list, FALSE); } SCM scheme_choose_directory (SCM title, SCM startdir, SCM list) { return scheme_choose_file_or_directory(title, startdir, list, TRUE); } SCM scheme_edit_graphics (SCM name, SCM newname) { SCM ret = SCM_BOOL_F; gchar *opened = NULL; gchar *thenewname = NULL; if (scm_is_string (newname)) thenewname = scm_to_locale_string (newname); if (scm_is_string (name)) { gchar *filename = scm_to_locale_string (name); opened = edit_graphics_file (filename, thenewname); free (filename); } else { opened = edit_graphics_file (NULL, thenewname); } if (opened) ret = scm_from_locale_string (opened); g_free (opened); if (thenewname) free (thenewname); return ret; } SCM scheme_open_source (SCM link) { SCM ret = SCM_BOOL_F; #ifndef USE_EVINCE g_debug ("This feature requires denemo to be built with evince"); #else if (scm_is_string (link)) { gchar *thestring = scm_to_locale_string (link); gchar *filename; #ifdef G_OS_WIN32 filename = thestring; (void) strtok (thestring + 2, ":"); //skip leading drive name on windows #else filename = strtok (thestring, ":"); //will not work if filename contains ':' characters. #endif if (filename) { gint x, y, page; gchar *xstr = strtok (NULL, ":"); gchar *ystr = strtok (NULL, ":"); gchar *pstr = strtok (NULL, ":"); x = xstr ? atoi (xstr) : 0; y = ystr ? atoi (ystr) : 0; page = pstr ? atoi (pstr) : 0; //check on file exists otherwise try Denemo.prefs.denemopath if(!Denemo.non_interactive) if (!g_file_test (filename, G_FILE_TEST_IS_REGULAR)) { gchar *base = Denemo.prefs.denemopath->str; gchar *found = try_to_find_file (base, filename); while (!found) { gchar *message = g_strdup_printf ("%s%s%s", _("Source File: " ), filename,_(" Not Found")); gchar *path = NULL; if (choose_option (message, _("Browse for this file's location"), _("Ignore it"))) path = choose_directory (_("Click Open when you have located the file"), Denemo.prefs.denemopath->str, NULL); if (path) found = try_to_find_file (path, filename); else break; } if (found) filename = found; else filename = NULL; } if (filename && open_source (filename, x, y, page)) ret = SCM_BOOL_T; } if (thestring) free (thestring); } #endif //USE_EVINCE return ret; } SCM scheme_open_source_file (SCM optional) { if (open_source_file ()) return SCM_BOOL_T; return SCM_BOOL_F; } SCM scheme_open_proofread_file (SCM optional) { if (open_proof_file ()) return SCM_BOOL_T; return SCM_BOOL_F; } #ifdef DISABLE_AUBIO #else SCM scheme_export_recorded_audio (SCM name) { gchar *filename = NULL; if (scm_is_string (name)) { filename = scm_to_locale_string (name); } return SCM_BOOL (export_recorded_audio (filename)); } SCM scheme_toggle_recording_audio (void) { toggle_recording_audio (); return SCM_BOOL( Denemo.project->audio_recording); } SCM scheme_recording_audio (void) { return SCM_BOOL( Denemo.project->audio_recording); } SCM scheme_open_source_audio_file (SCM name) { gchar *filename = NULL; if (scm_is_string (name)) { filename = scm_to_locale_string (name); } if ((filename?open_source_audio (filename):open_source_audio_file ()) && Denemo.project->movement->recording && Denemo.project->movement->recording->samplerate) { if (Denemo.project->movement->currentobject) set_lead_in (-((DenemoObject*)Denemo.project->movement->currentobject->data)->earliest_time); return scm_from_double (Denemo.project->movement->recording->nframes / (double) Denemo.project->movement->recording->samplerate); } return SCM_BOOL_F; } SCM scheme_close_source_audio (SCM optional) { return SCM_BOOL (close_source_audio ()); } SCM scheme_start_audio_play (SCM annotate) { if (Denemo.project->movement->recording) { start_audio_playing (scm_is_true (annotate)); return SCM_BOOL_T; } return SCM_BOOL_F; } SCM scheme_set_audio_lead_in (SCM seconds) { if (scm_is_real (seconds)) { gdouble secs = scm_to_double (seconds); return SCM_BOOL (set_lead_in (secs)); } return SCM_BOOL_F; } SCM scheme_stop_audio_play (SCM annotate) { if (audio_is_playing ()) { stop_audio_playing (); return SCM_BOOL_T; } return SCM_BOOL_F; } SCM scheme_next_audio_timing (SCM optional) { if (Denemo.project->movement->recording) { gdouble timing = get_audio_timing (); if (timing > 0.0) return scm_from_double (timing); } return SCM_BOOL_F; } #endif SCM scheme_audio_is_playing (void) { if (is_playing ()) return scm_from_double (Denemo.project->movement->playhead); return SCM_BOOL (/*audio_*/is_playing ()); //the audio_is_playing() is AUBIO only, for playing source audio. So the name of this command d-AudioIsPlaying is now less than ideal. } SCM scheme_take_snapshot (SCM optional) { return SCM_BOOL (take_snapshot ()); } SCM scheme_increase_guard (SCM optional) { if (Denemo.project->movement->undo_guard++) return SCM_BOOL_F; return SCM_BOOL_T; } SCM scheme_decrease_guard (SCM optional) { if (Denemo.project->movement->undo_guard > 0) return SCM_BOOL (!--Denemo.project->movement->undo_guard); Denemo.project->movement->undo_guard = 0; return SCM_BOOL_T; } //From a script undo must undo only the modifications to the start of the //script, and push another STAGE_END for the end of the actions that it will do //after the invocation of undo. This function overrides the built-in undo called //directly by the user. SCM scheme_undo (SCM optional) { stage_undo (Denemo.project->movement, ACTION_STAGE_START); undowrapper (NULL, NULL); stage_undo (Denemo.project->movement, ACTION_STAGE_END); return SCM_BOOL_T; } //Break the script up for undo purposes SCM scheme_stage_for_undo (SCM optional) { stage_undo (Denemo.project->movement, ACTION_STAGE_START); stage_undo (Denemo.project->movement, ACTION_STAGE_END); return SCM_BOOL_T; } SCM scheme_get_last_change (SCM optional) { SCM ret = SCM_BOOL_F; gchar *last = get_last_change (Denemo.project->movement); if (last) ret = scm_from_locale_string (last); g_free (last); return ret; } SCM scheme_new_window (SCM optional) { stage_undo (Denemo.project->movement, ACTION_STAGE_START); //gint current = Denemo.project->scorearea->allocation.width; newview (NULL, NULL); // Denemo.project->scorearea->allocation.width = current; stage_undo (Denemo.project->movement, ACTION_STAGE_END); return SCM_BOOL_T; } SCM scheme_zoom (SCM factor) { if (scm_is_real (factor)) Denemo.project->movement->zoom = scm_to_double (factor); else if (scm_is_string (factor)) { char *name; name = scm_to_locale_string (factor); if (name) { Denemo.project->movement->zoom = atof (name); free (name); } } else { return scm_from_double (Denemo.project->movement->zoom); } scorearea_configure_event (Denemo.scorearea, NULL); if (Denemo.project->movement->zoom > 0.01) { return scm_from_int (Denemo.project->movement->zoom); } Denemo.project->movement->zoom = 1.0; return SCM_BOOL_F; } SCM scheme_movement_tempo (SCM bpm) { DenemoMovement *si = Denemo.project->movement; gint tempo = 0; if (scm_is_integer (bpm)) { tempo = scm_to_int (bpm); } else if (scm_is_real (bpm)) { double val = scm_to_double (bpm); tempo = (int) (val + 0.5); } else if (scm_is_string (bpm)) { char *name; name = scm_to_locale_string (bpm); if (name) { tempo = atoi (name); free (name); } } else if (scm_is_bool (bpm)) tempo = movement_tempo_from_user (); if (tempo) set_movement_tempo (tempo); return scm_from_int (si->tempo); } SCM scheme_master_volume (SCM factor) { DenemoMovement *si = Denemo.project->movement; if (scm_is_real (factor)) si->master_volume = scm_to_double (factor); if (scm_is_string (factor)) { char *name; name = scm_to_locale_string (factor); if (name) { si->master_volume = atof (name); free (name); } } if (si->master_volume < 0.0) si->master_volume = 1.0; return scm_from_double (si->master_volume); } SCM scheme_staff_master_volume (SCM level) { DenemoStaff *thestaff = (DenemoStaff *) Denemo.project->movement->currentstaff->data; if (scm_is_real (level)) { gdouble master_volume = scm_to_double (level); thestaff->volume = (gint) (master_volume * 127); if (thestaff->volume > 127) thestaff->volume = 127; if (thestaff->volume < 0) thestaff->volume = 0; return scm_from_double (thestaff->volume / 127.0); } if (scm_is_false (level)) { thestaff->mute = TRUE; return scm_from_double (-thestaff->volume / 127.0); } if (scm_is_eq (level, SCM_UNDEFINED)) return thestaff->mute ? scm_from_double (-thestaff->volume / 127.0) : scm_from_double (thestaff->volume / 127.0); thestaff->mute = FALSE; return scm_from_double (thestaff->volume / 127.0); } SCM scheme_get_midi_tuning (void) { gchar *cents = get_cents_string (); SCM ret = scm_from_locale_string (cents); g_free (cents); return ret; } SCM scheme_get_sharpest (void) { gchar *name = get_sharpest (); SCM ret = scm_from_locale_string (name); g_free (name); return ret; } SCM scheme_get_flattest (void) { gchar *name = get_flattest (); SCM ret = scm_from_locale_string (name); g_free (name); return ret; } SCM scheme_get_temperament (void) { gchar *name = get_temperament_name (); SCM ret = scm_from_locale_string (name); g_free (name); return ret; } static SCM ignore_handler (gchar * data SCM_UNUSED, SCM tag, SCM throw_args SCM_UNUSED) { // g_warning("ignoring throw"); return SCM_BOOL_F; } SCM scheme_set_enharmonic_position (SCM position) { if (scm_is_integer (position)) { gint pos = scm_to_int (position); set_enharmonic_position (pos); return SCM_BOOL_T; } return SCM_BOOL_F; } SCM scheme_rewind_midi (SCM start) { DenemoProject *gui = Denemo.project; double thetime = 0.0; SCM scm = SCM_BOOL_T; gint err; if ((gui->movement->smf == NULL) || (gui->movement->smfsync != gui->movement->changecount)) generate_midi (); if (scm_is_real (start)) thetime = scm_to_double (start); if (thetime > 0.0) { err = smf_seek_to_seconds (gui->movement->smf, thetime); if (err) scm = SCM_BOOL_F; } else smf_rewind (gui->movement->smf); return scm; } //gets a list of midi-key numbers for note-on events whose time is within interval of the first note-on event after the current si->smf position //leaves the si->smf position on that note-on event. SCM scheme_next_midi_notes (SCM interval) { SCM scm = scm_list_n (SCM_UNDEFINED); DenemoMovement *si = Denemo.project->movement; if (scm_is_real (interval)) { double margin = scm_to_double (interval); double start = -1.0; //unset smf_event_t *event = si->smf ? smf_peek_next_event (si->smf) : NULL; if (event) { while ((event = smf_peek_next_event (si->smf))) { gint key; if ((key = noteon_key (event))) { if (start < 0.0) start = event->time_seconds; if ((event->time_seconds - start) < margin) { event = smf_get_next_event (si->smf); scm = scm_cons (scm_from_int (key), scm); } else { break; } } else { event = smf_get_next_event (si->smf); } } } scm = scm_cons (scm, scm_from_double (start)); return scm; } return SCM_BOOL_F; } //time at start of current object if smf up to date SCM scheme_get_midi_on_time (void) { GList *curObj = Denemo.project->movement->currentobject; while (curObj && (((DenemoObject *) curObj->data)->durinticks == 0)) curObj = curObj->next; //find first note/rest or duration-full object after the cursor if (curObj && (Denemo.project->movement->smfsync == Denemo.project->movement->changecount)) return scm_from_double (((DenemoObject *) curObj->data)->earliest_time); return scm_from_double (((DenemoMeasure*)Denemo.project->movement->currentmeasure->data)->earliest_time); } //time at end of first note/rest on/after current object if smf up to date SCM scheme_get_midi_off_time (void) { if (!(Denemo.project->movement->currentobject)) return SCM_BOOL_F; GList *curObj = Denemo.project->movement->currentobject; while (curObj && (((DenemoObject *) curObj->data)->durinticks == 0)) curObj = curObj->prev; //find last note/rest or duration-full object before the cursor if (curObj && (Denemo.project->movement->smfsync == Denemo.project->movement->changecount)) return scm_from_double (((DenemoObject *) curObj->data)->latest_time); return SCM_BOOL_F; } //time at right most measure visible on screen if smf up to date - rightmost_time is set by drawing SCM scheme_get_rightmost_time (void) { DenemoMovement *si = Denemo.project->movement; if (si->smfsync != si->changecount) { exportmidi (NULL, si); gint right = si->rightmeasurenum; GList *g = g_list_nth (((DenemoStaff*)si->currentstaff->data)->themeasures, right - 1); if (g) { DenemoMeasure *rMeasure = g->data; g_print ("Taking earliest time of last measure %0.2f\n", rMeasure->earliest_time); return scm_from_double (rMeasure->earliest_time);//well really it should have measure duration added... } } else return scm_from_double (si->rightmost_time);//rMeasure->earliest_time); return SCM_BOOL_F; } SCM scheme_midi_in_listening (void) { midi_in_adjust (GDK_SHIFT_MASK); return SCM_BOOL_T; } SCM scheme_toggle_midi_in_listening (void) { if (Denemo.keyboard_state == GDK_SHIFT_MASK) midi_in_adjust (0); else midi_in_adjust (GDK_SHIFT_MASK); return scm_from_bool (Denemo.keyboard_state == GDK_SHIFT_MASK); } SCM scheme_midi_in_checking (void) { midi_in_adjust (GDK_CONTROL_MASK); return scm_from_bool (Denemo.keyboard_state == GDK_CONTROL_MASK); } SCM scheme_midi_in_append_edit (void) { midi_in_adjust (0); return SCM_BOOL_T; } SCM scheme_restart_play (void) { restart_play (); return SCM_BOOL_T; } SCM scheme_staff_to_play (SCM num) { if (scm_is_integer (num)) { gint staffnum = scm_to_int (num); if (staffnum >= 0 && staffnum <= g_list_length (Denemo.project->movement->thescore)) { Denemo.project->movement->stafftoplay = staffnum; exportmidi (NULL, Denemo.project->movement); return scm_from_int (staffnum); } } Denemo.project->movement->stafftoplay = 0; exportmidi (NULL, Denemo.project->movement); return SCM_BOOL_F; } static double convert_and_adjust (SCM time) { return scm_to_double (time) * get_playback_speed (); } SCM scheme_set_playback_interval (SCM start, SCM end) { stop_midi_playback (NULL, NULL); if (scm_is_real (start) && scm_is_real (end)) { Denemo.project->movement->start_time = convert_and_adjust (start); Denemo.project->movement->end_time = convert_and_adjust (end); fix_start_end_ordering (); return SCM_BOOL_T; } if (scm_is_real (start)) { Denemo.project->movement->start_time = convert_and_adjust (start); fix_start_end_ordering (); return SCM_BOOL_T; } if (scm_is_real (end)) { Denemo.project->movement->end_time = convert_and_adjust (end); fix_start_end_ordering (); return SCM_BOOL_T; } if (scm_is_string (start) && scm_is_string (end)) { char *name; name = scm_to_locale_string (start); if (name) { Denemo.project->movement->start_time = atof (name); free (name); } name = scm_to_locale_string (end); if (name) { Denemo.project->movement->end_time = atof (name); free (name); } fix_start_end_ordering (); return SCM_BOOL_T; } if (scm_is_string (start)) { char *name; name = scm_to_locale_string (start); if (name) { Denemo.project->movement->start_time = atof (name); free (name); } fix_start_end_ordering (); return SCM_BOOL_T; } if (scm_is_string (end)) { char *name; name = scm_to_locale_string (end); if (name) { Denemo.project->movement->end_time = atof (name); free (name); } fix_start_end_ordering (); return SCM_BOOL_T; } return SCM_BOOL_F; } SCM scheme_adjust_playback_start (SCM adj) { SCM ret = SCM_BOOL_F; if (scm_is_real (adj)) { stop_midi_playback (NULL, NULL); Denemo.project->movement->start_time += convert_and_adjust (adj); if (Denemo.project->movement->start_time < 0.0) Denemo.project->movement->start_time = 0.0; else ret = scm_from_double (Denemo.project->movement->start_time); } fix_start_end_ordering (); return ret; } SCM scheme_adjust_playback_end (SCM adj) { SCM ret = SCM_BOOL_F; if (scm_is_real (adj)) { stop_midi_playback (NULL, NULL); if (Denemo.project->movement->end_time >= 0) Denemo.project->movement->end_time += convert_and_adjust (adj); ret = scm_from_double (Denemo.project->movement->end_time); } fix_start_end_ordering (); return ret; } SCM scheme_get_help (SCM command) { char *name = NULL; if (scm_is_string (command)) name = scm_to_locale_string (command); if (name == NULL) { return SCM_BOOL_F; } gint idx = lookup_command_from_name (Denemo.map, name); if (name) free (name); if (idx < 0) { #if 0 SCM help = scm_c_eval_string (g_strconcat ("Help-d-", name)); return help; #else return SCM_BOOL_F; #endif } return scm_from_locale_string ((gchar *) lookup_tooltip_from_idx (Denemo.map, idx)); } SCM scheme_email_help (SCM text) {gchar *page; if (scm_is_string (text)) { page = scm_to_locale_string (text); email_help (page); return SCM_BOOL_T; } return SCM_BOOL_F; } SCM scheme_get_lily_version (SCM optional) { gchar *version = get_lily_version_string (); return scm_from_locale_string (version); } SCM scheme_check_lily_version (SCM check_version) { char *version; if (scm_is_string (check_version)) { version = scm_to_locale_string (check_version); } else { return SCM_BOOL_F; } gint result = check_lily_version (version); if (version) free (version); if (result > 0) { return SCM_BOOL_T; } else { return SCM_BOOL_F; } } SCM scheme_get_id (SCM command) { char *name; if (scm_is_string (command)) { gint id; name = scm_to_locale_string (command); id = lookup_command_from_name (Denemo.map, name); if (name) free (name); if (id != -1) { return scm_from_int (id); } } return SCM_BOOL_F; } SCM scheme_add_keybinding (SCM command, SCM binding) { char *shortcut; char *name; gint id; gint old_id = -1; if (scm_is_string (binding)) { shortcut = scm_to_locale_string (binding); if (scm_is_string (command)) { name = scm_to_locale_string (command); old_id = add_keybinding_for_name (name, shortcut); } else if (scm_is_integer (command)) { id = scm_to_int (command); if (id >= 0) old_id = add_keybinding_for_command (id, shortcut); } if (shortcut) free (shortcut); if (name) free (name); } if (old_id >= 0) { return scm_from_int (old_id); } else { return SCM_BOOL_F; } } SCM scheme_get_label (SCM command) { char *name; if (scm_is_string (command)) { name = scm_to_locale_string (command); } else { return SCM_BOOL_F; } if (name == NULL) { return SCM_BOOL_F; } gint idx = lookup_command_from_name (Denemo.map, name); if (name) free (name); if (idx < 0) { return SCM_BOOL_F; } return scm_from_locale_string ((gchar *) lookup_label_from_idx (Denemo.map, idx)); } SCM scheme_get_command_script (SCM command) { char *name; if (scm_is_string (command)) { name = scm_to_locale_string (command); } else { return SCM_BOOL_F; } if (name == NULL) { return SCM_BOOL_F; } gint idx = lookup_command_from_name (Denemo.map, name); if (name) free (name); if (idx < 0) { return SCM_BOOL_F; } return scm_from_locale_string ((gchar *) get_scheme_from_idx (idx)); } SCM scheme_get_menu_position (SCM command) { char *name; SCM ret; gchar *menuposition = NULL; if (scm_is_string (command)) { name = scm_to_locale_string (command); } else { return SCM_BOOL_F; } if (name == NULL) { return SCM_BOOL_F; } gint idx = lookup_command_from_name (Denemo.map, name); command_row *row = NULL; keymap_get_command_row (Denemo.map, &row, idx); if (name) free (name); if ((row==NULL) || (idx < 0)) { return SCM_BOOL_F; } menuposition = get_menu_position (row->menupath); if (menuposition && *menuposition) { ret = scm_from_locale_string (menuposition); g_free (menuposition); } return ret; } SCM scheme_get_menu_path (SCM command) { char *name; if (scm_is_string (command)) { name = scm_to_locale_string (command); } else { return SCM_BOOL_F; } if (name == NULL) { return SCM_BOOL_F; } gint idx = lookup_command_from_name (Denemo.map, name); command_row *row = NULL; keymap_get_command_row (Denemo.map, &row, idx); if (name) free (name); if ((row==NULL) || (idx < 0)) { return SCM_BOOL_F; } if (row->menupath == NULL) { return SCM_BOOL_F; } return scm_from_locale_string (row->menupath); } SCM scheme_get_verse (SCM number) { gchar *text = NULL; DenemoProject *gui = Denemo.project; if (scm_is_integer (number)) { text = get_lyrics_for_verse_num (scm_to_int (number)); } else { DenemoStaff *staff = (DenemoStaff *) gui->movement->currentstaff->data; text = get_lyrics_for_current_verse (staff); } if (text) { SCM scm = scm_from_locale_string (text); //wrong!! g_free(text); return scm; } return SCM_BOOL_F; } SCM scheme_get_verse_number (SCM number) { DenemoProject *gui = Denemo.project; if (scm_is_integer (number)) { guint num = scm_to_int (number); if (verse_set_current ((DenemoStaff *) gui->movement->currentstaff->data, num)) return SCM_BOOL_T; } else { gint num = verse_get_current ((DenemoStaff *) gui->movement->currentstaff->data); if (num>-1) return scm_from_int (num); } return SCM_BOOL_F; } SCM scheme_syllable_count (void) { if (Denemo.project->movement->currentobject) return scm_from_int (syllable_count ()); return SCM_BOOL_F; } SCM scheme_typeset_lyrics_for_staff (SCM on) { DenemoStaff *staff = (DenemoStaff *) Denemo.project->movement->currentstaff->data; if (scm_is_bool (on)) { signal_structural_change (Denemo.project); staff->hide_lyrics = !scm_is_true (on); score_status (Denemo.project, TRUE); } return scm_from_bool (!staff->hide_lyrics); } SCM scheme_synchronize_lyric_cursor (SCM val) { gint offset = 0; if (scm_is_integer (val)) offset = scm_to_int (val); return SCM_BOOL (synchronize_lyric_cursor (offset)); } SCM scheme_insert_text_in_verse (SCM text) { if (scm_is_string (text)) { char *thetext; thetext = scm_to_locale_string (text); return SCM_BOOL (insert_text_in_verse (thetext)); } return SCM_BOOL_F; } SCM scheme_put_verse (SCM verse) { DenemoProject *gui = Denemo.project; DenemoStaff *staff = (DenemoStaff *) gui->movement->currentstaff->data; if (scm_is_string (verse)) { char *text; text = scm_to_locale_string (verse); gboolean ret = put_lyrics_for_current_verse (staff, text); if (text) free (text); return SCM_BOOL (ret); } return SCM_BOOL_F; } SCM scheme_append_to_verse (SCM verse) { DenemoProject *gui = Denemo.project; DenemoStaff *staff = (DenemoStaff *) gui->movement->currentstaff->data; if (scm_is_string (verse)) { char *text; text = scm_to_locale_string (verse); gboolean ret = append_lyrics_for_current_verse (staff, text); if (text) free (text); return SCM_BOOL (ret); } return SCM_BOOL_F; } /* write MIDI/Audio filter status */ SCM scheme_input_filter_names (SCM filtername) { char *name = NULL; if (scm_is_string (filtername)) { name = scm_to_locale_string (filtername); if (name) { g_string_printf (Denemo.input_filters, "MIDI Input: %s", name); gtk_widget_show (Denemo.input_label); write_input_status (); free (name); return SCM_BOOL_T; } } else { gtk_widget_hide (Denemo.input_label); } return SCM_BOOL_F; } /* write a status label on bottom right of window*/ SCM scheme_write_status (SCM filtername) { char *name = NULL; if (scm_is_string (filtername)) { name = scm_to_locale_string (filtername); if (name && Denemo.input_filters) { g_string_assign (Denemo.input_filters, name); gtk_widget_show (Denemo.input_label); write_input_status (); free (name); return SCM_BOOL_T; } } else { gtk_widget_hide (Denemo.input_label); } return SCM_BOOL_F; } SCM scheme_is_interactive (void) { return SCM_BOOL (!Denemo.non_interactive); } SCM scheme_goto_position (SCM movement, SCM staff, SCM measure, SCM object) { gint movementnum, staffnum, measurenum, objectnum; if (scm_is_integer (movement)) movementnum = scm_to_int (movement); else movementnum = g_list_index (Denemo.project->movements, Denemo.project->movement) + 1; if (scm_is_integer (staff)) staffnum = scm_to_int (staff); else staffnum = Denemo.project->movement->currentstaffnum; if (scm_is_integer (measure)) measurenum = scm_to_int (measure); else measurenum = Denemo.project->movement->currentmeasurenum; if (scm_is_integer (object)) objectnum = scm_to_int (object); else objectnum = 1 + Denemo.project->movement->cursor_x; gint origmvt = g_list_index (Denemo.project->movements, Denemo.project->movement) + 1, origstaff = Denemo.project->movement->currentstaffnum, origmeas = Denemo.project->movement->currentmeasurenum, origpos = 1 + Denemo.project->movement->cursor_x; goto_movement_staff_obj (NULL, movementnum, staffnum, measurenum, objectnum, 0); if ((movementnum == g_list_index (Denemo.project->movements, Denemo.project->movement) + 1) && (staffnum == Denemo.project->movement->currentstaffnum) && (measurenum == Denemo.project->movement->currentmeasurenum) && (objectnum == 1 + Denemo.project->movement->cursor_x)) return SCM_BOOL_T; else goto_movement_staff_obj (NULL, origmvt, origstaff, origmeas, origpos, 0); return SCM_BOOL_F; } SCM scheme_shift_cursor (SCM value) { if (!scm_is_integer (value)) return SCM_BOOL_F; gint shift = scm_to_int (value); Denemo.project->movement->cursor_y += shift; Denemo.project->movement->staffletter_y = offsettonumber (Denemo.project->movement->staffletter_y + shift); return SCM_BOOL_T; } SCM scheme_mid_c_offsettoname (gint offset) { gchar *notename = g_strdup_printf ("%c", mid_c_offsettoname (offset)); SCM scm = scm_from_locale_string (notename); g_free (notename); return scm; } SCM scheme_get_horizontal_position (void) { return scm_from_int (1 + Denemo.project->movement->cursor_x); } SCM scheme_set_object_display_width (SCM value) { if (!scm_is_integer (value)) return SCM_BOOL_F; if (Denemo.project->movement->currentobject) { DenemoObject *obj = Denemo.project->movement->currentobject->data; gint minpixels = scm_to_int (value); obj->minpixelsalloted = minpixels; return SCM_BOOL_T; } return SCM_BOOL_F; } SCM scheme_toggle_sketch (void) { Denemo.project->movement->sketch = !Denemo.project->movement->sketch; signal_structural_change (Denemo.project); return Denemo.project->movement->sketch? SCM_BOOL_T:SCM_BOOL_F; } SCM scheme_get_movement (void) { gint num = g_list_index (Denemo.project->movements, Denemo.project->movement) + 1; return scm_from_int (num); } SCM scheme_get_staff (void) { gint num = Denemo.project->movement->currentstaffnum; return scm_from_int (num); } SCM scheme_staff_hidden (SCM set) { DenemoProject *gui = Denemo.project; DenemoStaff *staff = (DenemoStaff *) gui->movement->currentstaff->data; if (scm_is_bool (set)) staff->hidden = scm_is_true (set); return SCM_BOOL (staff->hidden); } SCM scheme_get_voice_identifier (void) { gint snum = Denemo.project->movement->currentstaffnum; gint mnum = g_list_index (Denemo.project->movements, Denemo.project->movement) + 1; GString *voice_ident = g_string_new (""); GString *name = g_string_new (""); g_string_printf (name, "Mvmnt%dVoice%d", mnum, snum); set_lily_name (name, voice_ident); SCM ret = scm_from_locale_string (voice_ident->str); g_string_free (name, TRUE); g_string_free (voice_ident, TRUE); return ret; } SCM scheme_roman_numeral (SCM number) { SCM ret = SCM_BOOL_F; if (scm_is_string (number)) { GString *to, *from; gchar *input = scm_to_locale_string (number); from = g_string_new (input); to = g_string_new(""); set_lily_name (from, to); g_string_free (from, TRUE); ret = scm_from_locale_string (to->str); g_string_free (to, TRUE); if (input) free (input); } return ret; } SCM scheme_get_measure (void) { return scheme_get_measure_number (); } SCM scheme_get_cursor_note (SCM optional) { DenemoProject *gui = Denemo.project; return scheme_mid_c_offsettoname (gui->movement->cursor_y); } SCM scheme_get_cursor_note_with_octave (SCM optional) { DenemoProject *gui = Denemo.project; return scm_from_locale_string (mid_c_offsettolily (gui->movement->cursor_y, 0)); } SCM scheme_set_prefs (SCM xml) { if (scm_is_string (xml)) { char *xmlprefs; xmlprefs = scm_to_locale_string (xml); gint fail = readxmlprefsString (xmlprefs); if (xmlprefs) free (xmlprefs); return SCM_BOOL (!fail); } return SCM_BOOL (FALSE); } SCM scheme_get_boolean_pref (SCM pref) { gchar *prefname = NULL; gboolean val; if (scm_is_string (pref)) { prefname = scm_to_locale_string (pref); val = get_bool_pref (prefname); free (prefname); return SCM_BOOL (val); } return SCM_BOOL_F; } SCM scheme_get_int_pref (SCM pref) { gchar *prefname = NULL; gint val; if (scm_is_string (pref)) { prefname = scm_to_locale_string (pref); val = get_int_pref (prefname); free (prefname); return scm_from_int (val); } return SCM_BOOL_F; } SCM scheme_get_string_pref (SCM pref) { gchar *prefname = NULL; gchar *val; if (scm_is_string (pref)) { prefname = scm_to_locale_string (pref); val = get_string_pref (prefname); free (prefname); if (val) return scm_from_locale_string (val); } return SCM_BOOL_F; } SCM scheme_attach_quit_callback (SCM callback) { DenemoProject *gui = Denemo.project; if (scm_is_string (callback)) { char *scheme; scheme = scm_to_locale_string (callback); gui->callbacks = g_list_prepend (gui->callbacks, scheme); if (scheme) free (scheme); } return SCM_BOOL (TRUE); } SCM scheme_detach_quit_callback (void) { DenemoProject *gui = Denemo.project; if (gui->callbacks) { g_free (gui->callbacks->data); gui->callbacks = g_list_delete_link (gui->callbacks, gui->callbacks); return SCM_BOOL (TRUE); } else g_warning ("No callback registered"); return SCM_BOOL (FALSE); } SCM scheme_get_input_source (void) { return scm_from_int (Denemo.project->input_source); } SCM scheme_chordize (SCM setting) { DenemoProject *gui = Denemo.project; DenemoObject *curObj; chord *thechord; note *thenote; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object) || !(thechord->notes) || !(thenote = (note *) thechord->notes->data)) return SCM_BOOL (FALSE); gboolean old = thechord->chordize; thechord->chordize = scm_is_true (setting); if (old != thechord->chordize) score_status (Denemo.project, TRUE); return SCM_BOOL (TRUE); } SCM scheme_get_note_name (SCM optional) { //char *str=NULL; //if(scm_is_string(optional)){ //str = scm_to_locale_stringn(optional, &length); // } DenemoObject *curObj; chord *thechord; note *thenote; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object) || !(thechord->notes) || !(thenote = (note *) thechord->notes->data)) return SCM_BOOL (FALSE); else { return scheme_mid_c_offsettoname (thenote->mid_c_offset); } } SCM scheme_get_note_names_from_user (SCM num, SCM initial, SCM message) { SCM ret = SCM_BOOL_F; gint number = 1; gchar *text = NULL; gchar *init = NULL; if (scm_is_integer(num)) number = scm_to_int (num); if (number != 1) number = 2; if (scm_is_string (initial)) init = scm_to_locale_string (initial); if (scm_is_string (message)) text = scm_to_locale_string (message); gchar *note = notes_choice_dialog (number, init, text); if (note) ret = scm_from_locale_string (note); g_free (text); g_free (init); g_free (note); return ret; } SCM scheme_get_multiline_user_input (SCM title, SCM instruction, SCM initial) { SCM ret = SCM_BOOL_F; gchar *tl = _("Text Input"); gchar *ins = _("Give Text"); gchar *init = ""; if (scm_is_string (title)) tl = scm_to_locale_string (title); if (scm_is_string (instruction)) ins = scm_to_locale_string (instruction); if (scm_is_string (initial)) init = scm_to_locale_string (initial); gchar *val = get_multiline_input (tl, ins, init); if (val) ret = scm_from_locale_string (val); g_free (val); return ret; } SCM scheme_get_lilypond_syntax_from_user (SCM tit, SCM ins, SCM prior, SCM post, SCM initial) { SCM ret = SCM_BOOL_F; #ifndef USE_EVINCE g_debug ("This feature requires denemo to be built with evince"); #else gchar *title = _("LilyPond Syntax"); gchar *prior_context = "\\score {<<"; gchar *post_context = ">>}"; gchar *instruction = _("Give LilyPond Syntax"); gchar *initial_markup = ""; if (scm_is_string (tit)) title = scm_to_locale_string (tit); if (scm_is_string (ins)) instruction = scm_to_locale_string (ins); if (scm_is_string (prior)) prior_context = scm_to_locale_string (prior); if (scm_is_string (post)) post_context = scm_to_locale_string (post); if (scm_is_string (initial)) initial_markup = scm_to_locale_string (initial); gchar *val = get_lilypond_syntax_from_user (title, instruction, prior_context, post_context, initial_markup); if (val) ret = scm_from_locale_string (val); g_free (val); #endif return ret; } //Insert rests to the value of the timesig and return the number of rests inserted. SCM scheme_put_whole_measure_rests (void) { DenemoProject *gui = Denemo.project; SCM scm; if (!Denemo.project || !(Denemo.project->movement)) return scm_from_int (0); else { gint numerator = ((DenemoMeasure *) gui->movement->currentmeasure->data)->timesig->time1; // staff->timesig.time1; gint denominator = ((DenemoMeasure *) gui->movement->currentmeasure->data)->timesig->time2; //staff->timesig.time2; gboolean dot = TRUE; if (numerator % 3) dot = FALSE; else numerator = 2 * numerator / 3; gint length = (numerator * 4) / denominator; gchar *str = NULL; scm = scm_from_int (1); switch (length) { case 1: // e.g. 2/8 timesig str = g_strdup_printf ("(d-InsertRest2)(d-MoveCursorLeft)%s", dot ? "(d-AddDot)" : ""); break; case 2: str = g_strdup_printf ("(d-InsertRest1)(d-MoveCursorLeft)%s", dot ? "(d-AddDot)" : ""); break; case 3: // e.g. 9/8 timesig str = g_strdup_printf ("(d-InsertRest0)(d-InsertRest3)(d-MoveCursorLeft)(d-MoveCursorLeft)"); scm = scm_from_int (2); break; case 4: str = g_strdup_printf ("(d-InsertRest0)(d-MoveCursorLeft)%s", dot ? "(d-AddDot)" : ""); break; case 8: str = g_strdup_printf ("(d-InsertRest0)(d-InsertRest0)(d-MoveCursorLeft)%s", dot ? "(d-AddDot)" : ""); scm = scm_from_int (2); break; default: g_warning ("Not implemented %d %s", length, dot ? "dotted" : ""); scm = scm_from_int (0); break; } if (str) { call_out_to_guile (str); } g_free (str); return scm; } } SCM scheme_get_dots (void) { DenemoObject *curObj; chord *thechord; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object)) return SCM_BOOL_F; return scm_from_int (thechord->numdots); } SCM scheme_get_note_base_duration (void) { DenemoObject *curObj; chord *thechord; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object)) return SCM_BOOL_F; return scm_from_int (thechord->baseduration); } SCM scheme_get_note_duration (void) { DenemoObject *curObj; chord *thechord; gint duration; gint numdots = 0; gchar *str; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object)) return SCM_BOOL_F; if (thechord->baseduration >= 0) { duration = 1 << thechord->baseduration; str = g_strdup_printf ("%d", duration); if (thechord->numdots) { gchar *tmp = NULL; while (numdots++ < thechord->numdots) { tmp = g_strdup_printf ("%s" "%c", str, '.'); g_free (str); str = tmp; } } SCM scm = scm_from_locale_string (str); g_free (str); return scm; } return SCM_BOOL_F; } SCM scheme_set_duration_in_ticks (SCM duration) { DenemoObject *curObj; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data)) return SCM_BOOL_F; gint thedur = -1; //unset if (scm_is_integer (duration)) { thedur = scm_to_int (duration); } if (thedur >= 0) curObj->basic_durinticks = curObj->durinticks = thedur; if (curObj->type == CHORD) { chord *thechord = (chord *) curObj->object; if (thedur >= 0) { if ((thechord->baseduration <= 7) && (thechord->baseduration > 1)) //SWING or other cusstom duration being set - not available for wholenotes thechord->baseduration *= -1; if (thechord->baseduration == 0) // a wholenote being used for higher duration notes, it means you cannot give a custom duration to a wholenote. thechord->baseduration = -thedur;//for breve etc we hide the actual ticks here = -1536 for wholemeasure rest in 4/4 if (thechord->is_grace) thechord->is_grace |= DURATION_SET; } else { if (thechord->is_grace) thechord->is_grace &= ~DURATION_SET; gint curdur = thechord->baseduration; if ((curdur >= -7) && (curdur < 0)) { curdur *= -1; //unset the swing on this note changedur (curObj, curdur, thechord->numdots);//give it the default number of ticks } } } objnode *prev = Denemo.project->movement->currentobject->prev; DenemoObject *prevObj = prev ? (DenemoObject *) prev->data : NULL; gint starttick = (prevObj ? prevObj->starttickofnextnote : 0); curObj->starttickofnextnote = starttick + ((thedur < 0)? curObj->durinticks:thedur); return SCM_BOOL_T; } SCM scheme_get_recorded_midi_tempo (SCM index) { SCM scm = scm_list_n (SCM_UNDEFINED); if (scm_is_integer (index)) { gint idx = scm_to_int (index); smf_tempo_t *tempo = get_recorded_midi_tempo (idx); if (tempo) { scm = scm_cons (scm_from_double (tempo->microseconds_per_quarter_note / 1000000.0), scm); scm = scm_cons (scm_from_int (tempo->denominator), scm); scm = scm_cons (scm_from_int (tempo->numerator), scm); scm = scm_cons (scm_from_int (tempo->time_seconds), scm); return scm; } } return SCM_BOOL_F; } SCM scheme_get_imported_midi_track (SCM index) { if (scm_is_integer (index)) { gint idx = scm_to_int (index); if (get_imported_midi_track (idx)) return SCM_BOOL_F; } return SCM_BOOL_F; } SCM scheme_delete_imported_midi (void) { return SCM_BOOL (delete_imported_midi ()); } SCM scheme_get_current_midi_track (void) { gint track = get_current_midi_track (); if (track) return scm_from_int (track); return SCM_BOOL_F; } SCM scheme_get_imported_midi_tracks (void) { gint num = get_imported_midi_tracks (); if (num < 1) return SCM_BOOL_F; else return scm_from_int (num); } SCM scheme_get_recorded_midi_duration (void) { gdouble duration = get_recorded_midi_duration (); g_debug ("Duration returned %f so %d\n", duration, duration > 0.0); if (duration > 0.0) return scm_from_double (duration); return SCM_BOOL_F; } SCM scheme_get_time_at_cursor (void) { DenemoMovement *si = Denemo.project->movement; if (si->smfsync != si->changecount) exportmidi (NULL, si); return scm_from_double (get_time_at_cursor ()); } SCM scheme_movement_duration (void) { DenemoMovement *si = Denemo.project->movement; if (si->smfsync != si->changecount) exportmidi (NULL, si); return scm_from_double (smf_get_length_seconds (si->smf)); } SCM scheme_get_duration_in_ticks (void) { DenemoObject *curObj; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data)) return SCM_BOOL (FALSE); return scm_from_int (curObj->durinticks); } SCM scheme_get_base_duration_in_ticks (void) { DenemoObject *curObj; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data)) return SCM_BOOL (FALSE); if (curObj->type == CHORD) return scm_from_int (((chord *) curObj->object)->baseduration >= 0 ? /* (* (expt 2 (- 8 number)) 6) */ (int) pow (2.0, (8.0 - ((chord *) curObj->object)->baseduration)) * 6 : ((chord *) curObj->object)->baseduration);//this should just return basic_durinticks return SCM_BOOL (FALSE); } SCM scheme_get_end_tick (void) { DenemoObject *curObj; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data)) return SCM_BOOL (FALSE); return scm_from_int (curObj->starttickofnextnote); } SCM scheme_get_start_tick (void) { DenemoObject *curObj; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data)) return SCM_BOOL (FALSE); return scm_from_int (curObj->starttick); } SCM scheme_get_measure_number (void) { return scm_from_int (Denemo.project->movement->currentmeasurenum); } SCM scheme_set_measure_number_offset (SCM val) { DenemoMeasure *themeasure; if (scm_is_integer (val)) { gint offset = scm_to_int (val); DenemoPosition pos; get_position (Denemo.project->movement, &pos); gint i = 1; while (goto_movement_staff_obj (NULL, -1, i++, pos.measure, 0, 0)) { themeasure = (DenemoMeasure *) Denemo.project->movement->currentmeasure->data; themeasure->measure_numbering_offset = offset; } goto_movement_staff_obj (NULL, -1, pos.staff, pos.measure, pos.object, pos.leftmeasurenum); cache_all (); } else return SCM_BOOL_F; themeasure = Denemo.project->movement->currentmeasure->data; return scm_from_int (themeasure->measure_numbering_offset); } SCM scheme_get_measure_number_offset (void) { DenemoMeasure *themeasure = Denemo.project->movement->currentmeasure->data; return scm_from_int (themeasure->measure_numbering_offset); } SCM scheme_get_note (SCM count) { gint index = 0; DenemoObject *curObj; chord *thechord; note *thenote; if (scm_is_integer (count)) { index = scm_to_int (count) - 1; if (index < 0) return SCM_BOOL_F; } if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object) || !(thechord->notes) || !(thenote = (note *) g_list_nth_data (thechord->notes, index))) return SCM_BOOL_F; else { gchar *str = g_strdup_printf ("%s", mid_c_offsettolily (thenote->mid_c_offset, thenote->enshift)); SCM scm = scm_from_locale_string (str); g_free (str); return scm; } } SCM scheme_get_note_staff_position (SCM count) { gint index = 0; DenemoObject *curObj; chord *thechord; note *thenote; if (scm_is_integer (count)) { index = scm_to_int (count) - 1; if (index < 0) return SCM_BOOL_F; } if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object) || !(thechord->notes) || !(thenote = (note *) g_list_nth_data (thechord->notes, index))) return SCM_BOOL_F; else { return scm_from_int(4 - thenote->y/HALF_LINE_SPACE); } } SCM scheme_get_note_from_top (SCM count) { gint index = 1; DenemoObject *curObj; chord *thechord; note *thenote; if (scm_is_integer (count)) { index = scm_to_int (count); if (index < 1) return SCM_BOOL_F; } if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object) || !(thechord->notes)) return SCM_BOOL_F; else { SCM scm; gint end = g_list_length (thechord->notes); index = end - index; if (index < 0) scm = SCM_BOOL_F; else { thenote = (note *) g_list_nth_data (thechord->notes, index); gchar *str = g_strdup_printf ("%s", mid_c_offsettolily (thenote->mid_c_offset, thenote->enshift)); scm = scm_from_locale_string (str); g_free (str); } return scm; } } SCM scheme_get_note_from_top_as_midi (SCM count) { gint index = 1; DenemoObject *curObj; chord *thechord; note *thenote; if (scm_is_integer (count)) { index = scm_to_int (count); if (index < 1) return SCM_BOOL_F; } if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object) || !(thechord->notes)) return SCM_BOOL_F; else { SCM scm; gint end = g_list_length (thechord->notes); index = end - index; if (index < 0) scm = SCM_BOOL_F; else { thenote = (note *) g_list_nth_data (thechord->notes, index); gint midi = dia_to_midinote (thenote->mid_c_offset) + thenote->enshift; scm = scm_from_int (midi); } return scm; } } SCM scheme_spell_check_midi_chord (SCM list) { SCM scm; GList *notes = NULL; gboolean status; if (scm_is_list (list)) { for (scm = list; !scm_is_null (scm); scm = scm_cdr (scm)) { gint note = scm_to_int (scm_car (scm)); notes = g_list_prepend (notes, GINT_TO_POINTER (note)); } status = check_midi_intervals (notes); g_list_free (notes); return status ? SCM_BOOL_T : SCM_BOOL_F; } else { g_warning ("Bad pitch spell list"); return SCM_BOOL_F; } } SCM scheme_get_cursor_note_as_midi (SCM optional) { DenemoProject *gui = Denemo.project; gint midi = dia_to_midinote (gui->movement->cursor_y); SCM scm = scm_from_int (midi); return scm; } SCM scheme_get_note_as_midi (void) { DenemoObject *curObj; chord *thechord; note *thenote; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object) || !(thechord->notes) || !(thenote = (note *) thechord->notes->data)) return scm_from_int (0); else { gint midi = dia_to_midinote (thenote->mid_c_offset) + thenote->enshift; SCM scm = scm_from_int (midi); return scm; } } SCM scheme_get_notes (SCM optional) { DenemoObject *curObj; chord *thechord; note *thenote; GString *str = g_string_new (""); SCM scm; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object) || !(thechord->notes) || !(thenote = (note *) thechord->notes->data)) return SCM_BOOL (FALSE); else { GList *g; for (g = thechord->notes; g; g = g->next) { thenote = (note *) g->data; gchar *name = mid_c_offsettolily (thenote->mid_c_offset, thenote->enshift); str = g_string_append (str, name); if (g->next) str = g_string_append (str, " "); } scm = scm_from_locale_string (g_string_free (str, FALSE)); return scm; } } SCM scheme_get_note_at_cursor (void) { DenemoObject *curObj; chord *thechord; note *thenote; GString *str = g_string_new (""); SCM scm; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object) || !(thechord->notes) || !(thenote = (note *) thechord->notes->data)) return SCM_BOOL_F; GList *g; for (g = thechord->notes; g; g = g->next) { thenote = (note *) g->data; if (thenote->mid_c_offset == Denemo.project->movement->cursor_y) { gchar *name = mid_c_offsettolily (thenote->mid_c_offset, thenote->enshift); return scm_from_locale_string (name); } } return SCM_BOOL_F; } SCM scheme_add_movement (SCM optional) { append_blank_movement (); return SCM_BOOL_T; } SCM scheme_get_prevailing_clef (SCM optional) { gint theclef = find_prevailing_clef (Denemo.project->movement); //FIXME look at directives to see if it is overridden, e.g. drum clef const gchar *clefname = get_clef_name (theclef); if (clefname) return scm_from_locale_string (clefname); else return SCM_BOOL_F; } SCM scheme_get_prevailing_clef_as_lilypond (SCM optional) { const gchar *clefname = get_prevailing_clef_as_lilypond (); if (clefname) return scm_from_locale_string (clefname); else return SCM_BOOL_F; } SCM scheme_get_prevailing_keysig_as_lilypond (SCM optional) { const gchar *keysigname = get_prevailing_keysig_as_lilypond (); if (keysigname) return scm_from_locale_string (keysigname); else return SCM_BOOL_F; } SCM scheme_get_prevailing_timesig_as_lilypond (SCM optional) { const gchar *timesigname = get_prevailing_timesig_as_lilypond (); if (timesigname) return scm_from_locale_string (timesigname); else return SCM_BOOL_F; } SCM scheme_get_prevailing_duration (SCM optional) { if (scm_is_integer (optional)) { gint duration = scm_to_int (optional); if (duration >= 0 && (duration < 8)) { SetDur (duration); return SCM_BOOL_T; } return SCM_BOOL_F; } else return scm_from_int (get_prevailing_duration ()); } SCM scheme_get_prevailing_timesig (SCM optional) { timesig *timesig = get_prevailing_context (TIMESIG); //FIXME look at directives to see if it is overridden, e.g. drum clef gchar *name = g_strdup_printf ("%d/%d", timesig->time1, timesig->time2); SCM ret = scm_from_locale_string (name); g_free (name); return ret; } SCM scheme_get_prevailing_keysig (SCM optional) { GString *str = g_string_new (" "); keysig *keysig = get_prevailing_context (KEYSIG); gint i; for (i = 0; i < 7; i++) g_string_append_printf (str, "%d ", keysig->accs[i]); return scm_from_locale_string (g_string_free (str, FALSE)); } SCM scheme_get_prevailing_keysig_name (void) { SCM ret; gchar *key = get_prevailing_keysig_name(); ret = scm_from_locale_string (key); g_free (key); return ret; } SCM scheme_set_prevailing_keysig (SCM keyaccs) { //keysigs have a field called "number" which determines how it is drawn, setting like this does not get a keysig drawn, nor does it affect lilypond output char *accs = NULL; if (scm_is_string (keyaccs)) { accs = scm_to_locale_string (keyaccs); } if (!accs) { return SCM_BOOL_F; } keysig *keysig = get_prevailing_context (KEYSIG); sscanf (accs, "%d%d%d%d%d%d%d", keysig->accs + 0, keysig->accs + 1, keysig->accs + 2, keysig->accs + 3, keysig->accs + 4, keysig->accs + 5, keysig->accs + 6); staff_show_which_accidentals ((DenemoStaff *) Denemo.project->movement->currentstaff->data); free (accs); displayhelper (Denemo.project); //score_status(Denemo.project, TRUE); return SCM_BOOL_T; } SCM scheme_increment_initial_keysig (SCM amount) { DenemoStaff *curstaff = Denemo.project->movement->currentstaff->data; SCM ret = SCM_BOOL_F; gint inc = 1; if (scm_is_integer (amount)) inc = scm_to_int (amount); keysig *sig = &curstaff->keysig; inc += sig->number; if (inc < 8 && inc > -8) { dnm_setinitialkeysig (curstaff, inc, curstaff->keysig.isminor); score_status (Denemo.project, TRUE); ret = SCM_BOOL_T; } return ret; } SCM scheme_increment_keysig (SCM amount) { DenemoStaff *curstaff = Denemo.project->movement->currentstaff->data; DenemoObject *curObj = NULL; SCM ret = SCM_BOOL_F; gint inc = 1; if (scm_is_integer (amount)) inc = scm_to_int (amount); keysig *sig = &curstaff->keysig; if ((Denemo.project->movement->currentobject) && (curObj = Denemo.project->movement->currentobject->data) && (curObj->type == KEYSIG)) { sig = curObj->object; } inc += sig->number; if (inc < 8 && inc > -8) { if (sig == &curstaff->keysig) { dnm_setinitialkeysig (curstaff, inc, curstaff->keysig.isminor); } else { sig->number = inc; initkeyaccs (sig->accs, inc); set_basic_numticks (curObj); setpixelmin (curObj); } score_status (Denemo.project, TRUE); displayhelper (Denemo.project); ret = SCM_BOOL_T; } return ret; } SCM scheme_swap_notes_at_cursor_height (SCM nochange) { DenemoObject *curObj; chord *thechord; note *thenote; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object) || !(thechord->notes) || !(thenote = (note *) thechord->notes->data)) return SCM_BOOL_F; GList *g; for (g=thechord->notes;g;g=g->next) { thenote = (note *) g->data; if (thenote->mid_c_offset == Denemo.project->movement->cursor_y) { if (g->next) { gpointer temp; note *next = (note*)g->next->data; if (next->mid_c_offset == Denemo.project->movement->cursor_y) { if(scm_is_true (nochange)) //not just a query, actually swap notes { temp = g->next->data; g->next->data = g->data; g->data = temp; } return SCM_BOOL_T; } } else return SCM_BOOL_F; } } return SCM_BOOL_F; } SCM scheme_cursor_to_nth_note_height (SCM number) { return SCM_BOOL (cursor_to_nth_note_height (scm_to_int (number) - 1)); } SCM scheme_cursor_to_next_note_height (void) { return SCM_BOOL (cursor_to_next_note_height ()); } SCM scheme_cursor_to_note (SCM lilyname) { DenemoProject *gui = Denemo.project; gint mid_c_offset; gint enshift; char *notename; if (scm_is_string (lilyname)) { notename = scm_to_locale_string (lilyname); interpret_lilypond_notename (notename, &mid_c_offset, &enshift); gui->movement->cursor_y = mid_c_offset; gui->movement->staffletter_y = offsettonumber (gui->movement->cursor_y); displayhelper (gui); if (notename) free (notename); return SCM_BOOL (TRUE); } else { return SCM_BOOL (FALSE); } } SCM scheme_flash_cursor (void) { set_cursor_transition (); return SCM_BOOL (TRUE); } SCM scheme_change_chord_notes (SCM lilynotes) { DenemoProject *gui = Denemo.project; DenemoObject *curObj; chord *thechord; note *thenote; char *notename; gchar *chordnote; gint mid_c_offset; gint enshift; gint dclef; GList *g = NULL; GList *n = NULL; GList *directives = NULL; if (scm_is_string (lilynotes)) { if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object) || !(thechord->notes) || !(thenote = (note *) thechord->notes->data)) return SCM_BOOL (FALSE); else { /* delete all chord tones */ while (thechord->notes) { thenote = thechord->notes->data; g = g_list_append (g, thenote->directives); thenote->directives = NULL; delete_chordnote (gui); } /* add changed tones */ dclef = find_prevailing_clef (Denemo.project->movement); notename = scm_to_locale_string (lilynotes); chordnote = strtok (notename, " "); while (chordnote) { interpret_lilypond_notename (chordnote, &mid_c_offset, &enshift); dnm_addtone (curObj, mid_c_offset, enshift); chordnote = strtok (NULL, " "); } /* paste directives over */ for (n = thechord->notes; n && g; n = n->next, g = g->next) { thenote = (note *) n->data; directives = (GList *) g->data; if (directives) thenote->directives = directives; } score_status (gui, TRUE); displayhelper (gui); if (notename) free (notename); return SCM_BOOL (TRUE); } } else return SCM_BOOL (FALSE); } SCM scheme_get_user_input (SCM label, SCM prompt, SCM init, SCM modal) { char *title, *instruction, *initial_value; if (scm_is_string (label)) { title = scm_to_locale_string (label); } else title = strdup ("Input Required"); if (scm_is_string (prompt)) { instruction = scm_to_locale_string (prompt); } else instruction = strdup ("Give input: "); if (scm_is_string (init)) { initial_value = scm_to_locale_string (init); } else initial_value = strdup (" "); gchar *ret = string_dialog_entry_with_widget_opt (Denemo.project, title, instruction, initial_value, NULL, scm_is_eq (modal, SCM_UNDEFINED) || scm_is_true (modal)); SCM scm = ret ? scm_from_locale_string (ret) : SCM_BOOL_F; if (title) free (title); if (instruction) free (instruction); if (initial_value) free (initial_value); if (ret) g_free (ret); return scm; } SCM scheme_get_user_input_with_snippets (SCM label, SCM prompt, SCM init, SCM modal) { char *title, *instruction, *initial_value; SCM scm; gboolean ismodal = FALSE, format = FALSE; if (scm_is_string (modal)) { char *arg = scm_to_locale_string (modal); if (!strcmp (arg, "format")) ismodal = format = TRUE; else if (!strcmp (arg, "modal")) ismodal = TRUE, format = FALSE; //g_print ("setting from %s %d %d\n", arg, ismodal, format); free (arg); } else { ismodal = !scm_is_false (modal), format = (!scm_is_false (modal)) && (!scm_is_eq (modal, SCM_UNDEFINED)); } if (scm_is_string (label)) { title = scm_to_locale_string (label); } else title = strdup (_("Input Required")); if (scm_is_string (prompt)) { instruction = scm_to_locale_string (prompt); } else instruction = strdup (_("Give input: ")); if (scm_is_string (init)) { initial_value = scm_to_locale_string (init); } else initial_value = strdup (" "); GString *text = g_string_new (""), *lilypond = g_string_new (""); // g_print ("Called with %d %d\n", ismodal, format); gboolean ok = get_user_markup (text, lilypond, title, instruction, initial_value, ismodal, format); if (ok) { scm = scm_cons (scm_from_locale_string (text->str), scm_from_locale_string (lilypond->str)); } else scm = SCM_BOOL_F; if (title) free (title); if (instruction) free (instruction); if (initial_value) free (initial_value); g_string_free (text, TRUE); g_string_free (lilypond, TRUE); return scm; } static gchar * select_font (gchar * title) { gchar *fontname = NULL; GtkResponseType result; GtkWidget *dialog = #if GTK_MAJOR_VERSION == 2 gtk_font_selection_dialog_new (title); #else gtk_font_chooser_dialog_new (title, NULL); #endif result = gtk_dialog_run (GTK_DIALOG (dialog)); if (result == GTK_RESPONSE_OK || result == GTK_RESPONSE_APPLY) #if GTK_MAJOR_VERSION == 2 fontname = gtk_font_selection_dialog_get_font_name (GTK_FONT_SELECTION_DIALOG (dialog)); fontname = string_dialog_entry (Denemo.project, title, _("Please delete the font size and bold/italic indications,\nleaving just the font family name."), fontname); #else fontname = g_strdup (pango_font_family_get_name (gtk_font_chooser_get_font_family (GTK_FONT_CHOOSER (dialog)))); #endif gtk_widget_destroy (dialog); return fontname; } SCM scheme_select_font (SCM text) { SCM ret = SCM_BOOL_F; gchar *title, *choice; if (scm_is_string (text)) { title = scm_to_locale_string (text); } else title = strdup (_("Choose Font")); choice = select_font (title); if (choice) ret = scm_from_locale_string (choice); g_free (choice); return ret; } #define GDOUBLE_TO_POINTER(x) (GINT_TO_POINTER((gint)(10000*x))) #define GPOINTER_TO_DOUBLE(x) (GPOINTER_TO_INT(x)/10000.0) static GList * select_color (gchar * title) { GtkResponseType result; GList *ret = NULL; GtkWidget *dialog = #if GTK_MAJOR_VERSION == 2 gtk_color_selection_dialog_new (title); #else gtk_color_chooser_dialog_new (title, NULL); #endif result = gtk_dialog_run (GTK_DIALOG (dialog)); if (result == GTK_RESPONSE_OK || result == GTK_RESPONSE_APPLY) { #if GTK_MAJOR_VERSION == 2 GdkColor color; GtkColorSelection *colorsel = gtk_color_selection_dialog_get_color_selection (dialog); gtk_color_selection_get_current_color (colorsel, &color); ret = g_list_append (ret, GDOUBLE_TO_POINTER (color.red / 65535.0)); ret = g_list_append (ret, GDOUBLE_TO_POINTER (color.green / 65535.0)); ret = g_list_append (ret, GDOUBLE_TO_POINTER (color.blue / 65535.0)); #else GdkRGBA color; gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (dialog), &color); ret = g_list_append (ret, GDOUBLE_TO_POINTER (color.red)); ret = g_list_append (ret, GDOUBLE_TO_POINTER (color.green)); ret = g_list_append (ret, GDOUBLE_TO_POINTER (color.blue)); #endif } gtk_widget_destroy (dialog); return ret; } SCM scheme_select_color (SCM text) { SCM ret = SCM_BOOL_F; gchar *title; GList *list; if (scm_is_string (text)) { title = scm_to_locale_string (text); } else title = strdup (_("Choose Font")); list = select_color (title); if (list) { ret = scm_list_n (scm_from_double (GPOINTER_TO_DOUBLE (list->data)), scm_from_double (GPOINTER_TO_DOUBLE (list->next->data)), scm_from_double (GPOINTER_TO_DOUBLE (list->next->next->data)), SCM_UNDEFINED); g_list_free (list); } return ret; } SCM scheme_warningdialog (SCM msg) { char *title; if (scm_is_string (msg)) { title = scm_to_locale_string (msg); } else title = strdup ("Script generated warning"); warningdialog (title); if (title) free (title); return msg; } static void info_response (GtkWidget * dialog, gint reponse_id, gchar * script) { if (script) call_out_to_guile (script); gtk_widget_destroy (dialog); } SCM scheme_info_with_hook (SCM title, SCM hook) { GtkWidget *dialog; gchar *msg = NULL, *script = NULL; if (scm_is_string (hook)) script = scm_to_locale_string (hook); if (scm_is_string (title)) msg = scm_to_locale_string (title); if (msg) { dialog = gtk_message_dialog_new (GTK_WINDOW (Denemo.window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE, "%s", msg); #ifdef G_OS_WIN32 gtk_window_set_resizable (GTK_WINDOW (dialog), TRUE); //needed on windows because of a bug, not all text can be seen. #endif g_signal_connect (dialog, "response", G_CALLBACK (info_response), script); gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (Denemo.window)); gtk_window_set_keep_above (GTK_WINDOW (dialog), TRUE); gtk_widget_show_all (dialog); return SCM_BOOL_T; } return SCM_BOOL_F; } SCM scheme_infodialog (SCM msg, SCM noblock) { char *title; gboolean modal = FALSE; if (scm_is_false (noblock)) modal = TRUE; if (scm_is_string (msg)) { title = scm_to_locale_string (msg); msg = SCM_BOOL (TRUE); } else { title = strdup (_("Script error, wrong parameter type to d-InfoDialog")); msg = SCM_BOOL (FALSE); } if (modal) { infowarningdialog (title, FALSE); } else { static GtkWidget *dialog; if (dialog) { gtk_widget_show (dialog); gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog), title); } else { dialog = infodialog (title); g_signal_connect (dialog, "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL); } if (*title) { gtk_widget_show (dialog); } else { gtk_widget_hide (dialog); } } if (title) free (title); return msg; } SCM scheme_progressbar (SCM msg) { char *title = NULL; if (scm_is_string (msg)) { title = scm_to_locale_string (msg); progressbar (title, NULL); msg = SCM_BOOL (TRUE); } else msg = SCM_BOOL (FALSE); if (title) free (title); return msg; } SCM scheme_progressbar_stop (void) { progressbar_stop (); return SCM_BOOL (TRUE); } SCM scheme_typeset_for_script (SCM thescript) { SCM ret = SCM_BOOL_F; #ifndef USE_EVINCE g_debug ("This feature requires denemo to be built with evince"); #else if (scm_is_string (thescript)) { gchar *script = scm_to_locale_string (thescript); if (typeset_for_script (script)) ret = SCM_BOOL_T; } #endif return ret; } SCM scheme_print_typeset_pdf (void) { #ifndef USE_EVINCE g_debug ("This feature requires denemo to be built with evince"); return SCM_BOOL_F; #else return print_typeset_pdf ()? SCM_BOOL_F : SCM_BOOL_T; #endif } SCM scheme_create_pdf_from_lilyfile (SCM lily, SCM out) { if (scm_is_string (lily) && scm_is_string (out)) { gchar *lilyfile = scm_to_locale_string (lily); gchar *outfile = scm_to_locale_string (out); generate_pdf_from_lily_file (lilyfile, outfile); return SCM_BOOL_T; } return SCM_BOOL_F; } static gchar **get_vector (SCM list) { gchar **arg = NULL; gint length = scm_to_int (scm_length (list)); if (length>0) { gint i; arg = (gchar **)g_malloc (1 + sizeof (gchar*)*length); for (i=0;i\n", out); if (!err) return scm_from_locale_string (out); if (!Denemo.non_interactive) { gchar *text = g_strdup_printf ("%s%s%s%s", "Attempt to run program <", arg[0], "> failed with message: ", err->message); warningdialog (text); g_free (text); } } return SCM_BOOL_F; } SCM scheme_get_current_typeset_pdf (void) { gchar *pdf = Denemo.printstatus->printname_pdf[Denemo.printstatus->cycle]; if (pdf) return scm_from_locale_string (pdf); return SCM_BOOL_F; } SCM scheme_continuous_typesetting (void) { return SCM_BOOL (continuous_typesetting ()); } SCM scheme_display_typeset_svg (SCM scaling, SCM part) { if (!continuous_typesetting ()) { gdouble scale = 1.0; if (scm_is_real (scaling)) scale = scm_to_double (scaling); display_svg (scale, scm_is_true (part)); return SCM_BOOL_T; } else return SCM_BOOL_F; } SCM scheme_get_char (void) { GdkEventKey event; gboolean success = intercept_scorearea_keypress (&event); if (success) { gchar *str = g_strdup_printf ("%c", success ? event.keyval : 0); SCM scm = scm_from_locale_string (str); g_free (str); return scm; } else return SCM_BOOL (FALSE); } SCM scheme_get_keypress (SCM putback) { static GdkEventKey event; if (scm_is_false (putback)) { gint cmd = lookup_command_for_keyevent (&event); if (cmd != -1) return SCM_BOOL ( execute_callback_from_idx (Denemo.map, cmd)); else return SCM_BOOL_F; } else { gboolean success = intercept_scorearea_keypress (&event); if (success) { gchar *str = dnm_accelerator_name (event.keyval, event.state); SCM scm = scm_from_locale_string (str); g_free (str); return scm; } } return SCM_BOOL_F; } /* get last keypress that successfully invoked a command */ SCM scheme_get_command_keypress (void) { gchar *str = dnm_accelerator_name (Denemo.last_keyval, Denemo.last_keystate); SCM scm = scm_from_locale_string (str); g_free (str); return scm; } SCM scheme_get_command (void) { GdkEventKey event; GString *name = g_string_new (""); gboolean success = intercept_scorearea_keypress (&event); if (success) { gint cmd = lookup_command_for_keyevent (&event); //g_debug("command %d for %x %x\n", cmd, event.keyval, event.state); if (cmd != -1) name = g_string_append (name, lookup_name_from_idx (Denemo.map, cmd)); //FIXME NULL?, memory leaks name = g_string_prepend (name, DENEMO_SCHEME_PREFIX); } SCM scm = success ? scm_from_locale_string (name->str) : SCM_BOOL (FALSE); g_string_free (name, TRUE); return scm; } gchar * return_command (const gchar * name, GdkEventKey * event) { return name; } /* listens for a shortcut and returns a command, or if keypresses are not shortcut returns #f */ SCM scheme_get_command_from_user (void) { GdkEventKey event; if (intercept_scorearea_keypress (&event)) { gchar *command = process_key_event (&event, &return_command); if (command == NULL) return SCM_BOOL_F; if (*command == 0) { //can be two-key shortcut if (intercept_scorearea_keypress (&event)) { command = process_key_event (&event, &return_command); if (command == NULL) return SCM_BOOL_F; } else return SCM_BOOL_F; } write_status (Denemo.project); SCM scm = scm_from_locale_string (command); //command is from lookup_name_from... functions, do not free. return scm; } return SCM_BOOL_F; } /*UNUSED static void get_drag_offset (GtkWidget * dialog, gint response_id, GtkLabel * label) { g_object_set_data (G_OBJECT (dialog), "offset-response", (gpointer) (intptr_t) response_id); if (response_id < 0) gtk_main_quit (); gint offsetx, offsety; offsetx = (intptr_t) g_object_get_data (G_OBJECT (Denemo.printarea), "offsetx"); offsety = (intptr_t) g_object_get_data (G_OBJECT (Denemo.printarea), "offsety"); gchar *text = g_strdup_printf ("Offset now %d %d. Drag again in the print window to change\nOr click OK to apply the position shift", offsetx, offsety); gtk_label_set_text (label, text); g_free (text); }*/ static void get_drag_pad (GtkWidget * dialog, gint response_id, GtkLabel * label) { g_object_set_data (G_OBJECT (dialog), "pad-response", (gpointer) (intptr_t) response_id); if (response_id < 0) gtk_main_quit (); gint padding; padding = (intptr_t) g_object_get_data (G_OBJECT (Denemo.printarea), "padding"); gchar *text = g_strdup_printf ("Padding now %d. Drag again in the print window to change\nOr click OK to apply the padding to the graphical object belonging to the directive", padding); gtk_label_set_text (label, text); g_free (text); } /* return a string representing the relative font size the user wishes to use*/ SCM scheme_get_relative_font_size (void) { if (Denemo.printarea == NULL) return SCM_BOOL (FALSE); gchar *value = g_object_get_data (G_OBJECT (Denemo.printarea), "font-size"); if (value) g_free (value); value = string_dialog_entry (Denemo.project, "Font Size", "Give a value (+/-) to adjust font size by", "0"); if (!value) value = g_strdup ("0"); gchar *clean = g_strdup_printf ("%d", atoi (value)); g_free (value); g_object_set_data (G_OBJECT (Denemo.printarea), "font-size", (gpointer) clean); return scm_from_locale_stringn (clean, strlen (clean)); } void get_clipboard (DenemoAction * action, DenemoScriptParam * param); /* return a string from the X selection */ SCM scheme_get_text_selection (void) { SCM ret; DenemoScriptParam param; get_clipboard (NULL, ¶m); if (param.status) { ret = scm_from_locale_stringn (param.string->str, param.string->len); g_string_free (param.string, TRUE); } else ret = SCM_BOOL (FALSE); return ret; } /* return a string representing the padding desired for some lilypond graphic or #f if no printarea or user cancels*/ SCM scheme_get_padding (void) { SCM ret; if (Denemo.printarea == NULL) return SCM_BOOL (FALSE); if (g_object_get_data (G_OBJECT (Denemo.printarea), "pad-dialog")) { warningdialog (_("Already in a padding dialog")); return SCM_BOOL_F; } gint padding = (intptr_t) g_object_get_data (G_OBJECT (Denemo.printarea), "padding"); GtkWidget *dialog = gtk_dialog_new_with_buttons ("Select Padding in Print Window", GTK_WINDOW (Denemo.window), (GtkDialogFlags) (GTK_DIALOG_DESTROY_WITH_PARENT), _("_OK"), GTK_RESPONSE_ACCEPT, _("_Cancel"), GTK_RESPONSE_REJECT, NULL); g_object_set_data (G_OBJECT (Denemo.printarea), "pad-dialog", (gpointer) dialog); GtkWidget *vbox = gtk_vbox_new (FALSE, 8); GtkWidget *content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); gtk_container_add (GTK_CONTAINER (content_area), vbox); gchar *text = g_strdup_printf ("Current padding is %d\nUse right click in print window to change this\nClick OK to apply the padding to the music item drawn by the directive", padding); GtkWidget *label = gtk_label_new (text); g_free (text); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0); gtk_widget_show_all (dialog); gint val; g_signal_connect (dialog, "response", G_CALLBACK (get_drag_pad), label); gtk_widget_show_all (dialog); gtk_main (); padding = (intptr_t) g_object_get_data (G_OBJECT (Denemo.printarea), "padding"); val = (intptr_t) g_object_get_data (G_OBJECT (dialog), "pad-response"); g_object_set_data (G_OBJECT (Denemo.printarea), "pad-dialog", NULL); gtk_widget_destroy (dialog); if (val == GTK_RESPONSE_ACCEPT) { gchar *pad = g_strdup_printf ("%d", padding / 10); ret = scm_from_locale_string (pad); g_free (pad); } else ret = SCM_BOOL (FALSE); return ret; } /* create a dialog with two strings & title * return #t if the first is chosen else #f */ SCM scheme_make_choice (SCM default_option, SCM alternative, SCM title) { gchar *first, *second, *thetitle; if (scm_is_string (title)) { thetitle = scm_to_locale_string (title); if (scm_is_string (default_option)) { first = scm_to_locale_string (default_option); if (scm_is_string (alternative)) { second = scm_to_locale_string (alternative); return SCM_BOOL (confirm_first_choice (thetitle, first, second)); } } } return SCM_BOOL_F; } /* create a dialog with the options & return the one chosen, of #f if the user cancels */ SCM scheme_get_option (SCM options, SCM title) { gchar *response = NULL; size_t length; gchar *thetitle = NULL; //gchar *str=NULL; if (scm_is_string (title)) thetitle = scm_to_locale_string (title); if (scm_is_string (options)) { char *str_unterm; str_unterm = scm_to_locale_stringn (options, &length); response = get_option (thetitle, str_unterm, length); //returns NULL or a pointer to a location in str_unterm //g_debug("Got %p holding %s\n", response, response); if (response) response = g_strdup (response); if (str_unterm) free (str_unterm); } if (response) { SCM ret = scm_from_locale_stringn (response, strlen (response)); //g_debug("Freeing %p holding %s\n", response, response); g_free (response); //FIXME the g_strdup above is not needed? return ret; //return scm_from_locale_stringn (response, strlen(response)); } else { return SCM_BOOL_F; } } /* Scheme interface to DenemoDirectives (formerly LilyPond directives attached to notes/chords) */ SCM scheme_lock_directive (SCM lock) { DenemoObject *curObj; DenemoDirective *directive; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != LILYDIRECTIVE) || !(directive = (DenemoDirective *) curObj->object)) return SCM_BOOL (FALSE); directive->locked = scm_is_true (lock); return SCM_BOOL_T; } /* store the script to be invoked as an action for a directive tagged with tag */ SCM scheme_set_action_script_for_tag (SCM tag, SCM script) { if (scm_is_string (tag)) { char *the_tag; the_tag = scm_to_locale_string (tag); if (scm_is_string (script)) { char *the_script; the_script = scm_to_locale_string (script); gchar *stored_script = g_strdup (the_script); //FIXME free (the_script); set_action_script_for_tag (the_tag, stored_script); if (the_tag) free (the_tag); return SCM_BOOL (TRUE); } if (the_tag) free (the_tag); } return SCM_BOOL (FALSE); } SCM scheme_put_standalone_directive (SCM tag, SCM width) { if (scm_is_string (tag)) { char *the_tag; gint pixelwidth = 40; if (scm_is_integer (width)) pixelwidth = scm_to_int (width); the_tag = scm_to_locale_string (tag); put_standalone_directive (the_tag, pixelwidth); if (the_tag) free (the_tag); return SCM_BOOL_T; } return SCM_BOOL_F; } SCM scheme_choose_tag_at_cursor (void) { DenemoObject *curObj; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data)) return SCM_BOOL_F; gchar *tag; gboolean is_note = choose_tag_at_cursor (&tag); if (tag) { if (curObj->type == CHORD) return scm_cons (scm_from_locale_string (tag), scm_from_bool (is_note)); else return scm_from_locale_string (tag); } return SCM_BOOL_F; } SCM scheme_get_script_for_directive (SCM tagname, SCM isnote) { DenemoObject *curObj; SCM ret = SCM_BOOL_F; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD)) return SCM_BOOL_F; gchar *tag, *script; gboolean note = scm_is_true (isnote); if (scm_is_string (tagname)) { tag = scm_to_locale_string (tagname); DenemoDirective *directive = note ? get_note_directive (tag) : find_directive (((chord *) curObj->object)->directives, tag); if (directive) { Denemo.project->movement->directive_on_clipboard = (gpointer) directive; script = get_script_for_directive (directive, note ? "note" : "chord"); ret = scm_from_locale_string (script); g_free (script); } } return ret; } SCM scheme_directive_change_tag (SCM tag) { DenemoObject *curObj; if (scm_is_string (tag)) { gchar *thetag = scm_to_locale_string (tag); DenemoDirective *directive; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != LILYDIRECTIVE) || !(directive = (DenemoDirective *) curObj->object)) return SCM_BOOL (FALSE); if (directive->tag == NULL) directive->tag = g_string_new (""); g_string_assign (directive->tag, thetag); g_free (thetag); return SCM_BOOL_T; } return SCM_BOOL_F; } #define GET_NTH_TAG(what)\ SCM scheme_##what##_directive_get_nth_tag(SCM index) {\ gint n;\ if(!scm_is_integer(index))\ return SCM_BOOL_F;\ n = scm_to_int(index);\ extern gchar *get_nth_##what##_tag (gint n);\ gchar *val = get_nth_##what##_tag (n);\ if(val) return scm_from_locale_stringn (val, strlen(val));\ return SCM_BOOL_F;\ } GET_NTH_TAG (chord); GET_NTH_TAG (note); GET_NTH_TAG (staff); GET_NTH_TAG (voice); GET_NTH_TAG (score); GET_NTH_TAG (clef); GET_NTH_TAG (timesig); GET_NTH_TAG (tuplet); GET_NTH_TAG (stemdirective); GET_NTH_TAG (keysig); GET_NTH_TAG (scoreheader); GET_NTH_TAG (header); GET_NTH_TAG (paper); GET_NTH_TAG (layout); GET_NTH_TAG (movementcontrol); #undef GET_NTH_TAG #define PRIORITIZE_TAG(what)\ SCM scheme_##what##_directive_prioritize_tag(SCM name) {\ gchar *tag;\ if(!scm_is_string(name))\ return SCM_BOOL_F;\ tag = scm_to_locale_string (name);\ extern gboolean prioritize_##what##_tag (gchar *name);\ gboolean val = prioritize_##what##_tag (tag);\ if(val) return name;\ return SCM_BOOL_F;\ } PRIORITIZE_TAG (chord); PRIORITIZE_TAG (note); PRIORITIZE_TAG (staff); PRIORITIZE_TAG (voice); PRIORITIZE_TAG (score); PRIORITIZE_TAG (clef); PRIORITIZE_TAG (timesig); PRIORITIZE_TAG (tuplet); PRIORITIZE_TAG (stemdirective); PRIORITIZE_TAG (keysig); PRIORITIZE_TAG (scoreheader); PRIORITIZE_TAG (header); PRIORITIZE_TAG (paper); PRIORITIZE_TAG (layout); PRIORITIZE_TAG (movementcontrol); #undef PRIORITIZE_TAG SCM scheme_edit_system_directive (void) { edit_system_directive (); return SCM_BOOL_T; } SCM scheme_display_directive_text_editor (SCM type, SCM tagname) { if (scm_is_string (type) && scm_is_string (tagname)) { gchar *what = scm_to_locale_string (type); gchar *tag = scm_to_locale_string (tagname); DenemoDirective *directive; if (!strcmp (what, "score")) directive = get_score_directive (tag); else directive = get_movementcontrol_directive (tag); //others - note, chord ... if (directive && directive->override & DENEMO_OVERRIDE_EDITOR) { GtkWidget *texteditor = (GtkWidget *) g_object_get_data (G_OBJECT (directive->widget), DENEMO_TEXTEDITOR_TAG); if (texteditor) { gtk_widget_show_all (gtk_widget_get_toplevel (texteditor)); gtk_window_present (GTK_WINDOW (gtk_widget_get_toplevel (texteditor))); } return SCM_BOOL_T; } } return SCM_BOOL_F; } //only retrieve directives when cursor is actually on the note SCM scheme_directive_get_nth_tag_strict_note (SCM index) { gint n; if (!scm_is_integer (index)) return SCM_BOOL_F; n = scm_to_int (index); gchar *val = get_nth_strict_note_tag (n); if (val) return scm_from_locale_stringn (val, strlen (val)); return SCM_BOOL_F; } SCM scheme_directive_get_for_tag_strict_note (SCM tagname) { SCM ret = SCM_BOOL_F; const gchar *tag = NULL; if (scm_is_string (tagname)) tag = scm_to_locale_string (tagname); tag = strict_note_directive_get_tag ((gchar *) tag); if (tag) ret = scm_from_locale_string (tag); return ret; } #define GET_TAG_FN_DEF(what)\ SCM scheme_##what##_directive_get_tag(SCM tag) {\ char *tagname;\ if(!scm_is_string(tag))\ tagname = NULL;\ else { \ tagname = scm_to_locale_string(tag);\ } \ extern gchar *what##_directive_get_tag (gchar *tagname);\ gchar *val = (gchar*)what##_directive_get_tag ((gchar*)tagname);\ if(val){\ SCM ret = scm_from_locale_stringn (val, strlen(val));\ if(tagname) free(tagname);\ return ret;\ }\ if(tagname) free(tagname);\ return SCM_BOOL(FALSE);\ } GET_TAG_FN_DEF (object); GET_TAG_FN_DEF (standalone); GET_TAG_FN_DEF (chord); GET_TAG_FN_DEF (note); GET_TAG_FN_DEF (staff); GET_TAG_FN_DEF (voice); GET_TAG_FN_DEF (score); GET_TAG_FN_DEF (clef); GET_TAG_FN_DEF (timesig); GET_TAG_FN_DEF (tuplet); GET_TAG_FN_DEF (stemdirective); GET_TAG_FN_DEF (keysig); GET_TAG_FN_DEF (scoreheader); GET_TAG_FN_DEF (header); GET_TAG_FN_DEF (paper); GET_TAG_FN_DEF (layout); GET_TAG_FN_DEF (movementcontrol); #undef GET_TAG_FN_DEF #define ACTIVATE_FN_DEF(what)\ SCM scheme_activate_##what##_directive(SCM tag) {\ if(!scm_is_string(tag)){\ return SCM_BOOL(FALSE);\ }\ char *tagname;\ tagname = scm_to_locale_string(tag);\ extern gboolean activate_##what##_directive (gchar *tagname);\ gboolean ret = activate_##what##_directive (tagname);\ if(tagname) g_free(tagname);\ return SCM_BOOL(ret);\ } #define EDIT_FN_DEF(what)\ SCM scheme_text_edit_##what##_directive(SCM tag) {\ if(!scm_is_string(tag)){\ return SCM_BOOL(text_edit_##what##_directive (NULL));\ }\ char *tagname;\ tagname = scm_to_locale_string(tag);\ extern gboolean text_edit_##what##_directive (gchar *tagname);\ gboolean ret = text_edit_##what##_directive (tagname);\ if(tagname) g_free(tagname);\ return SCM_BOOL(ret);\ } #define DELETE_FN_DEF(what)\ SCM scheme_delete_##what##_directive(SCM tag) {\ if(!scm_is_string(tag)){\ return SCM_BOOL(FALSE);\ }\ char *tagname;\ tagname = scm_to_locale_string(tag);\ extern gboolean delete_##what##_directive (gchar *tagname);\ gboolean ret = delete_##what##_directive (tagname);\ if(tagname) free(tagname);\ return SCM_BOOL(ret);\ } #define EDIT_DELETE_FN_DEF(what) \ EDIT_FN_DEF(what) \ DELETE_FN_DEF(what) \ ACTIVATE_FN_DEF(what) EDIT_FN_DEF (standalone); EDIT_DELETE_FN_DEF (note); EDIT_DELETE_FN_DEF (chord); EDIT_DELETE_FN_DEF (staff); EDIT_DELETE_FN_DEF (voice); EDIT_DELETE_FN_DEF (score); #define GETFUNC_DEF(what, field)\ SCM scheme_##what##_directive_get_##field(SCM tag) {\ if(!scm_is_string(tag)){\ return SCM_BOOL(FALSE);\ }\ char *tagname;\ tagname = scm_to_locale_string(tag);\ extern gchar* what##_directive_get_##field(gchar *tagname);\ gchar *value = (gchar*)what##_directive_get_##field((gchar*)tagname);\ if(tagname) free(tagname);\ if(value && *value){\ return scm_from_locale_string(value);\ }\ return SCM_BOOL(FALSE);\ } static void structural_change_note (void) { } static void structural_change_chord (void) { } static void structural_change_clef (void) { if (!(Denemo.project->movement->currentobject && (((DenemoObject*)(Denemo.project->movement->currentobject->data))->type == CLEF))) signal_structural_change (Denemo.project); } static void structural_change_timesig (void) { if (!(Denemo.project->movement->currentobject && (((DenemoObject*)(Denemo.project->movement->currentobject->data))->type == TIMESIG))) signal_structural_change (Denemo.project);} static void structural_change_keysig (void) { if (!(Denemo.project->movement->currentobject && (((DenemoObject*)(Denemo.project->movement->currentobject->data))->type == KEYSIG))) signal_structural_change (Denemo.project);} static void structural_change_stemdirective (void) { } static void structural_change_tuplet (void) { } static void structural_change_standalone (void) { } static void structural_change_score (void) { signal_structural_change (Denemo.project); } static void structural_change_scoreheader (void) { signal_structural_change (Denemo.project); } static void structural_change_movementcontrol (void) { signal_structural_change (Denemo.project); } static void structural_change_paper (void) { signal_structural_change (Denemo.project); } static void structural_change_header (void) { signal_structural_change (Denemo.project); } static void structural_change_layout (void) { signal_structural_change (Denemo.project); } static void structural_change_staff (void) { signal_structural_change (Denemo.project); } static void structural_change_voice (void) { signal_structural_change (Denemo.project); } static void structural_change_object (void) { } //not sure what this is - some sort of temporary marker thing Nils devised. #define PUTFUNC_DEF(what, field)\ SCM scheme_##what##_directive_put_##field(SCM tag, SCM value) {\ if((!scm_is_string(tag))||(!scm_is_string(value)))\ return SCM_BOOL(FALSE);\ char *tagname;\ tagname = scm_to_locale_string(tag);\ char *valuename;\ valuename = scm_to_locale_string(value);\ extern gboolean what##_directive_put_##field (gchar *tagname, gchar *valuename);\ gboolean ret = what##_directive_put_##field ((gchar*)tagname, (gchar*)valuename);\ structural_change_##what ();\ score_status (Denemo.project, TRUE);\ if(tagname) free(tagname);\ if(valuename) free(valuename);\ return SCM_BOOL(ret);\ } // block to clone for new GString entries in DenemoDirective GETFUNC_DEF (note, display); GETFUNC_DEF (chord, display); GETFUNC_DEF (standalone, display); GETFUNC_DEF (staff, display); GETFUNC_DEF (voice, display); GETFUNC_DEF (score, display); GETFUNC_DEF (movementcontrol, display); PUTFUNC_DEF (note, display); PUTFUNC_DEF (chord, display); PUTFUNC_DEF (standalone, display); PUTFUNC_DEF (staff, display); PUTFUNC_DEF (voice, display); PUTFUNC_DEF (score, display); PUTFUNC_DEF (movementcontrol, display); // end of block to clone ??? there are now stem tuplet and keysigs as well - see grob GETFUNC_DEF (note, grob); GETFUNC_DEF (chord, grob); GETFUNC_DEF (standalone, grob); GETFUNC_DEF (standalone, graphic_name); GETFUNC_DEF (chord, graphic_name); GETFUNC_DEF (note, graphic_name); GETFUNC_DEF (clef, graphic_name); GETFUNC_DEF (keysig, graphic_name); GETFUNC_DEF (timesig, graphic_name); GETFUNC_DEF (tuplet, graphic_name); GETFUNC_DEF (staff, grob); GETFUNC_DEF (voice, grob); GETFUNC_DEF (score, grob); // UNUSED: GETFUNC_DEF (movementcontrol, grob); GETFUNC_DEF (clef, grob); GETFUNC_DEF (timesig, grob); GETFUNC_DEF (tuplet, grob); GETFUNC_DEF (stemdirective, grob); GETFUNC_DEF (keysig, grob); PUTFUNC_DEF (note, grob); PUTFUNC_DEF (chord, grob); PUTFUNC_DEF (standalone, grob); // UNUSED: PUTFUNC_DEF(staff, grob) // UNUSED: PUTFUNC_DEF(voice, grob) PUTFUNC_DEF (score, grob); // UNUSED: PUTFUNC_DEF(movementcontrol, grob) PUTFUNC_DEF (clef, grob); PUTFUNC_DEF (timesig, grob); PUTFUNC_DEF (tuplet, grob); PUTFUNC_DEF (stemdirective, grob); PUTFUNC_DEF (keysig, grob); GETFUNC_DEF (note, data); GETFUNC_DEF (chord, data); GETFUNC_DEF (standalone, data); GETFUNC_DEF (staff, data); GETFUNC_DEF (voice, data); GETFUNC_DEF (score, data); GETFUNC_DEF (scoreheader, data); GETFUNC_DEF (header, data); GETFUNC_DEF (paper, data); GETFUNC_DEF (layout, data); GETFUNC_DEF (movementcontrol, data); GETFUNC_DEF (clef, data); GETFUNC_DEF (timesig, data); GETFUNC_DEF (tuplet, data); GETFUNC_DEF (stemdirective, data); GETFUNC_DEF (keysig, data); PUTFUNC_DEF (note, data); PUTFUNC_DEF (chord, data); PUTFUNC_DEF (standalone, data); PUTFUNC_DEF (staff, data); PUTFUNC_DEF (voice, data); PUTFUNC_DEF (score, data); PUTFUNC_DEF (scoreheader, data); PUTFUNC_DEF (header, data); PUTFUNC_DEF (paper, data); PUTFUNC_DEF (layout, data); PUTFUNC_DEF (movementcontrol, data); PUTFUNC_DEF (clef, data); PUTFUNC_DEF (timesig, data); PUTFUNC_DEF (tuplet, data); PUTFUNC_DEF (stemdirective, data); PUTFUNC_DEF (keysig, data); GETFUNC_DEF (note, midibytes); GETFUNC_DEF (chord, midibytes); GETFUNC_DEF (keysig, midibytes); GETFUNC_DEF (timesig, midibytes); GETFUNC_DEF (tuplet, midibytes); GETFUNC_DEF (clef, midibytes); GETFUNC_DEF (standalone, midibytes); GETFUNC_DEF (staff, midibytes); GETFUNC_DEF (voice, midibytes); GETFUNC_DEF (score, midibytes); GETFUNC_DEF (movementcontrol, midibytes); PUTFUNC_DEF (note, midibytes); PUTFUNC_DEF (chord, midibytes); PUTFUNC_DEF (keysig, midibytes); PUTFUNC_DEF (timesig, midibytes); PUTFUNC_DEF (tuplet, midibytes); PUTFUNC_DEF (clef, midibytes); PUTFUNC_DEF (standalone, midibytes); PUTFUNC_DEF (staff, midibytes); PUTFUNC_DEF (voice, midibytes); PUTFUNC_DEF (score, midibytes); PUTFUNC_DEF (movementcontrol, midibytes); GETFUNC_DEF (note, prefix); GETFUNC_DEF (note, postfix); PUTFUNC_DEF (note, prefix); // UNUSED: PUTFUNC_DEF(clef, prefix) PUTFUNC_DEF (note, postfix); GETFUNC_DEF (score, prefix); GETFUNC_DEF (score, postfix); PUTFUNC_DEF (score, prefix); PUTFUNC_DEF (score, postfix); PUTFUNC_DEF (staff, prefix); PUTFUNC_DEF (voice, prefix); GETFUNC_DEF (staff, prefix); GETFUNC_DEF (voice, prefix); PUTFUNC_DEF (staff, postfix); PUTFUNC_DEF (voice, postfix); GETFUNC_DEF (staff, postfix); GETFUNC_DEF (voice, postfix); GETFUNC_DEF (chord, prefix); GETFUNC_DEF (chord, postfix); PUTFUNC_DEF (chord, prefix); PUTFUNC_DEF (chord, postfix); GETFUNC_DEF (standalone, prefix); GETFUNC_DEF (standalone, postfix); PUTFUNC_DEF (standalone, prefix); PUTFUNC_DEF (standalone, postfix); #define ALLOW_PUTFUNC_DEF(what)\ SCM scheme_##what##_directive_put_allow(SCM tag, SCM value) {\ if((!scm_is_string(tag))||(!scm_is_integer(value))){\ return SCM_BOOL(FALSE);\ }\ char *tagname;\ tagname = scm_to_locale_string(tag);\ gint valuename = scm_to_int(value);\ extern gboolean what##_directive_put_allow (gchar *tag, gint value);\ gboolean ret = what##_directive_put_allow ((gchar*)tagname, valuename);\ structural_change_##what ();\ score_status (Denemo.project, TRUE);\ if(tagname) free(tagname);\ return SCM_BOOL(ret);\ } #define IGNORE_PUTFUNC_DEF(what)\ SCM scheme_##what##_directive_put_ignore(SCM tag, SCM value) {\ if((!scm_is_string(tag))||(!scm_is_integer(value))){\ return SCM_BOOL(FALSE);\ }\ char *tagname;\ tagname = scm_to_locale_string(tag);\ gint valuename = scm_to_int(value);\ extern gboolean what##_directive_put_ignore (gchar *tag, gint value);\ gboolean ret = what##_directive_put_ignore ((gchar*)tagname, valuename);\ structural_change_##what ();\ score_status (Denemo.project, TRUE);\ if(tagname) free(tagname);\ return SCM_BOOL(ret);\ } #define INT_PUTFUNC_DEF(what, field)\ SCM scheme_##what##_directive_put_##field(SCM tag, SCM value) {\ if((!scm_is_string(tag))||(!scm_is_integer(value))){\ return SCM_BOOL(FALSE);\ }\ char *tagname;\ tagname = scm_to_locale_string(tag);\ gint valuename = scm_to_int(value);\ extern gboolean what##_directive_put_##field (gchar *tag, gint value);\ gboolean ret = what##_directive_put_##field ((gchar*)tagname, valuename);\ structural_change_##what ();\ score_status (Denemo.project, TRUE);\ if(tagname) free(tagname);\ return SCM_BOOL(ret);\ } #define INT_GETFUNC_DEF(what, field)\ SCM scheme_##what##_directive_get_##field(SCM tag) {\ if(!scm_is_string(tag)){\ return SCM_BOOL(FALSE);\ }\ char *tagname;\ tagname = scm_to_locale_string(tag);\ extern gint what##_directive_get_##field (gchar *tag);\ gint ret = what##_directive_get_##field ((gchar*)tagname);\ if(tagname) free(tagname);\ return scm_from_int(ret);\ } #define PUTGRAPHICFUNC_DEF(what)\ SCM scheme_##what##_directive_put_graphic(SCM tag, SCM value) {\ if((!scm_is_string(tag))||(!scm_is_string(value))){\ return SCM_BOOL(FALSE);\ }\ char *tagname;\ tagname = scm_to_locale_string(tag);\ char *valuename;\ valuename = scm_to_locale_string(value);\ gboolean ret = what##_directive_put_graphic ((gchar*)tagname, (gchar*)valuename);\ structural_change_##what ();\ score_status (Denemo.project, TRUE);\ if(tagname) free(tagname);\ if(valuename) free(valuename);\ return SCM_BOOL(ret);\ } PUTGRAPHICFUNC_DEF (note); PUTGRAPHICFUNC_DEF (chord); PUTGRAPHICFUNC_DEF (standalone); PUTGRAPHICFUNC_DEF (staff); PUTGRAPHICFUNC_DEF (voice); PUTGRAPHICFUNC_DEF (score); // block to copy for new int field in directive INT_PUTFUNC_DEF (note, minpixels); INT_PUTFUNC_DEF (chord, minpixels); INT_PUTFUNC_DEF (standalone, minpixels); INT_PUTFUNC_DEF (staff, minpixels); INT_PUTFUNC_DEF (voice, minpixels); INT_PUTFUNC_DEF (score, minpixels); INT_PUTFUNC_DEF (clef, minpixels); INT_PUTFUNC_DEF (timesig, minpixels); INT_PUTFUNC_DEF (tuplet, minpixels); INT_PUTFUNC_DEF (stemdirective, minpixels); INT_PUTFUNC_DEF (keysig, minpixels); INT_PUTFUNC_DEF (scoreheader, minpixels); INT_PUTFUNC_DEF (header, minpixels); INT_PUTFUNC_DEF (paper, minpixels); INT_PUTFUNC_DEF (layout, minpixels); INT_PUTFUNC_DEF (movementcontrol, minpixels); INT_GETFUNC_DEF (note, minpixels); INT_GETFUNC_DEF (chord, minpixels); INT_GETFUNC_DEF (standalone, minpixels); INT_GETFUNC_DEF (staff, minpixels); INT_GETFUNC_DEF (voice, minpixels); INT_GETFUNC_DEF (score, minpixels); INT_GETFUNC_DEF (clef, minpixels); INT_GETFUNC_DEF (timesig, minpixels); INT_GETFUNC_DEF (tuplet, minpixels); INT_GETFUNC_DEF (stemdirective, minpixels); INT_GETFUNC_DEF (keysig, minpixels); INT_GETFUNC_DEF (scoreheader, minpixels); INT_GETFUNC_DEF (header, minpixels); INT_GETFUNC_DEF (paper, minpixels); INT_GETFUNC_DEF (layout, minpixels); INT_GETFUNC_DEF (movementcontrol, minpixels); // end block to ocpy for new int field in directive INT_PUTFUNC_DEF (note, override); INT_PUTFUNC_DEF (chord, override); INT_PUTFUNC_DEF (standalone, override); INT_PUTFUNC_DEF (staff, override); INT_PUTFUNC_DEF (voice, override); INT_PUTFUNC_DEF (score, override); INT_GETFUNC_DEF (note, override); INT_GETFUNC_DEF (chord, override); INT_GETFUNC_DEF (standalone, override); INT_GETFUNC_DEF (staff, override); INT_GETFUNC_DEF (voice, override); INT_GETFUNC_DEF (score, override); IGNORE_PUTFUNC_DEF (note); IGNORE_PUTFUNC_DEF (chord); IGNORE_PUTFUNC_DEF (standalone); IGNORE_PUTFUNC_DEF (staff); IGNORE_PUTFUNC_DEF (voice); // UNUSED: INT_PUTFUNC_DEF (standalone) // UNUSED: INT_GETFUNC_DEF (note) // UNUSED: INT_GETFUNC_DEF (chord) // UNUSED: INT_GETFUNC_DEF (standalone) ALLOW_PUTFUNC_DEF (note); ALLOW_PUTFUNC_DEF (chord); ALLOW_PUTFUNC_DEF (standalone); ALLOW_PUTFUNC_DEF (staff); ALLOW_PUTFUNC_DEF (voice); // UNUSED: INT_GETFUNC_DEF (note) // UNUSED: INT_GETFUNC_DEF (chord) // UNUSED: INT_GETFUNC_DEF (standalone) INT_PUTFUNC_DEF (note, ty); INT_PUTFUNC_DEF (chord, ty); INT_PUTFUNC_DEF (standalone, ty); INT_GETFUNC_DEF (note, ty); INT_GETFUNC_DEF (chord, ty); INT_GETFUNC_DEF (standalone, ty); INT_PUTFUNC_DEF (note, tx); INT_PUTFUNC_DEF (chord, tx); INT_PUTFUNC_DEF (standalone, tx); INT_GETFUNC_DEF (note, tx); INT_GETFUNC_DEF (chord, tx); INT_GETFUNC_DEF (standalone, tx); INT_PUTFUNC_DEF (note, gy); INT_PUTFUNC_DEF (chord, gy); INT_PUTFUNC_DEF (standalone, gy); INT_GETFUNC_DEF (note, gy); INT_GETFUNC_DEF (chord, gy); INT_GETFUNC_DEF (standalone, gy); INT_PUTFUNC_DEF (note, gx); INT_PUTFUNC_DEF (chord, gx); INT_PUTFUNC_DEF (standalone, gx); INT_GETFUNC_DEF (note, gx); INT_GETFUNC_DEF (chord, gx); INT_GETFUNC_DEF (standalone, gx); INT_GETFUNC_DEF (note, width); INT_GETFUNC_DEF (chord, width); INT_GETFUNC_DEF (standalone, width); INT_GETFUNC_DEF (note, height); INT_GETFUNC_DEF (chord, height); INT_GETFUNC_DEF (standalone, height); INT_GETFUNC_DEF (score, tx); INT_GETFUNC_DEF (score, ty); INT_GETFUNC_DEF (score, gx); INT_GETFUNC_DEF (score, gy); INT_GETFUNC_DEF (score, width); INT_GETFUNC_DEF (score, height); ALLOW_PUTFUNC_DEF (score); IGNORE_PUTFUNC_DEF (score); INT_PUTFUNC_DEF (score, tx); INT_PUTFUNC_DEF (score, ty); INT_PUTFUNC_DEF (score, gx); INT_PUTFUNC_DEF (score, gy); INT_GETFUNC_DEF (object, minpixels); INT_PUTFUNC_DEF (object, minpixels); DELETE_FN_DEF (object); // block to copy for new type of directive, !!minpixels is done in block to copy for new fields!! GETFUNC_DEF (clef, prefix) GETFUNC_DEF (clef, postfix) GETFUNC_DEF (clef, display) PUTFUNC_DEF (clef, prefix) PUTFUNC_DEF (clef, postfix) PUTFUNC_DEF (clef, display) PUTGRAPHICFUNC_DEF (clef); ALLOW_PUTFUNC_DEF (clef); IGNORE_PUTFUNC_DEF (clef); INT_PUTFUNC_DEF (clef, tx); INT_PUTFUNC_DEF (clef, ty); INT_PUTFUNC_DEF (clef, gx); INT_PUTFUNC_DEF (clef, gy); INT_PUTFUNC_DEF (clef, override); INT_GETFUNC_DEF (clef, tx); INT_GETFUNC_DEF (clef, ty); INT_GETFUNC_DEF (clef, gx); INT_GETFUNC_DEF (clef, gy); INT_GETFUNC_DEF (clef, override); INT_GETFUNC_DEF (clef, width); INT_GETFUNC_DEF (clef, height); EDIT_DELETE_FN_DEF (clef); // end block GETFUNC_DEF (timesig, prefix) GETFUNC_DEF (timesig, postfix) GETFUNC_DEF (timesig, display) PUTFUNC_DEF (timesig, prefix) PUTFUNC_DEF (timesig, postfix) PUTFUNC_DEF (timesig, display) PUTGRAPHICFUNC_DEF (timesig); ALLOW_PUTFUNC_DEF (timesig); IGNORE_PUTFUNC_DEF (timesig); INT_PUTFUNC_DEF (timesig, tx); INT_PUTFUNC_DEF (timesig, ty); INT_PUTFUNC_DEF (timesig, gx); INT_PUTFUNC_DEF (timesig, gy); INT_PUTFUNC_DEF (timesig, override); INT_GETFUNC_DEF (timesig, tx); INT_GETFUNC_DEF (timesig, ty); INT_GETFUNC_DEF (timesig, gx); INT_GETFUNC_DEF (timesig, gy); INT_GETFUNC_DEF (timesig, override); INT_GETFUNC_DEF (timesig, width); INT_GETFUNC_DEF (timesig, height); EDIT_DELETE_FN_DEF (timesig); GETFUNC_DEF (tuplet, prefix); GETFUNC_DEF (tuplet, postfix); GETFUNC_DEF (tuplet, display); PUTFUNC_DEF (tuplet, prefix); PUTFUNC_DEF (tuplet, postfix); PUTFUNC_DEF (tuplet, display); PUTGRAPHICFUNC_DEF (tuplet); ALLOW_PUTFUNC_DEF (tuplet); IGNORE_PUTFUNC_DEF (tuplet); INT_PUTFUNC_DEF (tuplet, tx); INT_PUTFUNC_DEF (tuplet, ty); INT_PUTFUNC_DEF (tuplet, gx); INT_PUTFUNC_DEF (tuplet, gy); INT_PUTFUNC_DEF (tuplet, override); INT_GETFUNC_DEF (tuplet, tx); INT_GETFUNC_DEF (tuplet, ty); INT_GETFUNC_DEF (tuplet, gx); INT_GETFUNC_DEF (tuplet, gy); INT_GETFUNC_DEF (tuplet, override); INT_GETFUNC_DEF (tuplet, width); INT_GETFUNC_DEF (tuplet, height); EDIT_DELETE_FN_DEF (tuplet); GETFUNC_DEF (stemdirective, prefix); GETFUNC_DEF (stemdirective, postfix); GETFUNC_DEF (stemdirective, display); PUTFUNC_DEF (stemdirective, prefix); PUTFUNC_DEF (stemdirective, postfix); PUTFUNC_DEF (stemdirective, display); PUTGRAPHICFUNC_DEF (stemdirective); ALLOW_PUTFUNC_DEF (stemdirective); IGNORE_PUTFUNC_DEF (stemdirective); INT_PUTFUNC_DEF (stemdirective, tx); INT_PUTFUNC_DEF (stemdirective, ty); INT_PUTFUNC_DEF (stemdirective, gx); INT_PUTFUNC_DEF (stemdirective, gy); INT_PUTFUNC_DEF (stemdirective, override); INT_GETFUNC_DEF (stemdirective, tx); INT_GETFUNC_DEF (stemdirective, ty); INT_GETFUNC_DEF (stemdirective, gx); INT_GETFUNC_DEF (stemdirective, gy); INT_GETFUNC_DEF (stemdirective, override); INT_GETFUNC_DEF (stemdirective, width); INT_GETFUNC_DEF (stemdirective, height); EDIT_DELETE_FN_DEF (stemdirective); GETFUNC_DEF (keysig, prefix); GETFUNC_DEF (keysig, postfix); GETFUNC_DEF (keysig, display); PUTFUNC_DEF (keysig, prefix); PUTFUNC_DEF (keysig, postfix); PUTFUNC_DEF (keysig, display); PUTGRAPHICFUNC_DEF (keysig); ALLOW_PUTFUNC_DEF (keysig); IGNORE_PUTFUNC_DEF (keysig); INT_PUTFUNC_DEF (keysig, tx); INT_PUTFUNC_DEF (keysig, ty); INT_PUTFUNC_DEF (keysig, gx); INT_PUTFUNC_DEF (keysig, gy); INT_PUTFUNC_DEF (keysig, override); INT_GETFUNC_DEF (keysig, tx); INT_GETFUNC_DEF (keysig, ty); INT_GETFUNC_DEF (keysig, gx); INT_GETFUNC_DEF (keysig, gy); INT_GETFUNC_DEF (keysig, override); INT_GETFUNC_DEF (keysig, width); INT_GETFUNC_DEF (keysig, height); EDIT_DELETE_FN_DEF (keysig); GETFUNC_DEF (scoreheader, prefix); GETFUNC_DEF (scoreheader, postfix); GETFUNC_DEF (scoreheader, display); PUTFUNC_DEF (scoreheader, prefix); PUTFUNC_DEF (scoreheader, postfix); PUTFUNC_DEF (scoreheader, display); PUTGRAPHICFUNC_DEF (scoreheader); ALLOW_PUTFUNC_DEF (scoreheader); IGNORE_PUTFUNC_DEF (scoreheader); INT_PUTFUNC_DEF (scoreheader, tx); INT_PUTFUNC_DEF (scoreheader, ty); INT_PUTFUNC_DEF (scoreheader, gx); INT_PUTFUNC_DEF (scoreheader, gy); INT_PUTFUNC_DEF (scoreheader, override); INT_GETFUNC_DEF (scoreheader, tx); INT_GETFUNC_DEF (scoreheader, ty); INT_GETFUNC_DEF (scoreheader, gx); INT_GETFUNC_DEF (scoreheader, gy); INT_GETFUNC_DEF (scoreheader, override); INT_GETFUNC_DEF (scoreheader, width); INT_GETFUNC_DEF (scoreheader, height); EDIT_DELETE_FN_DEF (scoreheader); GETFUNC_DEF (header, prefix); GETFUNC_DEF (header, postfix); GETFUNC_DEF (header, display); PUTFUNC_DEF (header, prefix); PUTFUNC_DEF (header, postfix); PUTFUNC_DEF (header, display); PUTGRAPHICFUNC_DEF (header); ALLOW_PUTFUNC_DEF (header); IGNORE_PUTFUNC_DEF (header); INT_PUTFUNC_DEF (header, tx); INT_PUTFUNC_DEF (header, ty); INT_PUTFUNC_DEF (header, gx); INT_PUTFUNC_DEF (header, gy); INT_PUTFUNC_DEF (header, override); INT_GETFUNC_DEF (header, tx); INT_GETFUNC_DEF (header, ty); INT_GETFUNC_DEF (header, gx); INT_GETFUNC_DEF (header, gy); INT_GETFUNC_DEF (header, override); INT_GETFUNC_DEF (header, width); INT_GETFUNC_DEF (header, height); EDIT_DELETE_FN_DEF (header); GETFUNC_DEF (paper, prefix); GETFUNC_DEF (paper, postfix); GETFUNC_DEF (paper, display); PUTFUNC_DEF (paper, prefix); PUTFUNC_DEF (paper, postfix); PUTFUNC_DEF (paper, display); PUTGRAPHICFUNC_DEF (paper); ALLOW_PUTFUNC_DEF (paper); IGNORE_PUTFUNC_DEF (paper); INT_PUTFUNC_DEF (paper, tx); INT_PUTFUNC_DEF (paper, ty); INT_PUTFUNC_DEF (paper, gx); INT_PUTFUNC_DEF (paper, gy); INT_PUTFUNC_DEF (paper, override); INT_GETFUNC_DEF (paper, tx); INT_GETFUNC_DEF (paper, ty); INT_GETFUNC_DEF (paper, gx); INT_GETFUNC_DEF (paper, gy); INT_GETFUNC_DEF (paper, override); INT_GETFUNC_DEF (paper, width); INT_GETFUNC_DEF (paper, height); EDIT_DELETE_FN_DEF (paper); GETFUNC_DEF (layout, prefix); GETFUNC_DEF (layout, postfix); GETFUNC_DEF (layout, display); PUTFUNC_DEF (layout, prefix); PUTFUNC_DEF (layout, postfix); PUTFUNC_DEF (layout, display); PUTGRAPHICFUNC_DEF (layout); ALLOW_PUTFUNC_DEF (layout); IGNORE_PUTFUNC_DEF (layout); INT_PUTFUNC_DEF (layout, tx); INT_PUTFUNC_DEF (layout, ty); INT_PUTFUNC_DEF (layout, gx); INT_PUTFUNC_DEF (layout, gy); INT_PUTFUNC_DEF (layout, override); INT_GETFUNC_DEF (layout, tx); INT_GETFUNC_DEF (layout, ty); INT_GETFUNC_DEF (layout, gx); INT_GETFUNC_DEF (layout, gy); INT_GETFUNC_DEF (layout, override); INT_GETFUNC_DEF (layout, width); INT_GETFUNC_DEF (layout, height); EDIT_DELETE_FN_DEF (layout); GETFUNC_DEF (movementcontrol, prefix); GETFUNC_DEF (movementcontrol, postfix); PUTFUNC_DEF (movementcontrol, prefix); PUTFUNC_DEF (movementcontrol, postfix); PUTGRAPHICFUNC_DEF (movementcontrol); ALLOW_PUTFUNC_DEF (movementcontrol); IGNORE_PUTFUNC_DEF (movementcontrol); INT_PUTFUNC_DEF (movementcontrol, tx); INT_PUTFUNC_DEF (movementcontrol, ty); INT_PUTFUNC_DEF (movementcontrol, gx); INT_PUTFUNC_DEF (movementcontrol, gy); INT_PUTFUNC_DEF (movementcontrol, override); INT_GETFUNC_DEF (movementcontrol, tx); INT_GETFUNC_DEF (movementcontrol, ty); INT_GETFUNC_DEF (movementcontrol, gx); INT_GETFUNC_DEF (movementcontrol, gy); INT_GETFUNC_DEF (movementcontrol, override); INT_GETFUNC_DEF (movementcontrol, width); INT_GETFUNC_DEF (movementcontrol, height); EDIT_DELETE_FN_DEF (movementcontrol); SCM scheme_put_text_clipboard (SCM optional) { size_t length; char *str = NULL; if (scm_is_string (optional)) { str = scm_to_locale_stringn (optional, &length); GtkClipboard *clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD); gtk_clipboard_set_text (clipboard, str, length); if (str) free (str); return SCM_BOOL (TRUE); } return SCM_BOOL (FALSE); } SCM scheme_get_username (void) { return scm_from_locale_string (Denemo.prefs.username->str); } SCM scheme_get_password (void) { return scm_from_locale_string (Denemo.prefs.password->str); } SCM scheme_set_midi_capture (SCM setting) { gboolean prev; prev = set_midi_capture ((setting != SCM_BOOL_F)); return prev ? SCM_BOOL_T : SCM_BOOL_F; } SCM scheme_virtual_keyboard (SCM octaves) { gint num = 6; if (scm_is_integer (octaves)) { num = scm_to_int (octaves); } create_virtual_keyboard (num); return SCM_BOOL_T; } SCM scheme_get_keyboard_state (void) { return scm_from_int (Denemo.keyboard_state); } SCM scheme_set_midi_thru (SCM set) // see also d-MidiInListening this doesn't lock the state against keyboard changes { SCM ret = scm_from_int (Denemo.keyboard_state); if (scm_is_true (set)) Denemo.keyboard_state = GDK_SHIFT_MASK; else Denemo.keyboard_state = 0; set_midi_in_status (); return ret; } SCM scheme_get_recorded_midi_on_tick (void) { smf_track_t *track = Denemo.project->movement->recorded_midi_track; if (track) { #define MIDI_NOTEOFF 0x80 #define MIDI_NOTEON 0x90 smf_event_t *event = smf_track_get_next_event (track); if (event) switch (event->midi_buffer[0] & 0xF0) { case MIDI_NOTEON: return scm_from_int (event->time_pulses); case MIDI_NOTEOFF: return scm_from_int (-event->time_pulses); default: return SCM_BOOL_F; } } return SCM_BOOL_F; } SCM scheme_get_recorded_midi_note (void) { smf_track_t *track = Denemo.project->movement->recorded_midi_track; if (track) { smf_event_t *event = NULL; if (track->next_event_number > 0 && (track->next_event_number <= track->events_array->len)) event = g_ptr_array_index (track->events_array, track->next_event_number - 1); if (event) switch (event->midi_buffer[0] & 0xF0) { case MIDI_NOTEON: case MIDI_NOTEOFF: return scm_from_int (event->midi_buffer[1]); default: return SCM_BOOL_F; } } return SCM_BOOL_F; } SCM scheme_rewind_recorded_midi (void) { smf_track_t *track = Denemo.project->movement->recorded_midi_track; if (track) { if (track->smf == NULL) { if (Denemo.project->movement->smf) { smf_add_track (Denemo.project->movement->smf, track); smf_rewind (Denemo.project->movement->smf); } else return SCM_BOOL_F; } smf_rewind (track->smf); return SCM_BOOL_T; } return SCM_BOOL_F; } SCM scheme_get_note_for_midi_key (SCM scm) { gint notenum = 0, offset, enshift, octave; if (scm_is_integer (scm)) notenum = scm_to_int (scm); if (notenum > 0 && notenum < 256) { notenum2enharmonic (notenum, &offset, &enshift, &octave); gchar *name = mid_c_offsettolily (offset + 7 * octave, enshift); return scm_from_locale_string (name); } return SCM_BOOL_F; } SCM scheme_get_midi (SCM bytes) { gint midi; SCM scm; gboolean success = intercept_midi_event (&midi); if (scm_is_false (bytes)) { if (!success) scm = SCM_BOOL_F; else { Denemo.project->last_source = INPUTMIDI; scm = scm_list_n (scm_from_int (midi & 0xFF), scm_from_int ((midi >> 8) & 0xFF), scm_from_int ((midi >> 16) & 0xFF), scm_from_int (midi >> 24), SCM_UNDEFINED); } } else { if (!success) midi = 0; /* scripts should detect this impossible value and take action */ else Denemo.project->last_source = INPUTMIDI; gchar *buf = (gchar *) & midi; *buf &= 0xF0; //do not return channel info scm = scm_from_int (midi); } return scm; } //Simulates a midi event, with no capture by any calling scheme script unless midi==0 SCM scheme_put_midi (SCM scm) { gchar buf[3]; gint midi; if (scm_is_list (scm)) { buf[0] = scm_to_int (scm_list_ref (scm, scm_from_int (0))); buf[1] = scm_to_int (scm_list_ref (scm, scm_from_int (1))); buf[2] = scm_to_int (scm_list_ref (scm, scm_from_int (2))); midi = TRUE; } else { midi = scm_to_int (scm); buf[0] = midi & 0xFF; buf[1] = (midi >> 8) & 0xFF; buf[2] = (midi >> 16) & 0xFF; } //g_debug("got %x\nbreaks as %x %x %x\n", midi&0xFFFFFF, buf[0], buf[1], buf[2]); if (midi) { gboolean capture = set_midi_capture (FALSE); //Turn off any capturing process_midi_event (buf); set_midi_capture (capture); //Restore any capturing that might be on } else process_midi_event (buf); return SCM_BOOL (TRUE); } SCM scheme_output_midi (SCM scm) { gchar buf[3]; if (scm_is_list (scm)) { buf[0] = scm_to_int (scm_list_ref (scm, scm_from_int (0))); buf[1] = scm_to_int (scm_list_ref (scm, scm_from_int (1))); buf[2] = scm_to_int (scm_list_ref (scm, scm_from_int (2))); } else { gint midi = scm_to_int (scm); buf[0] = midi & 0xFF; buf[1] = (midi >> 8) & 0xFF; buf[2] = (midi >> 16) & 0xFF; } play_adjusted_midi_event (buf); return SCM_BOOL_T; } /* outputs a midibytes string to MIDI out. Format of midibytes as in DenemoDirective->midibytes */ SCM scheme_output_midi_bytes (SCM input) { char *next; gint i, numbytes; gint channel; gint volume; if (!scm_is_string (input)) { return SCM_BOOL_F; } DenemoStaff *curstaffstruct = (DenemoStaff *) Denemo.project->movement->currentstaff->data; channel = get_midi_channel (curstaffstruct); volume = curstaffstruct->volume; char *string_input; string_input = scm_to_locale_string (input); gchar *bytes = substitute_midi_values (string_input, channel, volume); for (i = 0, next = bytes; *next; next++) { i++; if (*next == 0) break; } numbytes = i; unsigned char *buffer = (unsigned char *) g_malloc0 (numbytes); for (i = 0, next = bytes; i < numbytes; i++, next++) buffer[i] = (unsigned char) strtol (next, &next, 0); g_free (bytes); //g_debug("\nbuffer[0] = %x buffer[1] = %x buffer[2] = %x\n", buffer[0], buffer[1], buffer[2]); play_midi_event (DEFAULT_BACKEND, curstaffstruct->midi_port, buffer); if (string_input) free (string_input); return SCM_BOOL (TRUE); } SCM scheme_create_timebase (SCM optional) { DenemoMovement *si = Denemo.project->movement; if (si->smfsync != si->changecount) { exportmidi (NULL, si); return SCM_BOOL_T; } return SCM_BOOL_F; } SCM scheme_pending_midi (SCM scm) { if (scm_is_integer (scm)) { guint key = scm_to_int (scm); g_queue_push_head (Denemo.project->pending_midi, GINT_TO_POINTER (key)); return SCM_BOOL_T; } else return SCM_BOOL_F; } SCM scheme_play_midi_note (SCM note, SCM volume, SCM channel, SCM duration) { guint vol = scm_to_int (volume); gint key = scm_to_int (note); gint chan = scm_to_int (channel); gint dur = scm_to_int (duration); //g_debug("Playing %x at %f volume, %d channel for %dms\n", key, vol/255.0, channel, dur); play_note (DEFAULT_BACKEND, 0 /*port */ , chan, key, dur, vol); return SCM_BOOL (TRUE); } SCM scheme_play_midikey (SCM scm) { guint midi = scm_to_int (scm); gint key = (midi >> 8) & 0xFF; gint channel = midi & 0xF; gint volume = ((midi >> 16) & 0x7F); //g_debug("Playing %x at %f volume, %d channel\n", key, (double)volume, channel); play_note (DEFAULT_BACKEND, 0 /*port */ , channel, key, 1000 /*duration */ , volume); //g_usleep(200000); return SCM_BOOL (TRUE); } //Insert a rest without setting the prevailing duration SCM scheme_put_rest (SCM optional_duration) { gint duration; if (scm_is_integer (optional_duration)) { duration = scm_to_int (optional_duration); } else { duration = get_prevailing_duration (); } if ((duration < 0) || (duration > 7)) return SCM_BOOL_F; //FIXME should not allow spillover? dnm_insertnote (Denemo.project, duration, 0, TRUE); displayhelper (Denemo.project); //without this a call to d-AddVoice causes a crash as the chord length info has not been updated return SCM_BOOL_T; } //Insert a note without setting the prevailing duration SCM scheme_put_note (SCM optional_duration) { gint duration; if (scm_is_integer (optional_duration)) { duration = scm_to_int (optional_duration); } else { duration = get_prevailing_duration (); } if ((duration < 0) || (duration > 7)) return SCM_BOOL_F; gboolean spill = Denemo.prefs.spillover; gint mode = Denemo.project->mode; Denemo.project->mode = 0; Denemo.prefs.spillover = 0; if (scm_is_false (optional_duration)) dnm_insertnote (Denemo.project, duration, INPUTNORMAL | INPUTBLANK, FALSE); //pass #f for nonprinting note else dnm_insertnote (Denemo.project, duration, INPUTNORMAL, FALSE); Denemo.project->mode = mode; Denemo.prefs.spillover = spill; displayhelper (Denemo.project); //without this a call to d-AddVoice causes a crash as the chord length info has not been updated return SCM_BOOL_T; } //Insert a chord at the cursor notes contains space separated lilypond note names SCM scheme_insert_chord (SCM notes, SCM duration) { GList *thenotes = NULL; gint theduration; if (scm_is_integer (duration)) theduration = scm_to_int (duration); else theduration = get_prevailing_duration (); if (scm_is_string (notes)) { gchar *notestring = scm_to_locale_string (notes); gchar *thenote = strtok (notestring, " "); while (thenote) { struct twoints *data = (struct twoints *)g_malloc (sizeof (struct twoints)); interpret_lilypond_notename (thenote, &data->a, &data->b); thenotes = g_list_prepend (thenotes, data); thenote = strtok (NULL, " "); } insert_chord (thenotes, theduration); return SCM_BOOL_T; } return SCM_BOOL_F; } //Insert a rest in the given (or prevailing duration) and set the prevailing duration SCM scheme_insert_rest (SCM optional) { SCM ret = scheme_put_rest (optional); if (scm_is_integer (optional)) { gint duration = scm_to_int (optional); highlight_duration (Denemo.project, duration); } return ret; } SCM scheme_toggle_playalong (void) { pb_playalong (get_playalong_button ()); return SCM_BOOL (Denemo.project->midi_destination & MIDIPLAYALONG); } SCM scheme_toggle_conduct (void) { pb_conduct (get_conduct_button ()); return SCM_BOOL (Denemo.project->midi_destination & MIDICONDUCT); } SCM scheme_playalong_active (void) { return SCM_BOOL (Denemo.project->midi_destination & MIDIPLAYALONG); } SCM scheme_midi_record (void) { toggle_midi_record (); return SCM_BOOL (Denemo.project->midi_destination & MIDIRECORD); } SCM scheme_synchronize_recording (void) { DenemoProject *gui = Denemo.project; DenemoMovement *si = gui->movement; if (si->recording && (si->recording->type == DENEMO_RECORDING_MIDI) && si->recording->marked_onset) { synchronize_recording (); return SCM_BOOL_T; } return SCM_BOOL_F; } SCM scheme_reposition_recorded_midi (SCM secs_from_end) { DenemoProject *gui = Denemo.project; DenemoMovement *si = gui->movement; if (scm_is_real (secs_from_end) && si->recording && (si->recording->type == DENEMO_RECORDING_MIDI)) { GList *g = g_list_last (si->recording->notes); gint time = ((DenemoRecordedNote*)g->data)->timing; gint interval = scm_to_double (secs_from_end) * si->recording->samplerate; for (;g;g=g->prev) { DenemoRecordedNote *thenote = (DenemoRecordedNote*)g->data; if (((thenote->midi_event[0]&0xF0)==MIDI_NOTE_ON) && (time - thenote->timing) >= interval) { si->recording->marked_onset = g; Denemo.project->movement->recording->sync = NULL;//g_print ("secs from end %0.2f recording end time %0.2f, this note %0.2f \n", scm_to_double (secs_from_end), time/44100.0, thenote->timing/44100.0); call_out_to_guile ("(d-SyncRecordingToCursor)");// syncs and extends MIDI track return SCM_BOOL_T; } } } return SCM_BOOL_F; } SCM scheme_recording_midi (void) { return SCM_BOOL (Denemo.project->midi_destination & MIDIRECORD); } SCM scheme_compute_midi_note_durations (void) { return SCM_BOOL (compute_midi_note_durations ()); } SCM scheme_get_marked_midi_note_as_lilypond (void) { SCM scm = SCM_BOOL_F; DenemoProject *gui = Denemo.project; DenemoMovement *si = gui->movement; if (si->recording && (si->recording->type == DENEMO_RECORDING_MIDI) && si->recording->marked_onset) { GList *marked = si->recording->marked_onset; DenemoRecordedNote *thenote = (DenemoRecordedNote *) marked->data; gchar *name = mid_c_offsettolily (thenote->mid_c_offset, thenote->enshift); gchar *str = g_strdup_printf ("%s", mid_c_offsettolily (thenote->mid_c_offset + 7 * thenote->octave, thenote->enshift)); scm = scm_from_locale_string (str); } return scm; } SCM scheme_get_marked_midi_note (void) { SCM scm = SCM_BOOL_F; DenemoProject *gui = Denemo.project; DenemoMovement *si = gui->movement; if (si->recording && (si->recording->type == DENEMO_RECORDING_MIDI) && si->recording->marked_onset) { GList *g; int i; for (i=0, g = si->recording->notes; g; g= g->next) { DenemoRecordedNote *thenote = (DenemoRecordedNote *) g->data; if ((thenote->midi_event[0]&0xF0)!=MIDI_NOTE_ON) continue; i++; if (si->recording->marked_onset == g) break; } scm = scm_from_int (i); } return scm; } SCM scheme_set_marked_midi_note (SCM pos) { SCM scm = SCM_BOOL_F; DenemoProject *gui = Denemo.project; DenemoMovement *si = gui->movement; if (scm_is_integer (pos) && si->recording && (si->recording->type == DENEMO_RECORDING_MIDI) && si->recording->notes) { gint i; GList *g; gint val = scm_to_int (pos); if (val==0) //pos 0 means unset marked midi { si->recording->marked_onset = NULL; return SCM_BOOL_F; } //val--; //pos starts at 1 (or -1 for last) if (val>0) for (i=0, g = si->recording->notes; g; g= g->next) { DenemoRecordedNote *thenote = (DenemoRecordedNote *) g->data; if ((thenote->midi_event[0]&0xF0)!=MIDI_NOTE_ON) continue; i++; if (i == val) { si->recording->marked_onset = g; break; } } else si->recording->marked_onset = g_list_last (si->recording->notes); if (si->recording->marked_onset) { DenemoRecordedNote *thenote; while (1) { thenote = (DenemoRecordedNote *) si->recording->marked_onset->data; if (thenote && ((thenote->midi_event[0]&0xF0)!=MIDI_NOTE_ON)) { si->recording->marked_onset = si->recording->marked_onset->prev; if (si->recording->marked_onset) continue; else break; } else break; } scm = scm_from_bool (si->recording->marked_onset != NULL); } } return scm; } SCM scheme_get_marked_midi_note_seconds (void) { SCM scm = SCM_BOOL_F; DenemoProject *gui = Denemo.project; DenemoMovement *si = gui->movement; if (si->recording && (si->recording->type == DENEMO_RECORDING_MIDI) && si->recording->marked_onset) { GList *marked = si->recording->marked_onset; DenemoRecordedNote *thenote = (DenemoRecordedNote *) marked->data; gdouble seconds = thenote->timing / ((gdouble) si->recording->samplerate); scm = scm_from_double (seconds); } return scm; } SCM scheme_get_midi_recording_duration (void) { SCM scm = SCM_BOOL_F; DenemoProject *gui = Denemo.project; DenemoMovement *si = gui->movement; if (si->recording && (si->recording->type == DENEMO_RECORDING_MIDI) && si->recording->notes) { GList *last = g_list_last(si->recording->notes); DenemoRecordedNote *thenote = (DenemoRecordedNote *) last->data;//this should be a note off event, unless someone stops recording while holding down a note. gdouble seconds = thenote->timing / ((gdouble) si->recording->samplerate); thenote = (DenemoRecordedNote *)si->recording->notes->data; seconds -= thenote->timing / ((gdouble) si->recording->samplerate); scm = scm_from_double (seconds); } return scm; } SCM scheme_midi_recording_offset (SCM leadin) { SCM scm = SCM_BOOL_F; DenemoProject *gui = Denemo.project; DenemoMovement *si = gui->movement; if (si->recording && (si->recording->type == DENEMO_RECORDING_MIDI)) { gint offset; if (scm_is_integer (leadin)) { offset = scm_to_int (leadin); si->recording->leadin = offset; } else if (scm_is_real (leadin)) { double val = scm_to_double (leadin); offset = (int) (val + 0.5); si->recording->leadin = offset; } scm = scm_from_int (si->recording->leadin); } return scm; } SCM scheme_delete_last_recorded_note (void) { DenemoProject *gui = Denemo.project; DenemoMovement *si = gui->movement; if (si->recording && (si->recording->type == DENEMO_RECORDING_MIDI) && si->recording->notes) { delete_last_recorded_note (); return SCM_BOOL_T; } return SCM_BOOL_F; } SCM scheme_play_marked_midi (void) { DenemoProject *gui = Denemo.project; DenemoMovement *si = gui->movement; if (si->recording && (si->recording->type == DENEMO_RECORDING_MIDI) && si->recording->marked_onset) { GList *marked = si->recording->marked_onset; DenemoStaff *curstaffstruct = (DenemoStaff *) Denemo.project->movement->currentstaff->data; DenemoRecordedNote *thenote = (DenemoRecordedNote *) marked->data; play_note (DEFAULT_BACKEND, 0 /*port */ , curstaffstruct->midi_channel, thenote->midi_event[1], 200, 127); return SCM_BOOL_T; } return SCM_BOOL_F; } SCM scheme_toggle_play_recorded_midi (void) { DenemoProject *gui = Denemo.project; DenemoMovement *si = gui->movement; if (si->recording && (si->recording->type == DENEMO_RECORDING_MIDI)) { play_recorded_midi (); return SCM_BOOL_T; } return SCM_BOOL_F; } SCM scheme_advance_marked_midi (SCM advance) { SCM scm = SCM_BOOL_F; DenemoProject *gui = Denemo.project; DenemoMovement *si = gui->movement; if (si->recording && (si->recording->type == DENEMO_RECORDING_MIDI)) { gint i; if (scm_is_false (advance)) { si->recording->marked_onset = NULL; return SCM_BOOL_T; } if (SCM_UNBNDP (advance)) i = 1; if (scm_is_integer (advance)) { i = scm_to_int (advance); advance_marked_midi (i); } if (si->recording->marked_onset) scm = SCM_BOOL_T; } return scm; } SCM scheme_insert_marked_midi_note (void) { return SCM_BOOL (insert_marked_midi_note ()); } typedef struct cb_scheme_and_id { char *scheme_code; gint timeout_id; gint id; } cb_scheme_and_id; static gboolean scheme_callback_one_shot_timer (cb_scheme_and_id * scheme) { char *scheme_code = scheme->scheme_code; if (scheme->id == Denemo.project->id) call_out_to_guile (scheme_code); else g_warning ("Timer missed for gui %d", scheme->id); g_free (scheme); free (scheme_code); return FALSE; } SCM scheme_one_shot_timer (SCM duration_amount, SCM callback) { char *scheme_code; scheme_code = scm_to_locale_string (callback); gint duration = scm_to_int (duration_amount); cb_scheme_and_id *scheme = g_malloc (sizeof (cb_scheme_and_id)); scheme->scheme_code = scheme_code; scheme->id = Denemo.project->id; g_timeout_add (duration, (GSourceFunc) scheme_callback_one_shot_timer, GINT_TO_POINTER (scheme)); return SCM_BOOL (TRUE); } GList *killed_timers = NULL;//a list of timers scheduled to be killed next time they are called static gboolean scheme_callback_timer (cb_scheme_and_id * scheme) { if (g_list_index (killed_timers, GUINT_TO_POINTER(scheme->timeout_id))>=0) { killed_timers = g_list_remove (killed_timers, GUINT_TO_POINTER(scheme->timeout_id)); free (scheme->scheme_code); g_free (scheme); return FALSE; //kill the timer } char *scheme_code = scheme->scheme_code; if (scheme->id == Denemo.project->id) call_out_to_guile (scheme_code); else g_warning ("Timer missed for gui %d", scheme->id); return TRUE; //continue to call } SCM scheme_timer (SCM duration_amount, SCM callback) { char *scheme_code; if (scm_is_string (callback)) { scheme_code = scm_to_locale_string (callback); gint duration = scm_to_int (duration_amount); //g_debug("setting timer for %s after %d ms", scheme_code, duration); cb_scheme_and_id *scheme = g_malloc (sizeof (cb_scheme_and_id)); scheme->scheme_code = scheme_code; scheme->id = Denemo.project->id; gint id = g_timeout_add (duration, (GSourceFunc) scheme_callback_timer, GINT_TO_POINTER (scheme)); scheme->timeout_id = id; return scm_from_int (id); } else return SCM_BOOL_F; } SCM scheme_kill_timer (SCM id) { if (scm_is_integer (id)) { gint timeout_id = scm_to_int (id); if (timeout_id) { //g_source_remove (scheme);g_print ("Removing %x\n", scheme); killed_timers = g_list_append (killed_timers, GUINT_TO_POINTER(timeout_id)); return SCM_BOOL_T; } } return SCM_BOOL_F; } SCM scheme_bass_figure (SCM bass, SCM harmony) { SCM ret = SCM_BOOL_F; gboolean status = FALSE; gint bassnum = scm_to_int (bass); gint harmonynum = scm_to_int (harmony); gchar *interval = determine_interval (bassnum, harmonynum, &status); if (interval) { ret = scm_cons (status ? SCM_BOOL_T : SCM_BOOL_F, scm_from_locale_string (interval)); g_free (interval); } return ret; } SCM scheme_has_figures (SCM optional) { return SCM_BOOL (((DenemoStaff *) Denemo.project->movement->currentstaff->data)->hasfigures); } SCM scheme_get_bass_figure (void) { DenemoObject *curObj; chord *thechord; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object) || ! (((DenemoStaff *) Denemo.project->movement->currentstaff->data)->hasfigures)) return SCM_BOOL_F; else { if ((thechord->figure == NULL) || ((((GString *) ((chord *) thechord->figure))->str) == NULL)) return scm_from_locale_string ("_"); /* the no-figure figure */ else return scm_from_locale_string (((GString *) ((chord *) thechord->figure))->str); } } //badly named: SCM scheme_put_note_name (SCM optional) { DenemoObject *curObj; chord *thechord; note *thenote; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object) || !(thechord->notes) || !(thenote = (note *) thechord->notes->data)) return SCM_BOOL (FALSE); else { char *str = NULL; if (scm_is_string (optional)) { str = scm_to_locale_string (optional); gint mid_c_offset; gint enshift; interpret_lilypond_notename (str, &mid_c_offset, &enshift); //g_debug("note %s gives %d and %d\n", str, mid_c_offset, enshift); modify_note (thechord, mid_c_offset, enshift, find_prevailing_clef (Denemo.project->movement)); if (str) free (str); return SCM_BOOL (TRUE); } } return SCM_BOOL (FALSE); } SCM scheme_set_accidental (SCM optional) { DenemoObject *curObj; chord *thechord; note *thenote; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object) || !(thechord->notes) || !(thenote = (note *) thechord->notes->data)) return SCM_BOOL (FALSE); else { GList *g; for (g = thechord->notes; g; g = g->next) { thenote = (note *) g->data; if (thenote->mid_c_offset == Denemo.project->movement->cursor_y) break; } if (g == NULL) return SCM_BOOL_F; DenemoMovement *si = Denemo.project->movement; char *str = NULL; if (scm_is_string (optional)) { str = scm_to_locale_string (optional); thenote->enshift = lilypond_to_enshift (str); } else if (scm_is_integer (optional)) thenote->enshift = scm_to_int (optional); else thenote->enshift = 0; if ((thenote->enshift < -2) || (thenote->enshift > 2)) thenote->enshift = 0; showwhichaccidentals ((objnode *) ((DenemoMeasure *) si->currentmeasure->data)->objects); // find_xes_in_measure (si, si->currentmeasurenum, si->cursortime1, // si->cursortime2); causes a crash, si is not passed correctly, why??? //thenote->mid_c_offset = interpret_lilypond_notename(str); displayhelper (Denemo.project); if (str) free (str); return SCM_BOOL (TRUE); } } //create a putnote here that takes a duration and numdots and note name, inserts a chord and calls the scheme_put_note_name above - this can be done via script at present, e.g. (d-C) (d-Change3) (d-AddDot) (d-PutNoteName "eis''") //Puts a note into the chord at the cursor PARAM lily is a string representation of the note SCM scheme_insert_note_in_chord (SCM lily) { DenemoProject *gui = Denemo.project; DenemoObject *curObj; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data)) return SCM_BOOL_F; #ifdef INSERT_NOTE_IN_CHORD_WORKS_ON_PREVIOUS_CHORD if (curObj->type != CHORD) { objnode *theobj = Denemo.project->movement->currentobject; while (theobj->prev) { theobj = theobj->prev; curObj = theobj->data; if (curObj->type == CHORD) break; } if (curObj->type != CHORD) return SCM_BOOL_F; } #else if (curObj->type != CHORD) return SCM_BOOL_F; #endif char *str = NULL; if (scm_is_string (lily)) { str = scm_to_locale_string (lily); gint mid_c_offset; gint enshift; interpret_lilypond_notename (str, &mid_c_offset, &enshift); //g_debug("note %s gives %d and %d\n", str, mid_c_offset, enshift); addtone (curObj, mid_c_offset, enshift); score_status (gui, TRUE); displayhelper (Denemo.project); if (str) free (str); return SCM_BOOL_T; } return SCM_BOOL (FALSE); } //return the number of objects in the copybuffer at staff m SCM scheme_get_clip_objects (SCM m) { gint staff = scm_to_int (m); gint num = get_clip_objs (staff); if (num == -1) return SCM_BOOL_F; else return scm_from_int (num); } //return the type of the nth object in the copybuffer SCM scheme_get_clip_obj_type (SCM m, SCM n) { gint value = scm_to_int (n); gint staff = scm_to_int (m); DenemoObjType type = get_clip_obj_type (staff, value); if (type == -1) return SCM_BOOL_F; else return scm_from_int (type); } //insert the nth object from the denemo copybuffer SCM scheme_put_clip_obj (SCM m, SCM n) { gint value = scm_to_int (n); gint staff = scm_to_int (m); return SCM_BOOL (insert_clip_obj (staff, value)); } SCM scheme_adjust_xes (SCM optional) { find_xes_in_all_measures (Denemo.project->movement); return SCM_BOOL_T; } static gint flash_cursor (void) { draw_score_area (); return TRUE; } //turn flashing of cursor off/on SCM scheme_highlight_cursor (SCM optional) { static gint id; SCM ret = SCM_BOOL_T; gboolean old_value = Denemo.prefs.cursor_highlight; if (scm_is_bool (optional)) { Denemo.prefs.cursor_highlight = scm_is_true (optional); ret = old_value ? SCM_BOOL_T : SCM_BOOL_F; } else { Denemo.prefs.cursor_highlight = !Denemo.prefs.cursor_highlight; } if (id && !Denemo.prefs.cursor_highlight) { g_source_remove (id); id = 0; } else if (Denemo.prefs.cursor_highlight) id = g_timeout_add (500, (GSourceFunc) flash_cursor, NULL); //g_debug("Cursor highlighting %d id %d", Denemo.prefs.cursor_highlight, id); return ret; } SCM scheme_get_type (SCM at_or_before) { DenemoObject *curObj; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || !(DENEMO_OBJECT_TYPE_NAME (curObj))) return scm_from_locale_string ("None"); if (scm_is_true (at_or_before) && Denemo.project->movement->cursor_appending) return scm_from_locale_string ("Appending"); return scm_from_locale_string (DENEMO_OBJECT_TYPE_NAME (curObj)); } SCM scheme_get_lilypond (SCM optional) { DenemoProject *gui = Denemo.project; DenemoObject *curObj; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || !(DENEMO_OBJECT_TYPE_NAME (curObj))) return SCM_BOOL_F; //g_debug("Before %d %d\n", gui->lilysync, gui->changecount); if (gui->lilysync != gui->changecount) refresh_lily_cb (NULL, Denemo.project); //g_debug("After %d %d\n", gui->lilysync, gui->changecount); if (curObj->lilypond) return scm_from_locale_string (curObj->lilypond); return SCM_BOOL_F; } SCM scheme_refresh_lilypond (void) { force_lily_refresh (Denemo.project); return SCM_BOOL_T; } SCM scheme_get_tuplet (SCM optional) { DenemoObject *curObj; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != TUPOPEN)) return SCM_BOOL_F; GString *ratio = g_string_new (""); g_string_printf (ratio, "%d/%d", ((tupopen *) curObj->object)->numerator, ((tupopen *) curObj->object)->denominator); return scm_from_locale_string (g_string_free (ratio, FALSE)); } SCM scheme_set_tuplet (SCM ratio) { DenemoObject *curObj; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != TUPOPEN)) { return SCM_BOOL_F; } char *theratio; theratio = scm_to_locale_string (ratio); sscanf (theratio, "%d/%d", &((tupopen *) curObj->object)->numerator, &((tupopen *) curObj->object)->denominator); //g_debug("Set %d/%d\n", (((tupopen*)curObj->object)->numerator), (((tupopen*)curObj->object)->denominator)); free (theratio); if (((tupopen *) curObj->object)->denominator) { return SCM_BOOL_T; } ((tupopen *) curObj->object)->denominator = 1; return SCM_BOOL_F; } SCM scheme_set_background (SCM color) { if (scm_is_integer (color)) { gint value = scm_to_int (color); Denemo.color = value; draw_score_area (); return SCM_BOOL_T; } return SCM_BOOL_F; } SCM scheme_get_nonprinting (SCM optional) { DenemoObject *curObj; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || curObj->isinvisible) return SCM_BOOL_T; return SCM_BOOL_F; } SCM scheme_set_nonprinting (SCM optional) { DenemoObject *curObj; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data)) return SCM_BOOL_F; if (scm_is_false (optional)) curObj->isinvisible = FALSE; else curObj->isinvisible = TRUE; return SCM_BOOL_T; } SCM scheme_is_grace (SCM optional) { DenemoObject *curObj; chord *thechord; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object) || !(thechord->is_grace)) return SCM_BOOL_F; return SCM_BOOL_T; } SCM scheme_is_tied (SCM optional) { DenemoObject *curObj; chord *thechord; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object) || !(thechord->is_tied)) return SCM_BOOL_F; return SCM_BOOL_T; } SCM scheme_is_slur_start (SCM optional) { DenemoObject *curObj; chord *thechord; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object) || !(thechord->slur_begin_p)) return SCM_BOOL_F; return SCM_BOOL_T; } SCM scheme_is_slur_end (SCM optional) { DenemoObject *curObj; chord *thechord; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object) || !(thechord->slur_end_p)) return SCM_BOOL_F; return SCM_BOOL_T; } SCM scheme_is_cresc_start (SCM optional) { DenemoObject *curObj; chord *thechord; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object) || !(thechord->crescendo_begin_p)) return SCM_BOOL_F; return SCM_BOOL_T; } SCM scheme_is_cresc_end (SCM optional) { DenemoObject *curObj; chord *thechord; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object) || !(thechord->crescendo_end_p)) return SCM_BOOL_F; return SCM_BOOL_T; } SCM scheme_is_dim_start (SCM optional) { DenemoObject *curObj; chord *thechord; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object) || !(thechord->diminuendo_begin_p)) return SCM_BOOL_F; return SCM_BOOL_T; } SCM scheme_is_dim_end (SCM optional) { DenemoObject *curObj; chord *thechord; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object) || !(thechord->diminuendo_end_p)) return SCM_BOOL_F; return SCM_BOOL_T; } SCM scheme_is_in_selection (void) { return SCM_BOOL (in_selection (Denemo.project->movement)); } SCM scheme_has_selection (void) { return SCM_BOOL (Denemo.project->movement->markstaffnum != 0); } SCM scheme_is_appending (void) { return SCM_BOOL (Denemo.project->movement->cursor_appending); } SCM scheme_clear_clipboard (SCM optional) { clearbuffer (); return SCM_BOOL (TRUE); } SCM scheme_get_staffs_in_clipboard (SCM optional) { gint num = get_staffs_in_clipboard (); if (num) return scm_from_int (num); return SCM_BOOL_F; } SCM scheme_get_measures_in_staff (SCM optional) { gint num = g_list_length (((DenemoStaff *) Denemo.project->movement->currentstaff->data)->themeasures); return scm_from_int (num); } SCM scheme_get_staffs_in_movement (SCM optional) { gint num = g_list_length (Denemo.project->movement->thescore); return scm_from_int (num); } SCM scheme_get_movements_in_score (void) { gint num = g_list_length (Denemo.project->movements); return scm_from_int (num); } SCM scheme_set_lines_in_staff (SCM lines) { DenemoStaff *thestaff = (DenemoStaff *) Denemo.project->movement->currentstaff->data; if (scm_is_integer (lines)) { gint value = scm_to_int (lines); thestaff->no_of_lines = value; displayhelper (Denemo.project); } return scm_from_int (thestaff->no_of_lines); } SCM scheme_staff_type (SCM type) { gchar *value = "Staff"; DenemoStaff *thestaff = (DenemoStaff *) Denemo.project->movement->currentstaff->data; if (thestaff->type) value = thestaff->type; if (scm_is_string (type)) { value = scm_to_locale_string (type); if (!g_strcmp0 (value, "Staff")) thestaff->type = NULL; else thestaff->type = value; signal_structural_change (Denemo.project); score_status (Denemo.project, FALSE); } else if (type != SCM_UNDEFINED) return SCM_BOOL_F; return scm_from_locale_string (value); } SCM scheme_inherit_staff_properties (void) { DenemoStaff *thestaff = (DenemoStaff *) Denemo.project->movement->currentstaff->data; DenemoStaff *prevstaff = (DenemoStaff *) (Denemo.project->movement->currentstaff->prev ? Denemo.project->movement->currentstaff->prev->data : NULL); if (prevstaff) { staff_copy (prevstaff, thestaff, FALSE); return SCM_BOOL_T; } return SCM_BOOL_F; } static SCM set_staff_range (SCM setting, gboolean hi) { DenemoStaff *thestaff = (DenemoStaff *) Denemo.project->movement->currentstaff->data; if (scm_is_integer (setting)) { gint value = scm_to_int (setting); *(hi ? &thestaff->range_hi : &thestaff->range_lo) = value; thestaff->range = TRUE; } if (thestaff->range) return scm_from_int (hi ? thestaff->range_hi : thestaff->range_lo); return SCM_BOOL_F; } SCM scheme_set_staff_range_hi (SCM hi) { return set_staff_range (hi, TRUE); } SCM scheme_set_staff_range_lo (SCM lo) { return set_staff_range (lo, FALSE); } SCM scheme_set_staff_range (void) { DenemoStaff *thestaff = (DenemoStaff *) Denemo.project->movement->currentstaff->data; if (Denemo.project->movement->currentobject) { DenemoObject *curobj = Denemo.project->movement->currentobject->data; if (curobj->type == CHORD) { chord *thechord = ((chord *) curobj->object); thestaff->range_hi = thechord->highestpitch; thestaff->range_lo = thechord->lowestpitch; thestaff->range = TRUE; return SCM_BOOL_T; } } return SCM_BOOL_F; } SCM scheme_shorten_staff_height (SCM shorten) { DenemoStaff *thestaff = (DenemoStaff *) Denemo.project->movement->currentstaff->data; if (scm_is_integer (shorten)) { gint value = scm_to_int (shorten); thestaff->space_shorten = value; displayhelper (Denemo.project); } return scm_from_int (thestaff->space_shorten); } SCM scheme_set_minimum_staff_spacing (SCM amount) { if (scm_is_integer (amount)) { gint value = scm_to_int (amount); Denemo.project->movement->staffspace = value; displayhelper (Denemo.project); } return scm_from_int (Denemo.project->movement->staffspace); } SCM scheme_staff_set_space_above (SCM space) { DenemoStaff *thestaff = (DenemoStaff *) Denemo.project->movement->currentstaff->data; if (scm_is_integer (space)) { gint value = scm_to_int (space); if (value<0) thestaff->fixed_height = FALSE; else { thestaff->space_above = value; displayhelper (Denemo.project); } } return scm_from_int (thestaff->space_above); } SCM scheme_staff_set_space_below (SCM space) { DenemoStaff *thestaff = (DenemoStaff *) Denemo.project->movement->currentstaff->data; if (scm_is_integer (space)) { gint value = scm_to_int (space); thestaff->space_below = value; displayhelper (Denemo.project); } return scm_from_int (thestaff->space_below); } SCM scheme_set_color_of_staff (SCM color) { DenemoStaff *thestaff = (DenemoStaff *) Denemo.project->movement->currentstaff->data; gint current = thestaff->color; if (scm_is_integer (color)) { gint value = scm_to_ulong (color); thestaff->color = value; displayhelper (Denemo.project); } return scm_from_ulong (thestaff->color); } SCM scheme_staff_to_voice (SCM optional) { SCM ret = SCM_BOOL_F; DenemoStaff *current = ((DenemoStaff *) Denemo.project->movement->currentstaff->data); if (Denemo.project->movement->currentstaff->prev && (current->voicecontrol == DENEMO_PRIMARY)) { current->voicecontrol |= DENEMO_SECONDARY; staff_set_current_primary (Denemo.project->movement); DenemoStaff *primary = (DenemoStaff *) Denemo.project->movement->currentprimarystaff->data; if ((current->timesig.time1 != primary->timesig.time1) || (current->timesig.time2 != primary->timesig.time2)) { warningdialog (_("Time Signatures do not match, will not make voice")); current->voicecontrol = DENEMO_PRIMARY; staff_set_current_primary (Denemo.project->movement); return SCM_BOOL_F; } if ((current->keysig.number != primary->keysig.number) || (current->keysig.isminor != primary->keysig.isminor) || (current->keysig.mode != primary->keysig.mode)) { warningdialog (_("Key Signatures do not match, will not make voice")); current->voicecontrol = DENEMO_PRIMARY; staff_set_current_primary (Denemo.project->movement); return SCM_BOOL_F; } if (current->clef.type != primary->clef.type) { warningdialog (_("This voice has a different clef from the staff it will be typeset on. This clef will be used for the display only.")); } ret = SCM_BOOL_T; signal_structural_change (Denemo.project); draw_score_area (); score_status (Denemo.project, TRUE); } return ret; } SCM scheme_voice_to_staff (SCM optional) { SCM ret = SCM_BOOL_F; if (((DenemoStaff *) Denemo.project->movement->currentstaff->data)->voicecontrol & DENEMO_SECONDARY) { ((DenemoStaff *) Denemo.project->movement->currentstaff->data)->voicecontrol = DENEMO_PRIMARY; staff_set_current_primary (Denemo.project->movement); ret = SCM_BOOL_T; signal_structural_change (Denemo.project); score_status (Denemo.project, TRUE); draw_score_area (); } return ret; } SCM scheme_is_voice (void) { return SCM_BOOL ((((DenemoStaff *) Denemo.project->movement->currentstaff->data)->voicecontrol & DENEMO_SECONDARY)); } /* shifts the note at the cursor by the number of diatonic steps passed in */ SCM scheme_diatonic_shift (SCM optional) { DenemoProject *gui = Denemo.project; DenemoObject *curObj; chord *thechord; note *thenote; if (!Denemo.project || !(Denemo.project->movement) || !(Denemo.project->movement->currentobject) || !(curObj = Denemo.project->movement->currentobject->data) || (curObj->type != CHORD) || !(thechord = (chord *) curObj->object) || !(thechord->notes) || !(thenote = (note *) thechord->notes->data)) { return SCM_BOOL (FALSE); } else { char *str = NULL; if (scm_is_string (optional)) { str = scm_to_locale_string (optional); gint shift; sscanf (str, "%d", &shift); // g_debug("note shift %s ie %d\n", str, shift); modify_note (thechord, thenote->mid_c_offset + shift, curObj->keysig->accs[offsettonumber (thenote->mid_c_offset + shift)], find_prevailing_clef (Denemo.project->movement)); free (str); } } return SCM_BOOL (FALSE); } /* moves currentobject to next object by calling cursorright. Steps over barlines (i.e. cursor_appending). returns TRUE if currentobject is different after than before doing the call */ SCM scheme_next_object (void) { return SCM_BOOL (cursor_to_next_object (FALSE, FALSE)); } /* moves currentobject to prev object by calling cursorleft. Steps over barlines (i.e. cursor_appending). returns TRUE if currentobject is different after than before doing the call */ SCM scheme_prev_object (void) { return SCM_BOOL (cursor_to_prev_object (FALSE, FALSE)); } /* advances the cursor to the next note, stopping at empty measures. The cursor is left after last note if no more notes * returns SCM_BOOL_T if cursor moves*/ SCM scheme_next_editable_note (void) { return SCM_BOOL (next_editable_note ()); } /* moves currentobject to next object in measure, if any returns TRUE if currentobject is different after than before doing the call */ SCM scheme_next_object_in_measure (void) { return SCM_BOOL (cursor_to_next_object (TRUE, FALSE)); } /* moves currentobject to previous object in measure, if any returns TRUE if currentobject is different after than before doing the call */ SCM scheme_prev_object_in_measure (void) { return SCM_BOOL (cursor_to_prev_object (TRUE, FALSE)); } SCM scheme_refresh_display (SCM optional) { displayhelper (Denemo.project); //done in displayhelper write_status(Denemo.project); return SCM_BOOL (TRUE); } SCM scheme_keep_alive (SCM optional) { keep_alive (); return SCM_BOOL (TRUE); } SCM scheme_refresh_cache (void) { return SCM_BOOL (TRUE); } SCM scheme_set_saved (SCM optional) { if (scm_is_false (optional)) score_status (Denemo.project, TRUE); else score_status (Denemo.project, FALSE); return SCM_BOOL (TRUE); } SCM scheme_get_saved (SCM optional) { return SCM_BOOL (!Denemo.project->notsaved); } SCM scheme_changecount (SCM count) { if (scm_is_integer (count)) { Denemo.project->changecount = scm_to_int (count); } return scm_from_int (Denemo.project->changecount); } SCM scheme_mark_status (SCM optional) { return SCM_BOOL (mark_status ()); } /* moves currentobject to next object in the selection. Steps over barlines (i.e. cursor_appending). returns TRUE if currentobject is different after than before the call */ SCM scheme_next_selected_object (SCM optional) { return SCM_BOOL (cursor_to_next_selected_object ()); } /* moves currentobject to previous object in the selection. Steps over barlines (i.e. cursor_appending). returns TRUE if currentobject is different after than before the call */ SCM scheme_prev_selected_object (SCM optional) { return SCM_BOOL (cursor_to_prev_selected_object ()); } /* return staff that starts selection or #f if none */ SCM scheme_selection_start_staff (SCM optional) { gint first = Denemo.project->movement->selection.firststaffmarked; gint last = Denemo.project->movement->selection.laststaffmarked; if (first) return scm_from_int (first); else return SCM_BOOL_F; } /* return staff that ends selection or #f if none */ SCM scheme_selection_end_staff (SCM optional) { gint first = Denemo.project->movement->selection.firststaffmarked; gint last = Denemo.project->movement->selection.laststaffmarked;//only valid if first is not 0 if (first) return scm_from_int (last); else return SCM_BOOL_F; } /* return start & end of selection as pair of positions (#f,staff,measure,object) or #f if none */ SCM scheme_get_selection (void) { gint firststaff = Denemo.project->movement->selection.firststaffmarked; gint laststaff = Denemo.project->movement->selection.laststaffmarked; gint firstmeas = Denemo.project->movement->selection.firstmeasuremarked; gint lastmeas = Denemo.project->movement->selection.lastmeasuremarked; gint firstobj = Denemo.project->movement->selection.firstobjmarked + 1;//selection object numbers start at 0 gint lastobj; if (firststaff && (firststaff != laststaff)) lastobj = 1;//lastobjmarked is a dummy in this case - the whole measure is selected. else lastobj = Denemo.project->movement->selection.lastobjmarked + 1; if (Denemo.project->movement->markstaffnum) return scm_cons (scm_list_4 (SCM_BOOL_F, scm_from_int (firststaff), scm_from_int (firstmeas), scm_from_int (firstobj)), scm_list_4 (SCM_BOOL_F, scm_from_int (laststaff), scm_from_int (lastmeas), scm_from_int (lastobj))); else return SCM_BOOL_F; } SCM scheme_next_standalone_directive (SCM optional) { return SCM_BOOL (cursor_to_next_standalone_directive ()); } SCM scheme_prev_standalone_directive (SCM optional) { return SCM_BOOL (cursor_to_prev_standalone_directive ()); } SCM scheme_next_standalone_directive_in_measure (SCM optional) { return SCM_BOOL (cursor_to_next_standalone_in_measure ()); } SCM scheme_prev_standalone_directive_in_measure (SCM optional) { return SCM_BOOL (cursor_to_prev_standalone_in_measure ()); } SCM scheme_next_chord (SCM optional) { DenemoPosition pos; get_position (Denemo.project->movement, &pos); gboolean ret = cursor_to_next_chord (); if (!ret) goto_movement_staff_obj (NULL, -1, pos.staff, pos.measure, pos.object, pos.leftmeasurenum); return SCM_BOOL (ret); } SCM scheme_prev_chord (SCM optional) { DenemoPosition pos; get_position (Denemo.project->movement, &pos); gboolean ret = cursor_to_prev_chord (); if (!ret) goto_movement_staff_obj (NULL, -1, pos.staff, pos.measure, pos.object, pos.leftmeasurenum); return SCM_BOOL (ret); } SCM scheme_next_chord_in_measure (SCM optional) { return SCM_BOOL (cursor_to_next_chord_in_measure ()); } SCM scheme_prev_chord_in_measure (SCM optional) { return SCM_BOOL (cursor_to_prev_chord_in_measure ()); } SCM scheme_is_measure_end (void) { return SCM_BOOL (Denemo.project->movement->currentobject? Denemo.project->movement->currentobject->next==NULL: TRUE); } SCM scheme_next_note (SCM optional) { return SCM_BOOL (cursor_to_next_note ()); } SCM scheme_prev_note (SCM optional) { return SCM_BOOL (cursor_to_prev_note ()); } SCM scheme_scroll_left (void) { scroll_left (); return SCM_BOOL_T; } SCM scheme_scroll_right (void) { scroll_right (); return SCM_BOOL_T; } void update_scheme_snippet_ids (void) { DenemoProject *gui = Denemo.project; GList *g; gint i; for (g = gui->rhythms, i = 1; g; g = g->next, i++) { RhythmPattern *r = (RhythmPattern *) g->data; if (r->name) { gchar *command = g_strdup_printf ("(define Snippet::%s %d)", r->name, i); call_out_to_guile (command); g_free (command); } } } SCM scheme_create_snippet_from_object (SCM name) { if (scm_is_string (name)) { char *str; str = scm_to_locale_string (name); if (Denemo.project->movement->currentobject) { DenemoObject *clonedobj = dnm_clone_object (Denemo.project->movement->currentobject->data); RhythmPattern *r = (RhythmPattern *) g_malloc0 (sizeof (RhythmPattern)); install_button_for_pattern (r, str); r->clipboard = g_list_append (NULL, g_list_append (NULL, clonedobj)); append_rhythm (r, NULL); RhythmElement *relement = (RhythmElement *) g_malloc0 (sizeof (RhythmElement)); //relement->icon = str; was wrong, must be NULL for a singleton. r->name = str; r->nickname = g_string_new (str); r->rsteps = g_list_append (NULL, relement); r->rsteps->prev = r->rsteps->next = r->rsteps; //make list circular SCM ret = scm_from_int (insert_pattern_in_toolbar (r, TRUE)); update_scheme_snippet_ids (); if (str) free (str); return ret; } if (str) free (str); } return SCM_BOOL_F; } SCM scheme_select_snippet (SCM number) { if (scm_is_integer (number)) { gint position = scm_to_int (number); GList *g = g_list_nth (Denemo.project->rhythms, position - 1); if (g) { RhythmPattern *r = g->data; if (r) { select_rhythm_pattern (r); return SCM_BOOL_T; } } } return SCM_BOOL_F; } SCM scheme_insert_snippet (SCM number, SCM select) { if (scm_is_integer (number)) { gint position = scm_to_int (number); GList *g = g_list_nth (Denemo.project->rhythms, position - 1); if (g) { RhythmPattern *r = g->data; if (r) { if (scm_is_true (select)) { select_rhythm_pattern (r); insert_note_following_pattern (Denemo.project); } else { insert_nth_rhythm (position - 1); } return SCM_BOOL_T; } } } return SCM_BOOL_F; } SCM scheme_locate_temp_dir (void) { return scm_from_locale_string (make_temp_dir(FALSE)); } SCM scheme_locate_dotdenemo (void) { const gchar *dotdenemo = get_user_data_dir (TRUE); if (!dotdenemo) return SCM_BOOL (FALSE); SCM scm = scm_from_locale_string (dotdenemo); return scm; } SCM scheme_log_debug (SCM message) { if (scm_is_string (message)) { const gchar *msg = scm_to_locale_string (message); g_debug ("%s", msg); } return SCM_BOOL_T; } SCM scheme_log_info (SCM message) { if (scm_is_string (message)) { const gchar *msg = scm_to_locale_string (message); g_info ("%s", msg); } return SCM_BOOL_T; } SCM scheme_log_message (SCM message) { if (scm_is_string (message)) { const gchar *msg = scm_to_locale_string (message); g_message ("%s", msg); } return SCM_BOOL_T; } SCM scheme_log_warning (SCM message) { if (scm_is_string (message)) { const gchar *msg = scm_to_locale_string (message); g_warning ("%s", msg); } return SCM_BOOL_T; } SCM scheme_log_critical (SCM message) { if (scm_is_string (message)) { const gchar *msg = scm_to_locale_string (message); g_critical ("%s", msg); } return SCM_BOOL_T; } SCM scheme_log_error (SCM message) { if (scm_is_string (message)) { const gchar *msg = scm_to_locale_string (message); g_error ("%s", msg); } return SCM_BOOL_T; }