Logo ROOT   6.30.04
Reference Guide
 All Namespaces Files Pages
TGTextView.cxx
Go to the documentation of this file.
1 // @(#)root/gui:$Id: 1f399bfa44c1323de4c6fe38d6d7a83a4bdf2e32 $
2 // Author: Fons Rademakers 1/7/2000
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 /**************************************************************************
12 
13  This source is based on Xclass95, a Win95-looking GUI toolkit.
14  Copyright (C) 1996, 1997 David Barth, Ricky Ralston, Hector Peraza.
15 
16  Xclass95 is free software; you can redistribute it and/or
17  modify it under the terms of the GNU Library General Public
18  License as published by the Free Software Foundation; either
19  version 2 of the License, or (at your option) any later version.
20 
21 **************************************************************************/
22 
23 //////////////////////////////////////////////////////////////////////////
24 // //
25 // TGTextView //
26 // //
27 // A TGTextView is a text viewer widget. It is a specialization of //
28 // TGView. It uses the TGText class (which contains all text //
29 // manipulation code, i.e. loading a file in memory, changing, //
30 // removing lines, etc.). Use a TGTextView to view non-editable text. //
31 // For supported messages see TGView. //
32 // //
33 //////////////////////////////////////////////////////////////////////////
34 
35 #include "TGTextView.h"
36 #include "TGScrollBar.h"
37 #include "TGResourcePool.h"
38 #include "TSystem.h"
39 #include "TGDNDManager.h"
40 #include "TBufferFile.h"
41 #include "TSystemFile.h"
42 #include "TObjString.h"
43 #include "TMacro.h"
44 #include "TGMsgBox.h"
45 #include "TUrl.h"
46 #include "Riostream.h"
47 
48 
49 const TGFont *TGTextView::fgDefaultFont = 0;
50 TGGC *TGTextView::fgDefaultGC = 0;
51 TGGC *TGTextView::fgDefaultSelectedGC = 0;
52 const TGGC *TGTextView::fgDefaultSelectedBackgroundGC = 0;
53 
54 
55 ////////////////////////////////////////////////////////////////////////////////
56 /// Notify when timer times out and reset the timer.
57 
58 Bool_t TViewTimer::Notify()
59 {
60  fView->HandleTimer(this);
61  Reset();
62  return kFALSE;
63 }
64 
65 ClassImp(TGTextView);
66 
67 
68 ////////////////////////////////////////////////////////////////////////////////
69 /// Initialize a text view widget.
70 
71 void TGTextView::Init(ULong_t back)
72 {
73  // set in TGResourcePool via .rootrc
74  fFont = GetDefaultFontStruct();
75  fNormGC = GetDefaultGC();
76  fSelGC = GetDefaultSelectedGC();
77  fSelbackGC = GetDefaultSelectedBackgroundGC();
78 
79  fWhiteGC = *fClient->GetResourcePool()->GetDocumentBckgndGC();
80  fWhiteGC.SetGraphicsExposures(kTRUE);
81  fWhiteGC.SetBackground(back);
82  fWhiteGC.SetForeground(back);
83 
84  fMarkedFromX = 0;
85  fMarkedFromY = 0;
86  fReadOnly = kFALSE;
87  fIsMarked = kFALSE;
88 
89  fText = new TGText();
90  TGView::Clear();
91 
92  fClipText = new TGText();
93 
94  gVirtualX->GetFontProperties(fFont, fMaxAscent, fMaxDescent);
95  fScrollVal.fY = fMaxAscent + fMaxDescent;
96  fScrollVal.fX = fMaxWidth = gVirtualX->TextWidth(fFont, "@", 1);
97 
98  fScrollTimer = new TViewTimer(this, 75);
99  gSystem->AddTimer(fScrollTimer);
100 
101  // define DND types
102  fDNDTypeList = new Atom_t[3];
103  fDNDTypeList[0] = gVirtualX->InternAtom("application/root", kFALSE);
104  fDNDTypeList[1] = gVirtualX->InternAtom("text/uri-list", kFALSE);
105  fDNDTypeList[2] = 0;
106  gVirtualX->SetDNDAware(fId, fDNDTypeList);
107  SetDNDTarget(kTRUE);
108 
109  gVirtualX->ClearWindow(fCanvas->GetId());
110  Layout();
111 }
112 
113 ////////////////////////////////////////////////////////////////////////////////
114 /// Create a text view widget.
115 
116 TGTextView::TGTextView(const TGWindow *parent, UInt_t w, UInt_t h, Int_t id,
117  UInt_t sboptions, ULong_t back) :
118  TGView(parent, w, h, id, 3, 3, kSunkenFrame | kDoubleBorder, sboptions, back)
119 {
120  Init(back);
121 }
122 
123 ////////////////////////////////////////////////////////////////////////////////
124 /// Create a text view widget.
125 
126 TGTextView::TGTextView(const TGWindow *parent, UInt_t w, UInt_t h, TGText *text,
127  Int_t id, UInt_t sboptions, ULong_t back) :
128  TGView(parent, w, h, id, 3, 3, kSunkenFrame | kDoubleBorder, sboptions, back)
129 {
130  Init(back);
131  TGLongPosition pos, srcStart, srcEnd;
132  pos.fX = pos.fY = 0;
133  srcStart.fX = srcStart.fY = 0;
134  srcEnd.fY = text->RowCount()-1;
135  srcEnd.fX = text->GetLineLength(srcEnd.fY)-1;
136  fText->InsText(pos, text, srcStart, srcEnd);
137 }
138 
139 ////////////////////////////////////////////////////////////////////////////////
140 /// Create a text view widget.
141 
142 TGTextView::TGTextView(const TGWindow *parent, UInt_t w, UInt_t h,
143  const char *string, Int_t id, UInt_t sboptions,
144  ULong_t back) :
145  TGView(parent, w, h, id, 3, 3, kSunkenFrame | kDoubleBorder, sboptions, back)
146 {
147  Init(back);
148  TGLongPosition pos;
149  pos.fX = pos.fY = 0;
150  fText->InsText(pos, string);
151 }
152 
153 ////////////////////////////////////////////////////////////////////////////////
154 /// Cleanup text view widget.
155 
156 TGTextView::~TGTextView()
157 {
158  delete fScrollTimer;
159  delete fText;
160  delete fClipText;
161  delete [] fDNDTypeList;
162 }
163 
164 ////////////////////////////////////////////////////////////////////////////////
165 /// set background color
166 
167 void TGTextView::SetBackground(Pixel_t p)
168 {
169  fCanvas->SetBackgroundColor(p);
170  fWhiteGC.SetBackground(p);
171  fWhiteGC.SetForeground(p);
172 }
173 
174 ////////////////////////////////////////////////////////////////////////////////
175 /// set selected text background color
176 
177 void TGTextView::SetSelectBack(Pixel_t p)
178 {
179  fSelbackGC.SetBackground(p);
180  fSelbackGC.SetForeground(p);
181 }
182 
183 ////////////////////////////////////////////////////////////////////////////////
184 /// set selected text color
185 
186 void TGTextView::SetSelectFore(Pixel_t p)
187 {
188  fSelGC.SetBackground(p);
189  fSelGC.SetForeground(p);
190 }
191 
192 ////////////////////////////////////////////////////////////////////////////////
193 /// Adopt a new text buffer. The text will be deleted by this object.
194 
195 void TGTextView::SetText(TGText *text)
196 {
197  Clear();
198  delete fText;
199  fText = text;
200  Layout();
201 }
202 
203 ////////////////////////////////////////////////////////////////////////////////
204 /// Add text to the view widget.
205 
206 void TGTextView::AddText(TGText *text)
207 {
208  UInt_t h1 = (UInt_t)ToScrYCoord(fText->RowCount());
209 
210  fText->AddText(text);
211  Layout();
212 
213  UInt_t h2 = (UInt_t)ToScrYCoord(fText->RowCount());
214 
215  if (h2 <= h1) {
216  return;
217  }
218 
219  if (h2 < fCanvas->GetHeight()) {
220  UpdateRegion(0, h1, fCanvas->GetWidth(), h2 - h1);
221  }
222 }
223 
224 ////////////////////////////////////////////////////////////////////////////////
225 /// Add a line of text to the view widget.
226 
227 void TGTextView::AddLine(const char *string)
228 {
229  UInt_t h1 = (UInt_t)ToScrYCoord(fText->RowCount());
230 
231  AddLineFast(string);
232  Layout();
233 
234  UInt_t h2 = (UInt_t)ToScrYCoord(fText->RowCount());
235 
236  if (h2 <= h1) {
237  return;
238  }
239  if (h2 < fCanvas->GetHeight()) {
240  UpdateRegion(0, h1, fCanvas->GetWidth(), h2 - h1);
241  }
242 }
243 
244 ////////////////////////////////////////////////////////////////////////////////
245 /// Add a line of text to the view widget.
246 /// Fast version. Use it if you are going to add
247 /// several lines, than call Update().
248 
249 void TGTextView::AddLineFast(const char *string)
250 {
251  TGLongPosition pos;
252  pos.fX = 0;
253  pos.fY = fText->RowCount();
254  fText->InsText(pos, string);
255 }
256 
257 ////////////////////////////////////////////////////////////////////////////////
258 /// update the whole window of text view
259 
260 void TGTextView::Update()
261 {
262  Layout();
263  fExposedRegion.Empty();
264  UpdateRegion(0, 0, fCanvas->GetWidth(), fCanvas->GetHeight());
265 }
266 
267 ////////////////////////////////////////////////////////////////////////////////
268 /// Return width of longest line.
269 
270 Long_t TGTextView::ReturnLongestLineWidth()
271 {
272  Long_t count = 0, longest = 0, width;
273  Long_t rows = fText->RowCount();
274  while (count < rows) {
275  width = ToScrXCoord(fText->GetLineLength(count), count) + fVisible.fX;
276  if (width > longest) {
277  longest = width;
278  }
279  count++;
280  }
281  return longest;
282 }
283 
284 ////////////////////////////////////////////////////////////////////////////////
285 /// Search for string in text. If direction is true search forward.
286 /// Returns true if string is found.
287 
288 Bool_t TGTextView::Search(const char *string, Bool_t direction, Bool_t caseSensitive)
289 {
290  TGLongPosition pos, pos2;
291  pos2.fX = pos2.fY = 0;
292  if (fIsMarked) {
293  if (!direction) {
294  pos2.fX = fMarkedStart.fX;
295  pos2.fY = fMarkedStart.fY;
296  } else {
297  pos2.fX = fMarkedEnd.fX + 1;
298  pos2.fY = fMarkedEnd.fY;
299  }
300  }
301  if (!fText->Search(&pos, pos2, string, direction, caseSensitive)) {
302  return kFALSE;
303  }
304  UnMark();
305  fIsMarked = kTRUE;
306  fMarkedStart.fY = fMarkedEnd.fY = pos.fY;
307  fMarkedStart.fX = pos.fX;
308  fMarkedEnd.fX = fMarkedStart.fX + strlen(string) - 1;
309  pos.fY = ToObjYCoord(fVisible.fY);
310  if ((fMarkedStart.fY < pos.fY) ||
311  (ToScrYCoord(fMarkedStart.fY) >= (Int_t)fCanvas->GetHeight())) {
312  pos.fY = fMarkedStart.fY;
313  }
314  pos.fX = ToObjXCoord(fVisible.fX, pos.fY);
315  if ((fMarkedStart.fX < pos.fX) ||
316  (ToScrXCoord(fMarkedStart.fX, pos.fY) >= (Int_t)fCanvas->GetWidth())) {
317  pos.fX = fMarkedStart.fX;
318  }
319 
320  SetVsbPosition((ToScrYCoord(pos.fY) + fVisible.fY)/fScrollVal.fY);
321  SetHsbPosition((ToScrXCoord(pos.fX, pos.fY) + fVisible.fX)/fScrollVal.fX);
322  UpdateRegion(0, (Int_t)ToScrYCoord(fMarkedStart.fY), fCanvas->GetWidth(),
323  UInt_t(ToScrYCoord(fMarkedEnd.fY+1) - ToScrYCoord(fMarkedEnd.fY)));
324 
325  return kTRUE;
326 }
327 
328 ////////////////////////////////////////////////////////////////////////////////
329 /// Changes text entry font.
330 
331 void TGTextView::SetFont(FontStruct_t font)
332 {
333  if (font != fFont) {
334  fFont = font;
335  fNormGC.SetFont(gVirtualX->GetFontHandle(fFont));
336  fSelGC.SetFont(gVirtualX->GetFontHandle(fFont));
337  fClient->NeedRedraw(this);
338  }
339 }
340 
341 ////////////////////////////////////////////////////////////////////////////////
342 /// Convert line number to screen coordinate.
343 
344 Long_t TGTextView::ToScrYCoord(Long_t yCoord)
345 {
346  if (yCoord * (fMaxAscent + fMaxDescent) <= 0) {
347  return 0;
348  }
349  if (yCoord > fText->RowCount()) {
350  return fText->RowCount() * (fMaxAscent + fMaxDescent);
351  }
352  return yCoord * (fMaxAscent + fMaxDescent) - fVisible.fY;
353 }
354 
355 ////////////////////////////////////////////////////////////////////////////////
356 /// Convert column number in specified line to screen coordinate.
357 
358 Long_t TGTextView::ToScrXCoord(Long_t xCoord, Long_t line)
359 {
360  TGLongPosition pos;
361  char *buffer;
362 
363  pos.fX = 0;
364  pos.fY = line;
365  Long_t width = fText->GetLineLength(line);
366  if (xCoord <= 0 || pos.fY < 0 || width <= 0) {
367  return 0;
368  }
369  if (xCoord > width) {
370  xCoord = width;
371  }
372  buffer = fText->GetLine(pos, xCoord);
373  width = gVirtualX->TextWidth(fFont, buffer, (Int_t)xCoord) - fVisible.fX;
374  delete [] buffer;
375 
376  return width;
377 }
378 
379 ////////////////////////////////////////////////////////////////////////////////
380 /// Convert y screen coordinate to line number.
381 
382 Long_t TGTextView::ToObjYCoord(Long_t yCoord)
383 {
384  return yCoord / (fMaxAscent + fMaxDescent);
385 }
386 
387 ////////////////////////////////////////////////////////////////////////////////
388 /// Convert x screen coordinate to column in specified line.
389 
390 Long_t TGTextView::ToObjXCoord(Long_t xCoord, Long_t line)
391 {
392  TGLongPosition pos;
393  char *buffer, *travelBuffer;
394  char charBuffer;
395 
396  if (line < 0 || line >= fText->RowCount()) {
397  return 0;
398  }
399 
400  Long_t len = fText->GetLineLength(line);
401  pos.fX = 0;
402  pos.fY = line;
403  if (len <= 0 || xCoord < 0) {
404  return 0;
405  }
406 
407  Long_t viscoord = xCoord;
408  buffer = fText->GetLine(pos, len);
409  if (!buffer) return 0;
410  travelBuffer = buffer;
411  charBuffer = *travelBuffer++;
412  int cw = gVirtualX->TextWidth(fFont, &charBuffer, 1);
413 
414  while (viscoord - cw >= 0 && pos.fX < len) {
415  viscoord -= cw;
416  pos.fX++;
417  charBuffer = *travelBuffer++;
418  cw = gVirtualX->TextWidth(fFont, &charBuffer, 1);
419  }
420 
421  delete [] buffer;
422  return pos.fX;
423 }
424 
425 ////////////////////////////////////////////////////////////////////////////////
426 /// Clear text view widget.
427 
428 void TGTextView::Clear(Option_t *)
429 {
430  TGView::Clear();
431  fIsMarked = kFALSE;
432  fIsSaved = kTRUE;
433  fMarkedStart.fX = fMarkedStart.fY = 0;
434  fMarkedEnd.fX = fMarkedEnd.fY = 0;
435  fIsMarking = kFALSE;
436 
437  delete fText;
438  fText = new TGText();
439  fText->Clear();
440  SendMessage(fMsgWindow, MK_MSG(kC_TEXTVIEW, kTXT_ISMARKED), fWidgetId, kFALSE);
441  Marked(kFALSE);
442  gVirtualX->ClearWindow(fCanvas->GetId());
443  SendMessage(fMsgWindow, MK_MSG(kC_TEXTVIEW, kTXT_DATACHANGE), fWidgetId, 0);
444  DataChanged();
445  Layout();
446 }
447 
448 ////////////////////////////////////////////////////////////////////////////////
449 /// Load a file in the text view widget. Return false in case file does not
450 /// exist.
451 
452 Bool_t TGTextView::LoadFile(const char *filename, Long_t startpos, Long_t length)
453 {
454  FILE *fp;
455  if (!(fp = fopen(filename, "r")))
456  return kFALSE;
457  fclose(fp);
458 
459  ShowTop();
460  Clear();
461  fText->Load(filename, startpos, length);
462  Update();
463  return kTRUE;
464 }
465 
466 ////////////////////////////////////////////////////////////////////////////////
467 /// Load text from a text buffer. Return false in case of failure.
468 
469 Bool_t TGTextView::LoadBuffer(const char *txtbuf)
470 {
471  if (!txtbuf || !txtbuf[0]) {
472  return kFALSE;
473  }
474 
475  Clear();
476  fText->LoadBuffer(txtbuf);
477  Update();
478  return kTRUE;
479 }
480 
481 ////////////////////////////////////////////////////////////////////////////////
482 /// Copy selected text to clipboard.
483 
484 Bool_t TGTextView::Copy()
485 {
486  TGLongPosition insPos, startPos, endPos;
487 
488  if (!fIsMarked) {
489  return kFALSE;
490  }
491  delete fClipText;
492  fClipText = new TGText();
493  insPos.fY = insPos.fX = 0;
494  startPos.fX = fMarkedStart.fX;
495  startPos.fY = fMarkedStart.fY;
496  endPos.fX = fMarkedEnd.fX-1;
497  endPos.fY = fMarkedEnd.fY;
498  if (endPos.fX == -1) {
499  if (endPos.fY > 0) {
500  endPos.fY--;
501  }
502  endPos.fX = fText->GetLineLength(endPos.fY);
503  if (endPos.fX < 0) {
504  endPos.fX = 0;
505  }
506  }
507  fClipText->InsText(insPos, fText, startPos, endPos);
508  gVirtualX->SetPrimarySelectionOwner(fId);
509  return kTRUE;
510 }
511 
512 ////////////////////////////////////////////////////////////////////////////////
513 /// Select all text in the viewer.
514 
515 Bool_t TGTextView::SelectAll()
516 {
517  if (fText->RowCount() == 1 && fText->GetLineLength(0) == 0) {
518  return kFALSE;
519  }
520  fIsMarked = kTRUE;
521  fMarkedStart.fY = 0;
522  fMarkedStart.fX = 0;
523  fMarkedEnd.fY = fText->RowCount()-1;
524  fMarkedEnd.fX = fText->GetLineLength(fMarkedEnd.fY);
525  if (fMarkedEnd.fX < 0) {
526  fMarkedEnd.fX = 0;
527  }
528  UpdateRegion(0, 0, fCanvas->GetWidth(), fCanvas->GetHeight());
529  Copy();
530 
531  return kTRUE;
532 }
533 
534 ////////////////////////////////////////////////////////////////////////////////
535 /// Draw lines in exposed region.
536 
537 void TGTextView::DrawRegion(Int_t x, Int_t y, UInt_t w, UInt_t h)
538 {
539  char *buffer;
540 
541  TGLongPosition pos;
542  Long_t xoffset, len, len1, len2;
543  Long_t line_count = fText->RowCount();
544  Rectangle_t rect;
545  rect.fX = x;
546  rect.fY = y;
547  pos.fY = ToObjYCoord(fVisible.fY + h);
548  rect.fHeight = UShort_t(h + ToScrYCoord(pos.fY + 1) - ToScrYCoord(pos.fY));
549  pos.fX = ToObjXCoord(fVisible.fX + w, pos.fY);
550  rect.fWidth = UShort_t(w + ToScrXCoord(pos.fX + 1, pos.fY) - ToScrXCoord(pos.fX, pos.fY));
551  Int_t yloc = rect.fY + (Int_t)fScrollVal.fY;
552  pos.fY = ToObjYCoord(fVisible.fY + rect.fY);
553 
554  while (pos.fY <= line_count &&
555  yloc - fScrollVal.fY <= (Int_t)fCanvas->GetHeight() &&
556  yloc <= rect.fY + rect.fHeight) {
557 
558  pos.fX = ToObjXCoord(fVisible.fX + rect.fX, pos.fY);
559  xoffset = ToScrXCoord(pos.fX, pos.fY);
560  len = fText->GetLineLength(pos.fY) - pos.fX;
561 
562  gVirtualX->ClearArea(fCanvas->GetId(), x, Int_t(ToScrYCoord(pos.fY)),
563  rect.fWidth, UInt_t(ToScrYCoord(pos.fY+1)-ToScrYCoord(pos.fY)));
564 
565 
566  if (len > 0) {
567  if (len > ToObjXCoord(fVisible.fX + rect.fX + rect.fWidth, pos.fY) - pos.fX) {
568  len = ToObjXCoord(fVisible.fX + rect.fX + rect.fWidth, pos.fY) - pos.fX + 1;
569  }
570  if (pos.fX == 0) {
571  xoffset = -fVisible.fX;
572  }
573  if (pos.fY >= ToObjYCoord(fVisible.fY)) {
574  buffer = fText->GetLine(pos, len);
575  if (!buffer) // skip next lines and continue the while() loop
576  continue;
577  Int_t i = 0;
578  while (buffer[i] != '\0') {
579  if (buffer[i] == '\t') {
580  buffer[i] = ' ';
581  Int_t j = i+1;
582  while (buffer[j] == 16 && buffer[j] != '\0') {
583  buffer[j++] = ' ';
584  }
585  }
586  i++;
587  }
588 
589  if (!fIsMarked ||
590  pos.fY < fMarkedStart.fY || pos.fY > fMarkedEnd.fY ||
591  (pos.fY == fMarkedStart.fY &&
592  fMarkedStart.fX >= pos.fX+len &&
593  fMarkedStart.fY != fMarkedEnd.fY) ||
594  (pos.fY == fMarkedEnd.fY &&
595  fMarkedEnd.fX < pos.fX &&
596  fMarkedStart.fY != fMarkedEnd.fY) ||
597  (fMarkedStart.fY == fMarkedEnd.fY &&
598  (fMarkedEnd.fX < pos.fX ||
599  fMarkedStart.fX > pos.fX+len))) {
600 
601  gVirtualX->DrawString(fCanvas->GetId(), fNormGC(), Int_t(xoffset),
602  Int_t(ToScrYCoord(pos.fY+1) - fMaxDescent),
603  buffer, Int_t(len));
604  } else {
605  if (pos.fY > fMarkedStart.fY && pos.fY < fMarkedEnd.fY) {
606  len1 = 0;
607  len2 = len;
608  } else {
609  if (fMarkedStart.fY == fMarkedEnd.fY) {
610  if (fMarkedStart.fX >= pos.fX &&
611  fMarkedStart.fX <= pos.fX + len) {
612  len1 = fMarkedStart.fX - pos.fX;
613  } else {
614  len1 = 0;
615  }
616  if (fMarkedEnd.fX >= pos.fX &&
617  fMarkedEnd.fX <= pos.fX + len) {
618  len2 = fMarkedEnd.fX - pos.fX - len1; // +1
619  } else {
620  len2 = len - len1;
621  }
622  } else {
623  if (pos.fY == fMarkedStart.fY) {
624  if (fMarkedStart.fX < pos.fX) {
625  len1 = 0;
626  len2 = len;
627  } else {
628  len1 = fMarkedStart.fX - pos.fX;
629  len2 = len - len1;
630  }
631  } else {
632  if (fMarkedEnd.fX > pos.fX+len) {
633  len1 = 0;
634  len2 = len;
635  } else {
636  len1 = 0 ;
637  len2 = fMarkedEnd.fX - pos.fX; // +1
638  }
639  }
640  }
641  }
642  gVirtualX->DrawString(fCanvas->GetId(), fNormGC(),
643  Int_t(ToScrXCoord(pos.fX, pos.fY)),
644  Int_t(ToScrYCoord(pos.fY+1) - fMaxDescent),
645  buffer, Int_t(len1));
646  gVirtualX->FillRectangle(fCanvas->GetId(), fSelbackGC(),
647  Int_t(ToScrXCoord(pos.fX+len1, pos.fY)),
648  Int_t(ToScrYCoord(pos.fY)),
649  UInt_t(ToScrXCoord(pos.fX+len1+len2, pos.fY) -
650  ToScrXCoord(pos.fX+len1, pos.fY)),
651  UInt_t(ToScrYCoord(pos.fY+1)-ToScrYCoord(pos.fY)));
652  gVirtualX->DrawString(fCanvas->GetId(), fSelGC(),
653  Int_t(ToScrXCoord(pos.fX+len1, pos.fY)),
654  Int_t(ToScrYCoord(pos.fY+1) - fMaxDescent),
655  buffer+len1, Int_t(len2));
656  gVirtualX->DrawString(fCanvas->GetId(), fNormGC(),
657  Int_t(ToScrXCoord(pos.fX+len1+len2, pos.fY)),
658  Int_t(ToScrYCoord(pos.fY+1) - fMaxDescent),
659  buffer+len1+len2, Int_t(len-(len1+len2)));
660  }
661  delete [] buffer;
662  }
663  }
664  pos.fY++;
665  yloc += Int_t(ToScrYCoord(pos.fY) - ToScrYCoord(pos.fY-1));
666  }
667 }
668 
669 ////////////////////////////////////////////////////////////////////////////////
670 /// Handle mouse crossing event.
671 
672 Bool_t TGTextView::HandleCrossing(Event_t *event)
673 {
674  if (event->fWindow != fCanvas->GetId())
675  return kTRUE;
676 
677  fMousePos.fY = ToObjYCoord(fVisible.fY + event->fY);
678  if (ToScrYCoord(fMousePos.fY+1) >= (Int_t)fCanvas->GetHeight()) {
679  fMousePos.fY--;
680  }
681  fMousePos.fX = ToObjXCoord(fVisible.fX + event->fX, fMousePos.fY);
682  if (fMousePos.fX >= ReturnLineLength(fMousePos.fY)) {
683  fMousePos.fX--;
684  }
685  if ((event->fState & kButton1Mask) && fIsMarked && fIsMarking) {
686  if (event->fType == kLeaveNotify) {
687  if (event->fX < 0) {
688  fScrolling = 0;
689  return kFALSE;
690  }
691  if (event->fX >= (Int_t)fCanvas->GetWidth()) {
692  fScrolling = 1;
693  return kFALSE;
694  }
695  if (event->fY < 0) {
696  fScrolling = 2;
697  return kFALSE;
698  }
699  if (event->fY >= (Int_t)fCanvas->GetHeight()) {
700  fScrolling = 3;
701  return kFALSE;
702  }
703  } else {
704  fScrolling = -1;
705  Mark(fMousePos.fX, fMousePos.fY);
706  }
707  } else {
708  fIsMarking = kFALSE;
709  }
710 
711  return kTRUE;
712 }
713 
714 ////////////////////////////////////////////////////////////////////////////////
715 /// Handle scroll timer.
716 
717 Bool_t TGTextView::HandleTimer(TTimer *)
718 {
719  static const Int_t kAutoScrollFudge = 10;
720  static const Int_t kAcceleration[kAutoScrollFudge + 1] = {1, 1, 1, 1, 2, 3, 4, 6, 8, 12, 16};
721 
722  TGLongPosition size;
723  Window_t dum1, dum2;
724  Event_t ev;
725  ev.fType = kButtonPress;
726  Int_t x, y;
727  Int_t dy = 0;
728 
729  if (fMarkedStart.fY == fMarkedEnd.fY) {
730  return kFALSE;
731  }
732  if (fIsMarked && (fScrolling != -1)) {
733  // where cursor
734  gVirtualX->QueryPointer(fId, dum1, dum2, ev.fXRoot, ev.fYRoot, x, y, ev.fState);
735 
736  fMousePos.fY = ToObjYCoord(fVisible.fY + y);
737 
738  if (fMousePos.fY >= ReturnLineCount()) {
739  fMousePos.fY = ReturnLineCount() - 1;
740  }
741  if (fMousePos.fY < 0) {
742  fMousePos.fY = 0;
743  }
744  if (ev.fState & kButton1Mask) {
745 
746  // Figure scroll amount y
747  if (y < kAutoScrollFudge) {
748  dy = kAutoScrollFudge - y;
749  } else if ((Int_t)fCanvas->GetHeight() - kAutoScrollFudge <= y) {
750  dy = fCanvas->GetHeight() - kAutoScrollFudge - y;
751  }
752  Int_t ady = TMath::Abs(dy) >> 3;
753 
754  if (dy) {
755  if (ady > kAutoScrollFudge) ady = kAutoScrollFudge;
756  dy = kAcceleration[ady];
757  } else {
758  dy = 1;
759  }
760 
761  if (y > (Int_t)fCanvas->GetHeight()) {
762  fScrolling = 3;
763  }
764  if (y < 0) {
765  fScrolling = 2;
766  }
767  } else {
768  fScrolling = -1;
769  }
770 
771  size.fY = ToObjYCoord(fVisible.fY + fCanvas->GetHeight()) - 1;
772  size.fX = ToObjXCoord(fVisible.fX + fCanvas->GetWidth(), fMousePos.fY) - 1;
773  switch (fScrolling) {
774  case -1:
775  break;
776  case 0:
777  if (fVisible.fX == 0) {
778  fScrolling = -1;
779  break;
780  } else {
781  SetHsbPosition(fVisible.fX / fScrollVal.fX - 1);
782  Mark(ToObjXCoord(fVisible.fX, fMousePos.fY) - 1, fMousePos.fY);
783  }
784  break;
785  case 1:
786  if ((Int_t)fCanvas->GetWidth() >= ToScrXCoord(ReturnLineLength(fMousePos.fY), fMousePos.fY)) {
787  fScrolling = -1;
788  break;
789  } else {
790  SetHsbPosition(fVisible.fX / fScrollVal.fX + 1);
791  Mark(size.fX+1, fMousePos.fY);
792  }
793  break;
794  case 2:
795  if (fVisible.fY == 0) {
796  fScrolling = -1;
797  break;
798  } else {
799  SetVsbPosition(fVisible.fY/fScrollVal.fY - dy);
800  Mark(fMousePos.fX, fMarkedStart.fY - 1);
801  }
802  break;
803  case 3:
804  if ((Int_t)fCanvas->GetHeight() >= ToScrYCoord(ReturnLineCount())) {
805  fScrolling = -1;
806  break;
807  } else {
808  SetVsbPosition(fVisible.fY/fScrollVal.fY + dy);
809  Mark(fMousePos.fX, size.fY + 1);
810  }
811  break;
812  default:
813  break;
814  }
815  }
816  return kTRUE;
817 }
818 
819 ////////////////////////////////////////////////////////////////////////////////
820 /// Handle mouse button event in text editor.
821 
822 Bool_t TGTextView::HandleButton(Event_t *event)
823 {
824  if (event->fWindow != fCanvas->GetId()) {
825  return kFALSE;
826  }
827 
828  if (event->fCode == kButton1) {
829  if (event->fType == kButtonPress) {
830  if (fIsMarked) {
831  if (event->fState & kKeyShiftMask) {
832  fIsMarking = kTRUE;
833  HandleMotion(event);
834  return kTRUE;
835  }
836 
837  UnMark();
838  }
839  fIsMarked = kTRUE;
840  fIsMarking = kTRUE;
841  fMousePos.fY = ToObjYCoord(fVisible.fY + event->fY);
842  fMousePos.fX = ToObjXCoord(fVisible.fX + event->fX, fMousePos.fY);
843  fMarkedStart.fX = fMarkedEnd.fX = fMousePos.fX;
844  fMarkedStart.fY = fMarkedEnd.fY = fMousePos.fY;
845  } else {
846  fScrolling = -1;
847  if ((fMarkedStart.fX == fMarkedEnd.fX) &&
848  (fMarkedStart.fY == fMarkedEnd.fY)) {
849  fIsMarked = kFALSE;
850  SendMessage(fMsgWindow, MK_MSG(kC_TEXTVIEW, kTXT_ISMARKED),
851  fWidgetId, kFALSE);
852  Marked(kFALSE);
853  } else {
854  SendMessage(fMsgWindow, MK_MSG(kC_TEXTVIEW, kTXT_ISMARKED),
855  fWidgetId, kTRUE);
856  Marked(kTRUE);
857  }
858  fIsMarking = kFALSE;
859  }
860  } else if (event->fCode == kButton4) {
861  // move three lines up
862  if (fVisible.fY > 0) {
863  Long_t amount = fVisible.fY / fScrollVal.fY - 3;
864  SetVsbPosition((amount >= 0) ? amount : 0);
865  //Mark(fMousePos.fX, fMarkedStart.fY - 3);
866  }
867  } else if (event->fCode == kButton5) {
868  // move three lines down
869  if ((Int_t)fCanvas->GetHeight() < ToScrYCoord(ReturnLineCount())) {
870  TGLongPosition size;
871  size.fY = ToObjYCoord(fVisible.fY + fCanvas->GetHeight()) - 1;
872  SetVsbPosition(fVisible.fY / fScrollVal.fY + 3);
873  //Mark(fMousePos.fX, size.fY + 3);
874  }
875  } else if (event->fType == kButtonPress) {
876  if (event->fCode == kButton2) {
877  SendMessage(fMsgWindow, MK_MSG(kC_TEXTVIEW, kTXT_CLICK2),
878  fWidgetId, (event->fYRoot << 16) | event->fXRoot);
879  UnMark();
880  } else if (event->fCode == kButton3) {
881  SendMessage(fMsgWindow, MK_MSG(kC_TEXTVIEW, kTXT_CLICK3),
882  fWidgetId, (event->fYRoot << 16) | event->fXRoot);
883  }
884  }
885 
886  if (event->fType == kButtonRelease) {
887  if (event->fCode == kButton1) {
888  if (fIsMarked) {
889  Copy();
890  }
891  }
892  }
893 
894  return kTRUE;
895 }
896 
897 ////////////////////////////////////////////////////////////////////////////////
898 /// handle double click
899 
900 Bool_t TGTextView::HandleDoubleClick(Event_t *)
901 {
902  return kFALSE;
903 }
904 
905 ////////////////////////////////////////////////////////////////////////////////
906 /// Handle mouse motion event in the text editor widget.
907 
908 Bool_t TGTextView::HandleMotion(Event_t *event)
909 {
910  if ((ToObjYCoord(fVisible.fY+event->fY) == fMousePos.fY) &&
911  (ToObjXCoord(fVisible.fX+event->fX, ToObjYCoord(fVisible.fY + event->fY)) == fMousePos.fX)) {
912  return kTRUE;
913  }
914 
915  if (fScrolling != -1) {
916  return kTRUE;
917  }
918 
919  fMousePos.fY = ToObjYCoord(fVisible.fY + event->fY);
920  if (fMousePos.fY >= ReturnLineCount()) {
921  fMousePos.fY = ReturnLineCount()-1;
922  }
923  fMousePos.fX = ToObjXCoord(fVisible.fX + event->fX, fMousePos.fY);
924 
925  if (fMousePos.fX > ReturnLineLength(fMousePos.fY)) {
926  fMousePos.fX = ReturnLineLength(fMousePos.fY);
927  }
928  if (event->fWindow != fCanvas->GetId()) {
929  return kTRUE;
930  }
931 
932  if (!fIsMarking) {
933  return kTRUE;
934  }
935  if (event->fX < 0) {
936  return kTRUE;
937  }
938  if (event->fX >= (Int_t)fCanvas->GetWidth()) {
939  return kTRUE;
940  }
941  if (event->fY < 0) {
942  return kTRUE;
943  }
944  if (event->fY >= (Int_t)fCanvas->GetHeight()) {
945  return kTRUE;
946  }
947  Mark(fMousePos.fX, fMousePos.fY);
948  return kTRUE;
949 }
950 
951 ////////////////////////////////////////////////////////////////////////////////
952 /// Handle selection clear event.
953 
954 Bool_t TGTextView::HandleSelectionClear(Event_t * /*event*/)
955 {
956  if (fIsMarked) {
957  UnMark();
958  }
959  return kTRUE;
960 }
961 
962 ////////////////////////////////////////////////////////////////////////////////
963 /// Handle request to send current clipboard contents to requestor window.
964 
965 Bool_t TGTextView::HandleSelectionRequest(Event_t *event)
966 {
967  Event_t reply;
968  char *buffer, *temp_buffer;
969  Long_t len, prev_len, temp_len, count;
970  TGLongPosition pos;
971  Atom_t targets[2];
972  Atom_t type;
973 
974  reply.fType = kSelectionNotify;
975  reply.fTime = event->fTime;
976  reply.fUser[0] = event->fUser[0]; // requestor
977  reply.fUser[1] = event->fUser[1]; // selection
978  reply.fUser[2] = event->fUser[2]; // target
979  reply.fUser[3] = event->fUser[3]; // property
980 
981  targets[0] = gVirtualX->InternAtom("TARGETS", kFALSE);
982  targets[1] = gVirtualX->InternAtom("XA_STRING", kFALSE);
983 
984  if ((Atom_t)event->fUser[2] == targets[0]) {
985  type = gVirtualX->InternAtom("XA_ATOM", kFALSE);
986  gVirtualX->ChangeProperty((Window_t) event->fUser[0], (Atom_t) event->fUser[3],
987  type, (UChar_t*) targets, (Int_t) 2);
988 
989  gVirtualX->SendEvent((Window_t)event->fUser[0], &reply);
990  return kTRUE;
991  }
992 
993  len = 0;
994  for (count = 0; count < fClipText->RowCount(); count++) {
995  len += fClipText->GetLineLength(count)+1;
996  }
997  len--; // remove \n for last line
998 
999  pos.fY = pos.fX = 0;
1000  buffer = new char[len+1];
1001  prev_len = temp_len = 0;
1002  for (pos.fY = 0; pos.fY < fClipText->RowCount(); pos.fY++) {
1003  temp_len = fClipText->GetLineLength(pos.fY);
1004  if (temp_len < 0) break;
1005  temp_buffer = fClipText->GetLine(pos, temp_len);
1006  strncpy(buffer+prev_len, temp_buffer, (UInt_t)temp_len);
1007  if (pos.fY < fClipText->RowCount()-1) {
1008  buffer[prev_len+temp_len] = 10; // \n
1009  prev_len += temp_len+1;
1010  } else
1011  prev_len += temp_len;
1012  delete [] temp_buffer;
1013  }
1014  buffer[len] = '\0';
1015 
1016  // get rid of special tab fillers
1017  ULong_t i = 0;
1018  while (buffer[i]) {
1019  if (buffer[i] == '\t') {
1020  ULong_t j = i + 1;
1021  while (buffer[j] == 16 && buffer[j]) {
1022  j++;
1023  }
1024  // coverity[secure_coding]
1025  strcpy(buffer+i+1, buffer+j);
1026  len -= j - i - 1;
1027  }
1028  i++;
1029  }
1030 
1031  gVirtualX->ChangeProperty((Window_t) event->fUser[0], (Atom_t) event->fUser[3],
1032  (Atom_t) event->fUser[2], (UChar_t*) buffer,
1033  (Int_t) len);
1034 
1035  delete [] buffer;
1036 
1037  gVirtualX->SendEvent((Window_t)event->fUser[0], &reply);
1038 
1039  return kTRUE;
1040 }
1041 
1042 ////////////////////////////////////////////////////////////////////////////////
1043 /// Returns true if given a text file
1044 /// Uses the specification given on p86 of the Camel book
1045 /// - Text files have no NULLs in the first block
1046 /// - and less than 30% of characters with high bit set
1047 
1048 static Bool_t IsTextFile(const char *candidate)
1049 {
1050  Int_t i;
1051  Int_t nchars;
1052  Int_t weirdcount = 0;
1053  char buffer[512];
1054  FILE *infile;
1055  FileStat_t buf;
1056 
1057  if (gSystem->GetPathInfo(candidate, buf) || !(buf.fMode & kS_IFREG))
1058  return kFALSE;
1059 
1060  infile = fopen(candidate, "r");
1061  if (infile) {
1062  // Read a block
1063  nchars = fread(buffer, 1, 512, infile);
1064  fclose (infile);
1065  // Examine the block
1066  for (i = 0; i < nchars; i++) {
1067  if (buffer[i] & 128)
1068  weirdcount++;
1069  if (buffer[i] == '\0')
1070  // No NULLs in text files
1071  return kFALSE;
1072  }
1073  if ((nchars > 0) && ((weirdcount * 100 / nchars) > 30))
1074  return kFALSE;
1075  } else {
1076  // Couldn't open it. Not a text file then
1077  return kFALSE;
1078  }
1079  return kTRUE;
1080 }
1081 
1082 ////////////////////////////////////////////////////////////////////////////////
1083 /// Handle Drop event
1084 
1085 Bool_t TGTextView::HandleDNDDrop(TDNDData *data)
1086 {
1087  static Atom_t rootObj = gVirtualX->InternAtom("application/root", kFALSE);
1088  static Atom_t uriObj = gVirtualX->InternAtom("text/uri-list", kFALSE);
1089 
1090  if (fText->RowCount() > 1) {
1091  Int_t ret;
1092  new TGMsgBox(fClient->GetRoot(), GetMainFrame(),
1093  "Overvrite", "Do you want to replace existing text?",
1094  kMBIconExclamation, kMBYes | kMBNo, &ret);
1095  if (ret == kMBNo)
1096  return kTRUE;
1097  }
1098  if (data->fDataType == rootObj) {
1099  TBufferFile buf(TBuffer::kRead, data->fDataLength, (void *)data->fData);
1100  buf.SetReadMode();
1101  TObject *obj = (TObject *)buf.ReadObjectAny(TObject::Class());
1102  if (obj && obj->InheritsFrom("TMacro")) {
1103  TMacro *macro = (TMacro *)obj;
1104  TIter next(macro->GetListOfLines());
1105  TObjString *objs;
1106  while ((objs = (TObjString*) next())) {
1107  AddLine(objs->GetName());
1108  }
1109  }
1110  else if (obj && obj->InheritsFrom("TSystemFile")) {
1111  TSystemFile *sfile = (TSystemFile *)obj;
1112  LoadFile(sfile->GetName());
1113  DataDropped(sfile->GetName());
1114  }
1115  return kTRUE;
1116  }
1117  else if (data->fDataType == uriObj) {
1118  TString sfname((char *)data->fData);
1119  if (sfname.Length() > 7) {
1120  sfname.ReplaceAll("\r\n", "");
1121  TUrl uri(sfname.Data());
1122  if (IsTextFile(uri.GetFile())) {
1123  LoadFile(uri.GetFile());
1124  DataDropped(uri.GetFile());
1125  }
1126  }
1127  }
1128  return kFALSE;
1129 }
1130 
1131 ////////////////////////////////////////////////////////////////////////////////
1132 /// Handle Drag position event
1133 
1134 Atom_t TGTextView::HandleDNDPosition(Int_t /*x*/, Int_t /*y*/, Atom_t action,
1135  Int_t /*xroot*/, Int_t /*yroot*/)
1136 {
1137  return action;
1138 }
1139 
1140 ////////////////////////////////////////////////////////////////////////////////
1141 /// Handle Drag Enter event
1142 
1143 Atom_t TGTextView::HandleDNDEnter(Atom_t *typelist)
1144 {
1145  static Atom_t rootObj = gVirtualX->InternAtom("application/root", kFALSE);
1146  static Atom_t uriObj = gVirtualX->InternAtom("text/uri-list", kFALSE);
1147  Atom_t ret = kNone;
1148  for (int i = 0; typelist[i] != kNone; ++i) {
1149  if (typelist[i] == rootObj)
1150  ret = rootObj;
1151  if (typelist[i] == uriObj)
1152  ret = uriObj;
1153  }
1154  return ret;
1155 }
1156 
1157 ////////////////////////////////////////////////////////////////////////////////
1158 /// Handle Drag Leave event
1159 
1160 Bool_t TGTextView::HandleDNDLeave()
1161 {
1162  return kTRUE;
1163 }
1164 
1165 ////////////////////////////////////////////////////////////////////////////////
1166 /// Mark a text region from xPos to yPos.
1167 
1168 void TGTextView::Mark(Long_t xPos, Long_t yPos)
1169 {
1170  TGLongPosition posStart, posEnd, pos;
1171 
1172  pos.fY = yPos;
1173  pos.fX = xPos;
1174  if (pos.fY > fText->RowCount()-1) {
1175  pos.fY = fText->RowCount()-1;
1176  }
1177  if (pos.fX > fText->GetLineLength(pos.fY)) {
1178  pos.fX = fText->GetLineLength(pos.fY);
1179  }
1180  if (pos.fY < fMarkedStart.fY) {
1181  posEnd.fY = fMarkedStart.fY;
1182  if (fMarkedFromY == 1 || fMarkedFromX == 1) {
1183  posEnd.fY = fMarkedEnd.fY;
1184  fMarkedEnd.fX = fMarkedStart.fX;
1185  fMarkedEnd.fY = fMarkedStart.fY;
1186  }
1187  posStart.fY = pos.fY;
1188  fMarkedStart.fY = pos.fY;
1189  fMarkedStart.fX = pos.fX;
1190  fMarkedFromY = 0;
1191  fMarkedFromX = 0;
1192  } else if (pos.fY > fMarkedEnd.fY) {
1193  posStart.fY = fMarkedEnd.fY;
1194  if (fMarkedFromY == 0 || fMarkedFromX == 0) {
1195  if (fMarkedStart.fY != fMarkedEnd.fY) {
1196  posStart.fY = fMarkedStart.fY;
1197  fMarkedStart.fX = fMarkedEnd.fX;
1198  fMarkedStart.fY = fMarkedEnd.fY;
1199  }
1200  }
1201  fMarkedEnd.fY = pos.fY;
1202  fMarkedEnd.fX = pos.fX; // -1
1203  fMarkedFromY = 1;
1204  fMarkedFromX = 1;
1205 
1206  posEnd.fY = fMarkedEnd.fY;
1207  } else {
1208  if (pos.fX <= fMarkedStart.fX && pos.fY == fMarkedStart.fY) {
1209  posEnd.fY = fMarkedStart.fY;
1210  if (fMarkedFromY == 1 || fMarkedFromX == 1) {
1211  posEnd.fY = fMarkedEnd.fY;
1212  fMarkedEnd.fX = fMarkedStart.fX;
1213  fMarkedEnd.fY = fMarkedStart.fY;
1214  }
1215  fMarkedStart.fX = pos.fX;
1216  fMarkedFromY = 0;
1217  fMarkedFromX = 0;
1218  posStart.fY = fMarkedStart.fY;
1219  } else {
1220  if (pos.fX > fMarkedEnd.fX && pos.fY == fMarkedEnd.fY) {
1221  posStart.fY = fMarkedEnd.fY;
1222  if (fMarkedFromY == 0 || fMarkedFromX == 0) {
1223  posStart.fY = fMarkedStart.fY;
1224  fMarkedStart.fX = fMarkedEnd.fX;
1225  fMarkedStart.fY = fMarkedEnd.fY;
1226  }
1227  fMarkedEnd.fX = pos.fX; // -1
1228  fMarkedFromY = 1;
1229  fMarkedFromX = 1;
1230  posEnd.fY = fMarkedEnd.fY;
1231  } else {
1232  if (fMarkedFromY == 0 || fMarkedFromX == 0) {
1233  posStart.fY = fMarkedStart.fY;
1234  fMarkedStart.fY = pos.fY;
1235  fMarkedStart.fX = pos.fX;
1236  posEnd.fY = fMarkedStart.fY;
1237  fMarkedFromX = 0;
1238  if (fMarkedStart.fY == fMarkedEnd.fY &&
1239  fMarkedStart.fX > fMarkedEnd.fX) {
1240  fMarkedStart.fX = fMarkedEnd.fX;
1241  fMarkedEnd.fX = pos.fX; // -1
1242  fMarkedFromX = 1;
1243  }
1244  } else if (fMarkedFromX == 1 || fMarkedFromY == 1) {
1245  posStart.fY = pos.fY;
1246  posEnd.fY = fMarkedEnd.fY;
1247  fMarkedEnd.fY = pos.fY;
1248  fMarkedEnd.fX = pos.fX; // -1
1249  fMarkedFromY = 1;
1250  fMarkedFromX = 1;
1251  if (fMarkedEnd.fX == -1) {
1252  fMarkedEnd.fY = pos.fY-1;
1253  fMarkedEnd.fX = fText->GetLineLength(fMarkedEnd.fY); // -1
1254  if (fMarkedEnd.fX < 0) {
1255  fMarkedEnd.fX = 0;
1256  }
1257  }
1258  fMarkedFromX = 1;
1259  if (fMarkedStart.fY == fMarkedEnd.fY &&
1260  fMarkedStart.fX > fMarkedEnd.fX) {
1261  fMarkedEnd.fX = fMarkedStart.fX;
1262  fMarkedStart.fX = pos.fX;
1263  fMarkedFromX = 0;
1264  }
1265  }
1266  }
1267  }
1268  }
1269 
1270  if (fMarkedEnd.fX == -1) {
1271  if (fMarkedEnd.fY > 0) {
1272  fMarkedEnd.fY--;
1273  }
1274  fMarkedEnd.fX = fText->GetLineLength(fMarkedEnd.fY); // -1
1275  if (fMarkedEnd.fX < 0) {
1276  fMarkedEnd.fX = 0;
1277  }
1278  }
1279  fIsMarked = kTRUE;
1280 
1281  Int_t yy = (Int_t)ToScrYCoord(posStart.fY);
1282  UInt_t hh = UInt_t(ToScrYCoord(posEnd.fY + 1) - ToScrYCoord(posStart.fY));
1283 
1284  DrawRegion(0, yy, fCanvas->GetWidth(), hh);
1285  return;
1286 }
1287 
1288 ////////////////////////////////////////////////////////////////////////////////
1289 /// Clear marked region.
1290 
1291 void TGTextView::UnMark()
1292 {
1293  if (!fIsMarked ||
1294  ((fMarkedEnd.fY == fMarkedStart.fY) &&
1295  (fMarkedEnd.fX == fMarkedStart.fX))) {
1296  return;
1297  }
1298  fIsMarked = kFALSE;
1299 
1300  Int_t y = (Int_t)ToScrYCoord(fMarkedStart.fY);
1301  UInt_t h = UInt_t(ToScrYCoord(fMarkedEnd.fY + 1) - y);
1302 
1303  // update marked region
1304  UpdateRegion(0, y, fCanvas->GetWidth(), h);
1305 }
1306 
1307 ////////////////////////////////////////////////////////////////////////////////
1308 /// Adjust widget width to longest line.
1309 
1310 void TGTextView::AdjustWidth()
1311 {
1312  Long_t line = fText->GetLongestLine();
1313  if (line <= 0) {
1314  return;
1315  }
1316  Long_t size = ToScrXCoord(fText->GetLineLength(line), line) + fVisible.fX;
1317  if (fVsb->IsMapped()) {
1318  size += fVsb->GetDefaultWidth();
1319  }
1320  size += (fBorderWidth << 1) + fXMargin+1;
1321  Resize((UInt_t)size, fHeight);
1322 }
1323 
1324 ////////////////////////////////////////////////////////////////////////////////
1325 /// Layout the components of view.
1326 
1327 void TGTextView::Layout()
1328 {
1329  VLayout();
1330  HLayout();
1331 }
1332 
1333 ////////////////////////////////////////////////////////////////////////////////
1334 /// Horizontal layout of widgets (canvas, scrollbar).
1335 
1336 void TGTextView::HLayout()
1337 {
1338  if (!fHsb) return;
1339 
1340  Int_t tcw, tch;
1341  Long_t cols;
1342  tch = fHeight - (fBorderWidth << 1) - fYMargin-1;
1343  tcw = fWidth - (fBorderWidth << 1) - fXMargin-1;
1344 
1345  if (fVsb && fVsb->IsMapped()) {
1346  tcw -= fVsb->GetDefaultWidth();
1347  if (tcw < 0) tcw = 0;
1348  }
1349  fCanvas->SetHeight(tch);
1350  fCanvas->SetWidth(tcw);
1351  cols = ReturnLongestLineWidth();
1352  if (cols <= tcw) {
1353  if (fHsb && fHsb->IsMapped()) {
1354  SetVisibleStart(0, kHorizontal);
1355  fHsb->UnmapWindow();
1356  VLayout();
1357  }
1358  fCanvas->MoveResize(fBorderWidth + fXMargin, fBorderWidth + fYMargin, tcw, tch);
1359  } else {
1360  if (fHsb) {
1361  tch -= fHsb->GetDefaultHeight();
1362  if (tch < 0) tch = 0;
1363  fHsb->MoveResize(fBorderWidth, fHeight - fHsb->GetDefaultHeight()-fBorderWidth,
1364  tcw+1+fBorderWidth, fHsb->GetDefaultHeight());
1365  fHsb->MapWindow();
1366  fHsb->SetRange(Int_t(cols/fScrollVal.fX), Int_t(tcw/fScrollVal.fX));
1367  }
1368  fCanvas->MoveResize(fBorderWidth + fXMargin, fBorderWidth + fYMargin, tcw, tch);
1369  }
1370 }
1371 
1372 ////////////////////////////////////////////////////////////////////////////////
1373 /// Vertical layout of widgets (canvas, scrollbar).
1374 
1375 void TGTextView::VLayout()
1376 {
1377  Int_t tcw, tch;
1378  Long_t lines;
1379 
1380  tch = fHeight - (fBorderWidth << 1) - fYMargin-1;
1381  tcw = fWidth - (fBorderWidth << 1) - fXMargin-1;
1382  if (fHsb && fHsb->IsMapped()) {
1383  tch -= fHsb->GetDefaultHeight();
1384  if (tch < 0) tch = 0;
1385  }
1386  fCanvas->SetHeight(tch);
1387  fCanvas->SetWidth(tcw);
1388  lines = ReturnHeighestColHeight();
1389  if (lines <= tch) {
1390  if (fVsb && fVsb->IsMapped()) {
1391  SetVisibleStart(0, kVertical);
1392  fVsb->UnmapWindow();
1393  HLayout();
1394  }
1395  fCanvas->MoveResize(fBorderWidth + fXMargin, fBorderWidth + fYMargin, tcw, tch);
1396  } else {
1397  if (fVsb) {
1398  tcw -= fVsb->GetDefaultWidth();
1399  if (tcw < 0) tcw = 0;
1400  fVsb->MoveResize(fWidth - fVsb->GetDefaultWidth() - fBorderWidth, fBorderWidth,
1401  fVsb->GetDefaultWidth(), tch+1+fBorderWidth);
1402  fVsb->MapWindow();
1403  fVsb->SetRange(Int_t(lines/fScrollVal.fY), Int_t(tch/fScrollVal.fY));
1404  }
1405  fCanvas->MoveResize(fBorderWidth + fXMargin, fBorderWidth + fYMargin, tcw, tch);
1406  }
1407 }
1408 
1409 ////////////////////////////////////////////////////////////////////////////////
1410 /// Set the range for the kVertical or kHorizontal scrollbar.
1411 
1412 void TGTextView::SetSBRange(Int_t direction)
1413 {
1414  if (direction == kVertical) {
1415  if (!fVsb) {
1416  return;
1417  }
1418  if (ReturnHeighestColHeight() <= (Int_t)fCanvas->GetHeight()) {
1419  if (fVsb->IsMapped()) {
1420  VLayout();
1421  } else {
1422  return;
1423  }
1424  }
1425  if (!fVsb->IsMapped()) {
1426  VLayout();
1427  }
1428  fVsb->SetRange(Int_t(ReturnHeighestColHeight()/fScrollVal.fY),
1429  Int_t(fCanvas->GetHeight()/fScrollVal.fY));
1430  HLayout();
1431  } else {
1432  if (!fHsb) {
1433  return;
1434  }
1435  if (ReturnLongestLineWidth() <= (Int_t)fCanvas->GetWidth()) {
1436  if (fHsb->IsMapped()) {
1437  HLayout();
1438  } else {
1439  return;
1440  }
1441  }
1442  if (!fHsb->IsMapped()) {
1443  HLayout();
1444  }
1445  fHsb->SetRange(Int_t(ReturnLongestLineWidth()/fScrollVal.fX),
1446  Int_t(fCanvas->GetWidth()/fScrollVal.fX));
1447  VLayout();
1448  }
1449 }
1450 
1451 ////////////////////////////////////////////////////////////////////////////////
1452 /// Set position of horizontal scrollbar.
1453 
1454 void TGTextView::SetHsbPosition(Long_t newPos)
1455 {
1456  if (fHsb && fHsb->IsMapped()) {
1457  fHsb->SetPosition(Int_t(newPos));
1458  } else {
1459  SetVisibleStart(Int_t(newPos * fScrollVal.fX), kHorizontal);
1460  }
1461 }
1462 
1463 ////////////////////////////////////////////////////////////////////////////////
1464 /// Set position of vertical scrollbar.
1465 
1466 void TGTextView::SetVsbPosition(Long_t newPos)
1467 {
1468  if (fVsb && fVsb->IsMapped()) {
1469  fVsb->SetPosition(Int_t(newPos));
1470  } else {
1471  SetVisibleStart(Int_t(newPos * fScrollVal.fY), kVertical);
1472  }
1473 }
1474 
1475 ////////////////////////////////////////////////////////////////////////////////
1476 /// Return default font structure in use.
1477 
1478 FontStruct_t TGTextView::GetDefaultFontStruct()
1479 {
1480  if (!fgDefaultFont) {
1481  fgDefaultFont = gClient->GetResourcePool()->GetDocumentFixedFont();
1482  }
1483  return fgDefaultFont->GetFontStruct();
1484 }
1485 
1486 ////////////////////////////////////////////////////////////////////////////////
1487 /// Show bottom of the page.
1488 
1489 void TGTextView::ShowBottom()
1490 {
1491  Int_t tch;
1492  Long_t lines, newPos;
1493 
1494  tch = fCanvas->GetHeight();
1495  lines = ReturnHeighestColHeight();
1496  if (lines > tch) {
1497  newPos = lines / fScrollVal.fY;
1498  SetVsbPosition(newPos);
1499  }
1500  Layout();
1501 }
1502 
1503 ////////////////////////////////////////////////////////////////////////////////
1504 /// Show top of the page.
1505 
1506 void TGTextView::ShowTop()
1507 {
1508  SetVsbPosition(0);
1509  Layout();
1510 }
1511 
1512 ////////////////////////////////////////////////////////////////////////////////
1513 /// Set text color.
1514 
1515 void TGTextView::SetForegroundColor(Pixel_t col)
1516 {
1517  fNormGC.SetBackground(col);
1518  fNormGC.SetForeground(col);
1519 }
1520 
1521 ////////////////////////////////////////////////////////////////////////////////
1522 /// Return default graphics context in use.
1523 
1524 const TGGC &TGTextView::GetDefaultGC()
1525 {
1526  if (!fgDefaultGC) {
1527  fgDefaultGC = new TGGC(*gClient->GetResourcePool()->GetFrameGC());
1528  fgDefaultGC->SetFont(fgDefaultFont->GetFontHandle());
1529  }
1530  return *fgDefaultGC;
1531 }
1532 
1533 ////////////////////////////////////////////////////////////////////////////////
1534 /// Return selection graphics context in use.
1535 
1536 const TGGC &TGTextView::GetDefaultSelectedGC()
1537 {
1538  if (!fgDefaultSelectedGC) {
1539  fgDefaultSelectedGC = new TGGC(*gClient->GetResourcePool()->GetSelectedGC());
1540  fgDefaultSelectedGC->SetFont(fgDefaultFont->GetFontHandle());
1541  }
1542  return *fgDefaultSelectedGC;
1543 }
1544 
1545 ////////////////////////////////////////////////////////////////////////////////
1546 /// Return graphics context for highlighted frame background.
1547 
1548 const TGGC &TGTextView::GetDefaultSelectedBackgroundGC()
1549 {
1550  if (!fgDefaultSelectedBackgroundGC) {
1551  fgDefaultSelectedBackgroundGC = gClient->GetResourcePool()->GetSelectedBckgndGC();
1552  }
1553  return *fgDefaultSelectedBackgroundGC;
1554 }
1555 
1556 ////////////////////////////////////////////////////////////////////////////////
1557 /// Save a text edit widget as a C++ statement(s) on output stream out
1558 
1559 void TGTextView::SavePrimitive(std::ostream &out, Option_t *option /*= ""*/)
1560 {
1561  char quote = '"';
1562  out << " TGTextView *";
1563  out << GetName() << " = new TGTextView(" << fParent->GetName()
1564  << "," << GetWidth() << "," << GetHeight()
1565  << ");"<< std::endl;
1566 
1567  if (option && strstr(option, "keep_names"))
1568  out << " " << GetName() << "->SetName(\"" << GetName() << "\");" << std::endl;
1569 
1570  if (fCanvas->GetBackground() != TGFrame::fgWhitePixel) {
1571  out << " " << GetName() << "->ChangeBackground(" << fCanvas->GetBackground() << ");" << std::endl;
1572  }
1573 
1574  TGText *txt = GetText();
1575  Bool_t fromfile = strlen(txt->GetFileName()) ? kTRUE : kFALSE;
1576  TString fn;
1577 
1578  if (fromfile) {
1579  const char *filename = txt->GetFileName();
1580  fn = gSystem->ExpandPathName(gSystem->UnixPathName(filename));
1581  } else {
1582  fn = TString::Format("Txt%s", GetName()+5);
1583  txt->Save(fn.Data());
1584  }
1585  out << " " << GetName() << "->LoadFile(" << quote << fn.Data() << quote << ");" << std::endl;
1586 }