Import upstream version 5.3.

[mup] / mup / mupmate / Main.C

/* Copyright (c) 2006 by Arkkra Enterprises */
/* All rights reserved */

// Code for the main window for Mupmate, a front end program for
// the Mup music publisher program from Arkkra Enterprises.
// It uses the FLTK toolkit for OS independence.

// This file contains code for the toolbar and editor window,
// as well as general startup and showing the license.

// We only support editing a single file at a time, so most classes
// as really effectively singletons, but the code is written to be
// able to support multiple instances, in case we ever want to do that.
// That means callback functions are always passed a pointer to
// a class instance as their second argument, and all they do is cast 
// that to the appropriate type, and call the corresponding class method.

// For the most part, widgets are only allocated when needed, but then
// stay around for the life of the process, in case they are needed again.

// Callbacks are named with _cb suffix.
// Pointers are named with _p suffix, except for (char *) types
// that are pointing to text strings, which don't have any special suffix.


#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>

#include <FL/Fl.H>
#include <FL/fl_ask.H>
#include <FL/Fl_Tooltip.H>

#include "globals.H"
#include "Main.H"
#include "Preferences.H"
#include "utils.H"

#include <FL/x.H>
#ifdef OS_LIKE_WIN32
#include "resource.h"
#else
#include <FL/Fl_File_Icon.H>
#ifdef OS_LIKE_UNIX
#include <X11/xpm.h>
#include "mup32.xpm"
#endif
#endif

// Height of the tool bar on the main window
#define TOOLBAR_HEIGHT 30

// How often to blink the cursor.
#define BLINK_RATE 0.5

// If file indicating user has agreed to license terms doesn't exist,
// we ask them to agree. This is the text of the license.
extern const char * const license_text;

//----------------------------------------------------------------------

// Define the toolbar and its submenus.
//  Indented lines indicate the submenus.
// The & indicates shortcut key

const char * File_label = "&File";
 const char * New_label = "&New";
 const char * NewFromTemplate_label = "New From &Template";
 const char * Open_label = "&Open...";
 const char * Save_label = "&Save";
 const char * SaveAs_label = "Save &As...";
 const char * Exit_label = "E&xit";
const char * Edit_label = "&Edit";
 const char * Undo_label = "&Undo";
 const char * Cut_label = "Cu&t";
 const char * Copy_label = "&Copy";
 const char * Paste_label = "&Paste";
 const char * Delete_label = "&Delete";
 const char * Find_label = "&Find...";
 const char * FindNext_label = "Find &Next";
 const char * Replace_label = "&Replace...";
 const char * GoTo_label = "&Go To...";
 const char * SelectAll_label = "&Select All";
const char * Run_label = "&Run";
 const char * Display_label = "&Display";
 const char * Play_label = "&Play";
 const char * WritePostScript_label = "&Write PostScript File";
 const char * WriteMIDI_label = "Write &MIDI File";
 const char * Options_label = "&Set Options...";
const char * Config_label = "&Config";
 const char * FileLocations_label = "&File Locations...";
 const char * Preferences_label = "&Preferences...";
 const char * RegistrationForm_label = "&Registration Form...";
 const char * RegistrationKey_label = "Registration &Key...";
const char * Help_label = "&Help";
 const char * UserGuide_label = "Mup &User's Guide";
 const char * StartupHints_label = "&Startup Hints";
 const char * AboutMupmate_label = "&About Mupmate";

Fl_Menu_Item Toolbar_menu[] = {
	{ File_label,	0,	0,	0,	FL_SUBMENU },
		{ New_label,	FL_CTRL + 'n',	File::New_cb },
		{ NewFromTemplate_label,	FL_CTRL + 't', File::NewFromTemplate_cb },
		{ Open_label,	FL_CTRL + 'o',	File::Open_cb },
		{ Save_label,	FL_CTRL + 's',	File::Save_cb },
		{ SaveAs_label,		0,	File::SaveAs_cb,	0,	FL_MENU_DIVIDER },
		{ Exit_label,	0,	File::Exit_cb },
		{ 0 },
	{ Edit_label,	0,	0,	0,	FL_SUBMENU },
		{ Undo_label,	FL_CTRL + 'z',	Edit::Undo_cb,	0,	FL_MENU_INACTIVE | FL_MENU_DIVIDER },
		{ Cut_label,	FL_CTRL + 'x',	Edit::Cut_cb,	0,	FL_MENU_INACTIVE },
		{ Copy_label,	FL_CTRL + 'c',	Edit::Copy_cb,	0,	FL_MENU_INACTIVE },
		{ Paste_label,	FL_CTRL + 'v',	Edit::Paste_cb,	0,	FL_MENU_INACTIVE },
		{ Delete_label,	FL_Delete,	Edit::Delete_cb,	0,	FL_MENU_INACTIVE | FL_MENU_DIVIDER },
		{ Find_label,	FL_CTRL + 'f',	Edit::Find_cb,	0,	FL_MENU_INACTIVE },
		{ FindNext_label,	FL_F + 3,	Edit::FindNext_cb,	0,	FL_MENU_INACTIVE },
		{ Replace_label,	FL_CTRL + 'h',	Edit::Replace_cb,	0,	FL_MENU_INACTIVE },
		{ GoTo_label,	FL_CTRL + 'g',	Edit::GoTo_cb,	0,	FL_MENU_DIVIDER },
		{ SelectAll_label,	FL_CTRL + 'a',	Edit::SelectAll_cb,	0, FL_MENU_INACTIVE },
		{ 0 },
	{ Run_label,	0,	0,	0,	FL_SUBMENU },
		{ Display_label,			0,	Run::Display_cb,	0,	FL_MENU_INACTIVE },
		{ Play_label,			0,	Run::Play_cb,	0,	FL_MENU_INACTIVE },
		{ WritePostScript_label,	0,	Run::WritePostScript_cb,	0, FL_MENU_INACTIVE },
		{ WriteMIDI_label,		0,	Run::WriteMIDI_cb,	0,	 FL_MENU_DIVIDER | FL_MENU_INACTIVE },
		{ Options_label,		0,	Run::Options_cb },
		{ 0 },
	{ Config_label,	0,	0,	0,	FL_SUBMENU },
		{ FileLocations_label,		0,	Config::FileLocations_cb },
		{ Preferences_label,		0,	Config::Preferences_cb,	0,	FL_MENU_DIVIDER },
		{ RegistrationForm_label,	0,	Config::RegistrationForm_cb },
		{ RegistrationKey_label,	0,	Config::RegistrationKey_cb },
		{ 0 },
	{ Help_label,	0,	0,	0,	FL_SUBMENU },
		{ UserGuide_label,		0,	Help::Uguide_cb },
		{ StartupHints_label,		0,	Help::Startup_Hints_cb },
		{ AboutMupmate_label,		0,	Help::About_cb },
		{ 0 },
	{ 0 }
};


//----------------------------------------------------------------------

// Linked list of main windows, in case we ever support more than one
// at a time. (Currently we don't, because we're not sure if it
// might be more confusing than useful.)
Main * Main::list_p;


// Constructor for main window. It contains toolbar and editor window.

Main::Main(const char * title)
	: Fl_Double_Window(Default_width, Default_height, title)
{
	xclass("mup");
#ifdef OS_LIKE_WIN32
	icon((char *)LoadIcon(fl_display, MAKEINTRESOURCE(IDI_ICON)));
#else
#ifdef OS_LIKE_UNIX
	fl_open_display();
	Pixmap p, mask;
	XpmCreatePixmapFromData(fl_display, DefaultRootWindow(fl_display),
                                 mup32_xpm, &p, &mask, NULL);
	icon((char *)p);
#endif
#endif
	// Try to use user's default foreground/background
	Fl::get_system_colors();

	void * data = 0;

	// Create class instances for each toolbar item
	filemenu_p = new File();
	editmenu_p = new Edit();
	configmenu_p = new Config();
	helpmenu_p = new Help();
	runmenu_p = new Run();

	// Add to list of windows 
	next = list_p;
	list_p = this;

	// Create the toolbar and populate its menu items
	toolbar_p = new Fl_Menu_Bar(0, 0, w(), TOOLBAR_HEIGHT);
	int numitems = sizeof(Toolbar_menu) / sizeof(Toolbar_menu[0]);
	for (int i = 0; i < numitems; i++) {
		if (Toolbar_menu[i].text != 0) {
			// As we move to each top-level menu item,
			// keep a pointer to that item, which is then
			// used as the argument to callback functions,
			// so they know what object to act on.
			if (strcmp(Toolbar_menu[i].text, File_label) == 0) {
				data = (void *) filemenu_p;
			}
			else if (strcmp(Toolbar_menu[i].text, Edit_label) == 0) {
				data = (void *) editmenu_p;
			}
			else if (strcmp(Toolbar_menu[i].text, Config_label) == 0) {
				data = (void *) configmenu_p;
			}
			else if (strcmp(Toolbar_menu[i].text, Run_label) == 0) {
				data = (void *) runmenu_p;
			}
			else if (strcmp(Toolbar_menu[i].text, Help_label) == 0) {
				data = (void *) helpmenu_p;
			}
		}
		Toolbar_menu[i].user_data(data);
	}
	toolbar_p->copy(Toolbar_menu);

	// Create and configure the editor window
	editor_p = new Fl_Text_Editor(0, TOOLBAR_HEIGHT, w(),
					h() - TOOLBAR_HEIGHT, "");
	editor_p->buffer( new Fl_Text_Buffer );

	// Set font/size and arrange to be notified of changes in them
	font_change_reg_p = new Font_change_registration(font_change_cb,
								(void *) this);

	// Several objects need to be notified of changes in the
	// editor window, so they can do things like gray-ungray menu items.
	editor_p->buffer()->add_modify_callback(modify_cb, (void*) this);
	editor_p->buffer()->add_modify_callback(File::modify_cb,
					(void*) filemenu_p);
	editor_p->buffer()->add_modify_callback(Edit::modify_cb,
					(void*) editmenu_p);

	// Initialize state information.
	have_selection = false;
	can_paste = false;
	prev_bufflength = 0;
	// Undo is inactive until user does something that can be undone.
	undo_active = false;
	undo_active_on_next_change = true;

	// Arrange to make cursor blink
	Fl::add_timeout(BLINK_RATE, blinker, this);
	cursor_state = 1;

	// Let editor take as much space as is available
	// if the user resizes the main window. 
	size_range(Min_width, Min_height, 0, 0);
	resizable((Fl_Widget *) editor_p);

	// Other classes need to have access to editor and such
	filemenu_p->set_editor(editor_p);
	filemenu_p->set_parent(this);
	editmenu_p->set_editor(editor_p);
	runmenu_p->set_file(filemenu_p);

	// Arrange for destructor to free the new-ed child widgets
	end();

	show();

	// Arrange for window manager closes to do Exit.
	callback(atclose_cb, this);
	when(FL_WHEN_NEVER);

#ifdef OS_LIKE_UNIX
	// Arrange for icon to be associated with window
	XWMHints hints;
	hints.flags = IconPixmapHint | IconMaskHint ;
	hints.icon_pixmap = p;
	hints.icon_mask = mask;
	XSetWMHints(fl_display, fl_xid((Fl_Window *)this), &hints);
#endif
}


// Destructor for main window

Main::~Main()
{
	delete font_change_reg_p;
	font_change_reg_p = 0;
	Fl::remove_timeout(blinker, this);
	// Remove from list of Main windows 
	if (list_p == this) {
		list_p = next;
	}
	else {
		for (Main * m = list_p; m != 0; m = m->next) {
			if (m->next == this) {
				m->next = this->next;
				break;
			}
		}
	}
	delete filemenu_p;
	filemenu_p = 0;
	delete editmenu_p;
	editmenu_p = 0;
	delete configmenu_p;
	configmenu_p = 0;
	delete helpmenu_p;
	helpmenu_p = 0;
	delete runmenu_p;
	runmenu_p = 0;
}


// Callback for when user changes font/size

void
Main::font_change_cb(void * data, Fl_Font font, unsigned char size)
{
	((Main *)data)->font_change(font, size);
}


void
Main::font_change(Fl_Font font, unsigned char size)
{
	// Get shorter name for buffer, as we'll be using it a lot.
	Fl_Text_Buffer * buffer_p = editor_p->buffer();

	// Don't want this change to count as something that can be undone
	buffer_p->canUndo(false);

	// We want to change the entire text buffer, so need to
	// select its whole contents. If there was already a selection,
	// save that and put it back when we are done
	int sel_start, sel_end;
	int had_selection;
	int cursorplace = editor_p->insert_position();
	if ((had_selection = buffer_p->selected()) != 0) {
		buffer_p->selection_position(&sel_start, &sel_end);
		buffer_p->unselect();
	}

	// set new font and size
	buffer_p->select(0, editor_p->buffer()->length() - 1);
	editor_p->textfont(font);
	editor_p->textsize(size);
	buffer_p->unselect();

	// Put selection and cursor back as they were before font change
	if (had_selection) {
		buffer_p->select(sel_start, sel_end);
	}
	editor_p->insert_position(cursorplace);
	buffer_p->canUndo(true);
}


// Callback for when editor window changes.
// This arranges to gray/ungray toolbar menu items.

void
Main::modify_cb(int, int, int, int, const char *, void * data)
{
	((Main *)data)->modify();
}

void
Main::modify()
{
	int bufflength = editor_p->buffer()->length();
	// See if what changed is something we might care about.
	if (editor_p->buffer()->selected() != have_selection ||
			editmenu_p->can_paste() != can_paste
			|| undo_active != undo_active_on_next_change
			|| bufflength < 2 || prev_bufflength == 0) {

		// Something changed, and we may need to
		// gray or ungray menu items in response.
		have_selection = editor_p->buffer()->selected();
		const Fl_Menu_Item * menu_p = toolbar_p->menu();
		Fl_Menu_Item * item_p;
		// Walk through toolbar and submenus, checking
		// if anything needs to be grayed/ungrayed.
		for (int i = 0; i < toolbar_p->size(); i++) {
			const char * mtext = toolbar_p->text(i);
			if (mtext == 0) {
				continue;
			}
			// Can only Copy, Cut, and Delete if something
			// is selected.
			if (strcmp(mtext, Copy_label) == 0 ||
					strcmp(mtext, Cut_label) == 0 ||
					strcmp(mtext, Delete_label) == 0) {
				// have to un-const so we can (de)activate
				item_p = (Fl_Menu_Item *) &(menu_p[i]);
				if (have_selection) {
					item_p->activate();
				}
				else {
					item_p->deactivate();
				}
			}

			// Paste is different. It becomes active when there
			// is something in clipboard, and never again becomes
			// inactive.
			if (strcmp(mtext, Paste_label) == 0 &&
						editmenu_p->can_paste()) {
				((Fl_Menu_Item *)&(menu_p[i]))->activate();
				can_paste = true;
			}

			// Undo is also different. On first change of any
			// kind it become active, and stays that way,
			// except it gets reset on new file.
			if (strcmp(mtext, Undo_label) == 0) {
				if (undo_active && ! undo_active_on_next_change) {
					((Fl_Menu_Item *)&(menu_p[i]))->deactivate();
					undo_active = false;
					undo_active_on_next_change = true;
				}
				else if ( ! undo_active && undo_active_on_next_change) {
					((Fl_Menu_Item *)&(menu_p[i]))->activate();
					undo_active = true;
				}
			}

			// Find and FindNext are inactive when file is empty,
			// because obviously there is nothing to find.
			// Similar for Replace and Select All.
			// Also for all the Run things
			if (strcmp(mtext, Find_label) == 0 ||
					strcmp(mtext, FindNext_label) == 0 ||
					strcmp(mtext, Replace_label) == 0 ||
					strcmp(mtext, SelectAll_label) == 0 ||
					strcmp(mtext, Display_label) == 0 ||
					strcmp(mtext, Play_label) == 0 ||
					strcmp(mtext, WritePostScript_label) == 0 ||
					strcmp(mtext, WriteMIDI_label) == 0) {
				if (bufflength == 0) {
					((Fl_Menu_Item *)&(menu_p[i]))->deactivate();
				}
				else {
					((Fl_Menu_Item *)&(menu_p[i]))->activate();
				}
			}
		}
	}
	prev_bufflength = bufflength;
}


// This method gets called when user starts working on a new file.
// It sets state information so we can know how to gray menu items properly.

void
Main::begin_new_file()
{
	// transition Undo-ability state from true to false
	undo_active = true;
	undo_active_on_next_change = false;
	editor_p->buffer()->call_modify_callbacks();
	runmenu_p->clean_up();
}


// Handle some special cases.
// 1. By default fltk will exit the main window upon getting escape.
// That seems bad, since a vi user will be used to hitting escape all the
// time when editing, because that is always a "safe" thing to do,
// and if they did it here by mistake, they would lose all
// their text entry since the last save. So we ignore the escape in this window.
// I suppose we could ask if they really want to quit...
// 2. If user does cut or copy via keyboard accelerator, the normal code
// for ungraying the Paste button doesn't get called, so we catch that case
// here and ungray it.

int
Main::handle_events(int e)
{
	// If escape is received while on main window,
	// return 1 to show that we consumed the event.
	if (e == FL_SHORTCUT && Fl::event_key() == FL_Escape) {
		for (Main * m_p = list_p; m_p != 0; m_p = m_p->next) {
			if (Fl::first_window() == m_p) {
				return(1);
			}
		}
	}

	// If user did cut or copy via cntl-c or cntl-x,
	// arrange to ungray Paste.
	if (e == FL_KEYUP && (Fl::event_state() & FL_CTRL)  &&
			(Fl::event_key() == 'v' || Fl::event_key() == 'x')) {
		for (Main * m_p = list_p; m_p != 0; m_p = m_p->next) {
			if (Fl::first_window() == m_p) {
				m_p->editmenu_p->set_can_paste();
				break;
			}
		}
	}

	return(0);
}


// If user tries to close the main window via the window manager
// while having unsaved changes, we ask user if they want to save
// the changes first. 

CALL_BACK(Main, atclose)
{
	File::Exit_cb(0, filemenu_p);
}


// Blink the cursor. It can be hard to see if next to selected text if not
// blinking. We could potentially optimize to only do this while
// the window has focus, but it doesn't seem worth the complication...

void
Main::blinker(void * data)
{
	Main * obj_p = (Main *) data;
	// Put cursor into opposite of its current state
	obj_p->cursor_state ^= 1;
	obj_p->editor_p->show_cursor(obj_p->cursor_state);
	// Reset timer to call ourselves again.
	Fl::repeat_timeout(BLINK_RATE, blinker, data);
}


// Give user hints if we haven't already done that before.

void
Main::hints(void)
{
	int did_startup;
	(void) Preferences_p->get(Showed_startup_hints, did_startup,
					Default_startup_hints_flag);
	if ( ! did_startup) { 
		Help::Startup_Hints_cb(0, (void *) helpmenu_p);
	}
}

//----------------------------------------------------------------------

int
main(int argc, char **argv, const char **arge)
{
	// The arge value may get changed when we set new environment
	// variables, so look up PATH first thing.
	get_path(arge);

	// Uguide browser needs to show images
	fl_register_images();

#ifndef OS_LIKE_WIN32
	// On Windows we use the native Open/Save As dialogs.
	// On other platforms we use FLTK's, but add icon for Mup files.
	Fl_File_Icon::load_system_icons();
	File::add_mup_icon();
#endif

	// Try to get best hardware support for graphics
	Fl::visual(FL_DOUBLE|FL_INDEX);

	// Get the user's preferences that persists across sessions
	Preferences_p = new Fl_Preferences(Fl_Preferences::USER,
					"arkkra.com", "mupmate");

	// Enable tips when user hovers their mouse over a widget.
	// If user doesn't like them, they can set delay to huge value.
	Fl_Tooltip::enable();
	double tooltips_delay;
	(void) Preferences_p->get(Tooltips_delay_preference, tooltips_delay,
					Default_tooltips_delay);
	Fl_Tooltip::delay(tooltips_delay);

	// Set $MUPPATH
	char * val;
	(void) Preferences_p->get(MUPPATH_location, val,
						Default_MUPPATH_location);
	set_muppath(val);

	// Tell Mup that it is being run via mupmate,
	// so it can give more appropriate error messages.
	putenv("MUPMATE=1");

	// Create main window
	Main *main_p = new Main("Mupmate");

	// Ensure "escape" key doesn't kill main window,
	// and make sure Paste ungraying works
	Fl::add_handler(Main::handle_events);

	// Try to find some reasonable defaults for configuration items
	// that aren't already set.
	deduce_helper_locations();

	// If magic file indicating license agreement isn't there,
	// ask user to agree to Mup license.
	if (access(magic_file(argv[0]), F_OK) != 0) {
		// Show the license and get agreement before continuing
		new License(main_p, magic_file(argv[0]));
	}
	else {
		// Display the main window.
		main_p->show(1, argv);

		// The first time, we show user some hints.
		main_p->hints();
	}

	// Go to where user said they want to store their Mup files by default.
	// Need to wait to do this until after we have deduced locations
	// of executable, in case they were in current directory.
	char * mup_dir;
	(void) Preferences_p->get(Music_files_location, mup_dir,
						Default_music_files_location);
	if (strcmp(mup_dir, ".") != 0) {
		if (chdir(mup_dir) != 0) {
			char curr_dir[FL_PATH_MAX] = "current";
			char message[2 * FL_PATH_MAX + 100];
			(void *) getcwd(curr_dir, sizeof(curr_dir));
			sprintf(message, "Unable to change to folder\n"
				"\"%s.\"\nStaying in \"%s\" folder.\n"
				"Fix setting of \"Folder for Mup Files\"\n"
				"in Config->File Locations.",
				mup_dir, curr_dir);
			fl_alert(message);
		}
	}

	// Expect 0 or 1 args. If 1, should be name of file to load
	if (argc > 1) {
		main_p->filemenu_p->load_file(argv[1]);
	}
	if (argc > 2) {
		fl_alert("Only expecting one file; extra arguments are being ignored.");
	}

	// Go into main event-handler loop
	int exitvalue = Fl::run();
	Main::clean_exit(exitvalue);
	/*NOTREACHED*/
	return(exitvalue);
}


// Clean up all the windows and their children and exit.

void
Main::clean_exit(int exitval)
{
	Main * m_p;
	Main * nextwin_p;

	for (m_p = list_p; m_p != 0; m_p = nextwin_p) {
		nextwin_p = m_p->next;
		delete m_p;
	}
	exit(exitval);
}

//---------- class to show Mup license and get user's agreement


License::License(Main *m_p, const char * magic)
	: Fl_Double_Window(Default_width, Default_height, "Mup License")
{
	// save passed-in info in object data
	main_p = m_p;
	magic_file_name = magic;

	// widget for displaying the license text
	text_p = new Fl_Text_Display(20, 20, w() - 40, h() - 90);
	resizable((Fl_Widget *) text_p);
	text_p->buffer( new Fl_Text_Buffer () );
	text_p->textsize(18);
	text_p->buffer()->text(license_text);

	i_agree_p = new Fl_Return_Button(100, h() - 50, 100, 30, "I Agree");
	i_agree_p->callback(IAgree_cb, this);

	cancel_p = new Fl_Button(w() - 200, h() - 50, 100, 30, "Cancel");
	cancel_p->callback(Cancel_cb, this);
	cancel_p->shortcut(FL_Escape);

	show();

	// Arrange for destructor to free the new-ed child widgets
	end();

	// Arrange for window manager closes to do Cancel.
	callback(Cancel_cb, this);
	when(FL_WHEN_NEVER);
}


License::~License()
{
}


// Callback for when user clicks that they agree to the license.

CALL_BACK(License, IAgree)
{
	// Create the magic file
	int fd;
	if ((fd = open(magic_file_name, O_WRONLY | O_CREAT, 0644)) < 0) {
		fl_alert("Unable to create file indicating license agreement.");
	}
	else {
		close(fd);
	}

	hide();

	// Bring up the normal main window
	main_p->show();
	main_p->hints();
}

// Callback if user refuses to accept license. We just exit if they refuse.

CALL_BACK(License, Cancel)
{
	exit(0);
}