]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: common/tbarbase.cpp | |
3 | // Purpose: wxToolBarBase implementation | |
4 | // Author: Julian Smart | |
5 | // Modified by: VZ at 11.12.99 (wxScrollableToolBar splitted off) | |
6 | // Created: 04/01/98 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) Julian Smart | |
9 | // Licence: wxWindows licence | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | // ============================================================================ | |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | // ---------------------------------------------------------------------------- | |
17 | // headers | |
18 | // ---------------------------------------------------------------------------- | |
19 | ||
20 | #ifdef __GNUG__ | |
21 | #pragma implementation "tbarbase.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 | |
32 | ||
33 | #ifndef WX_PRECOMP | |
34 | #include "wx/control.h" | |
35 | #endif | |
36 | ||
37 | #include "wx/frame.h" | |
38 | #include "wx/image.h" | |
39 | #include "wx/settings.h" | |
40 | ||
41 | #include "wx/tbarbase.h" | |
42 | ||
43 | // ---------------------------------------------------------------------------- | |
44 | // wxWindows macros | |
45 | // ---------------------------------------------------------------------------- | |
46 | ||
47 | IMPLEMENT_CLASS(wxToolBarBase, wxControl) | |
48 | ||
49 | BEGIN_EVENT_TABLE(wxToolBarBase, wxControl) | |
50 | EVT_IDLE(wxToolBarBase::OnIdle) | |
51 | END_EVENT_TABLE() | |
52 | ||
53 | #include "wx/listimpl.cpp" | |
54 | ||
55 | WX_DEFINE_LIST(wxToolBarToolsList); | |
56 | ||
57 | // ============================================================================ | |
58 | // implementation | |
59 | // ============================================================================ | |
60 | ||
61 | // ---------------------------------------------------------------------------- | |
62 | // wxToolBarToolBase | |
63 | // ---------------------------------------------------------------------------- | |
64 | ||
65 | bool wxToolBarToolBase::Enable(bool enable) | |
66 | { | |
67 | if ( m_enabled == enable ) | |
68 | return FALSE; | |
69 | ||
70 | m_enabled = enable; | |
71 | ||
72 | return TRUE; | |
73 | } | |
74 | ||
75 | bool wxToolBarToolBase::Toggle(bool toggle) | |
76 | { | |
77 | wxASSERT_MSG( CanBeToggled(), _T("can't toggle this tool") ); | |
78 | ||
79 | if ( m_toggled == toggle ) | |
80 | return FALSE; | |
81 | ||
82 | m_toggled = toggle; | |
83 | ||
84 | return TRUE; | |
85 | } | |
86 | ||
87 | bool wxToolBarToolBase::SetToggle(bool toggle) | |
88 | { | |
89 | wxItemKind kind = toggle ? wxITEM_CHECK : wxITEM_NORMAL; | |
90 | if ( m_kind == kind ) | |
91 | return FALSE; | |
92 | ||
93 | m_kind = kind; | |
94 | ||
95 | return TRUE; | |
96 | } | |
97 | ||
98 | bool wxToolBarToolBase::SetShortHelp(const wxString& help) | |
99 | { | |
100 | if ( m_shortHelpString == help ) | |
101 | return FALSE; | |
102 | ||
103 | m_shortHelpString = help; | |
104 | ||
105 | return TRUE; | |
106 | } | |
107 | ||
108 | bool wxToolBarToolBase::SetLongHelp(const wxString& help) | |
109 | { | |
110 | if ( m_longHelpString == help ) | |
111 | return FALSE; | |
112 | ||
113 | m_longHelpString = help; | |
114 | ||
115 | return TRUE; | |
116 | } | |
117 | ||
118 | wxToolBarToolBase::~wxToolBarToolBase() | |
119 | { | |
120 | } | |
121 | ||
122 | // ---------------------------------------------------------------------------- | |
123 | // wxToolBarBase adding/deleting items | |
124 | // ---------------------------------------------------------------------------- | |
125 | ||
126 | wxToolBarBase::wxToolBarBase() | |
127 | { | |
128 | // the list owns the pointers | |
129 | m_tools.DeleteContents(TRUE); | |
130 | ||
131 | m_xMargin = m_yMargin = 0; | |
132 | ||
133 | m_maxRows = m_maxCols = 0; | |
134 | } | |
135 | ||
136 | wxToolBarToolBase *wxToolBarBase::DoAddTool(int id, | |
137 | const wxString& label, | |
138 | const wxBitmap& bitmap, | |
139 | const wxBitmap& bmpDisabled, | |
140 | wxItemKind kind, | |
141 | const wxString& shortHelp, | |
142 | const wxString& longHelp, | |
143 | wxObject *clientData, | |
144 | wxCoord WXUNUSED(xPos), | |
145 | wxCoord WXUNUSED(yPos)) | |
146 | { | |
147 | return InsertTool(GetToolsCount(), id, label, bitmap, bmpDisabled, | |
148 | kind, shortHelp, longHelp, clientData); | |
149 | } | |
150 | ||
151 | wxToolBarToolBase *wxToolBarBase::InsertTool(size_t pos, | |
152 | int id, | |
153 | const wxString& label, | |
154 | const wxBitmap& bitmap, | |
155 | const wxBitmap& bmpDisabled, | |
156 | wxItemKind kind, | |
157 | const wxString& shortHelp, | |
158 | const wxString& longHelp, | |
159 | wxObject *clientData) | |
160 | { | |
161 | wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL, | |
162 | _T("invalid position in wxToolBar::InsertTool()") ); | |
163 | ||
164 | wxToolBarToolBase *tool = CreateTool(id, label, bitmap, bmpDisabled, kind, | |
165 | clientData, shortHelp, longHelp); | |
166 | ||
167 | if ( !InsertTool(pos, tool) ) | |
168 | { | |
169 | delete tool; | |
170 | ||
171 | return NULL; | |
172 | } | |
173 | ||
174 | return tool; | |
175 | } | |
176 | ||
177 | wxToolBarToolBase *wxToolBarBase::AddTool(wxToolBarToolBase *tool) | |
178 | { | |
179 | return InsertTool(GetToolsCount(), tool); | |
180 | } | |
181 | ||
182 | wxToolBarToolBase * | |
183 | wxToolBarBase::InsertTool(size_t pos, wxToolBarToolBase *tool) | |
184 | { | |
185 | wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL, | |
186 | _T("invalid position in wxToolBar::InsertTool()") ); | |
187 | ||
188 | if ( !tool || !DoInsertTool(pos, tool) ) | |
189 | { | |
190 | return NULL; | |
191 | } | |
192 | ||
193 | m_tools.Insert(pos, tool); | |
194 | ||
195 | return tool; | |
196 | } | |
197 | ||
198 | wxToolBarToolBase *wxToolBarBase::AddControl(wxControl *control) | |
199 | { | |
200 | return InsertControl(GetToolsCount(), control); | |
201 | } | |
202 | ||
203 | wxToolBarToolBase *wxToolBarBase::InsertControl(size_t pos, wxControl *control) | |
204 | { | |
205 | wxCHECK_MSG( control, (wxToolBarToolBase *)NULL, | |
206 | _T("toolbar: can't insert NULL control") ); | |
207 | ||
208 | wxCHECK_MSG( control->GetParent() == this, (wxToolBarToolBase *)NULL, | |
209 | _T("control must have toolbar as parent") ); | |
210 | ||
211 | wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL, | |
212 | _T("invalid position in wxToolBar::InsertControl()") ); | |
213 | ||
214 | wxToolBarToolBase *tool = CreateTool(control); | |
215 | ||
216 | if ( !InsertTool(pos, tool) ) | |
217 | { | |
218 | delete tool; | |
219 | ||
220 | return NULL; | |
221 | } | |
222 | ||
223 | return tool; | |
224 | } | |
225 | ||
226 | wxControl *wxToolBarBase::FindControl( int id ) | |
227 | { | |
228 | for ( wxToolBarToolsList::Node* node = m_tools.GetFirst(); | |
229 | node; | |
230 | node = node->GetNext() ) | |
231 | { | |
232 | const wxToolBarToolBase * const tool = node->GetData(); | |
233 | if ( tool->IsControl() ) | |
234 | { | |
235 | wxControl * const control = tool->GetControl(); | |
236 | ||
237 | if ( !control ) | |
238 | { | |
239 | wxFAIL_MSG( _T("NULL control in toolbar?") ); | |
240 | } | |
241 | else if ( control->GetId() == id ) | |
242 | { | |
243 | // found | |
244 | return control; | |
245 | } | |
246 | } | |
247 | } | |
248 | ||
249 | return NULL; | |
250 | } | |
251 | ||
252 | wxToolBarToolBase *wxToolBarBase::AddSeparator() | |
253 | { | |
254 | return InsertSeparator(GetToolsCount()); | |
255 | } | |
256 | ||
257 | wxToolBarToolBase *wxToolBarBase::InsertSeparator(size_t pos) | |
258 | { | |
259 | wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL, | |
260 | _T("invalid position in wxToolBar::InsertSeparator()") ); | |
261 | ||
262 | wxToolBarToolBase *tool = CreateTool(wxID_SEPARATOR, | |
263 | wxEmptyString, | |
264 | wxNullBitmap, wxNullBitmap, | |
265 | wxITEM_SEPARATOR, (wxObject *)NULL, | |
266 | wxEmptyString, wxEmptyString); | |
267 | ||
268 | if ( !tool || !DoInsertTool(pos, tool) ) | |
269 | { | |
270 | delete tool; | |
271 | ||
272 | return NULL; | |
273 | } | |
274 | ||
275 | m_tools.Insert(pos, tool); | |
276 | ||
277 | return tool; | |
278 | } | |
279 | ||
280 | wxToolBarToolBase *wxToolBarBase::RemoveTool(int id) | |
281 | { | |
282 | size_t pos = 0; | |
283 | wxToolBarToolsList::Node *node; | |
284 | for ( node = m_tools.GetFirst(); node; node = node->GetNext() ) | |
285 | { | |
286 | if ( node->GetData()->GetId() == id ) | |
287 | break; | |
288 | ||
289 | pos++; | |
290 | } | |
291 | ||
292 | if ( !node ) | |
293 | { | |
294 | // don't give any error messages - sometimes we might call RemoveTool() | |
295 | // without knowing whether the tool is or not in the toolbar | |
296 | return (wxToolBarToolBase *)NULL; | |
297 | } | |
298 | ||
299 | wxToolBarToolBase *tool = node->GetData(); | |
300 | if ( !DoDeleteTool(pos, tool) ) | |
301 | { | |
302 | return (wxToolBarToolBase *)NULL; | |
303 | } | |
304 | ||
305 | // the node would delete the data, so set it to NULL to avoid this | |
306 | node->SetData(NULL); | |
307 | ||
308 | m_tools.DeleteNode(node); | |
309 | ||
310 | return tool; | |
311 | } | |
312 | ||
313 | bool wxToolBarBase::DeleteToolByPos(size_t pos) | |
314 | { | |
315 | wxCHECK_MSG( pos < GetToolsCount(), FALSE, | |
316 | _T("invalid position in wxToolBar::DeleteToolByPos()") ); | |
317 | ||
318 | wxToolBarToolsList::Node *node = m_tools.Item(pos); | |
319 | ||
320 | if ( !DoDeleteTool(pos, node->GetData()) ) | |
321 | { | |
322 | return FALSE; | |
323 | } | |
324 | ||
325 | m_tools.DeleteNode(node); | |
326 | ||
327 | return TRUE; | |
328 | } | |
329 | ||
330 | bool wxToolBarBase::DeleteTool(int id) | |
331 | { | |
332 | size_t pos = 0; | |
333 | wxToolBarToolsList::Node *node; | |
334 | for ( node = m_tools.GetFirst(); node; node = node->GetNext() ) | |
335 | { | |
336 | if ( node->GetData()->GetId() == id ) | |
337 | break; | |
338 | ||
339 | pos++; | |
340 | } | |
341 | ||
342 | if ( !node || !DoDeleteTool(pos, node->GetData()) ) | |
343 | { | |
344 | return FALSE; | |
345 | } | |
346 | ||
347 | m_tools.DeleteNode(node); | |
348 | ||
349 | return TRUE; | |
350 | } | |
351 | ||
352 | wxToolBarToolBase *wxToolBarBase::FindById(int id) const | |
353 | { | |
354 | wxToolBarToolBase *tool = (wxToolBarToolBase *)NULL; | |
355 | ||
356 | for ( wxToolBarToolsList::Node *node = m_tools.GetFirst(); | |
357 | node; | |
358 | node = node->GetNext() ) | |
359 | { | |
360 | tool = node->GetData(); | |
361 | if ( tool->GetId() == id ) | |
362 | { | |
363 | // found | |
364 | break; | |
365 | } | |
366 | ||
367 | tool = NULL; | |
368 | } | |
369 | ||
370 | return tool; | |
371 | } | |
372 | ||
373 | void wxToolBarBase::ClearTools() | |
374 | { | |
375 | m_tools.Clear(); | |
376 | } | |
377 | ||
378 | bool wxToolBarBase::Realize() | |
379 | { | |
380 | return TRUE; | |
381 | } | |
382 | ||
383 | wxToolBarBase::~wxToolBarBase() | |
384 | { | |
385 | } | |
386 | ||
387 | // ---------------------------------------------------------------------------- | |
388 | // wxToolBarBase tools state | |
389 | // ---------------------------------------------------------------------------- | |
390 | ||
391 | void wxToolBarBase::EnableTool(int id, bool enable) | |
392 | { | |
393 | wxToolBarToolBase *tool = FindById(id); | |
394 | if ( tool ) | |
395 | { | |
396 | if ( tool->Enable(enable) ) | |
397 | { | |
398 | DoEnableTool(tool, enable); | |
399 | } | |
400 | } | |
401 | } | |
402 | ||
403 | void wxToolBarBase::ToggleTool(int id, bool toggle) | |
404 | { | |
405 | wxToolBarToolBase *tool = FindById(id); | |
406 | if ( tool && tool->CanBeToggled() ) | |
407 | { | |
408 | if ( tool->Toggle(toggle) ) | |
409 | { | |
410 | DoToggleTool(tool, toggle); | |
411 | } | |
412 | } | |
413 | } | |
414 | ||
415 | void wxToolBarBase::SetToggle(int id, bool toggle) | |
416 | { | |
417 | wxToolBarToolBase *tool = FindById(id); | |
418 | if ( tool ) | |
419 | { | |
420 | if ( tool->SetToggle(toggle) ) | |
421 | { | |
422 | DoSetToggle(tool, toggle); | |
423 | } | |
424 | } | |
425 | } | |
426 | ||
427 | void wxToolBarBase::SetToolShortHelp(int id, const wxString& help) | |
428 | { | |
429 | wxToolBarToolBase *tool = FindById(id); | |
430 | if ( tool ) | |
431 | { | |
432 | (void)tool->SetShortHelp(help); | |
433 | } | |
434 | } | |
435 | ||
436 | void wxToolBarBase::SetToolLongHelp(int id, const wxString& help) | |
437 | { | |
438 | wxToolBarToolBase *tool = FindById(id); | |
439 | if ( tool ) | |
440 | { | |
441 | (void)tool->SetLongHelp(help); | |
442 | } | |
443 | } | |
444 | ||
445 | wxObject *wxToolBarBase::GetToolClientData(int id) const | |
446 | { | |
447 | wxToolBarToolBase *tool = FindById(id); | |
448 | ||
449 | return tool ? tool->GetClientData() : (wxObject *)NULL; | |
450 | } | |
451 | ||
452 | void wxToolBarBase::SetToolClientData(int id, wxObject *clientData) | |
453 | { | |
454 | wxToolBarToolBase *tool = FindById(id); | |
455 | ||
456 | wxCHECK_RET( tool, _T("no such tool in wxToolBar::SetToolClientData") ); | |
457 | ||
458 | tool->SetClientData(clientData); | |
459 | } | |
460 | ||
461 | int wxToolBarBase::GetToolPos(int id) const | |
462 | { | |
463 | size_t pos = 0; | |
464 | wxToolBarToolsList::Node *node; | |
465 | ||
466 | for ( node = m_tools.GetFirst(); node; node = node->GetNext() ) | |
467 | { | |
468 | if ( node->GetData()->GetId() == id ) | |
469 | return pos; | |
470 | ||
471 | pos++; | |
472 | } | |
473 | ||
474 | return wxNOT_FOUND; | |
475 | } | |
476 | ||
477 | bool wxToolBarBase::GetToolState(int id) const | |
478 | { | |
479 | wxToolBarToolBase *tool = FindById(id); | |
480 | wxCHECK_MSG( tool, FALSE, _T("no such tool") ); | |
481 | ||
482 | return tool->IsToggled(); | |
483 | } | |
484 | ||
485 | bool wxToolBarBase::GetToolEnabled(int id) const | |
486 | { | |
487 | wxToolBarToolBase *tool = FindById(id); | |
488 | wxCHECK_MSG( tool, FALSE, _T("no such tool") ); | |
489 | ||
490 | return tool->IsEnabled(); | |
491 | } | |
492 | ||
493 | wxString wxToolBarBase::GetToolShortHelp(int id) const | |
494 | { | |
495 | wxToolBarToolBase *tool = FindById(id); | |
496 | wxCHECK_MSG( tool, _T(""), _T("no such tool") ); | |
497 | ||
498 | return tool->GetShortHelp(); | |
499 | } | |
500 | ||
501 | wxString wxToolBarBase::GetToolLongHelp(int id) const | |
502 | { | |
503 | wxToolBarToolBase *tool = FindById(id); | |
504 | wxCHECK_MSG( tool, _T(""), _T("no such tool") ); | |
505 | ||
506 | return tool->GetLongHelp(); | |
507 | } | |
508 | ||
509 | // ---------------------------------------------------------------------------- | |
510 | // wxToolBarBase geometry | |
511 | // ---------------------------------------------------------------------------- | |
512 | ||
513 | void wxToolBarBase::SetMargins(int x, int y) | |
514 | { | |
515 | m_xMargin = x; | |
516 | m_yMargin = y; | |
517 | } | |
518 | ||
519 | void wxToolBarBase::SetRows(int WXUNUSED(nRows)) | |
520 | { | |
521 | // nothing | |
522 | } | |
523 | ||
524 | // ---------------------------------------------------------------------------- | |
525 | // event processing | |
526 | // ---------------------------------------------------------------------------- | |
527 | ||
528 | // Only allow toggle if returns TRUE | |
529 | bool wxToolBarBase::OnLeftClick(int id, bool toggleDown) | |
530 | { | |
531 | wxCommandEvent event(wxEVT_COMMAND_TOOL_CLICKED, id); | |
532 | event.SetEventObject(this); | |
533 | ||
534 | // we use SetInt() to make wxCommandEvent::IsChecked() return toggleDown | |
535 | event.SetInt((int)toggleDown); | |
536 | ||
537 | // and SetExtraLong() for backwards compatibility | |
538 | event.SetExtraLong((long)toggleDown); | |
539 | ||
540 | // Send events to this toolbar instead (and thence up the window hierarchy) | |
541 | GetEventHandler()->ProcessEvent(event); | |
542 | ||
543 | return TRUE; | |
544 | } | |
545 | ||
546 | // Call when right button down. | |
547 | void wxToolBarBase::OnRightClick(int id, | |
548 | long WXUNUSED(x), | |
549 | long WXUNUSED(y)) | |
550 | { | |
551 | wxCommandEvent event(wxEVT_COMMAND_TOOL_RCLICKED, id); | |
552 | event.SetEventObject(this); | |
553 | event.SetInt(id); | |
554 | ||
555 | GetEventHandler()->ProcessEvent(event); | |
556 | } | |
557 | ||
558 | // Called when the mouse cursor enters a tool bitmap (no button pressed). | |
559 | // Argument is -1 if mouse is exiting the toolbar. | |
560 | // Note that for this event, the id of the window is used, | |
561 | // and the integer parameter of wxCommandEvent is used to retrieve | |
562 | // the tool id. | |
563 | void wxToolBarBase::OnMouseEnter(int id) | |
564 | { | |
565 | wxCommandEvent event(wxEVT_COMMAND_TOOL_ENTER, GetId()); | |
566 | event.SetEventObject(this); | |
567 | event.SetInt(id); | |
568 | ||
569 | wxFrame *frame = wxDynamicCast(GetParent(), wxFrame); | |
570 | if( frame ) | |
571 | { | |
572 | wxToolBarToolBase* tool = id == -1 ? (wxToolBarToolBase*)0 : FindById(id); | |
573 | wxString help = tool ? tool->GetLongHelp() : wxString(); | |
574 | frame->DoGiveHelp( help, id != -1 ); | |
575 | } | |
576 | ||
577 | (void)GetEventHandler()->ProcessEvent(event); | |
578 | } | |
579 | ||
580 | // ---------------------------------------------------------------------------- | |
581 | // UI updates | |
582 | // ---------------------------------------------------------------------------- | |
583 | ||
584 | void wxToolBarBase::OnIdle(wxIdleEvent& event) | |
585 | { | |
586 | DoToolbarUpdates(); | |
587 | ||
588 | event.Skip(); | |
589 | } | |
590 | ||
591 | // Do the toolbar button updates (check for EVT_UPDATE_UI handlers) | |
592 | void wxToolBarBase::DoToolbarUpdates() | |
593 | { | |
594 | wxWindow* parent = this; | |
595 | while (parent->GetParent()) | |
596 | parent = parent->GetParent(); | |
597 | ||
598 | // This kind of #ifdef is a good way to annoy people. It breaks | |
599 | // apps, but only on one platform and due to a hack in officially | |
600 | // platform independent code. It took me hours to fix this. RR. | |
601 | // | |
602 | // #ifdef __WXMSW__ | |
603 | // wxWindow* focusWin = wxFindFocusDescendant(parent); | |
604 | // #else | |
605 | wxWindow* focusWin = (wxWindow*) NULL; | |
606 | // #endif | |
607 | ||
608 | wxEvtHandler* evtHandler = focusWin ? focusWin->GetEventHandler() : GetEventHandler() ; | |
609 | ||
610 | for ( wxToolBarToolsList::Node* node = m_tools.GetFirst(); | |
611 | node; | |
612 | node = node->GetNext() ) | |
613 | { | |
614 | int id = node->GetData()->GetId(); | |
615 | ||
616 | wxUpdateUIEvent event(id); | |
617 | event.SetEventObject(this); | |
618 | ||
619 | if ( evtHandler->ProcessEvent(event) ) | |
620 | { | |
621 | if ( event.GetSetEnabled() ) | |
622 | EnableTool(id, event.GetEnabled()); | |
623 | if ( event.GetSetChecked() ) | |
624 | ToggleTool(id, event.GetChecked()); | |
625 | #if 0 | |
626 | if ( event.GetSetText() ) | |
627 | // Set tooltip? | |
628 | #endif // 0 | |
629 | } | |
630 | } | |
631 | } | |
632 | ||
633 | // Helper function, used by wxCreateGreyedImage | |
634 | ||
635 | static void wxGreyOutImage( const wxImage& src, | |
636 | wxImage& dest, | |
637 | const wxColour& darkCol, | |
638 | const wxColour& lightCol, | |
639 | const wxColour& bgCol ) | |
640 | { | |
641 | // Second attempt, just making things monochrome | |
642 | int width = src.GetWidth(); | |
643 | int height = src.GetHeight(); | |
644 | ||
645 | int redCur, greenCur, blueCur; | |
646 | for ( int x = 0; x < width; x++ ) | |
647 | { | |
648 | for ( int y = 1; y < height; y++ ) | |
649 | { | |
650 | redCur = src.GetRed(x, y); | |
651 | greenCur = src.GetGreen(x, y); | |
652 | blueCur = src.GetBlue(x, y); | |
653 | ||
654 | // Change light things to the background colour | |
655 | if ( redCur >= (lightCol.Red() - 50) && greenCur >= (lightCol.Green() - 50) && blueCur >= (lightCol.Blue() - 50) ) | |
656 | { | |
657 | dest.SetRGB(x,y, bgCol.Red(), bgCol.Green(), bgCol.Blue()); | |
658 | } | |
659 | else if ( redCur == bgCol.Red() && greenCur == bgCol.Green() && blueCur == bgCol.Blue() ) | |
660 | { | |
661 | // Leave the background colour as-is | |
662 | // dest.SetRGB(x,y, bgCol.Red(), bgCol.Green(), bgCol.Blue()); | |
663 | } | |
664 | else // if ( redCur <= darkCol.Red() && greenCur <= darkCol.Green() && blueCur <= darkCol.Blue() ) | |
665 | { | |
666 | // Change dark things to really dark | |
667 | dest.SetRGB(x,y, darkCol.Red(), darkCol.Green(), darkCol.Blue()); | |
668 | } | |
669 | } | |
670 | } | |
671 | } | |
672 | ||
673 | /* | |
674 | * Make a greyed-out image suitable for disabled buttons. | |
675 | * This code is adapted from wxNewBitmapButton in FL. | |
676 | */ | |
677 | ||
678 | bool wxCreateGreyedImage(const wxImage& in, wxImage& out) | |
679 | { | |
680 | out = in.Copy(); | |
681 | ||
682 | // assuming the pixels along the edges are of the background color | |
683 | wxColour bgCol(in.GetRed(0, 0), in.GetGreen(0, 0), in.GetBlue(0, 0)); | |
684 | ||
685 | wxColour darkCol = wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW) ; | |
686 | wxColour lightCol = wxSystemSettings::GetColour(wxSYS_COLOUR_3DHIGHLIGHT) ; | |
687 | ||
688 | wxGreyOutImage(in, out, darkCol, lightCol, bgCol); | |
689 | ||
690 | return TRUE; | |
691 | } | |
692 | ||
693 | #endif // wxUSE_TOOLBAR |