]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/clip_dnd.i
Removed unneeded assert
[wxWidgets.git] / wxPython / src / clip_dnd.i
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: clip_dnd.i
3 // Purpose: SWIG definitions for the Clipboard and Drag-n-drop classes
4 //
5 // Author: Robin Dunn
6 //
7 // Created: 31-October-1999
8 // RCS-ID: $Id$
9 // Copyright: (c) 1999 by Total Control Software
10 // Licence: wxWindows license
11 /////////////////////////////////////////////////////////////////////////////
12
13
14 %module clip_dnd
15
16 #ifndef __WXMAC__
17
18 %{
19 #include "helpers.h"
20 #include <wx/dataobj.h>
21 #include <wx/clipbrd.h>
22 #include <wx/dnd.h>
23 %}
24
25 //----------------------------------------------------------------------
26
27 %include typemaps.i
28 %include my_typemaps.i
29
30 // Import some definitions of other classes, etc.
31 %import _defs.i
32 %import misc.i
33 %import gdi.i
34
35
36 %pragma(python) code = "import wx"
37
38 //----------------------------------------------------------------------
39
40
41 enum wxDataFormatId
42 {
43 wxDF_INVALID = 0,
44 wxDF_TEXT = 1, /* CF_TEXT */
45 wxDF_BITMAP = 2, /* CF_BITMAP */
46 wxDF_METAFILE = 3, /* CF_METAFILEPICT */
47 wxDF_SYLK = 4,
48 wxDF_DIF = 5,
49 wxDF_TIFF = 6,
50 wxDF_OEMTEXT = 7, /* CF_OEMTEXT */
51 wxDF_DIB = 8, /* CF_DIB */
52 wxDF_PALETTE = 9,
53 wxDF_PENDATA = 10,
54 wxDF_RIFF = 11,
55 wxDF_WAVE = 12,
56 wxDF_UNICODETEXT = 13,
57 wxDF_ENHMETAFILE = 14,
58 wxDF_FILENAME = 15, /* CF_HDROP */
59 wxDF_LOCALE = 16,
60 wxDF_PRIVATE = 20,
61 wxDF_MAX
62 };
63
64 //----------------------------------------------------------------------
65
66 class wxDataFormat {
67 public:
68 wxDataFormat( wxDataFormatId type );
69 ~wxDataFormat();
70
71 void SetType(wxDataFormatId format);
72 wxDataFormatId GetType() const;
73
74 wxString GetId() const;
75 void SetId(const char *format);
76 };
77
78 %new wxDataFormat* wxCustomDataFormat(const wxString &id);
79 %{ // An alternate constructor...
80 wxDataFormat* wxCustomDataFormat(const wxString &id) {
81 return new wxDataFormat(id);
82 }
83 %}
84
85
86 %{
87 wxDataFormat wxPyFormatInvalid;
88 %}
89 %readonly
90 %name(wxFormatInvalid) wxDataFormat wxPyFormatInvalid;
91 %readwrite
92
93
94 //----------------------------------------------------------------------
95
96
97
98 class wxDataObject { // An abstract base class
99 public:
100 enum Direction {
101 Get = 0x01, // format is supported by GetDataHere()
102 Set = 0x02, // format is supported by SetData()
103 Both = 0x03 // format is supported by both (unused currently)
104 };
105
106 ~wxDataObject();
107
108 wxDataFormat GetPreferredFormat(Direction dir = wxDataObject::Get);
109 size_t GetFormatCount(Direction dir = wxDataObject::Get);
110 void GetAllFormats(wxDataFormat *formats,
111 Direction dir = wxDataObject::Get);
112 size_t GetDataSize(const wxDataFormat& format);
113 bool GetDataHere(const wxDataFormat& format, void *buf);
114 bool SetData(const wxDataFormat& format,
115 size_t len, const void * buf);
116 bool IsSupportedFormat(const wxDataFormat& format);
117 };
118
119 //----------------------------------------------------------------------
120
121 class wxDataObjectSimple : public wxDataObject {
122 public:
123 wxDataObjectSimple(const wxDataFormat& format = wxPyFormatInvalid);
124
125 const wxDataFormat& GetFormat();
126 void SetFormat(const wxDataFormat& format);
127
128 };
129
130
131 %{ // Create a new class for wxPython to use
132 class wxPyDataObjectSimple : public wxDataObjectSimple {
133 public:
134 wxPyDataObjectSimple(const wxDataFormat& format = wxPyFormatInvalid)
135 : wxDataObjectSimple(format) {}
136
137 DEC_PYCALLBACK_SIZET_(GetDataSize);
138 bool GetDataHere(void *buf);
139 bool SetData(size_t len, const void *buf);
140 PYPRIVATE;
141 };
142
143 IMP_PYCALLBACK_SIZET_(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
144
145 bool wxPyDataObjectSimple::GetDataHere(void *buf) {
146 // We need to get the data for this object and write it to buf. I think
147 // the best way to do this for wxPython is to have the Python method
148 // return either a string or None and then act appropriately with the
149 // C++ version.
150
151 bool rval = FALSE;
152 wxPyBeginBlockThreads();
153 if (m_myInst.findCallback("GetDataHere")) {
154 PyObject* ro;
155 ro = m_myInst.callCallbackObj(Py_BuildValue("()"));
156 if (ro) {
157 rval = (ro != Py_None && PyString_Check(ro));
158 if (rval)
159 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
160 Py_DECREF(ro);
161 }
162 }
163 wxPyEndBlockThreads();
164 return rval;
165 }
166
167 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
168 // For this one we simply need to make a string from buf and len
169 // and send it to the Python method.
170 bool rval = FALSE;
171 wxPyBeginBlockThreads();
172 if (m_myInst.findCallback("SetData")) {
173 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
174 rval = m_myInst.callCallback(Py_BuildValue("(O)", data));
175 Py_DECREF(data);
176 }
177 wxPyEndBlockThreads();
178 return rval;
179 }
180 %}
181
182
183
184 // Now define it for SWIG
185 class wxPyDataObjectSimple : public wxDataObjectSimple {
186 public:
187 wxPyDataObjectSimple(const wxDataFormat& format = wxPyFormatInvalid);
188 void _setCallbackInfo(PyObject* self, PyObject* _class);
189 %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPyDataObjectSimple)"
190 };
191
192 //----------------------------------------------------------------------
193
194 class wxDataObjectComposite : public wxDataObject {
195 public:
196 wxDataObjectComposite();
197
198 void Add(wxDataObjectSimple *dataObject, int preferred = FALSE);
199 %pragma(python) addtomethod = "Add:_args[0].thisown = 0"
200
201 };
202
203
204 //----------------------------------------------------------------------
205
206 class wxTextDataObject : public wxDataObjectSimple {
207 public:
208 wxTextDataObject(const wxString& text = wxEmptyString);
209
210 size_t GetTextLength();
211 wxString GetText();
212 void SetText(const wxString& text);
213 };
214
215
216
217 %{ // Create a new class for wxPython to use
218 class wxPyTextDataObject : public wxTextDataObject {
219 public:
220 wxPyTextDataObject(const wxString& text = wxEmptyString)
221 : wxTextDataObject(text) {}
222
223 DEC_PYCALLBACK_SIZET_(GetTextLength);
224 DEC_PYCALLBACK_STRING_(GetText);
225 DEC_PYCALLBACK__STRING(SetText);
226 PYPRIVATE;
227 };
228
229 IMP_PYCALLBACK_SIZET_(wxPyTextDataObject, wxTextDataObject, GetTextLength);
230 IMP_PYCALLBACK_STRING_(wxPyTextDataObject, wxTextDataObject, GetText);
231 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
232
233 %}
234
235
236 // Now define it for SWIG
237 class wxPyTextDataObject : public wxTextDataObject {
238 public:
239 wxPyTextDataObject(const wxString& text = wxEmptyString);
240 void _setCallbackInfo(PyObject* self, PyObject* _class);
241 %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPyTextDataObject)"
242 };
243
244 //----------------------------------------------------------------------
245
246 class wxBitmapDataObject : public wxDataObjectSimple {
247 public:
248 wxBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap);
249
250 wxBitmap GetBitmap();
251 void SetBitmap(const wxBitmap& bitmap);
252 };
253
254
255
256 %{ // Create a new class for wxPython to use
257 class wxPyBitmapDataObject : public wxBitmapDataObject {
258 public:
259 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
260 : wxBitmapDataObject(bitmap) {}
261
262 wxBitmap GetBitmap();
263 void SetBitmap(const wxBitmap& bitmap);
264 PYPRIVATE;
265 };
266
267 wxBitmap wxPyBitmapDataObject::GetBitmap() {
268 wxBitmap* rval = &wxNullBitmap;
269 wxPyBeginBlockThreads();
270 if (m_myInst.findCallback("GetBitmap")) {
271 PyObject* ro;
272 wxBitmap* ptr;
273 ro = m_myInst.callCallbackObj(Py_BuildValue("()"));
274 if (ro) {
275 if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxBitmap_p"))
276 rval = ptr;
277 Py_DECREF(ro);
278 }
279 }
280 wxPyEndBlockThreads();
281 return *rval;
282 }
283
284 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
285 wxPyBeginBlockThreads();
286 if (m_myInst.findCallback("SetBitmap")) {
287 m_myInst.callCallback(Py_BuildValue("(O)",
288 wxPyConstructObject((void*)&bitmap, "wxBitmap")));
289 }
290 wxPyEndBlockThreads();
291 }
292 %}
293
294
295
296 // Now define it for SWIG
297 class wxPyBitmapDataObject : public wxBitmapDataObject {
298 public:
299 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap);
300 void _setCallbackInfo(PyObject* self, PyObject* _class);
301 %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPyBitmapDataObject)"
302 };
303
304
305 //----------------------------------------------------------------------
306
307 class wxFileDataObject : public wxDataObjectSimple
308 {
309 public:
310 wxFileDataObject();
311
312 //const wxArrayString& GetFilenames();
313 %addmethods {
314 PyObject* GetFilenames() {
315 const wxArrayString& strings = self->GetFilenames();
316 return wxArrayString2PyList_helper(strings);
317 }
318 }
319 #ifdef __WXMSW__
320 void AddFile(const wxString &filename);
321 #endif
322 };
323
324
325 //----------------------------------------------------------------------
326
327 class wxCustomDataObject : public wxDataObjectSimple {
328 public:
329 wxCustomDataObject(const wxDataFormat& format = wxPyFormatInvalid);
330
331 //void TakeData(size_t size, void *data);
332 //bool SetData(size_t size, const void *buf);
333 %addmethods {
334 void TakeData(PyObject* data) {
335 if (PyString_Check(data)) {
336 self->SetData(PyString_Size(data), PyString_AsString(data));
337 }
338 }
339 bool SetData(PyObject* data) {
340 if (PyString_Check(data)) {
341 return self->SetData(PyString_Size(data), PyString_AsString(data));
342 }
343 return FALSE;
344 }
345 }
346
347 size_t GetSize();
348
349 //void *GetData();
350 %addmethods {
351 PyObject* GetData() {
352 return PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
353 }
354 }
355
356
357 };
358
359
360 //----------------------------------------------------------------------
361
362 class wxURLDataObject : public wxDataObjectComposite {
363 public:
364 wxURLDataObject();
365
366 wxString GetURL();
367 void SetURL(const wxString& url);
368 };
369
370 //----------------------------------------------------------------------
371
372 #ifndef __WXGTK__
373
374 %{
375 #include <wx/metafile.h>
376 %}
377
378 class wxMetafileDataObject : public wxDataObjectSimple
379 {
380 public:
381 wxMetafileDataObject();
382
383 void SetMetafile(const wxMetafile& metafile);
384 wxMetafile GetMetafile() const;
385 };
386
387 #endif
388
389 //----------------------------------------------------------------------
390 //----------------------------------------------------------------------
391 //----------------------------------------------------------------------
392
393 class wxClipboard : public wxObject {
394 public:
395 wxClipboard();
396
397 bool Open();
398 void Close();
399 bool IsOpened() const;
400
401 bool AddData( wxDataObject *data );
402 %pragma(python) addtomethod = "AddData:_args[0].thisown = 0"
403 bool SetData( wxDataObject *data );
404 %pragma(python) addtomethod = "SetData:_args[0].thisown = 0"
405
406 bool IsSupported( const wxDataFormat& format );
407 bool GetData( wxDataObject& data );
408 void Clear();
409 bool Flush();
410 void UsePrimarySelection( int primary = FALSE );
411 };
412
413 %{
414 // See below in the init function...
415 wxClipboard* wxPyTheClipboard;
416 %}
417 %readonly
418 %name(wxTheClipboard) wxClipboard* wxPyTheClipboard;
419 %readwrite
420
421 //----------------------------------------------------------------------
422 //----------------------------------------------------------------------
423
424 enum wxDragResult
425 {
426 wxDragError, // error prevented the d&d operation from completing
427 wxDragNone, // drag target didn't accept the data
428 wxDragCopy, // the data was successfully copied
429 wxDragMove, // the data was successfully moved (MSW only)
430 wxDragLink, // operation is a drag-link
431 wxDragCancel // the operation was cancelled by user (not an error)
432 };
433
434 bool wxIsDragResultOk(wxDragResult res);
435
436 //----------------------------------------------------------------------
437 %{
438 class wxPyDropSource : public wxDropSource {
439 public:
440 #ifdef __WXMSW__
441 wxPyDropSource(wxWindow *win = NULL,
442 const wxCursor &cursorCopy = wxNullCursor,
443 const wxCursor &cursorMove = wxNullCursor,
444 const wxCursor &cursorStop = wxNullCursor)
445 : wxDropSource(win, cursorCopy, cursorMove, cursorStop) {}
446 #else
447 wxPyDropSource(wxWindow *win = NULL,
448 const wxIcon &go = wxNullIcon)
449 : wxDropSource(win, go) {}
450 #endif
451 ~wxPyDropSource() { }
452
453 DEC_PYCALLBACK_BOOL_DR(GiveFeedback);
454 PYPRIVATE;
455 };
456
457 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
458
459 %}
460
461
462 %name(wxDropSource) class wxPyDropSource {
463 public:
464 #ifdef __WXMSW__
465 wxPyDropSource(wxWindow *win = NULL,
466 const wxCursor &cursorCopy = wxNullCursor,
467 const wxCursor &cursorMove = wxNullCursor,
468 const wxCursor &cursorStop = wxNullCursor);
469 #else
470 wxPyDropSource(wxWindow *win = NULL,
471 const wxIcon &go = wxNullIcon);
472 #endif
473
474 void _setCallbackInfo(PyObject* self, PyObject* _class, int incref);
475 %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxDropSource, 0)"
476 ~wxPyDropSource();
477
478 void SetData(wxDataObject& data);
479 wxDataObject *GetDataObject();
480 void SetCursor(wxDragResult res, const wxCursor& cursor);
481 wxDragResult DoDragDrop(int bAllowMove = FALSE);
482
483 bool base_GiveFeedback(wxDragResult effect);
484 };
485
486 //----------------------------------------------------------------------
487
488 // Just a place holder for the type system. The real base class for
489 // wxPython is wxPyDropTarget
490 class wxDropTarget {
491 public:
492 };
493
494
495 %{
496 class wxPyDropTarget : public wxDropTarget {
497 public:
498 wxPyDropTarget(wxDataObject *dataObject = NULL)
499 : wxDropTarget(dataObject) {}
500
501 // DEC_PYCALLBACK_SIZET_(GetFormatCount);
502 // DEC_PYCALLBACK_DATAFMT_SIZET(GetFormat);
503
504 DEC_PYCALLBACK__(OnLeave);
505 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
506 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
507 DEC_PYCALLBACK_DR_2WXCDR_pure(OnData);
508 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
509
510 PYPRIVATE;
511 };
512
513 // IMP_PYCALLBACK_SIZET_(wxPyDropTarget, wxDropTarget, GetFormatCount);
514 // IMP__PYCALLBACK_DATAFMT_SIZET(wxPyDropTarget, wxDropTarget, GetFormat);
515
516 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
517 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
518 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
519 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
520 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
521
522 %}
523
524
525 class wxPyDropTarget : public wxDropTarget {
526 public:
527 wxPyDropTarget(wxDataObject *dataObject = NULL);
528 %pragma(python) addtomethod = "__init__:if _args:_args[0].thisown = 0"
529 void _setCallbackInfo(PyObject* self, PyObject* _class);
530 %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPyDropTarget)"
531
532 ~wxPyDropTarget();
533
534 wxDataObject *GetDataObject();
535 void SetDataObject(wxDataObject *dataObject);
536 %pragma(python) addtomethod = "SetDataObject:if _args:_args[0].thisown = 0"
537
538 // size_t base_GetFormatCount();
539 // wxDataFormat base_GetFormat(size_t n);
540
541 wxDragResult base_OnEnter(wxCoord x, wxCoord y, wxDragResult def);
542 wxDragResult base_OnDragOver(wxCoord x, wxCoord y, wxDragResult def);
543 void base_OnLeave();
544 bool base_OnDrop(wxCoord x, wxCoord y);
545 //wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def) = 0;
546
547 // **** not sure about this one
548 bool GetData();
549
550 };
551
552
553 //----------------------------------------------------------------------
554
555 %{
556 class wxPyTextDropTarget : public wxTextDropTarget {
557 public:
558 wxPyTextDropTarget() {}
559
560 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
561
562 DEC_PYCALLBACK__(OnLeave);
563 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
564 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
565 DEC_PYCALLBACK_DR_2WXCDR(OnData);
566 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
567
568 PYPRIVATE;
569 };
570
571 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
572 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
573 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
574 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
575 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
576 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
577
578 %}
579
580 %name(wxTextDropTarget) class wxPyTextDropTarget : public wxPyDropTarget {
581 public:
582 wxPyTextDropTarget();
583 void _setCallbackInfo(PyObject* self, PyObject* _class);
584 %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxTextDropTarget)"
585
586 //bool OnDropText(wxCoord x, wxCoord y, const wxString& text) = 0;
587 wxDragResult base_OnEnter(wxCoord x, wxCoord y, wxDragResult def);
588 wxDragResult base_OnDragOver(wxCoord x, wxCoord y, wxDragResult def);
589 void base_OnLeave();
590 bool base_OnDrop(wxCoord x, wxCoord y);
591 wxDragResult base_OnData(wxCoord x, wxCoord y, wxDragResult def);
592 };
593
594 //----------------------------------------------------------------------
595 %{
596 class wxPyFileDropTarget : public wxFileDropTarget {
597 public:
598 wxPyFileDropTarget() {}
599
600 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
601
602 DEC_PYCALLBACK__(OnLeave);
603 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
604 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
605 DEC_PYCALLBACK_DR_2WXCDR(OnData);
606 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
607
608 PYPRIVATE;
609 };
610
611 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
612 const wxArrayString& filenames) {
613 bool rval = FALSE;
614 wxPyBeginBlockThreads();
615 PyObject* list = wxArrayString2PyList_helper(filenames);
616 if (m_myInst.findCallback("OnDropFiles"))
617 rval = m_myInst.callCallback(Py_BuildValue("(iiO)",x,y,list));
618 Py_DECREF(list);
619 wxPyEndBlockThreads();
620 return rval;
621 }
622
623
624
625 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
626 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
627 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
628 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
629 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
630
631 %}
632
633
634 %name(wxFileDropTarget) class wxPyFileDropTarget : public wxPyDropTarget
635 {
636 public:
637 wxPyFileDropTarget();
638 void _setCallbackInfo(PyObject* self, PyObject* _class);
639 %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxFileDropTarget)"
640
641 // bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames) = 0;
642 wxDragResult base_OnEnter(wxCoord x, wxCoord y, wxDragResult def);
643 wxDragResult base_OnDragOver(wxCoord x, wxCoord y, wxDragResult def);
644 void base_OnLeave();
645 bool base_OnDrop(wxCoord x, wxCoord y);
646 wxDragResult base_OnData(wxCoord x, wxCoord y, wxDragResult def);
647 };
648
649 //----------------------------------------------------------------------
650 //----------------------------------------------------------------------
651 //----------------------------------------------------------------------
652
653 %init %{
654
655 wxPyTheClipboard = wxTheClipboard;
656 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
657 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
658 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
659 %}
660
661 //----------------------------------------------------------------------
662 #endif
663