xref: /dports/audio/denemo/denemo-2.0.6/src/command/scorelayout.c

//      scorelayout.c
//
//      Copyright 2012 Richard Shann
//
//      This program is free software; you can redistribute it and/or modify
//      it under the terms of the GNU General Public License as published by
//      the Free Software Foundation; either version 3 of the License, or
//      (at your option) any later version.
//
//      This program is distributed in the hope that it will be useful,
//      but WITHOUT ANY WARRANTY; without even the implied warranty of
//      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//      GNU General Public License for more details.
//
//      You should have received a copy of the GNU General Public License
//      along with this program; if not, write to the Free Software
//      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
//      MA 02110-1301, USA.

#include <string.h>
#include "command/scorelayout.h"
#include "export/exportlilypond.h"
#include "core/utils.h"
#include "export/print.h"
#include "printview/printview.h"
#include "command/score.h"
#include "command/processstaffname.h"
#include "core/view.h"



#define LILYPOND_TEXT_EDITOR _("LilyPond text editor")
#define DEFAULT_SCORE_LAYOUT _("Default Score Layout")
static void set_notebook_page (GtkWidget * w);
static void prefix_edit_callback (GtkWidget * widget, GtkWidget * frame);
static void create_element (GtkWidget * vbox, GtkWidget * widget, gchar * lilypond);
static void create_standard_scoreblock (DenemoScoreblock ** psb, gint movement, gchar * partname);
static void recreate_standard_scoreblock (DenemoScoreblock ** psb);
static DenemoScoreblock *get_standard_scoreblock (GtkWidget * widget);
static GtkWidget *get_options_button (DenemoScoreblock * sb, gboolean custom);
static void install_duplicate_movement_callback (DenemoScoreblock *sb);
static void reorder_movement_callback (DenemoScoreblock * psb);
static gboolean edit_lilypond_prefix (GtkWidget * widget, gchar * oldval, gchar * newval);
static void reload_scorewide_block (GtkWidget *frame);
static gint layout_sync;

// Reverses (reflects) bits in a 32-bit word.
static guint32
bit_reverse (guint32 x)
{
  x = ((x & 0x55555555) << 1) | ((x >> 1) & 0x55555555);
  x = ((x & 0x33333333) << 2) | ((x >> 2) & 0x33333333);
  x = ((x & 0x0F0F0F0F) << 4) | ((x >> 4) & 0x0F0F0F0F);
  x = (x << 24) | ((x & 0xFF00) << 8) | ((x >> 8) & 0xFF00) | (x >> 24);
  return x;
}

/* This is the basic CRC algorithm with no optimizations. It follows the
logic circuit as closely as possible. */
//returns a 32 bit crc for the passed string
static guint32
crc32 (guchar * message)
{
  int i, j;
  guint32 byte, crc;
  i = 0;
  crc = 0xFFFFFFFF;
  while (message[i] != 0)
    {
      byte = message[i];        // Get next byte.
      byte = bit_reverse (byte);        // 32-bit reversal.
      for (j = 0; j <= 7; j++)
        {                       // Do eight times.
          if ((int) (crc ^ byte) < 0)
            crc = (crc << 1) ^ 0x04C11DB7;
          else
            crc = crc << 1;
          byte = byte << 1;     // Ready next msg bit.
        }
      i = i + 1;
    }
  return bit_reverse (~crc);
}

static guint
get_location (guint movementnum, guint voicecount)
{
  return (movementnum << 16) | voicecount;
}

static void
navigate_to_location (GtkWidget * w, guint location)
{
  guint movementnum = location >> 16;
  guint staffnum = location & 0xFFFF;
  goto_movement_staff_obj (NULL, movementnum, staffnum, 1, 0, 0);
}

static void
popup_staff_groups_menu (GtkWidget * button)
{
  GtkWidget *menuitem = gtk_ui_manager_get_widget (Denemo.ui_manager, "/ObjectMenu/StaffMenu/StaffGroupings");
  if (get_standard_scoreblock (button))
    {
      if (menuitem)
        gtk_menu_popup (GTK_MENU (gtk_menu_item_get_submenu (GTK_MENU_ITEM (menuitem))), NULL, NULL, NULL, NULL, 0, GDK_CURRENT_TIME);
      else
        g_warning ("No such menu path");
    }
  else
    warningdialog (_("This button is for changing the score itself, it will not affect this custom layout"));
}

static void
staff_groups_menu (GtkWidget * w, GdkEvent * event, guint location)
{
  navigate_to_location (NULL, location);
  popup_staff_groups_menu (w);
}

//callback on destroying widgets that are on the staff_list of a scoreblock.
static gboolean
remove_from_staff_list (GtkWidget * widget, GList ** g)
{
  *g = g_list_remove (*g, widget);
  return TRUE;                  //that is go on to destroy the widget
}

//free the passed DenemoScoreblock structure for re-use or disposal
static void
free_scoreblock (DenemoScoreblock * sb)
{
  if (sb->widget)
    gtk_widget_destroy (sb->widget);    //FIXME free lilypond attached to widgets
  sb->widget = 0;
  if (sb->lilypond)
    g_string_free ((GString *) (sb->lilypond), TRUE);
  g_free (sb->instrumentation);
  sb->instrumentation = NULL;
  sb->lilypond = NULL;
}

void
free_scoreblocks (DenemoProject * gui)
{
  if (gui->standard_scoreblocks)
    {
      GList *g;
      for (g = gui->standard_scoreblocks; g; g = g->next)
        {
          DenemoScoreblock *sb = ((DenemoScoreblock *) g->data);
          free_scoreblock (sb);
        }
      g_list_free (gui->standard_scoreblocks);
      gui->standard_scoreblocks = NULL;
    }
  if (gui->custom_scoreblocks)
    {
      GList *g;
      for (g = gui->custom_scoreblocks; g; g = g->next)
        {
          DenemoScoreblock *sb = ((DenemoScoreblock *) g->data);
          free_scoreblock (sb);
        }
      g_list_free (gui->custom_scoreblocks);
      gui->custom_scoreblocks = NULL;
    }
}



static gboolean
is_in_standard_scoreblock (DenemoScoreblock * sb)
{
  return (g_list_find (Denemo.project->standard_scoreblocks, sb) != NULL);
}


static gboolean
free_prefix_and_postfix (GtkWidget * widget)
{
  // glib 2.28 and greater can use:
  //g_list_free_full(g_object_get_data(G_OBJECT(widget), "prefix"), (GDestroyNotify)g_free);
  //g_list_free_full(g_object_get_data(G_OBJECT(widget), "postfix"), (GDestroyNotify)g_free);
  GList *g = g_object_get_data (G_OBJECT (widget), "prefix");
  g_list_foreach (g, (GFunc) (g_free), NULL);
  g_list_free (g);
  g = g_object_get_data (G_OBJECT (widget), "postfix");
  g_list_foreach (g, (GFunc) (g_free), NULL);
  g_list_free (g);
  return TRUE;                  //and destroy widget
}

// attaches the two lilypond strings to the prefix and postfix lists of widget
// prefix is created in the reverse order to postfix so they can nest
// the destroy widget is arranged to free the lists
static void
add_lilypond (GtkWidget * w, gchar * prefix, gchar * postfix)
{
  if (g_object_get_data (G_OBJECT (w), "prefix") == NULL && g_object_get_data (G_OBJECT (w), "postfix") == NULL)
    g_signal_connect (G_OBJECT (w), "destroy", G_CALLBACK (free_prefix_and_postfix), NULL);

  if (prefix)
    g_object_set_data (G_OBJECT (w), "prefix", (gpointer) g_list_append (g_object_get_data (G_OBJECT (w), "prefix"), prefix));
  if (postfix)
    g_object_set_data (G_OBJECT (w), "postfix", (gpointer) g_list_prepend (g_object_get_data (G_OBJECT (w), "postfix"), postfix));
}

static gchar *
get_voicetag (gint movementnum, gint voice_count)
{
  GString *str = g_string_new ("");
  GString *name = g_string_new ("");
  g_string_printf (str, "Voice%d Mvmnt%d", voice_count, movementnum);
  set_lily_name (str, name);
  g_string_free (str, TRUE);
  return g_string_free (name, FALSE);
}

static gchar *
get_voicename (gint movementnum, gint voice_count)
{
  GString *str = g_string_new ("");
  GString *name = g_string_new ("");
  g_string_printf (str, "Mvmnt%d Voice%d", movementnum, voice_count);
  set_lily_name (str, name);
  g_string_free (str, TRUE);
  return g_string_free (name, FALSE);
}


static gchar *
get_versename (gint movementnum, gint voice_count, gint versenum)
{
  GString *str = g_string_new ("");
  GString *name = g_string_new ("");
  g_string_printf (str, "Mvmnt%d Voice%d Verse%d", movementnum, voice_count, versenum);
  set_lily_name (str, name);
  g_string_free (str, TRUE);
  return g_string_free (name, FALSE);
}

//Change the name of the scoreblock to user given value
static gboolean
name_scoreblock (DenemoScoreblock * sb, gchar * name)
{
  gchar *value;
  if (name == NULL)
    value = string_dialog_entry (Denemo.project, _("New Score Layout"), _("Give a name for this new score layout"), _("Custom Layout"));
  else
    value = name;
  if (value)
    {
      sb->name = g_strdup (value);
      gtk_notebook_set_tab_label_text (GTK_NOTEBOOK (get_score_layout_notebook (Denemo.project)), sb->widget, value);
      //FIXME if name==NULL g_free(value) I think.
      return TRUE;
    }
  else
    return FALSE;
}

//gets the toplevel standard DenemoScoreblock which contains the passed in widget, or NULL if not in the standard scoreblocks
static DenemoScoreblock *
get_standard_scoreblock (GtkWidget * widget)
{
  GList *g;
  for (g = Denemo.project->standard_scoreblocks; g; g = g->next)
    {
      DenemoScoreblock *sb = (DenemoScoreblock *) g->data;
      if (sb->widget && gtk_widget_is_ancestor (widget, sb->widget))
        return sb;
    }
  return NULL;
}

//gets the toplevel custom DenemoScoreblock which contains the passed in widget, or NULL if not in the custom scoreblocks
/* UNUSED
static DenemoScoreblock *
get_custom_scoreblock (GtkWidget * widget)
{
  GList *g;
  for (g = Denemo.project->custom_scoreblocks; g; g = g->next)
    {
      DenemoScoreblock *sb = (DenemoScoreblock *) g->data;
      if (sb->widget && gtk_widget_is_ancestor (widget, sb->widget))
        return sb;
    }
  return NULL;
}
*/
static gboolean
is_lilypond_text_layout (DenemoScoreblock * sb)
{
  return sb->text_only;
//return sb->widget && GTK_IS_FRAME(sb->widget) && gtk_frame_get_label(GTK_FRAME(sb->widget)) && !strcmp(gtk_frame_get_label(GTK_FRAME(sb->widget)), LILYPOND_TEXT_EDITOR);
}

static void
open_lilypond_window_callback (void)
{
  if (Denemo.textwindow && !gtk_widget_get_visible (Denemo.textwindow))
    activate_action ("/MainMenu/ViewMenu/ToggleLilyText");
}

static void
convert_to_lilypond_callback (GtkWidget * widget, DenemoScoreblock * sb)
{
  refresh_lilypond (sb);
  DenemoScoreblock *newsb = get_scoreblock_for_lilypond (sb->lilypond->str);
  Denemo.project->custom_scoreblocks = g_list_remove (Denemo.project->custom_scoreblocks, sb);
  Denemo.project->standard_scoreblocks = g_list_remove (Denemo.project->standard_scoreblocks, sb);
  GtkWidget *notebook = get_score_layout_notebook (Denemo.project);
  GtkWidget *label = gtk_label_new (sb->name);
  if (sb->widget)
    gtk_widget_destroy (sb->widget);
  gtk_widget_show_all (newsb->widget);
  gtk_notebook_prepend_page (GTK_NOTEBOOK (notebook), newsb->widget, label);
  gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), 0);
  Denemo.project->custom_scoreblocks = g_list_append (Denemo.project->custom_scoreblocks, newsb);
  Denemo.project->layout_id = 0;
}

static void
delete_custom_scoreblock_callback (GtkWidget * dummy, DenemoScoreblock * sb)
{
  Denemo.project->custom_scoreblocks = g_list_remove (Denemo.project->custom_scoreblocks, sb);
  gtk_widget_destroy (sb->widget);
  if(Denemo.project->standard_scoreblocks==NULL && Denemo.project->custom_scoreblocks==NULL)
    create_default_scoreblock ();
  score_status (Denemo.project, TRUE);
}

static void
delete_standard_scoreblock_callback (GtkWidget * widget, DenemoScoreblock * sb)
{
  Denemo.project->standard_scoreblocks = g_list_remove (Denemo.project->standard_scoreblocks, sb);
  gtk_widget_destroy (sb->widget);
  if(Denemo.project->standard_scoreblocks==NULL && Denemo.project->custom_scoreblocks==NULL)
    create_default_scoreblock ();
  score_status (Denemo.project, TRUE);
}

static void
recreate_standard_scoreblock_callback (GtkWidget * widget, DenemoScoreblock * psb)
{
  recreate_standard_scoreblock (&psb);
}

static gboolean
customize_scoreblock (DenemoScoreblock * sb, gchar * name)
{
  if (is_lilypond_text_layout (sb))
    {
      DenemoScoreblock *newsb = get_scoreblock_for_lilypond (sb->lilypond->str);
      GtkWidget *notebook = get_score_layout_notebook (Denemo.project);
      name_scoreblock (newsb, name);
      GtkWidget *label = gtk_label_new (newsb->name);
      gtk_widget_show_all (newsb->widget);
      gtk_notebook_prepend_page (GTK_NOTEBOOK (notebook), newsb->widget, label);
      gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), 0);
      Denemo.project->custom_scoreblocks = g_list_append (Denemo.project->custom_scoreblocks, newsb);
      Denemo.project->layout_id = 0;
      gchar *new_name = g_strdup_printf ("%%%s\n", newsb->name);
      g_string_prepend (newsb->lilypond, new_name);
      g_free (new_name);
      g_string_append_printf (newsb->lilypond, "\n\\header {DenemoLayoutName = \"%s\"}\n", newsb->name);
      score_status (Denemo.project, TRUE);
    }
  else if (name_scoreblock (sb, name))
    {
      g_free (sb->partname);
      sb->partname = NULL;
      sb->movement = 0;
      if (sb->lilypond)
        g_string_free (sb->lilypond, TRUE);
      sb->lilypond = NULL;
      Denemo.project->standard_scoreblocks = g_list_remove (Denemo.project->standard_scoreblocks, sb);
      Denemo.project->custom_scoreblocks = g_list_append (Denemo.project->custom_scoreblocks, sb);
      score_status (Denemo.project, TRUE);
    }
  else
    {
      return FALSE;
    }
  return TRUE;
}

#if 0
//having buttons that affect the score itself is confusing
/* go through the layout deleting score block elements that are marked standard as they are not needed for a custom scoreblock*/
static void
prune_layout (GtkWidget * layout)
{
  if (GTK_IS_CONTAINER (layout))
    {
      GList *g = gtk_container_get_children (GTK_CONTAINER (layout));
      if (g)
        do
          {
            prune_layout (g->data);
          }
        while ((g = g->next));
    }
  if (g_object_get_data (G_OBJECT (layout), "standard"))
    gtk_widget_destroy (layout);
}
#endif
static DenemoScoreblock *
clone_scoreblock (DenemoScoreblock * sb, gchar * name)
{
  gchar *partname = g_strdup (sb->partname);
  //prune_layout (sb->widget);
  GtkWidget *options = get_options_button (sb, TRUE);
  gtk_widget_show_all (options);
  GtkWidget *viewport = gtk_bin_get_child (GTK_BIN (sb->widget));
  GList *children = gtk_container_get_children (GTK_CONTAINER (viewport));
  GtkWidget *vbox = children->data;
  GList *grandchildren = gtk_container_get_children (GTK_CONTAINER (vbox));
  gtk_container_remove (GTK_CONTAINER (vbox), grandchildren->data);
  gtk_box_pack_start (GTK_BOX (vbox), options, FALSE, FALSE, 0);
  gtk_box_reorder_child (GTK_BOX (vbox), options, 0);
  if (customize_scoreblock (sb, name))
    {
#if 0
      DenemoScoreblock *newsb = g_malloc0 (sizeof (DenemoScoreblock));
      create_standard_scoreblock (&newsb, movement, partname);
      Denemo.project->standard_scoreblocks = g_list_prepend (Denemo.project->standard_scoreblocks, newsb);
      Denemo.project->lilysync = G_MAXUINT;
      Denemo.project->layout_id = 0;
      gtk_window_present (GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (Denemo.project->score_layout))));
      return newsb;
#else
      g_free (partname);
      return sb;
#endif
    }
  else
    {
      g_free (partname);
      return NULL;
    }
}

static void
customize_standard_scoreblock_callback (GtkWidget * widget, DenemoScoreblock * sb)
{
    if(confirm (_("Customize Layout"), _("Replace Standard Layout?")))
    { static gboolean warned;
        clone_scoreblock (sb, sb->name);
        if(!warned)
            infodialog (_("This layout will be used in place of the standard one, unless you delete it.\nAny new staffs added to the score will not appear in it unless you edit it."));
        warned = TRUE;
    } else
    clone_scoreblock (sb, NULL);
}

static void
duplicate_lilypond_scoreblock_callback (GtkWidget * widget, DenemoScoreblock * sb)
{
  customize_scoreblock (sb, NULL);
}
#if 0
//having buttons that affect the score itself is confusing
//Mark the passed widget as being for standard layouts only
static void
mark_as_non_custom (GtkWidget * button)
{
  GdkColor color;
  if (gdk_color_parse ("#B0A090", &color))
    gtk_widget_modify_bg (button, GTK_STATE_NORMAL, &color);
  g_object_set_data (G_OBJECT (button), "standard", (gpointer) 1);
}
#endif

static GtkWidget *
get_options_button (DenemoScoreblock * sb, gboolean custom)
{
  GtkWidget *frame = gtk_frame_new (_("Actions for this Layout"));
  GtkWidget *hbox = gtk_hbox_new (FALSE, 8);
  gtk_container_add (GTK_CONTAINER (frame), hbox);

  GtkWidget *button = gtk_button_new_with_label (_("Typeset"));
  gtk_widget_set_tooltip_text (button, _("Typeset the score using this layout to determine which movements, parts, titles, page breaks etc should be used"));
  gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
#ifdef USE_EVINCE
  g_signal_connect (button, "clicked", G_CALLBACK (show_print_view), NULL);
#endif
  if (custom)
    {
      if (sb->text_only)
        {
          button = gtk_button_new_with_label (_("Edit LilyPond Text of Layout"));
          gtk_widget_set_tooltip_text (button, _("Opens the LilyPond window for further editing."));
          gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
          g_signal_connect (button, "clicked", G_CALLBACK (open_lilypond_window_callback), sb);
          button = gtk_button_new_with_label (_("Duplicate"));
          gtk_widget_set_tooltip_text (button, _("Create a duplicate of this layout."));
          gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
          g_signal_connect (button, "clicked", G_CALLBACK (duplicate_lilypond_scoreblock_callback), sb);


        }
      else
        {
          button = gtk_button_new_with_label (_("Convert to LilyPond Text"));
          gtk_widget_set_tooltip_text (button, _("Converts this layout to LilyPond text for further editing."));
          gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
          g_signal_connect (button, "clicked", G_CALLBACK (convert_to_lilypond_callback), sb);

        }
      button = gtk_button_new_with_label (_("Delete"));
      gtk_widget_set_tooltip_text (button, _("Discard this customized score layout."));
      gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
      g_signal_connect (button, "clicked", G_CALLBACK (delete_custom_scoreblock_callback), sb);

      button = gtk_button_new_with_label (_("Create Default Score Layout"));
      gtk_widget_set_tooltip_text (button, _("Creates the Default Score Layout"));
      gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
      g_signal_connect (button, "clicked", G_CALLBACK (create_default_scoreblock), NULL);

    if (!sb->text_only)
       {
          button = gtk_button_new_with_label (_("Append Current Movement"));
          gtk_widget_set_tooltip_text (button, _("Appends the current movement at the end of this layout. Select the movement you wish to append to the layout in the Denemo Display first. The same movement can be placed multiple times in the layout, with individual edits as needed."));
          gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
          g_signal_connect_swapped (button, "clicked", G_CALLBACK (install_duplicate_movement_callback), sb);

          button = gtk_button_new_with_label (_("Re-order Movement"));
          gtk_widget_set_tooltip_text (button, _("Moves the first expanded movement in this layout to the end.\nThis does not alter the score, just this layout. To re-order the actual movements of the score see the Movements menu."));
          gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
          g_signal_connect_swapped (button, "clicked", G_CALLBACK (reorder_movement_callback), sb);
        }
    }
  else
    {
      button = gtk_button_new_with_label (_("Refresh"));
      gtk_widget_set_tooltip_text (button, _("Re-calculate this layout to incorporate changes made to the score structure."));
      gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
      g_signal_connect (button, "clicked", G_CALLBACK (recreate_standard_scoreblock_callback), sb);

      button = gtk_button_new_with_label (_("Customize"));
      gtk_widget_set_tooltip_text (button, _("Create a layout from this standard layout that you can then modify."));
      gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
      g_signal_connect (button, "clicked", G_CALLBACK (customize_standard_scoreblock_callback), sb);
      button = gtk_button_new_with_label (_("Delete"));
      gtk_widget_set_tooltip_text (button, _("Discard this standard score layout."));
      gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
      g_signal_connect (button, "clicked", G_CALLBACK (delete_standard_scoreblock_callback), sb);
    }


  return frame;
}



//if widget is in a standard scoreblock, clone the scoreblock converting the standard one into a custom one.
static gboolean
clone_scoreblock_if_needed (GtkWidget * widget)
{
  DenemoScoreblock *default_sb;
  if ((default_sb = get_standard_scoreblock (widget)))
    {
      //the button widget was on the default scoreblock, so we convert this to a custom scoreblock
      return clone_scoreblock (default_sb, NULL) != NULL;
    }
  return TRUE;
}


static gboolean
move_parent (GtkWidget * widget, gboolean up)
{
  if (!clone_scoreblock_if_needed (widget))
    return TRUE;

  GtkWidget *parent = gtk_widget_get_parent (widget);
  GtkWidget *grandparent = gtk_widget_get_parent (parent);
  GList *children = gtk_container_get_children (GTK_CONTAINER (grandparent));
  gint position = g_list_index (children, parent);
  if (up)
    {
      if (position > 0)
        {
          position--;
          gtk_box_reorder_child (GTK_BOX (grandparent), parent, position);
          score_status (Denemo.project, TRUE);
        }
    }
  else
    {
      position++;
      gtk_box_reorder_child (GTK_BOX (grandparent), parent, position);
      score_status (Denemo.project, TRUE);
    }
  return TRUE;
}


static gboolean
move_grandparent (GtkWidget * widget, gboolean up)
{
  if (!clone_scoreblock_if_needed (widget))
    return TRUE;

  GtkWidget *parent = gtk_widget_get_parent (gtk_widget_get_parent (widget));
  GtkWidget *grandparent = gtk_widget_get_parent (parent);
  GList *children = gtk_container_get_children (GTK_CONTAINER (grandparent));
  gint position = g_list_index (children, parent);
  if (up)
    {
      if (position > 0)
        {
          position--;
          gtk_box_reorder_child (GTK_BOX (grandparent), parent, position);
          score_status (Denemo.project, TRUE);
        }
    }
  else
    {
      position++;
      gtk_box_reorder_child (GTK_BOX (grandparent), parent, position);
      score_status (Denemo.project, TRUE);
    }
  return TRUE;
}


static gboolean
remove_element (GtkWidget * widget)
{
  if (!clone_scoreblock_if_needed (widget))
    return TRUE;

  GtkWidget *parent = gtk_widget_get_parent (widget);
  gtk_widget_destroy (parent);
  score_status (Denemo.project, TRUE);
  return TRUE;
}

static gboolean
remove_parent_element (GtkWidget * widget)
{
  if (!clone_scoreblock_if_needed (widget))
    return TRUE;
  GtkWidget *parent = gtk_widget_get_parent (gtk_widget_get_parent (widget));
  gtk_widget_destroy (parent);
  score_status (Denemo.project, TRUE);
  return TRUE;
}

static gboolean
remove_lyric_element (GtkWidget * widget, gchar * context_text)
{
  if (!clone_scoreblock_if_needed (widget))
    return TRUE;
  GtkWidget *parent = gtk_widget_get_parent (widget);
  GtkWidget *grandparent = gtk_widget_get_parent (parent);
  gtk_widget_destroy (parent);
  GList *postfixes = (GList *) g_object_get_data (G_OBJECT (grandparent), "postfix");
  g_object_set_data (G_OBJECT (grandparent), "postfix", (gpointer) g_list_remove (postfixes, context_text));
  //free context_text here
  score_status (Denemo.project, TRUE);
  return TRUE;
}


static void substitute_voice_name (GtkWidget *button, GtkWidget *frame)
{
    if (!clone_scoreblock_if_needed (frame))
        return;
    GList *m;
    gint mvmnt = 1, staffnum = Denemo.project->movement->currentstaffnum;
    if (Denemo.project->movements)
        mvmnt = 1 + g_list_index (Denemo.project->movements, Denemo.project->movement);

    gchar *thename = g_strdup_printf ("\\Mvmnt%dVoice%d", mvmnt, staffnum);
    GString *initial = g_string_new (thename);
    g_free (thename);
    GString *lily = g_string_new ("");
    set_lily_name (initial, lily);
    GList *g = g_object_get_data (G_OBJECT (frame), "prefix");
    if (g)
        {
          gchar *oldlily = (gchar *) g->data;
          edit_lilypond_prefix (frame, oldlily, g_strdup(lily->str));
          score_status (Denemo.project, TRUE);
          gchar *text = g_strdup_printf (_("The music for this staff has been replaced by the music from the current staff, i.e. staff where the cursor is, Movement %d, Staff %d."), mvmnt, staffnum);
          infodialog (text);
        }
    g_string_free (lily, TRUE);
}


static GtkWidget *
create_voice_widget (DenemoStaff * staff, gchar * voicename, guint location)
{
  gchar *name = staff->denemo_name->str;
  GtkWidget *ret = gtk_hbox_new (FALSE, 8);
  GtkWidget *w = gtk_button_new_with_label (_("Edit"));
  gtk_widget_set_tooltip_text (w, _("Edit the voice directives for this layout"));
  gtk_box_pack_start (GTK_BOX (ret), w, FALSE, TRUE, 0);
  g_signal_connect (w, "clicked", G_CALLBACK (prefix_edit_callback), ret);

  w = gtk_button_new_with_label ("X");
  gtk_widget_set_tooltip_text (w, _("Delete this voice from the score layout\nNote that if it is the first voice the clef time and keysignatures will be deleted too."));
  g_signal_connect (w, "clicked", G_CALLBACK (remove_element), NULL);
  gtk_box_pack_end (GTK_BOX (ret), w, FALSE, TRUE, 0);

  gchar *text = g_strdup_printf (" \\%s", voicename);
  gchar *label_text = _("Initial Signatures");
  if (staff->voicecontrol == DENEMO_PRIMARY)
    {
      GtkWidget *expander = gtk_expander_new (label_text);
      gtk_widget_set_tooltip_text (expander, _("Click here to view and edit the clef, key and time signatures of this staff"));
      gtk_box_pack_start (GTK_BOX (ret), expander, FALSE, TRUE, 0);
      GtkWidget *hbox = gtk_hbox_new (FALSE, 8);
      gtk_container_add (GTK_CONTAINER (expander), hbox);

      GtkWidget *button = gtk_button_new_with_label (_("Clef"));
      gtk_widget_set_tooltip_text (button, _("Edit the LilyPond definition of the clef. The editing affects only this layout."));
      g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (prefix_edit_callback), button);
      add_lilypond (button, get_lilypond_for_clef (&staff->clef), NULL);
      gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);

      button = gtk_button_new_with_label (_("Key"));
      gtk_widget_set_tooltip_text (button, _("Edit the LilyPond definition of the key signature. The editing affects only this layout."));
      g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (prefix_edit_callback), button);
      add_lilypond (button, get_lilypond_for_keysig (&staff->keysig), NULL);
      gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);

      button = gtk_button_new_with_label (_("Time"));
      gtk_widget_set_tooltip_text (button, _("Edit the LilyPond definition of the time signature. The editing affects only this layout."));
      g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (prefix_edit_callback), button);
      add_lilypond (button, get_lilypond_for_timesig (&staff->timesig), NULL);
      gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
    }
  else
    {                           //Make a matching expander so the music aligns with primary voice

      GtkWidget *expander = gtk_expander_new (label_text);
      gtk_widget_set_sensitive (expander, FALSE);
      gtk_widget_set_tooltip_text (expander, _("The clef, time and key signatures attached to other voices are ignored, only the primary one has effect"));
      gtk_box_pack_start (GTK_BOX (ret), expander, FALSE, TRUE, 0);
    }
  gchar *music = g_strconcat (_("Music for "), name, NULL);
  w = gtk_button_new_with_label (music);
  gtk_widget_set_tooltip_text (w, _("Click here to move the Denemo cursor to the start of this music.\nThe actual notes live here. You can only edit these in the main Denemo display.\nHowever you can place conditional directives that are to be used only when using this layout. For example page breaks just for this layout can be placed at points in the music.\n"));
  g_signal_connect (G_OBJECT (w), "clicked", G_CALLBACK (navigate_to_location), GINT_TO_POINTER (location));
  g_free (music);
  add_lilypond (w, text, NULL);
  gtk_box_pack_start (GTK_BOX (ret), w, FALSE, TRUE, 0);

  GtkWidget *button = gtk_button_new_with_label (_("Substitute"));
  gtk_widget_set_tooltip_text (button, _("Substitute the music of this staff/voice with the music of the current staff/voice.\nYou can click the \"Music for ...\" button to move the cursor in the Denemo Display onto the staff/voice whose music you want to use before clicking this button to substitute the music. The editing affects only this layout."));
  g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (substitute_voice_name), w);//prefix_edit_callback), w);
  gtk_box_pack_start (GTK_BOX (ret), button, FALSE, TRUE, 0);

  return ret;
}

static GtkWidget *
create_lyric_widget (gchar * context_text, gchar * name)
{
  GtkWidget *ret = gtk_hbox_new (FALSE, 8);

  GtkWidget *w = gtk_button_new_with_label ("X");
  gtk_widget_set_tooltip_text (w, _("Drop this lyric part from the score layout"));
  g_signal_connect (w, "clicked", G_CALLBACK (remove_lyric_element), context_text);
  gtk_box_pack_end (GTK_BOX (ret), w, FALSE, TRUE, 0);
  w = gtk_button_new_with_label (name);
  //FIXME pop up the lyrics here or some info, or navigate??
  gtk_box_pack_start (GTK_BOX (ret), w, FALSE, TRUE, 0);

  w = gtk_button_new_with_label ("⬆");
  gtk_widget_set_tooltip_text (w, _("Move this lyric part above the staff for this score layout"));
  gtk_box_pack_start (GTK_BOX (ret), w, FALSE, TRUE, 0);
  g_signal_connect (w, "clicked", G_CALLBACK (move_parent), (gpointer) TRUE);
  w = gtk_button_new_with_label ("⬇");
  gtk_widget_set_tooltip_text (w, _("Move this lyric part below the staff for this score layout"));
  gtk_box_pack_start (GTK_BOX (ret), w, FALSE, TRUE, 0);
  g_signal_connect (w, "clicked", G_CALLBACK (move_parent), (gpointer) FALSE);
  return ret;
}

static void
install_voice (DenemoStaff * staff, gint movementnum, gint voice_count, GtkWidget * vbox)
{

  gchar *voicetag = get_voicetag (movementnum, voice_count);
  gchar *voicename = get_voicename (movementnum, voice_count);
  GtkWidget *voice = create_voice_widget (staff, voicename, get_location (movementnum, voice_count));

  GString *voicetext = g_string_new ("");
   //That is \new Voice = name prefix { postfix FIXME is prefix any use here????
  set_voice_definition (voicetext, staff, voicetag);
  gchar *text = g_strdup_printf (" %s ", voicetext->str);
  g_string_assign (voicetext, "");
  set_voice_termination (voicetext, staff);     // TAB TAB"} %End of voice" if not overridden
  add_lilypond (voice, text, g_string_free (voicetext, FALSE));


  gtk_box_pack_start (GTK_BOX (vbox), voice, FALSE, TRUE, 0);
}

static void
do_verses (DenemoStaff * staff, GtkWidget * vbox, gint movementnum, gint voice_count)
{
  //FIXME do text of the verses get_text_from_view(GtkWidget *textview) where staff->verse_views->data is textview widget
  GList *g = staff->verse_views;
  gint versenum = 1;
  if(!staff->hide_lyrics)
      for (versenum = 1; g; g = g->next, versenum++)
        {
          gchar *versename = get_versename (movementnum, voice_count, versenum);
          gchar *context_text = g_strdup_printf ("\n" TAB "\\%s%s", versename, "Context\n");
          //gchar *label = g_strconcat("Lyrics:", staff->denemo_name->str, NULL);
          gchar *label = g_strdup_printf ("Verse %d: %s", versenum, staff->denemo_name->str);
          GtkWidget *voice = create_lyric_widget (context_text, label);
          g_free (label);
          gchar *lyrics = g_strdup_printf ("\n" TAB "\\new Lyrics = %s\n", versename /*e.g. MvmntIVoiceIVerseI */ );
          add_lilypond (voice, lyrics, NULL);       //FIXME the destroy of these widgets should free the string
          add_lilypond (voice, NULL, context_text);

          gtk_box_pack_start (GTK_BOX (vbox), voice, FALSE, TRUE, 0);       //has to go outside the staff

          g_free (versename);
        }
}


//if oldval is in the prefix list attached to widget, replace it with newval and free oldval
static gboolean
edit_lilypond_prefix (GtkWidget * widget, gchar * oldval, gchar * newval)
{
  GList *g;
  for (g = g_object_get_data (G_OBJECT (widget), "prefix"); g; g = g->next)
    if (!strcmp ((gchar *) g->data, oldval))
      {
        g->data = (gpointer) newval;
        g_free (oldval);
        return TRUE;
      }
  return FALSE;
}


static void
prefix_edit_callback (GtkWidget * widget, GtkWidget * frame)
{
  if (!clone_scoreblock_if_needed (frame))
    return;
  GList *g = g_object_get_data (G_OBJECT (frame), "prefix");
  if (g)
    {
      gchar *lily = (gchar *) g->data;
      gchar *newval = string_dialog_editor_with_widget (Denemo.project, _("Edit LilyPond"), _("Edit this using LilyPond syntax\nThe editing applies just to this score layout"), lily ? lily : "", NULL, NULL);
      if (newval)
        {
          edit_lilypond_prefix (frame, lily, newval);
          score_status (Denemo.project, TRUE);
        }
    }
}

static void
affixes_delete_callback (GtkWidget * widget, GtkWidget * frame)
{
  if (!clone_scoreblock_if_needed (frame))
    return;
  GList *g = g_object_get_data (G_OBJECT (frame), "prefix");
  if (g)
    g_free (g->data);
  g_object_set_data (G_OBJECT (frame), "prefix", NULL);
  g = g_object_get_data (G_OBJECT (frame), "postfix");
  if (g)
    g_free (g->data);
  g_object_set_data (G_OBJECT (frame), "postfix", NULL);
  gtk_frame_set_label_widget (GTK_FRAME (frame), NULL);

  score_status (Denemo.project, TRUE);
}


static gboolean
popup (GtkWidget * button, GtkWidget * menu)
{
  gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, 0, GDK_CURRENT_TIME);
  return FALSE;
}

static void
create_element (GtkWidget * vbox, GtkWidget * widget, gchar * lilypond)
{
  GtkWidget *hbox = gtk_hbox_new (FALSE, 8);
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
  add_lilypond (hbox, lilypond, NULL);
  gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, TRUE, 0);
  GtkWidget *button = gtk_button_new_with_label (_("Edit"));
  gtk_widget_set_tooltip_text (button, _("Edit this element for this layout"));
  gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
  g_signal_connect (button, "clicked", G_CALLBACK (prefix_edit_callback), hbox);
  button = gtk_button_new_with_label ("⬆");
  gtk_widget_set_tooltip_text (button, _("Move this element upwards for this score layout"));
  gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
  g_signal_connect (button, "clicked", G_CALLBACK (move_parent), (gpointer) TRUE);
  button = gtk_button_new_with_label ("⬇");
  gtk_widget_set_tooltip_text (button, _("Move this element downwards for this score layout"));
  gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
  g_signal_connect (button, "clicked", G_CALLBACK (move_parent), (gpointer) FALSE);
  button = gtk_button_new_with_label ("X");
  gtk_widget_set_tooltip_text (button, _("Remove this element from this layout"));
  gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, TRUE, 0);
  g_signal_connect (button, "clicked", G_CALLBACK (remove_element), NULL);
  gtk_widget_show_all (hbox);
}



//gtk_expander_set_expanded (expander,gtk_expander_get_expanded (expander));
/* UNUSED
static void
toggle_expand (GtkWidget * item, GtkWidget * expander)
{
  gtk_expander_set_expanded (GTK_EXPANDER (expander), !gtk_expander_get_expanded (GTK_EXPANDER (expander)));
}
*/

static void
page_break (GtkWidget * item, GtkWidget * vbox)
{
  if (!clone_scoreblock_if_needed (vbox))
    return;
  GtkWidget *button = gtk_button_new_with_label (_("Page Break"));
  gtk_widget_set_tooltip_text (button, _("This forces a new page, useful for avoiding page turns\n"));
  create_element (vbox, button, g_strdup ("\\pageBreak\n"));
  gtk_box_reorder_child (GTK_BOX (vbox), gtk_widget_get_parent (button), 0);
  score_status (Denemo.project, TRUE);
}

static void
blank_page (GtkWidget * item, GtkWidget * vbox)
{
  if (!clone_scoreblock_if_needed (vbox))
    return;
  GtkWidget *button = gtk_button_new_with_label (_("Blank Page"));
  gtk_widget_set_tooltip_text (button, _("This prints a page intentionally left blank, useful for avoiding page turns\n"));
  create_element (vbox, button, g_strdup ("\\pageBreak\n\\markup \\italic \"This page is intentionally left blank\"\n\\pageBreak\n"));
  gtk_box_reorder_child (GTK_BOX (vbox), gtk_widget_get_parent (button), 0);
  score_status (Denemo.project, TRUE);
}

static void
custom_lilypond (GtkWidget * item, GtkWidget * vbox)
{
  if (!clone_scoreblock_if_needed (vbox))
    return;
  GtkWidget *button = gtk_button_new_with_label ("LilyPond");
  gtk_widget_set_tooltip_text (button, _("This lets you insert your own titles etc just for this layout.\nFor book titles use \\titledPiece \\markup \"myname\"\nSimple titles are not placed here, but appear in a header block at the end of the movement.\nFor other possible uses, see LilyPond manual."));
  create_element (vbox, button, g_strdup ("%Enter LilyPond syntax here\n"));
  gtk_box_reorder_child (GTK_BOX (vbox), gtk_widget_get_parent (button), 0);
  score_status (Denemo.project, TRUE);
}

static GtkWidget *
get_titles_menu (GtkWidget * vbox)
{
  GtkWidget *menu = gtk_menu_new ();
  GtkWidget *item;

  item = gtk_menu_item_new_with_label (_("Create Page Break"));
  gtk_widget_set_tooltip_text (item, _("This inserts a page break, useful for avoiding page turns\nMove it before the title (using the up arrow) once created!"));
  g_signal_connect (item, "activate", G_CALLBACK (page_break), vbox);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);

  item = gtk_menu_item_new_with_label (_("Create Blank Page"));
  gtk_widget_set_tooltip_text (item, _("This inserts a page intentionally left blank, useful for avoiding page turns when printing on both sides of the paper"));
  g_signal_connect (item, "activate", G_CALLBACK (blank_page), vbox);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);

  item = gtk_menu_item_new_with_label (_("Insert LilyPond"));
  gtk_widget_set_tooltip_text (item, _(_("This creates a LilyPond comment which you can then edit to give titles etc for this movment, applying just to this layout.")));
  g_signal_connect (item, "activate", G_CALLBACK (custom_lilypond), vbox);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);

  item = gtk_separator_menu_item_new ();
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);

  gtk_widget_show_all (menu);
  return menu;
}


//return a newly allocated label to hint at the contents of a directive
static gchar *
label_for_directive (DenemoDirective * d)
{
  gchar *text = g_strdup_printf ("%s%s%.25s", d->tag ? d->tag->str : "<Unknown Tag>", d->display ? ": " : "", d->display ? d->display->str : "");
  gchar *etext = g_strescape (text, NULL);
  g_free (text);
  return etext;
}

static void
popup_movement_menu (GtkWidget * w, GtkWidget * vbox)
{
  gtk_menu_popup (GTK_MENU (get_titles_menu (vbox)), NULL, NULL, NULL, NULL, 0, GDK_CURRENT_TIME);
}

static void
popup_movement_titles_menu (GtkWidget * button)
{
  GtkWidget *menuitem = gtk_ui_manager_get_widget (Denemo.ui_manager, "/ObjectMenu/MovementMenu/Titles/BookTitles");
  if (get_standard_scoreblock (button))
    {
      if (menuitem)
        gtk_menu_popup (GTK_MENU (gtk_menu_item_get_submenu (GTK_MENU_ITEM (menuitem))), NULL, NULL, NULL, NULL, 0, GDK_CURRENT_TIME);
      else
        g_warning ("No such menu path");
    }
  else
    warningdialog (_("This button is for changing the score itself, it will not affect this custom layout"));
}

/* installs movement titles, page breaks etc
 *
 */
static void
install_pre_movement_widgets (GtkWidget * vbox, DenemoMovement * si, gboolean standard)
{
  GtkWidget *frame = gtk_frame_new (NULL);
  gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
  GtkWidget *expander = gtk_expander_new (_("Movement Titles, Page Breaks etc"));
  gtk_widget_set_tooltip_text (expander, _("In here are settings for the movement title, page breaks before the movement etc"));
  gtk_container_add (GTK_CONTAINER (frame), expander);

  GtkWidget *inner_vbox = gtk_vbox_new (FALSE, 8);
  gtk_container_add (GTK_CONTAINER (expander), inner_vbox);

  GtkWidget *inner_hbox = gtk_hbox_new (FALSE, 8);
  gtk_box_pack_start (GTK_BOX (inner_vbox), inner_hbox, FALSE, TRUE, 0);
  GtkWidget *button;
#if 0
//having buttons that affect the score itself is confusing
  if(standard)
    {
      button = gtk_button_new_with_label (_("Create Titles for Movement"));
      mark_as_non_custom (button);
      gtk_widget_set_tooltip_text (button, _("Set book titles for this movement in the score"));
      g_signal_connect (button, "clicked", G_CALLBACK (popup_movement_titles_menu), NULL);
      gtk_box_pack_start (GTK_BOX (inner_hbox), button, FALSE, TRUE, 0);
    }
#endif

  button = gtk_button_new_with_label (_("Create for Custom Layout"));
  gtk_widget_set_tooltip_text (button, _("Create page breaks, blank pages ...for this layout"));
  g_signal_connect (button, "clicked", G_CALLBACK (popup_movement_menu), inner_vbox);
  gtk_box_pack_start (GTK_BOX (inner_hbox), button, FALSE, TRUE, 0);

  GList *g;
  for (g = si->movementcontrol.directives; g; g = g->next)
    {
      DenemoDirective *d = (DenemoDirective *) g->data;
      if (d->override & DENEMO_OVERRIDE_AFFIX)
        continue;
      if (d->override & DENEMO_OVERRIDE_HIDDEN)
        continue;
      if (d->prefix)
        {
          gchar *text = label_for_directive (d);
          GtkWidget *label = gtk_label_new (text);
          g_free (text);
          create_element (inner_vbox, label, g_strdup (d->prefix->str));
        }
    }
}

static void
popup_score_titles_menu (GtkWidget * button)
{
  GtkWidget *menuitem = gtk_ui_manager_get_widget (Denemo.ui_manager, "/ObjectMenu/Score/Titles/BookTitles");
  if (get_standard_scoreblock (button))
    {
      if (menuitem)
        gtk_menu_popup (GTK_MENU (gtk_menu_item_get_submenu (GTK_MENU_ITEM (menuitem))), NULL, NULL, NULL, NULL, 0, GDK_CURRENT_TIME);
      else
        g_warning ("No such menu path");
    }
  else
    warningdialog (_("This button is for changing the score itself, it will not affect this custom layout"));
}


/* install widgets for the postfix field of score directives (lilycontrol.directives) which are not hidden and which are not OVERRIDE_AFFIX -
 * the prefix is done in create_score_directives.
 * Ones with OVERRIDE_AFFIX are done in set_default_scoreblock()
 */
static GtkWidget *
install_scoreblock_overrides (GtkWidget * vbox, DenemoProject * gui, DenemoMovement * si, gboolean last_movement)
{

  GList *g;
  for (g = gui->lilycontrol.directives; g; g = g->next)
    {
      DenemoDirective *d = g->data;
      if (d->override & DENEMO_OVERRIDE_HIDDEN)
        continue;
      if (d->override & DENEMO_OVERRIDE_AFFIX)
        continue;
      gchar *start = (d->postfix && d->postfix->len) ? d->postfix->str : NULL;
      if (start)
        {
          GtkWidget *frame = gtk_frame_new (NULL);

          gchar *text = label_for_directive (d);
          GtkWidget *button = gtk_button_new_with_label (text);
          g_free (text);
          gtk_frame_set_label_widget (GTK_FRAME (frame), button);
          gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
          gchar *lily = g_strdup_printf ("\n<< %s\n<< ", start);
          add_lilypond (frame, lily, g_strdup ("\n          >>\n>>"));

          GtkWidget *menu = gtk_menu_new ();
          GtkWidget *menuitem = gtk_menu_item_new_with_label ("Edit");
          g_signal_connect (menuitem, "activate", G_CALLBACK (prefix_edit_callback), frame);
          gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
          menuitem = gtk_menu_item_new_with_label ("Delete");
          g_signal_connect (menuitem, "activate", G_CALLBACK (affixes_delete_callback), frame);
          gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
          gtk_widget_show_all (menu);
          g_signal_connect (button, "clicked", G_CALLBACK (popup), menu);



          vbox = gtk_vbox_new (FALSE, 8);
          gtk_container_add (GTK_CONTAINER (frame), vbox);
        }
    }
  return vbox;
}



static gboolean
draw_staff_brace_for_layout (GtkWidget * w, cairo_t *cr, gchar * context)
{
  GtkAllocation allocation;
  gtk_widget_get_allocation (w, &allocation);
  gint height = allocation.height;
  cairo_set_source_rgb (cr, 0.9, 0.9, 0.9);
  cairo_paint (cr);
  gboolean curly = !((!strcmp (context, "ChoirStaffStart")) || (!strcmp (context, "GroupStaffStart")));
  draw_staff_brace (cr, curly, 5, 8, height*0.9 - 15);
  return TRUE;
}
static gboolean
draw_staff_brace_gtk2 (GtkWidget * w, GdkEventExpose * event, gchar * context)
{
  cairo_t *cr = gdk_cairo_create (event->window);
  gdk_cairo_region (cr, event->region);
  cairo_clip (cr);
  draw_staff_brace_for_layout (w, cr, context);
  cairo_destroy (cr);
  return TRUE;
}

static void
show_type (GtkWidget * widget, gchar * message)
{
  g_message ("%s%s", message, widget ? g_type_name (G_TYPE_FROM_INSTANCE (widget)) : "NULL widget");
}

static void delete_brace (gchar *postfix)
{
    gchar *c = g_strrstr (postfix, ">>%");
    if(c && c>postfix) {
            *c = 0;
            return;
        }

#if 0
    gchar *c = postfix;
    while (*(c++));
        c--;c--;c--;
        if(c != postfix)
            while (*(c--) != '\n');
            c++;
            if(*c=='\n')
                *c=0;
#endif
}
static void remove_brace_end (GtkWidget *vbox)
{
 show_type (vbox, "new vbox ??? ")  ;
  GList *g  = g_object_get_data (G_OBJECT(vbox), "postfix");
  for ( ;g;g=g->next)
        {
           g_print ("Next postfix %s\n", (char *) g->data);
           delete_brace (g->data);
           g_print ("transformed to %s\n", (char *) g->data);
        }
}
static gboolean
remove_context (GtkWidget * button, GtkWidget * parent)
{
  if (!clone_scoreblock_if_needed (parent))
    return TRUE;
     show_type (parent, "parent ");
  GList *children = gtk_container_get_children (GTK_CONTAINER (parent));
  //show_type (g_list_last (children)->data, "vbox type is");
  //show_type (gtk_widget_get_parent (gtk_widget_get_parent (parent)), "Reparenting on ");
  GtkWidget *vbox = g_list_last (children)->data;
  GList *staff_list = gtk_container_get_children (GTK_CONTAINER (vbox));
  GList *g;
  for (g = staff_list; g; g = g->next)
    {
      //show_type (g->data, "The staff frame is ");
      gtk_widget_reparent (g->data,     //frame
                           gtk_widget_get_parent (gtk_widget_get_parent (parent)));
    }

    GtkWidget *topw = gtk_widget_get_parent (gtk_widget_get_parent (gtk_widget_get_parent (parent)));
    //show_type (topw, "new vbox parent ");g_print ("parent %p, grandparent %p, great-grp %p\n", parent, gtk_widget_get_parent (parent), topw);

    if (g_object_get_data (G_OBJECT(parent), "postfix")==NULL)
       remove_brace_end (gtk_bin_get_child (g_list_last(staff_list)->data));  // without it deleting a top level brace leaving lower ones fails.
     else
    for (g=g_object_get_data (G_OBJECT(parent), "postfix");g;g=g->next)
        {
         delete_brace (g->data);
         if (GTK_IS_BOX (topw))
            add_lilypond (topw, NULL, g_strdup (g->data));
        }
  Denemo.project->lilysync = G_MAXUINT;
  gtk_widget_destroy (gtk_widget_get_parent (parent));
  return TRUE;
}

//Move the frame above into this frame's vbox, unless we are inside it.
/* UNUSED
static gboolean
move_context_up (GtkWidget * button, GtkWidget * parent)
{                               //!!!! these not working
  if (!clone_scoreblock_if_needed (parent))
    return TRUE;
  DenemoScoreblock *sb = get_custom_scoreblock (parent);
  gint index = g_list_index (sb->staff_list, parent);
  if (index > 0)
    {
      GtkWidget *frame = (GtkWidget *) g_list_nth (sb->staff_list, index - 1)->data;
      if (!gtk_widget_is_ancestor (parent, frame))
        {
          GtkWidget *hbox = gtk_bin_get_child (GTK_BIN (parent));
          GList *children = gtk_container_get_children (GTK_CONTAINER (hbox));
          GtkWidget *vbox = g_list_last (children)->data;
          g_list_free (children);
          gtk_widget_reparent (frame, vbox);
          gtk_box_reorder_child (GTK_BOX (vbox), frame, 0);
          //now move the frame on one in the list of frames
          sb->staff_list = g_list_remove (sb->staff_list, frame);
          sb->staff_list = g_list_insert (sb->staff_list, frame, index);
          //layout = ???
        }
    }
  return TRUE;
}
*/
//Move the frame below into this frame's vbox, unless we are inside it.
/* UNUSED
static gboolean
move_context_down (GtkWidget * button, GtkWidget * parent)
{
  if (!clone_scoreblock_if_needed (parent))
    return TRUE;
  DenemoScoreblock *sb = get_custom_scoreblock (parent);        //!!!!doesn't work see junk.denemo
  g_assert (sb);
  gint index = g_list_index (sb->staff_list, parent);
  if (index < g_list_length (sb->staff_list))
    {
      GtkWidget *frame = (GtkWidget *) g_list_nth (sb->staff_list, index + 1)->data;
      if (!gtk_widget_is_ancestor (parent, frame))
        {
          GtkWidget *hbox = gtk_bin_get_child (GTK_BIN (parent));
          GList *children = gtk_container_get_children (GTK_CONTAINER (hbox));
          GtkWidget *vbox = g_list_last (children)->data;
          g_list_free (children);
          gtk_widget_reparent (frame, vbox);
          gtk_box_reorder_child (GTK_BOX (vbox), frame, -1);
          //now move the frame on one in the list of frames
          //sb->staff_list = g_list_remove(sb->staff_list, frame);
          //sb->staff_list = g_list_insert(sb->staff_list, frame, index);
//                      layout_sync = ???
        }
    }
  return TRUE;
}
*/

static GtkWidget *
install_staff_group_start (GList ** pstaffs, GtkWidget * vbox, GList * directives, gint * nesting)
{
  GList *g;
  for (g = directives; g; g = g->next)
    {
      DenemoDirective *directive = g->data;
      if (directive->override & DENEMO_OVERRIDE_AFFIX)
        {
          if (directive->prefix && (directive->prefix->len > 0))
            {
              GtkWidget *frame = (GtkWidget *) gtk_frame_new (directive->tag->str);
              add_lilypond (frame, directive->prefix ? g_strdup (directive->prefix->str) : NULL, directive->postfix ? g_strdup (directive->postfix->str) : NULL);
              (*nesting)++;
              *pstaffs = g_list_append (*pstaffs, frame);
              g_signal_connect (G_OBJECT (frame), "destroy", G_CALLBACK (remove_from_staff_list), pstaffs);
              gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
              GtkWidget *hbox = gtk_hbox_new (FALSE, 8);
              gtk_container_add (GTK_CONTAINER (frame), hbox);


              GtkWidget *layout = gtk_drawing_area_new ();
              gtk_widget_set_tooltip_text (layout, _("This brace connects together several staffs - you can delete it for a customized layout."));

#if GTK_MAJOR_VERSION != 2
              g_signal_connect (G_OBJECT (layout), "draw", G_CALLBACK (draw_staff_brace_for_layout), directive->tag->str);
#else
              g_signal_connect (G_OBJECT (layout), "expose_event", G_CALLBACK (draw_staff_brace_gtk2), directive->tag->str);
#endif

              gint width = 20, height = 100;
              gtk_widget_set_size_request (layout, width, height);

              gtk_box_pack_start (GTK_BOX (hbox), layout, TRUE, TRUE, 0);


              GtkWidget *controls = gtk_vbox_new (FALSE, 8);
              gtk_box_pack_start (GTK_BOX (hbox), controls, FALSE, TRUE, 0);

              GtkWidget *button = gtk_button_new_with_label ("X");
              gtk_widget_set_tooltip_text (button, _("Remove this staff brace from these staffs for a customized layout."));
              g_signal_connect (button, "clicked", G_CALLBACK (remove_context), hbox);
              gtk_box_pack_start (GTK_BOX (controls), button, FALSE, TRUE, 0);
              vbox = gtk_vbox_new (FALSE, 8);   //this vbox will be passed back so that the staffs can be put inside this staff group frame.
              gtk_box_pack_end (GTK_BOX (hbox), vbox, FALSE, TRUE, 0);
            }
        }
    }
  return vbox;
}

static GtkWidget *
install_staff_group_end (GtkWidget * vbox, GList * directives, gint * nesting)
{
  GList *g;
  for (g = directives; g; g = g->next)
    {
      DenemoDirective *directive = g->data;
      if (directive->override & DENEMO_OVERRIDE_AFFIX)
        {
          if (directive->postfix && (directive->postfix->len > 0))
            {
              if (*nesting)
                {
                    //show_type (gtk_widget_get_parent (vbox), "Adding beam ends to type: "); g_print ("Specifically %s to %p\n", directive->postfix->str, gtk_widget_get_parent (vbox));
                  add_lilypond (gtk_widget_get_parent (vbox), NULL, g_strdup (directive->postfix->str));
                  gint number_of_ends =  1;
                  if(directive->data)
                    number_of_ends = atoi (directive->data->str);
                  if (number_of_ends<0 || (number_of_ends>10)) number_of_ends = 1;//sanity check on data in directive

                  (*nesting) -=  number_of_ends;
                  vbox = gtk_widget_get_parent (gtk_widget_get_parent (gtk_widget_get_parent (vbox)));
                }
              else
                g_warning ("Badly placed end of staff group - ignored");
            }
        }
    }
  return vbox;
}

static GtkWidget *
get_label (GtkWidget * button)
{
  if (GTK_IS_CONTAINER (button))
    {
      GList *g = gtk_container_get_children (GTK_CONTAINER (button));
      for (; g; g = g->next)
        if (GTK_IS_LABEL (g->data))
          return GTK_WIDGET (g->data);
    }
  return NULL;
}

static GtkWidget *
get_large_button (gchar * text)
{
  GtkWidget *button = gtk_button_new_with_label ("dummy");
  GtkWidget *label = get_label (button);
  gchar *markup = g_markup_printf_escaped ("<big>%s</big>", text);
  gtk_label_set_markup (GTK_LABEL (label), markup);
  g_free (markup);
  return button;
}

static GtkWidget *
get_small_button (gchar * text)
{
  GtkWidget *button = gtk_button_new_with_label ("dummy");
  GtkWidget *label = get_label (button);
  gchar *markup = g_markup_printf_escaped ("<small>%s</small>", text);
  gtk_label_set_markup (GTK_LABEL (label), markup);
  g_free (markup);
  return button;
}

static void
add_staff_widget (DenemoStaff * staff, GtkWidget * hbox)
{
  gchar *clef_glyph = "\xF0\x9D\x84\x9E     ";
  switch (staff->clef.type)
    {
    case DENEMO_FRENCH_CLEF:

    case DENEMO_TREBLE_CLEF:
      clef_glyph = "��     ";
      break;
    case DENEMO_G_8_CLEF:
      clef_glyph = "��  ";
      break;

    case DENEMO_F_8_CLEF:
      clef_glyph = "��   ";
      break;

    case DENEMO_BASS_CLEF:
      clef_glyph = "��     ";
      break;
    case DENEMO_SOPRANO_CLEF:
    case DENEMO_ALTO_CLEF:
    case DENEMO_TENOR_CLEF:
      clef_glyph = "��   ";
      break;
    default:
      break;
    }
  GtkWidget *button = get_large_button (clef_glyph);
  gtk_widget_set_tooltip_text (button, _("This shows the clef in the Denemo score - the actual clef printed may be modified by Directives attached to it.\nYou can edit the clef for a custom layout - do this on the first voice on the staff."));
  gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);

  button = get_small_button ("⬆");
  gtk_widget_set_tooltip_text (button, _("Move this staff (with all its voices) above the preceding staff."));
  gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
  g_signal_connect (button, "clicked", G_CALLBACK (move_grandparent), (gpointer) TRUE);
  button = get_small_button ("⬇");
  gtk_widget_set_tooltip_text (button, _("Move this staff (with all its voices) after the following staff."));
  gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
  g_signal_connect (button, "clicked", G_CALLBACK (move_grandparent), (gpointer) FALSE);

  button = gtk_button_new_with_label ("X");
  gtk_widget_set_tooltip_text (button, _("Remove this staff (with all its voices) for customized layout."));

  gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, TRUE, 0);
  g_signal_connect_swapped (button, "clicked", G_CALLBACK (remove_parent_element), hbox);
}

/* UNUSED
static void
popup_initial_clef_menu (GtkWidget * button)
{
  GtkWidget *menuitem = gtk_ui_manager_get_widget (Denemo.ui_manager, "/ObjectMenu/ClefMenu");
  if (menuitem)
    gtk_menu_popup (GTK_MENU (gtk_menu_item_get_submenu (GTK_MENU_ITEM (menuitem))), NULL, NULL, NULL, NULL, 0, GDK_CURRENT_TIME);
  else
    g_warning ("No such menu path");
}
*/

static void
install_staff_with_voices (GList ** pstaffs, GtkWidget **pvbox, gchar *partname, GList **pstafflist,
    gint *pvoice_count, gint staff_count, gint movementnum, gint *pstaff_group_nesting, gboolean standard, gboolean append_only)
      {
        DenemoMovement *si = Denemo.project->movement;
      GList *g = *pstafflist;
      GtkWidget *vbox = *pvbox;
      DenemoStaff *staff = g->data;
      DenemoStaff *nextstaff = g->next ? g->next->data : NULL;


      //if (partname == NULL) Don't omit staff groups start for single part, since parts can be multi-staff e.g. piano, it will be closed at the end if the part doesn't include the close
      if(!append_only)
        vbox = install_staff_group_start (pstaffs, vbox, staff->staff_directives, pstaff_group_nesting);

      if (staff->hasfakechords)
        {                       //the reason these are outside the staff frame is it makes them appear above the staff
          GtkWidget *chords = gtk_label_new (_("Chord Symbols"));
          gchar *text = g_strdup_printf ("\n" TAB TAB "\\new ChordNames \\chordmode { \\%sChords }\n",
                                         get_voicename (movementnum, (*pvoice_count)));
          add_lilypond (chords, text, NULL);
          gtk_box_pack_start (GTK_BOX (vbox), chords, FALSE, TRUE, 0);
          *pstaffs = g_list_append (*pstaffs, chords);
          g_signal_connect (G_OBJECT (chords), "destroy", G_CALLBACK (remove_from_staff_list), pstaffs);
        }

      gchar *label_text = (si->thescore->next == NULL) ? g_strdup (_("Staff Menu")) : g_strdup_printf (_("Staff %d Menu"), staff_count);
      GtkWidget *frame = gtk_frame_new (NULL);

      GtkWidget *staff_hbox = gtk_hbox_new (FALSE, 8);
      //gtk_frame_set_label_widget (GTK_FRAME (frame), staff_hbox); !!!!! setting the label widget it's position looks odd because no frame is visible
      GtkWidget *button = gtk_button_new_with_label (label_text);
      g_free (label_text);
      gtk_box_pack_start (GTK_BOX (staff_hbox), button, FALSE, TRUE, 0);
      gtk_widget_set_tooltip_text (button, _("Click for a menu to position the Denemo cursor on this staff\nor to alter this staff for a customized layout"));


      GtkWidget *menu = gtk_menu_new ();
      GtkWidget *menuitem = gtk_menu_item_new_with_label (_("Move Denemo Cursor to this staff"));
      gtk_widget_set_tooltip_text (menuitem, _("This will move the Denemo Cursor to the start of this staff in this movement"));
      g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (navigate_to_location), GINT_TO_POINTER (get_location (movementnum, (*pvoice_count))));
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);



      menuitem = gtk_menu_item_new_with_label (_("Edit Staff Properties"));
      gtk_widget_set_tooltip_text (menuitem, _("Edit the properties of the staff to customize this layout\nTake care only alter the obvious bits, such as instrument name etc\nInjudicious deletion of the LilyPond typesetting characters {<<# etc can make the layout unreadable by the LilyPond typesetter. Just delete the layout if you get stuck."));
      g_signal_connect (menuitem, "activate", G_CALLBACK (prefix_edit_callback), frame);
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);

      gtk_widget_show_all (menu);
      g_signal_connect (button, "clicked", G_CALLBACK (popup), menu);
#if 0
//having buttons that affect the score itself is confusing
      if (standard && (si->thescore->next != NULL))
        {
          button = gtk_button_new_with_label (_("Set Staff Group Start/End"));
          mark_as_non_custom (button);
          gtk_box_pack_start (GTK_BOX (staff_hbox), button, FALSE, TRUE, 0);
          gtk_widget_set_tooltip_text (button, _("The braces { and [ binding staffs together can be set here. Set the start on one staff and the end on a later staff.\nThis is editing the score, not just customizing a layout.\nRefresh the layout view (see under Options for this Layout button at the top) once you have made the changes."));
          g_signal_connect (button, "button-press-event", G_CALLBACK (staff_groups_menu), GINT_TO_POINTER (get_location (movementnum, (*pvoice_count))));
        }
#endif
      *pstaffs = g_list_append (*pstaffs, frame);
      g_signal_connect (G_OBJECT (frame), "destroy", G_CALLBACK (remove_from_staff_list), pstaffs);

      GString *staffprefix = g_string_new ("");
      set_staff_definition (staffprefix, staff);


     // if (staff->no_of_lines != 5) now done by a directive
     //   g_string_append_printf (staffprefix, TAB "\\override Staff.StaffSymbol  #'line-count = #%d\n", staff->no_of_lines);     //FIXME create_element

      GString *stafftext = g_string_new ("");
      g_string_assign (stafftext, "");
      set_staff_termination (stafftext, staff); // "\n>>\n%End of Staff\n"


      add_lilypond (frame, g_string_free (staffprefix, FALSE), g_string_free (stafftext, FALSE));



      gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);

      GtkWidget *outer_vbox = gtk_vbox_new (FALSE, 8);
      gtk_container_add (GTK_CONTAINER (frame), outer_vbox);


      gtk_box_pack_start (GTK_BOX (outer_vbox), staff_hbox, FALSE, TRUE, 0);

      GtkWidget *hbox = gtk_hbox_new (FALSE, 8);
      gtk_box_pack_end (GTK_BOX (outer_vbox), hbox, FALSE, TRUE, 0);
      //gtk_container_add (GTK_CONTAINER (frame), hbox);
      add_staff_widget (staff, hbox);

      label_text = (nextstaff && nextstaff->voicecontrol & DENEMO_SECONDARY) ? _("Voices") : _("Voice");
      GtkWidget *expander = gtk_expander_new (label_text);
      gtk_widget_set_tooltip_text (expander, _("This holds the voice(s) of the staff - the clef, time signature, key signature and music are all here"));
      //gtk_container_add (GTK_CONTAINER (frame), expander);
      gtk_box_pack_end (GTK_BOX (hbox), expander, FALSE, TRUE, 0);
      GtkWidget *voices_vbox = gtk_vbox_new (FALSE, 8);
      gtk_container_add (GTK_CONTAINER (expander), voices_vbox);

      if (staff->hasfigures)
        {
          GtkWidget *voice = gtk_label_new ("Bass figures");
          gchar *text = g_strdup_printf ("\n" TAB TAB "\\context Staff \\with {implicitBassFigures = #'(0) } \\%sBassFiguresLine %%End of bass figures\n",
                                         get_voicename (movementnum, (*pvoice_count)));
          add_lilypond (voice, text, NULL);
          gtk_box_pack_start (GTK_BOX (voices_vbox), voice, FALSE, TRUE, 0);
        }

      install_voice (staff, movementnum, (*pvoice_count), voices_vbox);     //Primary voice
      do_verses (staff, vbox, movementnum, (*pvoice_count));

      if (nextstaff && (nextstaff->voicecontrol & DENEMO_SECONDARY))
        {
          for (g = g->next, (*pvoice_count)++; g && (((DenemoStaff *) g->data)->voicecontrol & DENEMO_SECONDARY); g = g->next, (*pvoice_count)++)
            {

              DenemoStaff *staff = g->data;
              install_voice (staff, movementnum, (*pvoice_count), voices_vbox);
              do_verses (staff, vbox, movementnum, (*pvoice_count));        //!!! these need *pstaffs = g_list_append(*pstaffs, voice); treatment too...
              if (partname == NULL)
                vbox = install_staff_group_end (vbox, staff->staff_directives, pstaff_group_nesting);
            }
          if (g != NULL)
            {
              g = g->prev;
              (*pvoice_count)--;
            }
        }
      if (partname == NULL) //Have to omit all end braces for part layouts, since the part may not include all the start braces for them.
        vbox = install_staff_group_end (vbox, staff->staff_directives, pstaff_group_nesting);
    *pstafflist = g;
    *pvbox = vbox;
}

static void
append_staff (GtkWidget *widget, GList ** pstaffs)
{
    if (!clone_scoreblock_if_needed (widget))
     return;
    gint staff_group_nesting = 0;
    gint voice_count = Denemo.project->movement->currentstaffnum;
    gint movementnum = 1;
    if (Denemo.project->movements)
        movementnum = 1 + g_list_index (Denemo.project->movements, Denemo.project->movement);
    GtkWidget *vbox = gtk_widget_get_parent (widget);
    install_staff_with_voices (pstaffs, &vbox, NULL, &Denemo.project->movement->currentstaff,
                    &voice_count, Denemo.project->movement->currentstaffnum, movementnum, &staff_group_nesting, FALSE, TRUE);
    gtk_widget_show_all (vbox);
    Denemo.project->lilysync = G_MAXUINT;
}
static GtkWidget *
get_movement_widget (GList ** pstaffs, gchar * partname, DenemoMovement * si, gint movementnum, gboolean last_movement, gboolean standard)
{
  DenemoProject *gui = Denemo.project;
  gint staff_group_nesting = 0; //to check on loose staff group markers
  gint voice_count;             //a count of voices from the very top of the score (ie DenemoStaffs in thescore)
  gint staff_count;             //a count of staffs excluding voices from top of score
  GtkWidget *ret = gtk_frame_new (NULL);
  GString *start = g_string_new ("");
  set_initiate_scoreblock (si, start);  // ie << possibly overridden
  add_lilypond (ret, g_string_free (start, FALSE), g_strdup ("\n          >>\n"));

  GtkWidget *vbox = gtk_vbox_new (FALSE, 8);
  gtk_container_add (GTK_CONTAINER (ret), vbox);

  vbox = install_scoreblock_overrides (vbox, gui, si, last_movement);   //things like transpose whole score etc

  gchar *label_text = (si->thescore->next == NULL) ? _("The Staff") : _("The Staffs");
  GtkWidget *topexpander = gtk_expander_new (label_text);
  gtk_widget_set_tooltip_text (topexpander, _("This holds the staffs below which are the voices with the music."));
  gtk_expander_set_expanded (GTK_EXPANDER (topexpander), si == Denemo.project->movement);
  gtk_box_pack_start (GTK_BOX (vbox), topexpander, FALSE, TRUE, 0);
  vbox = gtk_vbox_new (FALSE, 8);
  gtk_container_add (GTK_CONTAINER (topexpander), vbox);
  GtkWidget *addbutton = gtk_button_new_with_label (_ ("Append Current Staff"));
  gtk_widget_set_tooltip_text (addbutton, _("Appends the current staff (the one where the cursor is in the Denemo Display) to this layout. The same staff can be placed at multiple positions in the layout with individual edits in each."));

  gtk_box_pack_start (GTK_BOX(vbox), addbutton, FALSE, TRUE, 0);
  g_signal_connect (G_OBJECT(addbutton), "clicked", G_CALLBACK (append_staff), pstaffs);

  GList *g;
  for (voice_count = 1, staff_count = 1, g = si->thescore; g; g = g->next, voice_count++, staff_count++)
    {
    DenemoStaff *staff = g->data;
    if ( (*(staff->lily_name->str)) && (partname && strcmp (partname, staff->lily_name->str))) // empty partname means include with all parts.
        continue;
     install_staff_with_voices (pstaffs, &vbox, partname, &g, &voice_count, staff_count/*sic*/, movementnum, &staff_group_nesting, standard, FALSE);

     if (g == NULL)
        break;
    }                           //for each staff

  if (staff_group_nesting < 0)
    {
      g_critical ("Impossible staff group nesting");
    }
  else
    {

      for (; staff_group_nesting; staff_group_nesting--)
        {
            if (partname == NULL)
                {
                    g_warning ("Staff group start without end - terminating it");
                    add_lilypond (vbox, NULL, g_strdup (" >>%Missing staff group end inserted here\n"));
                } else
                    add_lilypond (vbox, NULL, g_strdup (" >>%Closing staff group end for part layout\n"));

        }
    }




  return ret;
}

/* append the data labeled with affix on the widget s to the out string */
static void
append_lilypond_for_affix (const gchar * affix, GtkWidget * w, GString * out)
{
  GList *g;
  for (g = (GList *) g_object_get_data (G_OBJECT (w), affix); g; g = g->next)
    {
      gchar *text = (gchar *) g->data;
      if (text)
        g_string_append (out, text);
    }
}

/* go through the layout appending score block elements to the out string */
static void
lilypond_for_layout (GString * out, GtkWidget * layout)
{
  append_lilypond_for_affix ("prefix", layout, out);
  if (GTK_IS_CONTAINER (layout))
    {
      GList *list = gtk_container_get_children (GTK_CONTAINER (layout));
      if (list)
        {
          GList *g = list;
          do
            {
              lilypond_for_layout (out, g->data);
            }
          while ((g = g->next));
          g_list_free (list);
        }
    }
  append_lilypond_for_affix ("postfix", layout, out);
}

//return a newly allocated name for a standard scoreblock
static gchar *
movement_part_name (gint movement, gchar * partname)
{
  if (movement && partname)
    return g_strdup_printf ("%s M%d", partname, movement);
  if (movement)
    return g_strdup_printf (_("Movement %d"), movement);
  if (partname)
    return g_strdup_printf ("%s", partname);
  return g_strdup (DEFAULT_SCORE_LAYOUT);
}

static GtkWidget *
get_colored_event_box (GtkWidget * vbox, gchar * colorstring)
{
  GtkWidget *event_box = gtk_event_box_new ();
  gtk_box_pack_start (GTK_BOX (vbox), event_box, FALSE, TRUE, 0);
  GdkColor color;
  if (gdk_color_parse (colorstring, &color))
    gtk_widget_modify_bg (event_box, GTK_STATE_NORMAL, &color);
  return event_box;
}

static void
create_misc_scorewide (GtkWidget * inner_vbox)
{
  DenemoProject *gui = Denemo.project;


  gchar *lily = g_strdup_printf ("#(set-default-paper-size \"%s\"%s)\n", gui->lilycontrol.papersize->str, gui->lilycontrol.orientation ? "" : " 'landscape");
  create_element (inner_vbox, gtk_button_new_with_label (_("paper size")), lily);
  lily = g_strdup_printf ("#(set-global-staff-size %s)\n", gui->lilycontrol.staffsize->str);
  create_element (inner_vbox, gtk_button_new_with_label (_("Global staff size")), lily);
  GtkWidget *expander = gtk_expander_new (_("Paper Block"));
  gtk_widget_set_tooltip_text (expander, _("Settings for whole score: includes overall staff size, paper size ...\n"));
  add_lilypond (expander, g_strdup ("\\paper {\n"), g_strdup ("\n       }\n"));
  gtk_box_pack_start (GTK_BOX (inner_vbox), expander, FALSE, TRUE, 0);
  GtkWidget *paper_box = gtk_vbox_new (FALSE, 8);
  gtk_container_add (GTK_CONTAINER (expander), paper_box);

  create_element (paper_box, gtk_button_new_with_label (_("the paper block contents")), get_lilypond_paper ());

}

static void
create_scoreheader_directives (GtkWidget * vbox)
{
  DenemoProject *gui = Denemo.project;
  GtkWidget *frame = gtk_frame_new (NULL);
  gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
  GtkWidget *top_expander = gtk_expander_new (_("Score Titles"));
  gtk_expander_set_expanded (GTK_EXPANDER (top_expander), TRUE);
  add_lilypond (top_expander, g_strdup ("\n\\header {\n"), g_strdup ("\n        }\n"));
  gtk_widget_set_tooltip_text (top_expander, _("Titles, layout settings, preferences etc for the whole score.\nIncludes main title, composer, date, instrumentation, tagline"));
  gtk_container_add (GTK_CONTAINER (frame), top_expander);
  GtkWidget *header_box = gtk_vbox_new (FALSE, 8);
  gtk_container_add (GTK_CONTAINER (top_expander), header_box);

  gchar *escaped_name = g_strescape (gui->filename->str, NULL);
  gchar *default_tagline = g_strdup_printf ("tagline = \\markup {\"%s\" on \\simple #(strftime \"%%x\" (localtime (current-time)))}\n", escaped_name);
  g_free (escaped_name);
  create_element (header_box, gtk_label_new (_("Default tagline")), default_tagline);

  GList *g;
  for (g = gui->scoreheader.directives; g; g = g->next)
    {
      DenemoDirective *directive = (DenemoDirective *) g->data;
      if (directive->override & (DENEMO_OVERRIDE_AFFIX | DENEMO_OVERRIDE_HIDDEN))
        continue;
      if (directive->postfix == NULL)
        continue;
      create_element (header_box, gtk_label_new (directive->tag->str), g_strdup (directive->postfix->str));
    }
}

static void
create_score_directives (GtkWidget * vbox)
{
  DenemoProject *gui = Denemo.project;
  if (gui->lilycontrol.directives == NULL)
    return;
  GtkWidget *frame = gtk_frame_new (NULL);
  gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
  GtkWidget *top_expander = gtk_expander_new (_("Score Directives"));
  gtk_widget_set_tooltip_text (top_expander, _("Includes the indent before first measure, LilyPond include files ..."));
  gtk_container_add (GTK_CONTAINER (frame), top_expander);
  GtkWidget *inner_vbox = gtk_vbox_new (FALSE, 8);
  gtk_container_add (GTK_CONTAINER (top_expander), inner_vbox);

  GList *g = gui->lilycontrol.directives;
  for (; g; g = g->next)
    {
      DenemoDirective *directive = g->data;
      if (directive->prefix && !(directive->override & (DENEMO_OVERRIDE_AFFIX)))
        {
          GtkWidget *label = gtk_label_new (directive->tag->str);
          create_element (inner_vbox, label, g_strdup (directive->prefix->str));
        }
    }
}

static void fill_scorewide_frame (GtkWidget *frame, GtkWidget *reload_button)
{

  GtkWidget *expander = gtk_expander_new (_("Score-wide Settings."));
  gtk_widget_set_tooltip_text (expander, _("Setting the score title, composer, headers and footers for this layout"));
  gtk_container_add (GTK_CONTAINER (frame), expander);

  GtkWidget *inner_box = gtk_vbox_new (FALSE, 8);
  gtk_container_add (GTK_CONTAINER (expander), inner_box);
  gtk_box_pack_start (GTK_BOX (inner_box), reload_button, FALSE, TRUE, 0);
#if 0
//having buttons that affect the score itself is confusing
  GtkWidget *button = gtk_button_new_with_label (_("Create Book Titles"));
  mark_as_non_custom (button);
  gtk_widget_set_tooltip_text (button, _("Set book titles for the score"));
  g_signal_connect (button, "clicked", G_CALLBACK (popup_score_titles_menu), NULL);
  gtk_box_pack_start (GTK_BOX (inner_box), button, FALSE, TRUE, 0);
#endif

  create_scoreheader_directives (inner_box);
  create_score_directives (inner_box);
  create_misc_scorewide (inner_box);
}

static GtkWidget *get_reload_button (GtkWidget *frame)
{
  GtkWidget *reload_button = gtk_button_new_with_label (_("Reload Score-Wide Settings"));
  gtk_widget_set_tooltip_text (reload_button, _("Reload the score wide settings for this layout from the current values in the score.\nDo this if you have made changes to the score titles etc which you wish to be used for this layout."));
  g_signal_connect_swapped (reload_button, "clicked", G_CALLBACK (reload_scorewide_block), frame);
   return reload_button;
}
static void reload_scorewide_block (GtkWidget *frame)
{
  GtkWidget *event_box = gtk_widget_get_parent (frame);
  GtkWidget *vbox = gtk_widget_get_parent (event_box);
  gtk_widget_destroy (frame);
  frame = gtk_frame_new (NULL);
  GtkWidget *reload_button = get_reload_button (frame);
  gtk_container_add (GTK_CONTAINER (event_box), frame);
  fill_scorewide_frame (frame, reload_button);
  gtk_widget_show_all (vbox);
  Denemo.project->lilysync = G_MAXUINT;

}
static void
create_scorewide_block (GtkWidget * vbox)
{
  GtkWidget *frame = gtk_frame_new (NULL);
  GtkWidget *reload_button = get_reload_button (frame);
  GtkWidget *event_box = get_colored_event_box (vbox, "#BBFFCC");// event_box is packed into vbox
  gtk_container_add (GTK_CONTAINER (event_box), frame);
  fill_scorewide_frame (frame, reload_button);
  gtk_widget_show_all (vbox);
}

static
void install_movement_widget (DenemoMovement *si, GtkWidget *vbox, DenemoScoreblock ** psb, gchar *partname, gint movement_num, gboolean last, gboolean standard)
          {
          DenemoProject *gui = Denemo.project;
          gchar *label_text = gui->movements->next ? g_strdup_printf (_("<b>Movement %d</b>"), movement_num) : g_strdup (_("Movement"));
          GtkWidget *movement_frame = gtk_expander_new (label_text);
          gtk_label_set_use_markup (GTK_LABEL (gtk_expander_get_label_widget (GTK_EXPANDER(movement_frame))), TRUE);
          gtk_widget_set_tooltip_text (movement_frame, _("This contains the layout of the movement- the movement title, and the actual music itself"));
          gtk_expander_set_expanded (GTK_EXPANDER (movement_frame), si == gui->movement);
          g_free (label_text);
          gtk_box_pack_start (GTK_BOX (vbox), movement_frame, FALSE, TRUE, 0);

          GtkWidget *frame_box = gtk_vbox_new (FALSE, 8);
          gtk_container_add (GTK_CONTAINER (movement_frame), frame_box);
          GtkWidget *remove_box = gtk_hbox_new (FALSE, 8);
          gtk_box_pack_start (GTK_BOX (frame_box), remove_box, FALSE, FALSE, 0);
          GtkWidget *w = gtk_button_new_with_label ("<span foreground=\"red\">Remove Movement</span>");
          gtk_label_set_use_markup (GTK_LABEL (gtk_bin_get_child (GTK_BIN(w))), TRUE);
          gtk_widget_set_tooltip_text (w, _("Remove this movement from the score layout"));
          g_signal_connect_swapped (w, "clicked", G_CALLBACK (remove_element), frame_box); //grandparent
          gtk_box_pack_start (GTK_BOX (remove_box), w, FALSE, FALSE, 14);
         // GtkWidget *dummy = gtk_label_new (" dummy ");
          //gtk_box_pack_start (GTK_BOX (frame_box), dummy, TRUE, TRUE, 0);

          GtkWidget *outer_hbox = gtk_hbox_new (FALSE, 8);
          gtk_box_pack_start (GTK_BOX (frame_box), outer_hbox, FALSE, TRUE, 0);

          GtkWidget *movement_vbox = gtk_vbox_new (FALSE, 8);
          gtk_box_pack_start (GTK_BOX (outer_hbox), movement_vbox, FALSE, TRUE, 10);
          install_pre_movement_widgets (movement_vbox, si, standard);
          GtkWidget *frame = gtk_frame_new (NULL);
          add_lilypond (frame, g_strdup ("\n\\score { %Start of Movement\n"), g_strdup ("\n       } %End of Movement\n"));
          gtk_box_pack_start (GTK_BOX (movement_vbox), frame, FALSE, TRUE, 0);
          GtkWidget *outer_vbox = gtk_vbox_new (FALSE, 8);
          gtk_container_add (GTK_CONTAINER (frame), outer_vbox);
          GtkWidget *hbox = gtk_hbox_new (FALSE, 8);

          gtk_box_pack_start (GTK_BOX (hbox), get_movement_widget (&(*psb)->staff_list, partname, si, movement_num, last, standard), FALSE, TRUE, 0);
          gtk_box_pack_start (GTK_BOX (outer_vbox), hbox, FALSE, TRUE, 0);
          if (si->header.directives)
            {
              GtkWidget *frame = gtk_frame_new (_("Header block"));
              gtk_box_pack_start (GTK_BOX (outer_vbox), frame, FALSE, TRUE, 0);
              add_lilypond (frame, g_strdup ("\n\\header {\n"), g_strdup ("\n        }\n"));
              GtkWidget *innerbox = gtk_vbox_new (FALSE, 8);
              gtk_container_add (GTK_CONTAINER (frame), innerbox);
              GList *g;
              for (g = si->header.directives; g; g = g->next)
                {
                  DenemoDirective *d = g->data;
                  if (d->override & DENEMO_OVERRIDE_HIDDEN)
                    continue;

                  gchar *lily = (d->postfix && d->postfix->len) ? d->postfix->str : NULL;
                  if (lily)
                    {
                      create_element (innerbox, gtk_button_new_with_label (d->tag->str), g_strdup (lily));
                    }
                }
            }
          if (si->layout.directives)
            {
              GtkWidget *frame = gtk_frame_new (_("Layout block"));
              gtk_box_pack_start (GTK_BOX (outer_vbox), frame, FALSE, TRUE, 0);
              add_lilypond (frame, g_strdup ("\n\\layout {\n"), g_strdup ("\n}\n"));
              GtkWidget *innerbox = gtk_vbox_new (FALSE, 8);
              gtk_container_add (GTK_CONTAINER (frame), innerbox);
              GList *g;
              for (g = si->layout.directives; g; g = g->next)
                {
                  DenemoDirective *d = g->data;
                  if (d->override & DENEMO_OVERRIDE_HIDDEN)
                    continue;

                  gchar *lily = (d->postfix && d->postfix->len) ? d->postfix->str : NULL;
                  if (lily)
                    {
                      create_element (innerbox, gtk_button_new_with_label (d->tag->str), g_strdup (lily));
                    }
                }
            }

            if (si->movementcontrol.directives)
                {
                  GtkWidget *frame = gtk_frame_new (_("Movement Block"));
                  gtk_box_pack_start (GTK_BOX (outer_vbox), frame, FALSE, TRUE, 0);
                  GtkWidget *innerbox = gtk_vbox_new (FALSE, 8);
                  gtk_container_add (GTK_CONTAINER (frame), innerbox);
                  GList *g;
                  for (g = si->movementcontrol.directives; g; g = g->next)
                    {
                      DenemoDirective *d = (DenemoDirective *) g->data;
                      if (d->override & DENEMO_OVERRIDE_AFFIX && d->postfix)
                        {
                          gchar *text = label_for_directive (d);
                          GtkWidget *label = gtk_label_new (text);
                          g_free (text);
                          create_element (innerbox, label, g_strdup (d->postfix->str));
                        }
                    }
                }



          if (si->movementcontrol.directives)
            {
              GtkWidget *frame = gtk_frame_new (_("Movement Epilog"));
              gtk_box_pack_start (GTK_BOX (movement_vbox), frame, FALSE, TRUE, 0);
              GtkWidget *innerbox = gtk_vbox_new (FALSE, 8);
              gtk_container_add (GTK_CONTAINER (frame), innerbox);
              GList *g;
              for (g = si->movementcontrol.directives; g; g = g->next)
                {
                  DenemoDirective *d = (DenemoDirective *) g->data;
                  if (d->override & DENEMO_OVERRIDE_AFFIX)
                    continue;
                  if (d->override & DENEMO_OVERRIDE_HIDDEN)
                    continue;

                  if (d->postfix)
                    {
                      gchar *text = label_for_directive (d);
                      GtkWidget *label = gtk_label_new (text);
                      g_free (text);
                      create_element (innerbox, label, g_strdup (d->postfix->str));
                    }
                }
            }
        }
static void install_duplicate_movement (DenemoScoreblock ** psb, gint movement)
{
    gchar *partname = NULL;
    //show_type  (gtk_bin_get_child (gtk_bin_get_child ((*psb)->widget)), "Type of widget ");
    GtkWidget *vbox = gtk_bin_get_child (GTK_BIN (gtk_bin_get_child (GTK_BIN ((*psb)->widget))));
    DenemoMovement *si = g_list_nth_data (Denemo.project->movements, movement - 1);
    if (si)
        install_movement_widget (si, vbox, psb, partname, movement, TRUE, FALSE);
}
static void install_duplicate_movement_callback (DenemoScoreblock *sb)
{
    install_duplicate_movement (&sb, Denemo.project->movement->currentmovementnum);
    score_status (Denemo.project, TRUE);
    gtk_widget_show_all (sb->widget);
}

static void reorder_movement (DenemoScoreblock * psb)
{
    //show_type  (gtk_bin_get_child (gtk_bin_get_child ((*psb)->widget)), "Type of widget ");
    GtkWidget *vbox = gtk_bin_get_child (GTK_BIN (gtk_bin_get_child (GTK_BIN (psb->widget))));
    GList *children = gtk_container_get_children (GTK_CONTAINER(vbox));
    //show_type  ( g_list_nth_data (children, movement)     , "Type of widget ");
    for ( ;children; children=children->next)
        {
        if( GTK_IS_EXPANDER (children->data) && gtk_expander_get_expanded (children->data))
            {
                if (children->next == NULL)
                    warningdialog (_( "The currently expanded movement is already at the end"));
                else
                    gtk_box_reorder_child (GTK_BOX(vbox), children->data, -1);//-1 = to end
                g_list_free (children);
                return;
            }
        }
    warningdialog (_("No movement is expanded - don't know which movement to move"));
}

static void reorder_movement_callback (DenemoScoreblock * psb)
{
    reorder_movement (psb);
    score_status (Denemo.project, TRUE);

}

 //find the one that is expanded FIXME

//populates the scoreblock *psb with the movement or movements for partname from the current score Denemo.project
static void
set_default_scoreblock (DenemoScoreblock ** psb, gint movement, gchar * partname)
{
  DenemoProject *gui = Denemo.project;
  (*psb)->staff_list = NULL;    //list of staff frames in order they appear in scoreblock

  (*psb)->widget = gtk_scrolled_window_new (gtk_adjustment_new (1.0, 1.0, 2.0, 1.0, 4.0, 1.0), gtk_adjustment_new (1.0, 1.0, 2.0, 1.0, 4.0, 1.0));

  (*psb)->visible = FALSE;      //will be set true when/if tab is selected
  if (partname)
    (*psb)->partname = g_strdup (partname);
  (*psb)->movement = movement;
  layout_sync = (*psb)->layout_sync = gui->layout_sync;


  GtkWidget *vbox = gtk_vbox_new (FALSE, 8);
  gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW ((*psb)->widget), vbox);
  GtkWidget *options = get_options_button (*psb, FALSE);
  gtk_box_pack_start (GTK_BOX (vbox), options, FALSE, FALSE, 0);
  //now create a hierarchy of widgets representing the score
  create_scorewide_block (vbox);

  GList *g;
  gint movement_num = 1;
  for (g = gui->movements; g; g = g->next, movement_num++)
    {
      if (movement == 0 /*all movements */  || (movement == movement_num) /*this movement */ )
        {
          DenemoMovement *si = (DenemoMovement *) g->data;
          install_movement_widget (si, vbox, psb, partname, movement_num, !(gboolean) GPOINTER_TO_INT (g->next), TRUE);

        }                       //if movement is wanted
    }                           //for all movements

  for (g = gui->lilycontrol.directives; g; g = g->next)
    {
      DenemoDirective *d = g->data;//g_print("def %s %s\n", d->tag->str, d->postfix?d->postfix->str:"No postfix");
      if (d->override & DENEMO_OVERRIDE_HIDDEN)
        continue;
      if (!(d->override & DENEMO_OVERRIDE_AFFIX))
        continue;
      gchar *post = (d->postfix && d->postfix->len) ? d->postfix->str : NULL;
      if (post)
        {
          create_element (vbox, gtk_button_new_with_label (d->tag->str), g_strdup (post));
        }
    }


}

//recompute a standard scoreblock
static void
recreate_standard_scoreblock (DenemoScoreblock ** psb)
{
  gint movement = (*psb)->movement;
  gchar *partname = (*psb)->partname ? g_strdup ((*psb)->partname) : NULL;
  gchar *instrumentation = (*psb)->instrumentation ? g_strdup ((*psb)->instrumentation) : NULL;
  gboolean visible = (*psb)->visible;
  GtkNotebook *notebook = GTK_NOTEBOOK (get_score_layout_notebook (Denemo.project));
  if((*psb)->widget)
    set_notebook_page((*psb)->widget);
  gint position = gtk_notebook_get_current_page(notebook);
  free_scoreblock ((*psb));     //this changes the page in the notebook if it was selected before. So if sb->visible then re-select this page after reconstruction
  create_standard_scoreblock (psb, movement, partname);
  (*psb)->instrumentation = instrumentation;
  gtk_notebook_reorder_child (notebook, (*psb)->widget, position);
//alternatively pass in desired position to create_standard_scoreblock....


 // if (visible)
  //  gtk_notebook_set_current_page (GTK_NOTEBOOK (get_score_layout_notebook (Denemo.project)), 0);
}

//return value must not be freed
/* UNUSED
static const gchar *
scoreblock_name (DenemoScoreblock * sb)
{
  return gtk_notebook_get_tab_label_text (GTK_NOTEBOOK (get_score_layout_notebook (Denemo.project)), sb->widget);
}
*/


//refreshes the lilypond field of all the standard scoreblocks after re-computing the standard scoreblocks already present
//returns FALSE if structure has not changed since they were computed.
static gboolean
check_for_update (void)
{
  DenemoProject *gui = Denemo.project;
  if (gui->layout_sync > layout_sync)
    {
      GList *g;
      for (g = gui->standard_scoreblocks; g; g = g->next)
        {
          DenemoScoreblock *sb = (DenemoScoreblock *) g->data;
          recreate_standard_scoreblock (&sb);
      }
      return TRUE;
    }
  return FALSE;
}

static gboolean
change_tab (GtkNotebook * notebook, GtkWidget * page, gint pagenum)
{
  //this is getting called with pagenum 0 when clicking on the lilypond text window...
  Denemo.project->lilysync = G_MAXUINT;
  page = gtk_notebook_get_nth_page (notebook, pagenum); // value passed in appears to be something else - it is not documented what.

  GList *g;
  for (g = Denemo.project->custom_scoreblocks; g; g = g->next)
    {
      DenemoScoreblock *sb = ((DenemoScoreblock *) g->data);
      sb->visible = (sb->widget == page);
    }
  for (g = Denemo.project->standard_scoreblocks; g; g = g->next)
    {
      DenemoScoreblock *sb = ((DenemoScoreblock *) g->data);
      sb->visible = (sb->widget == page);
    }
  Denemo.project->layout_id = 0;
  return TRUE;
}

//takes a DenemoScoreblock that has a valid widget field and recomputes the lilypond field of the scoreblock
//from the widget. It also sets the name field of the scoreblock to the name on the Notebook tab.
// It sets the instrumentation if set in the scoreblock structure.
void
refresh_lilypond (DenemoScoreblock * sb)
{
  if (sb->widget)
    {

      if ((!is_lilypond_text_layout (sb)))
        {
          gchar *instrumentation = sb->instrumentation;
          gchar *set_instr = instrumentation? g_strdup (instrumentation):
                                             ((!strcmp (sb->name, DEFAULT_SCORE_LAYOUT))?g_strdup (_("Full Score")):
                                             ((g_str_has_prefix (sb->name, _("Movement")))?
                                                    g_strdup (sb->name):
                                                    NULL));

          instrumentation = set_instr? g_strdup_printf ("        instrumentation = \\markup { \\with-url #'\"scheme:(d-BookInstrumentation)\" \"%s\"}\n", set_instr):
                                        g_strdup ("");
          g_free (set_instr);
          set_instr = instrumentation;

          sb->id = crc32 ((guchar*) sb->name);
          if (sb->lilypond == NULL)
            sb->lilypond = g_string_new (sb->name);
          else
            g_string_assign (sb->lilypond, sb->name);
          g_string_prepend (sb->lilypond, "%");
          g_string_append_printf (sb->lilypond, "\n\\header{DenemoLayoutName = \"%s\"\n%s        }\n",
          sb->name,
          set_instr);
          g_free (set_instr);
          lilypond_for_layout (sb->lilypond, sb->widget);
        }
    }
  else
    g_warning ("No widget for scoreblock");
}
gboolean
current_scoreblock_is_custom (void)
{
  GtkWidget *notebook = get_score_layout_notebook (Denemo.project);
  gint pagenum = gtk_notebook_get_current_page (GTK_NOTEBOOK (notebook));
  GtkWidget *page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), pagenum);
  GList *g;
  for (g = Denemo.project->custom_scoreblocks; g; g = g->next)
    {
      DenemoScoreblock *sb = ((DenemoScoreblock *) g->data);
      if (sb->widget == page)
         return TRUE;
     }
return FALSE;
}
DenemoScoreblock *
selected_scoreblock (void)
{
  GtkWidget *notebook = get_score_layout_notebook (Denemo.project);
  gint pagenum = gtk_notebook_get_current_page (GTK_NOTEBOOK (notebook));       // value passed in appears to be something else - it is not documented what.
  GtkWidget *page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), pagenum);
  GList *g;
  for (g = Denemo.project->custom_scoreblocks; g; g = g->next)
    {
      DenemoScoreblock *sb = ((DenemoScoreblock *) g->data);
      if (sb->widget == page)
        {
          refresh_lilypond (sb);        //!!!! needs sorting out !!!
          return sb;
        }
    }
  for (g = Denemo.project->standard_scoreblocks; g; g = g->next)
    {
      DenemoScoreblock *sb = ((DenemoScoreblock *) g->data);
      if (sb->widget == page)
        {
          refresh_lilypond (sb);
          return sb;
        }
    }
  return NULL;
}

//returns a uri for the pdf output for the current scoreblock. The user must free when done.
gchar *
get_output_uri_from_scoreblock (void)
{
  DenemoScoreblock *sb = selected_scoreblock ();
  if (sb == NULL)
    {
      g_warning ("No Score Layout");
      return g_strdup ("");
    }
  DenemoProject *gui = Denemo.project;
  if (sb->uri)
    return g_strdup (sb->uri);
  gchar *basename;
  gchar *dirname;
  if (Denemo.project->filename && Denemo.project->filename->len)
    {
      gchar *filename = gui->filename->str;
      dirname = g_path_get_dirname (filename);
      basename = g_path_get_basename (filename);
      gchar *suffix = g_strrstr (basename, DENEMO_FILE_SUFFIX);
      if (suffix)
        *suffix = 0;
    }
  else
    {
      basename = g_strdup ("output");
      dirname = g_get_current_dir ();
    }
  gchar *uri = g_strdup_printf ("file://%s", dirname);
  g_free (dirname);
  gchar *ret;
  if (sb)
    {
      gchar *pdf_name = g_strconcat (basename, "-", sb->name, ".pdf", NULL);
      ret = g_build_filename (uri, pdf_name, NULL);
      g_free (pdf_name);
    }
  else
    {
      ret = g_build_filename (uri, "output.pdf", NULL);
    }
  g_free (basename);
  g_free (uri);
  return ret;
}

void
set_current_scoreblock_uri (gchar * uri)
{
  DenemoScoreblock *sb = selected_scoreblock ();
  if (sb)
    {
        g_free (sb->uri);
        sb->uri = uri;
    }
}

//Returns the next scoreblock in the score layout notebook, or NULL if it is the last
DenemoScoreblock *
get_next_scoreblock (void)
{
  GtkWidget *notebook = get_score_layout_notebook (Denemo.project);
  gint pagenum = gtk_notebook_get_current_page (GTK_NOTEBOOK (notebook));
  GtkWidget *page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), pagenum + 1);
  if (page)
    gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), pagenum + 1);
  GList *g;
  for (g = Denemo.project->custom_scoreblocks; g; g = g->next)
    {
      DenemoScoreblock *sb = ((DenemoScoreblock *) g->data);
      if (sb->widget == page)
        {
          refresh_lilypond (sb);        //!!!! needs sorting out !!!
          return sb;
        }
    }
  for (g = Denemo.project->standard_scoreblocks; g; g = g->next)
    {
      DenemoScoreblock *sb = ((DenemoScoreblock *) g->data);
      if (sb->widget == page)
        {
          refresh_lilypond (sb);
          return sb;
        }
    }
  return NULL;
}

//Returns the next scoreblock in the score layout notebook, or NULL if it is the last
DenemoScoreblock *
get_first_scoreblock (void)
{
  GtkWidget *notebook = get_score_layout_notebook (Denemo.project);
  gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), 0);
  GtkWidget *page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), 0);
  GList *g;
  for (g = Denemo.project->custom_scoreblocks; g; g = g->next)
    {
      DenemoScoreblock *sb = ((DenemoScoreblock *) g->data);
      if (sb->widget == page)
        {
          refresh_lilypond (sb);
          return sb;
        }
    }
  for (g = Denemo.project->standard_scoreblocks; g; g = g->next)
    {
      DenemoScoreblock *sb = ((DenemoScoreblock *) g->data);
      if (sb->widget == page)
        {
          refresh_lilypond (sb);
          return sb;
        }
    }
  return NULL;
}


gboolean
iterate_custom_layout (gboolean init)
{                               //!!!!!!!!problem for lilypondized ones is widget NULL????
  static gint current;
  DenemoScoreblock *sb;
  if (Denemo.project->custom_scoreblocks == NULL)
    {
      return FALSE;
    }
  if (init)
    {
      current = 0;
      sb = (DenemoScoreblock *) (Denemo.project->custom_scoreblocks->data);
    }
  else
    {
      current++;
      sb = (DenemoScoreblock *) g_list_nth_data (Denemo.project->custom_scoreblocks, current);
    }
  if (sb && sb->widget)
    {
      if(!Denemo.non_interactive){
        if (!gtk_widget_get_visible (Denemo.project->score_layout))
          activate_action ("/MainMenu/ViewMenu/ToggleScoreLayout");
        set_notebook_page (sb->widget);
      }
      return TRUE;
    }
  else
    {
      g_debug ("No custom layout %d sb = %p\n", current, sb);
      return FALSE;
    }
}

guint
get_layout_id_for_name (gchar *name)
{
return crc32(name);
}

guint
selected_layout_id (void)
{
  if (Denemo.project->layout_id == 0)
    {
      DenemoScoreblock *sb = selected_scoreblock ();
      if (sb)
        Denemo.project->layout_id = sb->id;
    }
  return Denemo.project->layout_id;
}

GtkWidget *
get_score_layout_notebook (DenemoProject * gui)
{
  GtkWidget *notebook = gtk_bin_get_child (GTK_BIN (gui->score_layout));
  if (notebook == NULL)
    {
      notebook = gtk_notebook_new ();
      g_signal_connect (notebook, "switch_page", G_CALLBACK (change_tab), NULL);
      g_signal_connect (gui->score_layout, "focus-in-event", G_CALLBACK (check_for_update), NULL);
      gtk_container_add (GTK_CONTAINER (gui->score_layout), notebook);
    }
  return notebook;
}

//create a standard scoreblock in the passed DenemoScoreblock structure and put it in a new tab in the score
//does not add it to the standard scoreblocks list
static void
create_standard_scoreblock (DenemoScoreblock ** psb, gint movement, gchar * partname)
{
  DenemoProject *gui = Denemo.project;
  GtkWidget *notebook = get_score_layout_notebook (gui);
  set_default_scoreblock (psb, movement, partname);

  gchar *label_text = movement_part_name (movement, partname);
  (*psb)->name = g_strdup (label_text);
  GtkWidget *label = gtk_label_new (label_text);
  g_free (label_text);
  gtk_notebook_prepend_page (GTK_NOTEBOOK (notebook), (*psb)->widget, label);
  gtk_widget_set_tooltip_markup ((*psb)->widget,
                                 _
                                 ("This is a score layout - the buttons mostly customize the layout\nYou can have several layouts and use them to print different versions of your score.\nOnce customized e.g. by adding page breaks, deleting certain parts etc the layout will be saved with your score and can be used for printing from even though you may have made corrections to the music.\nStandard layouts are created by invoking the standard print commands - print, print part, print movement etc.\nThese standard layouts provide a convenient starting point for your customized layouts.<b>Note 1</b>Custom layouts are not saved for further graphical editing, only the typesetting commands are saved, so, unless you are familiar with LilyPond do all your work on the layout in one session.<b>Note 2</b>The first comment in the LilyPond text of the layout holds the name of the layout. If you change it any conditional directives that are for the layout will need refreshing"));
  gtk_widget_show_all (notebook);
}

static void
set_notebook_page (GtkWidget * w)
{
  GtkWidget *notebook = get_score_layout_notebook (Denemo.project);
  GList *g = gtk_container_get_children (GTK_CONTAINER (notebook));
  gint position = g_list_index (g, w);  //g_debug("pos %d", position);
  g_list_free (g);
  gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), position);
}

void
create_default_scoreblock (void)
{
  DenemoProject *gui = Denemo.project;
  if (gui->custom_scoreblocks)
    {
      GList *g;
      for (g = gui->custom_scoreblocks; g; g = g->next)
        {
          DenemoScoreblock *sb = g->data;
          if (!strcmp (sb->name, DEFAULT_SCORE_LAYOUT))
            {
              set_notebook_page (sb->widget);
              return;
            }
        }
    }
  if (gui->standard_scoreblocks)
    {
      GList *g;
      for (g = gui->standard_scoreblocks; g; g = g->next)
        {
          DenemoScoreblock *sb = g->data;
          if (!strcmp (sb->name, DEFAULT_SCORE_LAYOUT))
            {
              set_notebook_page (sb->widget);
              return;
            }
        }
    }
  DenemoScoreblock *sb = g_malloc0 (sizeof (DenemoScoreblock));
  (void) create_standard_scoreblock (&sb, 0, NULL);
  gui->standard_scoreblocks = g_list_prepend (gui->standard_scoreblocks, (gpointer) sb);
}

/* select the scoreblock with the standard default scoreblock name, choosing a customized
 * version over any standard version. Create one if it does not exist.
 */
void
select_default_scoreblock (void)
{
  DenemoProject *gui = Denemo.project;
  if (gui->custom_scoreblocks)
    {
      GList *g;
      for (g = gui->custom_scoreblocks; g; g = g->next)
        {
          DenemoScoreblock *sb = g->data;
          if (!strcmp (sb->name, DEFAULT_SCORE_LAYOUT))
            {
              set_notebook_page (sb->widget);
              return;
            }
        }
    }
  if (gui->standard_scoreblocks)
    {
      GList *g;
      for (g = gui->standard_scoreblocks; g; g = g->next)
        {
          DenemoScoreblock *sb = g->data;
          if (!strcmp (sb->name, DEFAULT_SCORE_LAYOUT))
            {
              set_notebook_page (sb->widget);
              return;
            }
        }
    }
}

static void
selection_install_voice (DenemoStaff * staff, gint movementnum, gint voice_count, GString * lilypond, GString * tail, GString * voice_tail)
{
  gchar *voicetag = get_voicetag (movementnum, voice_count);
  gchar *voicename = get_voicename (movementnum, voice_count);
  gchar *text1;


  GString *voicetext = g_string_new ("");
  set_voice_definition (voicetext, staff, voicetag);    //That is \new Voice = name prefix { postfix FIXME is prefix any use here????
  gchar *text = g_strdup_printf (" %s ", voicetext->str);
  g_string_assign (voicetext, "");

  set_voice_termination (voice_tail, staff);     // TAB TAB"} %End of voice" if not overridden



  g_string_append (lilypond, text);

  text1 = g_strdup_printf (" \\%s", voicename);
  if (staff->voicecontrol == DENEMO_PRIMARY)
    {
      g_string_append (lilypond, get_lilypond_for_clef (&staff->clef));
      g_string_append (lilypond, get_lilypond_for_keysig (&staff->keysig));
      g_string_append (lilypond, get_lilypond_for_timesig (&staff->timesig));
    }
  g_string_append (lilypond, text1);
  g_free (text1);


  g_string_prepend (tail, g_string_free (voicetext, FALSE));
}

//returns a layout with no widget whose lilypond is the scoreblock for just the selected staffs
DenemoScoreblock *
selection_layout (void)
{
  DenemoProject *gui = Denemo.project;
  DenemoMovement *si = gui->movement;
  GString *movement_tail = g_string_new ("");
  gint movementnum = g_list_index (Denemo.project->movements, Denemo.project->movement) + 1;
  static DenemoScoreblock *sb;
  if (sb == NULL)
    {
      sb = g_malloc0 (sizeof (DenemoScoreblock));
      sb->lilypond = g_string_new ("");
    }

  g_string_assign (sb->lilypond, "\n\\score\n{ %Start of Selection from current movement\n");
  set_initiate_scoreblock (si, sb->lilypond);   // ie << possibly overridden

  GList *g;                     //things like transpose whole score etc
  for (g = gui->lilycontrol.directives; g; g = g->next)
    {
      DenemoDirective *d = g->data;
      if (d->override & DENEMO_OVERRIDE_HIDDEN)
        continue;
      if (d->override & DENEMO_OVERRIDE_AFFIX)
        continue;
      gchar *start = (d->postfix && d->postfix->len) ? d->postfix->str : NULL;
      if (start)
        {
          g_string_append_printf (sb->lilypond, "\n << %s\n  << ", start);
          g_string_prepend (movement_tail, "\n >>\n  >>");
        }
    }
  gint voice_count;
  for (voice_count = 1, g = gui->movement->thescore; g; g? g = g->next : g, voice_count++)
    {
      DenemoStaff *staff = g->data;
      DenemoStaff *nextstaff = g->next ? g->next->data : NULL;
      GString *stafftext = g_string_new ("");
      if (!(voice_count >= gui->movement->selection.firststaffmarked && voice_count <= gui->movement->selection.laststaffmarked))
        continue;
      if (staff->hasfakechords)
        {                       //the reason these are outside the staff frame is it makes them appear above the staff
          g_string_append_printf (sb->lilypond, "\n" TAB TAB "\\new ChordNames \\chordmode { \\%sChords }\n", get_voicename (movementnum, voice_count));
        }
      set_staff_definition (sb->lilypond, staff);




      //if (staff->no_of_lines != 5)
      //  g_string_append_printf (sb->lilypond, TAB "\\override Staff.StaffSymbol  #'line-count = #%d\n", staff->no_of_lines);    //FIXME create_element
      GString *tail = g_string_new ("");
GString *voice_tail = g_string_new ("");
      g_string_assign (stafftext, "");
      set_staff_termination (stafftext, staff); // "\n>>\n%End of Staff\n"

      g_string_prepend (tail, g_string_free (stafftext, FALSE));

      if (staff->hasfigures)
        {
          g_string_append_printf (sb->lilypond, "\n" TAB TAB "\\context Staff \\with {implicitBassFigures = #'(0) } \\%sBassFiguresLine %%End of bass figures\n", get_voicename (movementnum, voice_count));
        }

      selection_install_voice (staff, movementnum, voice_count, sb->lilypond, tail, voice_tail);    //Primary voice

      g_string_append (sb->lilypond, voice_tail->str);
      g_string_assign(voice_tail, "");
      //selection_do_verses(staff, vbox, movementnum, this is repeated below
       gboolean voices_intervened;
       voices_intervened = FALSE;
       if (nextstaff && (nextstaff->voicecontrol & DENEMO_SECONDARY))
        {
          for (g = g->next, voice_count++; g && (((DenemoStaff *) g->data)->voicecontrol & DENEMO_SECONDARY); g = g->next, voice_count++)
            {
              GString *voicetail = g_string_new ("");
              DenemoStaff *staff = g->data;
              selection_install_voice (staff, movementnum, voice_count, sb->lilypond, voicetail, voice_tail);
              g_string_append (sb->lilypond, g_string_free (voicetail, FALSE));
              g_string_append (sb->lilypond, voice_tail->str);
              g_string_assign(voice_tail, "");
              voices_intervened = TRUE;
              //selection_do_verses(staff, vbox, movementnum, this is repeated above
            }
        }

      g_string_free (voice_tail, TRUE);

      if (tail->len)
        g_string_append (sb->lilypond, g_string_free (tail, FALSE));
      else
        g_string_free (tail, FALSE);

     if(g && voices_intervened) // we have added voices to the staff, so the for loop has advanced the iterator over staffs and voice count already, so back up
     {
         g = g->prev;
         voice_count--;
     }
    }                           // end of for each staff Now loop back for all the staffs in firststaffnum -  laststaffnum
  g_string_append (sb->lilypond, movement_tail->str);
  g_string_free (movement_tail, TRUE);
  g_string_append (sb->lilypond, "\n          >>\n");
  g_string_append_printf (sb->lilypond, "\n\\header {\n");

  for (g = si->header.directives; g; g = g->next)
    {
      DenemoDirective *d = g->data;
      if (d->override & DENEMO_OVERRIDE_HIDDEN)
        continue;

      gchar *lily = (d->postfix && d->postfix->len) ? d->postfix->str : NULL;
      if (lily)
        {
          g_string_append (sb->lilypond, lily);
        }
    }

  g_string_append (sb->lilypond, "\n}\n");



  if (si->layout.directives)
    {
      g_string_append (sb->lilypond, "\n\\layout {\n");
      for (g = si->layout.directives; g; g = g->next)
        {
          DenemoDirective *d = g->data;
          if (d->override & DENEMO_OVERRIDE_HIDDEN)
            continue;

          gchar *lily = (d->postfix && d->postfix->len) ? d->postfix->str : NULL;
          if (lily)
            {
              g_string_append (sb->lilypond, lily);
            }
        }
      g_string_append (sb->lilypond, ("\n}\n"));
    }
#if 0
  maybe not this ... for (g = gui->lilycontrol.directives; g; g = g->next)
    {
      DenemoDirective *d = g->data;
      if (d->override & DENEMO_OVERRIDE_HIDDEN)
        continue;
      if (!(d->override & DENEMO_OVERRIDE_AFFIX))
        continue;
      gchar *post = (d->postfix && d->postfix->len) ? d->postfix->str : NULL;
      if (post)
        {
          create_element (vbox, gtk_button_new_with_label (d->tag->str), g_strdup (post));
        }
    }
#endif

  g_string_append (sb->lilypond, "\n} %End of Movement\n");


  return sb;
}

//if the call is all_movements is current (1) and no partname ie default, then current layout is returned, re-created (if need be) if it is a standard one
//otherwise selects or creates a standard layout for the given spec: all_movements (0=all, 1 = current) and part (NULL is all parts, otherwise parts with partname).
DenemoScoreblock *
select_layout (gboolean all_movements, gchar * partname, gchar * instrumentation)
{
  GList *g;
  DenemoScoreblock *sb;
  if (Denemo.project->movement->markstaffnum)
    return selection_layout ();



  if (all_movements && partname == NULL)
    {
      sb = selected_scoreblock ();
      if (sb)
        {
          if (is_in_standard_scoreblock (sb))
            {
              recreate_standard_scoreblock (&sb);
              refresh_lilypond (sb);
            }
          set_notebook_page (sb->widget);
          return sb;
        }
    }


//otherwise return a standard scoreblock recreating it - though this should only need doing if changecount has moved on

  //make sure at least the default scoreblock has been created, this can now be a custom version named with default scoreblock name
  if (Denemo.project->standard_scoreblocks == NULL)
    {
      create_default_scoreblock ();
      if (Denemo.project->standard_scoreblocks)
        sb = (DenemoScoreblock *) (Denemo.project->standard_scoreblocks->data);
      else if (Denemo.project->custom_scoreblocks)
        sb = (DenemoScoreblock *) (Denemo.project->custom_scoreblocks->data);
      else
        {
          g_critical ("No score layout available");
          return NULL;
        }

      refresh_lilypond (sb);    //creating a scoreblock does *not* include generating the lilypond from its widgets.
    }



//first recreate all the standard scoreblocks and set them not visible
  for (g = Denemo.project->standard_scoreblocks; g; g = g->next)
    {
      sb = (DenemoScoreblock *) g->data;
      //      if(sb->layout_sync!=Denemo.project->layout_sync)
      recreate_standard_scoreblock (&sb);
      sb->visible = FALSE;
    }

  if (all_movements && partname == NULL)
    {                           //select the one for the whole score
      for (g = Denemo.project->standard_scoreblocks; g; g = g->next)
        {
          sb = (DenemoScoreblock *) g->data;
          if ((sb->movement == 0) && (sb->partname == NULL))
            {
              sb->visible = TRUE;
              refresh_lilypond (sb);
              set_notebook_page (sb->widget);
              return sb;
            }
        }
      if (Denemo.project->custom_scoreblocks)
        {
          sb = (DenemoScoreblock *) (Denemo.project->custom_scoreblocks->data);
          return sb;
        }
      g_warning ("Error in logic: the default standard scoreblock should exist or a custom one of that name ");
    }
  else
    {                           //Not a whole score print
      for (g = Denemo.project->standard_scoreblocks; g; g = g->next)
        {
          sb = (DenemoScoreblock *) g->data;

          //a good match to partname ?
          gboolean good = (sb->partname && partname && !strcmp (sb->partname, partname)) || (sb->partname == NULL && partname == NULL);

          if (good && (all_movements && (sb->movement == 0)))
            {                   //scoreblock is for good partname and is for all movements - use it
              sb->visible = TRUE;
              refresh_lilypond (sb);
              set_notebook_page (sb->widget);
              return sb;
            }
        }
    }

//either just the current movement or just the part named or both. Set up the movement number (1 ...) or 0 for the all movements case
  gint movement;
  if (all_movements)
    {
      movement = 0;
    }
  else
    {
      movement = g_list_index (Denemo.project->movements, Denemo.project->movement) + 1;      //current movement
    }


  if (movement || partname)
    {                           //a specific movement and/or a specific part
      for (g = Denemo.project->standard_scoreblocks; g; g = g->next)
        {
          sb = (DenemoScoreblock *) g->data;
          if ((movement == sb->movement) && ((partname == sb->partname) || (partname && sb->partname && !strcmp (sb->partname, partname))))
            {
              sb->visible = TRUE;
              refresh_lilypond (sb);
              set_notebook_page (sb->widget);
              return sb;
            }
        }
      sb = g_malloc0 (sizeof (DenemoScoreblock));
      create_standard_scoreblock (&sb, movement, partname);
      Denemo.project->standard_scoreblocks = g_list_prepend (Denemo.project->standard_scoreblocks, sb);
      sb->visible = TRUE;
      sb->instrumentation = g_strdup (instrumentation); g_print ("instrumentation %s\n", sb->instrumentation);
      refresh_lilypond (sb);
      set_notebook_page (sb->widget);
      return sb;
    }
  //NOT REACHED
  g_warning ("Error in logic: the default standard scoreblock should exist and be returned ");
  return sb;                    //this is the last in the list of standard scoreblocks but cannot be reached
}

void
select_standard_layout (DenemoScoreblock * sb)
{
  if (Denemo.project->standard_scoreblocks == NULL)
    {
      create_default_scoreblock ();
      //creating a scoreblock does *not* include generating the lilypond from its widgets.
      if (Denemo.project->standard_scoreblocks == NULL)
        {
            DenemoScoreblock *sb = g_malloc0 (sizeof (DenemoScoreblock));
            (void) create_standard_scoreblock (&sb, 0, NULL);
            Denemo.project->standard_scoreblocks = g_list_prepend (NULL, (gpointer) sb);
        }
      sb = (DenemoScoreblock *) (Denemo.project->standard_scoreblocks->data);
    }
  refresh_lilypond (sb);
  set_notebook_page (sb->widget);
}

void
select_custom_layout (DenemoScoreblock * sb)
{
  if (Denemo.project->custom_scoreblocks == NULL)
    {
      return;
    }
  set_notebook_page (sb->widget);
}

gboolean
select_custom_layout_for_name (gchar * name)
{
  GList *g = Denemo.project->custom_scoreblocks;
  for (; g; g = g->next)
    {
      DenemoScoreblock *sb = g->data;

      if (sb->name && !strcmp (name, sb->name))
        return TRUE;
    }
  return FALSE;
}

gboolean
select_layout_id (gint id)
{
  GList *g = Denemo.project->custom_scoreblocks;
  for (; g; g = g->next)
    {
      DenemoScoreblock *sb = g->data;
      if (sb->id == id)
        {
          set_notebook_page (sb->widget);
          return TRUE;
        }
    }

  for (g = Denemo.project->standard_scoreblocks; g; g = g->next)
    {
      DenemoScoreblock *sb = g->data;
      if (sb->id == id)
        {
          set_notebook_page (sb->widget);
          return TRUE;
        }
    }
  return FALSE;
}
/* UNUSED
static void
text_modified (GtkTextBuffer * textbuffer, DenemoScoreblock * sb)
{
  GtkTextIter startiter, enditer;
  gtk_text_buffer_get_start_iter (textbuffer, &startiter);
  gtk_text_buffer_get_end_iter (textbuffer, &enditer);
  gchar *text = gtk_text_buffer_get_text (textbuffer, &startiter, &enditer, FALSE);
  if (sb->lilypond)
    g_string_assign (sb->lilypond, text);
  else
    sb->lilypond = g_string_new (text);
  score_status (Denemo.project, TRUE);
}
*/

DenemoScoreblock *
get_scoreblock_for_lilypond (gchar * lily)
{
  gchar *text = _("The LilyPond text for this layout can be edited in the LilyPond view window.\nYou can safely delete this layout if you no longer need it\n(for example if you have made structural changes to the score\nnot reflected in this layout).");
  gchar *name = NULL;
  DenemoScoreblock *sb = g_malloc0 (sizeof (DenemoScoreblock));
  sb->text_only = TRUE;

  if(!Denemo.non_interactive){
    GtkWidget *frame = gtk_frame_new (LILYPOND_TEXT_EDITOR);
    sb->widget = frame;
    gtk_widget_set_tooltip_text (frame, _("This is a customized layout, which has been transformed into instructions for the LilyPond music typesetter.\nThis is the form in which customized layouts are stored in a Denemo score on disk - the graphical interface is no longer available. You can, however still edit the layout with care (and some understanding of LilyPond).\nUse the View → LilyPond window to do this.\nOtherwise you can delete it and create a new one from a standard layout."));
    GtkWidget *vbox = gtk_vbox_new (FALSE, 8);
    gtk_container_add (GTK_CONTAINER (sb->widget), vbox);
    GtkWidget *options = get_options_button (sb, TRUE);
    gtk_box_pack_start (GTK_BOX (vbox), options, FALSE, FALSE, 0);
    GtkWidget *textview = gtk_text_view_new ();
    gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (textview), TRUE);
    GtkTextBuffer *textbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (textview));
    gtk_text_buffer_set_text (textbuffer, text, -1);

    GtkWidget *sw = gtk_scrolled_window_new (gtk_adjustment_new (1.0, 1.0, 2.0, 1.0, 4.0, 1.0), gtk_adjustment_new (1.0, 1.0, 2.0, 1.0, 4.0, 1.0));
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
    gtk_container_add (GTK_CONTAINER (sw), textview);
    gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
  }

  gchar *newline = g_strstr_len (lily, -1, "\n");
  if (newline)
    {
      name = g_strndup (lily, newline - lily);
      sb->name = g_strdup (name + 1);
      sb->id = crc32 ((guchar*) sb->name);
      g_free (name);
    }
  else
    sb->name = g_strdup (_("Custom Scoreblock"));
  sb->id = crc32 ((guchar*) sb->name);
  sb->lilypond = g_string_new (lily);

  refresh_lilypond (sb);
  return sb;
}

//if the score_layout window is visible and a standard scoreblock is selected, create a custom one cloned from it with the passed name
DenemoScoreblock *
create_custom_scoreblock (gchar * layout_name, gboolean force)
{
  GList *g;
  if (!force && !gtk_widget_get_visible (Denemo.project->score_layout))
    return NULL;
  for (g = Denemo.project->custom_scoreblocks; g; g = g->next)
    {
      DenemoScoreblock *sb = (DenemoScoreblock *) g->data;
      if (!strcmp (layout_name, sb->name))
        return NULL;
    }
  for (g = Denemo.project->standard_scoreblocks; g; g = g->next)
    {
      DenemoScoreblock *sb = (DenemoScoreblock *) g->data;
      if (sb->visible)
        {
          if (clone_scoreblock (sb, layout_name))
            return sb;
        }
    }
  return NULL;
}


gboolean delete_custom_scoreblock (gchar * layout_name)
{
  GList *g;

  for (g = Denemo.project->custom_scoreblocks; g; g = g->next)
    {
      DenemoScoreblock *sb = (DenemoScoreblock *) g->data;
      if (!strcmp (layout_name, sb->name))
        {
            delete_custom_scoreblock_callback (NULL, sb);
            return TRUE;
        }
    }
  return FALSE;
}

DenemoScoreblock *
create_custom_lilypond_scoreblock (void)
{
  //called for
  //make_scoreblock_editable(); in view.c
  DenemoScoreblock *sb = NULL;
  GList *g;
  for (g = Denemo.project->custom_scoreblocks; g; g = g->next)
    {
      sb = (DenemoScoreblock *) g->data;
      if (sb->visible)
        {
          if (!sb->text_only)
            convert_to_lilypond_callback (NULL, sb);
          return sb;
        }
    }
  for (g = Denemo.project->standard_scoreblocks; g; g = g->next)
    {
      sb = (DenemoScoreblock *) g->data;
      if (sb->visible)
        {
          if (!sb->text_only)
            convert_to_lilypond_callback (NULL, sb);
          return sb;
        }
    }
  //if none, create the default and convert that to lilypoond.
  create_default_scoreblock ();
  sb = (DenemoScoreblock *) (Denemo.project->standard_scoreblocks->data);
  convert_to_lilypond_callback (NULL, sb);
  return sb;
}


static GtkWidget *LayoutMenu;   //a menu for the default layout and all created layouts
static void
typeset_layout (DenemoScoreblock * sb)
{
#ifndef USE_EVINCE
  g_debug("This feature requires denemo to be built with evince");
#else
  set_notebook_page (sb->widget);
  g_debug ("Switched to %s\n", sb->name);
  typeset_current_layout ();
#endif
}

static void
remove_menuitem (GtkWidget * menuitem, GtkContainer * container)
{
  gtk_container_remove (container, menuitem);
}

static void
attach_item (DenemoScoreblock * sb)
{
  GtkWidget *menuitem = gtk_menu_item_new_with_label (sb->name);
  gtk_widget_set_tooltip_text (menuitem, _("Typesets this layout"));
  g_signal_connect_swapped (menuitem, "activate", G_CALLBACK (typeset_layout), sb);
  gtk_menu_shell_append (GTK_MENU_SHELL (LayoutMenu), menuitem);
}

GtkWidget *
GetLayoutMenu (void)
{
  GList *g;
  if (LayoutMenu == NULL)
    {
      LayoutMenu = gtk_menu_new ();
    }
  else
    {
      gtk_container_foreach (GTK_CONTAINER (LayoutMenu), (GtkCallback) remove_menuitem, LayoutMenu);
    }
  if (Denemo.project->standard_scoreblocks == NULL)
    create_default_scoreblock ();
  for (g = Denemo.project->standard_scoreblocks; g; g = g->next)
    {
      DenemoScoreblock *sb = (DenemoScoreblock *) g->data;
      attach_item (sb);
    }
  for (g = Denemo.project->custom_scoreblocks; g; g = g->next)
    {
      DenemoScoreblock *sb = (DenemoScoreblock *) g->data;
      attach_item (sb);
    }

  gtk_widget_show_all (LayoutMenu);
  return LayoutMenu;
}