MythTV  master
cc708window.cpp
Go to the documentation of this file.
1 // -*- Mode: c++ -*-
2 // Copyright (c) 2003-2005, Daniel Kristjansson
3 
4 #include <cassert>
5 #include <algorithm>
6 
8 #include "captions/cc708window.h"
9 
10 /************************************************************************
11 
12  FCC Addons to EIA-708.
13 
14  * Decoders must support the standard, large, and small caption sizes
15  and must allow the caption provider to choose a size and allow the
16  viewer to choose an alternative size.
17 
18  * Decoders must support the eight fonts listed in EIA-708. Caption
19  providers may specify 1 of these 8 font styles to be used to write
20  caption text. Decoders must include the ability for consumers to
21  choose among the eight fonts. The decoder must display the font
22  chosen by the caption provider unless the viewer chooses a different
23  font.
24 
25  * Decoders must implement the same 8 character background colors
26  as those that Section 9 requires be implemented for character
27  foreground (white, black, red, green, blue, yellow, magenta and cyan).
28 
29  * Decoders must implement options for altering the appearance of
30  caption character edges.
31 
32  * Decoders must display the color chosen by the caption provider,
33  and must allow viewers to override the foreground and/or background
34  color chosen by the caption provider and select alternate colors.
35 
36  * Decoders must be capable of decoding and processing data for the
37  six standard services, but information from only one service need
38  be displayed at a given time.
39 
40  * Decoders must include an option that permits a viewer to choose a
41  setting that will display captions as intended by the caption
42  provider (a default). Decoders must also include an option that
43  allows a viewer's chosen settings to remain until the viewer
44  chooses to alter these settings, including during periods when
45  the television is turned off.
46 
47  * Cable providers and other multichannel video programming
48  distributors must transmit captions in a format that will be
49  understandable to this decoder circuitry in digital cable
50  television sets when transmitting programming to digital
51  television devices.
52 
53 ******************************************************************************/
54 
59 
60 const uint k708EffectSnap = 0;
61 const uint k708EffectFade = 1;
62 const uint k708EffectWipe = 2;
63 
64 const uint k708BorderNone = 0;
70 
75 
79 
83 
92 
99 
102 
107 
108 void CC708Window::DefineWindow(int _priority, bool _visible,
109  int _anchor_point, int _relative_pos,
110  int _anchor_vertical, int _anchor_horizontal,
111  int _row_count, int _column_count,
112  int _row_lock, int _column_lock,
113  int _pen_style, int _window_style)
114 {
115  // The DefineWindow command may be sent frequently to allow a
116  // caption decoder just tuning in to get in synch quickly.
117  // Usually the row_count and column_count are unchanged, but it is
118  // possible to add or remove rows or columns. Due to the
119  // one-dimensional row-major representation of characters, if the
120  // number of columns is changed, a new array must be created and
121  // the old characters copied in. If only the number of rows
122  // decreases, the array can be left unchanged. If only the number
123  // of rows increases, the old characters can be copied into the
124  // new character array directly without any index translation.
125  QMutexLocker locker(&m_lock);
126 
127  _row_count++;
128  _column_count++;
129 
130  m_priority = _priority;
131  SetVisible(_visible);
132  m_anchor_point = _anchor_point;
133  m_relative_pos = _relative_pos;
134  m_anchor_vertical = _anchor_vertical;
135  m_anchor_horizontal = _anchor_horizontal;
136  m_row_lock = _row_lock;
137  m_column_lock = _column_lock;
138 
139  if ((!_pen_style && !GetExists()) || _pen_style)
140  m_pen.SetPenStyle(_pen_style ? _pen_style : 1);
141 
142  if ((!_window_style && !GetExists()) || _window_style)
143  SetWindowStyle(_window_style ? _window_style : 1);
144 
145  Resize(_row_count, _column_count);
146  m_row_count = _row_count;
147  m_column_count = _column_count;
149 
150  SetExists(true);
151 }
152 
153 // Expand the internal array of characters if necessary to accommodate
154 // the current values of row_count and column_count. Any new (space)
155 // characters exposed are given the current pen attributes. At the
156 // end, row_count and column_count are NOT updated.
157 void CC708Window::Resize(uint new_rows, uint new_columns)
158 {
159 
160  if (!GetExists() || m_text == nullptr)
161  {
162  m_true_row_count = 0;
164  }
165 
166  //We need to shrink Rows, at times Scroll (row >= (int)m_true_row_count)) fails and we
167  // Don't scroll caption line resulting in overwriting the same.
168  // Ex: [CAPTIONING FUNDED BY CBS SPORTS
169  // DIVISION]NG FUNDED BY CBS SPORTS
170 
171  if (new_rows < m_true_row_count || new_columns < m_true_column_count)
172  {
173  delete [] m_text;
174  m_text = new CC708Character [static_cast<size_t>(new_rows) * new_columns];
175  m_true_row_count = new_rows;
176  m_true_column_count = new_columns;
177  m_pen.m_row = 0;
178  m_pen.m_column = 0;
179  Clear();
180  SetChanged();
181  SetExists(true);
182  LOG(VB_VBI,
183  LOG_DEBUG,
184  QString("Shrinked nr %1 nc %2 rc %3 cc %4 tr %5 tc %6").arg(new_rows)
185  .arg(new_columns) .arg(m_row_count) .arg(m_column_count)
187  return;
188  }
189 
190  if (new_rows > m_true_row_count || new_columns > m_true_column_count)
191  {
192  new_rows = std::max(new_rows, m_true_row_count);
193  new_columns = std::max(new_columns, m_true_column_count);
194 
195  // Expand the array if the new size exceeds the current capacity
196  // in either dimension.
197  auto *new_text = new CC708Character[static_cast<size_t>(new_rows) * new_columns];
198  m_pen.m_column = 0;
199  m_pen.m_row = 0;
200  uint i = 0;
201  for (i = 0; m_text && i < m_row_count; ++i)
202  {
203  uint j = 0;
204  for (j = 0; j < m_column_count; ++j)
205  new_text[i * new_columns + j] = m_text[i * m_true_column_count + j];
206  for (; j < new_columns; ++j)
207  new_text[i * new_columns + j].m_attr = m_pen.m_attr;
208  }
209  for (; i < new_rows; ++i)
210  for (uint j = 0; j < new_columns; ++j)
211  new_text[i * new_columns + j].m_attr = m_pen.m_attr;
212 
213  delete [] m_text;
214  m_text = new_text;
215  m_true_row_count = new_rows;
216  m_true_column_count = new_columns;
217  SetChanged();
218  }
219  else if (new_rows > m_row_count || new_columns > m_column_count)
220  {
221  // At least one dimension expanded into existing space, so
222  // those newly exposed characters must be cleared.
223  for (uint i = 0; i < m_row_count; ++i)
224  {
225  for (uint j = m_column_count; j < new_columns; ++j)
226  {
227  m_text[i * m_true_column_count + j].m_character = ' ';
229  }
230  }
231  for (uint i = m_row_count; i < new_rows; ++i)
232  {
233  for (uint j = 0; j < new_columns; ++j)
234  {
235  m_text[i * m_true_column_count + j].m_character = ' ';
237  }
238  }
239  SetChanged();
240  }
241  SetExists(true);
242 }
243 
244 
246 {
247  QMutexLocker locker(&m_lock);
248 
249  SetExists(false);
250  m_true_row_count = 0;
252 
253  if (m_text)
254  {
255  delete [] m_text;
256  m_text = nullptr;
257  }
258 }
259 
261 {
262  QMutexLocker locker(&m_lock);
263 
264  if (!GetExists() || !m_text)
265  return;
266 
267  for (uint i = 0; i < m_true_row_count * m_true_column_count; i++)
268  {
269  m_text[i].m_character = QChar(' ');
270  m_text[i].m_attr = m_pen.m_attr;
271  }
272  SetChanged();
273 }
274 
276 {
277  assert(GetExists());
278  assert(m_text);
282 }
283 
284 std::vector<CC708String*> CC708Window::GetStrings(void) const
285 {
286  // Note on implementation. In many cases, one line will be
287  // computed as the concatenation of 3 strings: a prefix of spaces
288  // with a default foreground color, followed by the actual text in
289  // a specific foreground color, followed by a suffix of spaces
290  // with a default foreground color. This leads to 3
291  // FormattedTextChunk objects when 1 would suffice. The prefix
292  // and suffix ultimately get optimized away, but not before a
293  // certain amount of unnecessary work.
294  //
295  // This can be solved with two steps. First, suppress a format
296  // change when only non-underlined spaces have been seen so far.
297  // (Background changes can be ignored because the subtitle code
298  // suppresses leading spaces.) Second, for trailing
299  // non-underlined spaces, either suppress a format change, or
300  // avoid creating such a string when it appears at the end of the
301  // row. (We can't do the latter for an initial string of spaces,
302  // because the spaces are needed for coordinate calculations.)
303  QMutexLocker locker(&m_lock);
304 
305  std::vector<CC708String*> list;
306 
307  CC708String *cur = nullptr;
308 
309  if (!m_text)
310  return list;
311 
312  bool createdNonblankStrings = false;
313  std::array<QChar,k708MaxColumns> chars {};
314  for (uint j = 0; j < m_row_count; j++)
315  {
316  bool inLeadingSpaces = true;
317  bool inTrailingSpaces = true;
318  bool createdString = false;
319  uint strStart = 0;
320  for (uint i = 0; i < m_column_count; i++)
321  {
322  CC708Character &chr = m_text[j * m_true_column_count + i];
323  chars[i] = chr.m_character;
324  if (!cur)
325  {
326  cur = new CC708String;
327  cur->m_x = i;
328  cur->m_y = j;
329  cur->m_attr = chr.m_attr;
330  strStart = i;
331  }
332  bool isDisplayable = (chr.m_character != ' ' || chr.m_attr.m_underline);
333  if (inLeadingSpaces && isDisplayable)
334  {
335  cur->m_attr = chr.m_attr;
336  inLeadingSpaces = false;
337  }
338  if (isDisplayable)
339  {
340  inTrailingSpaces = false;
341  }
342  if (cur->m_attr != chr.m_attr)
343  {
344  cur->m_str = QString(&chars[strStart], i - strStart);
345  list.push_back(cur);
346  createdString = true;
347  createdNonblankStrings = true;
348  inTrailingSpaces = true;
349  cur = nullptr;
350  i--;
351  }
352  }
353  if (cur)
354  {
355  // If the entire string is spaces, we still may need to
356  // create a chunk to preserve spacing between lines.
357  if (!inTrailingSpaces || !createdString)
358  {
359  bool allSpaces = (inLeadingSpaces || inTrailingSpaces);
360  int length = allSpaces ? 0 : m_column_count - strStart;
361  if (length)
362  createdNonblankStrings = true;
363  cur->m_str = QString(&chars[strStart], length);
364  list.push_back(cur);
365  }
366  else
367  delete cur;
368  cur = nullptr;
369  }
370  }
371  if (!createdNonblankStrings)
372  list.clear();
373  return list;
374 }
375 
376 void CC708Window::DisposeStrings(std::vector<CC708String*> &strings)
377 {
378  while (!strings.empty())
379  {
380  delete strings.back();
381  strings.pop_back();
382  }
383 }
384 
386 {
387  static const std::array<const uint,8> style2justify
388  {
391  };
392 
393  if ((style < 1) || (style > 7))
394  return;
395 
397  m_fill_opacity = ((2 == style) || (5 == style)) ?
405  m_effect_speed = 0;
406  m_justify = style2justify[style];
407  m_word_wrap = (style > 3) && (style < 7) ? 1 : 0;
408 
410  // It appears that ths is missused by broadcasters (FOX -- Dollhouse)
413 }
414 
415 void CC708Window::AddChar(QChar ch)
416 {
417  if (!GetExists())
418  return;
419 
420  QString dbg_char = ch;
421  if (ch.toLatin1() < 32)
422  dbg_char = QString("0x%1").arg( (int)ch.toLatin1(), 0,16);
423 
424  if (!IsPenValid())
425  {
426  LOG(VB_VBI, LOG_DEBUG,
427  QString("AddChar(%1) at (c %2, r %3) INVALID win(%4,%5)")
428  .arg(dbg_char).arg(m_pen.m_column).arg(m_pen.m_row)
430  return;
431  }
432 
433  // CEA-708-D Section 7.1.4, page 30
434  // Carriage Return (CR) moves the current entry point to the beginning of the next row. If the next row is
435  // below the visible window, the window "rolls up" as defined in CEA-608-E Section 7.4. If the next row is
436  // within the visible window and contains text, the cursor is moved to the beginning of the row, but the pre-
437  // existing text is not erased.
438  if (ch.toLatin1() == 0x0D) // C0::CR
439  {
440  Scroll(m_pen.m_row + 1, 0);
441  SetChanged();
442  return;
443  }
444 
445  QMutexLocker locker(&m_lock);
446 
447  // CEA-708-D Section 7.1.4, page 30
448  // Horizontal Carriage Return (HCR) moves the current entry point to the beginning of the current row
449  // without row increment or decrement. It shall erase all text on the row.
450  if (ch.toLatin1() == 0x0E) // C0::HCR
451  {
453  for (uint c = 0; c < m_column_count; c++)
454  {
455  m_text[c + p].m_attr = m_pen.m_attr;
456  m_text[c + p].m_character = QChar(' ');
457  }
458  m_pen.m_column = 0;
460  SetChanged();
461  return;
462  }
463 
464  // Backspace
465  if (ch.toLatin1() == 0x08)
466  {
467  DecrPenLocation();
468  CC708Character& chr = GetCCChar();
469  chr.m_attr = m_pen.m_attr;
470  chr.m_character = QChar(' ');
471  SetChanged();
472  return;
473  }
474 
475  // CEA-708-D Section 7.1.4, page 30
476  // Form Feed (FF) erases all text in the window and moves the cursor to the first character position in the
477  // window (0,0).
478  if (ch.toLatin1() == 0x0c) // C0::FF
479  {
480  Clear();
481  SetPenLocation(0,0);
482  SetChanged();
483  return;
484  }
485 
486  CC708Character& chr = GetCCChar();
487  chr.m_attr = m_pen.m_attr;
488  chr.m_character = ch;
489  int c = m_pen.m_column;
490  int r = m_pen.m_row;
491  IncrPenLocation();
492  SetChanged();
493 
494  LOG(VB_VBI, LOG_DEBUG, QString("AddChar(%1) at (c %2, r %3) -> (%4,%5)")
495  .arg(dbg_char).arg(c).arg(r).arg(m_pen.m_column).arg(m_pen.m_row));
496 }
497 
498 void CC708Window::Scroll(int row, int col)
499 {
500  QMutexLocker locker(&m_lock);
501 
503  return;
504 
505  if (m_text && (k708DirBottomToTop == m_scroll_dir) &&
506  (row >= (int)m_true_row_count))
507  {
508  for (uint j = 0; j < m_true_row_count - 1; j++)
509  {
510  for (uint i = 0; i < m_true_column_count; i++)
511  m_text[(m_true_column_count * j) + i] =
512  m_text[(m_true_column_count * (j+1)) + i];
513  }
514  //uint colsz = m_true_column_count * sizeof(CC708Character);
515  //memmove(m_text, m_text + colsz, colsz * (m_true_row_count - 1));
516 
517  CC708Character tmp(*this);
518  for (uint i = 0; i < m_true_column_count; i++)
520 
522  SetChanged();
523  }
524  else
525  {
526  m_pen.m_row = row;
527  }
528  // TODO implement other 3 scroll directions...
529 
530  m_pen.m_column = col;
531 }
532 
534 {
535  // TODO: Scroll direction and up/down printing,
536  // and word wrap not handled yet...
537  int new_column = m_pen.m_column;
538  int new_row = m_pen.m_row;
539 
540  new_column += (m_print_dir == k708DirLeftToRight) ? +1 : 0;
541  new_column += (m_print_dir == k708DirRightToLeft) ? -1 : 0;
542  new_row += (m_print_dir == k708DirTopToBottom) ? +1 : 0;
543  new_row += (m_print_dir == k708DirBottomToTop) ? -1 : 0;
544 
545 #if 0
546  LOG(VB_VBI, LOG_DEBUG, QString("IncrPen dir%1: (c %2, r %3) -> (%4,%5)")
547  .arg(m_print_dir).arg(m_pen.m_column).arg(m_pen.m_row)
548  .arg(new_column).arg(new_row));
549 #endif
550 
552  {
553  // basic wrapping for l->r, r->l languages
554  if (!m_row_lock && m_column_lock && (new_column >= (int)m_true_column_count))
555  {
556  new_column = 0;
557  new_row += 1;
558  }
559  else if (!m_row_lock && m_column_lock && (new_column < 0))
560  {
561  new_column = (int)m_true_column_count - 1;
562  new_row -= 1;
563  }
564  Scroll(new_row, new_column);
565  }
566  else
567  {
568  m_pen.m_column = std::max(new_column, 0);
569  m_pen.m_row = std::max(new_row, 0);
570  }
571  // TODO implement other 2 scroll directions...
572 
574 }
575 
577 {
578  // TODO: Scroll direction and up/down printing,
579  // and word wrap not handled yet...
580  int new_column = m_pen.m_column;
581  int new_row = m_pen.m_row;
582 
583  new_column -= (m_print_dir == k708DirLeftToRight) ? +1 : 0;
584  new_column -= (m_print_dir == k708DirRightToLeft) ? -1 : 0;
585  new_row -= (m_print_dir == k708DirTopToBottom) ? +1 : 0;
586  new_row -= (m_print_dir == k708DirBottomToTop) ? -1 : 0;
587 
588 #if 0
589  LOG(VB_VBI, LOG_DEBUG, QString("DecrPen dir%1: (c %2, r %3) -> (%4,%5)")
590  .arg(m_print_dir).arg(m_pen.m_column).arg(m_pen.m_row)
591  .arg(new_column).arg(new_row));
592 #endif
593 
595  {
596  // basic wrapping for l->r, r->l languages
597  if (!m_row_lock && m_column_lock && (new_column >= (int)m_true_column_count))
598  {
599  new_column = 0;
600  new_row += 1;
601  }
602  else if (!m_row_lock && m_column_lock && (new_column < 0))
603  {
604  new_column = (int)m_true_column_count - 1;
605  new_row -= 1;
606  }
607  Scroll(new_row, new_column);
608  }
609  else
610  {
611  m_pen.m_column = std::max(new_column, 0);
612  m_pen.m_row = std::max(new_row, 0);
613  }
614  // TODO implement other 2 scroll directions...
615 
617 }
618 
620 {
621  //Clear current row in case we are reseting Pen Location.
622  LOG(VB_VBI,
623  LOG_DEBUG,
624  QString("SetPenLocation nr %1 nc %2 rc %3 cc %4 tr %5 tc %6").arg(row)
625  .arg(column).arg(m_row_count).arg(m_column_count).arg(m_true_row_count)
626  .arg(m_true_column_count));
627  if(0 == row)
628  {
629  Scroll(m_true_row_count, column);
630  m_pen.m_row = row;
631  }
632  else
633  {
634  Scroll(row, column);
635  }
637 }
638 
640 {
641  // basic limiting
642  uint max_col = std::max((int)m_true_column_count - 1, 0);
643  uint max_row = std::max((int)m_true_row_count - 1, 0);
644  m_pen.m_column = std::min(m_pen.m_column, max_col);
645  m_pen.m_row = std::min(m_pen.m_row, max_row);
646 }
647 
648 /***************************************************************************/
649 
651 {
652  static const std::array<const uint8_t,8> kStyle2Font
653  { 0, 0, 1, 2, 3, 4, 3, 4 };
654 
655  if ((style < 1) || (style > 7))
656  return;
657 
660  m_attr.m_fontTag = kStyle2Font[style];
661  m_attr.m_italics = false;
662  m_attr.m_underline = false;
663  m_attr.m_boldface = false;
664  m_attr.m_edgeType = 0;
668  m_attr.m_bgOpacity = (style<6) ?
671  m_attr.m_actualFgColor = QColor();
672 }
673 
675  : m_attr(win.m_pen.m_attr)
676 {
677 }
678 
680  const CC708CharacterAttribute &other) const
681 {
682  return ((m_penSize == other.m_penSize) &&
683  (m_offset == other.m_offset) &&
684  (m_textTag == other.m_textTag) &&
685  (m_fontTag == other.m_fontTag) &&
686  (m_edgeType == other.m_edgeType) &&
687  (m_underline == other.m_underline) &&
688  (m_italics == other.m_italics) &&
689  (m_fgColor == other.m_fgColor) &&
690  (m_fgOpacity == other.m_fgOpacity) &&
691  (m_bgColor == other.m_bgColor) &&
692  (m_bgOpacity == other.m_bgOpacity) &&
693  (m_edgeColor == other.m_edgeColor));
694 }
695 
697 {
698  // Color is expressed in 6 bits, 2 each for red, green, and blue.
699  // U.S. ATSC programs seem to use just the higher-order bit,
700  // i.e. values 0 and 2, so the last two elements of X[] are both
701  // set to the maximum 255, otherwise font colors are dim.
702  static constexpr std::array<const uint8_t,4> kX {0, 96, 255, 255};
703  return {kX[(eia708color>>4)&3], kX[(eia708color>>2)&3], kX[eia708color&3]};
704 }
CC708Window::m_text
CC708Character * m_text
Definition: cc708window.h:278
k708JustifyFull
const uint k708JustifyFull
Definition: cc708window.cpp:58
CC708Pen::m_attr
CC708CharacterAttribute m_attr
Definition: cc708window.h:169
k708JustifyRight
const uint k708JustifyRight
Definition: cc708window.cpp:56
k708AttrEdgeDepressed
const uint k708AttrEdgeDepressed
Definition: cc708window.cpp:95
CC708Window::m_fill_color
uint m_fill_color
Definition: cc708window.h:261
CC708Pen::m_column
uint m_column
Definition: cc708window.h:172
CC708CharacterAttribute::operator==
bool operator==(const CC708CharacterAttribute &other) const
Definition: cc708window.cpp:679
CC708Window::SetPenLocation
void SetPenLocation(uint row, uint column)
Definition: cc708window.cpp:619
k708AttrColorBlack
const uint k708AttrColorBlack
Definition: cc708window.cpp:100
CC708CharacterAttribute::m_edgeType
uint m_edgeType
Definition: cc708window.h:90
CC708Window::SetWindowStyle
void SetWindowStyle(uint style)
Definition: cc708window.cpp:385
CC708Window::m_lock
QRecursiveMutex m_lock
Definition: cc708window.h:310
k708JustifyLeft
const uint k708JustifyLeft
Definition: cc708window.cpp:55
cc708window.h
CC708CharacterAttribute::m_penSize
uint m_penSize
Definition: cc708window.h:86
CC708Window
Definition: cc708window.h:194
CC708CharacterAttribute::m_edgeColor
uint m_edgeColor
Definition: cc708window.h:99
k708BorderShadowLeft
const uint k708BorderShadowLeft
Definition: cc708window.cpp:68
CC708CharacterAttribute::m_fontTag
uint m_fontTag
Definition: cc708window.h:89
CC708Window::m_border_color
uint m_border_color
Definition: cc708window.h:263
CC708Window::m_column_lock
uint m_column_lock
Definition: cc708window.h:257
CC708CharacterAttribute
Definition: cc708window.h:83
CC708Window::m_justify
uint m_justify
Definition: cc708window.h:270
k708AttrFontCursive
const uint k708AttrFontCursive
Definition: cc708window.cpp:90
LOG
#define LOG(_MASK_, _LEVEL_, _QSTRING_)
Definition: mythlogging.h:39
CC708CharacterAttribute::m_fgOpacity
uint m_fgOpacity
Definition: cc708window.h:96
CC708Character::m_character
QChar m_character
Definition: cc708window.h:182
CC708Window::m_anchor_vertical
uint m_anchor_vertical
Definition: cc708window.h:252
CC708CharacterAttribute::m_bgOpacity
uint m_bgOpacity
Definition: cc708window.h:98
k708BorderNone
const uint k708BorderNone
Definition: cc708window.cpp:64
k708DirTopToBottom
const uint k708DirTopToBottom
Definition: cc708window.cpp:73
k708AttrEdgeUniform
const uint k708AttrEdgeUniform
Definition: cc708window.cpp:96
CC708Window::Resize
void Resize(uint new_rows, uint new_columns)
Definition: cc708window.cpp:157
CC708CharacterAttribute::m_actualFgColor
QColor m_actualFgColor
Definition: cc708window.h:101
CC708Window::GetCCChar
CC708Character & GetCCChar(void) const
Definition: cc708window.cpp:275
tmp
static guint32 * tmp
Definition: goom_core.cpp:26
CC708Window::IncrPenLocation
void IncrPenLocation(void)
Definition: cc708window.cpp:533
k708DirBottomToTop
const uint k708DirBottomToTop
Definition: cc708window.cpp:74
CC708Window::Clear
void Clear(void)
Definition: cc708window.cpp:260
CC708String
Definition: cc708window.h:185
CC708CharacterAttribute::m_boldface
bool m_boldface
Definition: cc708window.h:93
CC708Window::DecrPenLocation
void DecrPenLocation(void)
Definition: cc708window.cpp:576
k708AttrEdgeNone
const uint k708AttrEdgeNone
Definition: cc708window.cpp:93
CC708Character
Definition: cc708window.h:176
k708BorderRaised
const uint k708BorderRaised
Definition: cc708window.cpp:65
k708AttrOffsetSubscript
const uint k708AttrOffsetSubscript
Definition: cc708window.cpp:80
CC708Window::m_relative_pos
uint m_relative_pos
Definition: cc708window.h:251
k708AttrOpacityTransparent
const uint k708AttrOpacityTransparent
Definition: cc708window.cpp:106
k708AttrFontMonospacedSansSerif
const uint k708AttrFontMonospacedSansSerif
Definition: cc708window.cpp:87
mythlogging.h
CC708Character::m_attr
CC708CharacterAttribute m_attr
Definition: cc708window.h:181
CC708Window::AddChar
void AddChar(QChar ch)
Definition: cc708window.cpp:415
hardwareprofile.config.p
p
Definition: config.py:33
k708EffectSnap
const uint k708EffectSnap
Definition: cc708window.cpp:60
k708DirLeftToRight
const uint k708DirLeftToRight
Definition: cc708window.cpp:71
k708JustifyCenter
const uint k708JustifyCenter
Definition: cc708window.cpp:57
k708AttrFontDefault
const uint k708AttrFontDefault
Definition: cc708window.cpp:84
k708AttrOpacityFlash
const uint k708AttrOpacityFlash
Definition: cc708window.cpp:104
k708AttrEdgeLeftDropShadow
const uint k708AttrEdgeLeftDropShadow
Definition: cc708window.cpp:97
CC708CharacterAttribute::ConvertToQColor
static QColor ConvertToQColor(uint eia708color)
Definition: cc708window.cpp:696
k708EffectWipe
const uint k708EffectWipe
Definition: cc708window.cpp:62
CC708Window::Scroll
void Scroll(int row, int col)
Definition: cc708window.cpp:498
k708BorderShadowRight
const uint k708BorderShadowRight
Definition: cc708window.cpp:69
CC708Window::SetExists
void SetExists(bool value)
Definition: cc708window.h:290
CC708Window::m_effect_dir
uint m_effect_dir
Definition: cc708window.h:267
uint
unsigned int uint
Definition: compat.h:81
CC708Window::m_true_row_count
uint m_true_row_count
Definition: cc708window.h:275
CC708Window::m_fill_opacity
uint m_fill_opacity
Definition: cc708window.h:262
k708AttrSizeLarge
const uint k708AttrSizeLarge
Definition: cc708window.cpp:78
CC708Window::m_print_dir
uint m_print_dir
Definition: cc708window.h:266
CC708Window::m_border_type
uint m_border_type
Definition: cc708window.h:264
k708BorderDepressed
const uint k708BorderDepressed
Definition: cc708window.cpp:66
k708AttrSizeStandard
const uint k708AttrSizeStandard
Definition: cc708window.cpp:77
k708AttrSizeSmall
const uint k708AttrSizeSmall
Definition: cc708window.cpp:76
CC708String::m_y
uint m_y
Definition: cc708window.h:189
k708AttrEdgeRightDropShadow
const uint k708AttrEdgeRightDropShadow
Definition: cc708window.cpp:98
CC708Window::m_word_wrap
uint m_word_wrap
Definition: cc708window.h:271
CC708String::m_str
QString m_str
Definition: cc708window.h:190
CC708Window::SetChanged
void SetChanged(void)
Definition: cc708window.h:302
k708AttrEdgeRaised
const uint k708AttrEdgeRaised
Definition: cc708window.cpp:94
assert
#define assert(x)
Definition: audiooutputalsa.cpp:16
k708AttrOffsetNormal
const uint k708AttrOffsetNormal
Definition: cc708window.cpp:81
k708AttrColorWhite
const uint k708AttrColorWhite
Definition: cc708window.cpp:101
CC708Pen::SetPenStyle
void SetPenStyle(uint style)
Definition: cc708window.cpp:650
CC708String::m_x
uint m_x
Definition: cc708window.h:188
k708AttrFontProportionalSerif
const uint k708AttrFontProportionalSerif
Definition: cc708window.cpp:86
CC708Window::m_column_count
uint m_column_count
Definition: cc708window.h:255
k708AttrFontCasual
const uint k708AttrFontCasual
Definition: cc708window.cpp:89
CC708Window::m_effect_speed
uint m_effect_speed
Definition: cc708window.h:269
CC708Window::m_true_column_count
uint m_true_column_count
Definition: cc708window.h:276
CC708Window::m_display_effect
uint m_display_effect
Definition: cc708window.h:268
k708AttrFontProportionalSansSerif
const uint k708AttrFontProportionalSansSerif
Definition: cc708window.cpp:88
CC708Window::GetStrings
std::vector< CC708String * > GetStrings(void) const
Definition: cc708window.cpp:284
CC708Window::DisposeStrings
static void DisposeStrings(std::vector< CC708String * > &strings)
Definition: cc708window.cpp:376
CC708CharacterAttribute::m_textTag
uint m_textTag
Definition: cc708window.h:88
CC708Window::~CC708Window
~CC708Window()
Definition: cc708window.cpp:245
CC708CharacterAttribute::m_offset
uint m_offset
Definition: cc708window.h:87
CC708Window::LimitPenLocation
void LimitPenLocation(void)
Definition: cc708window.cpp:639
CC708Character::CC708Character
CC708Character()=default
CC708Window::m_scroll_dir
uint m_scroll_dir
Definition: cc708window.h:265
CC708Pen::m_row
uint m_row
Definition: cc708window.h:171
CC708Window::DefineWindow
void DefineWindow(int priority, bool visible, int anchor_point, int relative_pos, int anchor_vertical, int anchor_horizontal, int row_count, int column_count, int row_lock, int column_lock, int pen_style, int window_style)
Definition: cc708window.cpp:108
k708AttrFontSmallCaps
const uint k708AttrFontSmallCaps
Definition: cc708window.cpp:91
CC708String::m_attr
CC708CharacterAttribute m_attr
Definition: cc708window.h:191
CC708Window::m_anchor_point
uint m_anchor_point
Definition: cc708window.h:250
CC708CharacterAttribute::m_italics
bool m_italics
Definition: cc708window.h:92
CC708Window::SetVisible
void SetVisible(bool value)
Definition: cc708window.h:296
CC708Window::m_priority
uint m_priority
Definition: cc708window.h:241
k708BorderUniform
const uint k708BorderUniform
Definition: cc708window.cpp:67
CC708CharacterAttribute::m_bgColor
uint m_bgColor
Definition: cc708window.h:97
CC708Window::IsPenValid
bool IsPenValid(void) const
Definition: cc708window.h:216
k708AttrOffsetSuperscript
const uint k708AttrOffsetSuperscript
Definition: cc708window.cpp:82
CC708Window::m_row_count
uint m_row_count
Definition: cc708window.h:254
k708EffectFade
const uint k708EffectFade
Definition: cc708window.cpp:61
CC708Window::m_row_lock
uint m_row_lock
Definition: cc708window.h:256
k708AttrOpacitySolid
const uint k708AttrOpacitySolid
Definition: cc708window.cpp:103
CC708Window::m_anchor_horizontal
uint m_anchor_horizontal
Definition: cc708window.h:253
k708AttrFontMonospacedSerif
const uint k708AttrFontMonospacedSerif
Definition: cc708window.cpp:85
k708AttrOpacityTranslucent
const uint k708AttrOpacityTranslucent
Definition: cc708window.cpp:105
CC708CharacterAttribute::m_fgColor
uint m_fgColor
Definition: cc708window.h:95
CC708CharacterAttribute::m_underline
bool m_underline
Definition: cc708window.h:91
CC708Window::GetExists
bool GetExists(void) const
Definition: cc708window.h:287
CC708Window::m_pen
CC708Pen m_pen
Definition: cc708window.h:279
k708DirRightToLeft
const uint k708DirRightToLeft
Definition: cc708window.cpp:72