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 
7 #include "captions/cc708window.h"
8 #include "mythlogging.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 [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[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  if (ch.toLatin1() == 0x0D)
434  {
435  Scroll(m_pen.m_row + 1, 0);
436  SetChanged();
437  return;
438  }
439  QMutexLocker locker(&m_lock);
440 
441  if (ch.toLatin1() == 0x08)
442  {
443  DecrPenLocation();
444  CC708Character& chr = GetCCChar();
445  chr.m_attr = m_pen.m_attr;
446  chr.m_character = QChar(' ');
447  SetChanged();
448  return;
449  }
450 
451  CC708Character& chr = GetCCChar();
452  chr.m_attr = m_pen.m_attr;
453  chr.m_character = ch;
454  int c = m_pen.m_column;
455  int r = m_pen.m_row;
456  IncrPenLocation();
457  SetChanged();
458 
459  LOG(VB_VBI, LOG_DEBUG, QString("AddChar(%1) at (c %2, r %3) -> (%4,%5)")
460  .arg(dbg_char).arg(c).arg(r).arg(m_pen.m_column).arg(m_pen.m_row));
461 }
462 
463 void CC708Window::Scroll(int row, int col)
464 {
465  QMutexLocker locker(&m_lock);
466 
468  return;
469 
470  if (m_text && (k708DirBottomToTop == m_scroll_dir) &&
471  (row >= (int)m_true_row_count))
472  {
473  for (uint j = 0; j < m_true_row_count - 1; j++)
474  {
475  for (uint i = 0; i < m_true_column_count; i++)
476  m_text[(m_true_column_count * j) + i] =
477  m_text[(m_true_column_count * (j+1)) + i];
478  }
479  //uint colsz = m_true_column_count * sizeof(CC708Character);
480  //memmove(m_text, m_text + colsz, colsz * (m_true_row_count - 1));
481 
482  CC708Character tmp(*this);
483  for (uint i = 0; i < m_true_column_count; i++)
485 
487  SetChanged();
488  }
489  else
490  {
491  m_pen.m_row = row;
492  }
493  // TODO implement other 3 scroll directions...
494 
495  m_pen.m_column = col;
496 }
497 
499 {
500  // TODO: Scroll direction and up/down printing,
501  // and word wrap not handled yet...
502  int new_column = m_pen.m_column;
503  int new_row = m_pen.m_row;
504 
505  new_column += (m_print_dir == k708DirLeftToRight) ? +1 : 0;
506  new_column += (m_print_dir == k708DirRightToLeft) ? -1 : 0;
507  new_row += (m_print_dir == k708DirTopToBottom) ? +1 : 0;
508  new_row += (m_print_dir == k708DirBottomToTop) ? -1 : 0;
509 
510 #if 0
511  LOG(VB_VBI, LOG_DEBUG, QString("IncrPen dir%1: (c %2, r %3) -> (%4,%5)")
513  .arg(new_column).arg(new_row));
514 #endif
515 
517  {
518  // basic wrapping for l->r, r->l languages
519  if (!m_row_lock && m_column_lock && (new_column >= (int)m_true_column_count))
520  {
521  new_column = 0;
522  new_row += 1;
523  }
524  else if (!m_row_lock && m_column_lock && (new_column < 0))
525  {
526  new_column = (int)m_true_column_count - 1;
527  new_row -= 1;
528  }
529  Scroll(new_row, new_column);
530  }
531  else
532  {
533  m_pen.m_column = std::max(new_column, 0);
534  m_pen.m_row = std::max(new_row, 0);
535  }
536  // TODO implement other 2 scroll directions...
537 
539 }
540 
542 {
543  // TODO: Scroll direction and up/down printing,
544  // and word wrap not handled yet...
545  int new_column = m_pen.m_column;
546  int new_row = m_pen.m_row;
547 
548  new_column -= (m_print_dir == k708DirLeftToRight) ? +1 : 0;
549  new_column -= (m_print_dir == k708DirRightToLeft) ? -1 : 0;
550  new_row -= (m_print_dir == k708DirTopToBottom) ? +1 : 0;
551  new_row -= (m_print_dir == k708DirBottomToTop) ? -1 : 0;
552 
553 #if 0
554  LOG(VB_VBI, LOG_DEBUG, QString("DecrPen dir%1: (c %2, r %3) -> (%4,%5)")
556  .arg(new_column).arg(new_row));
557 #endif
558 
560  {
561  // basic wrapping for l->r, r->l languages
562  if (!m_row_lock && m_column_lock && (new_column >= (int)m_true_column_count))
563  {
564  new_column = 0;
565  new_row += 1;
566  }
567  else if (!m_row_lock && m_column_lock && (new_column < 0))
568  {
569  new_column = (int)m_true_column_count - 1;
570  new_row -= 1;
571  }
572  Scroll(new_row, new_column);
573  }
574  else
575  {
576  m_pen.m_column = std::max(new_column, 0);
577  m_pen.m_row = std::max(new_row, 0);
578  }
579  // TODO implement other 2 scroll directions...
580 
582 }
583 
585 {
586  //Clear current row in case we are reseting Pen Location.
587  LOG(VB_VBI,
588  LOG_DEBUG,
589  QString("SetPenLocation nr %1 nc %2 rc %3 cc %4 tr %5 tc %6").arg(row)
592  if(0 == row)
593  {
594  Scroll(m_true_row_count, column);
595  m_pen.m_row = row;
596  }
597  else
598  {
599  Scroll(row, column);
600  }
602 }
603 
605 {
606  // basic limiting
607  uint max_col = std::max((int)m_true_column_count - 1, 0);
608  uint max_row = std::max((int)m_true_row_count - 1, 0);
609  m_pen.m_column = std::min(m_pen.m_column, max_col);
610  m_pen.m_row = std::min(m_pen.m_row, max_row);
611 }
612 
613 /***************************************************************************/
614 
616 {
617  static const std::array<const uint8_t,8> kStyle2Font
618  { 0, 0, 1, 2, 3, 4, 3, 4 };
619 
620  if ((style < 1) || (style > 7))
621  return;
622 
625  m_attr.m_fontTag = kStyle2Font[style];
626  m_attr.m_italics = false;
627  m_attr.m_underline = false;
628  m_attr.m_boldface = false;
629  m_attr.m_edgeType = 0;
633  m_attr.m_bgOpacity = (style<6) ?
636  m_attr.m_actualFgColor = QColor();
637 }
638 
640  : m_attr(win.m_pen.m_attr)
641 {
642 }
643 
645  const CC708CharacterAttribute &other) const
646 {
647  return ((m_penSize == other.m_penSize) &&
648  (m_offset == other.m_offset) &&
649  (m_textTag == other.m_textTag) &&
650  (m_fontTag == other.m_fontTag) &&
651  (m_edgeType == other.m_edgeType) &&
652  (m_underline == other.m_underline) &&
653  (m_italics == other.m_italics) &&
654  (m_fgColor == other.m_fgColor) &&
655  (m_fgOpacity == other.m_fgOpacity) &&
656  (m_bgColor == other.m_bgColor) &&
657  (m_bgOpacity == other.m_bgOpacity) &&
658  (m_edgeColor == other.m_edgeColor));
659 }
660 
662 {
663  // Color is expressed in 6 bits, 2 each for red, green, and blue.
664  // U.S. ATSC programs seem to use just the higher-order bit,
665  // i.e. values 0 and 2, so the last two elements of X[] are both
666  // set to the maximum 255, otherwise font colors are dim.
667  static constexpr std::array<const uint8_t,4> kX {0, 96, 255, 255};
668  return {kX[(eia708color>>4)&3], kX[(eia708color>>2)&3], kX[eia708color&3]};
669 }
CC708Window::m_text
CC708Character * m_text
Definition: cc708window.h:277
k708JustifyFull
const uint k708JustifyFull
Definition: cc708window.cpp:58
CC708Pen::m_attr
CC708CharacterAttribute m_attr
Definition: cc708window.h:168
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:260
CC708Pen::m_column
uint m_column
Definition: cc708window.h:171
CC708CharacterAttribute::operator==
bool operator==(const CC708CharacterAttribute &other) const
Definition: cc708window.cpp:644
CC708Window::SetPenLocation
void SetPenLocation(uint row, uint column)
Definition: cc708window.cpp:584
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
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:262
arg
arg(title).arg(filename).arg(doDelete))
CC708Window::m_column_lock
uint m_column_lock
Definition: cc708window.h:256
CC708CharacterAttribute
Definition: cc708window.h:84
CC708Window::m_justify
uint m_justify
Definition: cc708window.h:269
k708AttrFontCursive
const uint k708AttrFontCursive
Definition: cc708window.cpp:90
LOG
#define LOG(_MASK_, _LEVEL_, _QSTRING_)
Definition: mythlogging.h:23
CC708CharacterAttribute::m_fgOpacity
uint m_fgOpacity
Definition: cc708window.h:96
CC708Character::m_character
QChar m_character
Definition: cc708window.h:181
CC708Window::m_anchor_vertical
uint m_anchor_vertical
Definition: cc708window.h:251
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:31
CC708Window::IncrPenLocation
void IncrPenLocation(void)
Definition: cc708window.cpp:498
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:541
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:250
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:180
CC708Window::AddChar
void AddChar(QChar ch)
Definition: cc708window.cpp:415
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:661
k708EffectWipe
const uint k708EffectWipe
Definition: cc708window.cpp:62
CC708Window::Scroll
void Scroll(int row, int col)
Definition: cc708window.cpp:463
k708BorderShadowRight
const uint k708BorderShadowRight
Definition: cc708window.cpp:69
CC708Window::SetExists
void SetExists(bool value)
Definition: cc708window.h:289
CC708Window::m_effect_dir
uint m_effect_dir
Definition: cc708window.h:266
uint
unsigned int uint
Definition: compat.h:140
CC708Window::m_true_row_count
uint m_true_row_count
Definition: cc708window.h:274
CC708Window::m_fill_opacity
uint m_fill_opacity
Definition: cc708window.h:261
k708AttrSizeLarge
const uint k708AttrSizeLarge
Definition: cc708window.cpp:78
CC708Window::m_print_dir
uint m_print_dir
Definition: cc708window.h:265
CC708Window::m_border_type
uint m_border_type
Definition: cc708window.h:263
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:188
k708AttrEdgeRightDropShadow
const uint k708AttrEdgeRightDropShadow
Definition: cc708window.cpp:98
CC708Window::m_word_wrap
uint m_word_wrap
Definition: cc708window.h:270
CC708String::m_str
QString m_str
Definition: cc708window.h:189
CC708Window::SetChanged
void SetChanged(void)
Definition: cc708window.h:301
k708AttrEdgeRaised
const uint k708AttrEdgeRaised
Definition: cc708window.cpp:94
assert
#define assert(x)
Definition: audiooutputalsa.cpp:18
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:615
CC708String::m_x
uint m_x
Definition: cc708window.h:187
k708AttrFontProportionalSerif
const uint k708AttrFontProportionalSerif
Definition: cc708window.cpp:86
CC708Window::m_column_count
uint m_column_count
Definition: cc708window.h:254
k708AttrFontCasual
const uint k708AttrFontCasual
Definition: cc708window.cpp:89
CC708Window::m_effect_speed
uint m_effect_speed
Definition: cc708window.h:268
CC708Window::m_true_column_count
uint m_true_column_count
Definition: cc708window.h:275
CC708Window::m_display_effect
uint m_display_effect
Definition: cc708window.h:267
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:604
CC708Character::CC708Character
CC708Character()=default
CC708Window::m_scroll_dir
uint m_scroll_dir
Definition: cc708window.h:264
CC708Window::m_lock
QMutex m_lock
Definition: cc708window.h:309
CC708Pen::m_row
uint m_row
Definition: cc708window.h:170
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:190
CC708Window::m_anchor_point
uint m_anchor_point
Definition: cc708window.h:249
CC708CharacterAttribute::m_italics
bool m_italics
Definition: cc708window.h:92
CC708Window::SetVisible
void SetVisible(bool value)
Definition: cc708window.h:295
CC708Window::m_priority
uint m_priority
Definition: cc708window.h:240
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:215
k708AttrOffsetSuperscript
const uint k708AttrOffsetSuperscript
Definition: cc708window.cpp:82
CC708Window::m_row_count
uint m_row_count
Definition: cc708window.h:253
k708EffectFade
const uint k708EffectFade
Definition: cc708window.cpp:61
CC708Window::m_row_lock
uint m_row_lock
Definition: cc708window.h:255
k708AttrOpacitySolid
const uint k708AttrOpacitySolid
Definition: cc708window.cpp:103
CC708Window::m_anchor_horizontal
uint m_anchor_horizontal
Definition: cc708window.h:252
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:286
CC708Window::m_pen
CC708Pen m_pen
Definition: cc708window.h:278
k708DirRightToLeft
const uint k708DirRightToLeft
Definition: cc708window.cpp:72