← Back to branch summary

~ubuntu-dev/wxwidgets2.6/upstream-debian

« back to all changes in this revision

Viewing changes to contrib/src/deprecated/tbarsmpl.cpp

  • Committer: Daniel T Chen
  • Date: 2006-06-26 10:15:11 UTC
  • Revision ID: crimsun@ubuntu.com-20060626101511-a4436cec4c6d9b35
Import Debian 2.6.3.2.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
contrib/src/deprecated/tbarsmpl.cpp
 
1
/////////////////////////////////////////////////////////////////////////////
 
2
// Name:        contrib/src/deprecated//tbarsmpl.cpp
 
3
// Purpose:     wxToolBarSimple
 
4
// Author:      Julian Smart
 
5
// Modified by: VZ on 14.12.99 during wxToolBarSimple reorganization
 
6
// Created:     04/01/98
 
7
// RCS-ID:      $Id: tbarsmpl.cpp,v 1.4 2004/09/27 19:24:45 ABX Exp $
 
8
// Copyright:   (c) Julian Smart
 
9
// Licence:     wxWindows licence
 
10
/////////////////////////////////////////////////////////////////////////////
 
11
 
 
12
// ============================================================================
 
13
// declarations
 
14
// ============================================================================
 
15
 
 
16
// ----------------------------------------------------------------------------
 
17
// headers
 
18
// ----------------------------------------------------------------------------
 
19
 
 
20
#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
 
21
    #pragma implementation "tbarsmpl.h"
 
22
#endif
 
23
 
 
24
// For compilers that support precompilation, includes "wx.h".
 
25
#include "wx/wxprec.h"
 
26
 
 
27
#ifdef __BORLANDC__
 
28
    #pragma hdrstop
 
29
#endif
 
30
 
 
31
#if wxUSE_TOOLBAR && wxUSE_TOOLBAR_SIMPLE
 
32
 
 
33
#ifndef WX_PRECOMP
 
34
    #include "wx/settings.h"
 
35
    #include "wx/window.h"
 
36
    #include "wx/dcclient.h"
 
37
    #include "wx/dcmemory.h"
 
38
#endif
 
39
 
 
40
#include "wx/toolbar.h"
 
41
#include "wx/deprecated/tbarsmpl.h"
 
42
 
 
43
// ----------------------------------------------------------------------------
 
44
// private classes
 
45
// ----------------------------------------------------------------------------
 
46
 
 
47
class WXDLLIMPEXP_DEPRECATED wxToolBarToolSimple : public wxToolBarToolBase
 
48
{
 
49
public:
 
50
    wxToolBarToolSimple(wxToolBarSimple *tbar,
 
51
                        int id,
 
52
                        const wxString& label,
 
53
                        const wxBitmap& bmpNormal,
 
54
                        const wxBitmap& bmpDisabled,
 
55
                        wxItemKind kind,
 
56
                        wxObject *clientData,
 
57
                        const wxString& shortHelp,
 
58
                        const wxString& longHelp)
 
59
        : wxToolBarToolBase(tbar, id, label, bmpNormal, bmpDisabled, kind,
 
60
                            clientData, shortHelp, longHelp)
 
61
    {
 
62
    }
 
63
 
 
64
    wxToolBarToolSimple(wxToolBarSimple *tbar, wxControl *control)
 
65
        : wxToolBarToolBase(tbar, control)
 
66
    {
 
67
    }
 
68
 
 
69
    void SetSize(const wxSize& size)
 
70
    {
 
71
        m_width = size.x;
 
72
        m_height = size.y;
 
73
    }
 
74
 
 
75
    wxCoord GetWidth() const { return m_width; }
 
76
    wxCoord GetHeight() const { return m_height; }
 
77
 
 
78
    wxCoord m_x;
 
79
    wxCoord m_y;
 
80
    wxCoord m_width;
 
81
    wxCoord m_height;
 
82
 
 
83
    DECLARE_NO_COPY_CLASS(wxToolBarToolSimple)
 
84
};
 
85
 
 
86
// ----------------------------------------------------------------------------
 
87
// wxWin macros
 
88
// ----------------------------------------------------------------------------
 
89
 
 
90
IMPLEMENT_DYNAMIC_CLASS(wxToolBarSimple, wxControl)
 
91
 
 
92
#if !wxUSE_TOOLBAR_NATIVE && !defined(__WXUNIVERSAL__)
 
93
    IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarSimple)
 
94
#endif
 
95
 
 
96
BEGIN_EVENT_TABLE(wxToolBarSimple, wxToolBarBase)
 
97
    EVT_SIZE(wxToolBarSimple::OnSize)
 
98
    EVT_SCROLL(wxToolBarSimple::OnScroll)
 
99
    EVT_PAINT(wxToolBarSimple::OnPaint)
 
100
    EVT_KILL_FOCUS(wxToolBarSimple::OnKillFocus)
 
101
    EVT_MOUSE_EVENTS(wxToolBarSimple::OnMouseEvent)
 
102
END_EVENT_TABLE()
 
103
 
 
104
// ============================================================================
 
105
// implementation
 
106
// ============================================================================
 
107
 
 
108
// ----------------------------------------------------------------------------
 
109
// tool bar tools creation
 
110
// ----------------------------------------------------------------------------
 
111
 
 
112
wxToolBarToolBase *wxToolBarSimple::CreateTool(int id,
 
113
                                               const wxString& label,
 
114
                                               const wxBitmap& bmpNormal,
 
115
                                               const wxBitmap& bmpDisabled,
 
116
                                               wxItemKind kind,
 
117
                                               wxObject *clientData,
 
118
                                               const wxString& shortHelp,
 
119
                                               const wxString& longHelp)
 
120
{
 
121
    return new wxToolBarToolSimple(this, id, label, bmpNormal, bmpDisabled,
 
122
                                   kind, clientData, shortHelp, longHelp);
 
123
}
 
124
 
 
125
wxToolBarToolBase *wxToolBarSimple::CreateTool(wxControl *control)
 
126
{
 
127
    return new wxToolBarToolSimple(this, control);
 
128
}
 
129
 
 
130
// ----------------------------------------------------------------------------
 
131
// wxToolBarSimple creation
 
132
// ----------------------------------------------------------------------------
 
133
 
 
134
void wxToolBarSimple::Init()
 
135
{
 
136
    m_currentRowsOrColumns = 0;
 
137
 
 
138
    m_lastX =
 
139
    m_lastY = 0;
 
140
 
 
141
    m_maxWidth =
 
142
    m_maxHeight = 0;
 
143
 
 
144
    m_pressedTool =
 
145
    m_currentTool = -1;
 
146
 
 
147
    m_xPos =
 
148
    m_yPos = wxDefaultCoord;
 
149
 
 
150
    m_toolPacking = 1;
 
151
    m_toolSeparation = 5;
 
152
 
 
153
    m_defaultWidth = 16;
 
154
    m_defaultHeight = 15;
 
155
 
 
156
    m_xScrollPixelsPerLine = 1;
 
157
    m_yScrollPixelsPerLine = 1;
 
158
    m_xScrollingEnabled = false;
 
159
    m_yScrollingEnabled = false;
 
160
    m_xScrollPosition = 0;
 
161
    m_yScrollPosition = 0;
 
162
    m_xScrollLines = 0;
 
163
    m_yScrollLines = 0;
 
164
    m_xScrollLinesPerPage = 0;
 
165
    m_yScrollLinesPerPage = 0;
 
166
}
 
167
 
 
168
wxToolBarToolBase *wxToolBarSimple::DoAddTool(int id,
 
169
                                              const wxString& label,
 
170
                                              const wxBitmap& bitmap,
 
171
                                              const wxBitmap& bmpDisabled,
 
172
                                              wxItemKind kind,
 
173
                                              const wxString& shortHelp,
 
174
                                              const wxString& longHelp,
 
175
                                              wxObject *clientData,
 
176
                                              wxCoord xPos,
 
177
                                              wxCoord yPos)
 
178
{
 
179
    // rememeber the position for DoInsertTool()
 
180
    m_xPos = xPos;
 
181
    m_yPos = yPos;
 
182
 
 
183
    return wxToolBarBase::DoAddTool(id, label, bitmap, bmpDisabled, kind,
 
184
                                    shortHelp, longHelp,
 
185
                                    clientData, xPos, yPos);
 
186
}
 
187
 
 
188
bool wxToolBarSimple::DoInsertTool(size_t WXUNUSED(pos),
 
189
                                   wxToolBarToolBase *toolBase)
 
190
{
 
191
    wxToolBarToolSimple *tool = (wxToolBarToolSimple *)toolBase;
 
192
 
 
193
    wxCHECK_MSG( !tool->IsControl(), false,
 
194
                 _T("generic wxToolBarSimple doesn't support controls") );
 
195
 
 
196
    tool->m_x = m_xPos;
 
197
    if ( tool->m_x == wxDefaultCoord )
 
198
        tool->m_x = m_xMargin;
 
199
 
 
200
    tool->m_y = m_yPos;
 
201
    if ( tool->m_y == wxDefaultCoord )
 
202
        tool->m_y = m_yMargin;
 
203
 
 
204
    tool->SetSize(GetToolSize());
 
205
 
 
206
    if ( tool->IsButton() )
 
207
    {
 
208
        // Calculate reasonable max size in case Layout() not called
 
209
        if ((tool->m_x + tool->GetNormalBitmap().GetWidth() + m_xMargin) > m_maxWidth)
 
210
            m_maxWidth = (wxCoord)((tool->m_x + tool->GetWidth() + m_xMargin));
 
211
 
 
212
        if ((tool->m_y + tool->GetNormalBitmap().GetHeight() + m_yMargin) > m_maxHeight)
 
213
            m_maxHeight = (wxCoord)((tool->m_y + tool->GetHeight() + m_yMargin));
 
214
    }
 
215
 
 
216
    return true;
 
217
}
 
218
 
 
219
bool wxToolBarSimple::DoDeleteTool(size_t WXUNUSED(pos),
 
220
                                   wxToolBarToolBase *tool)
 
221
{
 
222
    // VZ: didn't test whether it works, but why not...
 
223
    tool->Detach();
 
224
 
 
225
    Refresh();
 
226
 
 
227
    return true;
 
228
}
 
229
 
 
230
bool wxToolBarSimple::Create(wxWindow *parent,
 
231
                             wxWindowID id,
 
232
                             const wxPoint& pos,
 
233
                             const wxSize& size,
 
234
                             long style,
 
235
                             const wxString& name)
 
236
{
 
237
    if ( !wxWindow::Create(parent, id, pos, size, style, name) )
 
238
        return false;
 
239
 
 
240
    // Set it to grey (or other 3D face colour)
 
241
    SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));
 
242
 
 
243
    if ( GetWindowStyleFlag() & wxTB_VERTICAL )
 
244
    {
 
245
        m_lastX = 7;
 
246
        m_lastY = 3;
 
247
 
 
248
        m_maxRows = 32000;      // a lot
 
249
        m_maxCols = 1;
 
250
    }
 
251
    else
 
252
    {
 
253
        m_lastX = 3;
 
254
        m_lastY = 7;
 
255
 
 
256
        m_maxRows = 1;
 
257
        m_maxCols = 32000;      // a lot
 
258
    }
 
259
 
 
260
    SetCursor(*wxSTANDARD_CURSOR);
 
261
 
 
262
    return true;
 
263
}
 
264
 
 
265
wxToolBarSimple::~wxToolBarSimple()
 
266
{
 
267
}
 
268
 
 
269
bool wxToolBarSimple::Realize()
 
270
{
 
271
    m_currentRowsOrColumns = 0;
 
272
    m_lastX = m_xMargin;
 
273
    m_lastY = m_yMargin;
 
274
    m_maxWidth = 0;
 
275
    m_maxHeight = 0;
 
276
 
 
277
    int maxToolWidth = 0;
 
278
    int maxToolHeight = 0;
 
279
 
 
280
    // Find the maximum tool width and height
 
281
    wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
 
282
    while ( node )
 
283
    {
 
284
        wxToolBarToolSimple *tool = (wxToolBarToolSimple *)node->GetData();
 
285
        if ( tool->GetWidth() > maxToolWidth )
 
286
            maxToolWidth = tool->GetWidth();
 
287
        if (tool->GetHeight() > maxToolHeight)
 
288
            maxToolHeight = tool->GetHeight();
 
289
 
 
290
        node = node->GetNext();
 
291
    }
 
292
 
 
293
    int separatorSize = m_toolSeparation;
 
294
 
 
295
    node = m_tools.GetFirst();
 
296
    while ( node )
 
297
    {
 
298
        wxToolBarToolSimple *tool = (wxToolBarToolSimple *)node->GetData();
 
299
        if ( tool->IsSeparator() )
 
300
        {
 
301
            if ( GetWindowStyleFlag() & wxTB_HORIZONTAL )
 
302
            {
 
303
                if (m_currentRowsOrColumns >= m_maxCols)
 
304
                    m_lastY += separatorSize;
 
305
                else
 
306
                    m_lastX += separatorSize;
 
307
            }
 
308
            else
 
309
            {
 
310
                if (m_currentRowsOrColumns >= m_maxRows)
 
311
                    m_lastX += separatorSize;
 
312
                else
 
313
                    m_lastY += separatorSize;
 
314
            }
 
315
        }
 
316
        else if ( tool->IsButton() )
 
317
        {
 
318
            if ( GetWindowStyleFlag() & wxTB_HORIZONTAL )
 
319
            {
 
320
                if (m_currentRowsOrColumns >= m_maxCols)
 
321
                {
 
322
                    m_currentRowsOrColumns = 0;
 
323
                    m_lastX = m_xMargin;
 
324
                    m_lastY += maxToolHeight + m_toolPacking;
 
325
                }
 
326
                tool->m_x = (wxCoord)(m_lastX + (maxToolWidth - tool->GetWidth())/2.0);
 
327
                tool->m_y = (wxCoord)(m_lastY + (maxToolHeight - tool->GetHeight())/2.0);
 
328
 
 
329
                m_lastX += maxToolWidth + m_toolPacking;
 
330
            }
 
331
            else
 
332
            {
 
333
                if (m_currentRowsOrColumns >= m_maxRows)
 
334
                {
 
335
                    m_currentRowsOrColumns = 0;
 
336
                    m_lastX += (maxToolWidth + m_toolPacking);
 
337
                    m_lastY = m_yMargin;
 
338
                }
 
339
                tool->m_x = (wxCoord)(m_lastX + (maxToolWidth - tool->GetWidth())/2.0);
 
340
                tool->m_y = (wxCoord)(m_lastY + (maxToolHeight - tool->GetHeight())/2.0);
 
341
 
 
342
                m_lastY += maxToolHeight + m_toolPacking;
 
343
            }
 
344
            m_currentRowsOrColumns ++;
 
345
        }
 
346
        else
 
347
        {
 
348
            // TODO: support the controls
 
349
        }
 
350
 
 
351
        if (m_lastX > m_maxWidth)
 
352
            m_maxWidth = m_lastX;
 
353
        if (m_lastY > m_maxHeight)
 
354
            m_maxHeight = m_lastY;
 
355
 
 
356
        node = node->GetNext();
 
357
    }
 
358
 
 
359
    if ( GetWindowStyleFlag() & wxTB_HORIZONTAL )
 
360
        m_maxHeight += maxToolHeight;
 
361
    else
 
362
        m_maxWidth += maxToolWidth;
 
363
 
 
364
    m_maxWidth += m_xMargin;
 
365
    m_maxHeight += m_yMargin;
 
366
 
 
367
    SetSize(m_maxWidth, m_maxHeight);
 
368
 
 
369
    return true;
 
370
}
 
371
 
 
372
// ----------------------------------------------------------------------------
 
373
// event handlers
 
374
// ----------------------------------------------------------------------------
 
375
 
 
376
void wxToolBarSimple::OnPaint (wxPaintEvent& WXUNUSED(event))
 
377
{
 
378
    wxPaintDC dc(this);
 
379
    PrepareDC(dc);
 
380
 
 
381
    static int count = 0;
 
382
    // Prevent reentry of OnPaint which would cause wxMemoryDC errors.
 
383
    if ( count > 0 )
 
384
        return;
 
385
    count++;
 
386
 
 
387
    for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
 
388
          node;
 
389
          node = node->GetNext() )
 
390
    {
 
391
        wxToolBarToolBase *tool = node->GetData();
 
392
        if ( tool->IsButton() )
 
393
            DrawTool(dc, tool);
 
394
    }
 
395
 
 
396
    count--;
 
397
}
 
398
 
 
399
void wxToolBarSimple::OnSize (wxSizeEvent& WXUNUSED(event))
 
400
{
 
401
    if (GetAutoLayout())
 
402
        Layout();
 
403
 
 
404
    AdjustScrollbars();
 
405
}
 
406
 
 
407
void wxToolBarSimple::OnKillFocus(wxFocusEvent& WXUNUSED(event))
 
408
{
 
409
    OnMouseEnter(m_pressedTool = m_currentTool = -1);
 
410
}
 
411
 
 
412
void wxToolBarSimple::OnMouseEvent(wxMouseEvent & event)
 
413
{
 
414
    wxCoord x, y;
 
415
    event.GetPosition(&x, &y);
 
416
    wxToolBarToolSimple *tool = (wxToolBarToolSimple *)FindToolForPosition(x, y);
 
417
 
 
418
    if (event.LeftDown())
 
419
    {
 
420
        CaptureMouse();
 
421
    }
 
422
    if (event.LeftUp())
 
423
    {
 
424
        ReleaseMouse();
 
425
    }
 
426
 
 
427
    if (!tool)
 
428
    {
 
429
        if (m_currentTool > -1)
 
430
        {
 
431
            if (event.LeftIsDown())
 
432
                SpringUpButton(m_currentTool);
 
433
            m_currentTool = -1;
 
434
            OnMouseEnter(-1);
 
435
        }
 
436
        return;
 
437
    }
 
438
 
 
439
    if (!event.IsButton())
 
440
    {
 
441
        if ( tool->GetId() != m_currentTool )
 
442
        {
 
443
            // If the left button is kept down and moved over buttons,
 
444
            // press those buttons.
 
445
            if ( event.LeftIsDown() && tool->IsEnabled() )
 
446
            {
 
447
                SpringUpButton(m_currentTool);
 
448
 
 
449
                if ( tool->CanBeToggled() )
 
450
                {
 
451
                    tool->Toggle();
 
452
                }
 
453
 
 
454
                DrawTool(tool);
 
455
            }
 
456
 
 
457
            m_currentTool = tool->GetId();
 
458
            OnMouseEnter(m_currentTool);
 
459
        }
 
460
        return;
 
461
    }
 
462
 
 
463
    // Left button pressed.
 
464
    if ( event.LeftDown() && tool->IsEnabled() )
 
465
    {
 
466
        if ( tool->CanBeToggled() )
 
467
        {
 
468
            tool->Toggle();
 
469
        }
 
470
 
 
471
        DrawTool(tool);
 
472
    }
 
473
    else if (event.RightDown())
 
474
    {
 
475
        OnRightClick(tool->GetId(), x, y);
 
476
    }
 
477
 
 
478
    // Left Button Released.  Only this action confirms selection.
 
479
    // If the button is enabled and it is not a toggle tool and it is
 
480
    // in the pressed state, then raise the button and call OnLeftClick.
 
481
    //
 
482
    if ( event.LeftUp() && tool->IsEnabled() )
 
483
    {
 
484
        // Pass the OnLeftClick event to tool
 
485
        if ( !OnLeftClick(tool->GetId(), tool->IsToggled()) &&
 
486
                          tool->CanBeToggled() )
 
487
        {
 
488
            // If it was a toggle, and OnLeftClick says No Toggle allowed,
 
489
            // then change it back
 
490
            tool->Toggle();
 
491
        }
 
492
 
 
493
        DrawTool(tool);
 
494
    }
 
495
}
 
496
 
 
497
// ----------------------------------------------------------------------------
 
498
// drawing
 
499
// ----------------------------------------------------------------------------
 
500
 
 
501
void wxToolBarSimple::DrawTool(wxToolBarToolBase *tool)
 
502
{
 
503
    wxClientDC dc(this);
 
504
    DrawTool(dc, tool);
 
505
}
 
506
 
 
507
void wxToolBarSimple::DrawTool(wxDC& dc, wxToolBarToolBase *toolBase)
 
508
{
 
509
    wxToolBarToolSimple *tool = (wxToolBarToolSimple *)toolBase;
 
510
 
 
511
    wxMemoryDC memDC;
 
512
    PrepareDC(dc);
 
513
 
 
514
    wxPen dark_grey_pen(wxColour( 85,85,85 ), 1, wxSOLID);
 
515
    wxPen white_pen(wxT("WHITE"), 1, wxSOLID);
 
516
    wxPen black_pen(wxT("BLACK"), 1, wxSOLID);
 
517
 
 
518
    wxBitmap bitmap = tool->GetNormalBitmap();
 
519
    if (!bitmap.Ok())
 
520
        return;
 
521
 
 
522
    if ( !tool->IsToggled() )
 
523
    {
 
524
#if wxUSE_PALETTE
 
525
#ifndef __WXGTK__
 
526
        if (bitmap.GetPalette())
 
527
            memDC.SetPalette(*bitmap.GetPalette());
 
528
#endif
 
529
#endif // wxUSE_PALETTE
 
530
 
 
531
        int ax = (int)tool->m_x,
 
532
        ay = (int)tool->m_y,
 
533
        bx = (int)(tool->m_x+tool->GetWidth()),
 
534
        by = (int)(tool->m_y+tool->GetHeight());
 
535
 
 
536
        memDC.SelectObject(bitmap);
 
537
        if (m_windowStyle & wxTB_3DBUTTONS)
 
538
        {
 
539
            dc.SetClippingRegion(ax, ay, (bx-ax+1), (by-ay+1));
 
540
            dc.Blit((ax+1), (ay+1), (bx-ax-2), (by-ay-2), &memDC, 0, 0);
 
541
            wxPen * old_pen = & dc.GetPen();
 
542
            dc.SetPen( white_pen );
 
543
            dc.DrawLine(ax,(by-1),ax,ay);
 
544
            dc.DrawLine(ax,ay,(bx-1),ay);
 
545
            dc.SetPen( dark_grey_pen );
 
546
            dc.DrawLine((bx-1),(ay+1),(bx-1),(by-1));
 
547
            dc.DrawLine((bx-1),(by-1),(ax+1),(by-1));
 
548
            dc.SetPen( black_pen );
 
549
            dc.DrawLine(bx,ay,bx,by);
 
550
            dc.DrawLine(bx,by,ax,by);
 
551
            dc.SetPen( *old_pen );
 
552
            dc.DestroyClippingRegion();
 
553
            // Select bitmap out of the DC
 
554
        }
 
555
        else
 
556
        {
 
557
            dc.Blit(tool->m_x, tool->m_y,
 
558
                    bitmap.GetWidth(), bitmap.GetHeight(),
 
559
                    &memDC, 0, 0);
 
560
        }
 
561
        memDC.SelectObject(wxNullBitmap);
 
562
 
 
563
#if wxUSE_PALETTE
 
564
#ifndef __WXGTK__
 
565
        if (bitmap.GetPalette())
 
566
            memDC.SetPalette(wxNullPalette);
 
567
#endif
 
568
#endif // wxUSE_PALETTE
 
569
    }
 
570
    // No second bitmap, so draw a thick line around bitmap, or invert if mono
 
571
    else if ( tool->IsToggled() )
 
572
    {
 
573
        bool drawBorder = false;
 
574
#ifdef __X__ // X doesn't invert properly on colour
 
575
        drawBorder = wxColourDisplay();
 
576
#else       // Inversion works fine under Windows
 
577
        drawBorder = false;
 
578
#endif
 
579
 
 
580
        if (!drawBorder)
 
581
        {
 
582
            memDC.SelectObject(tool->GetNormalBitmap());
 
583
            dc.Blit(tool->m_x, tool->m_y, tool->GetWidth(), tool->GetHeight(),
 
584
                    &memDC, 0, 0, wxSRC_INVERT);
 
585
            memDC.SelectObject(wxNullBitmap);
 
586
        }
 
587
        else
 
588
        {
 
589
            bitmap = tool->GetNormalBitmap();
 
590
 
 
591
            if (m_windowStyle & wxTB_3DBUTTONS)
 
592
            {
 
593
                int ax = (int)tool->m_x,
 
594
                ay = (int)tool->m_y,
 
595
                bx = (int)(tool->m_x+tool->GetWidth()),
 
596
                by = (int)(tool->m_y+tool->GetHeight());
 
597
 
 
598
                memDC.SelectObject(bitmap);
 
599
                dc.SetClippingRegion(ax, ay, (bx-ax+1), (by-ay+1));
 
600
                dc.Blit((ax+2), (ay+2), (bx-ax-2), (by-ay-2), &memDC, 0, 0);
 
601
                wxPen * old_pen = & dc.GetPen();
 
602
                dc.SetPen( black_pen );
 
603
                dc.DrawLine(ax,(by-1),ax,ay);
 
604
                dc.DrawLine(ax,ay,(bx-1),ay);
 
605
                dc.SetPen( dark_grey_pen );
 
606
                dc.DrawLine((ax+1),(by-2),(ax+1),(ay+1));
 
607
                dc.DrawLine((ax+1),(ay+1),(bx-2),(ay+1));
 
608
                dc.SetPen( white_pen );
 
609
                dc.DrawLine(bx,ay,bx,by);
 
610
                dc.DrawLine(bx,by,ax,by);
 
611
                dc.SetPen( *old_pen );
 
612
                dc.DestroyClippingRegion();
 
613
                memDC.SelectObject(wxNullBitmap);
 
614
            }
 
615
            else
 
616
            {
 
617
                wxCoord x = tool->m_x;
 
618
                wxCoord y = tool->m_y;
 
619
                wxCoord w = bitmap.GetWidth();
 
620
                wxCoord h = bitmap.GetHeight();
 
621
                wxPen thick_black_pen(wxT("BLACK"), 3, wxSOLID);
 
622
 
 
623
                memDC.SelectObject(bitmap);
 
624
                dc.SetClippingRegion(tool->m_x, tool->m_y, w, h);
 
625
                dc.Blit(tool->m_x, tool->m_y, w, h,
 
626
                        &memDC, 0, 0);
 
627
                dc.SetPen(thick_black_pen);
 
628
                dc.SetBrush(*wxTRANSPARENT_BRUSH);
 
629
                dc.DrawRectangle(x, y, w-1, h-1);
 
630
                dc.DestroyClippingRegion();
 
631
                memDC.SelectObject(wxNullBitmap);
 
632
            }
 
633
        }
 
634
    }
 
635
}
 
636
 
 
637
// ----------------------------------------------------------------------------
 
638
// toolbar geometry
 
639
// ----------------------------------------------------------------------------
 
640
 
 
641
void wxToolBarSimple::SetRows(int nRows)
 
642
{
 
643
    wxCHECK_RET( nRows != 0, _T("max number of rows must be > 0") );
 
644
 
 
645
    m_maxCols = (GetToolsCount() + nRows - 1) / nRows;
 
646
 
 
647
    AdjustScrollbars();
 
648
    Refresh();
 
649
}
 
650
 
 
651
wxToolBarToolBase *wxToolBarSimple::FindToolForPosition(wxCoord x,
 
652
                                                        wxCoord y) const
 
653
{
 
654
    wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
 
655
    while (node)
 
656
    {
 
657
        wxToolBarToolSimple *tool = (wxToolBarToolSimple *)node->GetData();
 
658
        if ((x >= tool->m_x) && (y >= tool->m_y) &&
 
659
            (x <= (tool->m_x + tool->GetWidth())) &&
 
660
            (y <= (tool->m_y + tool->GetHeight())))
 
661
        {
 
662
            return tool;
 
663
        }
 
664
 
 
665
        node = node->GetNext();
 
666
    }
 
667
 
 
668
    return (wxToolBarToolBase *)NULL;
 
669
}
 
670
 
 
671
// ----------------------------------------------------------------------------
 
672
// tool state change handlers
 
673
// ----------------------------------------------------------------------------
 
674
 
 
675
void wxToolBarSimple::DoEnableTool(wxToolBarToolBase *tool,
 
676
                                   bool WXUNUSED(enable))
 
677
{
 
678
    DrawTool(tool);
 
679
}
 
680
 
 
681
void wxToolBarSimple::DoToggleTool(wxToolBarToolBase *tool,
 
682
                                   bool WXUNUSED(toggle))
 
683
{
 
684
    DrawTool(tool);
 
685
}
 
686
 
 
687
void wxToolBarSimple::DoSetToggle(wxToolBarToolBase * WXUNUSED(tool),
 
688
                                  bool WXUNUSED(toggle))
 
689
{
 
690
    // nothing to do
 
691
}
 
692
 
 
693
// Okay, so we've left the tool we're in ... we must check if the tool we're
 
694
// leaving was a 'sprung push button' and if so, spring it back to the up
 
695
// state.
 
696
void wxToolBarSimple::SpringUpButton(int id)
 
697
{
 
698
    wxToolBarToolBase *tool = FindById(id);
 
699
 
 
700
    if ( tool && tool->CanBeToggled() )
 
701
    {
 
702
        if (tool->IsToggled())
 
703
            tool->Toggle();
 
704
 
 
705
        DrawTool(tool);
 
706
    }
 
707
}
 
708
 
 
709
// ----------------------------------------------------------------------------
 
710
// scrolling implementation
 
711
// ----------------------------------------------------------------------------
 
712
 
 
713
/*
 
714
 * pixelsPerUnitX/pixelsPerUnitY: number of pixels per unit (e.g. pixels per text line)
 
715
 * noUnitsX/noUnitsY:        : no. units per scrollbar
 
716
 */
 
717
void wxToolBarSimple::SetScrollbars (int pixelsPerUnitX, int pixelsPerUnitY,
 
718
                                   int noUnitsX, int noUnitsY,
 
719
                                   int xPos, int yPos)
 
720
{
 
721
    m_xScrollPixelsPerLine = pixelsPerUnitX;
 
722
    m_yScrollPixelsPerLine = pixelsPerUnitY;
 
723
    m_xScrollLines = noUnitsX;
 
724
    m_yScrollLines = noUnitsY;
 
725
 
 
726
    int w, h;
 
727
    GetSize(&w, &h);
 
728
 
 
729
    // Recalculate scroll bar range and position
 
730
    if (m_xScrollLines > 0)
 
731
    {
 
732
        m_xScrollPosition = xPos;
 
733
        SetScrollPos (wxHORIZONTAL, m_xScrollPosition, true);
 
734
    }
 
735
    else
 
736
    {
 
737
        SetScrollbar(wxHORIZONTAL, 0, 0, 0, false);
 
738
        m_xScrollPosition = 0;
 
739
    }
 
740
 
 
741
    if (m_yScrollLines > 0)
 
742
    {
 
743
        m_yScrollPosition = yPos;
 
744
        SetScrollPos (wxVERTICAL, m_yScrollPosition, true);
 
745
    }
 
746
    else
 
747
    {
 
748
        SetScrollbar(wxVERTICAL, 0, 0, 0, false);
 
749
        m_yScrollPosition = 0;
 
750
    }
 
751
    AdjustScrollbars();
 
752
    Refresh();
 
753
 
 
754
#if 0 //def __WXMSW__
 
755
    ::UpdateWindow ((HWND) GetHWND());
 
756
#endif
 
757
}
 
758
 
 
759
void wxToolBarSimple::OnScroll(wxScrollEvent& event)
 
760
{
 
761
    int orient = event.GetOrientation();
 
762
 
 
763
    int nScrollInc = CalcScrollInc(event);
 
764
    if (nScrollInc == 0)
 
765
        return;
 
766
 
 
767
    if (orient == wxHORIZONTAL)
 
768
    {
 
769
        int newPos = m_xScrollPosition + nScrollInc;
 
770
        SetScrollPos(wxHORIZONTAL, newPos, true );
 
771
    }
 
772
    else
 
773
    {
 
774
        int newPos = m_yScrollPosition + nScrollInc;
 
775
        SetScrollPos(wxVERTICAL, newPos, true );
 
776
    }
 
777
 
 
778
    if (orient == wxHORIZONTAL)
 
779
    {
 
780
        if (m_xScrollingEnabled)
 
781
            ScrollWindow(-m_xScrollPixelsPerLine * nScrollInc, 0, NULL);
 
782
        else
 
783
            Refresh();
 
784
    }
 
785
    else
 
786
    {
 
787
        if (m_yScrollingEnabled)
 
788
            ScrollWindow(0, -m_yScrollPixelsPerLine * nScrollInc, NULL);
 
789
        else
 
790
            Refresh();
 
791
    }
 
792
 
 
793
    if (orient == wxHORIZONTAL)
 
794
    {
 
795
        m_xScrollPosition += nScrollInc;
 
796
    }
 
797
    else
 
798
    {
 
799
        m_yScrollPosition += nScrollInc;
 
800
    }
 
801
 
 
802
}
 
803
 
 
804
int wxToolBarSimple::CalcScrollInc(wxScrollEvent& event)
 
805
{
 
806
    int pos = event.GetPosition();
 
807
    int orient = event.GetOrientation();
 
808
 
 
809
    int nScrollInc = 0;
 
810
    if (event.GetEventType() == wxEVT_SCROLL_TOP)
 
811
    {
 
812
            if (orient == wxHORIZONTAL)
 
813
                nScrollInc = - m_xScrollPosition;
 
814
            else
 
815
                nScrollInc = - m_yScrollPosition;
 
816
    } else
 
817
    if (event.GetEventType() == wxEVT_SCROLL_BOTTOM)
 
818
    {
 
819
            if (orient == wxHORIZONTAL)
 
820
                nScrollInc = m_xScrollLines - m_xScrollPosition;
 
821
            else
 
822
                nScrollInc = m_yScrollLines - m_yScrollPosition;
 
823
    } else
 
824
    if (event.GetEventType() == wxEVT_SCROLL_LINEUP)
 
825
    {
 
826
            nScrollInc = -1;
 
827
    } else
 
828
    if (event.GetEventType() == wxEVT_SCROLL_LINEDOWN)
 
829
    {
 
830
            nScrollInc = 1;
 
831
    } else
 
832
    if (event.GetEventType() == wxEVT_SCROLL_PAGEUP)
 
833
    {
 
834
            if (orient == wxHORIZONTAL)
 
835
                nScrollInc = -GetScrollPageSize(wxHORIZONTAL);
 
836
            else
 
837
                nScrollInc = -GetScrollPageSize(wxVERTICAL);
 
838
    } else
 
839
    if (event.GetEventType() == wxEVT_SCROLL_PAGEDOWN)
 
840
    {
 
841
            if (orient == wxHORIZONTAL)
 
842
                nScrollInc = GetScrollPageSize(wxHORIZONTAL);
 
843
            else
 
844
                nScrollInc = GetScrollPageSize(wxVERTICAL);
 
845
    } else
 
846
    if ((event.GetEventType() == wxEVT_SCROLL_THUMBTRACK) ||
 
847
        (event.GetEventType() == wxEVT_SCROLL_THUMBRELEASE))
 
848
    {
 
849
            if (orient == wxHORIZONTAL)
 
850
                nScrollInc = pos - m_xScrollPosition;
 
851
            else
 
852
                nScrollInc = pos - m_yScrollPosition;
 
853
    }
 
854
 
 
855
    if (orient == wxHORIZONTAL)
 
856
    {
 
857
        int w, h;
 
858
        GetClientSize(&w, &h);
 
859
 
 
860
        int nMaxWidth = m_xScrollLines*m_xScrollPixelsPerLine;
 
861
        int noPositions = (int) ( ((nMaxWidth - w)/(float)m_xScrollPixelsPerLine) + 0.5 );
 
862
        if (noPositions < 0)
 
863
            noPositions = 0;
 
864
 
 
865
        if ( (m_xScrollPosition + nScrollInc) < 0 )
 
866
            nScrollInc = -m_xScrollPosition; // As -ve as we can go
 
867
        else if ( (m_xScrollPosition + nScrollInc) > noPositions )
 
868
            nScrollInc = noPositions - m_xScrollPosition; // As +ve as we can go
 
869
 
 
870
        return nScrollInc;
 
871
    }
 
872
    else
 
873
    {
 
874
        int w, h;
 
875
        GetClientSize(&w, &h);
 
876
 
 
877
        int nMaxHeight = m_yScrollLines*m_yScrollPixelsPerLine;
 
878
        int noPositions = (int) ( ((nMaxHeight - h)/(float)m_yScrollPixelsPerLine) + 0.5 );
 
879
        if (noPositions < 0)
 
880
            noPositions = 0;
 
881
 
 
882
        if ( (m_yScrollPosition + nScrollInc) < 0 )
 
883
            nScrollInc = -m_yScrollPosition; // As -ve as we can go
 
884
        else if ( (m_yScrollPosition + nScrollInc) > noPositions )
 
885
            nScrollInc = noPositions - m_yScrollPosition; // As +ve as we can go
 
886
 
 
887
        return nScrollInc;
 
888
    }
 
889
}
 
890
 
 
891
// Adjust the scrollbars - new version.
 
892
void wxToolBarSimple::AdjustScrollbars()
 
893
{
 
894
    int w, h;
 
895
    GetClientSize(&w, &h);
 
896
 
 
897
    // Recalculate scroll bar range and position
 
898
    if (m_xScrollLines > 0)
 
899
    {
 
900
        int nMaxWidth = m_xScrollLines*m_xScrollPixelsPerLine;
 
901
        int newRange = (int) ( ((nMaxWidth)/(float)m_xScrollPixelsPerLine) + 0.5 );
 
902
        if (newRange < 0)
 
903
            newRange = 0;
 
904
 
 
905
        m_xScrollPosition = wxMin(newRange, m_xScrollPosition);
 
906
 
 
907
        // Calculate page size i.e. number of scroll units you get on the
 
908
        // current client window
 
909
        int noPagePositions = (int) ( (w/(float)m_xScrollPixelsPerLine) + 0.5 );
 
910
        if (noPagePositions < 1)
 
911
            noPagePositions = 1;
 
912
 
 
913
        SetScrollbar(wxHORIZONTAL, m_xScrollPosition, noPagePositions, newRange);
 
914
        SetScrollPageSize(wxHORIZONTAL, noPagePositions);
 
915
    }
 
916
    if (m_yScrollLines > 0)
 
917
    {
 
918
        int nMaxHeight = m_yScrollLines*m_yScrollPixelsPerLine;
 
919
        int newRange = (int) ( ((nMaxHeight)/(float)m_yScrollPixelsPerLine) + 0.5 );
 
920
        if (newRange < 0)
 
921
            newRange = 0;
 
922
 
 
923
        m_yScrollPosition = wxMin(newRange, m_yScrollPosition);
 
924
 
 
925
        // Calculate page size i.e. number of scroll units you get on the
 
926
        // current client window
 
927
        int noPagePositions = (int) ( (h/(float)m_yScrollPixelsPerLine) + 0.5 );
 
928
        if (noPagePositions < 1)
 
929
            noPagePositions = 1;
 
930
 
 
931
        SetScrollbar(wxVERTICAL, m_yScrollPosition, noPagePositions, newRange);
 
932
        SetScrollPageSize(wxVERTICAL, noPagePositions);
 
933
    }
 
934
}
 
935
 
 
936
// Prepare the DC by translating it according to the current scroll position
 
937
void wxToolBarSimple::PrepareDC(wxDC& dc)
 
938
{
 
939
    dc.SetDeviceOrigin(- m_xScrollPosition * m_xScrollPixelsPerLine, - m_yScrollPosition * m_yScrollPixelsPerLine);
 
940
}
 
941
 
 
942
void wxToolBarSimple::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const
 
943
{
 
944
      *x_unit = m_xScrollPixelsPerLine;
 
945
      *y_unit = m_yScrollPixelsPerLine;
 
946
}
 
947
 
 
948
int wxToolBarSimple::GetScrollPageSize(int orient) const
 
949
{
 
950
    if ( orient == wxHORIZONTAL )
 
951
        return m_xScrollLinesPerPage;
 
952
    else
 
953
        return m_yScrollLinesPerPage;
 
954
}
 
955
 
 
956
void wxToolBarSimple::SetScrollPageSize(int orient, int pageSize)
 
957
{
 
958
    if ( orient == wxHORIZONTAL )
 
959
        m_xScrollLinesPerPage = pageSize;
 
960
    else
 
961
        m_yScrollLinesPerPage = pageSize;
 
962
}
 
963
 
 
964
/*
 
965
 * Scroll to given position (scroll position, not pixel position)
 
966
 */
 
967
void wxToolBarSimple::Scroll (int x_pos, int y_pos)
 
968
{
 
969
    int old_x, old_y;
 
970
    ViewStart (&old_x, &old_y);
 
971
    if (((x_pos == wxDefaultCoord) || (x_pos == old_x)) && ((y_pos == wxDefaultCoord) || (y_pos == old_y)))
 
972
        return;
 
973
 
 
974
    if (x_pos != wxDefaultCoord)
 
975
    {
 
976
        m_xScrollPosition = x_pos;
 
977
        SetScrollPos (wxHORIZONTAL, x_pos, true);
 
978
    }
 
979
    if (y_pos != wxDefaultCoord)
 
980
    {
 
981
        m_yScrollPosition = y_pos;
 
982
        SetScrollPos (wxVERTICAL, y_pos, true);
 
983
    }
 
984
    Refresh();
 
985
 
 
986
#if 0 //def __WXMSW__
 
987
    UpdateWindow ((HWND) GetHWND());
 
988
#endif
 
989
}
 
990
 
 
991
void wxToolBarSimple::EnableScrolling (bool x_scroll, bool y_scroll)
 
992
{
 
993
    m_xScrollingEnabled = x_scroll;
 
994
    m_yScrollingEnabled = y_scroll;
 
995
}
 
996
 
 
997
void wxToolBarSimple::GetVirtualSize (int *x, int *y) const
 
998
{
 
999
    *x = m_xScrollPixelsPerLine * m_xScrollLines;
 
1000
    *y = m_yScrollPixelsPerLine * m_yScrollLines;
 
1001
}
 
1002
 
 
1003
// Where the current view starts from
 
1004
void wxToolBarSimple::ViewStart (int *x, int *y) const
 
1005
{
 
1006
    *x = m_xScrollPosition;
 
1007
    *y = m_yScrollPosition;
 
1008
}
 
1009
 
 
1010
#endif // wxUSE_TOOLBAR_SIMPLE
 
1011