← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to src/core/Mono.Texteditor/Mono.TextEditor.Utils/RtfWriter.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
Import upstream version 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/core/Mono.Texteditor/Mono.TextEditor.Utils/RtfWriter.cs
26
26
using System;
27
27
using System.Text;
28
28
using System.Collections.Generic;
 
29
using Mono.TextEditor.Highlighting;
29
30
 
30
31
namespace Mono.TextEditor.Utils
31
32
{
32
33
        public static class RtfWriter
33
34
        {
34
 
                static string CreateColorTable (List<Gdk.Color> colorList)
 
35
                static string CreateColorTable (List<Cairo.Color> colorList)
35
36
                {
36
37
                        var colorTable = new StringBuilder ();
37
38
                        colorTable.Append (@"{\colortbl ;");
38
39
                        for (int i = 0; i < colorList.Count; i++) {
39
 
                                Gdk.Color color = colorList [i];
 
40
                                var color = colorList [i];
40
41
                                colorTable.Append (@"\red");
41
 
                                colorTable.Append (color.Red / 256);
 
42
                                colorTable.Append ((int)(255  * color.R));
42
43
                                colorTable.Append (@"\green");
43
 
                                colorTable.Append (color.Green / 256);
 
44
                                colorTable.Append ((int)(255  * color.G));
44
45
                                colorTable.Append (@"\blue");
45
 
                                colorTable.Append (color.Blue / 256);
 
46
                                colorTable.Append ((int)(255  * color.B));
46
47
                                colorTable.Append (";");
47
48
                        }
48
49
                        colorTable.Append ("}");
51
52
 
52
53
                public static string GenerateRtf (TextEditorData data)
53
54
                {
54
 
                        return GenerateRtf (data.Document, data.Document.SyntaxMode, data.ColorStyle, data.Options);
55
 
                }
56
 
 
57
 
                public static string GenerateRtf (TextDocument doc, Mono.TextEditor.Highlighting.ISyntaxMode mode, Mono.TextEditor.Highlighting.ColorScheme style, ITextEditorOptions options)
 
55
                        return GenerateRtf (ColoredSegment.GetChunks (data, new TextSegment (0, data.Length)), data.ColorStyle, data.Options);
 
56
                }
 
57
 
 
58
                static void AppendRtfText (StringBuilder rtfText, string text, ref bool appendSpace)
 
59
                {
 
60
                        foreach (char ch in text) {
 
61
                                switch (ch) {
 
62
                                case '\\':
 
63
                                        rtfText.Append (@"\\");
 
64
                                        break;
 
65
                                case '{':
 
66
                                        rtfText.Append (@"\{");
 
67
                                        break;
 
68
                                case '}':
 
69
                                        rtfText.Append (@"\}");
 
70
                                        break;
 
71
                                case '\t':
 
72
                                        rtfText.Append (@"\tab");
 
73
                                        appendSpace = true;
 
74
                                        break;
 
75
                                default:
 
76
                                        if (appendSpace) {
 
77
                                                rtfText.Append (' ');
 
78
                                                appendSpace = false;
 
79
                                        }
 
80
 
 
81
                                        int unicodeCh = (int)ch;
 
82
                                        if (0x7F < unicodeCh && unicodeCh <= 0xFF) {
 
83
                                                rtfText.Append(@"\u" + unicodeCh);
 
84
                                        } else if (0xFF < unicodeCh && unicodeCh <= 0x8000) {
 
85
                                                rtfText.Append(@"\uc1\u" + unicodeCh + "*");
 
86
                                        } else if (0x8000 < unicodeCh && unicodeCh <= 0xFFFF) {
 
87
                                                rtfText.Append(@"\uc1\u" + (unicodeCh - 0x10000) + "*");
 
88
                                        } else {
 
89
                                                rtfText.Append (ch);
 
90
                                        }
 
91
                                        break;
 
92
                                }
 
93
                        }
 
94
                }
 
95
                internal static string GenerateRtf (List<List<ColoredSegment>> chunks, Mono.TextEditor.Highlighting.ColorScheme style, ITextEditorOptions options)
58
96
                {
59
97
                        var rtfText = new StringBuilder ();
60
 
                        var colorList = new List<Gdk.Color> ();
 
98
                        var colorList = new List<Cairo.Color> ();
61
99
 
62
 
                        var selection = new TextSegment (0, doc.TextLength);
63
 
                        int startLineNumber = doc.OffsetToLineNumber (selection.Offset);
64
 
                        int endLineNumber = doc.OffsetToLineNumber (selection.EndOffset);
65
 
                        
66
100
                        bool isItalic = false;
67
101
                        bool isBold = false;
68
102
                        int curColor = -1;
69
 
                        foreach (var line in doc.GetLinesBetween (startLineNumber, endLineNumber)) {
 
103
                        foreach (var line in chunks) {
70
104
                                bool appendSpace = false;
71
 
                                foreach (var chunk in mode.GetChunks (style, line, line.Offset, line.Length)) {
72
 
                                        int start = System.Math.Max (selection.Offset, chunk.Offset);
73
 
                                        int end = System.Math.Min (chunk.EndOffset, selection.EndOffset);
74
 
                                        var chunkStyle = style.GetChunkStyle (chunk);
75
 
                                        if (start < end) {
76
 
                                                if (isBold != chunkStyle.Bold) {
77
 
                                                        rtfText.Append (chunkStyle.Bold ? @"\b" : @"\b0");
78
 
                                                        isBold = chunkStyle.Bold;
79
 
                                                        appendSpace = true;
80
 
                                                }
81
 
                                                if (isItalic != chunkStyle.Italic) {
82
 
                                                        rtfText.Append (chunkStyle.Italic ? @"\i" : @"\i0");
83
 
                                                        isItalic = chunkStyle.Italic;
84
 
                                                        appendSpace = true;
85
 
                                                }
86
 
                                                if (!colorList.Contains (chunkStyle.Color)) 
87
 
                                                        colorList.Add (chunkStyle.Color);
88
 
                                                int color = colorList.IndexOf (chunkStyle.Color);
89
 
                                                if (curColor != color) {
90
 
                                                        curColor = color;
91
 
                                                        rtfText.Append (@"\cf" + (curColor + 1));
92
 
                                                        appendSpace = true;
93
 
                                                }
94
 
                                                for (int i = start; i < end; i++) {
95
 
                                                        char ch = doc.GetCharAt (i);
96
 
                                                        
97
 
                                                        switch (ch) {
98
 
                                                        case '\\':
99
 
                                                                rtfText.Append (@"\\");
100
 
                                                                break;
101
 
                                                        case '{':
102
 
                                                                rtfText.Append (@"\{");
103
 
                                                                break;
104
 
                                                        case '}':
105
 
                                                                rtfText.Append (@"\}");
106
 
                                                                break;
107
 
                                                        case '\t':
108
 
                                                                rtfText.Append (@"\tab");
109
 
                                                                appendSpace = true;
110
 
                                                                break;
111
 
                                                        default:
112
 
                                                                if (appendSpace) {
113
 
                                                                        rtfText.Append (' ');
114
 
                                                                        appendSpace = false;
115
 
                                                                }
116
 
                                                                rtfText.Append (ch);
117
 
                                                                break;
118
 
                                                        }
119
 
                                                }
120
 
                                        }
 
105
                                foreach (var chunk in line) {
 
106
                                        var chunkStyle = style.GetChunkStyle (chunk.Style);
 
107
                                        if (isBold != (chunkStyle.FontWeight == Xwt.Drawing.FontWeight.Bold)) {
 
108
                                                isBold = chunkStyle.FontWeight == Xwt.Drawing.FontWeight.Bold;
 
109
                                                rtfText.Append (isBold ? @"\b" : @"\b0");
 
110
                                                appendSpace = true;
 
111
                                        }
 
112
                                        if (isItalic != (chunkStyle.FontStyle == Xwt.Drawing.FontStyle.Italic)) {
 
113
                                                isItalic = chunkStyle.FontStyle == Xwt.Drawing.FontStyle.Italic;
 
114
                                                rtfText.Append (isItalic ? @"\i" : @"\i0");
 
115
                                                appendSpace = true;
 
116
                                        }
 
117
                                        var foreground = style.GetForeground (chunkStyle);
 
118
                                        if (!colorList.Contains (foreground)) 
 
119
                                                colorList.Add (foreground);
 
120
                                        int color = colorList.IndexOf (foreground);
 
121
                                        if (curColor != color) {
 
122
                                                curColor = color;
 
123
                                                rtfText.Append (@"\cf" + (curColor + 1));
 
124
                                                appendSpace = true;
 
125
                                        }
 
126
                                        AppendRtfText (rtfText, chunk.Text, ref appendSpace);
121
127
                                }
122
 
                                rtfText.Append (@"\par");
123
 
                                rtfText.AppendLine ();
 
128
                                rtfText.AppendLine (@"\line");
124
129
                        }
125
130
                        
126
131
                        var rtf = new StringBuilder();
127
132
 
128
 
                        rtf.Append (@"{\rtf1\ansi\deff0\adeflang1025");
129
 
                        
130
 
                        // font table
131
 
                        rtf.Append (@"{\fonttbl");
132
 
 
133
 
                        rtf.Append (@"{\f0\fnil\fprq1\fcharset128 " + options.Font.Family + ";}");
134
 
 
135
 
                        rtf.Append ("}");
136
 
                        
 
133
                        rtf.AppendLine (@"{\rtf1\ansi\deff0\adeflang1025");
 
134
                        rtf.AppendLine (@"{\fonttbl");
 
135
                        rtf.AppendLine (@"{\f0\fnil\fprq1\fcharset128 " + options.Font.Family + ";}");
 
136
                        rtf.AppendLine ("}");
137
137
                        rtf.Append (CreateColorTable (colorList));
138
 
                        
139
 
                        rtf.Append (@"\viewkind4\uc1\pard");
140
 
 
141
 
                        rtf.Append (@"\f0");
 
138
                        rtf.AppendLine (@"\viewkind4\uc1\pard");
 
139
                        rtf.AppendLine (@"\f0");
142
140
                        try {
143
141
                                string fontName = options.Font.ToString ();
144
142
                                double fontSize = Double.Parse (fontName.Substring (fontName.LastIndexOf (' ')  + 1), System.Globalization.CultureInfo.InvariantCulture) * 2;
145
143
                                rtf.Append (@"\fs");
146
144
                                rtf.Append (fontSize);
147
145
                        } catch (Exception) {};
148
 
                        rtf.Append (@"\cf1");
 
146
                        rtf.AppendLine (@"\cf1");
149
147
                        rtf.Append (rtfText.ToString ());
150
148
                        rtf.Append("}");
151
149
                        return rtf.ToString ();