public static string ConvertEditCategorieToDatabse(Gtk.TextBuffer buffer)
{
StringBuilder dbBuilder = new StringBuilder(buffer.Text);
// Replace tags of the textBuffer and save them as HTML-Tags
int buildOffset = 0;
for (Gtk.TextIter iter = buffer.StartIter; !iter.IsEnd; iter.ForwardChar())
{
if (iter.BeginsTag(boldTag))
{
dbBuilder.Insert(iter.Offset + buildOffset, "<b>", 1);
buildOffset += 3;
}
else
if (iter.BeginsTag(italicTag))
{
dbBuilder.Insert(iter.Offset + buildOffset, "<i>", 1);
buildOffset += 3;
}
if (iter.EndsTag(boldTag))
{
dbBuilder.Insert(iter.Offset + buildOffset, "</b>", 1);
buildOffset += 4;
}
if (iter.EndsTag(italicTag))
{
dbBuilder.Insert(iter.Offset + buildOffset, "</i>", 1);
buildOffset += 4;
}
}
dbBuilder.Replace("\n", "<br>");
return(dbBuilder.ToString());
}
/// <summary>
/// Remove the task tag on the line specified by the TextIter. This
/// will not remove the "todo:" text (i.e., it will not modify the
/// actual characters of the TextBuffer.
/// <param name="iter">The TextIter specifying the line where the
/// TaskTag should be removed.</param>
/// <returns>True if a TaskTag was removed, otherwise False.</returns>
/// </summary>
bool RemoveTaskTagFromLine(Gtk.TextIter iter)
{
Gtk.TextIter start = iter;
Gtk.TextIter end = iter;
TaskTag task_tag = GetTaskTagFromLineIter(ref start);
if (task_tag == null)
{
return(false);
}
while (start.StartsLine() == false)
{
start.BackwardChar();
}
while (end.EndsLine() == false)
{
end.ForwardChar();
}
// end.ForwardToLineEnd ();
last_removed_tag = null;
Buffer.RemoveTag(task_tag, start, end);
return(true);
}
/// <summary>
/// Remove the task from the line specified by the TextIter. This
/// will remove the TextTag and also the "todo:" portion of the line
/// so it will no longer be a task. The task summary text will be
/// left on the line.
/// <param name="iter">The TextIter specifying the line where the
/// task should be removed.</param>
/// <returns>True if a task was removed, otherwise False.</returns>
/// </summary>
bool RemoveTaskFromLine(ref Gtk.TextIter iter)
{
if (RemoveTaskTagFromLine(iter) == false)
{
return(false);
}
while (iter.StartsLine() == false)
{
iter.BackwardChar();
}
Gtk.TextIter line_end = iter;
while (line_end.EndsLine() == false)
{
line_end.ForwardChar();
}
// line_end.ForwardToLineEnd ();
string text = iter.GetText(line_end);
Buffer.Delete(ref iter, ref line_end);
text = GetTaskSummaryFromLine(text);
if (text.Length > 0)
{
Buffer.Insert(ref iter, text);
}
return(true);
}
// shortcuts for mainwindow
public static void Shortcut(MainWindow window, string key)
{
Console.WriteLine(key);
switch (key)
{
case "w":
FileMethods.Popup(window, window, new EventArgs(), FileMethods.Trigger.Close);
break;
case "q":
FileMethods.Popup(window, window, new EventArgs(), FileMethods.Trigger.Exit);
break;
case "r":
FileMethods.Popup(window, window, new EventArgs(), FileMethods.Trigger.Open);
break;
case "n":
EditMethods.Popup(window, window, new EventArgs(), EditMethods.Trigger.New);
break;
case "o":
EditMethods.Popup(window, window, new EventArgs(), EditMethods.Trigger.Open);
break;
case "l":
ShellMethods.Popup(window, window, new EventArgs(), ShellMethods.Trigger.Clear);
break;
case "d":
window.Message("Restart");
break;
case "t":
new MainWindow();
break;
case "p":
Console.WriteLine("Getting tags per character:");
Gtk.TextIter iter = window.mainShell.Buffer.StartIter.Copy();
for (int i = 0; i < window.mainShell.Buffer.CharCount; i++)
{
iter.ForwardChar();
foreach (var tag in iter.Tags)
{
Console.WriteLine(iter.Char + ": " + tag.Name);
}
}
break;
}
}
/// <summary>
/// If the renamed task is included inside this note, this
/// handler will update the task summary in the note buffer.
/// </summary>
private void OnTaskRenamed(Task task, string old_title)
{
if (task.OriginNoteUri == null || task.OriginNoteUri != Note.Uri)
{
return;
}
// Search through the note looking for the TaskTag so that it can
// be renamed
if (!ContainsText(old_title))
{
return;
}
// Iterate through the lines looking for tasks
Gtk.TextIter iter = Buffer.StartIter;
iter.ForwardLine(); // Move past the note's title
do
{
TaskTag task_tag = (TaskTag)
Buffer.GetDynamicTag("task", iter);
if (task_tag != null)
{
if (task_tag.Uri != task.Uri)
{
continue;
}
Gtk.TextIter line_start = iter;
while (line_start.StartsLine() == false)
{
line_start.BackwardChar();
}
Gtk.TextIter line_end = iter;
while (line_end.EndsLine() == false)
{
line_end.ForwardChar();
}
// line_end.ForwardToLineEnd ();
Buffer.Delete(ref line_start, ref line_end);
last_removed_tag = task_tag;
Buffer.Insert(ref line_start,
string.Format("{0}: {1}",
Catalog.GetString("todo"),
task.Summary));
task_tag.fillByData(task.Data);
break;
}
} while (iter.ForwardLine());
}
void TagApplied(object sender, Gtk.TagAppliedArgs args)
{
bool remove = false;
if (args.Tag.Name == "gtkspell-misspelled")
{
// Remove misspelled tag for links & title
foreach (Gtk.TextTag tag in args.StartChar.Tags)
{
if (tag != args.Tag &&
!NoteTagTable.TagIsSpellCheckable(tag))
{
remove = true;
break;
}
}
// Remove misspelled tag for acronyms (in all caps)
if (!args.StartChar.EndsWord() && System.Char.IsUpper(args.StartChar.Char, 0))
{
Gtk.TextIter char_iter = args.StartChar;
remove = true;
while (!char_iter.EndsWord())
{
if (Char.IsLower(char_iter.Char, 0))
{
remove = false;
break;
}
else
{
char_iter.ForwardChar();
}
}
}
}
else if (!NoteTagTable.TagIsSpellCheckable(args.Tag))
{
remove = true;
}
if (remove)
{
Buffer.RemoveTag("gtkspell-misspelled",
args.StartChar,
args.EndChar);
}
}
void OnInsertText(object sender, Gtk.InsertTextArgs args)
{
Gtk.TextIter start = args.Pos;
//Logger.Debug ("TaskNoteAddin.OnInsertText:\n" +
// "\tLength: {0}\n" +
// "\tText: {1}\n" +
// "\tLine: {2}",
// args.Length,
// args.Text,
// args.Pos.Line);
if (args.Length == 1 && args.Text == "\n")
{
Gtk.TextIter curr_line = args.Pos;
TaskTag task_tag = GetTaskTagFromLineIter(ref curr_line);
Gtk.TextIter prev_line = args.Pos;
prev_line.BackwardLine();
/*TaskTag*/
task_tag = GetTaskTagFromLineIter(ref prev_line);
if (task_tag != null)
{
// If the user just entered a newline and the previous
// line was a task, do some special processing...but
// we have to do it on idle since there are other
// Buffer.InsertText handlers that we'll screw up if
// we modify anything here.
args.RetVal = ProcessNewline();
}
else
{
// Check to see if the previous line is a todo: line
while (prev_line.StartsLine() == false)
{
prev_line.BackwardChar();
}
Gtk.TextIter prev_line_end = prev_line;
while (prev_line_end.EndsLine() == false)
{
prev_line_end.ForwardChar();
}
string prev_line_text = prev_line.GetText(prev_line_end);
Match match = regex.Match(prev_line_text);
if (match.Success && last_removed_tag != null)
{
TaskManager task_mgr = TasksApplicationAddin.DefaultTaskManager;
Task task;
task = task_mgr.FindByUri(last_removed_tag.Uri);
if (task != null)
{
// Update the task's summary and make sure that
// the previous line is appropriately tagged.
string summary = GetTaskSummaryFromLine(prev_line_text);
task.Summary = summary;
Buffer.ApplyTag(last_removed_tag, prev_line, prev_line_end);
}
else
{
Logger.Debug("Shouldn't ever hit this code (hopefully)");
}
}
last_removed_tag = null;
}
}
else
{
ApplyTaskTagToBlock(ref start, args.Pos);
}
}
void ApplyTaskTagToBlock(ref Gtk.TextIter start, Gtk.TextIter end)
{
Gtk.TextIter line_end = start;
while (line_end.EndsLine() == false)
{
line_end.ForwardChar();
}
// For some reason, the above code behaves like it should (i.e.,
// without advancing to the next line). The line below that's
// commented out doesn't work. It ends up advancing the iter to
// the end of the next line. Very strange!
// line_end.ForwardToLineEnd ();
TaskTag task_tag = GetTaskTagFromLineIter(ref start);
if (task_tag != null)
{
Buffer.RemoveTag(task_tag, start, line_end);
}
else
{
task_tag = last_removed_tag;
}
string text = start.GetText(line_end);
// Logger.Debug ("Evaluating with regex: {0}", text);
TaskManager task_mgr = TasksApplicationAddin.DefaultTaskManager;
Task task;
Match match = regex.Match(text);
if (match.Success)
{
string summary = GetTaskSummaryFromLine(text);
if (task_tag == null)
{
task = task_mgr.Create(summary);
task.QueueSave(true);
task.OriginNoteUri = Note.Uri;
task_tag = (TaskTag)
Note.TagTable.CreateDynamicTag("task");
task_tag.Uri = task.Uri;
}
else
{
task = task_mgr.FindByUri(task_tag.Uri);
if (task != null)
{
task.Summary = summary;
}
else
{
Logger.Debug("FIXME: Add code to remove the task tag if this case is hit");
}
}
Buffer.ApplyTag(task_tag, start, line_end);
last_removed_tag = null;
}
else if (task_tag != null)
{
// This task should be deleted
task = task_mgr.FindByUri(task_tag.Uri);
if (task != null)
{
task_mgr.Delete(task);
}
last_removed_tag = null;
}
}
void OnInsertText(object sender, Gtk.InsertTextArgs args)
{
Gtk.TextIter start;
Gtk.TextIter end = args.Pos;
end.BackwardChars(2);
Gtk.TextIter iter = end;
string id;
switch (end.Char)
{
case bold_id:
id = bold_id;
break;
case italic_id:
id = italic_id;
break;
case underlined_id:
id = underlined_id;
break;
case highlight_id:
id = highlight_id;
break;
case strikethrough_id:
id = strikethrough_id;
break;
default:
return;
}
/* TODO: Catch double "id" characters. ** should not be
* detected
*/
while (iter.LineOffset != 0)
{
iter.BackwardChar();
if (iter.Char == id)
{
start = iter;
iter.ForwardChar();
string text = Buffer.GetText(iter, end, false);
end.ForwardChar();
Gtk.TextTag tags;
switch (id)
{
case bold_id:
tags = (Gtk.TextTag)bold_tag;
break;
case italic_id:
tags = italic_tag;
break;
case underlined_id:
tags = underline_tag;
break;
case highlight_id:
tags = highlight_tag;
break;
case strikethrough_id:
tags = strikethrough_tag;
break;
default:
return;
}
Buffer.Delete(ref start, ref end);
Buffer.InsertWithTags(ref start, text, tags);
break;
}
}
}