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