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