Import upstream version 5.3.

[mup] / mup / mupmate / Edit.C

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

// Code for Edit menu on main toolbar


#include "globals.H"
#include "Edit.H"
#include "utils.H"
#include <FL/Enumerations.H>
#include <FL/fl_ask.H>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>


//-------------------Find_dialog class--------------------------------
// This class is for the window that pops up when user does a "Find"

// Constructor creates the window and all the widgets inside it

Find_dialog::Find_dialog(void)
	: Fl_Double_Window(430, 170, "Find")
{
	pattern_p = new Fl_Input(90, 20, 175, 20, "Find what:");
	// We have ungray the "Find Next" when user enters a pattern,
	// so set up callback for that
	pattern_p->callback(Pattern_cb, this);
	pattern_p->when(FL_WHEN_CHANGED);
	pattern_p->tooltip("Enter the pattern you want to\n"
			"search for in your Mup input.");

	replace_with_p = new Fl_Input(90, 60, 175, 20, "Replace with");
	replace_with_p->tooltip("Enter the replacement text.");
	replace_with_p->hide();

	casematch_p = new Fl_Check_Button(10, 85, 100, 20, "Match case");
	casematch_p->tooltip("If checked, upper/lower case must match.\n"
			"If not checked, case is ignored.");

	direction_p = new Fl_Box(FL_ENGRAVED_BOX, 120, 55, 125, 35, "");
	up_p = new Fl_Round_Button(130, 60, 40, 20, "Up");
	up_p->type(FL_RADIO_BUTTON);
	up_p->value(0);
	up_p->tooltip("Search upward from current place.");
	up_p->callback(change_cb, this);
	down_p = new Fl_Round_Button(175, 60, 60, 20, "Down");
	down_p->type(FL_RADIO_BUTTON);
	down_p->value(1);
	down_p->tooltip("Search downward from current place.");
	down_p->callback(change_cb, this);

	next_p = new Fl_Return_Button(285, 10, 125, 30, "Find Next");
	next_p->when(FL_WHEN_RELEASE);
	next_p->callback(FindNext_cb, this);
	next_p->deactivate();

	replace_p = new Fl_Button(285, 45, 125, 30, "Replace");
	replace_p->tooltip("Replace the current instance of the pattern\n"
			"with the replacement text.");
	replace_p->callback(Replace_cb, this);
	replace_p->when(FL_WHEN_RELEASE);
	replace_p->deactivate();
	replace_p->hide();

	replace_all_p = new Fl_Button(285, 80, 125, 30, "Replace All");
	replace_all_p->tooltip("Replace all instances of the pattern\n"
			"with the replacement text.");
	replace_all_p->callback(ReplaceAll_cb, this);
	replace_all_p->when(FL_WHEN_RELEASE);
	replace_all_p->deactivate();
	replace_all_p->hide();

	cancel_p = new Fl_Button(285, 115, 125, 30, "Cancel");
	cancel_p->shortcut(FL_Escape);
	cancel_p->when(FL_WHEN_RELEASE);
	cancel_p->callback(Cancel_cb, this);

	// Arrange for destructor to clean up new-ed widgets
	end();

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

Find_dialog::~Find_dialog()
{
}


// The class can be used for either Find or Replace.
// These next two methods set which of those two personalities
// the window has.

void
Find_dialog::as_Find()
{
	label("Find");
	cancel_p->resize(cancel_p->x(), 55, cancel_p->w(), cancel_p->h());
	casematch_p->resize(casematch_p->x(), 65, casematch_p->w(), casematch_p->h());
	resize(x(), y(), w(), 120);
	direction_p->show();
	up_p->show();
	down_p->show();
	replace_with_p->hide();
	replace_p->hide();
	replace_all_p->hide();
	is_replace = false;
}

void
Find_dialog::as_Replace()
{
	label("Replace");
	cancel_p->resize(cancel_p->x(), 115, cancel_p->w(), cancel_p->h());
	casematch_p->resize(casematch_p->x(), 115, casematch_p->w(), casematch_p->h());
	resize(x(), y(), w(), 155);
	direction_p->hide();
	up_p->hide();
	down_p->hide();
	replace_with_p->show();
	replace_p->show();
	replace_all_p->show();
	is_replace = true;
}


// Callback for when user clicks "Find Next" button after filling in
// the dialog.

CALL_BACK(Find_dialog, FindNext)
{
	int start = editor_p->insert_position();
	bool found;
	int where;
	if (down_p->value() == 1 || is_replace) {
		found = editor_p->buffer()->search_forward(
				start + 1, pattern_p->value(),
				&where, casematch_p->value());
	}
	else {
		found = editor_p->buffer()->search_backward(
				start - 1, pattern_p->value(),
				&where, casematch_p->value());
	}

	if ( ! found ) {
		// It seems fltk does not find a pattern if it is exactly
		// at the beginning for an upward search or exactly
		// at the end for a downward search. That surely can't
		// be right, so add special checks for that. If fltk
		// fixes that some day, we'll never hit this case,
		// so this should still be compatible.
		int patlength = pattern_p->size();
		int bufflength = editor_p->buffer()->length();
		where = (down_p->value() ? bufflength - patlength : 0);
		// If pattern is longer than buffer, then no match possible.
		// If already at pattern,
		// we already found the end one last time.
		if (patlength <= bufflength &&
				where != editor_p->insert_position() - patlength) {
			if (casematch_p->value()) {
				if (strncmp(pattern_p->value(),
						editor_p->buffer()->text()
						+ where, patlength) == 0) {
					found = 1;
				}
			}
			else {
				if (strncasecmp(pattern_p->value(),
						editor_p->buffer()->text()
						+ where, patlength) == 0) {
					found = 1;
				}
			}
		}

		if ( ! found ) {
			fl_alert("Cannot find \"%s\"", pattern_p->value());
			gray_out();

			// The main editor window should now
			// be made active, rather than the Find window.
			editor_p->take_focus();
		}
	}
	if (found) {
		editor_p->buffer()->highlight(where, where + pattern_p->size());
		editor_p->insert_position(where + pattern_p->size());
		editor_p->show_insert_position();
	}
}


// Callback for when user clicks "Replace"

CALL_BACK(Find_dialog, Replace)
{
	// See if we are already at the pattern to replace due to
	// a previous Replace/Find Next
	int start, end, isRect, rectStart, rectEnd;
	bool at_pattern = false;
	if (editor_p->buffer()->highlight_position(&start, &end, &isRect,
						&rectStart, &rectEnd)) {
		int place = editor_p->insert_position();
		if (place == end && (end - start == pattern_p->size())) {
			if (casematch_p->value()) {
			
				at_pattern = (strncmp(pattern_p->value(),
					editor_p->buffer()->text() + start,
					pattern_p->size()) == 0);
			}
			else {
				at_pattern = (strncasecmp(pattern_p->value(),
					editor_p->buffer()->text() + start,
					pattern_p->size()) == 0);
			}
		}
	}

	if (at_pattern) {
		editor_p->buffer()->unhighlight();
		editor_p->buffer()->replace(start, end, replace_with_p->value());
	}

	FindNext();
}


// Callback for when use clicks "Replace All"

CALL_BACK(Find_dialog, ReplaceAll)
{
	// We want to be able to "undo" the entire "Replace All"
	// so we make a copy of the buffer, make all the changes in the
	// copy and then replace the original with the altered copy.
	Fl_Text_Buffer altered_buff;
	altered_buff.copy(editor_p->buffer(), 0, editor_p->buffer()->length(), 0);
	int start;	// where to begin each search
	bool found = true;	// if matching pattern found on current search
	int where;	// offset into buffer where match occurred
	int new_cursor_pos;
	bool replaced_something = false;	// if any matches found at all

	new_cursor_pos = editor_p->insert_position();
	for (start = 0; found; start = where + replace_with_p->size()) {
		if ((found = altered_buff.search_forward(
						start, pattern_p->value(),
						&where, casematch_p->value()))
						!= 0) {
			altered_buff.replace(where, where + pattern_p->size(),
						replace_with_p->value());
			new_cursor_pos = where + replace_with_p->size();
			replaced_something = true;
		}
	}
	// Kludge because pattern at very end is not found.
	// See more complete explanation in FindNext().
	where = altered_buff.length() - pattern_p->size();
	if (where >= 0) {
		found = false;
		if (casematch_p->value()) {
			if (strcmp(pattern_p->value(),
					altered_buff.text() + where) == 0) {
				found = true;
			}
		}	
		else {
			if (strcasecmp(pattern_p->value(),
					altered_buff.text() + where) == 0) {
				found = true;
			}
		}
		if (found) {
			altered_buff.replace(where, where + pattern_p->size(),
						replace_with_p->value());
			new_cursor_pos = where + replace_with_p->size();
			replaced_something = true;
		}
	}

	if (replaced_something) {
		editor_p->buffer()->replace(0, editor_p->buffer()->length(),
						altered_buff.text());
		editor_p->insert_position(new_cursor_pos);
	}
	else {
		fl_alert("No instances of pattern to replace.");
	}
	replace_all_p->deactivate();
}


// Callback for when user clicks "Cancel" in the "Find" window.
// Hides the window.

CALL_BACK(Find_dialog, Cancel)
{
	editor_p->buffer()->unhighlight();
	hide();
}


// If user did Find Next until no more instances found,
// the Find Next and Replace buttons will get grayed out,
// But if they then change search direction, we need to reactivate them
// since the pattern might be found in that direction.
// They must also be ungrayed if the contents of the editor buffer change,
// since the new text might contain the pattern.

CALL_BACK(Find_dialog, change)
{
	next_p->activate();
	replace_p->activate();
	replace_all_p->activate();
}


// Callback for when user changes pattern, to know whether to gray or ungray
// Find Next button or not.

CALL_BACK(Find_dialog, Pattern)
{
	if (pattern_p->size() > 0) {
		next_p->activate();
		replace_p->activate();
		replace_all_p->activate();
	}
	else {
		gray_out();
	}
}

// Horrible kludge. If the "Find" or "Replace" is grayed out because there
// are no more instances of the pattern in the current direction,
// and then user moves the cursor somewhere else, it's possible the pattern
// may then be findable. But modify_callback does not get called for
// a change in cursor position. So we poll to see if the cursor position
// changed since the last check, and if so, ungray.
// Fortunately, we can limit this to only when the button are grayed,
// which shouldn't be too often.

void
Find_dialog::gray_out(void)
{
	next_p->deactivate();
	replace_p->deactivate();
	replace_all_p->deactivate();
	// Remember where we are and set up to poll for changes
	last_cursor_position = editor_p->insert_position();
	Fl::add_timeout(0.5, cursor_change_check, this);
}

void
Find_dialog::cursor_change_check(void * data)
{
	Find_dialog * obj_p = (Find_dialog *) data;
	if (obj_p->editor_p->insert_position() != obj_p->last_cursor_position
				&& obj_p->pattern_p->size() > 0) {
		obj_p->change();
	}
	else {
		Fl::repeat_timeout(0.5, cursor_change_check, data);
	}
}


// Class needs access to the editor; this lets it know which editor
// instance to use, and which main window it is associated with.

void
Find_dialog::set_editor(Fl_Text_Editor * ed)
{
	editor_p = ed;
}


// Returns the current "Find" pattern entered by user,
// or "" if they have not yet entered any such pattern

const char *
Find_dialog::get_pattern()
{
	if (pattern_p->value() == 0) {
		return("");
	}
	else {
		return(pattern_p->value());
	}
}


//---------------- GoTo class---------------------------------------------

GoTo_dialog::GoTo_dialog(void)
	: Fl_Double_Window(225, 95, "Goto line")
{
	linenum_p = new Positive_Int_Input(115, 10, 60, 30, "Line Number:");
	linenum_p->tooltip("Enter the line number of the line\n"
			"you want to make the current line.");

	ok_p = new Fl_Return_Button(25, 50, 75, 30, "OK");
	ok_p->when(FL_WHEN_RELEASE);
	ok_p->callback(OK_cb, this);

	cancel_p = new Fl_Button(125, 50, 75, 30, "Cancel");
	cancel_p->shortcut(FL_Escape);
	cancel_p->when(FL_WHEN_RELEASE);
	cancel_p->callback(Cancel_cb, this);

	// Arrange for destructor to clean up new-ed widgets
	end();

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

GoTo_dialog::~GoTo_dialog()
{
}


// Callback for when user clicks "OK" in GoTo dialog

CALL_BACK(GoTo_dialog, OK)
{
	// Find end of valid range
	int last_line = editor_p->buffer()->count_lines(0,
			editor_p->buffer()->length());
	// FLTK line numbers start at 0, so we have to subtract 1 from
	// number supplied by user.
	int desired_line = (int) strtol(linenum_p->value(), 0, 0) - 1;
	if (desired_line < 0 || desired_line > last_line) {
		fl_alert("Line number out of range");
		return;
	}

	// Find appropriate new cursor position and move cursor there
	int newposition = editor_p->buffer()->skip_lines(0, desired_line);
	editor_p->insert_position(newposition);
	editor_p->show_insert_position();
	hide();
}


// Callback if user cancel Go To

CALL_BACK(GoTo_dialog, Cancel)
{
	hide();
}


// Code that calls constructor should then call this to tell
// us which editor instance to act upon.

void
GoTo_dialog::set_editor(Fl_Text_Editor * ed)
{
	editor_p = ed;
}


// Initialize contents on GoTo field to the current line number

void
GoTo_dialog::set_current_line()
{
	char num_as_string[16];
	// fltk numbers lines from 0, so add 1 to get what user expects
	(void) sprintf(num_as_string, "%d",
		editor_p->buffer()->count_lines(0, editor_p->insert_position()) + 1);
	linenum_p->value(num_as_string);
}


//------------------Edit class-----------------------------------------------
// Implements the items in the Edit menu on the main toolbar


Edit::Edit()
{
	find_p = 0;
	goto_p = 0;
	wrote_to_clipboard = false;
}


Edit::~Edit()
{
	if (find_p != 0) {
		delete find_p;
		find_p = 0;
	}
	if (goto_p != 0) {
		delete goto_p;
		goto_p = 0;
	}
}


//---Undo menu item---------------

CALL_BACK(Edit, Undo)
{
	buffer_p->undo();
}


//---Cut menu item---------------

CALL_BACK(Edit, Cut)
{
	Fl_Text_Editor::kf_cut('x', editor_p);
	set_can_paste();
}


//---Copy menu item---------------

CALL_BACK(Edit, Copy)
{
	Fl_Text_Editor::kf_copy('c', editor_p);
	set_can_paste();
}


//---Paste menu item---------------

CALL_BACK(Edit, Paste)
{
	Fl_Text_Editor::kf_paste('v', editor_p);
}


//---Delete menu item---------------

CALL_BACK(Edit, Delete)
{
	buffer_p->remove_selection();
	buffer_p->unselect();
}


//---Find menu item---------------

CALL_BACK(Edit, Find)
{
	if (find_p == 0) {
		// First time, create widget
		find_p = new Find_dialog();
		find_p->set_editor(editor_p);
	}
	find_p->as_Find();
	find_p->show();
}


//---Find Next menu item---------------

CALL_BACK(Edit, FindNext)
{
	if (find_p == 0 || strlen(find_p->get_pattern()) == 0) {
		// No pattern specified yet; turn into Find
		Find();
		return;
	}
	find_p->FindNext();
}


//---Replace menu item---------------

CALL_BACK(Edit, Replace)
{
	if (find_p == 0) {
		// First time, create widget
		find_p = new Find_dialog();
		find_p->set_editor(editor_p);
	}
	find_p->as_Replace();
	find_p->show();
}


//---Go To menu item---------------

CALL_BACK(Edit, GoTo)
{
	if (goto_p == 0) {
		// First time, create widget
		goto_p = new GoTo_dialog();
		goto_p->set_editor(editor_p);
	}
	goto_p->set_current_line();
	goto_p->show();
}


//---Select All menu item---------------

CALL_BACK(Edit, SelectAll)
{
	buffer_p->select(0, buffer_p->length());
}


//---- Callback for when editor window is modified.
// Grayed out find/replace should be ungrayed, because the modified
// text might now match.

void
Edit::modify_cb(int, int, int, int, const char *, void * data)
{
	if ( ((Edit *)data)->find_p != 0) {
		((Edit *)data)->find_p->change();
	}
}


// Class needs access to the editor; this lets it know which editor
// instance to use.

void
Edit::set_editor(Fl_Text_Editor * ed)
{
	editor_p = ed;
	buffer_p = editor_p->buffer();
}

// Ungray Paste button

void
Edit::set_can_paste(void)
{
	wrote_to_clipboard = true;
	editor_p->buffer()->call_modify_callbacks();
}