advapi32: LookupAccountSid buffer size query tests.
[wine] / dlls / glut32 / glut.c
1 /*
2  * Copyright 2003 Jacek Caban
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17  */
18
19 #include <stdarg.h>
20 #include "windef.h"
21 #include "winbase.h"
22
23 static void (*__glutExitFunc)(int ret) = 0;
24
25 /***************************************************
26  *      DllMain [glut32.init]
27  */
28 BOOL WINAPI DllMain(HINSTANCE hInstDll, DWORD fdwReason, LPVOID lpvReserved)
29 {
30    if(fdwReason == DLL_PROCESS_DETACH)  {
31       if(__glutExitFunc)
32          __glutExitFunc(0);
33    }
34    return TRUE;
35 }
36
37 /****************************************************
38  *      glutGetColor (glut32.@)
39  */
40 extern float glutGetColor(int arg1, int arg2);
41 float WINAPI wine_glutGetColor(int arg1, int arg2)
42 {
43    return glutGetColor(arg1, arg2);
44 }
45
46 /****************************************************
47  *      glutBitmapLength (glut32.@)
48  */
49 extern int glutBitmapLength(void *arg1, void *arg2);
50 int WINAPI wine_glutBitmapLength(void *arg1, void *arg2)
51 {
52    return glutBitmapLength(arg1, arg2);
53 }
54
55 /****************************************************
56  *      glutBitmapWith (glut32.@)
57  */
58 extern int glutBitmapWidth(void *arg1, int arg2);
59 int WINAPI wine_glutBitmapWidth(void *arg1, int arg2)
60 {
61    return glutBitmapWidth(arg1, arg2);
62 }
63
64 /****************************************************
65  *      glutCreateMenu (glut32.@)
66  */
67 extern int glutCreateMenu(void *arg);
68 int WINAPI wine_glutCreateMenu(void *arg)
69 {
70    return glutCreateMenu(arg);
71 }
72
73 /****************************************************
74  *      __glutCreateMenuWithExit (glut32.@)
75  */
76 int WINAPI wine___glutCreateMenuWithExit(void *arg1, void (*exitfunc)(int))
77 {
78    __glutExitFunc = exitfunc;
79    return glutCreateMenu(arg1);
80 }
81
82 /*****************************************************
83  *      glutCreateSubWindow (glut32.@)
84  */
85 extern int glutCreateSubWindow(int arg1, int arg2, int arg3, int arg4, int arg5);
86 int WINAPI wine_glutCreateSubWindow(int arg1, int arg2, int arg3, int arg4, int arg5)
87 {
88    return glutCreateSubWindow(arg1, arg2, arg3, arg4, arg5);
89 }
90
91 /*****************************************************
92  *      glutCreateWindow (glut32.@)
93  */
94 extern int glutCreateWindow(void *arg);
95 int WINAPI wine_glutCreateWindow(void *arg)
96 {
97    return glutCreateWindow(arg);
98 }
99
100 /****************************************************
101  *      __glutCreateWindowWithExit (glut32.@)
102  */
103 int WINAPI wine___glutCreateWindowWithExit(void *arg, void (*exitfunc)(int))
104 {
105    __glutExitFunc = exitfunc;
106    return glutCreateWindow(arg);
107 }
108
109 /*****************************************************
110  *      glutDeviceGet (glut32.@)
111  */
112 extern int glutDeviceGet(int arg);
113 int WINAPI wine_glutDeviceGet(int arg)
114 {
115    return glutDeviceGet(arg);
116 }
117
118 /****************************************************
119  *      glutEnterGameMode (glut32.@)
120  */
121 extern int glutEnterGameMode(void);
122 int WINAPI wine_glutEnterGameMode(void)
123 {
124    return glutEnterGameMode();
125 }
126
127 /****************************************************
128  *      glutExtensionSupported (glut32.@)
129  */
130 extern int glutExtensionSupported(void *arg);
131 int WINAPI wine_glutExtensionSupported(void *arg)
132 {
133    return glutExtensionSupported(arg);
134 }
135
136 /****************************************************
137  *      glutGameModeGet (glut32.@)
138  */
139 extern int glutGameModeGet(int arg);
140 int WINAPI wine_glutGameModeGet(int arg)
141 {
142    return glutGameModeGet(arg);
143 }
144
145 /****************************************************
146  *      glutGetMenu (glut32.@)
147  */
148 extern int glutGetMenu(void);
149 int WINAPI wine_glutGetMenu(void)
150 {
151    return wine_glutGetMenu();
152 }
153
154 /****************************************************
155  *      glutGetModifiers (glut32.@)
156  */
157 extern int glutGetModifiers(void);
158 int WINAPI wine_glutGetModifiers(void)
159 {
160    return glutGetModifiers();
161 }
162
163 /****************************************************
164  *      glutGet (glut32.@)
165  */
166 extern int glutGet(int arg);
167 int WINAPI wine_glutGet(int arg)
168 {
169    return glutGet(arg);
170 }
171
172 /****************************************************
173  *      glutGetWindow (glut32.@)
174  */
175 extern int glutGetWindow(void);
176 int WINAPI wine_glutGetWindow(void)
177 {
178    return glutGetWindow();
179 }
180
181 /****************************************************
182  *      glutLayerGet (glut32.@)
183  */
184 extern int glutLayerGet(int arg);
185 int WINAPI wine_glutLayerGet(int arg)
186 {
187    return glutLayerGet(arg);
188 }
189
190 /****************************************************
191  *      glutStrokeLength (glut32.@)
192  */
193 extern int glutStrokeLength(void *arg1, void* arg2);
194 int WINAPI wine_glutStrokeLength(void *arg1, void *arg2)
195 {
196    return glutStrokeLength(arg1, arg2);
197 }
198
199 /****************************************************
200  *      glutStrokeWidth (glut32.@)
201  */
202 extern int glutStrokeWidth(void *arg1, int arg2);
203 int WINAPI wine_glutStrokeWidth(void *arg1, int arg2)
204 {
205    return glutStrokeWidth(arg1, arg2);
206 }
207
208 /****************************************************
209  *      glutVideoResizeGet (glut32.@)
210  */
211 extern int glutVideoResizeGet(int arg);
212 int WINAPI wine_glutVideoResizeGet(int arg)
213 {
214    return glutVideoResizeGet(arg);
215 }
216
217 /****************************************************
218  *      glutAddMenuEntry (glut32.@)
219  */
220 extern void glutAddMenuEntry(void *arg1, int arg2);
221 void WINAPI wine_glutAddMenuEntry(void *arg1, int arg2)
222 {
223    glutAddMenuEntry(arg1, arg2);
224 }
225
226 /****************************************************
227  *      glutAddSubMenu (glut32.@)
228  */
229 extern void glutAddSubMenu(void *arg1, int arg2);
230 void WINAPI wine_glutAddSubMenu(void *arg1, int arg2)
231 {
232    glutAddSubMenu(arg1, arg2);
233 }
234
235 /****************************************************
236  *      glutAttachMenu (glut32.@)
237  */
238 extern void glutAttachMenu(int arg);
239 void WINAPI wine_glutAttachMenu(int arg)
240 {
241    glutAttachMenu(arg);
242 }
243
244 /****************************************************
245  *      glutBitmapCharacter (glut32.@)
246  */
247 extern void glutBitmapCharacter(void *arg1, int arg2);
248 void WINAPI wine_glutBitmapCharacter(void *arg1, int arg2)
249 {
250    glutBitmapCharacter(arg1, arg2);
251 }
252
253 /****************************************************
254  *      glutButtonBoxFunc (glut32.@)
255  */
256 extern void glutButtonBoxFunc(void *arg);
257 void WINAPI wine_glutButtonBoxFunc(void *arg)
258 {
259    glutButtonBoxFunc(arg);
260 }
261
262 /****************************************************
263  *      glutChangeToMenuEntry (glut32.@)
264  */
265 extern void glutChangeToMenuEntry(int arg1, void *arg2, int arg3);
266 void WINAPI wine_glutChangeToMenuEntry(int arg1, void *arg2, int arg3)
267 {
268    glutChangeToMenuEntry(arg1, arg2, arg3);
269 }
270
271 /****************************************************
272  *      glutChangeToSubMenu (glut32.@)
273  */
274 extern void glutChangeToSubMenu(int arg1, void *arg2, int arg3);
275 void WINAPI wine_glutChangeToSubMenu(int arg1, void *arg2, int arg3)
276 {
277    glutChangeToSubMenu(arg1, arg2, arg3);
278 }
279
280 /****************************************************
281  *      glutCopyColormap (glut32.@)
282  */
283 extern void glutCopyColormap(int arg);
284 void WINAPI wine_glutCopyColormap(int arg)
285 {
286    glutCopyColormap(arg);
287 }
288
289 /****************************************************
290  *      glutDestroyMenu (glut32.@)
291  */
292 extern void glutDestroyMenu(int arg);
293 void WINAPI wine_glutDestroyMenu(int arg)
294 {
295    glutDestroyMenu(arg);
296 }
297
298 /****************************************************
299  *      glutDestroyWindow (glut32.@)
300  */
301 extern void glutDestroyWindow(int arg);
302 void WINAPI wine_glutDestroyWindow(int arg)
303 {
304    glutDestroyWindow(arg);
305 }
306
307 /****************************************************
308  *      glutDetachMenu (glut32.@)
309  */
310 extern void glutDetachMenu(int arg);
311 void WINAPI wine_glutDetachMenu(int arg)
312 {
313    glutDetachMenu(arg);
314 }
315
316 /****************************************************
317  *      glutDialsFunc (glut32.@)
318  */
319 extern void glutDialsFunc(void *arg);
320 void WINAPI wine_glutDialsFunc(void *arg)
321 {
322    glutDialsFunc(arg);
323 }
324
325 /*******************************************************
326  *      glutDisplayFunc (glut32.@)
327  */
328 extern void glutDisplayFunc(void *arg);
329 void WINAPI wine_glutDisplayFunc(void *arg)
330 {
331    glutDisplayFunc(arg);
332 }
333
334 /*******************************************************
335  *      glutEntryFunc (glut32.@)
336  */
337 extern void glutEntryFunc(void *arg);
338 void WINAPI wine_glutEntryFunc(void *arg)
339 {
340    glutEntryFunc(arg);
341 }
342
343 /*******************************************************
344  *      glutEstablishOverlay (glut32.@)
345  */
346 extern void glutEstablishOverlay(void);
347 void WINAPI wine_glutEstablishOverlay(void)
348 {
349    glutEstablishOverlay();
350 }
351
352 /*******************************************************
353  *      glutForceJoystickFunc (glut32.@)
354  */
355 extern void glutForceJoystickFunc(void);
356 void WINAPI wine_glutForceJoystickFunc(void)
357 {
358    glutForceJoystickFunc();
359 }
360
361 /*******************************************************
362  *      glutFullScreen (glut32.@)
363  */
364 extern void glutFullScreen(void);
365 void WINAPI wine_glutFullScreen(void)
366 {
367    glutFullScreen();
368 }
369
370 /*******************************************************
371  *      glutGameModeString (glut32.@)
372  */
373 extern void glutGameModeString(void *arg);
374 void WINAPI wine_glutGameModeString(void *arg)
375 {
376    glutGameModeString(arg);
377 }
378
379 /*******************************************************
380  *      glutHideOverlay (glut32.@)
381  */
382 extern void glutHideOverlay(void);
383 void WINAPI wine_glutHideOverlay(void)
384 {
385    glutHideOverlay();
386 }
387
388 /*******************************************************
389  *      glutHideWindow (glut32.@)
390  */
391 extern void glutHideWindow(void);
392 void WINAPI wine_glutHideWindow(void)
393 {
394    glutHideWindow();
395 }
396
397 /*******************************************************
398  *      glutIconifyWindow (glut32.@)
399  */
400 extern void glutIconifyWindow(void);
401 void WINAPI wine_glutIconifyWindow(void)
402 {
403    glutIconifyWindow();
404 }
405
406 /*********************************************
407  *      glutIdleFunc (glut32.@)
408  */
409 extern void glutIdleFunc(void *arg);
410 void WINAPI wine_glutIdleFunc(void *arg)
411 {
412    glutIdleFunc(arg);
413 }
414
415 /*********************************************
416  *      glutIgnoreKeyRepeat (glut32.@)
417  */
418 extern void glutIgnoreKeyRepeat(int arg);
419 void WINAPI wine_glutIgnoreKeyRepeat(int arg)
420 {
421    glutIgnoreKeyRepeat(arg);
422 }
423
424 /**********************************************
425  *      glutInitDisplayMode (glut32.@)
426  */
427 extern void glutInitDisplayMode(unsigned int arg);
428 void WINAPI wine_glutInitDisplayMode(unsigned int arg)
429 {
430    glutInitDisplayMode(arg);
431 }
432
433 /**********************************************
434  *      glutInitDisplayString (glut32.@)
435  */
436 extern void glutInitDisplayString(void *arg);
437 void WINAPI wine_glutInitDisplayString(void *arg)
438 {
439    glutInitDisplayString(arg);
440 }
441
442 /**********************************************
443  *      glutInit (glut32.@)
444  */
445 extern void glutInit(void *arg1, void *arg2);
446 void WINAPI wine_glutInit(void *arg1, void **arg2)
447 {
448    glutInit(arg1, arg2);
449 }
450
451 /**********************************************
452  *      __glutInitWithExit (glut32.@)
453  */
454 void WINAPI wine___glutInitWithExit(void *arg1, void *arg2, void (*exitfunc)(int))
455 {
456    __glutExitFunc = exitfunc;
457    glutInit(arg1, arg2);
458 }
459
460 /***********************************************
461  *      glutInitWindowPosition (glut32.@)
462  */
463 extern void glutInitWindowPosition(int arg1, int arg2);
464 void WINAPI wine_glutInitWindowPosition(int arg1, int arg2)
465 {
466    glutInitWindowPosition(arg1, arg2);
467 }
468
469 /***********************************************
470  *      glutInitWindowSize (glut32.@)
471  */
472 extern void glutInitWindowSize(int arg1, int arg2);
473 void WINAPI wine_glutInitWindowSize(int arg1, int arg2)
474 {
475    glutInitWindowSize(arg1, arg2);
476 }
477
478 /***********************************************
479  *      glutJoystickFunc (glut32.@)
480  */
481 extern void glutJoystickFunc(void *arg1, int arg2);
482 void WINAPI wine_glutJoystickFunc(void *arg1, int arg2)
483 {
484    glutJoystickFunc(arg1, arg2);
485 }
486
487 /***********************************************
488  *      glutKeyboardFunc (glut32.@)
489  */
490 extern void glutKeyboardFunc(void *arg);
491 void WINAPI wine_glutKeyboardFunc(void *arg)
492 {
493    glutKeyboardFunc(arg);
494 }
495
496 /***********************************************
497  *      glutKeyboardUpFunc (glut32.@)
498  */
499 extern void glutKeyboardUpFunc(void *arg);
500 void WINAPI wine_glutKeyboardUpFunc(void *arg)
501 {
502    glutKeyboardUpFunc(arg);
503 }
504
505 /***********************************************
506  *      glutLeaveGameMode (glut32.@)
507  */
508 extern void glutLeaveGameMode(void);
509 void WINAPI wine_glutLeaveGameMode(void)
510 {
511    glutLeaveGameMode();
512 }
513
514 /***********************************************
515  *      glutMainLoop (glut32.@)
516  */
517 extern void glutMainLoop(void);
518 void WINAPI wine_glutMainLoop(void)
519 {
520    glutMainLoop();
521 }
522
523 /***********************************************
524  *      glutMenuStateFunc(glut32.@)
525  */
526 extern void glutMenuStateFunc(void *arg);
527 void WINAPI wine_glutMenuStateFunc(void *arg)
528 {
529    glutMenuStateFunc(arg);
530 }
531
532 /***********************************************
533  *      glutMenuStatusFunc (glut32.@)
534  */
535 extern void glutMenuStatusFunc(void *arg);
536 void WINAPI wine_glutMenuStatusFunc(void *arg)
537 {
538    glutMenuStatusFunc(arg);
539 }
540
541 /***********************************************
542  *      glutMotionFunc (glut32.@)
543  */
544 extern void glutMotionFunc(void *arg);
545 void WINAPI wine_glutMotionFunc(void *arg)
546 {
547    glutMotionFunc(arg);
548 }
549
550 /********************************************
551  *      glutMouseFunc (glut32.@)
552  */
553 extern void glutMouseFunc(void *arg);
554 void WINAPI wine_glutMouseFunc(void *arg)
555 {
556    glutMouseFunc(arg);
557 }
558
559 /********************************************
560  *      glutOverlayDisplayFunc (glut32.@)
561  */
562 extern void glutOverlayDisplayFunc(void *arg);
563 void WINAPI wine_glutOverlayDisplayFunc(void *arg)
564 {
565    glutOverlayDisplayFunc(arg);
566 }
567
568 /********************************************
569  *      glutPassiveMotionFunc (glut32.@)
570  */
571 extern void glutPassiveMotionFunc(void *arg);
572 void WINAPI wine_glutPassiveMotionFunc(void *arg)
573 {
574    glutPassiveMotionFunc(arg);
575 }
576
577 /********************************************
578  *      glutPopWindow (glut32.@)
579  */
580 extern void glutPopWindow(void);
581 void WINAPI wine_glutPopWindow(void)
582 {
583    glutPopWindow();
584 }
585
586 /********************************************
587  *      glutPositionWindow (glut32.@)
588  */
589 extern void glutPositionWindow(int arg1, int arg2);
590 void WINAPI wine_glutPositionWindow(int arg1, int arg2)
591 {
592    glutPositionWindow(arg1, arg2);
593 }
594
595 /********************************************
596  *      glutPostOverlayRedisplay (glut32.@)
597  */
598 extern void glutPostOverlayRedisplay(void);
599 void WINAPI wine_glutPostOverlayRedisplay(void)
600 {
601    glutPostOverlayRedisplay();
602 }
603
604 /********************************************
605  *      glutPostRedisplay (glut32.@)
606  */
607 extern void glutPostRedisplay(void);
608 void WINAPI wine_glutPostRedisplay(void)
609 {
610    glutPostRedisplay();
611 }
612
613 /********************************************
614  *      glutPostWindowOverlayRedisplay (glut32.@)
615  */
616 extern void glutPostWindowOverlayRedisplay(int arg);
617 void WINAPI wine_glutPostWindowOverlayRedisplay(int arg)
618 {
619    glutPostWindowOverlayRedisplay(arg);
620 }
621
622 /********************************************
623  *      glutPostWindowRedisplay (glut32.@)
624  */
625 extern void glutPostWindowRedisplay(int arg);
626 void WINAPI wine_glutPostWindowRedisplay(int arg)
627 {
628    glutPostWindowRedisplay(arg);
629 }
630
631 /********************************************
632  *      glutPushWindow (glut32.@)
633  */
634 extern void glutPushWindow(void);
635 void WINAPI wine_glutPushWindow(void)
636 {
637    glutPushWindow();
638 }
639
640 /********************************************
641  *      glutRemoveMenuItem (glut32.@)
642  */
643 extern void glutRemoveMenuItem(int arg);
644 void WINAPI wine_glutRemoveMenuItem(int arg)
645 {
646    glutRemoveMenuItem(arg);
647 }
648
649 /********************************************
650  *      glutRemoveOverlay (glut32.@)
651  */
652 extern void glutRemoveOverlay(void);
653 void WINAPI wine_glutRemoveOverlay(void)
654 {
655    glutRemoveOverlay();
656 }
657
658 /********************************************
659  *      glutReportErrors (glut32.@)
660  */
661 extern void glutReportErrors(void);
662 void WINAPI wine_glutReportErrors(void)
663 {
664    glutReportErrors();
665 }
666
667 /********************************************
668  *      glutReshapeFunc (glut32.@)
669  */
670 extern void glutReshapeFunc(void *arg);
671 void WINAPI wine_glutReshapeFunc(void *arg)
672 {
673    glutReshapeFunc(arg);
674 }
675
676 /********************************************
677  *      glutReshapeWindow (glut32.@)
678  */
679 extern void glutReshapeWindow(int arg1, int arg2);
680 void WINAPI wine_glutReshapeWindow(int arg1, int arg2)
681 {
682    glutReshapeWindow(arg1, arg2);
683 }
684
685 /********************************************
686  *      glutSetColor (glut32.@)
687  */
688 extern void glutSetColor(float arg1, float arg2, float arg3);
689 void WINAPI wine_glutSetColor(float arg1, float arg2, float arg3)
690 {
691    glutSetColor(arg1, arg2, arg3);
692 }
693
694 /********************************************
695  *      glutSetCursor (glut32.@)
696  */
697 extern void glutSetCursor(int arg);
698 void WINAPI wine_glutSetCursor(int arg)
699 {
700    glutSetCursor(arg);
701 }
702
703 /********************************************
704  *      glutSetIconTitle (glut32.@)
705  */
706 extern void glutSetIconTitle(void *arg);
707 void WINAPI wine_glutSetIconTitle(void *arg)
708 {
709    glutSetIconTitle(arg);
710 }
711
712 /********************************************
713  *      glutSetKeyRepeat (glut32.@)
714  */
715 extern void glutSetKeyRepeat(int arg);
716 void WINAPI wine_glutSetKeyRepeat(int arg)
717 {
718    glutSetKeyRepeat(arg);
719 }
720
721 /********************************************
722  *      glutSetMenu (glut32.@)
723  */
724 extern void glutSetMenu(int arg);
725 void WINAPI wine_glutSetMenu(int arg)
726 {
727    glutSetMenu(arg);
728 }
729
730 /********************************************
731  *      glutSetupVideoResizing (glut32.@)
732  */
733 extern void glutSetupVideoResizing(void);
734 void WINAPI wine_glutSetupVideoResizing(void)
735 {
736 /*   glutSetupVideoResizing(); */
737 }
738
739 /********************************************
740  *      glutSetWindow (glut32.@)
741  */
742 extern void glutSetWindow(int arg);
743 void WINAPI wine_glutSetWindow(int arg)
744 {
745    glutSetWindow(arg);
746 }
747
748 /********************************************
749  *      glutSetWindowTitle (glut32.@)
750  */
751 extern void glutSetWindowTitle(void *arg);
752 void WINAPI wine_glutSetWindowTitle(void *arg)
753 {
754    glutSetWindowTitle(arg);
755 }
756
757 /********************************************
758  *      glutShowOverlay (glut32.@)
759  */
760 extern void glutShowOverlay(void);
761 void WINAPI wine_glutShowOverlay(void)
762 {
763    glutShowOverlay();
764 }
765
766 /********************************************
767  *      glutShowWindow (glut32.@)
768  */
769 extern void glutShowWindow(void);
770 void WINAPI wine_glutShowWindow(void)
771 {
772    glutShowWindow();
773 }
774
775 /*********************************************
776  * glutSolidCone (glut32.@)
777  */
778 extern void glutSolidCone(double arg1, double arg2, int arg3, int arg4);
779 void WINAPI wine_glutSolidCone(double arg1, double arg2, int arg3, int arg4)
780 {
781    glutSolidCone(arg1, arg2, arg3, arg4);
782 }
783
784 /**********************************************
785  *      glutSolidCube (glut32.@)
786  */
787 extern void glutSolidCube(double arg);
788 void WINAPI wine_glutSolidCube(double arg)
789 {
790    glutSolidCube(arg);
791 }
792
793 /**********************************************
794  *      glutSolidDodecahedron (glut32.@)
795  */
796 extern void glutSolidDodecahedron(void);
797 void WINAPI wine_glutSolidDodecahedron(void)
798 {
799    glutSolidDodecahedron();
800 }
801
802 /**********************************************
803  *      glutSolidIcosahedron (glut32.@)
804  */
805 extern void glutSolidIcosahedron(void);
806 void WINAPI wine_glutSolidIcosahedron(void)
807 {
808    glutSolidIcosahedron();
809 }
810
811 /**********************************************
812  *      glutSolidOctahedron (glut32.@)
813  */
814 extern void glutSolidOctahedron(void);
815 void WINAPI wine_glutSolidOctahedron(void)
816 {
817    glutSolidOctahedron();
818 }
819
820 /**********************************************
821  *      glutSolidSphere (glut32.@)
822  */
823 extern void glutSolidSphere(double arg1, int arg2, int arg3);
824 void WINAPI wine_glutSolidSphere(double arg1, int arg2, int arg3)
825 {
826    glutSolidSphere(arg1, arg2, arg3);
827 }
828
829 /**********************************************
830  *      glutSolidTeapot (glut32.@)
831  */
832 extern void glutSolidTeapot(double arg);
833 void WINAPI wine_glutSolidTeapot(double arg)
834 {
835    glutSolidTeapot(arg);
836 }
837
838 /**********************************************
839  *      glutSolidTetrahedron (glut32.@)
840  */
841 extern void glutSolidTetrahedron(void);
842 void WINAPI wine_glutSolidTetrahedron(void)
843 {
844    glutSolidTetrahedron();
845 }
846
847 /**********************************************
848  *      glutSolidTetrahedron (glut32.@)
849  */
850 extern void glutSolidTorus(double arg1, double arg2,int arg3, int arg4);
851 void WINAPI wine_glutSolidTorus(double arg1, double arg2,int arg3, int arg4)
852 {
853    glutSolidTorus(arg1, arg2, arg3, arg4);
854 }
855
856 /**********************************************
857  *      glutSpaceballButtonFunc (glut32.@)
858  */
859 extern void glutSpaceballButtonFunc(void *arg);
860 void WINAPI wine_glutSpaceballButtonFunc(void *arg)
861 {
862    glutSpaceballButtonFunc(arg);
863 }
864
865 /**********************************************
866  *      glutSpaceballMotionFunc (glut32.@)
867  */
868 extern void glutSpaceballMotionFunc(void *arg);
869 void WINAPI wine_glutSpaceballMotionFunc(void *arg)
870 {
871    glutSpaceballMotionFunc(arg);
872 }
873
874 /**********************************************
875  *      glutSpaceballRotateFunc (glut32.@)
876  */
877 extern void glutSpaceballRotateFunc(void *arg);
878 void WINAPI wine_glutSpaceballRotateFunc(void *arg)
879 {
880    glutSpaceballRotateFunc(arg);
881 }
882
883 /**********************************************
884  *      glutSpecialFunc (glut32.@)
885  */
886 extern void glutSpecialFunc(void *arg);
887 void WINAPI wine_glutSpecialFunc(void *arg)
888 {
889    glutSpecialFunc(arg);
890 }
891
892 /**********************************************
893  *      glutSpecialUpFunc (glut32.@)
894  */
895 extern void glutSpecialUpFunc(void *arg);
896 void WINAPI wine_glutSpecialUpFunc(void *arg)
897 {
898    glutSpecialUpFunc(arg);
899 }
900
901 /**********************************************
902  *      glutStopVideoResizing (glut32.@)
903  */
904 extern void glutStopVideoResizing(void);
905 void WINAPI wine_glutStopVideoResizing(void)
906 {
907    glutStopVideoResizing();
908 }
909
910 /**********************************************
911  *      glutStrokeCharacter (glut32.@)
912  */
913 extern void glutStrokeCharacter(void *arg1, int arg2);
914 void WINAPI wine_glutStrokeCharacter(void *arg1, int arg2)
915 {
916    glutStrokeCharacter(arg1, arg2);
917 }
918
919 /**************************************************
920  *      glutSwapBuffers (glut32.@)
921  */
922 extern void glutSwapBuffers(void);
923 void WINAPI wine_glutSwapBuffers(void)
924 {
925    glutSwapBuffers();
926 }
927
928 /**********************************************
929  *      glutTabletButtonFunc (glut32.@)
930  */
931 extern void glutTabletButtonFunc(void *arg);
932 void WINAPI wine_glutTabletButtonFunc(void *arg)
933 {
934    glutTabletButtonFunc(arg);
935 }
936
937 /**********************************************
938  *      glutTabletMotionFunc (glut32.@)
939  */
940 extern void glutTabletMotionFunc(void *arg);
941 void WINAPI wine_glutTabletMotionFunc(void *arg)
942 {
943    glutTabletMotionFunc(arg);
944 }
945
946 /**********************************************
947  *      glutTimerFunc (glut32.@)
948  */
949 extern void glutTimerFunc(int arg1, void *arg2, int arg3);
950 void WINAPI wine_glutTimerFunc(int arg1, void *arg2, int arg3)
951 {
952    glutTimerFunc(arg1, arg2, arg3);
953 }
954
955 /**********************************************
956  *      glutUseLayer (glut32.@)
957  */
958 extern void glutUseLayer(int arg);
959 void WINAPI wine_glutUseLayer(int arg)
960 {
961    glutUseLayer(arg);
962 }
963
964 /**********************************************
965  *      glutVideoPan (glut32.@)
966  */
967 extern void glutVideoPan(int arg1, int arg2, int arg3, int arg4);
968 void WINAPI wine_glutVideoPan(int arg1, int arg2, int arg3, int arg4)
969 {
970    glutVideoPan(arg1, arg2, arg3, arg4);
971 }
972
973 /**********************************************
974  *      glutVideoResize (glut32.@)
975  */
976 extern void glutVideoResize(int arg1, int arg2, int arg3, int arg4);
977 void WINAPI wine_glutVideoResize(int arg1, int arg2, int arg3, int arg4)
978 {
979    glutVideoResize(arg1, arg2, arg3, arg4);
980 }
981
982 /**********************************************
983  *      glutVisibilityFunc (glut32.@)
984  */
985 extern void glutVisibilityFunc(void *arg);
986 void WINAPI wine_glutVisibilityFunc(void *arg)
987 {
988    glutVisibilityFunc(arg);
989 }
990
991 /**********************************************
992  *      glutWarpPointer (glut32.@)
993  */
994 extern void glutWarpPointer(int arg1, int arg2);
995 void WINAPI wine_glutWarpPointer(int arg1, int arg2)
996 {
997    glutWarpPointer(arg1, arg2);
998 }
999
1000 /**********************************************
1001  *      glutWindowStatusFunc (glut32.@)
1002  */
1003 extern void glutWindowStatusFunc(void *arg);
1004 void WINAPI wine_glutWindowStatusFunc(void *arg)
1005 {
1006    glutWindowStatusFunc(arg);
1007 }
1008
1009 /**********************************************
1010  *      glutWireCone (glut32.@)
1011  */
1012 extern void glutWireCone(double arg1, double arg2, int arg3, int arg4);
1013 void WINAPI wine_glutWireCone(double arg1, double arg2, int arg3,int arg4)
1014 {
1015    glutWireCone(arg1, arg2, arg3, arg4);
1016 }
1017
1018 /**********************************************
1019  *      glutWireCube (glut32.@)
1020  */
1021 extern void glutWireCube(double arg);
1022 void WINAPI wine_glutWireCube(double arg)
1023 {
1024    glutWireCube(arg);
1025 }
1026
1027 /**********************************************
1028  *      glutWireDodecahedron (glut32.@)
1029  */
1030 extern void glutWireDodecahedron(void);
1031 void WINAPI wine_glutWireDodecahedron(void)
1032 {
1033    glutWireDodecahedron();
1034 }
1035
1036 /**********************************************
1037  *      glutWireIcosahedron (glut32.@)
1038  */
1039 extern void glutWireIcosahedron(void);
1040 void WINAPI wine_glutWireIcosahedron(void)
1041 {
1042    glutWireIcosahedron();
1043 }
1044
1045 /**********************************************
1046  *      glutWireOctahedron (glut32.@)
1047  */
1048 extern void glutWireOctahedron(void);
1049 void WINAPI wine_glutWireOctahedron(void)
1050 {
1051    glutWireOctahedron();
1052 }
1053
1054 /**********************************************
1055  *      glutWireSphere (glut32.@)
1056  */
1057 extern void glutWireSphere(double arg1, int arg2, int arg3);
1058 void WINAPI wine_glutWireSphere(double arg1, int arg2, int arg3)
1059 {
1060    glutWireSphere(arg1, arg2, arg3);
1061 }
1062
1063 /**********************************************
1064  *      glutWireTeapot (glut32.@)
1065  */
1066 extern void glutWireTeapot(double arg);
1067 void WINAPI wine_glutWireTeapot(double arg)
1068 {
1069    glutWireTeapot(arg);
1070 }
1071
1072 /**********************************************
1073  *     glutWireTetrahedron (glut32.@)
1074  */
1075 extern void glutWireTetrahedron(void);
1076 void WINAPI wine_glutWireTetrahedron(void)
1077 {
1078    glutWireTetrahedron();
1079 }
1080
1081 /***********************************************
1082  *      glutWireTorus (glut32.@)
1083  */
1084 extern void glutWireTorus(double arg1, double arg2, int arg3, int arg4);
1085 void WINAPI wine_glutWireTorus(double arg1, double arg2, int arg3, int arg4)
1086 {
1087    glutWireTorus(arg1, arg2, arg3, arg4);
1088 }