Commit | Line | Data |
---|---|---|
b4eb4c6b DW |
1 | /////////////////////////////////////////////////////////////////////////////// |
2 | // Name: msw/gdiimage.cpp | |
3 | // Purpose: wxGDIImage implementation | |
4 | // Author: Vadim Zeitlin | |
5 | // Modified by: | |
6 | // Created: 20.11.99 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr> | |
9 | // Licence: wxWindows license | |
10 | /////////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | // ============================================================================ | |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | // ---------------------------------------------------------------------------- | |
17 | // headers | |
18 | // ---------------------------------------------------------------------------- | |
19 | ||
aa213887 SN |
20 | #ifdef __GNUG__ |
21 | #pragma implementation "gdiimage.h" | |
22 | #endif | |
23 | ||
b4eb4c6b DW |
24 | // For compilers that support precompilation, includes "wx.h". |
25 | #include "wx/wxprec.h" | |
26 | ||
27 | ||
28 | #ifndef WX_PRECOMP | |
29 | #include "wx/string.h" | |
30 | #endif // WX_PRECOMP | |
31 | ||
32 | #include "wx/os2/private.h" | |
b4eb4c6b | 33 | #include "wx/app.h" |
d4714748 | 34 | #include "wx/xpmhand.h" |
b4eb4c6b DW |
35 | #include "wx/os2/gdiimage.h" |
36 | ||
37 | // ---------------------------------------------------------------------------- | |
38 | // private classes | |
39 | // ---------------------------------------------------------------------------- | |
40 | ||
41 | // all image handlers are declared/defined in this file because the outside | |
42 | // world doesn't have to know about them (but only about wxBITMAP_TYPE_XXX ids) | |
43 | ||
44 | class WXDLLEXPORT wxBMPFileHandler : public wxBitmapHandler | |
45 | { | |
46 | public: | |
47 | wxBMPFileHandler() : wxBitmapHandler(_T("Windows bitmap file"), _T("bmp"), | |
48 | wxBITMAP_TYPE_BMP) | |
49 | { | |
50 | } | |
51 | ||
52 | virtual bool LoadFile( wxBitmap* pBitmap | |
53 | ,const wxString& rName | |
54 | ,HPS hPs | |
55 | ,long lFlags | |
56 | ,int nDesiredWidth | |
57 | ,int nDesiredHeight | |
58 | ); | |
59 | virtual bool SaveFile( wxBitmap* pBitmap | |
60 | ,const wxString& rName | |
61 | ,int lType | |
62 | ,const wxPalette* pPalette = NULL | |
63 | ); | |
64 | ||
65 | private: | |
66 | DECLARE_DYNAMIC_CLASS(wxBMPFileHandler) | |
67 | }; | |
68 | ||
69 | class WXDLLEXPORT wxBMPResourceHandler: public wxBitmapHandler | |
70 | { | |
71 | public: | |
72 | wxBMPResourceHandler() : wxBitmapHandler(_T("Windows bitmap resource"), | |
73 | wxEmptyString, | |
74 | wxBITMAP_TYPE_BMP_RESOURCE) | |
75 | { | |
76 | } | |
77 | ||
78 | virtual bool LoadFile( wxBitmap* pBitmap | |
79 | ,const wxString& rName | |
80 | ,HPS hPs | |
81 | ,long lFlags | |
82 | ,int nDesiredWidth | |
83 | ,int nDesiredHeight | |
84 | ); | |
85 | ||
86 | private: | |
87 | DECLARE_DYNAMIC_CLASS(wxBMPResourceHandler) | |
88 | }; | |
89 | ||
90 | class WXDLLEXPORT wxIconHandler : public wxGDIImageHandler | |
91 | { | |
92 | public: | |
93 | wxIconHandler( const wxString& rName | |
94 | ,const wxString& rExt | |
95 | ,long lType | |
96 | ) : wxGDIImageHandler( rName | |
97 | ,rExt | |
98 | ,lType | |
99 | ) | |
100 | { | |
101 | } | |
102 | ||
103 | // creating and saving icons is not supported | |
104 | virtual bool Create( wxGDIImage* WXUNUSED(pImage) | |
105 | ,void* WXUNUSED(pData) | |
106 | ,long WXUNUSED(lFlags) | |
107 | ,int WXUNUSED(nWidth) | |
108 | ,int WXUNUSED(nHeight) | |
109 | ,int WXUNUSED(nDepth) = 1 | |
110 | ) | |
111 | { | |
112 | return(FALSE); | |
113 | } | |
114 | ||
115 | virtual bool Save( wxGDIImage* WXUNUSED(pImage) | |
116 | ,const wxString& WXUNUSED(rName) | |
117 | ,int WXUNUSED(nType) | |
118 | ) | |
119 | { | |
120 | return(FALSE); | |
121 | } | |
122 | virtual bool Load( wxGDIImage* pImage | |
123 | ,const wxString& rName | |
124 | ,HPS hPs | |
125 | ,long lFlags | |
126 | ,int nDesiredWidth | |
127 | ,int nDesiredHeight | |
128 | ) | |
129 | { | |
130 | wxIcon* pIcon = wxDynamicCast(pImage, wxIcon); | |
131 | wxCHECK_MSG(pIcon, FALSE, _T("wxIconHandler only works with icons")); | |
132 | ||
133 | return LoadIcon( pIcon | |
134 | ,rName | |
135 | ,hPs | |
136 | ,lFlags | |
137 | ,nDesiredWidth | |
138 | ,nDesiredHeight | |
139 | ); | |
140 | } | |
141 | ||
142 | protected: | |
143 | virtual bool LoadIcon( wxIcon* pIcon | |
144 | ,const wxString& rName | |
145 | ,HPS hPs | |
146 | ,long lFlags | |
147 | ,int nDesiredWidth = -1 | |
148 | ,int nDesiredHeight = -1 | |
149 | ) = 0; | |
150 | }; | |
151 | ||
152 | class WXDLLEXPORT wxICOFileHandler : public wxIconHandler | |
153 | { | |
154 | public: | |
155 | wxICOFileHandler() : wxIconHandler(_T("ICO icon file"), | |
156 | _T("ico"), | |
157 | wxBITMAP_TYPE_ICO) | |
158 | { | |
159 | } | |
160 | ||
161 | virtual bool LoadIcon( wxIcon * pIcon | |
162 | ,const wxString& rName | |
163 | ,HPS hPs | |
164 | ,long lFlags | |
165 | ,int nDesiredWidth = -1 | |
166 | ,int nDesiredHeight = -1 | |
167 | ); | |
168 | ||
169 | private: | |
170 | DECLARE_DYNAMIC_CLASS(wxICOFileHandler) | |
171 | }; | |
172 | ||
173 | class WXDLLEXPORT wxICOResourceHandler: public wxIconHandler | |
174 | { | |
175 | public: | |
176 | wxICOResourceHandler() : wxIconHandler(_T("ICO resource"), | |
177 | _T("ico"), | |
178 | wxBITMAP_TYPE_ICO_RESOURCE) | |
179 | { | |
180 | } | |
181 | ||
182 | virtual bool LoadIcon( wxIcon* pIcon | |
183 | ,const wxString& rName | |
184 | ,HPS hPs | |
185 | ,long lFlags | |
186 | ,int nDesiredWidth = -1 | |
187 | ,int nDesiredHeight = -1 | |
188 | ); | |
189 | ||
190 | private: | |
191 | DECLARE_DYNAMIC_CLASS(wxICOResourceHandler) | |
192 | }; | |
193 | ||
194 | // ---------------------------------------------------------------------------- | |
195 | // wxWin macros | |
196 | // ---------------------------------------------------------------------------- | |
197 | ||
198 | #if !USE_SHARED_LIBRARIES | |
199 | IMPLEMENT_DYNAMIC_CLASS(wxBMPFileHandler, wxBitmapHandler) | |
200 | IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler) | |
201 | IMPLEMENT_DYNAMIC_CLASS(wxICOFileHandler, wxGDIImageHandler) | |
202 | IMPLEMENT_DYNAMIC_CLASS(wxICOResourceHandler, wxGDIImageHandler) | |
203 | #endif | |
204 | ||
205 | // ---------------------------------------------------------------------------- | |
206 | // private functions | |
207 | // ---------------------------------------------------------------------------- | |
208 | ||
209 | static wxSize GetHiconSize(WXHICON hicon); | |
210 | ||
211 | // ============================================================================ | |
212 | // implementation | |
213 | // ============================================================================ | |
214 | ||
215 | wxList wxGDIImage::ms_handlers; | |
216 | ||
217 | // ---------------------------------------------------------------------------- | |
218 | // wxGDIImage functions forwarded to wxGDIImageRefData | |
219 | // ---------------------------------------------------------------------------- | |
220 | ||
221 | bool wxGDIImage::FreeResource( | |
222 | bool WXUNUSED(bForce) | |
223 | ) | |
224 | { | |
225 | if ( !IsNull() ) | |
226 | { | |
227 | GetGDIImageData()->Free(); | |
228 | GetGDIImageData()->m_hHandle = 0; | |
229 | } | |
230 | ||
231 | return(TRUE); | |
232 | } | |
233 | ||
234 | WXHANDLE wxGDIImage::GetResourceHandle() | |
235 | { | |
236 | return GetHandle(); | |
237 | } | |
238 | ||
239 | // ---------------------------------------------------------------------------- | |
240 | // wxGDIImage handler stuff | |
241 | // ---------------------------------------------------------------------------- | |
242 | ||
243 | void wxGDIImage::AddHandler( | |
244 | wxGDIImageHandler* pHandler | |
245 | ) | |
246 | { | |
247 | ms_handlers.Append(pHandler); | |
248 | } | |
249 | ||
250 | void wxGDIImage::InsertHandler( | |
251 | wxGDIImageHandler* pHandler | |
252 | ) | |
253 | { | |
254 | ms_handlers.Insert(pHandler); | |
255 | } | |
256 | ||
257 | bool wxGDIImage::RemoveHandler( | |
258 | const wxString& rName | |
259 | ) | |
260 | { | |
261 | wxGDIImageHandler* pHandler = FindHandler(rName); | |
262 | ||
263 | if (pHandler) | |
264 | { | |
265 | ms_handlers.DeleteObject(pHandler); | |
266 | return(TRUE); | |
267 | } | |
268 | else | |
269 | return(FALSE); | |
270 | } | |
271 | ||
272 | wxGDIImageHandler* wxGDIImage::FindHandler( | |
273 | const wxString& rName | |
274 | ) | |
275 | { | |
276 | wxNode* pNode = ms_handlers.First(); | |
277 | ||
278 | while (pNode) | |
279 | { | |
280 | wxGDIImageHandler* pHandler = (wxGDIImageHandler *)pNode->Data(); | |
281 | ||
282 | if (pHandler->GetName() == rName) | |
283 | return(pHandler); | |
284 | pNode = pNode->Next(); | |
285 | } | |
286 | return(NULL); | |
287 | } | |
288 | ||
289 | wxGDIImageHandler* wxGDIImage::FindHandler( | |
290 | const wxString& rExtension | |
291 | , long lType | |
292 | ) | |
293 | { | |
294 | wxNode* pNode = ms_handlers.First(); | |
295 | ||
296 | while (pNode) | |
297 | { | |
298 | wxGDIImageHandler* pHandler = (wxGDIImageHandler *)pNode->Data(); | |
299 | ||
300 | if ((pHandler->GetExtension() = rExtension) && | |
301 | (lType == -1 || pHandler->GetType() == lType)) | |
302 | { | |
303 | return(pHandler); | |
304 | } | |
305 | pNode = pNode->Next(); | |
306 | } | |
307 | return(NULL); | |
308 | } | |
309 | ||
310 | wxGDIImageHandler* wxGDIImage::FindHandler( | |
311 | long lType | |
312 | ) | |
313 | { | |
314 | wxNode* pNode = ms_handlers.First(); | |
315 | ||
316 | while (pNode) | |
317 | { | |
318 | wxGDIImageHandler* pHandler = (wxGDIImageHandler *)pNode->Data(); | |
319 | ||
320 | if (pHandler->GetType() == lType) | |
321 | return pHandler; | |
322 | pNode = pNode->Next(); | |
323 | } | |
324 | return(NULL); | |
325 | } | |
326 | ||
327 | void wxGDIImage::CleanUpHandlers() | |
328 | { | |
329 | wxNode* pNode = ms_handlers.First(); | |
330 | ||
331 | while (pNode) | |
332 | { | |
333 | wxGDIImageHandler* pHandler = (wxGDIImageHandler *)pNode->Data(); | |
334 | wxNode* pNext = pNode->Next(); | |
335 | ||
336 | delete pHandler; | |
f6bcfd97 | 337 | #if (!(defined(__VISAGECPP__) && (__IBMCPP__ < 400 || __IBMC__ < 400 ))) |
b4eb4c6b | 338 | delete pNode; |
f6bcfd97 | 339 | #endif |
b4eb4c6b DW |
340 | pNode = pNext; |
341 | } | |
342 | } | |
343 | ||
344 | void wxGDIImage::InitStandardHandlers() | |
345 | { | |
346 | AddHandler(new wxBMPResourceHandler); | |
347 | AddHandler(new wxBMPFileHandler); | |
348 | ||
d4714748 DW |
349 | AddHandler(new wxXPMFileHandler); |
350 | AddHandler(new wxXPMDataHandler); | |
b4eb4c6b DW |
351 | |
352 | AddHandler(new wxICOResourceHandler); | |
353 | AddHandler(new wxICOFileHandler); | |
354 | } | |
355 | ||
356 | // ---------------------------------------------------------------------------- | |
357 | // wxBitmap handlers | |
358 | // ---------------------------------------------------------------------------- | |
359 | ||
360 | bool wxBMPResourceHandler::LoadFile( | |
361 | wxBitmap* pBitmap | |
362 | , const wxString& rName | |
363 | , HPS hPs | |
364 | , long lFlags | |
365 | , int nDesiredWidth | |
366 | , int nDesiredHeight | |
367 | ) | |
368 | { | |
369 | // TODO: load a bitmap from a file | |
370 | /* | |
371 | rBitmap->SetHBITMAP((WXHBITMAP)::LoadBitmap(wxGetInstance(), rName)); | |
372 | ||
373 | wxBitmapRefData* pData = bitmap->GetBitmapData(); | |
374 | ||
375 | if (pBitmap->Ok()) | |
376 | { | |
377 | BITMAP bm; | |
378 | ||
379 | if ( !::GetObject(GetHbitmapOf(*pBitmap), sizeof(BITMAP), (LPSTR) &bm) ) | |
380 | { | |
381 | wxLogLastError("GetObject(HBITMAP)"); | |
382 | } | |
383 | ||
384 | data->m_width = bm.bmWidth; | |
385 | data->m_height = bm.bmHeight; | |
386 | data->m_depth = bm.bmBitsPixel; | |
387 | } | |
388 | else | |
389 | { | |
390 | // it's probably not found | |
391 | wxLogError(wxT("Can't load bitmap '%s' from resources! Check .rc file."), | |
392 | name.c_str()); | |
393 | } | |
394 | ||
395 | return bitmap->Ok(); | |
396 | */ | |
397 | return(FALSE); | |
398 | } | |
399 | ||
400 | bool wxBMPFileHandler::LoadFile( | |
401 | wxBitmap* pBitmap | |
402 | , const wxString& rName | |
403 | , HPS hPs | |
404 | , long WXUNUSED(lFlags) | |
405 | , int WXUNUSED(nDesiredWidth) | |
406 | , int WXUNUSED(nDesiredHeight) | |
407 | ) | |
408 | { | |
409 | #if wxUSE_IMAGE_LOADING_IN_OS2 | |
410 | wxPalette* pPalette = NULL; | |
411 | ||
412 | bool bSuccess = FALSE; /* wxLoadIntoBitmap( WXSTRINGCAST rName | |
413 | ,pBitmap | |
414 | ,&pPalette | |
415 | ) != 0; */ | |
416 | if (bSuccess && pPalette) | |
417 | { | |
418 | pBitmap->SetPalette(*pPalette); | |
419 | } | |
420 | ||
421 | // it was copied by the bitmap if it was loaded successfully | |
422 | delete pPalette; | |
423 | ||
424 | return(bSuccess); | |
425 | #else | |
426 | return(FALSE); | |
427 | #endif | |
428 | } | |
429 | ||
430 | bool wxBMPFileHandler::SaveFile( | |
431 | wxBitmap* pBitmap | |
432 | , const wxString& rName | |
433 | , int WXUNUSED(nType) | |
434 | , const wxPalette* pPal | |
435 | ) | |
436 | { | |
437 | #if wxUSE_IMAGE_LOADING_IN_OS2 | |
438 | wxPalette* pActualPalette = (wxPalette *)pPal; | |
439 | ||
440 | if (!pActualPalette) | |
441 | pActualPalette = pBitmap->GetPalette(); | |
442 | /* return(wxSaveBitmap( WXSTRINGCAST rName | |
443 | ,pBitmap | |
444 | ,pActualPalette | |
445 | ) != 0); */ | |
446 | return(FALSE); | |
447 | #else | |
448 | return(FALSE); | |
449 | #endif | |
450 | } | |
451 | ||
452 | // ---------------------------------------------------------------------------- | |
453 | // wxIcon handlers | |
454 | // ---------------------------------------------------------------------------- | |
455 | ||
456 | bool wxICOFileHandler::LoadIcon( | |
457 | wxIcon* pIcon | |
458 | , const wxString& rName | |
459 | , HPS hPs | |
460 | , long lFlags | |
461 | , int nDesiredWidth | |
462 | , int nDesiredHeight | |
463 | ) | |
464 | { | |
465 | #if wxUSE_RESOURCE_LOADING_IN_OS2 | |
466 | pIcon->UnRef(); | |
467 | ||
468 | // actual size | |
469 | wxSize vSize; | |
470 | ||
471 | // TODO: load icon directly from a file | |
472 | /* | |
473 | #ifdef __WIN32__ | |
474 | HICON hicon = ::ExtractIcon(wxGetInstance(), name, first); | |
475 | if ( !hicon ) | |
476 | { | |
477 | wxLogSysError(_T("Failed to load icon from the file '%s'"), | |
478 | name.c_str()); | |
479 | ||
480 | return FALSE; | |
481 | } | |
482 | ||
483 | size = GetHiconSize(hicon); | |
484 | #else // Win16 | |
485 | HICON hicon = ReadIconFile((wxChar *)name.c_str(), | |
486 | wxGetInstance(), | |
487 | &size.x, &size.y); | |
488 | #endif // Win32/Win16 | |
489 | ||
490 | if ( (desiredWidth != -1 && desiredWidth != size.x) || | |
491 | (desiredHeight != -1 && desiredHeight != size.y) ) | |
492 | { | |
493 | wxLogDebug(_T("Returning FALSE from wxICOFileHandler::Load because " | |
494 | "of the size mismatch: actual (%d, %d), " | |
495 | "requested (%d, %d)"), | |
496 | size.x, size.y, | |
497 | desiredWidth, desiredHeight); | |
498 | ||
499 | ::DestroyIcon(hicon); | |
500 | ||
501 | return FALSE; | |
502 | } | |
503 | ||
504 | icon->SetHICON((WXHICON)hicon); | |
505 | icon->SetSize(size.x, size.y); | |
506 | ||
507 | return icon->Ok(); | |
508 | */ | |
509 | return(FALSE); | |
510 | #else | |
511 | return(FALSE); | |
512 | #endif | |
513 | } | |
514 | ||
515 | bool wxICOResourceHandler::LoadIcon( | |
516 | wxIcon* pIcon | |
517 | , const wxString& rName | |
518 | , HPS hPs | |
519 | , long lFlags | |
22e90769 DW |
520 | , int WXUNUSED(nDesiredWidth) |
521 | , int WXUNUSED(nDesiredHeight) | |
b4eb4c6b DW |
522 | ) |
523 | { | |
22e90769 | 524 | HPOINTER hIcon; |
b4eb4c6b | 525 | |
22e90769 DW |
526 | hIcon = ::WinLoadFileIcon( (PSZ)rName.c_str() |
527 | ,TRUE // load for private use | |
528 | ); | |
b4eb4c6b | 529 | |
22e90769 | 530 | pIcon->SetSize(32, 32); // all OS/2 icons are 32 x 32 |
b4eb4c6b | 531 | |
b4eb4c6b | 532 | |
22e90769 | 533 | pIcon->SetHICON((WXHICON)hIcon); |
b4eb4c6b | 534 | |
22e90769 DW |
535 | return pIcon->Ok(); |
536 | } // end of wxICOResourceHandler::LoadIcon | |
b4eb4c6b DW |
537 | |
538 | // ---------------------------------------------------------------------------- | |
539 | // private functions | |
540 | // ---------------------------------------------------------------------------- | |
541 | ||
542 | static wxSize GetHiconSize( | |
543 | WXHICON hicon | |
544 | ) | |
545 | { | |
546 | wxSize vSize(32, 32); // default | |
547 | ||
548 | // all OS/2 icons are 32x32 | |
549 | return(vSize); | |
550 | } | |
551 |