Is there a better way to implement Shift+Tab or Decrease Indent?

Question

this is how i implemented Shift-Tab or decrease indent... the result on screenr

if ((Keyboard.Modifiers & ModifierKeys.Shift) == ModifierKeys.Shift && e.Key == Key.Tab)
{
    // Shift+Tab
    int selStart = txtEditor.SelectionStart;
    int selLength = txtEditor.SelectionLength;
    string selText = txtEditor.SelectedText;
    string text = txtEditor.Text;

    // find new lines that are followed by 1 or more spaces
    Regex regex = new Regex(Environment.NewLine + @"(\s+)");
    Match m = regex.Match(selText);
    string spaces;
    while (m.Success)
    {
        GroupCollection grps = m.Groups;
        spaces = grps[1].Value;
        int i = 0;
        // remove 1 space on each loop to a max of 4 spaces
        while (i < 4 && spaces.Length > 0)
        {
            spaces = spaces.Remove(0, 1);
            i++;
        }
        // update spaces in selText
        selText = selText.Remove(grps[1].Index, grps[1].Length).Insert(grps[1].Index, spaces);

        m = regex.Match(selText, grps[1].Index + spaces.Length);
    }

    // commit changes to selText to text 
    text = text.Remove(selStart, selLength).Insert(selStart, selText);

    // decrease indent of 1st line
    // - find 1st character of selection
    regex = new Regex(@"\w");
    m = regex.Match(text, selStart);
    int start = selStart;
    if (m.Success) {
        start = m.Index;
    }
    // - start search for spaces 
    regex = new Regex(Environment.NewLine + @"(\s+)", RegexOptions.RightToLeft);
    m = regex.Match(text, start);
    if (m.Success) {
        spaces = m.Groups[1].Value;
        int i = 0;
        while (i < 4 && spaces.Length > 0) {
            spaces = spaces.Remove(0, 1); // remove 1 space
            i++;
        }
        text = text.Remove(m.Groups[1].Index, m.Groups[1].Length).Insert(m.Groups[1].Index, spaces);
        selStart = m.Groups[1].Index;
    }

    txtEditor.Text = text;
    txtEditor.SelectionStart = selStart;
    txtEditor.SelectionLength = selText.Length;
    e.Handled = true;
}

the code looks messy and i wonder if theres a better way.

Answer 1

I'm thinking freely as I have never implemented a text editor.

What if you represent each line by an object with an indentation property, which is reflected in the rendering of the line. Then it would be easy to increase and decrease the indent.

Answer 2

Personally, I wouldn't use Regex for this.

Untested, probably needs modification:

public static class StringExtensions
{
 // Removes leading white-spaces in a string up to a maximum
 // of 'level' characters
 public static string ReduceIndent(this string line, int level)
 { 
   // Produces an IEnumerable<char> with the characters 
   // of the string verbatim, other than leading white-spaces
   var unindentedChars = line.SkipWhile((c, index) => char.IsWhiteSpace(c) && index < level);

   return new string(unindentedChars.ToArray());
 }


 // Applies a transformation to each line of a string and returns the
 // transformed string
 public static string LineTransform(this string text, Func<string,string> transform)
 {
   //Splits the string into an array of lines
   var lines = text.Split(new[] { Environment.NewLine }, StringSplitOptions.None);

   //Applies the transformation to each line
   var transformedLines = lines.Select(transform);

   //Joins the transformed lines into a new string
   return string.Join(Environment.NewLine, transformedLines.ToArray());
 } 
}
 ... 

if ((Keyboard.Modifiers & ModifierKeys.Shift) == ModifierKeys.Shift && e.Key == Key.Tab)
{                             
  // Reduces the indent level of the selected text by applying the
  // 'ReduceIndent' transformation to each line of the text.
  string replacement = txtEditor.SelectedText
                                .LineTransform(line => line.ReduceIndent(4));

  int selStart = txtEditor.SelectionStart;
  int selLength = txtEditor.SelectionLength;

  txtEditor.Text = txtEditor.Text
                            .Remove(selStart, selLength)
                            .Insert(selStart, replacement);

  txtEditor.SelectionStart = selStart;
  txtEditor.SelectionLength = replacement.Length;
  e.Handled = true;
}   

EDIT:

Added comments to the code as per the request of the OP.

For more info:

• Extension Methods
• Func<T, TResult> delegate
• Enumerable.SkipWhile extension method
• Lambda Expressions