← Back to branch summary

~ubuntu-branches/ubuntu/saucy/blender/saucy-proposed

« back to all changes in this revision

Viewing changes to intern/ghost/test/gears/GHOST_C-Test.c

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2013-03-06 12:08:47 UTC
  • mfrom: (1.5.1) (14.1.8 experimental)
  • Revision ID: package-import@ubuntu.com-20130306120847-frjfaryb2zrotwcg
Tags: 2.66a-1ubuntu1
https://launchpad.net/bugs/1076930
https://launchpad.net/bugs/1089256
https://launchpad.net/bugs/1052743
https://launchpad.net/bugs/999024
* Resynchronize with Debian (LP: #1076930, #1089256, #1052743, #999024,
  #1122888, #1147084)
* debian/control:
  - Lower build-depends on libavcodec-dev since we're not
    doing the libav9 transition in Ubuntu yet

Show diffs side-by-side

added added

removed removed

Lines of Context:
intern/ghost/test/gears/GHOST_C-Test.c
26
26
 */
27
27
 
28
28
/**
29
 
 
30
29
 * Copyright (C) 2001 NaN Technologies B.V.
31
30
 *
32
31
 * Simple test file for the GHOST library.
33
32
 * The OpenGL gear code is taken from the Qt sample code which,
34
33
 * in turn, is probably taken from somewhere as well.
35
 
 * @author      Maarten Gribnau
36
 
 * @date        May 31, 2001
 
34
 * \author      Maarten Gribnau
 
35
 * \date        May 31, 2001
37
36
 */
38
37
 
39
38
#include <stdlib.h>
46
45
#include "GHOST_C-api.h"
47
46
 
48
47
#if defined(WIN32) || defined(__APPLE__)
49
 
        #ifdef WIN32
50
 
                #include <windows.h>
51
 
                #include <GL/gl.h>
52
 
        #else /* WIN32 */
53
 
                /* __APPLE__ is defined */
54
 
                #include <AGL/gl.h>
55
 
        #endif /* WIN32 */
 
48
#  ifdef WIN32
 
49
#    include <windows.h>
 
50
#    include <GL/gl.h>
 
51
#  else /* WIN32 */
 
52
     /* __APPLE__ is defined */
 
53
#    include <AGL/gl.h>
 
54
#  endif /* WIN32 */
56
55
#else /* defined(WIN32) || defined(__APPLE__) */
57
 
        #include <GL/gl.h>
 
56
#  include <GL/gl.h>
58
57
#endif /* defined(WIN32) || defined(__APPLE__) */
59
58
 
60
59
 
61
60
static void gearsTimerProc(GHOST_TimerTaskHandle task, GHOST_TUns64 time);
62
61
int processEvent(GHOST_EventHandle hEvent, GHOST_TUserDataPtr userData);
63
62
 
64
 
static GLfloat view_rotx=20.0, view_roty=30.0, view_rotz=0.0;
 
63
static GLfloat view_rotx = 20.0, view_roty = 30.0, view_rotz = 0.0;
65
64
static GLfloat fAngle = 0.0;
66
65
static int sExitRequested = 0;
67
66
static GHOST_SystemHandle shSystem = NULL;
87
86
        const double pi = 3.14159264;
88
87
        
89
88
        r0 = inner_radius;
90
 
        r1 = (float)(outer_radius - tooth_depth/2.0);
91
 
        r2 = (float)(outer_radius + tooth_depth/2.0);
 
89
        r1 = (float)(outer_radius - tooth_depth / 2.0);
 
90
        r2 = (float)(outer_radius + tooth_depth / 2.0);
92
91
        
93
 
        da = (float)(2.0*pi / teeth / 4.0);
 
92
        da = (float)(2.0 * pi / teeth / 4.0);
94
93
        
95
94
        glShadeModel(GL_FLAT);
96
95
        glNormal3f(0.0, 0.0, 1.0);
97
96
        
98
97
        /* draw front face */
99
98
        glBegin(GL_QUAD_STRIP);
100
 
        for (i=0;i<=teeth;i++) {
101
 
                angle = (float)(i * 2.0*pi / teeth);
102
 
                glVertex3f((float)(r0*cos(angle)), (float)(r0*sin(angle)), (float)(width*0.5));
103
 
                glVertex3f((float)(r1*cos(angle)), (float)(r1*sin(angle)), (float)(width*0.5));
104
 
                glVertex3f((float)(r0*cos(angle)), (float)(r0*sin(angle)), (float)(width*0.5));
105
 
                glVertex3f((float)(r1*cos(angle+3*da)), (float)(r1*sin(angle+3*da)), (float)(width*0.5));
 
99
        for (i = 0; i <= teeth; i++) {
 
100
                angle = (float)(i * 2.0 * pi / teeth);
 
101
                glVertex3f((float)(r0 * cos(angle)), (float)(r0 * sin(angle)), (float)(width * 0.5));
 
102
                glVertex3f((float)(r1 * cos(angle)), (float)(r1 * sin(angle)), (float)(width * 0.5));
 
103
                glVertex3f((float)(r0 * cos(angle)), (float)(r0 * sin(angle)), (float)(width * 0.5));
 
104
                glVertex3f((float)(r1 * cos(angle + 3 * da)), (float)(r1 * sin(angle + 3 * da)), (float)(width * 0.5));
106
105
        }
107
106
        glEnd();
108
107
        
109
108
        /* draw front sides of teeth */
110
109
        glBegin(GL_QUADS);
111
 
        da = (float)(2.0*pi / teeth / 4.0);
112
 
        for (i=0;i<teeth;i++) {
113
 
                angle = (float)(i * 2.0*pi / teeth);
114
 
                glVertex3f((float)(r1*cos(angle)), (float)(r1*sin(angle)), (float)(width*0.5));
115
 
                glVertex3f((float)(r2*cos(angle+da)), (float)(r2*sin(angle+da)), (float)(width*0.5));
116
 
                glVertex3f((float)(r2*cos(angle+2*da)), (float)(r2*sin(angle+2*da)), (float)(width*0.5));
117
 
                glVertex3f((float)(r1*cos(angle+3*da)), (float)(r1*sin(angle+3*da)), (float)(width*0.5));
 
110
        da = (float)(2.0 * pi / teeth / 4.0);
 
111
        for (i = 0; i < teeth; i++) {
 
112
                angle = (float)(i * 2.0 * pi / teeth);
 
113
                glVertex3f((float)(r1 * cos(angle)), (float)(r1 * sin(angle)), (float)(width * 0.5));
 
114
                glVertex3f((float)(r2 * cos(angle + da)), (float)(r2 * sin(angle + da)), (float)(width * 0.5));
 
115
                glVertex3f((float)(r2 * cos(angle + 2 * da)), (float)(r2 * sin(angle + 2 * da)), (float)(width * 0.5));
 
116
                glVertex3f((float)(r1 * cos(angle + 3 * da)), (float)(r1 * sin(angle + 3 * da)), (float)(width * 0.5));
118
117
        }
119
118
        glEnd();
120
119
        
122
121
        
123
122
        /* draw back face */
124
123
        glBegin(GL_QUAD_STRIP);
125
 
        for (i=0;i<=teeth;i++) {
126
 
                angle = (float)(i * 2.0*pi / teeth);
127
 
                glVertex3f((float)(r1*cos(angle)), (float)(r1*sin(angle)), (float)(-width*0.5));
128
 
                glVertex3f((float)(r0*cos(angle)), (float)(r0*sin(angle)), (float)(-width*0.5));
129
 
                glVertex3f((float)(r1*cos(angle+3*da)), (float)(r1*sin(angle+3*da)), (float)(-width*0.5));
130
 
                glVertex3f((float)(r0*cos(angle)), (float)(r0*sin(angle)), (float)(-width*0.5));
 
124
        for (i = 0; i <= teeth; i++) {
 
125
                angle = (float)(i * 2.0 * pi / teeth);
 
126
                glVertex3f((float)(r1 * cos(angle)), (float)(r1 * sin(angle)), (float)(-width * 0.5));
 
127
                glVertex3f((float)(r0 * cos(angle)), (float)(r0 * sin(angle)), (float)(-width * 0.5));
 
128
                glVertex3f((float)(r1 * cos(angle + 3 * da)), (float)(r1 * sin(angle + 3 * da)), (float)(-width * 0.5));
 
129
                glVertex3f((float)(r0 * cos(angle)), (float)(r0 * sin(angle)), (float)(-width * 0.5));
131
130
        }
132
131
        glEnd();
133
132
        
134
133
        /* draw back sides of teeth */
135
134
        glBegin(GL_QUADS);
136
 
        da = (float)(2.0*pi / teeth / 4.0);
137
 
        for (i=0;i<teeth;i++) {
138
 
                angle = (float)(i * 2.0*pi / teeth);
139
 
                glVertex3f((float)(r1*cos(angle+3*da)), (float)(r1*sin(angle+3*da)), (float)(-width*0.5));
140
 
                glVertex3f((float)(r2*cos(angle+2*da)), (float)(r2*sin(angle+2*da)), (float)(-width*0.5));
141
 
                glVertex3f((float)(r2*cos(angle+da)), (float)(r2*sin(angle+da)), (float)(-width*0.5));
142
 
                glVertex3f((float)(r1*cos(angle)), (float)(r1*sin(angle)), (float)(-width*0.5));
 
135
        da = (float)(2.0 * pi / teeth / 4.0);
 
136
        for (i = 0; i < teeth; i++) {
 
137
                angle = (float)(i * 2.0 * pi / teeth);
 
138
                glVertex3f((float)(r1 * cos(angle + 3 * da)), (float)(r1 * sin(angle + 3 * da)), (float)(-width * 0.5));
 
139
                glVertex3f((float)(r2 * cos(angle + 2 * da)), (float)(r2 * sin(angle + 2 * da)), (float)(-width * 0.5));
 
140
                glVertex3f((float)(r2 * cos(angle + da)), (float)(r2 * sin(angle + da)), (float)(-width * 0.5));
 
141
                glVertex3f((float)(r1 * cos(angle)), (float)(r1 * sin(angle)), (float)(-width * 0.5));
143
142
        }
144
143
        glEnd();
145
144
        
146
145
        /* draw outward faces of teeth */
147
146
        glBegin(GL_QUAD_STRIP);
148
 
        for (i=0;i<teeth;i++) {
149
 
                angle = (float)(i * 2.0*pi / teeth);
150
 
                glVertex3f((float)(r1*cos(angle)), (float)(r1*sin(angle)), (float)(width*0.5));
151
 
                glVertex3f((float)(r1*cos(angle)), (float)(r1*sin(angle)), (float)(-width*0.5));
152
 
                u = (float)(r2*cos(angle+da) - r1*cos(angle));
153
 
                v = (float)(r2*sin(angle+da) - r1*sin(angle));
154
 
                len = (float)(sqrt(u*u + v*v));
 
147
        for (i = 0; i < teeth; i++) {
 
148
                angle = (float)(i * 2.0 * pi / teeth);
 
149
                glVertex3f((float)(r1 * cos(angle)), (float)(r1 * sin(angle)), (float)(width * 0.5));
 
150
                glVertex3f((float)(r1 * cos(angle)), (float)(r1 * sin(angle)), (float)(-width * 0.5));
 
151
                u = (float)(r2 * cos(angle + da) - r1 * cos(angle));
 
152
                v = (float)(r2 * sin(angle + da) - r1 * sin(angle));
 
153
                len = (float)(sqrt(u * u + v * v));
155
154
                u /= len;
156
155
                v /= len;
157
156
                glNormal3f(v, -u, 0.0);
158
 
                glVertex3f((float)(r2*cos(angle+da)), (float)(r2*sin(angle+da)), (float)(width*0.5));
159
 
                glVertex3f((float)(r2*cos(angle+da)), (float)(r2*sin(angle+da)), (float)(-width*0.5));
 
157
                glVertex3f((float)(r2 * cos(angle + da)), (float)(r2 * sin(angle + da)), (float)(width * 0.5));
 
158
                glVertex3f((float)(r2 * cos(angle + da)), (float)(r2 * sin(angle + da)), (float)(-width * 0.5));
160
159
                glNormal3f((float)(cos(angle)), (float)(sin(angle)), 0.0);
161
 
                glVertex3f((float)(r2*cos(angle+2*da)), (float)(r2*sin(angle+2*da)), (float)(width*0.5));
162
 
                glVertex3f((float)(r2*cos(angle+2*da)), (float)(r2*sin(angle+2*da)), (float)(-width*0.5));
163
 
                u = (float)(r1*cos(angle+3*da) - r2*cos(angle+2*da));
164
 
                v = (float)(r1*sin(angle+3*da) - r2*sin(angle+2*da));
 
160
                glVertex3f((float)(r2 * cos(angle + 2 * da)), (float)(r2 * sin(angle + 2 * da)), (float)(width * 0.5));
 
161
                glVertex3f((float)(r2 * cos(angle + 2 * da)), (float)(r2 * sin(angle + 2 * da)), (float)(-width * 0.5));
 
162
                u = (float)(r1 * cos(angle + 3 * da) - r2 * cos(angle + 2 * da));
 
163
                v = (float)(r1 * sin(angle + 3 * da) - r2 * sin(angle + 2 * da));
165
164
                glNormal3f(v, -u, 0.0);
166
 
                glVertex3f((float)(r1*cos(angle+3*da)), (float)(r1*sin(angle+3*da)), (float)(width*0.5));
167
 
                glVertex3f((float)(r1*cos(angle+3*da)), (float)(r1*sin(angle+3*da)), (float)(-width*0.5));
 
165
                glVertex3f((float)(r1 * cos(angle + 3 * da)), (float)(r1 * sin(angle + 3 * da)), (float)(width * 0.5));
 
166
                glVertex3f((float)(r1 * cos(angle + 3 * da)), (float)(r1 * sin(angle + 3 * da)), (float)(-width * 0.5));
168
167
                glNormal3f((float)(cos(angle)), (float)(sin(angle)), 0.0);
169
168
        }
170
 
        glVertex3f((float)(r1*cos(0.0)), (float)(r1*sin(0.0)), (float)(width*0.5));
171
 
        glVertex3f((float)(r1*cos(0.0)), (float)(r1*sin(0.0)), (float)(-width*0.5));
 
169
        glVertex3f((float)(r1 * cos(0.0)), (float)(r1 * sin(0.0)), (float)(width * 0.5));
 
170
        glVertex3f((float)(r1 * cos(0.0)), (float)(r1 * sin(0.0)), (float)(-width * 0.5));
172
171
        glEnd();
173
172
        
174
173
        glShadeModel(GL_SMOOTH);
175
174
        
176
175
        /* draw inside radius cylinder */
177
176
        glBegin(GL_QUAD_STRIP);
178
 
        for (i=0;i<=teeth;i++) {
179
 
                angle = (float)(i * 2.0*pi / teeth);
 
177
        for (i = 0; i <= teeth; i++) {
 
178
                angle = (float)(i * 2.0 * pi / teeth);
180
179
                glNormal3f((float)(-cos(angle)), (float)(-sin(angle)), 0.0);
181
 
                glVertex3f((float)(r0*cos(angle)), (float)(r0*sin(angle)), (float)(-width*0.5));
182
 
                glVertex3f((float)(r0*cos(angle)), (float)(r0*sin(angle)), (float)(width*0.5));
 
180
                glVertex3f((float)(r0 * cos(angle)), (float)(r0 * sin(angle)), (float)(-width * 0.5));
 
181
                glVertex3f((float)(r0 * cos(angle)), (float)(r0 * sin(angle)), (float)(width * 0.5));
183
182
        }
184
183
        glEnd();
185
184
}
201
200
        
202
201
        switch (id)
203
202
        {
204
 
        case 1:
205
 
                glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, ared);
206
 
                gearGL(1.0f, 4.0f, 1.0f, 20, 0.7f);
207
 
                break;
208
 
        case 2:
209
 
                glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, agreen);
210
 
                gearGL(0.5f, 2.0f, 2.0f, 10, 0.7f);
211
 
                break;
212
 
        case 3:
213
 
                glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, ablue);
214
 
                gearGL(1.3f, 2.0f, 0.5f, 10, 0.7f);
215
 
                break;
216
 
        default:
217
 
                break;
 
203
                case 1:
 
204
                        glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, ared);
 
205
                        gearGL(1.0f, 4.0f, 1.0f, 20, 0.7f);
 
206
                        break;
 
207
                case 2:
 
208
                        glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, agreen);
 
209
                        gearGL(0.5f, 2.0f, 2.0f, 10, 0.7f);
 
210
                        break;
 
211
                case 3:
 
212
                        glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, ablue);
 
213
                        gearGL(1.3f, 2.0f, 0.5f, 10, 0.7f);
 
214
                        break;
 
215
                default:
 
216
                        break;
218
217
        }
219
218
        glEnable(GL_NORMALIZE);
220
219
}
238
237
        
239
238
        glPushMatrix();
240
239
        glTranslatef(3.1f, -2.0f, 0.0f);
241
 
        glRotatef((float)(-2.0*fAngle-9.0), 0.0, 0.0, 1.0);
 
240
        glRotatef((float)(-2.0 * fAngle - 9.0), 0.0, 0.0, 1.0);
242
241
        drawGearGL(2);
243
242
        glPopMatrix();
244
243
        
245
244
        glPushMatrix();
246
245
        glTranslatef(-3.1f, 2.2f, -1.8f);
247
246
        glRotatef(90.0f, 1.0f, 0.0f, 0.0f);
248
 
        glRotatef((float)(2.0*fAngle-2.0), 0.0, 0.0, 1.0);
 
247
        glRotatef((float)(2.0 * fAngle - 2.0), 0.0, 0.0, 1.0);
249
248
        drawGearGL(3);
250
249
        glPopMatrix();
251
250
        
274
273
        glLoadIdentity();
275
274
        glTranslatef(0.0, 0.0, -40.0);
276
275
        
277
 
        glClearColor(.2f,0.0f,0.0f,0.0f);
 
276
        glClearColor(.2f, 0.0f, 0.0f, 0.0f);
278
277
        glClear(GL_COLOR_BUFFER_BIT);
279
278
 
280
279
        GHOST_DisposeRectangle(hRect);
287
286
        int handled = 1;
288
287
        int cursor;
289
288
        int visibility;
290
 
        GHOST_TEventKeyData* keyData = NULL;
291
 
        GHOST_TEventWheelData* wheelData = NULL;
 
289
        GHOST_TEventKeyData *keyData = NULL;
 
290
        GHOST_TEventWheelData *wheelData = NULL;
292
291
        GHOST_DisplaySetting setting;
293
292
        GHOST_WindowHandle window = GHOST_GetEventWindow(hEvent);
294
293
        
295
294
        switch (GHOST_GetEventType(hEvent))
296
295
        {
297
 
        /*
298
 
        case GHOST_kEventUnknown:
299
 
                break;
300
 
        case GHOST_kEventCursorButton:
301
 
                break;
302
 
        case GHOST_kEventCursorMove:
303
 
                break;
304
 
        */
305
 
        case GHOST_kEventWheel:
306
 
                {
307
 
                wheelData = (GHOST_TEventWheelData*)GHOST_GetEventData(hEvent);
308
 
                if (wheelData->z > 0)
309
 
                {
310
 
                        view_rotz += 5.f;
311
 
                }
312
 
                else
313
 
                {
314
 
                        view_rotz -= 5.f;
315
 
                }
 
296
#if 0
 
297
                case GHOST_kEventUnknown:
 
298
                        break;
 
299
                case GHOST_kEventCursorButton:
 
300
                        break;
 
301
                case GHOST_kEventCursorMove:
 
302
                        break;
 
303
#endif
 
304
                case GHOST_kEventWheel:
 
305
                {
 
306
                        wheelData = (GHOST_TEventWheelData *)GHOST_GetEventData(hEvent);
 
307
                        if (wheelData->z > 0)
 
308
                        {
 
309
                                view_rotz += 5.f;
 
310
                        }
 
311
                        else {
 
312
                                view_rotz -= 5.f;
 
313
                        }
316
314
                }
317
315
                break;
318
316
 
319
 
        case GHOST_kEventKeyUp:
320
 
                break;
 
317
                case GHOST_kEventKeyUp:
 
318
                        break;
321
319
                
322
 
        case GHOST_kEventKeyDown:
 
320
                case GHOST_kEventKeyDown:
323
321
                {
324
 
                        keyData = (GHOST_TEventKeyData*)GHOST_GetEventData(hEvent);
 
322
                        keyData = (GHOST_TEventKeyData *)GHOST_GetEventData(hEvent);
325
323
                        switch (keyData->key)
326
324
                        {
327
 
                        case GHOST_kKeyC:
 
325
                                case GHOST_kKeyC:
328
326
                                {
329
327
                                        cursor = sCursor;
330
328
                                        cursor++;
336
334
                                        GHOST_SetCursorShape(window, sCursor);
337
335
                                }
338
336
                                break;
339
 
                        case GHOST_kKeyF:
340
 
                                if (!GHOST_GetFullScreen(shSystem))
341
 
                                {
342
 
                                        /* Begin fullscreen mode */
343
 
                                        setting.bpp = 24;
344
 
                                        setting.frequency = 85;
345
 
                                        setting.xPixels = 640;
346
 
                                        setting.yPixels = 480;
347
 
                                        
348
 
                                        /*
349
 
                                        setting.bpp = 16;
350
 
                                        setting.frequency = 75;
351
 
                                        setting.xPixels = 640;
352
 
                                        setting.yPixels = 480;
353
 
                                        */
354
 
 
355
 
                                        sFullScreenWindow = GHOST_BeginFullScreen(shSystem, &setting,
356
 
 
357
 
                                                FALSE /* stereo flag */);
358
 
                                }
359
 
                                else
360
 
                                {
361
 
                                        GHOST_EndFullScreen(shSystem);
362
 
                                        sFullScreenWindow = 0;
363
 
                                }
364
 
                                break;
365
 
                        case GHOST_kKeyH:
 
337
                                case GHOST_kKeyF:
 
338
                                        if (!GHOST_GetFullScreen(shSystem))
 
339
                                        {
 
340
                                                /* Begin fullscreen mode */
 
341
                                                setting.bpp = 24;
 
342
                                                setting.frequency = 85;
 
343
                                                setting.xPixels = 640;
 
344
                                                setting.yPixels = 480;
 
345
 
 
346
                                                /*
 
347
                                                 * setting.bpp = 16;
 
348
                                                 * setting.frequency = 75;
 
349
                                                 * setting.xPixels = 640;
 
350
                                                 * setting.yPixels = 480;
 
351
                                                 */
 
352
 
 
353
                                                sFullScreenWindow = GHOST_BeginFullScreen(shSystem, &setting,
 
354
 
 
355
                                                                                          FALSE /* stereo flag */);
 
356
                                        }
 
357
                                        else {
 
358
                                                GHOST_EndFullScreen(shSystem);
 
359
                                                sFullScreenWindow = 0;
 
360
                                        }
 
361
                                        break;
 
362
                                case GHOST_kKeyH:
366
363
                                {
367
364
                                        visibility = GHOST_GetCursorVisibility(window);
368
365
                                        GHOST_SetCursorVisibility(window, !visibility);
369
366
                                }
370
367
                                break;
371
 
                        case GHOST_kKeyQ:
372
 
                                if (GHOST_GetFullScreen(shSystem))
373
 
                                {
374
 
                                        GHOST_EndFullScreen(shSystem);
375
 
                                        sFullScreenWindow = 0;
376
 
                                }
377
 
                                sExitRequested = 1;
378
 
                        case GHOST_kKeyT:
379
 
                                if (!sTestTimer)
380
 
                                {
381
 
                                        sTestTimer = GHOST_InstallTimer(shSystem, 0, 1000, testTimerProc, NULL);
382
 
                                }
383
 
                                else
384
 
                                {
385
 
                                        GHOST_RemoveTimer(shSystem, sTestTimer);
386
 
                                        sTestTimer = 0;
387
 
                                }
388
 
                                break;
389
 
                        case GHOST_kKeyW:
 
368
                                case GHOST_kKeyQ:
 
369
                                        if (GHOST_GetFullScreen(shSystem))
 
370
                                        {
 
371
                                                GHOST_EndFullScreen(shSystem);
 
372
                                                sFullScreenWindow = 0;
 
373
                                        }
 
374
                                        sExitRequested = 1;
 
375
                                case GHOST_kKeyT:
 
376
                                        if (!sTestTimer)
 
377
                                        {
 
378
                                                sTestTimer = GHOST_InstallTimer(shSystem, 0, 1000, testTimerProc, NULL);
 
379
                                        }
 
380
                                        else {
 
381
                                                GHOST_RemoveTimer(shSystem, sTestTimer);
 
382
                                                sTestTimer = 0;
 
383
                                        }
 
384
                                        break;
 
385
                                case GHOST_kKeyW:
390
386
                                {
391
387
                                        if (sMainWindow)
392
388
                                        {
393
389
                                                char *title = GHOST_GetTitle(sMainWindow);
394
 
                                                char *ntitle = malloc(strlen(title)+2);
 
390
                                                char *ntitle = malloc(strlen(title) + 2);
395
391
 
396
392
                                                sprintf(ntitle, "%s-", title);
397
393
                                                GHOST_SetTitle(sMainWindow, ntitle);
401
397
                                        }
402
398
                                }
403
399
                                break;
404
 
                        default:
405
 
                                break;
 
400
                                default:
 
401
                                        break;
406
402
                        }
407
403
                }
408
404
                break;
409
405
                
410
 
        case GHOST_kEventWindowClose:
 
406
                case GHOST_kEventWindowClose:
411
407
                {
412
408
                        GHOST_WindowHandle window2 = GHOST_GetEventWindow(hEvent);
413
409
                        if (window2 == sMainWindow)
414
410
                        {
415
411
                                sExitRequested = 1;
416
412
                        }
417
 
                        else
418
 
                        {
 
413
                        else {
419
414
                                if (sGearsTimer)
420
415
                                {
421
416
                                        GHOST_RemoveTimer(shSystem, sGearsTimer);
426
421
                }
427
422
                break;
428
423
                
429
 
        case GHOST_kEventWindowActivate:
430
 
                handled = 0;
431
 
                break;
432
 
        case GHOST_kEventWindowDeactivate:
433
 
                handled = 0;
434
 
                break;
435
 
        case GHOST_kEventWindowUpdate:
 
424
                case GHOST_kEventWindowActivate:
 
425
                        handled = 0;
 
426
                        break;
 
427
                case GHOST_kEventWindowDeactivate:
 
428
                        handled = 0;
 
429
                        break;
 
430
                case GHOST_kEventWindowUpdate:
436
431
                {
437
432
                        GHOST_WindowHandle window2 = GHOST_GetEventWindow(hEvent);
438
433
                        if (!GHOST_ValidWindow(shSystem, window2))
443
438
                }
444
439
                break;
445
440
                
446
 
        default:
447
 
                handled = 0;
448
 
                break;
 
441
                default:
 
442
                        handled = 0;
 
443
                        break;
449
444
        }
450
445
        return handled;
451
446
}
452
447
 
453
448
 
454
 
int main(int argc, char** argv)
 
449
int main(int argc, char **argv)
455
450
{
456
 
        char* title1 = "gears - main window";
457
 
        char* title2 = "gears - secondary window";
 
451
        char *title1 = "gears - main window";
 
452
        char *title2 = "gears - secondary window";
458
453
        GHOST_EventConsumerHandle consumer = GHOST_CreateEventConsumer(processEvent, NULL);
459
454
 
460
455
        /* Create the system */
465
460
        {
466
461
                /* Create the main window */
467
462
                sMainWindow = GHOST_CreateWindow(shSystem,
468
 
                        title1,
469
 
                        10,
470
 
                        64,
471
 
                        320,
472
 
                        200,
473
 
                        GHOST_kWindowStateNormal,
474
 
                        GHOST_kDrawingContextTypeOpenGL,
475
 
                        FALSE,
476
 
                        FALSE);
 
463
                                                 title1,
 
464
                                                 10,
 
465
                                                 64,
 
466
                                                 320,
 
467
                                                 200,
 
468
                                                 GHOST_kWindowStateNormal,
 
469
                                                 GHOST_kDrawingContextTypeOpenGL,
 
470
                                                 FALSE,
 
471
                                                 FALSE);
477
472
                if (!sMainWindow)
478
473
                {
479
474
                        printf("could not create main window\n");
482
477
                
483
478
                /* Create a secondary window */
484
479
                sSecondaryWindow = GHOST_CreateWindow(shSystem,
485
 
                        title2,
486
 
                        340,
487
 
                        64,
488
 
                        320,
489
 
                        200,
490
 
                        GHOST_kWindowStateNormal,
491
 
                        GHOST_kDrawingContextTypeOpenGL,
492
 
                        FALSE,
493
 
                        FALSE);
 
480
                                                      title2,
 
481
                                                      340,
 
482
                                                      64,
 
483
                                                      320,
 
484
                                                      200,
 
485
                                                      GHOST_kWindowStateNormal,
 
486
                                                      GHOST_kDrawingContextTypeOpenGL,
 
487
                                                      FALSE,
 
488
                                                      FALSE);
494
489
                if (!sSecondaryWindow)
495
490
                {
496
491
                        printf("could not create secondary window\n");
498
493
                }
499
494
                
500
495
                /* Install a timer to have the gears running */
501
 
                 sGearsTimer = GHOST_InstallTimer(shSystem,
502
 
                        0,
503
 
                        10,
504
 
                        gearsTimerProc,
505
 
                        sMainWindow);
 
496
                sGearsTimer = GHOST_InstallTimer(shSystem,
 
497
                                                 0,
 
498
                                                 10,
 
499
                                                 gearsTimerProc,
 
500
                                                 sMainWindow);
506
501
 
507
502
                /* Enter main loop */
508
503
                while (!sExitRequested)
530
525
 
531
526
        /* Dispose the system */
532
527
        GHOST_DisposeSystem(shSystem);
533
 
        GHOST_DisposeEventConsumer(consumer);
534
528
        
535
529
        return 0;
536
530
}
547
541
                /* Running full screen */
548
542
                GHOST_InvalidateWindow(sFullScreenWindow);
549
543
        }
550
 
        else
551
 
        {
 
544
        else {
552
545
                if (GHOST_ValidWindow(shSystem, hWindow))
553
546
                {
554
547
                        GHOST_InvalidateWindow(hWindow);