← Back to branch summary

~registry/codeblocks/trunk

« back to all changes in this revision

Viewing changes to src/plugins/contrib/wxContribItems/wxled/ledpanel/src/wxledpanel.cpp

  • Committer: mortenmacfly
  • Date: 2012-02-22 14:40:26 UTC
  • Revision ID: svn-v4:98b59c6a-2706-0410-b7d6-d2fa1a1880c9:trunk:7835
* merged wxSmith branch into trunk
* this brings tons of new wxSmith items, including KWIC, wxImagePanel, wxGridBagSizer and more
* based on work of the community, mainly cryogen
* for more information, see changelog of wxSmith branch
* also, re-factoring of contributed wxWidgets items for wxSmith
* PLEASE DO A CLEAN CHECKOUT AND RE-BUILD EVERYTHING FROM SCRATCH!

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/plugins/contrib/wxContribItems/wxled/ledpanel/src/wxledpanel.cpp
 
1
/***************************************************************
 
2
 * Name:      wxledpanel.cpp
 
3
 * Purpose:   Code for Class wxLEDPanel
 
4
 * Author:    Christian Gr�fe (info@mcs-soft.de)
 
5
 * Created:   2007-02-28
 
6
 * Copyright: Christian Gr�fe (www.mcs-soft.de)
 
7
 * License:       wxWindows licence
 
8
 **************************************************************/
 
9
 
 
10
// For compilers that support precompilation, includes "wx.h".
 
11
#include "wx/wxprec.h"
 
12
 
 
13
#ifdef __BORLANDC__
 
14
#pragma hdrstop
 
15
#endif
 
16
 
 
17
#ifndef WX_PRECOMP
 
18
    #include <wx/wx.h>
 
19
#endif
 
20
 
 
21
#include <wx/dcbuffer.h>
 
22
#include "wx/wxledpanel.h"
 
23
 
 
24
#define TIMER_SCROLL_ID 1000
 
25
 
 
26
BEGIN_EVENT_TABLE(wxLEDPanel, wxControl)
 
27
        EVT_PAINT(wxLEDPanel::OnPaint)
 
28
        EVT_ERASE_BACKGROUND(wxLEDPanel::OnEraseBackground)
 
29
        EVT_TIMER(TIMER_SCROLL_ID,wxLEDPanel::OnScrollTimer)
 
30
END_EVENT_TABLE()
 
31
 
 
32
wxLEDPanel::wxLEDPanel() :
 
33
        m_align(wxALIGN_LEFT|wxALIGN_TOP),
 
34
        m_padLeft(1),
 
35
        m_padRight(1),
 
36
        m_invert(false),
 
37
        m_show_inactivs(true),
 
38
        m_scrollspeed(0),
 
39
        m_scrolldirection(wxALL),
 
40
        m_aniFrameNr(-1)
 
41
{
 
42
}
 
43
 
 
44
wxLEDPanel::wxLEDPanel(wxWindow* parent, wxWindowID id, const wxSize& ledsize,
 
45
                                        const wxSize& fieldsize, int padding, const wxPoint& pos,
 
46
                                        long style, const wxValidator& validator) :
 
47
        m_align(wxALIGN_LEFT|wxALIGN_TOP),
 
48
        m_padLeft(1),
 
49
        m_padRight(1),
 
50
        m_invert(false),
 
51
        m_show_inactivs(true),
 
52
        m_scrollspeed(0),
 
53
        m_scrolldirection(wxALL),
 
54
        m_aniFrameNr(-1)
 
55
{
 
56
        Create(parent,id,ledsize,fieldsize,padding,pos,style,validator);
 
57
}
 
58
 
 
59
wxLEDPanel::~wxLEDPanel()
 
60
{
 
61
}
 
62
 
 
63
bool wxLEDPanel::Create(wxWindow* parent, wxWindowID id, const wxSize& ledsize,
 
64
                                        const wxSize& fieldsize, int padding, const wxPoint& pos,
 
65
                                        long style, const wxValidator& validator)
 
66
{
 
67
        // save in member
 
68
        m_ledsize=ledsize;
 
69
        m_padding=padding;
 
70
        wxSize size;
 
71
        size.SetWidth((ledsize.GetWidth()+padding)*fieldsize.GetWidth()+padding);
 
72
    size.SetHeight((ledsize.GetHeight()+padding)*fieldsize.GetHeight()+padding);
 
73
 
 
74
        // create the control
 
75
        if(!wxControl::Create(parent,id,pos,size,style,validator))
 
76
                return false;
 
77
 
 
78
    // initialise MatrixObjekt
 
79
        m_field.Init(0,fieldsize.GetWidth(),fieldsize.GetHeight());
 
80
 
 
81
    // default backgroundcolor is black (call parent, to prevent the call of PrepareBackground)
 
82
        wxWindow::SetBackgroundColour(*wxBLACK);
 
83
 
 
84
        // default led-color is red
 
85
        this->SetLEDColour(wxLED_COLOUR_RED);
 
86
 
 
87
        // no Input Events
 
88
        this->Enable(false);
 
89
 
 
90
        // bind timer
 
91
        m_scrollTimer.SetOwner(this,TIMER_SCROLL_ID);
 
92
 
 
93
        return true;
 
94
}
 
95
 
 
96
wxSize wxLEDPanel::DoGetBestSize() const
 
97
{
 
98
        wxSize size;
 
99
        size.SetWidth((m_ledsize.GetWidth()+m_padding)*m_field.GetWidth()+m_padding);
 
100
    size.SetHeight((m_ledsize.GetHeight()+m_padding)*m_field.GetHeight()+m_padding);
 
101
    return size;
 
102
}
 
103
 
 
104
void wxLEDPanel::Clear()
 
105
{
 
106
    m_field.Clear();
 
107
}
 
108
 
 
109
void wxLEDPanel::Reset()
 
110
{
 
111
    SetText(m_text);
 
112
}
 
113
 
 
114
/** @return the size of the field in points */
 
115
wxSize wxLEDPanel::GetFieldsize() const
 
116
{
 
117
    return m_field.GetSize();
 
118
}
 
119
 
 
120
/** @return the size of one LED on the field */
 
121
wxSize wxLEDPanel::GetLEDSize() const
 
122
{
 
123
    return m_ledsize;
 
124
}
 
125
 
 
126
/**
 
127
* Sets the colour of the LEDs
 
128
* @param colourID the ID of the new colour
 
129
*/
 
130
void wxLEDPanel::SetLEDColour(wxLEDColour colourID)
 
131
{
 
132
        // for drawing
 
133
        wxBrush brush;
 
134
        wxPen pen;
 
135
 
 
136
        // colourID speichern
 
137
        m_activ_colour_id=colourID;
 
138
 
 
139
        int w=m_ledsize.GetWidth()+m_padding;
 
140
        int h=m_ledsize.GetHeight()+m_padding;
 
141
 
 
142
        // create Bitmaps for "LED on" und "LED off"
 
143
        wxBitmap led_on(w,h);
 
144
        wxBitmap led_off(w,h);
 
145
        wxBitmap led_none(w,h);
 
146
 
 
147
        // draw "LED on"
 
148
        m_mdc_led_on.SelectObject(led_on);
 
149
 
 
150
        // Clear Background
 
151
        m_mdc_led_on.SetBackground(this->GetBackgroundColour());
 
152
    m_mdc_led_on.Clear();
 
153
 
 
154
        // complete point
 
155
    pen.SetColour(s_colour_dark[colourID-1]);
 
156
    brush.SetColour(s_colour[colourID-1]);
 
157
    m_mdc_led_on.SetPen(pen);
 
158
    m_mdc_led_on.SetBrush(brush);
 
159
    m_mdc_led_on.DrawEllipse(wxPoint(0,0),m_ledsize);
 
160
 
 
161
        // left top corner in lighter colour
 
162
        pen.SetColour(s_colour_light[colourID-1]);
 
163
        m_mdc_led_on.SetPen(pen);
 
164
        m_mdc_led_on.DrawEllipticArc(0,0,m_ledsize.GetWidth(),m_ledsize.GetHeight(),75.0,195.0);
 
165
 
 
166
 
 
167
        // draw "LED off"
 
168
        m_mdc_led_off.SelectObject(led_off);
 
169
 
 
170
        // cleare Background
 
171
        m_mdc_led_off.SetBackground(this->GetBackgroundColour());
 
172
    m_mdc_led_off.Clear();
 
173
 
 
174
    // complete point
 
175
    pen.SetColour(s_colour_dark[colourID-1]);
 
176
    brush.SetColour(s_colour_verydark[colourID-1]);
 
177
    m_mdc_led_off.SetPen(pen);
 
178
    m_mdc_led_off.SetBrush(brush);
 
179
    m_mdc_led_off.DrawEllipse(wxPoint(0,0),m_ledsize);
 
180
 
 
181
 
 
182
    // draw "no LED"
 
183
    m_mdc_led_none.SelectObject(led_none);
 
184
        m_mdc_led_none.SetBackground(this->GetBackgroundColour());
 
185
    m_mdc_led_none.Clear();
 
186
 
 
187
 
 
188
    PrepareBackground();
 
189
}
 
190
 
 
191
/** @return the real colour of a LED */
 
192
const wxColour& wxLEDPanel::GetLEDColour() const
 
193
{
 
194
    return s_colour[m_activ_colour_id];
 
195
}
 
196
 
 
197
/** Overwritten to prepare the background with the new backgroundcolour
 
198
* @param colour the new backroundcolour
 
199
*/
 
200
bool wxLEDPanel::SetBackgroundColour(const wxColour& colour)
 
201
{
 
202
    if (wxWindow::SetBackgroundColour(colour))
 
203
    {
 
204
      PrepareBackground();
 
205
      return true;
 
206
    }
 
207
 
 
208
    return false;
 
209
}
 
210
 
 
211
/** Sets the speed for the scrolling
 
212
* @param speed the speed in ms (optimal range between 80-120)
 
213
*/
 
214
void wxLEDPanel::SetScrollSpeed(int speed)
 
215
{
 
216
        // the save way
 
217
        m_scrollTimer.Stop();
 
218
 
 
219
        // save speed
 
220
        m_scrollspeed=speed;
 
221
 
 
222
        // start timer
 
223
        if(m_scrollspeed>0 && m_scrolldirection!=wxALL)
 
224
                m_scrollTimer.Start(speed,true);
 
225
}
 
226
 
 
227
/** @return the speed of the scrolling */
 
228
int wxLEDPanel::GetScrollSpeed() const
 
229
{
 
230
    return m_scrollspeed;
 
231
}
 
232
 
 
233
/** Sets the direction to scroll
 
234
* @param d the direction (wxALL for no scrolling)
 
235
*/
 
236
void wxLEDPanel::SetScrollDirection(wxDirection d)
 
237
{
 
238
        // the save way
 
239
        m_scrollTimer.Stop();
 
240
 
 
241
        // save direction
 
242
        m_scrolldirection=d;
 
243
 
 
244
        if(m_scrollspeed>0 && m_scrolldirection!=wxALL)
 
245
                m_scrollTimer.Start(m_scrollspeed,true);
 
246
}
 
247
 
 
248
/** @return the current direction of the scrolling (wxALL for no scrolling)*/
 
249
wxDirection wxLEDPanel::GetScrollDirection() const
 
250
{
 
251
    return m_scrolldirection;
 
252
}
 
253
 
 
254
/** Swaps the LED states
 
255
* @param invert if true, all active LEDs are drawn as inactiv and all inactiv drawn as activ
 
256
*/
 
257
void wxLEDPanel::ShowInvertet(bool invert)
 
258
{
 
259
    if(m_invert==invert) return;
 
260
 
 
261
    m_invert=invert;
 
262
    PrepareBackground();
 
263
}
 
264
 
 
265
/** Should the inactive LEDs be drawn */
 
266
void wxLEDPanel::ShowInactivLEDs(bool show_inactivs)
 
267
{
 
268
    if(m_show_inactivs==show_inactivs) return;
 
269
 
 
270
    m_show_inactivs=show_inactivs;
 
271
    PrepareBackground();
 
272
}
 
273
 
 
274
void wxLEDPanel::SetContentAlign(int a)
 
275
{
 
276
        // save value
 
277
        m_align=a;
 
278
 
 
279
        // Reset the Horizontal position
 
280
        ResetPos();
 
281
 
 
282
        // Reinit the field
 
283
        m_field.Clear();
 
284
        m_field.SetDatesAt(m_pos,m_content_mo);
 
285
}
 
286
 
 
287
int wxLEDPanel::GetContentAlign() const
 
288
{
 
289
    return m_align;
 
290
}
 
291
 
 
292
void wxLEDPanel::SetText(const wxString& text, int align)
 
293
{
 
294
        // String emtpy
 
295
        if(text.IsEmpty()) return;
 
296
 
 
297
        // the MO for the Text
 
298
        MatrixObject* tmp=NULL;
 
299
 
 
300
        // save the align
 
301
        if(align!=-1) m_align=align;
 
302
 
 
303
        // save the string
 
304
        m_text=text;
 
305
        m_aniFrameNr=-1;
 
306
 
 
307
        // get the MO for the text
 
308
        if(m_align&wxALIGN_CENTER_HORIZONTAL)
 
309
                tmp=m_font.GetMOForText(text,wxALIGN_CENTER_HORIZONTAL);
 
310
        else if(m_align&wxALIGN_RIGHT)
 
311
                tmp=m_font.GetMOForText(text,wxALIGN_RIGHT);
 
312
        else tmp=m_font.GetMOForText(text);     // wxALIGN_LEFT
 
313
 
 
314
        // save the MO, and delete the tmp
 
315
        m_content_mo.Init(*tmp);
 
316
        delete tmp;
 
317
 
 
318
        // Find the place for the text
 
319
        ResetPos();
 
320
 
 
321
        // Set in field
 
322
        m_field.Clear();
 
323
        m_field.SetDatesAt(m_pos,m_content_mo);
 
324
}
 
325
 
 
326
/** @return the current text */
 
327
wxString wxLEDPanel::GetText() const
 
328
{
 
329
    return m_text;
 
330
}
 
331
 
 
332
void wxLEDPanel::SetImage(const wxImage img)
 
333
{
 
334
    if(!img.IsOk()) return;
 
335
    m_text.Empty();
 
336
 
 
337
    m_content_mo.Init(img);
 
338
    m_aniFrameNr=-1;
 
339
 
 
340
    // Find the place for the bitmap
 
341
        ResetPos();
 
342
 
 
343
        // Set in field
 
344
        m_field.Clear();
 
345
        m_field.SetDatesAt(m_pos,m_content_mo);
 
346
}
 
347
 
 
348
wxImage wxLEDPanel::GetContentAsImage() const
 
349
{
 
350
    return m_content_mo.GetAsImage();
 
351
}
 
352
 
 
353
void wxLEDPanel::SetAnimation(const wxAnimation ani)
 
354
{
 
355
    if(!ani.IsOk() || ani.GetFrameCount()==0) return;
 
356
 
 
357
    m_ani = ani;
 
358
    m_text.Empty();
 
359
    m_aniFrameNr = 0;
 
360
 
 
361
    m_content_mo.Init(ani.GetFrame(0));
 
362
 
 
363
    // Find the place for the bitmap
 
364
        ResetPos();
 
365
 
 
366
        // Set in field
 
367
        m_field.Clear();
 
368
        m_field.SetDatesAt(m_pos,m_content_mo);
 
369
 
 
370
        // start timer
 
371
        m_scrollTimer.Stop();
 
372
        m_scrollspeed = m_ani.GetDelay(0);
 
373
        m_scrollTimer.Start(m_scrollspeed,true);
 
374
}
 
375
 
 
376
const wxAnimation wxLEDPanel::GetAnimation() const
 
377
{
 
378
    return m_ani;
 
379
}
 
380
 
 
381
void wxLEDPanel::SetContentPaddingLeft(int padLeft)
 
382
{
 
383
        // Save value
 
384
        m_padLeft=padLeft;
 
385
 
 
386
        // Reset the text position
 
387
        ResetPos();
 
388
 
 
389
        // Reinit the field
 
390
        m_field.Clear();
 
391
        m_field.SetDatesAt(m_pos,m_content_mo);
 
392
}
 
393
 
 
394
int wxLEDPanel::GetContentPaddingLeft() const
 
395
{
 
396
    return m_padLeft;
 
397
}
 
398
 
 
399
void wxLEDPanel::SetContentPaddingRight(int padRight)
 
400
{
 
401
        // Save the Value
 
402
        m_padRight=padRight;
 
403
 
 
404
        // Reset the text position
 
405
        ResetPos();
 
406
 
 
407
        // Reinit the field
 
408
        m_field.Clear();
 
409
        m_field.SetDatesAt(m_pos,m_content_mo);
 
410
}
 
411
 
 
412
int wxLEDPanel::GetContentPaddingRight() const
 
413
{
 
414
    return m_padRight;
 
415
}
 
416
 
 
417
/** Sets the space between two letters
 
418
* @param leterSpace the space in points (one point = one LED)
 
419
*/
 
420
void wxLEDPanel::SetLetterSpace(int letterSpace)
 
421
{
 
422
    // is already this size?
 
423
    if(m_font.GetLetterSpace()==letterSpace) return;
 
424
 
 
425
    m_font.SetLetterSpace(letterSpace);
 
426
    Reset();
 
427
}
 
428
 
 
429
/** @return the space between two letters in points */
 
430
int wxLEDPanel::GetLetterSpace() const
 
431
{
 
432
    return m_font.GetLetterSpace();
 
433
}
 
434
 
 
435
void wxLEDPanel::SetFontType(wxLEDFontType t)
 
436
{
 
437
    if(m_font.GetFontType()==t) return;
 
438
 
 
439
    m_font.SetFontType(t);
 
440
    Reset();
 
441
}
 
442
 
 
443
wxLEDFontType wxLEDPanel::GetFontType() const
 
444
{
 
445
    return m_font.GetFontType();
 
446
}
 
447
 
 
448
/** this draws the data on the Control */
 
449
void wxLEDPanel::DrawField(wxDC& dc, bool backgroundMode)
 
450
{
 
451
        wxPoint point;
 
452
        int w=m_ledsize.GetWidth()+m_padding;
 
453
        int h=m_ledsize.GetHeight()+m_padding;
 
454
        char data;
 
455
 
 
456
        // Z�hler f�r Zeile und Spalte
 
457
    int x=0,y=0;
 
458
 
 
459
    // Pointer to avoid unnesecerie if blocks in the for block
 
460
    wxMemoryDC* p_mdc_data=((m_invert)?((m_show_inactivs)?(&m_mdc_led_off):(&m_mdc_led_none)):(&m_mdc_led_on));
 
461
    wxMemoryDC* p_mdc_nodata=((m_invert)?(&m_mdc_led_on):((m_show_inactivs)?(&m_mdc_led_off):(&m_mdc_led_none)));
 
462
 
 
463
    int l = m_field.GetLength();
 
464
    int fw = m_field.GetWidth();
 
465
    const char* field = m_field.GetData();
 
466
    for(int i=0;i<l;++i)
 
467
    {
 
468
        // Daten des Feldes
 
469
        data=field[i];
 
470
 
 
471
                // Koordinaten
 
472
        point.x=x*w+m_padding;
 
473
        point.y=y*h+m_padding;
 
474
 
 
475
        // zeichnen
 
476
        if(field[i] && !backgroundMode)
 
477
        {
 
478
            dc.Blit(point.x,point.y,w,h,p_mdc_data,0,0);
 
479
        }
 
480
        else if(backgroundMode)
 
481
        {
 
482
            dc.Blit(point.x,point.y,w,h,p_mdc_nodata,0,0);
 
483
        }
 
484
 
 
485
        // hochz�hlen
 
486
        ++x;
 
487
        if(x==fw) {++y; x=0;}
 
488
    }
 
489
}
 
490
 
 
491
/** Do nothing to avoid flicker */
 
492
void wxLEDPanel::OnEraseBackground(wxEraseEvent& event)
 
493
{
 
494
}
 
495
 
 
496
void wxLEDPanel::OnPaint(wxPaintEvent &event)
 
497
{
 
498
    wxBufferedPaintDC dc(this);
 
499
    //dc.SetBackground(this->GetBackgroundColour());
 
500
    //dc.Clear();
 
501
 
 
502
    // background
 
503
    dc.Blit(0,0,m_mdc_background.GetSize().GetWidth(),m_mdc_background.GetSize().GetHeight(),&m_mdc_background,0,0);
 
504
    // field
 
505
    DrawField(dc);
 
506
}
 
507
 
 
508
void wxLEDPanel::ShiftLeft()
 
509
{
 
510
        // new text Pos
 
511
        m_pos.x--;
 
512
 
 
513
        // out of bound
 
514
        if(m_pos.x+m_content_mo.GetWidth()<=0)
 
515
        {
 
516
                m_pos.x=m_field.GetWidth();
 
517
                return;
 
518
        }
 
519
 
 
520
        // Shift
 
521
        m_field.ShiftLeft();
 
522
 
 
523
        // TODO check bounds!
 
524
        // data for the new line
 
525
        for(int i=0;i<m_content_mo.GetHeight();++i)
 
526
        {
 
527
                char d=m_content_mo.GetDataFrom(abs(m_pos.x-m_field.GetWidth()+1),i);
 
528
                if(d>0) m_field.SetDataAt(m_field.GetWidth()-1,m_pos.y+i,d);
 
529
        }
 
530
}
 
531
 
 
532
void wxLEDPanel::ShiftRight()
 
533
{
 
534
        // new text Pos
 
535
        m_pos.x++;
 
536
        // out of bound
 
537
        if(m_pos.x>=m_field.GetWidth())
 
538
        {
 
539
                m_pos.x=-m_content_mo.GetWidth();       // TODO without +1 error (in SetDatesAt??)
 
540
                return;
 
541
        }
 
542
 
 
543
        // Shift
 
544
        m_field.ShiftRight();
 
545
 
 
546
        // TODO check bounds!
 
547
        // TODO at first run -> false y-pos!
 
548
        // data for the new line
 
549
        for(int i=0;i<m_content_mo.GetHeight();++i)
 
550
        {
 
551
                char d=m_content_mo.GetDataFrom(abs(m_pos.x-m_field.GetWidth()+1),i);
 
552
                if(d>0) m_field.SetDataAt(0,m_pos.y+i,d);
 
553
        }
 
554
}
 
555
 
 
556
void wxLEDPanel::ShiftUp()
 
557
{
 
558
        // new text Pos
 
559
        m_pos.y--;
 
560
        // out of bound
 
561
        if(m_pos.y+m_content_mo.GetHeight()<=0)
 
562
                m_pos.y=m_field.GetHeight();
 
563
 
 
564
        // TODO optimize with shift
 
565
        m_field.Clear();
 
566
        m_field.SetDatesAt(m_pos,m_content_mo);
 
567
}
 
568
 
 
569
void wxLEDPanel::ShiftDown()
 
570
{
 
571
        // new text Pos
 
572
        m_pos.y++;
 
573
        // out of bound
 
574
        if(m_pos.y>=m_field.GetHeight())
 
575
                m_pos.y=-m_content_mo.GetHeight();
 
576
 
 
577
        // TODO optimize with shift
 
578
        m_field.Clear();
 
579
        m_field.SetDatesAt(m_pos,m_content_mo);
 
580
 
 
581
}
 
582
 
 
583
void wxLEDPanel::OnScrollTimer(wxTimerEvent& event)
 
584
{
 
585
        if(m_scrollspeed==0||m_content_mo.IsEmpty()) return;
 
586
 
 
587
        // the save way
 
588
        m_scrollTimer.Stop();
 
589
 
 
590
    if(m_aniFrameNr < 0)
 
591
    {
 
592
 
 
593
        // Scroll
 
594
        switch(m_scrolldirection)
 
595
        {
 
596
            case wxALL: return;
 
597
            case wxLEFT: this->ShiftLeft(); break;
 
598
            case wxRIGHT: this->ShiftRight(); break;
 
599
            case wxDOWN: this->ShiftDown(); break;
 
600
            case wxUP: this->ShiftUp(); break;
 
601
            default: return;
 
602
        }
 
603
    }
 
604
    else
 
605
    {
 
606
        m_aniFrameNr++;
 
607
        if(m_aniFrameNr >= m_ani.GetFrameCount())
 
608
            m_aniFrameNr=0;
 
609
 
 
610
        m_content_mo.Init(m_ani.GetFrame(m_aniFrameNr));
 
611
        m_field.Clear();
 
612
        m_field.SetDatesAt(m_pos,m_content_mo);
 
613
        m_scrollspeed = m_ani.GetDelay(m_aniFrameNr);
 
614
    }
 
615
 
 
616
        // Repaint
 
617
        this->Refresh();
 
618
 
 
619
        // start timer again
 
620
        m_scrollTimer.Start(m_scrollspeed,true);
 
621
}
 
622
 
 
623
/** Resets the position of the content after scrolling */
 
624
void wxLEDPanel::ResetPos()
 
625
{
 
626
        // has a text?
 
627
        if(m_content_mo.GetData()==NULL) return;
 
628
 
 
629
        // horizontal text pos
 
630
        if(m_scrolldirection!=wxLEFT && m_scrolldirection!=wxRIGHT)
 
631
        {
 
632
                if(m_align & wxALIGN_RIGHT)
 
633
                        m_pos.x=m_field.GetWidth()-m_content_mo.GetWidth()-m_padRight;
 
634
                else if(m_align & wxALIGN_CENTER_HORIZONTAL)
 
635
                        m_pos.x=(m_field.GetWidth()-m_content_mo.GetWidth())/2;
 
636
                else // wxALING_LEFT
 
637
                        m_pos.x=m_padLeft;
 
638
        }
 
639
        else if(m_scrolldirection==wxLEFT)
 
640
                m_pos.x=m_field.GetWidth();
 
641
        else if(m_scrolldirection==wxRIGHT)
 
642
                m_pos.x=-m_content_mo.GetWidth();
 
643
 
 
644
        // vertical text pos
 
645
        if(m_scrolldirection!=wxUP && m_scrolldirection!=wxDOWN)
 
646
        {
 
647
                if(m_align & wxALIGN_BOTTOM)
 
648
                        m_pos.y=m_field.GetHeight()-m_content_mo.GetHeight();
 
649
                else if(m_align & wxALIGN_CENTER_VERTICAL)
 
650
                        m_pos.y=(m_field.GetHeight()-m_content_mo.GetHeight())/2;
 
651
                else // wxALIGN TOP
 
652
                        m_pos.y=0;
 
653
        }
 
654
        else if(m_scrolldirection==wxUP)
 
655
                m_pos.y=m_field.GetHeight();
 
656
        else if(m_scrolldirection==wxDOWN)
 
657
                m_pos.y=-m_content_mo.GetHeight();
 
658
}
 
659
 
 
660
/** Prepares the backgroundimage, to optimze speed */
 
661
void wxLEDPanel::PrepareBackground()
 
662
{
 
663
    wxSize s=DoGetBestSize();
 
664
    wxBitmap bmpBG(s.GetWidth(),s.GetHeight());
 
665
 
 
666
    m_mdc_background.SelectObject(bmpBG);
 
667
 
 
668
    // clear the background
 
669
    m_mdc_background.SetBackground(this->GetBackgroundColour());
 
670
    m_mdc_background.Clear();
 
671
 
 
672
    if(m_invert || m_show_inactivs)
 
673
        DrawField(m_mdc_background, true);
 
674
}
 
675
 
 
676
// Red, Green, Blue, Yellow, Magenta, Cyan, Grey
 
677
const wxColour wxLEDPanel::s_colour[7]=
 
678
        {       wxColour(255,0,0), wxColour(0,255,0), wxColour(0,0,255),
 
679
                wxColour(255,255,0), wxColour(255,0,255), wxColour(0,255,255),
 
680
                wxColour(128,128,128) };
 
681
 
 
682
const wxColour wxLEDPanel::s_colour_dark[7]=
 
683
        {       wxColour(128,0,0), wxColour(0,128,0), wxColour(0,0,128),
 
684
                wxColour(128,128,0), wxColour(128,0,128), wxColour(0,128,128),
 
685
                wxColour(64,64,64) };
 
686
 
 
687
const wxColour wxLEDPanel::s_colour_verydark[7]=
 
688
        {       wxColour(64,0,0), wxColour(0,64,0), wxColour(0,0,64),
 
689
                wxColour(64,64,0), wxColour(64,0,64), wxColour(0,64,64),
 
690
                wxColour(32,32,32) };
 
691
 
 
692
const wxColour wxLEDPanel::s_colour_light[7]=
 
693
        {       wxColour(255,128,128), wxColour(128,255,128), wxColour(128,128,255),
 
694
                wxColour(255,255,128), wxColour(255,128,255), wxColour(128,255,255),
 
695
                wxColour(192,192,192) };