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 = ' ';
228  m_text[(i * m_true_column_count) + j].m_attr = m_pen.m_attr;
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 = ' ';
236  m_text[(i * m_true_column_count) + j].m_attr = m_pen.m_attr;
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  {
368  delete cur;
369  }
370  cur = nullptr;
371  }
372  }
373  if (!createdNonblankStrings)
374  list.clear();
375  return list;
376 }
377 
378 void CC708Window::DisposeStrings(std::vector<CC708String*> &strings)
379 {
380  while (!strings.empty())
381  {
382  delete strings.back();
383  strings.pop_back();
384  }
385 }
386 
388 {
389  static const std::array<const uint,8> style2justify
390  {
393  };
394 
395  if ((style < 1) || (style > 7))
396  return;
397 
399  m_fill_opacity = ((2 == style) || (5 == style)) ?
407  m_effect_speed = 0;
408  m_justify = style2justify[style];
409  m_word_wrap = (style > 3) && (style < 7) ? 1 : 0;
410 
412  // It appears that ths is missused by broadcasters (FOX -- Dollhouse)
415 }
416 
417 void CC708Window::AddChar(QChar ch)
418 {
419  if (!GetExists())
420  return;
421 
422  QString dbg_char = ch;
423  if (ch.toLatin1() < 32)
424  dbg_char = QString("0x%1").arg( (int)ch.toLatin1(), 0,16);
425 
426  if (!IsPenValid())
427  {
428  LOG(VB_VBI, LOG_DEBUG,
429  QString("AddChar(%1) at (c %2, r %3) INVALID win(%4,%5)")
430  .arg(dbg_char).arg(m_pen.m_column).arg(m_pen.m_row)
432  return;
433  }
434 
435  // CEA-708-D Section 7.1.4, page 30
436  // Carriage Return (CR) moves the current entry point to the beginning of the next row. If the next row is
437  // below the visible window, the window "rolls up" as defined in CEA-608-E Section 7.4. If the next row is
438  // within the visible window and contains text, the cursor is moved to the beginning of the row, but the pre-
439  // existing text is not erased.
440  if (ch.toLatin1() == 0x0D) // C0::CR
441  {
442  Scroll(m_pen.m_row + 1, 0);
443  SetChanged();
444  return;
445  }
446 
447  QMutexLocker locker(&m_lock);
448 
449  // CEA-708-D Section 7.1.4, page 30
450  // Horizontal Carriage Return (HCR) moves the current entry point to the beginning of the current row
451  // without row increment or decrement. It shall erase all text on the row.
452  if (ch.toLatin1() == 0x0E) // C0::HCR
453  {
455  for (uint c = 0; c < m_column_count; c++)
456  {
457  m_text[c + p].m_attr = m_pen.m_attr;
458  m_text[c + p].m_character = QChar(' ');
459  }
460  m_pen.m_column = 0;
462  SetChanged();
463  return;
464  }
465 
466  // Backspace
467  if (ch.toLatin1() == 0x08)
468  {
469  DecrPenLocation();
470  CC708Character& chr = GetCCChar();
471  chr.m_attr = m_pen.m_attr;
472  chr.m_character = QChar(' ');
473  SetChanged();
474  return;
475  }
476 
477  // CEA-708-D Section 7.1.4, page 30
478  // Form Feed (FF) erases all text in the window and moves the cursor to the first character position in the
479  // window (0,0).
480  if (ch.toLatin1() == 0x0c) // C0::FF
481  {
482  Clear();
483  SetPenLocation(0,0);
484  SetChanged();
485  return;
486  }
487 
488  CC708Character& chr = GetCCChar();
489  chr.m_attr = m_pen.m_attr;
490  chr.m_character = ch;
491  int c = m_pen.m_column;
492  int r = m_pen.m_row;
493  IncrPenLocation();
494  SetChanged();
495 
496  LOG(VB_VBI, LOG_DEBUG, QString("AddChar(%1) at (c %2, r %3) -> (%4,%5)")
497  .arg(dbg_char).arg(c).arg(r).arg(m_pen.m_column).arg(m_pen.m_row));
498 }
499 
500 void CC708Window::Scroll(int row, int col)
501 {
502  QMutexLocker locker(&m_lock);
503 
505  return;
506 
507  if (m_text && (k708DirBottomToTop == m_scroll_dir) &&
508  (row >= (int)m_true_row_count))
509  {
510  for (uint j = 0; j < m_true_row_count - 1; j++)
511  {
512  for (uint i = 0; i < m_true_column_count; i++)
513  m_text[(m_true_column_count * j) + i] =
514  m_text[(m_true_column_count * (j+1)) + i];
515  }
516  //uint colsz = m_true_column_count * sizeof(CC708Character);
517  //memmove(m_text, m_text + colsz, colsz * (m_true_row_count - 1));
518 
519  CC708Character tmp(*this);
520  for (uint i = 0; i < m_true_column_count; i++)
522 
524  SetChanged();
525  }
526  else
527  {
528  m_pen.m_row = row;
529  }
530  // TODO implement other 3 scroll directions...
531 
532  m_pen.m_column = col;
533 }
534 
536 {
537  // TODO: Scroll direction and up/down printing,
538  // and word wrap not handled yet...
539  int new_column = m_pen.m_column;
540  int new_row = m_pen.m_row;
541 
542  new_column += (m_print_dir == k708DirLeftToRight) ? +1 : 0;
543  new_column += (m_print_dir == k708DirRightToLeft) ? -1 : 0;
544  new_row += (m_print_dir == k708DirTopToBottom) ? +1 : 0;
545  new_row += (m_print_dir == k708DirBottomToTop) ? -1 : 0;
546 
547 #if 0
548  LOG(VB_VBI, LOG_DEBUG, QString("IncrPen dir%1: (c %2, r %3) -> (%4,%5)")
549  .arg(m_print_dir).arg(m_pen.m_column).arg(m_pen.m_row)
550  .arg(new_column).arg(new_row));
551 #endif
552 
554  {
555  // basic wrapping for l->r, r->l languages
556  if (!m_row_lock && m_column_lock && (new_column >= (int)m_true_column_count))
557  {
558  new_column = 0;
559  new_row += 1;
560  }
561  else if (!m_row_lock && m_column_lock && (new_column < 0))
562  {
563  new_column = (int)m_true_column_count - 1;
564  new_row -= 1;
565  }
566  Scroll(new_row, new_column);
567  }
568  else
569  {
570  m_pen.m_column = std::max(new_column, 0);
571  m_pen.m_row = std::max(new_row, 0);
572  }
573  // TODO implement other 2 scroll directions...
574 
576 }
577 
579 {
580  // TODO: Scroll direction and up/down printing,
581  // and word wrap not handled yet...
582  int new_column = m_pen.m_column;
583  int new_row = m_pen.m_row;
584 
585  new_column -= (m_print_dir == k708DirLeftToRight) ? +1 : 0;
586  new_column -= (m_print_dir == k708DirRightToLeft) ? -1 : 0;
587  new_row -= (m_print_dir == k708DirTopToBottom) ? +1 : 0;
588  new_row -= (m_print_dir == k708DirBottomToTop) ? -1 : 0;
589 
590 #if 0
591  LOG(VB_VBI, LOG_DEBUG, QString("DecrPen dir%1: (c %2, r %3) -> (%4,%5)")
592  .arg(m_print_dir).arg(m_pen.m_column).arg(m_pen.m_row)
593  .arg(new_column).arg(new_row));
594 #endif
595 
597  {
598  // basic wrapping for l->r, r->l languages
599  if (!m_row_lock && m_column_lock && (new_column >= (int)m_true_column_count))
600  {
601  new_column = 0;
602  new_row += 1;
603  }
604  else if (!m_row_lock && m_column_lock && (new_column < 0))
605  {
606  new_column = (int)m_true_column_count - 1;
607  new_row -= 1;
608  }
609  Scroll(new_row, new_column);
610  }
611  else
612  {
613  m_pen.m_column = std::max(new_column, 0);
614  m_pen.m_row = std::max(new_row, 0);
615  }
616  // TODO implement other 2 scroll directions...
617 
619 }
620 
622 {
623  //Clear current row in case we are reseting Pen Location.
624  LOG(VB_VBI,
625  LOG_DEBUG,
626  QString("SetPenLocation nr %1 nc %2 rc %3 cc %4 tr %5 tc %6").arg(row)
627  .arg(column).arg(m_row_count).arg(m_column_count).arg(m_true_row_count)
628  .arg(m_true_column_count));
629  if(0 == row)
630  {
631  Scroll(m_true_row_count, column);
632  m_pen.m_row = row;
633  }
634  else
635  {
636  Scroll(row, column);
637  }
639 }
640 
642 {
643  // basic limiting
644  uint max_col = std::max((int)m_true_column_count - 1, 0);
645  uint max_row = std::max((int)m_true_row_count - 1, 0);
646  m_pen.m_column = std::min(m_pen.m_column, max_col);
647  m_pen.m_row = std::min(m_pen.m_row, max_row);
648 }
649 
650 /***************************************************************************/
651 
653 {
654  static const std::array<const uint8_t,8> kStyle2Font
655  { 0, 0, 1, 2, 3, 4, 3, 4 };
656 
657  if ((style < 1) || (style > 7))
658  return;
659 
662  m_attr.m_fontTag = kStyle2Font[style];
663  m_attr.m_italics = false;
664  m_attr.m_underline = false;
665  m_attr.m_boldface = false;
666  m_attr.m_edgeType = 0;
670  m_attr.m_bgOpacity = (style<6) ?
673  m_attr.m_actualFgColor = QColor();
674 }
675 
677  : m_attr(win.m_pen.m_attr)
678 {
679 }
680 
682  const CC708CharacterAttribute &other) const
683 {
684  return ((m_penSize == other.m_penSize) &&
685  (m_offset == other.m_offset) &&
686  (m_textTag == other.m_textTag) &&
687  (m_fontTag == other.m_fontTag) &&
688  (m_edgeType == other.m_edgeType) &&
689  (m_underline == other.m_underline) &&
690  (m_italics == other.m_italics) &&
691  (m_fgColor == other.m_fgColor) &&
692  (m_fgOpacity == other.m_fgOpacity) &&
693  (m_bgColor == other.m_bgColor) &&
694  (m_bgOpacity == other.m_bgOpacity) &&
695  (m_edgeColor == other.m_edgeColor));
696 }
697 
699 {
700  // Color is expressed in 6 bits, 2 each for red, green, and blue.
701  // U.S. ATSC programs seem to use just the higher-order bit,
702  // i.e. values 0 and 2, so the last two elements of X[] are both
703  // set to the maximum 255, otherwise font colors are dim.
704  static constexpr std::array<const uint8_t,4> kX {0, 96, 255, 255};
705  return {kX[(eia708color>>4)&3], kX[(eia708color>>2)&3], kX[eia708color&3]};
706 }
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:681
CC708Window::SetPenLocation
void SetPenLocation(uint row, uint column)
Definition: cc708window.cpp:621
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:387
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:535
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:578
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:417
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:698
k708EffectWipe
const uint k708EffectWipe
Definition: cc708window.cpp:62
CC708Window::Scroll
void Scroll(int row, int col)
Definition: cc708window.cpp:500
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
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:17
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:652
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:378
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:641
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
uint
unsigned int uint
Definition: freesurround.h:24
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