-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathpin.diff
1529 lines (1507 loc) · 77.7 KB
/
pin.diff
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
diff -Nur vdr-1.7.35.orig/device.c vdr-1.7.35/device.c
--- vdr-1.7.35.orig/device.c 2013-01-06 15:58:43.337883780 +0100
+++ vdr-1.7.35/device.c 2013-01-06 16:02:54.891139559 +0100
@@ -776,6 +776,7 @@
cChannel *channel;
while ((channel = Channels.GetByNumber(n, Direction)) != NULL) {
// try only channels which are currently available
+ if (!cStatus::MsgChannelProtected(0, channel)) // PIN PATCH
if (GetDevice(channel, LIVEPRIORITY, true, true))
break;
n = channel->Number() + Direction;
@@ -797,6 +798,12 @@
eSetChannelResult cDevice::SetChannel(const cChannel *Channel, bool LiveView)
{
+ // I hope 'LiveView = false' indicates a channel switch for recording, // PIN PATCH
+ // I really don't know, but it works ... // PIN PATCH
+
+ if (LiveView && cStatus::MsgChannelProtected(this, Channel)) // PIN PATCH
+ return scrNotAvailable; // PIN PATCH
+
cStatus::MsgChannelSwitch(this, 0, LiveView);
if (LiveView) {
diff -Nur vdr-1.7.35.orig/menu.c vdr-1.7.35/menu.c
--- vdr-1.7.35.orig/menu.c 2013-01-06 15:54:59.851117859 +0100
+++ vdr-1.7.35/menu.c 2013-01-06 16:02:54.891139559 +0100
@@ -911,6 +911,16 @@
Add(new cMenuEditBitItem( tr("VPS"), &data.flags, tfVps));
Add(new cMenuEditIntItem( tr("Priority"), &data.priority, 0, MAXPRIORITY));
Add(new cMenuEditIntItem( tr("Lifetime"), &data.lifetime, 0, MAXLIFETIME));
+
+ // PIN PATCH
+ if (cOsd::pinValid || !data.fskProtection) Add(new cMenuEditBoolItem(tr("Childlock"),&data.fskProtection));
+ else {
+ char* buf = 0;
+ asprintf(&buf, "%s\t%s", tr("Childlock"), data.fskProtection ? tr("yes") : tr("no"));
+ Add(new cOsdItem(buf));
+ free(buf);
+ }
+
Add(file = new cMenuEditStrItem( tr("File"), data.file, sizeof(data.file)));
SetFirstDayItem();
}
@@ -2626,7 +2636,10 @@
for (cRecording *recording = Recordings.First(); recording; recording = Recordings.Next(recording)) {
if (!base || (strstr(recording->Name(), base) == recording->Name() && recording->Name()[strlen(base)] == FOLDERDELIMCHAR)) {
cMenuRecordingItem *Item = new cMenuRecordingItem(recording, level);
- if (*Item->Text() && (!Item->IsDirectory() || (!LastItem || !LastItem->IsDirectory() || strcmp(Item->Text(), LastItemText) != 0))) {
+
+ if (*Item->Text() && (!Item->IsDirectory() || (!LastItem || !LastItem->IsDirectory() || strcmp(Item->Text(), LastItemText) != 0))
+ && (!cStatus::MsgReplayProtected(Item->Recording(), Item->Name(), base,
+ Item->IsDirectory(), true))) { // PIN PATCH
Add(Item);
LastItem = Item;
free(LastItemText);
@@ -2678,6 +2691,9 @@
{
cMenuRecordingItem *ri = (cMenuRecordingItem *)Get(Current());
if (ri) {
+ if (cStatus::MsgReplayProtected(ri->Recording(), ri->Name(), base,
+ ri->IsDirectory()) == true) // PIN PATCH
+ return osContinue; // PIN PATCH
if (ri->IsDirectory())
Open();
else {
@@ -3794,28 +3810,32 @@
// Basic menu items:
- Add(new cOsdItem(hk(tr("Schedule")), osSchedule));
- Add(new cOsdItem(hk(tr("Channels")), osChannels));
- Add(new cOsdItem(hk(tr("Timers")), osTimers));
- Add(new cOsdItem(hk(tr("Recordings")), osRecordings));
+ // PIN PATCH
+ if (!cStatus::MsgMenuItemProtected("Schedule", true)) Add(new cOsdItem(hk(tr("Schedule")), osSchedule));
+ if (!cStatus::MsgMenuItemProtected("Channels", true)) Add(new cOsdItem(hk(tr("Channels")), osChannels));
+ if (!cStatus::MsgMenuItemProtected("Timers", true)) Add(new cOsdItem(hk(tr("Timers")), osTimers));
+ if (!cStatus::MsgMenuItemProtected("Recordings", true)) Add(new cOsdItem(hk(tr("Recordings")), osRecordings));
// Plugins:
for (int i = 0; ; i++) {
cPlugin *p = cPluginManager::GetPlugin(i);
if (p) {
+ if (!cStatus::MsgPluginProtected(p, true)) { // PIN PATCH
const char *item = p->MainMenuEntry();
if (item)
Add(new cMenuPluginItem(hk(item), i));
}
+ }
else
break;
}
// More basic menu items:
- Add(new cOsdItem(hk(tr("Setup")), osSetup));
+ if (!cStatus::MsgMenuItemProtected("Setup", true)) Add(new cOsdItem(hk(tr("Setup")), osSetup)); // PIN PATCH
if (Commands.Count())
+ if (!cStatus::MsgMenuItemProtected("Commands", true)) // PIN PATCH
Add(new cOsdItem(hk(tr("Commands")), osCommands));
}
@@ -3899,6 +3919,14 @@
eOSState state = cOsdMenu::ProcessKey(Key);
HadSubMenu |= HasSubMenu();
+ // > PIN PATCH
+ cOsdItem* item = Get(Current());
+
+ if (item && item->Text() && state != osContinue && state != osUnknown && state != osBack)
+ if (cStatus::MsgMenuItemProtected(item->Text()))
+ return osContinue;
+ // PIN PATCH <
+
cOsdObject *menu = NULL;
switch (state) {
case osSchedule:
@@ -3951,6 +3979,7 @@
if (item) {
cPlugin *p = cPluginManager::GetPlugin(item->PluginIndex());
if (p) {
+ if (!cStatus::MsgPluginProtected(p)) { // PIN PATCH
cOsdObject *menu = p->MainMenuAction();
if (menu) {
if (menu->IsMenu())
@@ -3962,6 +3991,7 @@
}
}
}
+ }
state = osEnd;
}
break;
@@ -4173,6 +4203,7 @@
Channel = Direction > 0 ? Channels.Next(Channel) : Channels.Prev(Channel);
if (!Channel && Setup.ChannelsWrap)
Channel = Direction > 0 ? Channels.First() : Channels.Last();
+ if (!cStatus::MsgChannelProtected(0, Channel)) // PIN PATCH
if (Channel && !Channel->GroupSep() && cDevice::GetDevice(Channel, LIVEPRIORITY, true, true))
return Channel;
}
@@ -4866,6 +4897,7 @@
for (int i = 0; i < MAXRECORDCONTROLS; i++) {
if (!RecordControls[i]) {
RecordControls[i] = new cRecordControl(device, Timer, Pause);
+ cStatus::MsgRecordingFile(RecordControls[i]->FileName()); // PIN PATCH
return RecordControls[i]->Process(time(NULL));
}
}
diff -Nur vdr-1.7.35.orig/menu.c.orig vdr-1.7.35/menu.c.orig
--- vdr-1.7.35.orig/menu.c.orig 2013-01-06 15:47:15.617845736 +0100
+++ vdr-1.7.35/menu.c.orig 2013-01-06 15:54:59.851117859 +0100
@@ -35,6 +35,8 @@
#include "videodir.h"
#include "menuorgpatch.h"
+#include "remotetimers.h"
+
#define MAXWAIT4EPGINFO 3 // seconds
#define MODETIMEOUT 3 // seconds
#define NEWTIMERLIMIT 120 // seconds until the start time of a new timer created from the Schedule menu,
@@ -4786,6 +4788,50 @@
bool cRecordControls::Start(cTimer *Timer, bool Pause)
{
+ if (!Timer) {
+ cTimer *t = new cTimer(true, Pause);
+
+ //get event
+ cSchedulesLock SchedulesLock;
+ const cEvent *event = NULL;;
+ const cSchedules *Schedules = cSchedules::Schedules(SchedulesLock);
+ if (Schedules) {
+ const cSchedule *Schedule = Schedules->GetSchedule(t->Channel());
+ if (Schedule) {
+ event = Schedule->GetEventAround(t->StartTime() + INSTANT_REC_EPG_LOOKAHEAD);
+ }
+ }
+
+ if (cPluginManager::GetPlugin("timersync")) {
+ // sets the file name
+ cRecording recording(t, event);
+ Timers.Add(t);
+ Timers.SetModified();
+ if (!cReplayControl::LastReplayed())
+ cReplayControl::SetRecording(recording.FileName());
+ return true;
+ }
+ else {
+ RemoteTimers_InstantRecording_v1_0 ir;
+ ir.timer = t;
+ ir.pause = Pause;
+ ir.event = event;
+ ir.name = NULL;
+ ir.fileName = NULL;
+
+ if (cPluginManager::CallFirstService("RemoteTimers::InstantRecording-v1.0", &ir)) {
+ if (!cReplayControl::LastReplayed())
+ cReplayControl::SetRecording(ir.fileName);
+ delete t;
+ // empty names indicate an error
+ return *ir.fileName && *ir.name;
+ }
+ // service disabled or an error occured and the user confirmed local recording
+ // fall through to local instant recording
+ }
+ delete t;
+ }
+
static time_t LastNoDiskSpaceMessage = 0;
int FreeMB = 0;
if (Timer) {
diff -Nur vdr-1.7.35.orig/osd.c vdr-1.7.35/osd.c
--- vdr-1.7.35.orig/osd.c 2012-12-15 12:16:41.000000000 +0100
+++ vdr-1.7.35/osd.c 2013-01-06 16:02:54.894474006 +0100
@@ -1623,6 +1623,7 @@
int cOsd::osdHeight = 0;
cVector<cOsd *> cOsd::Osds;
cMutex cOsd::mutex;
+bool cOsd::pinValid = false; // PIN PATCH
cOsd::cOsd(int Left, int Top, uint Level)
{
diff -Nur vdr-1.7.35.orig/osd.h vdr-1.7.35/osd.h
--- vdr-1.7.35.orig/osd.h 2012-12-03 14:49:02.000000000 +0100
+++ vdr-1.7.35/osd.h 2013-01-06 16:04:52.294542041 +0100
@@ -931,6 +931,7 @@
///< MyOsdDrawPixmap(Left() + pm->ViewPort().X(), Top() + pm->ViewPort().Y(), pm->Data(), w, h, h * d);
///< delete pm;
///< }
+ static bool pinValid; // PIN PATCH
};
#define MAXOSDIMAGES 64
diff -Nur vdr-1.7.35.orig/osd.h.orig vdr-1.7.35/osd.h.orig
--- vdr-1.7.35.orig/osd.h.orig 1970-01-01 01:00:00.000000000 +0100
+++ vdr-1.7.35/osd.h.orig 2013-01-06 16:02:54.894474006 +0100
@@ -0,0 +1,1028 @@
+/*
+ * osd.h: Abstract On Screen Display layer
+ *
+ * See the main source file 'vdr.c' for copyright information and
+ * how to reach the author.
+ *
+ * $Id: osd.h 2.18 2012/12/03 13:49:02 kls Exp $
+ */
+
+#ifndef __OSD_H
+#define __OSD_H
+
+#include <limits.h>
+#include <stdio.h>
+#include <stdint.h>
+#include "config.h"
+#include "font.h"
+#include "thread.h"
+#include "tools.h"
+
+#define OSD_LEVEL_DEFAULT 0
+#define OSD_LEVEL_SUBTITLES 10
+
+#define MAXNUMCOLORS 256
+#define ALPHA_TRANSPARENT 0x00
+#define ALPHA_OPAQUE 0xFF
+#define IS_OPAQUE(c) ((c >> 24) == ALPHA_OPAQUE)
+#define TEXT_ALIGN_BORDER 10 // fraction of the font height used for sizing border
+
+enum {
+ //AARRGGBB
+ clrTransparent = 0x00000000,
+ clrGray50 = 0x7F000000, // 50% gray
+ clrBlack = 0xFF000000,
+ clrRed = 0xFFFC1414,
+ clrGreen = 0xFF24FC24,
+ clrYellow = 0xFFFCC024,
+ clrMagenta = 0xFFB000FC,
+ clrBlue = 0xFF0000FC,
+ clrCyan = 0xFF00FCFC,
+ clrWhite = 0xFFFCFCFC,
+ };
+
+enum eOsdError { oeOk, // see also OsdErrorTexts in osd.c
+ oeTooManyAreas,
+ oeTooManyColors,
+ oeBppNotSupported,
+ oeAreasOverlap,
+ oeWrongAlignment,
+ oeOutOfMemory,
+ oeWrongAreaSize,
+ oeUnknown,
+ };
+
+typedef uint32_t tColor; // see also font.h
+typedef uint8_t tIndex;
+
+inline tColor ArgbToColor(uint8_t A, uint8_t R, uint8_t G, uint8_t B)
+{
+ return (tColor(A) << 24) | (tColor(R) << 16) | (tColor(G) << 8) | B;
+}
+
+inline tColor RgbToColor(uint8_t R, uint8_t G, uint8_t B)
+{
+ return (tColor(R) << 16) | (tColor(G) << 8) | B;
+}
+
+inline tColor RgbToColor(double R, double G, double B)
+{
+ return RgbToColor(uint8_t(0xFF * R), uint8_t(0xFF * G), uint8_t(0xFF * B));
+}
+
+tColor RgbShade(tColor Color, double Factor);
+ ///< Returns a brighter (Factor > 0) or darker (Factor < 0) version
+ ///< of the given Color.
+ ///< If Factor is 0.0, the return value is the unchanged Color,
+ ///< If Factor is 1.0, white is returned.
+ ///< If Factor is -1.0, black is returned.
+ ///< The alpha value of Color is returned unchanged.
+
+tColor HsvToColor(double H, double S, double V);
+ ///< Converts the given Hue (0..360), Saturation (0..1) and Value (0..1)
+ ///< to an RGB tColor value. The alpha value of the result is 0x00, so
+ ///< the caller may need to set it accordingly.
+
+tColor AlphaBlend(tColor ColorFg, tColor ColorBg, uint8_t AlphaLayer = ALPHA_OPAQUE);
+
+class cPalette {
+private:
+ tColor color[MAXNUMCOLORS];
+ int bpp;
+ int maxColors, numColors;
+ bool modified;
+ double antiAliasGranularity;
+protected:
+ typedef tIndex tIndexes[MAXNUMCOLORS];
+public:
+ cPalette(int Bpp = 8);
+ ///< Initializes the palette with the given color depth.
+ virtual ~cPalette();
+ void SetAntiAliasGranularity(uint FixedColors, uint BlendColors);
+ ///< Allows the system to optimize utilization of the limited color
+ ///< palette entries when generating blended colors for anti-aliasing.
+ ///< FixedColors is the maximum number of colors used, and BlendColors
+ ///< is the maximum number of foreground/background color combinations
+ ///< used with anti-aliasing. If this function is not called with
+ ///< useful values, the palette may be filled up with many shades of
+ ///< a single color combination, and may not be able to serve all
+ ///< requested colors. By default the palette assumes there will be
+ ///< 10 fixed colors and 10 color combinations.
+ int Bpp(void) const { return bpp; }
+ void Reset(void);
+ ///< Resets the palette, making it contain no colors.
+ int Index(tColor Color);
+ ///< Returns the index of the given Color (the first color has index 0).
+ ///< If Color is not yet contained in this palette, it will be added if
+ ///< there is a free slot. If the color can't be added to this palette,
+ ///< the closest existing color will be returned.
+ tColor Color(int Index) const { return Index < maxColors ? color[Index] : 0; }
+ ///< Returns the color at the given Index. If Index is outside the valid
+ ///< range, 0 will be returned.
+ void SetBpp(int Bpp);
+ ///< Sets the color depth of this palette to the given value.
+ ///< The palette contents will be reset, so that it contains no colors.
+ void SetColor(int Index, tColor Color);
+ ///< Sets the palette entry at Index to Color. If Index is larger than
+ ///< the number of currently used entries in this palette, the entries
+ ///< in between will have undefined values.
+ const tColor *Colors(int &NumColors) const;
+ ///< Returns a pointer to the complete color table and stores the
+ ///< number of valid entries in NumColors. If no colors have been
+ ///< stored yet, NumColors will be set to 0 and the function will
+ ///< return NULL.
+ void Take(const cPalette &Palette, tIndexes *Indexes = NULL, tColor ColorFg = 0, tColor ColorBg = 0);
+ ///< Takes the colors from the given Palette and adds them to this palette,
+ ///< using existing entries if possible. If Indexes is given, it will be
+ ///< filled with the index values that each color of Palette has in this
+ ///< palette. If either of ColorFg or ColorBg is not zero, the first color
+ ///< in Palette will be taken as ColorBg, and the second color will become
+ ///< ColorFg.
+ void Replace(const cPalette &Palette);
+ ///< Replaces the colors of this palette with the colors from the given
+ ///< palette.
+ tColor Blend(tColor ColorFg, tColor ColorBg, uint8_t Level) const;
+ ///< Determines a color that consists of a linear blend between ColorFg
+ ///< and ColorBg. If Level is 0, the result is ColorBg, if it is 255,
+ ///< the result is ColorFg. If SetAntiAliasGranularity() has been called previously,
+ ///< Level will be mapped to a limited range of levels that allow to make best
+ ///< use of the palette entries.
+ int ClosestColor(tColor Color, int MaxDiff = INT_MAX) const;
+ ///< Returns the index of a color in this palette that is closest to the given
+ ///< Color. MaxDiff can be used to control the maximum allowed color difference.
+ ///< If no color with a maximum difference of MaxDiff can be found, -1 will
+ ///< be returned. With the default value of INT_MAX, there will always be
+ ///< a valid color index returned, but the color may be completely different.
+ };
+
+enum eTextAlignment { taCenter = 0x00,
+ taLeft = 0x01,
+ taRight = 0x02,
+ taTop = 0x04,
+ taBottom = 0x08,
+ taBorder = 0x10, // keeps some distance from the left or right alignment edge
+ taDefault = taTop | taLeft
+ };
+
+class cFont;
+
+class cBitmap : public cPalette {
+private:
+ tIndex *bitmap;
+ int x0, y0;
+ int width, height;
+ int dirtyX1, dirtyY1, dirtyX2, dirtyY2;
+public:
+ cBitmap(int Width, int Height, int Bpp, int X0 = 0, int Y0 = 0);
+ ///< Creates a bitmap with the given Width, Height and color depth (Bpp).
+ ///< X0 and Y0 define the offset at which this bitmap will be located on the OSD.
+ ///< All coordinates given in the other functions will be relative to
+ ///< this offset (unless specified otherwise).
+ cBitmap(const char *FileName);
+ ///< Creates a bitmap and loads an XPM image from the given file.
+ cBitmap(const char *const Xpm[]);
+ ///< Creates a bitmap from the given XPM data.
+ virtual ~cBitmap();
+ int X0(void) const { return x0; }
+ int Y0(void) const { return y0; }
+ int Width(void) const { return width; }
+ int Height(void) const { return height; }
+ void SetSize(int Width, int Height);
+ ///< Sets the size of this bitmap to the given values. Any previous
+ ///< contents of the bitmap will be lost. If Width and Height are the same
+ ///< as the current values, nothing will happen and the bitmap remains
+ ///< unchanged.
+ bool Contains(int x, int y) const;
+ ///< Returns true if this bitmap contains the point (x, y).
+ bool Covers(int x1, int y1, int x2, int y2) const;
+ ///< Returns true if the rectangle defined by the given coordinates
+ ///< completely covers this bitmap.
+ bool Intersects(int x1, int y1, int x2, int y2) const;
+ ///< Returns true if the rectangle defined by the given coordinates
+ ///< intersects with this bitmap.
+ bool Dirty(int &x1, int &y1, int &x2, int &y2);
+ ///< Tells whether there is a dirty area and returns the bounding
+ ///< rectangle of that area (relative to the bitmaps origin).
+ void Clean(void);
+ ///< Marks the dirty area as clean.
+ bool LoadXpm(const char *FileName);
+ ///< Calls SetXpm() with the data from the file FileName.
+ ///< Returns true if the operation was successful.
+ bool SetXpm(const char *const Xpm[], bool IgnoreNone = false);
+ ///< Sets this bitmap to the given XPM data. Any previous bitmap or
+ ///< palette data will be overwritten with the new data.
+ ///< If IgnoreNone is true, a "none" color entry will be ignored.
+ ///< Only set IgnoreNone to true if you know that there is a "none"
+ ///< color entry in the XPM data and that this entry is not used!
+ ///< If SetXpm() is called with IgnoreNone set to false and the XPM
+ ///< data contains an unused "none" entry, it will be automatically
+ ///< called again with IgnoreNone set to true.
+ ///< Returns true if the operation was successful.
+ void SetIndex(int x, int y, tIndex Index);
+ ///< Sets the index at the given coordinates to Index.
+ ///< Coordinates are relative to the bitmap's origin.
+ void DrawPixel(int x, int y, tColor Color);
+ ///< Sets the pixel at the given coordinates to the given Color, which is
+ ///< a full 32 bit ARGB value.
+ ///< If the coordinates are outside the bitmap area, no pixel will be set.
+ void DrawBitmap(int x, int y, const cBitmap &Bitmap, tColor ColorFg = 0, tColor ColorBg = 0, bool ReplacePalette = false, bool Overlay = false);
+ ///< Sets the pixels in this bitmap with the data from the given
+ ///< Bitmap, putting the upper left corner of the Bitmap at (x, y).
+ ///< If ColorFg or ColorBg is given, the first palette entry of the Bitmap
+ ///< will be mapped to ColorBg and the second palette entry will be mapped to
+ ///< ColorFg (palette indexes are defined so that 0 is the background and
+ ///< 1 is the foreground color). ReplacePalette controls whether the target
+ ///< area shall have its palette replaced with the one from Bitmap.
+ ///< If Overlay is true, any pixel in Bitmap that has color index 0 will
+ ///< not overwrite the corresponding pixel in the target area.
+ void DrawText(int x, int y, const char *s, tColor ColorFg, tColor ColorBg, const cFont *Font, int Width = 0, int Height = 0, int Alignment = taDefault);
+ ///< Draws the given string at coordinates (x, y) with the given foreground
+ ///< and background color and font. If Width and Height are given, the text
+ ///< will be drawn into a rectangle with the given size and the given
+ ///< Alignment (default is top-left). If ColorBg is clrTransparent, no
+ ///< background pixels will be drawn, which allows drawing "transparent" text.
+ void DrawRectangle(int x1, int y1, int x2, int y2, tColor Color);
+ ///< Draws a filled rectangle defined by the upper left (x1, y1) and lower right
+ ///< (x2, y2) corners with the given Color. If the rectangle covers the entire
+ ///< bitmap area, the color palette will be reset, so that new colors can be
+ ///< used for drawing.
+ void DrawEllipse(int x1, int y1, int x2, int y2, tColor Color, int Quadrants = 0);
+ ///< Draws a filled ellipse defined by the upper left (x1, y1) and lower right
+ ///< (x2, y2) corners with the given Color. Quadrants controls which parts of
+ ///< the ellipse are actually drawn:
+ ///< 0 draws the entire ellipse
+ ///< 1..4 draws only the first, second, third or fourth quadrant, respectively
+ ///< 5..8 draws the right, top, left or bottom half, respectively
+ ///< -1..-8 draws the inverted part of the given quadrant(s)
+ ///< If Quadrants is not 0, the coordinates are those of the actual area, not
+ ///< the full circle!
+ void DrawSlope(int x1, int y1, int x2, int y2, tColor Color, int Type);
+ ///< Draws a "slope" into the rectangle defined by the upper left (x1, y1) and
+ ///< lower right (x2, y2) corners with the given Color. Type controls the
+ ///< direction of the slope and which side of it will be drawn:
+ ///< 0: horizontal, rising, lower
+ ///< 1: horizontal, rising, upper
+ ///< 2: horizontal, falling, lower
+ ///< 3: horizontal, falling, upper
+ ///< 4: vertical, rising, lower
+ ///< 5: vertical, rising, upper
+ ///< 6: vertical, falling, lower
+ ///< 7: vertical, falling, upper
+ const tIndex *Data(int x, int y) const;
+ ///< Returns the address of the index byte at the given coordinates.
+ tColor GetColor(int x, int y) const { return Color(*Data(x, y)); }
+ ///< Returns the color at the given coordinates.
+ void ReduceBpp(const cPalette &Palette);
+ ///< Reduces the color depth of the bitmap to that of the given Palette.
+ ///< If Palette's color depth is not smaller than the bitmap's current
+ ///< color depth, or if it is not one of 4bpp or 2bpp, nothing happens. After
+ ///< reducing the color depth the current palette is replaced with
+ ///< the given one.
+ void ShrinkBpp(int NewBpp);
+ ///< Shrinks the color depth of the bitmap to NewBpp by keeping only
+ ///< the 2^NewBpp most frequently used colors as defined in the current palette.
+ ///< If NewBpp is not smaller than the bitmap's current color depth,
+ ///< or if it is not one of 4bpp or 2bpp, nothing happens.
+ cBitmap *Scaled(double FactorX, double FactorY, bool AntiAlias = false);
+ ///< Creates a copy of this bitmap, scaled by the given factors.
+ ///< If AntiAlias is true and either of the factors is greater than 1.0,
+ ///< anti-aliasing is applied. This will also set the color depth of the
+ ///< returned bitmap to 8bpp.
+ ///< The caller must delete the returned bitmap once it is no longer used.
+ };
+
+struct tArea {
+ int x1, y1, x2, y2;
+ int bpp;
+ int Width(void) const { return x2 - x1 + 1; }
+ int Height(void) const { return y2 - y1 + 1; }
+ bool Intersects(const tArea &Area) const { return !(x2 < Area.x1 || x1 > Area.x2 || y2 < Area.y1 || y1 > Area.y2); }
+ };
+
+class cPoint {
+private:
+ int x;
+ int y;
+public:
+ cPoint(void) { x = y = 0; }
+ cPoint(int X, int Y) { x = X; y = Y; }
+ cPoint(const cPoint &Point) { x = Point.X(); y = Point.Y(); }
+ bool operator==(const cPoint &Point) const { return x == Point.X() && y == Point.Y(); }
+ bool operator!=(const cPoint &Point) const { return !(*this == Point); }
+ cPoint operator-(void) const { return cPoint(-x, -y); }
+ cPoint operator-(const cPoint &Point) const { return cPoint(x - Point.X(), y - Point.Y()); }
+ int X(void) const { return x; }
+ int Y(void) const { return y; }
+ void SetX(int X) { x = X; }
+ void SetY(int Y) { y = Y; }
+ void Set(int X, int Y) { x = X; y = Y; }
+ void Set(const cPoint &Point) { x = Point.X(); y = Point.Y(); }
+ void Shift(int Dx, int Dy) { x += Dx; y += Dy; }
+ void Shift(const cPoint &Dp) { x += Dp.X(); y += Dp.Y(); }
+ cPoint Shifted(int Dx, int Dy) const { cPoint p(*this); p.Shift(Dx, Dy); return p; }
+ cPoint Shifted(const cPoint &Dp) const { cPoint p(*this); p.Shift(Dp); return p; }
+ };
+
+class cSize {
+private:
+ int width;
+ int height;
+public:
+ cSize(void) { width = height = 0; }
+ cSize(int Width, int Height) { width = Width; height = Height; }
+ cSize(const cSize &Size) { width = Size.Width(); height = Size.Height(); }
+ bool operator==(const cSize &Size) const { return width == Size.Width() && height == Size.Height(); }
+ bool operator!=(const cSize &Size) const { return !(*this == Size); }
+ bool operator<(const cSize &Size) const { return width < Size.Width() && height < Size.Height(); }
+ int Width(void) const { return width; }
+ int Height(void) const { return height; }
+ void SetWidth(int Width) { width = Width; }
+ void SetHeight(int Height) { height = Height; }
+ void Set(int Width, int Height) { width = Width; height = Height; }
+ void Set(const cSize &Size) { width = Size.Width(); height = Size.Height(); }
+ bool Contains(const cPoint &Point) const { return 0 <= Point.X() && 0 <= Point.Y() && Point.X() < width && Point.Y() < height; }
+ void Grow(int Dw, int Dh) { width += 2 * Dw; height += 2 * Dh; }
+ cSize Grown(int Dw, int Dh) const { cSize s(*this); s.Grow(Dw, Dh); return s; }
+ };
+
+class cRect {
+private:
+ cPoint point;
+ cSize size;
+public:
+ static const cRect Null;
+ cRect(void): point(0, 0), size(0, 0) {}
+ cRect(int X, int Y, int Width, int Height): point(X, Y), size(Width, Height) {}
+ cRect(const cPoint &Point, const cSize &Size): point(Point), size(Size) {}
+ cRect(const cSize &Size): point(0, 0), size(Size) {}
+ cRect(const cRect &Rect): point(Rect.Point()), size(Rect.Size()) {}
+ bool operator==(const cRect &Rect) const { return point == Rect.Point() && size == Rect.Size(); }
+ bool operator!=(const cRect &Rect) const { return !(*this == Rect); }
+ int X(void) const { return point.X(); }
+ int Y(void) const { return point.Y(); }
+ int Width(void) const { return size.Width(); }
+ int Height(void) const { return size.Height(); }
+ int Left(void) const { return X(); }
+ int Top(void) const { return Y(); }
+ int Right(void) const { return X() + Width() - 1; }
+ int Bottom(void) const { return Y() + Height() - 1; }
+ const cPoint &Point(void) const { return point; }
+ const cSize &Size(void) const { return size; }
+ void Set(int X, int Y, int Width, int Height) { point.Set(X, Y); size.Set(Width, Height); }
+ void Set(cPoint Point, cSize Size) { point.Set(Point); size.Set(Size); }
+ void SetPoint(int X, int Y) { point.Set(X, Y); }
+ void SetPoint(const cPoint &Point) { point.Set(Point); }
+ void SetSize(int Width, int Height) { size.Set(Width, Height); }
+ void SetSize(const cSize &Size) { size.Set(Size); }
+ void SetX(int X) { point.SetX(X); }
+ void SetY(int Y) { point.SetY(Y); }
+ void SetWidth(int Width) { size.SetWidth(Width); }
+ void SetHeight(int Height) { size.SetHeight(Height); }
+ void SetLeft(int Left) { SetWidth(Width() + X() - Left); SetX(Left); }
+ void SetTop(int Top) { SetHeight(Height() + Y() - Top); SetY(Top); }
+ void SetRight(int Right) { SetWidth(Right - X() + 1); }
+ void SetBottom(int Bottom) { SetHeight(Bottom - Y() + 1); }
+ void Shift(int Dx, int Dy) { point.Shift(Dx, Dy); }
+ void Shift(const cPoint &Dp) { point.Shift(Dp); }
+ cRect Shifted(int Dx, int Dy) const { cRect r(*this); r.Shift(Dx, Dy); return r; }
+ cRect Shifted(const cPoint &Dp) const { cRect r(*this); r.Shift(Dp); return r; }
+ void Grow(int Dx, int Dy);
+ ///< Grows the rectangle by the given number of pixels in either direction.
+ ///< A negative value will shrink the rectangle.
+ cRect Grown(int Dw, int Dh) const { cRect r(*this); r.Grow(Dw, Dh); return r; }
+ bool Contains(const cPoint &Point) const;
+ ///< Returns true if this rectangle contains Point.
+ bool Contains(const cRect &Rect) const;
+ ///< Returns true if this rectangle completely contains Rect.
+ bool Intersects(const cRect &Rect) const;
+ ///< Returns true if this rectangle intersects with Rect.
+ cRect Intersected(const cRect &Rect) const;
+ ///< Returns the intersection of this rectangle and the given Rect.
+ void Combine(const cRect &Rect);
+ ///< Combines this rectangle with the given Rect.
+ cRect Combined(const cRect &Rect) const { cRect r(*this); r.Combine(Rect); return r; }
+ ///< Returns the surrounding rectangle that contains this rectangle and the
+ ///< given Rect.
+ void Combine(const cPoint &Point);
+ ///< Combines this rectangle with the given Point.
+ cRect Combined(const cPoint &Point) const { cRect r(*this); r.Combine(Point); return r; }
+ ///< Returns the surrounding rectangle that contains this rectangle and the
+ ///< given Point.
+ bool IsEmpty(void) const { return Width() <= 0 || Height() <= 0; }
+ ///< Returns true if this rectangle is empty.
+ };
+
+class cImage {
+private:
+ cSize size;
+ tColor *data;
+public:
+ cImage(void);
+ cImage(const cImage &Image);
+ cImage(const cSize &Size, const tColor *Data = NULL);
+ ///< Creates an image with the given Size and allocates the necessary memory
+ ///< to copy the pixels pointed to by Data, which is a sequence of
+ ///< (Size.Width() * Size.Height()) tColor values.
+ ///< If Data is NULL, the allocated memory is not initialized.
+ ///< The alpha value of the Image's pixels is taken into account, so it has to be
+ ///< greater than 0 for the image to be visible.
+ virtual ~cImage();
+ const cSize &Size(void) const { return size; }
+ int Width(void) const { return size.Width(); }
+ int Height(void) const { return size.Height(); }
+ const tColor *Data(void) const { return data; }
+ tColor GetPixel(const cPoint &Point) const { return data[size.Width() * Point.Y() + Point.X()]; }
+ ///< Returns the pixel value at the given Point.
+ ///< For performance reasons there is no range check here, so the caller
+ ///< must make sure that the Point is within the images size.
+ void SetPixel(const cPoint &Point, tColor Color) { data[size.Width() * Point.Y() + Point.X()] = Color; }
+ ///< Sets the pixel at the given Point to Color.
+ ///< For performance reasons there is no range check here, so the caller
+ ///< must make sure that the Point is within the images size.
+ void Clear(void);
+ ///< Clears the image data by setting all pixels to be fully transparent.
+ void Fill(tColor Color);
+ ///< Fills the image data with the given Color.
+ };
+
+#define MAXPIXMAPLAYERS 8
+
+class cPixmap {
+ friend class cOsd;
+ friend class cPixmapMutexLock;
+private:
+ static cMutex mutex;
+ int layer;
+ int alpha;
+ bool tile;
+ cRect viewPort;
+ cRect drawPort;
+ cRect dirtyViewPort;
+ cRect dirtyDrawPort;
+protected:
+ virtual ~cPixmap() {}
+ void MarkViewPortDirty(const cRect &Rect);
+ ///< Marks the given rectangle of the view port of this pixmap as dirty.
+ ///< Rect is combined with the existing dirtyViewPort rectangle.
+ ///< The coordinates of Rect are given in absolute OSD values.
+ void MarkViewPortDirty(const cPoint &Point);
+ ///< Marks the given point of the view port of this pixmap as dirty.
+ ///< Point is combined with the existing dirtyViewPort rectangle.
+ ///< The coordinates of Point are given in absolute OSD values.
+ void MarkDrawPortDirty(const cRect &Rect);
+ ///< Marks the given rectangle of the draw port of this pixmap as dirty.
+ ///< Rect is combined with the existing dirtyDrawPort rectangle.
+ ///< The coordinates of Rect are relative to the pixmap's draw port.
+ ///< If Rect extends into the currently visible view port of this pixmap,
+ ///< MarkViewPortDirty() is called with the appropriate value.
+ void MarkDrawPortDirty(const cPoint &Point);
+ ///< Marks the given point of the draw port of this pixmap as dirty.
+ ///< Point is combined with the existing dirtyDrawPort rectangle.
+ ///< The coordinates of Point are relative to the pixmap's draw port.
+ ///< If Point is within the currently visible view port of this pixmap,
+ ///< MarkViewPortDirty() is called with the appropriate value.
+ void SetClean(void);
+ ///< Resets the "dirty" rectangles of this pixmap.
+ virtual void DrawPixmap(const cPixmap *Pixmap, const cRect &Dirty);
+ ///< Draws the Dirty part of the given Pixmap into this pixmap. If the
+ ///< Pixmap's layer is 0, it is copied, otherwise it is rendered into this
+ ///< pixmap. This function is used only to implement the tile handling
+ ///< in the final rendering to the OSD.
+public:
+ cPixmap(void);
+ cPixmap(int Layer, const cRect &ViewPort, const cRect &DrawPort = cRect::Null);
+ ///< Creates a pixmap in the given Layer. When rendering the final OSD, pixmaps
+ ///< are handled in ascending order of their individual layer. This is
+ ///< important if pixmaps overlap each other. The one with the highest layer is
+ ///< rendered last. The actual value of Layer doesn't matter, it is only used
+ ///< for defining the rendering sequence. If Layer is less than zero, this
+ ///< pixmap will not be rendered into the final OSD (it can be activated by a
+ ///< later call to SetLayer()). The value 0 is reserved for the background
+ ///< pixmap and shall not be used otherwise (with the sole exception of
+ ///< temporarily using layer 0 to have a text with transparent background
+ ///< rendered with alpha blending into that pixmap; see also DrawPixel()).
+ ///< If there are several pixmaps with the same value of Layer, their rendering
+ ///< sequence within that layer is undefined.
+ ///< In order to allow devices that can handle only a limited number of layers,
+ ///< the Layer parameter must be less than 8 (MAXPIXMAPLAYERS).
+ ///< ViewPort defines the rectangle in which this pixmap will be rendered on
+ ///< the OSD. If no DrawPort is given, it defaults to the same size as the
+ ///< ViewPort, with its upper left corner set to (0, 0).
+ ///< All drawing operations will be executed relative to the origin of the
+ ///< DrawPort rectangle, and will be clipped to the size of this rectangle.
+ ///< The DrawPort may have a different size than the ViewPort. If it is smaller
+ ///< than the ViewPort, the rest of the ViewPort is treated as fully transparent
+ ///< (unless this is a tiled pixmap, in which case the DrawPort is repeated
+ ///< horizontally and vertically to fill the entire ViewPort). If the DrawPort
+ ///< is larger than the ViewPort, only that portion of the DrawPort that
+ ///< intersects with the ViewPort will be visible on the OSD.
+ ///< The drawing area of a newly created cPixmap is not initialized and may
+ ///< contain random data.
+ static void Lock(void) { mutex.Lock(); }
+ ///< All public member functions of cPixmap set locks as necessary to make sure
+ ///< they are thread-safe (unless noted otherwise). If several cPixmap member
+ ///< functions need to be called in a row, the caller must surround these calls
+ ///< with proper Lock()/Unlock() calls. See the LOCK_PIXMAPS macro for a
+ ///< convenient way of doing this.
+ static void Unlock(void) { mutex.Unlock(); }
+ int Layer(void) const { return layer; }
+ int Alpha(void) const { return alpha; }
+ bool Tile(void) const { return tile; }
+ const cRect &ViewPort(void) const { return viewPort; }
+ ///< Returns the pixmap's view port, which is relative to the OSD's origin.
+ ///< Since this function returns a reference to a data member, the caller must
+ ///< use Lock()/Unlock() to make sure the data doesn't change while it is used.
+ const cRect &DrawPort(void) const { return drawPort; }
+ ///< Returns the pixmap's draw port, which is relative to the view port.
+ ///< Since this function returns a reference to a data member, the caller must
+ ///< use Lock()/Unlock() to make sure the data doesn't change while it is used.
+ const cRect &DirtyViewPort(void) const { return dirtyViewPort; }
+ ///< Returns the "dirty" rectangle this pixmap causes on the OSD. This is the
+ ///< surrounding rectangle around all pixels that have been modified since the
+ ///< last time this pixmap has been rendered to the OSD. The rectangle is
+ ///< relative to the OSD's origin.
+ ///< Since this function returns a reference to a data member, the caller must
+ ///< use Lock()/Unlock() to make sure the data doesn't change while it is used.
+ const cRect &DirtyDrawPort(void) const { return dirtyDrawPort; }
+ ///< Returns the "dirty" rectangle in the draw port of this this pixmap. This is
+ ///< the surrounding rectangle around all pixels that have been modified since the
+ ///< last time this pixmap has been rendered to the OSD. The rectangle is
+ ///< relative to the draw port's origin.
+ ///< Since this function returns a reference to a data member, the caller must
+ ///< use Lock()/Unlock() to make sure the data doesn't change while it is used.
+ virtual void SetLayer(int Layer);
+ ///< Sets the layer of this pixmap to the given value.
+ ///< If the new layer is greater than zero, the pixmap will be visible.
+ ///< If it is less than zero, it will be invisible.
+ ///< A value of 0 will be silently ignored.
+ ///< If a derived class reimplements this function, it needs to call the base
+ ///< class function.
+ virtual void SetAlpha(int Alpha);
+ ///< Sets the alpha value of this pixmap to the given value.
+ ///< Alpha is limited to the range 0 (fully transparent) to 255 (fully opaque).
+ ///< If a derived class reimplements this function, it needs to call the base
+ ///< class function.
+ virtual void SetTile(bool Tile);
+ ///< Sets the tile property of this pixmap to the given value. If Tile is true,
+ ///< the pixmaps data will be repeated horizontally and vertically if necessary
+ ///< to fill the entire view port.
+ ///< If a derived class reimplements this function, it needs to call the base
+ ///< class function.
+ virtual void SetViewPort(const cRect &Rect);
+ ///< Sets the pixmap's view port to the given Rect.
+ ///< If a derived class reimplements this function, it needs to call the base
+ ///< class function.
+ virtual void SetDrawPortPoint(const cPoint &Point, bool Dirty = true);
+ ///< Sets the pixmap's draw port to the given Point.
+ ///< Only the origin point of the draw port can be modified, its size is fixed.
+ ///< By default, setting a new draw port point results in marking the relevant
+ ///< part of the view port as "dirty". If Dirty is set to false, the view port
+ ///< will not be marked as dirty. This is mainly used to implement the Pan()
+ ///< function.
+ ///< If a derived class reimplements this function, it needs to call the base
+ ///< class function.
+ virtual void Clear(void) = 0;
+ ///< Clears the pixmap's draw port by setting all pixels to be fully transparent.
+ ///< A derived class must call Lock()/Unlock().
+ virtual void Fill(tColor Color) = 0;
+ ///< Fills the pixmap's draw port with the given Color.
+ ///< A derived class must call Lock()/Unlock().
+ virtual void DrawImage(const cPoint &Point, const cImage &Image) = 0;
+ ///< Draws the given Image into this pixmap at the given Point.
+ virtual void DrawImage(const cPoint &Point, int ImageHandle) = 0;
+ ///< Draws the image referenced by the given ImageHandle into this pixmap at
+ ///< the given Point. ImageHandle must be a value that has previously been
+ ///< returned by a call to cOsdProvider::StoreImage(). If ImageHandle
+ ///< has an invalid value, nothing happens.
+ virtual void DrawPixel(const cPoint &Point, tColor Color) = 0;
+ ///< Sets the pixel at the given Point to the given Color, which is
+ ///< a full 32 bit ARGB value. If the alpha value of Color is not 0xFF
+ ///< (fully opaque), and this is the background pixmap (layer 0), the pixel is
+ ///< alpha blended with the existing color at the given position in this pixmap.
+ virtual void DrawBitmap(const cPoint &Point, const cBitmap &Bitmap, tColor ColorFg = 0, tColor ColorBg = 0, bool Overlay = false) = 0;
+ ///< Sets the pixels in the OSD with the data from the given
+ ///< Bitmap, putting the upper left corner of the Bitmap at Point.
+ ///< If ColorFg or ColorBg is given, the first palette entry of the Bitmap
+ ///< will be mapped to ColorBg and the second palette entry will be mapped to
+ ///< ColorFg (palette indexes are defined so that 0 is the background and
+ ///< 1 is the foreground color).
+ ///< If Overlay is true, any pixel in Bitmap that has color index 0 will
+ ///< not overwrite the corresponding pixel in the target area.
+ ///< This function is mainly for compatibility with skins or plugins that
+ ///< draw bitmaps onto the OSD.
+ virtual void DrawText(const cPoint &Point, const char *s, tColor ColorFg, tColor ColorBg, const cFont *Font, int Width = 0, int Height = 0, int Alignment = taDefault) = 0;
+ ///< Draws the given string at Point with the given foreground
+ ///< and background color and font. If Width and Height are given, the text
+ ///< will be drawn into a rectangle with the given size and the given
+ ///< Alignment (default is top-left). If ColorBg is clrTransparent, no
+ ///< background pixels will be drawn, which allows drawing "transparent" text.
+ virtual void DrawRectangle(const cRect &Rect, tColor Color) = 0;
+ ///< Draws a filled rectangle with the given Color.
+ virtual void DrawEllipse(const cRect &Rect, tColor Color, int Quadrants = 0) = 0;
+ ///< Draws a filled ellipse with the given Color that fits into the given
+ ///< rectangle. Quadrants controls which parts of the ellipse are actually drawn:
+ ///< 0 draws the entire ellipse
+ ///< 1..4 draws only the first, second, third or fourth quadrant, respectively
+ ///< 5..8 draws the right, top, left or bottom half, respectively
+ ///< -1..-8 draws the inverted part of the given quadrant(s)
+ ///< If Quadrants is not 0, the coordinates are those of the actual area, not
+ ///< the full circle!
+ virtual void DrawSlope(const cRect &Rect, tColor Color, int Type) = 0;
+ ///< Draws a "slope" with the given Color into the given rectangle.
+ ///< Type controls the direction of the slope and which side of it will be drawn:
+ ///< 0: horizontal, rising, lower
+ ///< 1: horizontal, rising, upper
+ ///< 2: horizontal, falling, lower
+ ///< 3: horizontal, falling, upper
+ ///< 4: vertical, rising, lower
+ ///< 5: vertical, rising, upper
+ ///< 6: vertical, falling, lower
+ ///< 7: vertical, falling, upper
+ virtual void Render(const cPixmap *Pixmap, const cRect &Source, const cPoint &Dest) = 0;
+ ///< Renders the part of the given Pixmap covered by Source into this pixmap at
+ ///< location Dest. The Source rectangle is relative to the given Pixmap's draw port.
+ ///< The Pixmap's alpha value is to be used when rendering.
+ virtual void Copy(const cPixmap *Pixmap, const cRect &Source, const cPoint &Dest) = 0;
+ ///< Copies the part of the given Pixmap covered by Source into this pixmap at
+ ///< location Dest. The Source rectangle is relative to the given Pixmap's draw port.
+ ///< The data from Pixmap is copied as is, no alpha handling of any kind takes
+ ///< place.
+ virtual void Scroll(const cPoint &Dest, const cRect &Source = cRect::Null) = 0;
+ ///< Scrolls the data in the pixmap's draw port to the given Dest point.
+ ///< If Source is given, only the data within that rectangle is scrolled.
+ ///< Source and Dest are relative to this pixmap's draw port.
+ virtual void Pan(const cPoint &Dest, const cRect &Source = cRect::Null) = 0;
+ ///< Does the same as Scroll(), but also shifts the draw port accordingly,
+ ///< so that the view port doesn't get dirty if the scrolled rectangle
+ ///< covers the entire view port. This may be of advantage if, e.g.,
+ ///< there is a draw port that holds, say, 11 lines of text, while the
+ ///< view port displays only 10 lines. By Pan()'ing the draw port up one
+ ///< line, an new bottom line can be written into the draw port (without
+ ///< being seen through the view port), and later the draw port can be
+ ///< shifted smoothly, resulting in a smooth scrolling.
+ ///< It is the caller's responsibility to make sure that Source and Dest
+ ///< are given in such a way that the view port will not get dirty. No
+ ///< check is done whether this condition actually holds true.
+ };
+
+class cPixmapMutexLock : public cMutexLock {
+public:
+ cPixmapMutexLock(void): cMutexLock(&cPixmap::mutex) {}
+ };
+
+#define LOCK_PIXMAPS cPixmapMutexLock PixmapMutexLock
+
+// cPixmapMemory is an implementation of cPixmap that uses an array of tColor
+// values to store the pixmap.
+
+class cPixmapMemory : public cPixmap {
+private:
+ tColor *data;
+ bool panning;
+public:
+ cPixmapMemory(void);
+ cPixmapMemory(int Layer, const cRect &ViewPort, const cRect &DrawPort = cRect::Null);
+ virtual ~cPixmapMemory();
+ const uint8_t *Data(void) { return (uint8_t *)data; }
+ virtual void Clear(void);
+ virtual void Fill(tColor Color);
+ virtual void DrawImage(const cPoint &Point, const cImage &Image);
+ virtual void DrawImage(const cPoint &Point, int ImageHandle);
+ virtual void DrawPixel(const cPoint &Point, tColor Color);
+ virtual void DrawBitmap(const cPoint &Point, const cBitmap &Bitmap, tColor ColorFg = 0, tColor ColorBg = 0, bool Overlay = false);
+ virtual void DrawText(const cPoint &Point, const char *s, tColor ColorFg, tColor ColorBg, const cFont *Font, int Width = 0, int Height = 0, int Alignment = taDefault);
+ virtual void DrawRectangle(const cRect &Rect, tColor Color);
+ virtual void DrawEllipse(const cRect &Rect, tColor Color, int Quadrants = 0);
+ virtual void DrawSlope(const cRect &Rect, tColor Color, int Type);
+ virtual void Render(const cPixmap *Pixmap, const cRect &Source, const cPoint &Dest);
+ virtual void Copy(const cPixmap *Pixmap, const cRect &Source, const cPoint &Dest);
+ virtual void Scroll(const cPoint &Dest, const cRect &Source = cRect::Null);
+ virtual void Pan(const cPoint &Dest, const cRect &Source = cRect::Null);
+ };
+
+#define MAXOSDAREAS 16
+#define MAXOSDPIXMAPS 64
+
+/// The cOsd class is the interface to the "On Screen Display".
+/// An actual output device needs to derive from this class and implement
+/// the functionality necessary to display the OSD on the TV screen.
+/// If the actual OSD supports "True Color", it can either let VDR do
+/// all the rendering by calling RenderPixmaps() ("raw mode"), or it can
+/// reimplement all necessary cPixmap functions and do the rendering
+/// itself ("high level mode").
+/// If an OSD provides a "high level mode", it shall also provide a "raw mode"
+/// in order to verify proper operation. The plugin that implements the OSD
+/// shall offer a configuration switch in its setup.
+
+class cOsd {
+ friend class cOsdProvider;
+private:
+ static int osdLeft, osdTop, osdWidth, osdHeight;
+ static cVector<cOsd *> Osds;
+ static cMutex mutex;
+ bool isTrueColor;
+ cBitmap *savedBitmap;
+ cBitmap *bitmaps[MAXOSDAREAS];
+ int numBitmaps;
+ cPixmapMemory *savedPixmap;
+ cPixmap *pixmaps[MAXOSDPIXMAPS];
+ int numPixmaps;
+ int left, top, width, height;
+ uint level;
+ bool active;
+protected:
+ cOsd(int Left, int Top, uint Level);
+ ///< Initializes the OSD with the given coordinates.
+ ///< By default it is assumed that the full area will be able to display
+ ///< full 32 bit graphics (ARGB with eight bit for each color and the alpha
+ ///< value, respectively). However, the actual hardware in use may not be
+ ///< able to display such a high resolution OSD, so there is an option to
+ ///< divide the full OSD area into several sub-areas with lower color depths
+ ///< and individual palettes. The sub-areas need not necessarily cover the
+ ///< entire OSD area, but only the OSD area actually covered by sub-areas
+ ///< will be available for drawing.
+ ///< At least one area must be defined in order to set the actual width and
+ ///< height of the OSD. Also, the caller must first try to use an area that
+ ///< consists of only one sub-area that covers the entire drawing space,
+ ///< and should require only the minimum necessary color depth. This is
+ ///< because a derived cOsd class may or may not be able to handle more
+ ///< than one area.
+ ///< There can be any number of cOsd objects at the same time, but only
+ ///< one of them will be active at any given time. The active OSD is the
+ ///< one with the lowest value of Level. If there are several cOsd objects
+ ///< with the same Level, the one that was created first will be active.
+ bool Active(void) { return active; }
+ virtual void SetActive(bool On) { active = On; }
+ ///< Sets this OSD to be the active one.
+ ///< A derived class must call cOsd::SetActive(On).
+ const cPixmap * const *Pixmaps(void) { return pixmaps; }
+ ///< Returns the list of currently active pixmaps in this OSD.
+ int NumPixmaps(void) { return numPixmaps; }