?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Updated from its repository.
[cake.git] / workbench / classes / gadgets / texteditor / mcc / EditorStuff.c
blob1b2cb705ec3ec2d72fb79d07eb11116554bf2b56
1 /***************************************************************************
2
3 TextEditor.mcc - Textediting MUI Custom Class
4 Copyright (C) 1997-2000 Allan Odgaard
5 Copyright (C) 2005-2009 by TextEditor.mcc Open Source Team
6
7 This library is free software; you can redistribute it and/or
8 modify it under the terms of the GNU Lesser General Public
9 License as published by the Free Software Foundation; either
10 version 2.1 of the License, or (at your option) any later version.
11
12 This library is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
16
17 TextEditor class Support Site: http://www.sf.net/projects/texteditor-mcc
18
19 $Id$
20
21 ***************************************************************************/
22
23 #include <string.h>
24
25 #include <devices/clipboard.h>
26 #include <libraries/iffparse.h>
27
28 #include <clib/alib_protos.h>
29 #include <proto/graphics.h>
30 #include <proto/layers.h>
31 #include <proto/exec.h>
32 #include <proto/iffparse.h>
33 #include <proto/intuition.h>
34
35 #include "private.h"
36 #include "Debug.h"
37
38 BOOL InitClipboard(struct InstData *data, ULONG flags);
39 void EndClipSession(struct InstData *data);
40
41 #if defined(__MORPHOS__)
42 #include <proto/keymap.h>
43 #include <proto/locale.h>
44
45 static char *utf8_to_ansi(struct InstData *data, STRPTR src)
46 {
47 static struct KeyMap *keymap;
48 CONST_STRPTR ptr;
49 STRPTR dst;
50 ULONG octets, strlength;
51
52 ENTER();
53
54 keymap = AskKeyMapDefault();
55
56 strlength = 0;
57 ptr = src;
58
59 do
60 {
61 WCHAR wc;
62 UBYTE c;
63
64 ptr += (octets = UTF8_Decode(ptr, &wc));
65 c = ToANSI(wc, keymap);
66
67 strlength++;
68
69 /* ToANSI() returns '?' if there is not matching code point in the current keymap */
70 if (c == '?' && wc != '?')
71 {
72 /* If direct conversion fails try compatibility decomposition (but without recursion) */
73 CONST_WSTRPTR p = UCS4_Decompose(wc);
74
75 if (p)
76 {
77 while (p[1])
78 {
79 strlength++;
80 p++;
81 }
82 }
83 }
84 }
85 while (octets > 0);
86
87 dst = MyAllocPooled(data->mypool, strlength);
88
89 if (dst)
90 {
91 STRPTR bufptr = dst;
92
93 ptr = src;
94
95 do
96 {
97 WCHAR wc;
98 UBYTE c;
99
100 ptr += (octets = UTF8_Decode(ptr, &wc));
101 c = ToANSI(wc, keymap);
102
103 *bufptr++ = c;
104
105 if (c == '?' && wc != '?')
106 {
107 CONST_WSTRPTR p = UCS4_Decompose(wc);
108
109 if (p)
110 {
111 bufptr--;
112
113 while (*p)
114 {
115 *bufptr++ = ToANSI(*p, keymap);
116 p++;
117 }
118 }
119 }
120 }
121 while (octets > 0);
122
123 MyFreePooled(data->mypool, src); // Free original buffer
124 }
125
126 if(dst == NULL)
127 dst = src;
128
129 RETURN(dst);
130 return dst;
131 }
132 #endif
133
134 /*----------------------*
135 * Paste from Clipboard *
136 *----------------------*/
137 BOOL PasteClip (LONG x, struct line_node *actline, struct InstData *data)
138 {
139 struct line_node *line = NULL;
140 struct line_node *startline = NULL;
141 struct line_node *previous = NULL;
142 UWORD *styles = NULL;
143 UWORD *colors = NULL;
144 STRPTR textline;
145 BOOL newline = TRUE;
146 BOOL res = FALSE;
147
148 ENTER();
149
150 if(InitClipboard(data, IFFF_READ))
151 {
152 if(StopChunk(data->iff, ID_FTXT, ID_CHRS) == 0 &&
153 StopChunk(data->iff, ID_FTXT, ID_FLOW) == 0 &&
154 StopChunk(data->iff, ID_FTXT, ID_HIGH) == 0 &&
155 StopChunk(data->iff, ID_FTXT, ID_SBAR) == 0 &&
156 StopChunk(data->iff, ID_FTXT, ID_COLS) == 0 &&
157 StopChunk(data->iff, ID_FTXT, ID_STYL) == 0 &&
158 StopChunk(data->iff, ID_FTXT, ID_CSET) == 0)
159 {
160 LONG error, codeset = 0;
161 UWORD flow = MUIV_TextEditor_Flow_Left;
162 UWORD color = FALSE;
163 UWORD separator = 0;
164 BOOL ownclip = FALSE;
165 LONG updatefrom;
166
167 while(TRUE)
168 {
169 struct ContextNode *cn;
170
171 error = ParseIFF(data->iff, IFFPARSE_SCAN);
172 SHOWVALUE(DBF_CLIPBOARD, error);
173 if(error == IFFERR_EOC)
174 continue;
175 else if(error)
176 break;
177
178 if((cn = CurrentChunk(data->iff)) != NULL)
179 {
180 switch (cn->cn_ID)
181 {
182 case ID_CSET:
183 D(DBF_CLIPBOARD, "reading FLOW");
184 SHOWVALUE(DBF_CLIPBOARD, cn->cn_Size);
185 if(cn->cn_Size >= 4)
186 {
187 /* Only the first four bytes are interesting */
188 if(ReadChunkBytes(data->iff, &codeset, 4) != 4)
189 {
190 codeset = 0;
191 }
192 SHOWVALUE(DBF_CLIPBOARD, codeset);
193 }
194 break;
195
196 case ID_FLOW:
197 D(DBF_CLIPBOARD, "reading FLOW");
198 SHOWVALUE(DBF_CLIPBOARD, cn->cn_Size);
199 if(cn->cn_Size == 2)
200 {
201 if(ReadChunkBytes(data->iff, &flow, 2) == 2)
202 if(flow > MUIV_TextEditor_Flow_Right)
203 flow = MUIV_TextEditor_Flow_Left;
204 SHOWVALUE(DBF_CLIPBOARD, flow);
205 }
206 break;
207
208 case ID_HIGH:
209 D(DBF_CLIPBOARD, "reading HIGH");
210 SHOWVALUE(DBF_CLIPBOARD, cn->cn_Size);
211 if (cn->cn_Size == 2)
212 {
213 error = ReadChunkBytes(data->iff, &color, 2);
214 SHOWVALUE(DBF_CLIPBOARD, color);
215 SHOWVALUE(DBF_CLIPBOARD, error);
216 }
217 break;
218
219 case ID_SBAR:
220 D(DBF_CLIPBOARD, "reading SBAR");
221 SHOWVALUE(DBF_CLIPBOARD, cn->cn_Size);
222 if (cn->cn_Size == 2)
223 {
224 error = ReadChunkBytes(data->iff, &separator, 2);
225 SHOWVALUE(DBF_CLIPBOARD, separator);
226 SHOWVALUE(DBF_CLIPBOARD, error);
227 }
228 break;
229
230 case ID_COLS:
231 D(DBF_CLIPBOARD, "reading COLS");
232 SHOWVALUE(DBF_CLIPBOARD, cn->cn_Size);
233 if(colors)
234 {
235 MyFreePooled(data->mypool, colors);
236 colors = NULL;
237 }
238 // allocate one word more than the chunk tell us, because we terminate the array with an additional value
239 if(cn->cn_Size > 0 && (colors = (UWORD *)MyAllocPooled(data->mypool, cn->cn_Size + sizeof(UWORD))) != NULL)
240 {
241 error = ReadChunkBytes(data->iff, colors, cn->cn_Size);
242 SHOWVALUE(DBF_CLIPBOARD, error);
243 colors[cn->cn_Size / 2] = 0xffff;
244 }
245 break;
246
247 case ID_STYL:
248 D(DBF_CLIPBOARD, "reading STYL");
249 SHOWVALUE(DBF_CLIPBOARD, cn->cn_Size);
250 ownclip = TRUE;
251 if(styles)
252 {
253 MyFreePooled(data->mypool, styles);
254 styles = NULL;
255 }
256 // allocate one word more than the chunk tell us, because we terminate the array with an additional value
257 if(cn->cn_Size > 0 && (styles = (UWORD *)MyAllocPooled(data->mypool, cn->cn_Size + sizeof(UWORD))) != NULL)
258 {
259 error = ReadChunkBytes(data->iff, styles, cn->cn_Size);
260 SHOWVALUE(DBF_CLIPBOARD, error);
261 styles[cn->cn_Size / 2] = EOS;
262 }
263 break;
264
265 case ID_CHRS:
266 {
267 D(DBF_CLIPBOARD, "reading CHRS");
268 SHOWVALUE(DBF_CLIPBOARD, cn->cn_Size);
269
270 data->HasChanged = TRUE;
271
272 if(cn->cn_Size > 0 && !ownclip)
273 {
274 char *contents;
275 ULONG length = cn->cn_Size;
276
277 if((contents = (char *)MyAllocPooled(data->mypool, length + 1)) != NULL)
278 {
279 error = ReadChunkBytes(data->iff, contents, length);
280 SHOWVALUE(DBF_CLIPBOARD, error);
281
282 if(contents[length - 1] != '\n')
283 {
284 newline = FALSE;
285 }
286 else
287 {
288 length--;
289 }
290 contents[length] = '\0';
291
292 #if defined(__MORPHOS__)
293 if (codeset == CODESET_UTF8)
294 {
295 if (IS_MORPHOS2)
296 contents = utf8_to_ansi(data, contents);
297 }
298 #endif
299
300 if((line = ImportText(contents, data, &ImPlainHook, data->ImportWrap)))
301 {
302 if(!startline)
303 startline = line;
304 if(previous)
305 previous->next = line;
306
307 line->previous = previous;
308 line->visual = VisualHeight(line, data);
309 data->totallines += line->visual;
310 while(line->next)
311 {
312 line = line->next;
313 line->visual = VisualHeight(line, data);
314 data->totallines += line->visual;
315 }
316 previous = line;
317 }
318 MyFreePooled(data->mypool, contents);
319 }
320 }
321 else
322 {
323 ULONG length = cn->cn_Size;
324
325 if(length > 0 && (textline = (char *)MyAllocPooled(data->mypool, length + 2)) != NULL)
326 {
327 error = ReadChunkBytes(data->iff, textline, length);
328 SHOWVALUE(DBF_CLIPBOARD, error);
329
330 if (textline[length - 1] != '\n')
331 {
332 newline = FALSE;
333 textline[length] = '\n';
334 length++;
335 }
336 textline[length] = '\0';
337
338 if((line = AllocLine(data)))
339 {
340 line->next = NULL;
341 line->previous = previous;
342 line->line.Contents = textline;
343 line->line.Length = length;
344 line->visual = VisualHeight(line, data);
345 line->line.Color = color;
346 line->line.Flow = flow;
347 line->line.Separator = separator;
348 line->line.Styles = styles;
349 line->line.Colors = colors;
350 data->totallines += line->visual;
351
352 if(!startline)
353 startline = line;
354 if(previous)
355 previous->next = line;
356
357 previous = line;
358 }
359 else
360 {
361 if(styles)
362 MyFreePooled(data->mypool, (void *)styles);
363 if(colors)
364 MyFreePooled(data->mypool, (void *)colors);
365 }
366 }
367 else
368 {
369 if(styles)
370 MyFreePooled(data->mypool, styles);
371 if(colors)
372 MyFreePooled(data->mypool, (void *)colors);
373 }
374 styles = NULL;
375 colors = NULL;
376 flow = MUIV_TextEditor_Flow_Left;
377 color = FALSE;
378 separator = 0;
379 ownclip = FALSE;
380 }
381 }
382 break;
383 }
384 }
385 }
386
387 if(line)
388 {
389 BOOL oneline = FALSE;
390
391 SplitLine(x, actline, FALSE, NULL, data);
392 line->next = actline->next;
393 actline->next->previous = line;
394 actline->next = startline;
395 startline->previous = actline;
396 data->CPos_X = line->line.Length-1;
397 if(actline->next == line)
398 {
399 data->CPos_X += actline->line.Length-1;
400 oneline = TRUE;
401 }
402 if(!newline)
403 MergeLines(line, data);
404 MergeLines(actline, data);
405 if(oneline)
406 line = actline;
407 if(newline)
408 {
409 line = line->next;
410 data->CPos_X = 0;
411 }
412 data->actualline = line;
413 }
414 else
415 {
416 switch(error)
417 {
418 case IFFERR_MANGLED:
419 case IFFERR_SYNTAX:
420 case IFFERR_NOTIFF:
421 D(DBF_CLIPBOARD, "no FTXT clip!");
422 DoMethod(data->object, MUIM_TextEditor_HandleError, Error_ClipboardIsNotFTXT);
423 break;
424 default:
425 D(DBF_CLIPBOARD, "clipboard is empty!");
426 DoMethod(data->object, MUIM_TextEditor_HandleError, Error_ClipboardIsEmpty);
427 break;
428 }
429 }
430 data->update = TRUE;
431
432 ScrollIntoDisplay(data);
433 updatefrom = LineToVisual(actline, data)-1;
434 if(updatefrom < 0)
435 updatefrom = 0;
436 DumpText(data->visual_y+updatefrom, updatefrom, data->maxlines, TRUE, data);
437
438 if(data->update)
439 res = TRUE;
440 else
441 data->update = TRUE;
442 }
443
444 EndClipSession(data);
445 }
446
447 RETURN(res);
448 return res;
449 }
450 /*--------------------------*
451 * Merge two lines into one *
452 *--------------------------*/
453 BOOL MergeLines(struct line_node *line, struct InstData *data)
454 {
455 struct line_node *next;
456 char *newbuffer;
457 LONG visual, oldvisual, line_nr;
458 LONG emptyline = FALSE;
459 LONG color = line->line.Color;
460 UWORD flow = line->line.Flow;
461 UWORD separator = line->line.Separator;
462
463 ENTER();
464
465 data->HasChanged = TRUE;
466 if(line->line.Length == 1)
467 {
468 emptyline = TRUE;
469 color = line->next->line.Color;
470 flow = line->next->line.Flow;
471 separator = line->next->line.Separator;
472 }
473 visual = line->visual + line->next->visual;
474
475 if((newbuffer = MyAllocPooled(data->mypool, line->line.Length+line->next->line.Length+1)) != NULL)
476 {
477 memcpy(newbuffer, line->line.Contents, line->line.Length-1);
478 memcpy(newbuffer+line->line.Length-1, line->next->line.Contents, line->next->line.Length+1);
479 MyFreePooled(data->mypool, line->line.Contents);
480 MyFreePooled(data->mypool, line->next->line.Contents);
481
482 if(emptyline == TRUE)
483 {
484 if(line->line.Styles != NULL)
485 MyFreePooled(data->mypool, line->line.Styles);
486
487 line->line.Styles = line->next->line.Styles;
488
489 if(line->line.Colors != NULL)
490 MyFreePooled(data->mypool, line->line.Colors);
491
492 line->line.Colors = line->next->line.Colors;
493 }
494 else
495 {
496 UWORD *styles;
497 UWORD *styles1 = line->line.Styles;
498 UWORD *styles2 = line->next->line.Styles;
499 UWORD *colors;
500 UWORD *colors1 = line->line.Colors;
501 UWORD *colors2 = line->next->line.Colors;
502 UWORD length = 12;
503
504 if(styles1 != NULL)
505 length += *((long *)styles1-1) - 4;
506 if(styles2 != NULL)
507 length += *((long *)styles2-1) - 4;
508
509 if((styles = MyAllocPooled(data->mypool, length)) != NULL)
510 {
511 unsigned short* t_styles = styles;
512 unsigned short style = 0;
513
514 SHOWVALUE(DBF_CLIPBOARD, length);
515 SHOWVALUE(DBF_CLIPBOARD, styles);
516 SHOWVALUE(DBF_CLIPBOARD, styles1);
517 SHOWVALUE(DBF_CLIPBOARD, styles2);
518
519 if(styles2 != NULL)
520 {
521 unsigned short* t_styles2 = styles2;
522
523 while(*t_styles2++ == 1)
524 {
525 if(*t_styles2 > 0xff)
526 style &= *t_styles2++;
527 else
528 style |= *t_styles2++;
529 }
530 }
531
532 if(styles1 != NULL)
533 {
534 while(*styles1 != EOS)
535 {
536 if((*styles1 == line->line.Length) && ((~*(styles1+1) & style) == (*(styles1+1) ^ 0xffff)))
537 {
538 style &= *(styles1+1);
539 styles1 += 2;
540 }
541 else
542 {
543 *styles++ = *styles1++;
544 *styles++ = *styles1++;
545 }
546 }
547 SHOWVALUE(DBF_CLIPBOARD, line->line.Styles);
548 MyFreePooled(data->mypool, line->line.Styles);
549 }
550
551 if(styles2 != NULL)
552 {
553 while(*styles2 != EOS)
554 {
555 if((*styles2 == 1) && (!(*(styles2+1) & style)))
556 {
557 styles2 += 2;
558 }
559 else
560 {
561 *styles++ = *styles2++ + line->line.Length - 1;
562 *styles++ = *styles2++;
563 }
564 }
565 SHOWVALUE(DBF_CLIPBOARD, line->next->line.Styles);
566 MyFreePooled(data->mypool, line->next->line.Styles);
567 }
568 *styles = EOS;
569 line->line.Styles = t_styles;
570 }
571
572 length = 12;
573
574 if(colors1 != NULL)
575 length += *((long *)colors1-1) - 4;
576 if(colors2 != NULL)
577 length += *((long *)colors2-1) - 4;
578
579 if((colors = MyAllocPooled(data->mypool, length)) != NULL)
580 {
581 UWORD *t_colors = colors;
582 UWORD end_color = 0;
583
584 SHOWVALUE(DBF_CLIPBOARD, length);
585 SHOWVALUE(DBF_CLIPBOARD, colors);
586 SHOWVALUE(DBF_CLIPBOARD, colors1);
587 SHOWVALUE(DBF_CLIPBOARD, colors2);
588
589 if(colors1 != NULL)
590 {
591 while(*colors1 < line->line.Length && *colors1 != 0xffff)
592 {
593 *colors++ = *colors1++;
594 end_color = *colors1;
595 *colors++ = *colors1++;
596 }
597 SHOWVALUE(DBF_CLIPBOARD, line->line.Colors);
598 MyFreePooled(data->mypool, line->line.Colors);
599 }
600
601 if(end_color && (colors2 == NULL || *colors2 != 1))
602 {
603 *colors++ = line->line.Length;
604 *colors++ = 0;
605 }
606
607 if(colors2 != NULL)
608 {
609 if(*colors2 == 1 && *(colors2+1) == end_color)
610 colors2 += 2;
611
612 while(*colors2 != 0xffff)
613 {
614 *colors++ = *colors2++ + line->line.Length - 1;
615 *colors++ = *colors2++;
616 }
617 SHOWVALUE(DBF_CLIPBOARD, line->next->line.Colors);
618 MyFreePooled(data->mypool, line->next->line.Colors);
619 }
620 *colors = 0xffff;
621 line->line.Colors = t_colors;
622 }
623 }
624
625 line->line.Contents = newbuffer;
626 line->line.Length = strlen(newbuffer);
627
628 next = line->next;
629 line->next = line->next->next;
630 if(line->next != NULL)
631 line->next->previous = line;
632 oldvisual = line->visual;
633 line->visual = VisualHeight(line, data);
634 line->line.Color = color;
635 line->line.Flow = flow;
636 line->line.Separator = separator;
637
638 FreeLine(next, data);
639
640 line_nr = LineToVisual(line, data);
641
642 // handle that we have to scroll up/down due to word wrapping
643 // that occurrs when merging lines
644 if(visual > line->visual)
645 {
646 data->totallines -= 1;
647 if(line_nr+line->visual-1 < data->maxlines)
648 {
649 if(emptyline && line_nr > 0)
650 {
651 if(data->fastbackground)
652 {
653 ScrollUp(line_nr - 1, 1, data);
654 SetCursor(data->CPos_X, data->actualline, TRUE, data);
655 }
656 else
657 DumpText(data->visual_y+line_nr-1, line_nr-1, data->maxlines, TRUE, data);
658 }
659 else
660 {
661 if(data->fastbackground)
662 ScrollUp(line_nr + line->visual - 1, 1, data);
663 else
664 DumpText(data->visual_y+line_nr+line->visual-1, line_nr+line->visual-1, data->maxlines, TRUE, data);
665 }
666 }
667 }
668 else if(visual < line->visual)
669 {
670 data->totallines += 1;
671 if(line_nr+line->visual-1 < data->maxlines)
672 ScrollDown(line_nr + line->visual - 2, 1, data);
673 }
674
675 if(!(emptyline && (line_nr + line->visual - 1 < data->maxlines)))
676 {
677 LONG t_oldvisual = oldvisual;
678 LONG t_line_nr = line_nr;
679 ULONG c = 0;
680
681 while((--t_oldvisual) && (t_line_nr++ <= data->maxlines))
682 c = c + LineCharsWidth(line->line.Contents+c, data);
683
684 while((c < line->line.Length) && (t_line_nr <= data->maxlines))
685 c = c + PrintLine(c, line, t_line_nr++, TRUE, data);
686 }
687
688 if(line_nr + oldvisual == 1 && line->visual == visual-1)
689 {
690 data->visual_y--;
691 data->totallines -= 1;
692
693 if(data->fastbackground)
694 DumpText(data->visual_y, 0, visual-1, TRUE, data);
695 else
696 DumpText(data->visual_y, 0, data->maxlines, TRUE, data);
697 }
698
699 RETURN(TRUE);
700 return(TRUE);
701 }
702 else
703 {
704 RETURN(FALSE);
705 return(FALSE);
706 }
707 }
708 /*---------------------*
709 * Split line into two *
710 *---------------------*/
711 BOOL SplitLine(LONG x, struct line_node *line, BOOL move_crsr, struct UserAction *buffer, struct InstData *data)
712 {
713 struct line_node *newline;
714 struct line_node *next;
715 struct pos_info pos;
716 LONG line_nr, lines;
717 ULONG c;
718 UWORD crsr_x = data->CPos_X;
719 struct line_node *crsr_l = data->actualline;
720
721 ENTER();
722
723 OffsetToLines(x, line, &pos, data);
724 lines = pos.lines;
725
726 next = line->next;
727 if((newline = AllocLine(data)) != NULL)
728 {
729 UWORD *styles = line->line.Styles;
730 UWORD *newstyles = NULL;
731 UWORD *colors = line->line.Colors;
732 UWORD *newcolors = NULL;
733
734 data->HasChanged = TRUE;
735 Init_LineNode(newline, line, line->line.Contents+x, data);
736 newline->line.Color = line->line.Color;
737 newline->line.Flow = line->line.Flow;
738 newline->line.Separator = line->line.Separator;
739 if(buffer != NULL)
740 {
741 newline->line.Color = buffer->del.style;
742 newline->line.Flow = buffer->del.flow;
743 newline->line.Separator = buffer->del.separator;
744 }
745
746 if(styles != NULL)
747 {
748 LONG style = 0;
749 LONG length = 0;
750 UWORD *ostyles;
751
752 while(*styles++ <= x+1)
753 {
754 if(*styles > 0xff)
755 style &= *styles++;
756 else
757 style |= *styles++;
758 }
759 styles--;
760 ostyles = styles;
761 while(*(styles+length) != EOS)
762 length += 2;
763 length = (length*2) + 16;
764
765 if((newstyles = MyAllocPooled(data->mypool, length)) != NULL)
766 {
767 UWORD *nstyles = newstyles;
768
769 if(isFlagSet(style, BOLD))
770 {
771 *nstyles++ = 1;
772 *nstyles++ = BOLD;
773 }
774 if(isFlagSet(style, ITALIC))
775 {
776 *nstyles++ = 1;
777 *nstyles++ = ITALIC;
778 }
779 if(isFlagSet(style, UNDERLINE))
780 {
781 *nstyles++ = 1;
782 *nstyles++ = UNDERLINE;
783 }
784
785 while(*styles != EOS)
786 {
787 *nstyles++ = (*styles++) - x;
788 *nstyles++ = *styles++;
789 }
790 *nstyles = EOS;
791 }
792
793 if(isFlagSet(style, BOLD))
794 {
795 *ostyles++ = x+1;
796 *ostyles++ = ~BOLD;
797 }
798 if(isFlagSet(style, ITALIC))
799 {
800 *ostyles++ = x+1;
801 *ostyles++ = ~ITALIC;
802 }
803 if(isFlagSet(style, UNDERLINE))
804 {
805 *ostyles++ = x+1;
806 *ostyles++ = ~UNDERLINE;
807 }
808 if(x != 0)
809 ostyles = line->line.Styles;
810 *ostyles = EOS;
811 }
812 newline->line.Styles = newstyles;
813
814 if(colors != NULL)
815 {
816 UWORD color = GetColor(x, line);
817 UWORD length = 0;
818 UWORD *ocolors;
819
820 while(*colors <= x+1)
821 {
822 colors += 2;
823 }
824 ocolors = colors;
825
826 while(*(colors+length) != 0xffff)
827 length += 2;
828 length = (length*2) + 16;
829
830 if((newcolors = MyAllocPooled(data->mypool, length)) != NULL)
831 {
832 UWORD *ncolors = newcolors;
833
834 if(color && *colors-x != 1)
835 {
836 *ncolors++ = 1;
837 *ncolors++ = color;
838 }
839
840 while(*colors != 0xffff)
841 {
842 *ncolors++ = (*colors++) - x;
843 *ncolors++ = *colors++;
844 }
845 *ncolors = 0xffff;
846 }
847 if(x != 0)
848 ocolors = line->line.Colors;
849 *ocolors = 0xffff;
850 }
851 newline->line.Colors = newcolors;
852
853
854 newline->next = next;
855 if(next != NULL)
856 next->previous = newline;
857
858 *(line->line.Contents+x) = '\n';
859 *(line->line.Contents+x+1) = '\0';
860 line->line.Length = x+1;
861
862 /*------------------*/
863 c = line->visual;
864 line->visual = VisualHeight(line, data);
865 CompressLine(line, data);
866
867 line_nr = LineToVisual(line, data) + line->visual - 1;
868 if(line_nr < 0)
869 line_nr = 0;
870
871 if(move_crsr)
872 {
873 data->CPos_X = 0;
874 data->actualline = data->actualline->next;
875 }
876
877 if(x == 0)
878 {
879 line->line.Color = 0;
880 line->line.Separator = 0;
881 if(!(line->previous && line->previous->line.Flow == line->line.Flow))
882 {
883 line->line.Flow = MUIV_TextEditor_Flow_Left;
884 }
885 if(line_nr != data->maxlines)
886 {
887 data->totallines += 1;
888 if(data->fastbackground)
889 {
890 if(line_nr)
891 {
892 ScrollDown(line_nr-1, 1, data);
893 PrintLine(0, line, line_nr, FALSE, data);
894 }
895 else
896 {
897 ScrollDown(line_nr, 1, data);
898 }
899 }
900 else DumpText(data->visual_y+line_nr-1, line_nr-1, data->maxlines, TRUE, data);
901 }
902 else
903 {
904 data->visual_y++;
905 data->totallines += 1;
906 if(isFlagClear(data->flags, FLG_Quiet))
907 {
908 struct Hook *oldhook;
909
910 oldhook = InstallLayerHook(data->rport->Layer, LAYERS_NOBACKFILL);
911 ScrollRasterBF(data->rport, 0, data->height,
912 data->xpos, data->ypos,
913 data->xpos + data->innerwidth - 1, (data->ypos + ((data->maxlines-1) * data->height)) - 1);
914 InstallLayerHook(data->rport->Layer, oldhook);
915
916 PrintLine(0, line, data->maxlines-1, FALSE, data);
917 if(!data->fastbackground)
918 {
919 DumpText(data->visual_y+data->maxlines-1, data->maxlines-1, data->maxlines, TRUE, data);
920 }
921 }
922 }
923
924 RETURN(TRUE);
925 return(TRUE);
926 }
927
928 if(x == (LONG)(line->line.Length + newline->line.Length - 2))
929 {
930 data->totallines += 1;
931 if(buffer == NULL)
932 {
933 line->next->line.Color = 0;
934 line->next->line.Separator = 0;
935 }
936 SetCursor(crsr_x, crsr_l, FALSE, data);
937 if(line_nr < data->maxlines)
938 {
939 if(data->fastbackground)
940 {
941 ScrollDown(line_nr, 1, data);
942 if(line_nr+1 <= data->maxlines)
943 PrintLine(0, line->next, line_nr+1, FALSE, data);
944 }
945 else DumpText(data->visual_y+line_nr, line_nr, data->maxlines, TRUE, data);
946 }
947
948 RETURN(TRUE);
949 return(TRUE);
950 }
951 x = line->line.Length;
952
953 OffsetToLines(x-1, line, &pos, data);
954 if(((ULONG)(line->visual + line->next->visual) >= c) && (line->visual == lines))
955 {
956 if((ULONG)(line->visual + line->next->visual) > c)
957 data->totallines += 1;
958
959 PrintLine(pos.bytes, line, line_nr, TRUE, data);
960
961 if((line_nr+line->next->visual-1 < data->maxlines) && ((ULONG)(line->visual + line->next->visual) > c))
962 {
963 ScrollDown(line_nr+line->next->visual-1, 1, data);
964 }
965 }
966 else
967 {
968 PrintLine((x-1)-pos.x, line, line_nr, TRUE, data);
969
970 if((line_nr < data->maxlines) && ((ULONG)(line->visual + line->next->visual) < c))
971 {
972 data->totallines -= 1;
973 ScrollUp(line_nr, 1, data);
974 }
975 }
976 /*------------------*/
977 line = line->next;
978 line_nr++;
979 c = 0;
980 while((c < line->line.Length) && (line_nr <= data->maxlines))
981 c = c + PrintLine(c, line, line_nr++, TRUE, data);
982 /* Her printes !HELE! den nye linie, burde optimeres! */
983
984 RETURN(TRUE);
985 return (TRUE);
986 }
987 else
988 {
989 RETURN(FALSE);
990 return (FALSE);
991 }
992 }
993 /*------------------------------------------------------------------*
994 * Backwards string copy, please replace with some assembler stuff! *
995 *------------------------------------------------------------------*/
996 static void strcpyback(char *dest, char *src)
997 {
998 size_t length;
999
1000 ENTER();
1001
1002 length = strlen(src)+1;
1003 dest = dest + length;
1004 src = src + length;
1005
1006 length++;
1007 while(--length)
1008 *--dest = *--src;
1009
1010 LEAVE();
1011 }
1012
1013 /* ------------------------------------ *
1014 * Functions which updates the display *
1015 * ------------------------------------ */
1016 void OptimizedPrint(LONG x, struct line_node *line, LONG line_nr, LONG width, struct InstData *data)
1017 {
1018 ENTER();
1019
1020 do
1021 {
1022 LONG twidth;
1023
1024 twidth = PrintLine(x, line, line_nr, TRUE, data);
1025 line_nr++;
1026
1027 if(twidth != width && x+twidth < (LONG)line->line.Length && line_nr <= data->maxlines)
1028 {
1029 x += twidth;
1030 width = LineCharsWidth(line->line.Contents+x+width, data) + width - twidth;
1031 }
1032 else
1033 break;
1034 }
1035 while(TRUE);
1036
1037 LEAVE();
1038 }
1039
1040 static void UpdateChange(LONG x, struct line_node *line, LONG length, const char *characters, struct UserAction *buffer, struct InstData *data)
1041 {
1042 LONG diff;
1043 LONG skip=0;
1044 LONG line_nr;
1045 LONG orgline_nr;
1046 LONG width=0;
1047 LONG lineabove_width=0;
1048
1049 ENTER();
1050
1051 line_nr = LineToVisual(line, data);
1052 orgline_nr = line_nr;
1053
1054 do
1055 {
1056 // don't exceed the line length!
1057 if(skip > (LONG)line->line.Length)
1058 break;
1059
1060 width = LineCharsWidth(line->line.Contents + skip, data);
1061 if(width > 0 && skip + width < x)
1062 {
1063 lineabove_width = width;
1064 skip += width;
1065 line_nr++;
1066 }
1067 else
1068 break;
1069 }
1070 while(TRUE);
1071
1072 if(characters != NULL)
1073 {
1074 strcpyback(line->line.Contents+x+length, line->line.Contents+x);
1075 memcpy(line->line.Contents+x, characters, length);
1076 width += length;
1077 line->line.Length += length;
1078 if(buffer != NULL)
1079 {
1080 UWORD style = buffer->del.style;
1081
1082 AddStyleToLine(x, line, 1, (style & BOLD) ? BOLD : ~BOLD, data);
1083 AddStyleToLine(x, line, 1, (style & ITALIC) ? ITALIC : ~ITALIC, data);
1084 AddStyleToLine(x, line, 1, (style & UNDERLINE) ? UNDERLINE : ~UNDERLINE, data);
1085 line->line.Flow = buffer->del.flow;
1086 line->line.Separator = buffer->del.separator;
1087 }
1088 }
1089 else
1090 {
1091 strlcpy(line->line.Contents+x, line->line.Contents+x+length, line->line.Length);
1092 width -= length;
1093 line->line.Length -= length;
1094 }
1095
1096 diff = VisualHeight(line, data) - line->visual;
1097 if(diff != 0)
1098 {
1099 LONG movement;
1100
1101 movement = orgline_nr + line->visual - 1;
1102
1103 line->visual += diff;
1104 data->totallines += diff;
1105
1106 if(diff > 0)
1107 {
1108 if(movement < data->maxlines)
1109 ScrollDown(movement, diff, data);
1110 }
1111 else
1112 {
1113 movement = orgline_nr + line->visual - 1;
1114 if(movement <= data->maxlines)
1115 ScrollUp(movement, -diff, data);
1116 }
1117 }
1118
1119 if(orgline_nr != line_nr)
1120 {
1121 if(lineabove_width != LineCharsWidth(line->line.Contents+skip-lineabove_width, data))
1122 {
1123 LONG newwidth;
1124
1125 newwidth = PrintLine(skip-lineabove_width, line, line_nr-1, TRUE, data) - lineabove_width;
1126 skip += newwidth;
1127 width -= newwidth;
1128 if(skip >= (LONG)line->line.Length)
1129 {
1130 LEAVE();
1131 return;
1132 }
1133 }
1134 }
1135
1136 OptimizedPrint(skip, line, line_nr, width, data);
1137 ScrollIntoDisplay(data);
1138 data->HasChanged = TRUE;
1139
1140 LEAVE();
1141 }
1142
1143 /*------------------------------*
1144 * Paste n characters to a line *
1145 *------------------------------*/
1146 BOOL PasteChars(LONG x, struct line_node *line, LONG length, const char *characters, struct UserAction *buffer, struct InstData *data)
1147 {
1148 ENTER();
1149
1150 if(line->line.Styles != NULL)
1151 {
1152 if(*line->line.Styles != EOS)
1153 {
1154 ULONG c = 0;
1155
1156 while(*(line->line.Styles+c) <= x+1)
1157 c += 2;
1158 while(*(line->line.Styles+c) != EOS)
1159 {
1160 *(line->line.Styles+c) += length;
1161 c += 2;
1162 }
1163 }
1164 }
1165
1166 if(line->line.Colors != NULL)
1167 {
1168 if(*line->line.Colors != 0xffff)
1169 {
1170 ULONG c = 0;
1171
1172 while(*(line->line.Colors+c) <= x+1)
1173 c += 2;
1174 while(*(line->line.Colors+c) != 0xffff)
1175 {
1176 *(line->line.Colors+c) += length;
1177 c += 2;
1178 }
1179 }
1180 }
1181
1182 if((*((long *)line->line.Contents-1))-4 < (LONG)(line->line.Length + length + 1))
1183 {
1184 if(ExpandLine(line, length, data) == FALSE)
1185 {
1186 RETURN(FALSE);
1187 return(FALSE);
1188 }
1189 }
1190
1191 UpdateChange(x, line, length, characters, buffer, data);
1192
1193 RETURN(TRUE);
1194 return(TRUE);
1195 }
1196 /*----------------------------*
1197 * Remove n chars from a line *
1198 *----------------------------*/
1199 BOOL RemoveChars(LONG x, struct line_node *line, LONG length, struct InstData *data)
1200 {
1201 ENTER();
1202
1203 if(line->line.Styles != NULL)
1204 {
1205 if(*line->line.Styles != EOS)
1206 {
1207 UWORD start_style = GetStyle(x-1, line);
1208 UWORD end_style = GetStyle(x+length, line);
1209 ULONG c = 0, store;
1210
1211 while(*(line->line.Styles+c) <= x)
1212 c += 2;
1213
1214 if(start_style != end_style)
1215 {
1216 UWORD turn_off = start_style & ~end_style;
1217 UWORD turn_on = end_style & ~start_style;
1218
1219 if(isFlagSet(turn_off, BOLD))
1220 {
1221 *(line->line.Styles+c++) = x+1;
1222 *(line->line.Styles+c++) = ~BOLD;
1223 }
1224 if(isFlagSet(turn_off, ITALIC))
1225 {
1226 *(line->line.Styles+c++) = x+1;
1227 *(line->line.Styles+c++) = ~ITALIC;
1228 }
1229 if(isFlagSet(turn_off, UNDERLINE))
1230 {
1231 *(line->line.Styles+c++) = x+1;
1232 *(line->line.Styles+c++) = ~UNDERLINE;
1233 }
1234 if(isFlagSet(turn_on, BOLD))
1235 {
1236 *(line->line.Styles+c++) = x+1;
1237 *(line->line.Styles+c++) = BOLD;
1238 }
1239 if(isFlagSet(turn_on, ITALIC))
1240 {
1241 *(line->line.Styles+c++) = x+1;
1242 *(line->line.Styles+c++) = ITALIC;
1243 }
1244 if(isFlagSet(turn_on, UNDERLINE))
1245 {
1246 *(line->line.Styles+c++) = x+1;
1247 *(line->line.Styles+c++) = UNDERLINE;
1248 }
1249 }
1250
1251 store = c;
1252 while(*(line->line.Styles+c) <= x+length+1)
1253 c += 2;
1254
1255 while(*(line->line.Styles+c) != EOS)
1256 {
1257 *(line->line.Styles+store++) = *(line->line.Styles+c++)-length;
1258 *(line->line.Styles+store++) = *(line->line.Styles+c++);
1259 }
1260 *(line->line.Styles+store) = EOS;
1261 }
1262 }
1263
1264 if(line->line.Colors != NULL)
1265 {
1266 if(*line->line.Colors != 0xffff)
1267 {
1268 UWORD start_color = x ? GetColor(x-1, line) : 0;
1269 UWORD end_color = GetColor(x+length, line);
1270 ULONG c = 0, store;
1271
1272 while(*(line->line.Colors+c) <= x)
1273 c += 2;
1274
1275 if(start_color != end_color)
1276 {
1277 *(line->line.Colors+c++) = x+1;
1278 *(line->line.Colors+c++) = end_color;
1279 }
1280
1281 store = c;
1282 while(*(line->line.Colors+c) <= x+length+1)
1283 c += 2;
1284
1285 while(*(line->line.Colors+c) != 0xffff)
1286 {
1287 *(line->line.Colors+store++) = *(line->line.Colors+c++)-length;
1288 *(line->line.Colors+store++) = *(line->line.Colors+c++);
1289 }
1290 *(line->line.Colors+store) = 0xffff;
1291 }
1292 }
1293
1294 UpdateChange(x, line, length, NULL, NULL, data);
1295
1296 RETURN(TRUE);
1297 return(TRUE);
1298 }
1299
The AROS cake. Goodness baked in, have it and eat it too. Delicious!