Context Navigation

← Previous Change
Next Change →

Changeset 13 for branches

Timestamp:

02/28/08 10:42:27 (4 years ago)

Author:

sokoow

Message:

Added:
- DEBUG_MODE and DEBUG_MODE_ASSERT
- code indentation

Files:

: 1 modified

branches/pdfcube-0.0.3/src/pdfcube.cc (modified) (22 diffs)

Legend:

: Unmodified
: Added
: Removed

branches/pdfcube-0.0.3/src/pdfcube.cc

r12	r13
20	20
21	21	#include <iostream>
22
23	22	#include <cstdio>
24	23	#include <cstdlib>
25	24	#include <cmath>
26		~~#include <cassert>~~
27	25	#include <sstream>
28	26
…	…
46	44	//////////////////////////////////////////////////////////////////////////
47	45	// Macros
	46
	47	//#define DEBUG_MODE
	48	//#define DEBUG_MODE_ASSERT
	49	#ifdef DEBUG_MODE_ASSERT
	50	#include <cassert>
	51	#endif
48	52
49	53	#define DEFAULT_WIDTH 640
…	…
56	60	// Globals (will be moved inside classes some day)
57	61
58
59		enum animation { ANIM_NONE,
60		CUBE_NEXT, CUBE_PREV,
61		ZOOM0, ZOOM1, ZOOM2, ZOOM3, ZOOM4, ZOOMC,
62		SWITCH_FW, SWITCH_BW
	62	enum animation { ANIM_NONE,
	63	CUBE_NEXT, CUBE_PREV,
	64	ZOOM0, ZOOM1, ZOOM2, ZOOM3, ZOOM4, ZOOMC,
	65	SWITCH_FW, SWITCH_BW
63	66	};
64
65	67
66	68	static gboolean fullscreen = TRUE;
…	…
77	79	// Forward declarations
78	80
79
80		static void timeout_add (GtkWidget *widget);
81		static void timeout_remove (GtkWidget *widget);
82
83		static void start_animation (GtkWidget *widget, animation);
84		static void stop_animation (GtkWidget *widget);
85
86
87		static GdkGLConfig *configure_gl (void);
88
89		static GtkWidget create_window (GdkGLConfig glconfig);
90
91		static bool sleeping() { return !animating && active_animation == ANIM_NONE; }
	81	static void timeout_add(GtkWidget * widget);
	82	static void timeout_remove(GtkWidget * widget);
	83
	84	static void start_animation(GtkWidget * widget, animation);
	85	static void stop_animation(GtkWidget * widget);
	86
	87	static GdkGLConfig *configure_gl(void);
	88
	89	static GtkWidget create_window(GdkGLConfig glconfig);
	90
	91	static bool
	92	sleeping()
	93	{
	94	return !animating && active_animation == ANIM_NONE;
	95	}
92	96
93	97	//////////////////////////////////////////////////////////////////////////
…	…
99	103	// hack in a serious pdf-viewer
100	104	//
101		class pdfcube
102		{
103		public:
104		pdfcube(PopplerDocument *d)
105		: doc(d),
106		current_page(0),
107		current_face(0),
108		total_pages(poppler_document_get_n_pages(d)),
109		frame(0),
110		lookposx(0.0), lookposy(0.0), lookposz(3.48),
111		atx(0.0), aty(0.0), atz(0.0),
112		persp(44.0), angle(0.0),
113		pixmap(0)
114		{
115		texmap[0] = 0; texmap[1] = 1; texmap[2] = 2;
116		pixmap =
117		gdk_pixbuf_new(GDK_COLORSPACE_RGB, true, 8, tex_width, tex_height);
118		steps = new GLfloat[N_FRAMES];
119		xsteps = new double[N_FRAMES];
120		zsteps = new double[N_FRAMES];
121		zoomsteps = new double[N_FRAMES];
122		perspsteps = new double[N_FRAMES];
123		perspstepsc = new double[N_FRAMES];
124		}
125
126		~pdfcube()
127		{
128		delete []steps;
129		delete []xsteps;
130		delete []zsteps;
131		delete []zoomsteps;
132		delete []perspsteps;
133		delete []perspstepsc;
134		}
135
136		int page() { return current_page; }
137
138		int pages() { return total_pages; }
139		// Cube Normals
140		static GLfloat n[6][3];
141		// Cube Faces
142		static GLint faces[6][4];
143		// Cube vertex (filled in pdfcube->initialize())
144		GLfloat v[8][3];
145		// Cube texture mapping
146		static GLfloat mapping[6][8];
147		// Cube Rotation Animation steps (17 frames)
148		// Cube rotation at each frame
149
150		GLfloat *steps;
151		// x camera movement
152		double *xsteps;
153		// z camera movement
154		double *zsteps;
155		double *zoomsteps;
156		double *perspsteps;
157		double *perspstepsc;
158
159		void restart(GtkWidget* widget)
160		{
161		current_page = 0; update_textures(widget);
162		}
163
164		void go_to(GtkWidget* widget, int page)
165		{
166		if(page>=0 && page < total_pages)
167		{
168		current_page = page;
169		update_textures(widget);
170		}
171		}
172
173		void section(GtkWidget* widget, int section)
174		{
175		cerr << "Section: " << section << " total pages: " << total_pages << endl;
176		int ii;
177		for(ii = 0; ii < total_pages; ++ii)
178		{
179		if(page_transition[ii]) section--;
180		if(section == 0) break;
181		}
182		cerr << "Page: " << ii << endl;
183		if(ii < total_pages)
184		{
185		current_page = ii;
186		update_textures(widget);
187		}
188		}
189
190		void
191		initialize(GtkWidget *widget)
192		{
193		GLfloat position[] = { 1.0, 1.0, 0.0, 1.0 };
194		GLfloat local_view[] = { 0.0 };
195
196		glShadeModel(GL_SMOOTH);
197		glEnable(GL_TEXTURE_RECTANGLE_ARB);
198
199		GLfloat mat_ambient[] = { 0.0, 0.0, 0.0, 1.00 };
200		GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.00 };
201		GLfloat mat_shininess[] = { 15.0 };
202
203		glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
204		glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
205		glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
206
207		glEnable (GL_LIGHTING);
208		glEnable (GL_LIGHT0);
209		glEnable (GL_BLEND);
210		glEnable (GL_CULL_FACE);
211		glEnable (GL_POLYGON_SMOOTH);
212		glPolygonMode (GL_FRONT,GL_FILL);
213		glEdgeFlag(GL_FALSE);
214
215		glClearColor (0.0, 0.0, 0.0, 0.5);
216		glCullFace(GL_FRONT);
217		glDisable(GL_DEPTH_TEST);
218
219		glEnable(GL_DEPTH_TEST);
220		glDepthFunc(GL_LEQUAL);
221		glLightfv(GL_LIGHT0, GL_POSITION, position);
222		glLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER, local_view);
223
224		glFrontFace (GL_CCW);
225		glEnable(GL_LIGHTING);
226		glEnable(GL_LIGHT0);
227		glEnable(GL_AUTO_NORMAL);
228		glEnable(GL_NORMALIZE);
229		glEnable(GL_FOG);
230		{
231		GLfloat fogColor[4] = {0.5, 0.5, 0.5, 0.5};
232
233		glFogi (GL_FOG_MODE, GL_EXP);
234		glFogi (GL_FOG_START, 0.0);
235		glFogi (GL_FOG_END, 5.0);
236		glFogfv (GL_FOG_COLOR, fogColor);
237		glFogf (GL_FOG_DENSITY, 0.35);
238		glHint (GL_FOG_HINT, GL_DONT_CARE);
239		glClearColor(fogColor[0],fogColor[1],fogColor[2],fogColor[3]);
240		}
241
242		glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
243
244		glGenTextures (3, textures);
245
246		glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
247		glTexParameteri( GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S,
248		GL_CLAMP_TO_EDGE );
249		glTexParameteri( GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T,
250		GL_CLAMP_TO_EDGE );
251
252		glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
253		GL_LINEAR_MIPMAP_LINEAR);
254		glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
255		GL_LINEAR);
256
257		update_textures(widget);
258
259		GLint size;
260		glGetIntegerv(GL_MAX_TEXTURE_SIZE, &size);
261		printf("%u\n", size);
262		assert(size >= 512);
263		assert(glIsTexture(textures[0]));
264
265		// Cube vertex
266		v[0][0] = v[1][0] = v[2][0] = v[3][0] = -1;
267		v[4][0] = v[5][0] = v[6][0] = v[7][0] = 1;
268		v[0][1] = v[1][1] = v[4][1] = v[5][1] = -1;
269		v[2][1] = v[3][1] = v[6][1] = v[7][1] = 1;
270		v[0][2] = v[3][2] = v[4][2] = v[7][2] = 1;
271		v[1][2] = v[2][2] = v[5][2] = v[6][2] = -1;
272
273
274		glMatrixMode(GL_PROJECTION);
275		gluPerspective( persp,
276		1.0,
277		0.5,
278		10.0);
279
280		glMatrixMode(GL_MODELVIEW);
281
282		gluLookAt(lookposx, lookposy, lookposz,
283		atx, aty, atz,
284		0.0, 1.0, 0.0); // up is in positive Y direction
285
286		matrix_setup();
287		}
288
289
290		void
291		redraw(GtkWidget *widget)
292		{
293
294		double yoffset = 0.1;
295		if(animating)
296		{
297		switch(active_animation)
298		{
299		case ANIM_NONE:
300		cerr << "No animation... stopping right now." << endl;
301		frame = 0;
302		stop_animation(widget);
303		break;
304		case CUBE_NEXT:
305		cerr << "cube " << frame << endl;
306		if(frame == N_FRAMES)
307		{
308		frame = 0;
309		stop_animation(widget);
310		quick_reset(widget);
311		}
312		else
313		{
314		glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
	105	class pdfcube {
	106	public:
	107	pdfcube(PopplerDocument * d)
	108	:doc(d),
	109	current_page(0),
	110	current_face(0),
	111	total_pages(poppler_document_get_n_pages(d)),
	112	frame(0),
	113	lookposx(0.0), lookposy(0.0), lookposz(3.48),
	114	atx(0.0), aty(0.0), atz(0.0), persp(44.0), angle(0.0), pixmap(0) {
	115	texmap[0] = 0;
	116	texmap[1] = 1;
	117	texmap[2] = 2;
	118	pixmap =
	119	gdk_pixbuf_new(GDK_COLORSPACE_RGB, true, 8, tex_width,
	120	tex_height);
	121	steps = new GLfloat[N_FRAMES];
	122	xsteps = new double[N_FRAMES];
	123	zsteps = new double[N_FRAMES];
	124	zoomsteps = new double[N_FRAMES];
	125	perspsteps = new double[N_FRAMES];
	126	perspstepsc = new double[N_FRAMES];
	127	} ~pdfcube() {
	128	delete[]steps;
	129	delete[]xsteps;
	130	delete[]zsteps;
	131	delete[]zoomsteps;
	132	delete[]perspsteps;
	133	delete[]perspstepsc;
	134	}
	135
	136	int page() {
	137	return current_page;
	138	}
	139
	140	int pages() {
	141	return total_pages;
	142	}
	143	// Cube Normals
	144	static GLfloat n[6][3];
	145	// Cube Faces
	146	static GLint faces[6][4];
	147	// Cube vertex (filled in pdfcube->initialize())
	148	GLfloat v[8][3];
	149	// Cube texture mapping
	150	static GLfloat mapping[6][8];
	151	// Cube Rotation Animation steps (17 frames)
	152	// Cube rotation at each frame
	153
	154	GLfloat *steps;
	155	// x camera movement
	156	double *xsteps;
	157	// z camera movement
	158	double *zsteps;
	159	double *zoomsteps;
	160	double *perspsteps;
	161	double *perspstepsc;
	162
	163	void restart(GtkWidget * widget) {
	164	current_page = 0;
	165	update_textures(widget);
	166	}
	167
	168	void go_to(GtkWidget * widget, int page) {
	169	if (page >= 0 && page < total_pages) {
	170	current_page = page;
	171	update_textures(widget);
	172	}
	173	}
	174
	175	void section(GtkWidget * widget, int section) {
	176	#ifdef DEBUG_MODE
	177	cerr << "Section: " << section << " total pages: " <<
	178	total_pages << endl;
	179	#endif
	180	int ii;
	181	for (ii = 0; ii < total_pages; ++ii) {
	182	if (page_transition[ii])
	183	section--;
	184	if (section == 0)
	185	break;
	186	}
	187	#ifdef DEBUG_MODE
	188	cerr << "Page: " << ii << endl;
	189	#endif
	190	if (ii < total_pages) {
	191	current_page = ii;
	192	update_textures(widget);
	193	}
	194	}
	195
	196	void
	197	initialize(GtkWidget * widget) {
	198	GLfloat position[] = { 1.0, 1.0, 0.0, 1.0 };
	199	GLfloat local_view[] = { 0.0 };
	200
	201	glShadeModel(GL_SMOOTH);
	202	glEnable(GL_TEXTURE_RECTANGLE_ARB);
	203
	204	GLfloat mat_ambient[] = { 0.0, 0.0, 0.0, 1.00 };
	205	GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.00 };
	206	GLfloat mat_shininess[] = { 15.0 };
	207
	208	glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
	209	glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
	210	glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
	211
	212	glEnable(GL_LIGHTING);
	213	glEnable(GL_LIGHT0);
	214	glEnable(GL_BLEND);
	215	glEnable(GL_CULL_FACE);
	216	glEnable(GL_POLYGON_SMOOTH);
	217	glPolygonMode(GL_FRONT, GL_FILL);
	218	glEdgeFlag(GL_FALSE);
	219
	220	glClearColor(0.0, 0.0, 0.0, 0.5);
	221	glCullFace(GL_FRONT);
	222	glDisable(GL_DEPTH_TEST);
	223
	224	glEnable(GL_DEPTH_TEST);
	225	glDepthFunc(GL_LEQUAL);
	226	glLightfv(GL_LIGHT0, GL_POSITION, position);
	227	glLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER, local_view);
	228
	229	glFrontFace(GL_CCW);
	230	glEnable(GL_LIGHTING);
	231	glEnable(GL_LIGHT0);
	232	glEnable(GL_AUTO_NORMAL);
	233	glEnable(GL_NORMALIZE);
	234	glEnable(GL_FOG);
	235	{
	236	GLfloat fogColor[4] = { 0.5, 0.5, 0.5, 0.5 };
	237
	238	glFogi(GL_FOG_MODE, GL_EXP);
	239	glFogi(GL_FOG_START, 0.0);
	240	glFogi(GL_FOG_END, 5.0);
	241	glFogfv(GL_FOG_COLOR, fogColor);
	242	glFogf(GL_FOG_DENSITY, 0.35);
	243	glHint(GL_FOG_HINT, GL_DONT_CARE);
	244	glClearColor(fogColor[0], fogColor[1], fogColor[2],
	245	fogColor[3]);
	246	}
	247
	248	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
	249
	250	glGenTextures(3, textures);
	251
	252	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
	253	glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S,
	254	GL_CLAMP_TO_EDGE);
	255	glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T,
	256	GL_CLAMP_TO_EDGE);
	257
	258	glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
	259	GL_LINEAR_MIPMAP_LINEAR);
	260	glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
	261	GL_LINEAR);
	262
	263	update_textures(widget);
	264
	265	GLint size;
	266	glGetIntegerv(GL_MAX_TEXTURE_SIZE, &size);
	267	#ifdef DEBUG_MODE_ASSERT
	268	printf("%u\n", size);
	269	assert(size >= 512);
	270	assert(glIsTexture(textures[0]));
	271	#endif
	272	// Cube vertex
	273	v[0][0] = v[1][0] = v[2][0] = v[3][0] = -1;
	274	v[4][0] = v[5][0] = v[6][0] = v[7][0] = 1;
	275	v[0][1] = v[1][1] = v[4][1] = v[5][1] = -1;
	276	v[2][1] = v[3][1] = v[6][1] = v[7][1] = 1;
	277	v[0][2] = v[3][2] = v[4][2] = v[7][2] = 1;
	278	v[1][2] = v[2][2] = v[5][2] = v[6][2] = -1;
	279
	280	glMatrixMode(GL_PROJECTION);
	281	gluPerspective(persp, 1.0, 0.5, 10.0);
	282
315	283	glMatrixMode(GL_MODELVIEW);
316		glLoadIdentity();
317		lookposz -= zsteps[frame]*4;
318		lookposy = 6*xsteps[frame];
319		gluLookAt(lookposx, lookposy, lookposz, atx,aty,atz, 0,1,0);
320		angle -= steps[frame];
321		glRotatef(angle, 0.0, 1.0, 0.0);
322		drawCube();
323		frame++;
324		}
325		break;
326		case CUBE_PREV:
327		cerr << "cube " << frame << endl;
328		if(frame == N_FRAMES)
329		{
330		frame = 0;
331		stop_animation(widget);
332		quick_reset(widget);
333		}
334		else
335		{
336		glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
337		glMatrixMode(GL_MODELVIEW);
338		glLoadIdentity();
339		lookposz -= zsteps[frame]*4;
340		lookposy = 6*xsteps[frame];
341		gluLookAt(lookposx, lookposy, lookposz, atx,aty,atz, 0,1,0);
342		angle -= steps[frame];
343		glRotatef(angle, 0.0, -1.0, 0.0);
344		drawCube();
345		frame++;
346		}
347		break;
348		case ZOOM0:
349		cerr << "zoom0 " << frame << endl;
350		if(frame == N_FRAMES)
351		{
352		frame = 0;
353		stop_animation(widget);
354		quick_reset(widget);
355		}
356		else
357		{
358		glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
359		switch(previous_animation)
360		{
361		case ZOOM1:
362		persp = perspsteps[(N_FRAMES-1)-frame];
363		atx = lookposx = -(1.3*zoomsteps[(N_FRAMES-1)-frame]);
364		aty = lookposy = zoomsteps[(N_FRAMES-1)-frame] -
365		yoffset/N_FRAMES * ((N_FRAMES-1)-frame);
366		break;
367		case ZOOM2:
368		persp = perspsteps[(N_FRAMES-1)-frame];
369		atx = lookposx = 1.3*zoomsteps[(N_FRAMES-1)-frame];
370		aty = lookposy = zoomsteps[(N_FRAMES-1)-frame] -
371		yoffset/N_FRAMES * ((N_FRAMES-1)-frame);
372		break;
373		case ZOOM3:
374		persp = perspsteps[(N_FRAMES-1)-frame];
375		atx = lookposx = -1.3*zoomsteps[(N_FRAMES-1)-frame];
376		aty = lookposy = -zoomsteps[(N_FRAMES-1)-frame] -
377		yoffset/N_FRAMES * ((N_FRAMES-1)-frame);
378		break;
379		case ZOOM4:
380		persp = perspsteps[(N_FRAMES-1)-frame];
381		atx = lookposx = 1.3*zoomsteps[(N_FRAMES-1)-frame];
382		aty = lookposy = -zoomsteps[(N_FRAMES-1)-frame] -
383		yoffset/N_FRAMES * ((N_FRAMES-1)-frame);
384		break;
385		case ZOOMC:
386		persp = perspstepsc[(N_FRAMES-1)-frame];
387		aty = lookposy = - zoomsteps[(N_FRAMES-1)-frame]*0.38;
388		break;
389		default:
390		cerr << "Should not reach" << endl;
391		break;
	284
	285	gluLookAt(lookposx, lookposy, lookposz, atx, aty, atz, 0.0, 1.0, 0.0); // up is in positive Y direction
	286
	287	matrix_setup();
	288	}
	289
	290	void
	291	redraw(GtkWidget * widget) {
	292
	293	double yoffset = 0.1;
	294	if (animating) {
	295	switch (active_animation) {
	296	case ANIM_NONE:
	297
	298	#ifdef DEBUG_MODE
	299	cerr << "No animation... stopping right now." <<
	300	endl;
	301	#endif
	302	frame = 0;
	303	stop_animation(widget);
	304	break;
	305	case CUBE_NEXT:
	306	#ifdef DEBUG_MODE
	307	cerr << "cube " << frame << endl;
	308	#endif
	309	if (frame == N_FRAMES) {
	310	frame = 0;
	311	stop_animation(widget);
	312	quick_reset(widget);
	313	} else {
	314	glClear(GL_COLOR_BUFFER_BIT \|
	315	GL_DEPTH_BUFFER_BIT);
	316	glMatrixMode(GL_MODELVIEW);
	317	glLoadIdentity();
	318	lookposz -= zsteps[frame] * 4;
	319	lookposy = 6 * xsteps[frame];
	320	gluLookAt(lookposx, lookposy, lookposz,
	321	atx, aty, atz, 0, 1, 0);
	322	angle -= steps[frame];
	323	glRotatef(angle, 0.0, 1.0, 0.0);
	324	drawCube();
	325	frame++;
	326	}
	327	break;
	328	case CUBE_PREV:
	329	#ifdef DEBUG_MODE
	330	cerr << "cube " << frame << endl;
	331	#endif
	332	if (frame == N_FRAMES) {
	333	frame = 0;
	334	stop_animation(widget);
	335	quick_reset(widget);
	336	} else {
	337	glClear(GL_COLOR_BUFFER_BIT \|
	338	GL_DEPTH_BUFFER_BIT);
	339	glMatrixMode(GL_MODELVIEW);
	340	glLoadIdentity();
	341	lookposz -= zsteps[frame] * 4;
	342	lookposy = 6 * xsteps[frame];
	343	gluLookAt(lookposx, lookposy, lookposz,
	344	atx, aty, atz, 0, 1, 0);
	345	angle -= steps[frame];
	346	glRotatef(angle, 0.0, -1.0, 0.0);
	347	drawCube();
	348	frame++;
	349	}
	350	break;
	351	case ZOOM0:
	352
	353	#ifdef DEBUG_MODE
	354	cerr << "zoom0 " << frame << endl;
	355	#endif
	356	if (frame == N_FRAMES) {
	357	frame = 0;
	358	stop_animation(widget);
	359	quick_reset(widget);
	360	} else {
	361	glClear(GL_COLOR_BUFFER_BIT \|
	362	GL_DEPTH_BUFFER_BIT);
	363	switch (previous_animation) {
	364	case ZOOM1:
	365	persp =
	366	perspsteps[(N_FRAMES - 1) -
	367	frame];
	368	atx = lookposx =
	369	-(1.3 *
	370	zoomsteps[(N_FRAMES - 1) -
	371	frame]);
	372	aty = lookposy =
	373	zoomsteps[(N_FRAMES - 1) -
	374	frame] -
	375	yoffset / N_FRAMES *
	376	((N_FRAMES - 1) - frame);
	377	break;
	378	case ZOOM2:
	379	persp =
	380	perspsteps[(N_FRAMES - 1) -
	381	frame];
	382	atx = lookposx =
	383	1.3 *
	384	zoomsteps[(N_FRAMES - 1) -
	385	frame];
	386	aty = lookposy =
	387	zoomsteps[(N_FRAMES - 1) -
	388	frame] -
	389	yoffset / N_FRAMES *
	390	((N_FRAMES - 1) - frame);
	391	break;
	392	case ZOOM3:
	393	persp =
	394	perspsteps[(N_FRAMES - 1) -
	395	frame];
	396	atx = lookposx =
	397	-1.3 *
	398	zoomsteps[(N_FRAMES - 1) -
	399	frame];
	400	aty = lookposy =
	401	-zoomsteps[(N_FRAMES - 1) -
	402	frame] -
	403	yoffset / N_FRAMES *
	404	((N_FRAMES - 1) - frame);
	405	break;
	406	case ZOOM4:
	407	persp =
	408	perspsteps[(N_FRAMES - 1) -
	409	frame];
	410	atx = lookposx =
	411	1.3 *
	412	zoomsteps[(N_FRAMES - 1) -
	413	frame];
	414	aty = lookposy =
	415	-zoomsteps[(N_FRAMES - 1) -
	416	frame] -
	417	yoffset / N_FRAMES *
	418	((N_FRAMES - 1) - frame);
	419	break;
	420	case ZOOMC:
	421	persp =
	422	perspstepsc[(N_FRAMES - 1) -
	423	frame];
	424	aty = lookposy =
	425	-zoomsteps[(N_FRAMES - 1) -
	426	frame] * 0.38;
	427	break;
	428	default:
	429
	430	#ifdef DEBUG_MODE
	431	cerr << "Should not reach" <<
	432	endl;
	433	#endif
	434	break;
	435	}
	436	glMatrixMode(GL_PROJECTION);
	437	glLoadIdentity();
	438	gluPerspective(persp, 1.0, 0.5, 10.0);
	439	glMatrixMode(GL_MODELVIEW);
	440	glLoadIdentity();
	441	gluLookAt(lookposx, lookposy, lookposz,
	442	atx, aty, atz, 0, 1, 0);
	443	glRotatef(angle, 0.0, 1.0, 0.0);
	444	drawCube();
	445	frame++;
	446	}
	447	break;
	448	case ZOOM1:
	449	#ifdef DEBUG_MODE
	450	cerr << "zoom1 " << frame << endl;
	451	#endif
	452	if (frame == N_FRAMES) {
	453	frame = 0;
	454	stop_animation(widget);
	455	} else {
	456	glClear(GL_COLOR_BUFFER_BIT \|
	457	GL_DEPTH_BUFFER_BIT);
	458	glMatrixMode(GL_PROJECTION);
	459	glLoadIdentity();
	460	persp = perspsteps[frame];
	461	gluPerspective(persp, 1.0, 0.5, 10.0);
	462	glMatrixMode(GL_MODELVIEW);
	463	glLoadIdentity();
	464	atx = lookposx =
	465	-1.3 * zoomsteps[frame];
	466	aty = lookposy =
	467	zoomsteps[frame] -
	468	yoffset / N_FRAMES * (frame);
	469	gluLookAt(lookposx, lookposy, lookposz,
	470	atx, aty, atz, 0, 1, 0);
	471	glRotatef(angle, 0.0, 1.0, 0.0);
	472	drawCube();
	473	frame++;
	474	}
	475	break;
	476	case ZOOM2:
	477	#ifdef DEBUG_MODE
	478	cerr << "zoom1 " << frame << endl;
	479	#endif
	480	if (frame == N_FRAMES) {
	481	frame = 0;
	482	stop_animation(widget);
	483	} else {
	484	glClear(GL_COLOR_BUFFER_BIT \|
	485	GL_DEPTH_BUFFER_BIT);
	486	glMatrixMode(GL_PROJECTION);
	487	glLoadIdentity();
	488	persp = perspsteps[frame];
	489	gluPerspective(persp, 1.0, 0.5, 10.0);
	490	glMatrixMode(GL_MODELVIEW);
	491	glLoadIdentity();
	492	atx = lookposx = 1.3 * zoomsteps[frame];
	493	aty = lookposy =
	494	zoomsteps[frame] -
	495	yoffset / N_FRAMES * (frame);
	496	gluLookAt(lookposx, lookposy, lookposz,
	497	atx, aty, atz, 0, 1, 0);
	498	glRotatef(angle, 0.0, 1.0, 0.0);
	499	drawCube();
	500	frame++;
	501	}
	502	break;
	503	case ZOOM3:
	504	#ifdef DEBUG_MODE
	505	cerr << "zoom1 " << frame << endl;
	506	#endif
	507	if (frame == N_FRAMES) {
	508	frame = 0;
	509	stop_animation(widget);
	510	} else {
	511	glClear(GL_COLOR_BUFFER_BIT \|
	512	GL_DEPTH_BUFFER_BIT);
	513	glMatrixMode(GL_PROJECTION);
	514	glLoadIdentity();
	515	persp = perspsteps[frame];
	516	gluPerspective(persp, 1.0, 0.5, 10.0);
	517	glMatrixMode(GL_MODELVIEW);
	518	glLoadIdentity();
	519	atx = lookposx =
	520	-1.3 * zoomsteps[frame];
	521	aty = lookposy =
	522	-zoomsteps[frame] -
	523	yoffset / N_FRAMES * (frame);
	524	gluLookAt(lookposx, lookposy, lookposz,
	525	atx, aty, atz, 0, 1, 0);
	526	glRotatef(angle, 0.0, 1.0, 0.0);
	527	drawCube();
	528	frame++;
	529	}
	530	break;
	531	case ZOOM4:
	532	#ifdef DEBUG_MODE
	533	cerr << "zoom1 " << frame << endl;
	534	#endif
	535	if (frame == N_FRAMES) {
	536	frame = 0;
	537	stop_animation(widget);
	538	} else {
	539	glClear(GL_COLOR_BUFFER_BIT \|
	540	GL_DEPTH_BUFFER_BIT);
	541	glMatrixMode(GL_PROJECTION);
	542	glLoadIdentity();
	543	persp = perspsteps[frame];
	544	gluPerspective(persp, 1.0, 0.5, 10.0);
	545	glMatrixMode(GL_MODELVIEW);
	546	glLoadIdentity();
	547	atx = lookposx = 1.3 * zoomsteps[frame];
	548	aty = lookposy =
	549	-zoomsteps[frame] -
	550	yoffset / N_FRAMES * (frame);
	551	gluLookAt(lookposx, lookposy, lookposz,
	552	atx, aty, atz, 0, 1, 0);
	553	glRotatef(angle, 0.0, 1.0, 0.0);
	554	drawCube();
	555	frame++;
	556	}
	557	break;
	558	case ZOOMC:
	559	#ifdef DEBUG_MODE
	560	cerr << "zoomc " << frame << endl;
	561	#endif
	562	if (frame == N_FRAMES) {
	563	frame = 0;
	564	stop_animation(widget);
	565	} else {
	566	glClear(GL_COLOR_BUFFER_BIT \|
	567	GL_DEPTH_BUFFER_BIT);
	568	persp = perspstepsc[frame];
	569	aty = lookposy =
	570	-zoomsteps[frame] * 0.38;
	571	glMatrixMode(GL_PROJECTION);
	572	glLoadIdentity();
	573	gluPerspective(persp, 1.0, 0.5, 10.0);
	574	glMatrixMode(GL_MODELVIEW);
	575	glLoadIdentity();
	576	gluLookAt(lookposx, lookposy, lookposz,
	577	atx, aty, atz, 0, 1, 0);
	578	glRotatef(angle, 0.0, 1.0, 0.0);
	579	drawCube();
	580	frame++;
	581	}
	582	break;
	583	case SWITCH_FW:
	584	#ifdef DEBUG_MODE
	585	cerr << "fw " << frame << endl;
	586	#endif
	587	if (frame == 1) {
	588	frame = 0;
	589	stop_animation(widget);
	590	} else {
	591	glClear(GL_COLOR_BUFFER_BIT \|
	592	GL_DEPTH_BUFFER_BIT);
	593	glMatrixMode(GL_MODELVIEW);
	594	glLoadIdentity();
	595	gluLookAt(lookposx, lookposy, lookposz,
	596	atx, aty, atz, 0, 1, 0);
	597	angle -= 90;
	598	glRotatef(angle, 0.0, 1.0, 0.0);
	599	drawCube();
	600	frame++;
	601	}
	602	break;
	603	case SWITCH_BW:
	604	#ifdef DEBUG_MODE
	605	cerr << "bw " << frame << endl;
	606	#endif
	607	if (frame == 1) {
	608	frame = 0;
	609	stop_animation(widget);
	610	} else {
	611	glClear(GL_COLOR_BUFFER_BIT \|
	612	GL_DEPTH_BUFFER_BIT);
	613	glMatrixMode(GL_MODELVIEW);
	614	glLoadIdentity();
	615	gluLookAt(lookposx, lookposy, lookposz,
	616	atx, aty, atz, 0, 1, 0);
	617	angle += 90;
	618	glRotatef(angle, 0.0, 1.0, 0.0);
	619	drawCube();
	620	frame++;
	621	}
	622	break;
	623	}
	624	} else {
	625	switch (active_animation) {
	626	case ANIM_NONE:
	627	#ifdef DEBUG_MODE
	628	cerr << "Redrawing" << endl;
	629	#endif
	630	break;
	631	case CUBE_NEXT:
	632	#ifdef DEBUG_MODE
	633	cerr << "cube stop" << endl;
	634	#endif
	635	forward(widget);
	636	current_face = next_face();
	637	// quick_reset(widget);
	638	break;
	639	case CUBE_PREV:
	640	#ifdef DEBUG_MODE
	641	cerr << "cube stop" << endl;
	642	#endif
	643	backward(widget);
	644	current_face = prev_face();
	645	// quick_reset(widget);
	646	break;
	647	case SWITCH_FW:
	648	#ifdef DEBUG_MODE
	649	cerr << "fw stop" << endl;
	650	#endif
	651	forward(widget);
	652	current_face = next_face();
	653	break;
	654	case SWITCH_BW:
	655	#ifdef DEBUG_MODE
	656	cerr << "bw stop" << endl;
	657	#endif
	658	backward(widget);
	659	current_face = prev_face();
	660	break;
	661	case ZOOM0:
	662	case ZOOM1:
	663	case ZOOM2:
	664	case ZOOM3:
	665	case ZOOM4:
	666	case ZOOMC:
	667	default:
	668	#ifdef DEBUG_MODE
	669	cerr << "default stop" << endl;
	670	#endif
	671	break;
	672
	673	}
	674
	675	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
	676	// glClear(GL_COLOR_BUFFER_BIT);
	677	glMatrixMode(GL_PROJECTION);
	678	glLoadIdentity();
	679	gluPerspective(persp, 1.0, 0.5, 10.0);
	680	glMatrixMode(GL_MODELVIEW);
	681	glLoadIdentity();
	682	gluLookAt(lookposx, lookposy, lookposz, atx, aty, atz,
	683	0, 1, 0);
	684	glRotatef(angle, 0.0, 1.0, 0.0);
	685	drawCube();
	686
	687	glRasterPos3f(0, -1.4, 0);
	688	GLuint rcube[] = {
	689	0, 0, 0, 127
	690	};
	691	glDrawPixels(1, 1, GL_RGBA, GL_UNSIGNED_BYTE, rcube);
	692
	693	active_animation = ANIM_NONE;
	694
	695	#ifdef DEBUG_MODE
	696	cerr << "Ok!" << endl;
	697	#endif
	698	glFlush();
392	699	}
393		glMatrixMode(GL_PROJECTION);
394		glLoadIdentity();
395		gluPerspective( persp,
396		1.0,
397		0.5,
398		10.0);
399		glMatrixMode(GL_MODELVIEW);
400		glLoadIdentity();
401		gluLookAt(lookposx, lookposy, lookposz, atx, aty, atz, 0,1,0);
402		glRotatef(angle, 0.0, 1.0, 0.0);
403		drawCube();
404		frame++;
405		}
406		break;
407		case ZOOM1:
408		cerr << "zoom1 " << frame << endl;
409		if(frame == N_FRAMES)
410		{
411		frame = 0;
412		stop_animation(widget);
413		}
414		else
415		{
416		glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
417		glMatrixMode(GL_PROJECTION);
418		glLoadIdentity();
419		persp = perspsteps[frame];
420		gluPerspective(persp,
421		1.0,
422		0.5,
423		10.0);
424		glMatrixMode(GL_MODELVIEW);
425		glLoadIdentity();
426		atx = lookposx = -1.3*zoomsteps[frame];
427		aty = lookposy = zoomsteps[frame] - yoffset/N_FRAMES * (frame);
428		gluLookAt(lookposx, lookposy, lookposz, atx, aty, atz, 0,1,0);
429		glRotatef(angle, 0.0, 1.0, 0.0);
430		drawCube();
431		frame++;
432		}
433		break;
434		case ZOOM2:
435		cerr << "zoom1 " << frame << endl;
436		if(frame == N_FRAMES)
437		{
438		frame = 0;
439		stop_animation(widget);
440		}
441		else
442		{
443		glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
444		glMatrixMode(GL_PROJECTION);
445		glLoadIdentity();
446		persp = perspsteps[frame];
447		gluPerspective(persp,
448		1.0,
449		0.5,
450		10.0);
451		glMatrixMode(GL_MODELVIEW);
452		glLoadIdentity();
453		atx = lookposx = 1.3*zoomsteps[frame];
454		aty = lookposy = zoomsteps[frame] - yoffset/N_FRAMES * (frame);
455		gluLookAt(lookposx, lookposy, lookposz, atx, aty, atz, 0,1,0);
456		glRotatef(angle, 0.0, 1.0, 0.0);
457		drawCube();
458		frame++;
459		}
460		break;
461		case ZOOM3:
462		cerr << "zoom1 " << frame << endl;
463		if(frame == N_FRAMES)
464		{
465		frame = 0;
466		stop_animation(widget);
467		}
468		else
469		{
470		glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
471		glMatrixMode(GL_PROJECTION);
472		glLoadIdentity();
473		persp = perspsteps[frame];
474		gluPerspective(persp,
475		1.0,
476		0.5,
477		10.0);
478		glMatrixMode(GL_MODELVIEW);
479		glLoadIdentity();
480		atx = lookposx = -1.3*zoomsteps[frame];
481		aty = lookposy = -zoomsteps[frame] - yoffset/N_FRAMES * (frame);
482		gluLookAt(lookposx, lookposy, lookposz, atx, aty, atz, 0,1,0);
483		glRotatef(angle, 0.0, 1.0, 0.0);
484		drawCube();
485		frame++;
486		}
487		break;
488		case ZOOM4:
489		cerr << "zoom1 " << frame << endl;
490		if(frame == N_FRAMES)
491		{
492		frame = 0;
493		stop_animation(widget);
494		}
495		else
496		{
497		glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
498		glMatrixMode(GL_PROJECTION);
499		glLoadIdentity();
500		persp = perspsteps[frame];
501		gluPerspective(persp,
502		1.0,
503		0.5,
504		10.0);
505		glMatrixMode(GL_MODELVIEW);
506		glLoadIdentity();
507		atx = lookposx = 1.3*zoomsteps[frame];
508		aty = lookposy = -zoomsteps[frame] -yoffset/N_FRAMES * (frame);
509		gluLookAt(lookposx, lookposy, lookposz, atx, aty, atz, 0,1,0);
510		glRotatef(angle, 0.0, 1.0, 0.0);
511		drawCube();
512		frame++;
513		}
514		break;
515		case ZOOMC:
516		cerr << "zoomc " << frame << endl;
517		if(frame == N_FRAMES)
518		{
519		frame = 0;
520		stop_animation(widget);
521		}
522		else
523		{
524		glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
525		persp = perspstepsc[frame];
526		aty = lookposy = - zoomsteps[frame]*0.38;
527		glMatrixMode(GL_PROJECTION);
528		glLoadIdentity();
529		gluPerspective(persp,
530		1.0,
531		0.5,
532		10.0);
533		glMatrixMode(GL_MODELVIEW);
534		glLoadIdentity();
535		gluLookAt(lookposx, lookposy, lookposz, atx, aty, atz, 0,1,0);
536		glRotatef(angle, 0.0, 1.0, 0.0);
537		drawCube();
538		frame++;
539		}
540		break;
541		case SWITCH_FW:
542		cerr << "fw " << frame << endl;
543		if(frame == 1)
544		{
545		frame = 0;
546		stop_animation(widget);
547		}
548		else
549		{
550		glClear (GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
551		glMatrixMode(GL_MODELVIEW);
552		glLoadIdentity();
553		gluLookAt(lookposx, lookposy, lookposz, atx, aty, atz, 0,1,0);
554		angle -= 90;
555		glRotatef(angle, 0.0, 1.0, 0.0);
556		drawCube();
557		frame++;
558		}
559		break;
560		case SWITCH_BW:
561		cerr << "bw " << frame << endl;
562		if(frame == 1)
563		{
564		frame = 0;
565		stop_animation(widget);
566		}
567		else
568		{
569		glClear (GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
570		glMatrixMode(GL_MODELVIEW);
571		glLoadIdentity();
572		gluLookAt(lookposx, lookposy, lookposz, atx, aty, atz, 0,1,0);
573		angle += 90;
574		glRotatef(angle, 0.0, 1.0, 0.0);
575		drawCube();
576		frame++;
577		}
578		break;
579		}
580		}
581		else
582		{
583		switch(active_animation)
584		{
585		case ANIM_NONE:
586		cerr << "Redrawing" << endl;
587		break;
588		case CUBE_NEXT:
589		cerr << "cube stop" << endl;
590		forward(widget);
591		current_face = next_face();
592		// quick_reset(widget);
593		break;
594		case CUBE_PREV:
595		cerr << "cube stop" << endl;
596		backward(widget);
597		current_face = prev_face();
598		// quick_reset(widget);
599		break;
600		case SWITCH_FW:
601		cerr << "fw stop" << endl;
602		forward(widget);
603		current_face = next_face();
604		break;
605		case SWITCH_BW:
606		cerr << "bw stop" << endl;
607		backward(widget);
608		current_face = prev_face();
609		break;
610		case ZOOM0:
611		case ZOOM1:
612		case ZOOM2:
613		case ZOOM3:
614		case ZOOM4:
615		case ZOOMC:
616		default:
617		cerr << "default stop" << endl;
618		break;
619
620		}
621
622		glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
623		// glClear(GL_COLOR_BUFFER_BIT);
624		glMatrixMode(GL_PROJECTION);
625		glLoadIdentity();
626		gluPerspective( persp,
627		1.0,
628		0.5,
629		10.0);
630		glMatrixMode(GL_MODELVIEW);
631		glLoadIdentity();
632		gluLookAt(lookposx, lookposy, lookposz, atx, aty, atz, 0,1,0);
633		glRotatef(angle, 0.0, 1.0, 0.0);
634		drawCube();
635
636		glRasterPos3f(0, -1.4, 0);
637		GLuint rcube[] = {
638		0,0,0,127
639		};
640		glDrawPixels(1, 1, GL_RGBA, GL_UNSIGNED_BYTE, rcube);
641
642		active_animation = ANIM_NONE;
643
644		cerr << "Ok!" << endl;
645		glFlush();
646		}
647		}
648
649		int prev_face()
650		{
651		if(current_face-1 < 0) return 3;
652		else return current_face -1;
653		}
654
655		int next_face()
656		{
657		if(current_face+1 > 3) return 0;
658		else return current_face+1;
659		}
660
661		int prev_page()
662		{
663		assert(current_page >= 0);
664		if(current_page == 0) return total_pages-1;
665		else return current_page-1;
666		}
667
668		int next_page()
669		{
670		assert(current_page < total_pages);
671		if(current_page == total_pages-1) return 0;
672		else return current_page+1;
673		}
674
675		void
676		forward(GtkWidget *widget)
677		{
678		update_textures_dir(widget, true);
679		cerr << "Current page: " << current_page << endl;
680		}
681
682		void matrix_setup()
683		{
	700	}
	701
	702	int prev_face() {
	703	if (current_face - 1 < 0)
	704	return 3;
	705	else
	706	return current_face - 1;
	707	}
	708
	709	int next_face() {
	710	if (current_face + 1 > 3)
	711	return 0;
	712	else
	713	return current_face + 1;
	714	}
	715
	716	int prev_page() {
	717	#ifdef DEBUG_MODE_ASSERT
	718	assert(current_page >= 0);
	719	#endif
	720	if (current_page == 0)
	721	return total_pages - 1;
	722	else
	723	return current_page - 1;
	724	}
	725
	726	int next_page() {
	727	#ifdef DEBUG_MODE_ASSERT
	728	assert(current_page < total_pages);
	729	#endif
	730	if (current_page == total_pages - 1)
	731	return 0;
	732	else
	733	return current_page + 1;
	734	}
	735
	736	void
	737	forward(GtkWidget * widget) {
	738	update_textures_dir(widget, true);
	739	#ifdef DEBUG_MODE
	740	cerr << "Current page: " << current_page << endl;
	741	#endif
	742	}
	743
	744	void matrix_setup() {
684	745	/*GLfloat pdfcube::steps[N_FRAMES] =
685	746	{ 2.0, 2.5, 3, 4, 5, 6, 8, 10,
686	747	14, 10, 8, 6, 4, 3, 2.5, 2.0, 0.0 };*/
687	748
688		float step_factor = 0.2*N_FRAMES; //this is little buggy
689		float step = (step_factor)/double(N_FRAMES/2);
690		int i=0;
691		for (i=0;i<N_FRAMES/2;i++)
692		{
693		steps[i]=i*step;
694		if(steps[i]>step_factor) steps[i]=step_factor;
695		}
696		for (i=N_FRAMES/2;i<N_FRAMES;i++)
697		{
698		steps[i]=step_factor-(i-N_FRAMES/2)*step;
699		if(steps[i]<0) steps[i]=0;
700		}
701		steps[N_FRAMES-1]=0;
702		cout << "Step " << step << endl;
703		cout << "Matrix ";
704		for (i=0;i<N_FRAMES;i++) cout << steps[i] << " ";
705		cout << endl;
706
	749	float step_factor = 0.2 * N_FRAMES; //this is little buggy
	750	float step = (step_factor) / double (N_FRAMES / 2);
	751	int i = 0;
	752	for (i = 0; i < N_FRAMES / 2; i++) {
	753	steps[i] = i * step;
	754	if (steps[i] > step_factor)
	755	steps[i] = step_factor;
	756	}
	757	for (i = N_FRAMES / 2; i < N_FRAMES; i++) {
	758	steps[i] = step_factor - (i - N_FRAMES / 2) * step;
	759	if (steps[i] < 0)
	760	steps[i] = 0;
	761	}
	762	steps[N_FRAMES - 1] = 0;
	763	#ifdef DEBUG_MODE
	764	cout << "Step " << step << endl;
	765	cout << "Matrix ";
	766	for (i = 0; i < N_FRAMES; i++)
	767	cout << steps[i] << " ";
	768	cout << endl;
	769	#endif
707	770	/*double pdfcube::xsteps[N_FRAMES] =
708	771	{ 0.01, 0.03, 0.07, 0.12, 0.16, 0.18, 0.20, 0.21,
709	772	0.21, 0.20, 0.18, 0.16, 0.12, 0.07, 0.03, 0.01, 0.00 };*/
710
711		float xstep_ratio = 0.4;
712		float xstep = double(xstep_ratio-0.01)/double(N_FRAMES/2);
713		for (i=0;i<N_FRAMES/2;i++)
714		{
715		xsteps[i]=i*xstep;
716		if(xsteps[i]>xstep_ratio) xsteps[i]=xstep_ratio;
717		}
718		for (i=N_FRAMES/2;i<N_FRAMES;i++)
719		{
720		xsteps[i]=xstep_ratio-(i-N_FRAMES/2)*xstep;
721		if(xsteps[i]<0.01) xsteps[i]=0;
722		}
723		xsteps[N_FRAMES-1]=0;
724
725		cout << "Step x " << xstep << endl;
726		cout << "Matrix2 ";
727		for (i=0;i<N_FRAMES;i++) cout << xsteps[i] << " ";
728		cout << endl;
729
	773
	774	float xstep_ratio = 0.4;
	775	float xstep =
	776	double (xstep_ratio - 0.01) / double (N_FRAMES / 2);
	777	for (i = 0; i < N_FRAMES / 2; i++) {
	778	xsteps[i] = i * xstep;
	779	if (xsteps[i] > xstep_ratio)
	780	xsteps[i] = xstep_ratio;
	781	}
	782	for (i = N_FRAMES / 2; i < N_FRAMES; i++) {
	783	xsteps[i] = xstep_ratio - (i - N_FRAMES / 2) * xstep;
	784	if (xsteps[i] < 0.01)
	785	xsteps[i] = 0;
	786	}
	787	xsteps[N_FRAMES - 1] = 0;
	788
	789	#ifdef DEBUG_MODE
	790	cout << "Step x " << xstep << endl;
	791	cout << "Matrix2 ";
	792	for (i = 0; i < N_FRAMES; i++)
	793	cout << xsteps[i] << " ";
	794	cout << endl;
	795	#endif
730	796	/*double pdfcube::zsteps[N_FRAMES] =
731	797	{ -0.01, -0.02, -0.04, -0.05, -0.04, -0.02, -0.02, -0.01,
732	798	0.01, 0.02, 0.02, 0.04, 0.05, 0.04, 0.02, 0.01, 0.00 };*/
733	799
734		float granular = 0.07;
735		~~float zstep = granular/double(N_FRAMES/~~4);
736		for (i=0;i<N_FRAMES/4;i++)
737		{
738		zsteps[i]=-i*zstep;
739		}
740		for (i=N_FRAMES/4;i<N_FRAMES/2;i++)
741		{
742		zsteps[i]=-granular+(i-N_FRAMES/4)*zstep;
743		}
744		for (i=N_FRAMES/2;i<N_FRAMES;i++)
745		{
746		zsteps[i]=-zsteps[i-N_FRAMES/2];
747		}
748		~~zsteps[N_FRAMES-1]=0~~;
749		~~cout << "Step z " << zstep << endl~~;
750		~~cout << "Matrix3 ";~~
751		~~for (i=0;i<N_FRAMES;i++)~~ cout << zsteps[i] << " ";
752		cout << endl;
753
	800	float granular = 0.07;
	801	float zstep = granular / double (N_FRAMES / 4);
	802	for (i = 0; i < N_FRAMES / 4; i++) {
	803	zsteps[i] = -i * zstep;
	804	}
	805	for (i = N_FRAMES / 4; i < N_FRAMES / 2; i++) {
	806	zsteps[i] = -granular + (i - N_FRAMES / 4) * zstep;
	807	}
	808	for (i = N_FRAMES / 2; i < N_FRAMES; i++) {
	809	zsteps[i] = -zsteps[i - N_FRAMES / 2];
	810	}
	811	zsteps[N_FRAMES - 1] = 0;
	812
	813	#ifdef DEBUG_MODE
	814	cout << "Step z " << zstep << endl;
	815	cout << "Matrix3 ";
	816	for (i = 0; i < N_FRAMES; i++)
	817	cout << zsteps[i] << " ";
	818	cout << endl;
	819	#endif
754	820	/*double pdfcube::zoomsteps[N_FRAMES] =
755	821	{ 0.00, 0.01, 0.02, 0.03, 0.05, 0.07, 0.10, 0.13, 0.17,
756	822	0.21, 0.25, 0.29, 0.32, 0.35, 0.37, 0.38, 0.38 };*/
757	823
758		float zoomstop = 0.38;
759		float zoomstep = (zoomstop/double(N_FRAMES));
760		for (i=0;i<N_FRAMES;i++)
761		{
762		zoomsteps[i]=i*zoomstep;
763		}
764		zoomsteps[N_FRAMES-1]= zoomstop;
765		cout << "Step zoom " << zoomstep << endl;
766		cout << "Matrix4 ";
767		for (i=0;i<N_FRAMES;i++) cout << zoomsteps[i] << " ";
768		cout << endl;
769
	824	float zoomstop = 0.38;
	825	float zoomstep = (zoomstop / double (N_FRAMES));
	826	for (i = 0; i < N_FRAMES; i++) {
	827	zoomsteps[i] = i * zoomstep;
	828	}
	829	zoomsteps[N_FRAMES - 1] = zoomstop;
	830
	831	#ifdef DEBUG_MODE
	832	cout << "Step zoom " << zoomstep << endl;
	833	cout << "Matrix4 ";
	834	for (i = 0; i < N_FRAMES; i++)
	835	cout << zoomsteps[i] << " ";
	836	cout << endl;
	837	#endif
770	838	/*double pdfcube::perspsteps[N_FRAMES] =
771	839	{ 44.0, 44.0, 44.0, 44.00, 44.00, 43.00, 42.00, 40.00,
772	840	38.00, 36.00, 33.00, 30.00, 27.00, 24.00, 22.00, 21.00, 21.00 };*/
773	841
774		float perspstart = 44.00;
775		float perspstop = 21.00;
776		float perspstep = (perspstart-perspstop)/double(N_FRAMES);
777		for (i=0;i<N_FRAMES;i++)
778		{
779		perspsteps[i]=perspstart-i*perspstep;
780		}
781		perspsteps[0]=perspstart;
782		perspsteps[N_FRAMES-1]=perspstop;
783		cout << "Step persp " << perspstep << endl;
784		cout << "Matrix5 ";
785		for (i=0;i<N_FRAMES;i++) cout << perspsteps[i] << " ";
786		cout << endl;
787
	842	float perspstart = 44.00;
	843	float perspstop = 21.00;
	844	float perspstep = (perspstart - perspstop) / double (N_FRAMES);
	845	for (i = 0; i < N_FRAMES; i++) {
	846	perspsteps[i] = perspstart - i * perspstep;
	847	}
	848	perspsteps[0] = perspstart;
	849	perspsteps[N_FRAMES - 1] = perspstop;
	850
	851	#ifdef DEBUG_MODE
	852	cout << "Step persp " << perspstep << endl;
	853	cout << "Matrix5 ";
	854	for (i = 0; i < N_FRAMES; i++)
	855	cout << perspsteps[i] << " ";
	856	cout << endl;
	857	#endif
788	858
789	859	/*double pdfcube::perspstepsc[N_FRAMES] =
790	860	{ 44.0, 44.0, 44.0, 44.00, 44.00, 43.00, 42.00, 40.00,
791	861	38.00, 36.00, 34.00, 32.00, 31.00, 30.00, 30.00, 30.00, 30.00 };*/
792		float perspcstart = 44.00;
793		float perspcstop = 30.00;
794		float perspcstep = (perspcstart-perspcstop)/double(N_FRAMES/2);
795		for (i=0;i<N_FRAMES/4;i++) perspstepsc[i]=perspcstart;
796
797		for (i=N_FRAMES/4;i<3*(N_FRAMES/4);i++)
798		{
799		perspstepsc[i]=perspcstart-i*perspcstep;
800		}
801		for (i=3*(N_FRAMES/4);i<N_FRAMES;i++) perspstepsc[i]=perspcstop;
802		cout << "Step perspc " << perspcstep << endl;
803		cout << "Matrix6 ";
804		for (i=0;i<N_FRAMES;i++) cout << perspstepsc[i] << " ";
805		cout << endl;
806
807		}
808
809		void
810		backward(GtkWidget *widget)
811		{
812		update_textures_dir(widget, false);
813		cerr << "Current page: " << current_page << endl;
814		}
815
816		void
817		reset(GtkWidget *widget)
818		{
819		animating = FALSE;
820		frame = 0;
821		lookposx = 0.0;
822		lookposy = 0.0;
823		lookposz = 3.48;
824		atx = 0.0;
825		aty = 0.0;
826		atz = 0.0;
827		persp = 44.0;
828		angle = 0.0;
829		current_face = 0;
830		active_animation = ANIM_NONE;
831		previous_animation = ANIM_NONE;
832		last_animation = ANIM_NONE;
833		update_textures(widget);
834		}
835
836		void
837		quick_reset(GtkWidget *widget)
838		{
839		animating = FALSE;
840		frame = 0;
841		lookposx = 0.0;
842		lookposy = 0.0;
843		lookposz = 3.48;
844		atx = 0.0;
845		aty = 0.0;
846		atz = 0.0;
847		persp = 44.0;
848		angle = 0.0;
849		current_face = 0;
850		active_animation = ANIM_NONE;
851		previous_animation = ANIM_NONE;
852		last_animation = ANIM_NONE;
	862	float perspcstart = 44.00;
	863	float perspcstop = 30.00;
	864	float perspcstep =
	865	(perspcstart - perspcstop) / double (N_FRAMES / 2);
	866	for (i = 0; i < N_FRAMES / 4; i++)
	867	perspstepsc[i] = perspcstart;
	868
	869	for (i = N_FRAMES / 4; i < 3 * (N_FRAMES / 4); i++) {
	870	perspstepsc[i] = perspcstart - i * perspcstep;
	871	}
	872	for (i = 3 * (N_FRAMES / 4); i < N_FRAMES; i++)
	873	perspstepsc[i] = perspcstop;
	874
	875	#ifdef DEBUG_MODE
	876	cout << "Step perspc " << perspcstep << endl;
	877	cout << "Matrix6 ";
	878	for (i = 0; i < N_FRAMES; i++)
	879	cout << perspstepsc[i] << " ";
	880	cout << endl;
	881	#endif
	882	}
	883
	884	void
	885	backward(GtkWidget * widget) {
	886	update_textures_dir(widget, false);
	887	#ifdef DEBUG_MODE
	888	cerr << "Current page: " << current_page << endl;
	889	#endif
	890	}
	891
	892	void
	893	reset(GtkWidget * widget) {
	894	animating = FALSE;
	895	frame = 0;
	896	lookposx = 0.0;
	897	lookposy = 0.0;
	898	lookposz = 3.48;
	899	atx = 0.0;
	900	aty = 0.0;
	901	atz = 0.0;
	902	persp = 44.0;
	903	angle = 0.0;
	904	current_face = 0;
	905	active_animation = ANIM_NONE;
	906	previous_animation = ANIM_NONE;
	907	last_animation = ANIM_NONE;
	908	update_textures(widget);
	909	}
	910
	911	void
	912	quick_reset(GtkWidget * widget) {
	913	animating = FALSE;
	914	frame = 0;
	915	lookposx = 0.0;
	916	lookposy = 0.0;
	917	lookposz = 3.48;
	918	atx = 0.0;
	919	aty = 0.0;
	920	atz = 0.0;
	921	persp = 44.0;
	922	angle = 0.0;
	923	current_face = 0;
	924	active_animation = ANIM_NONE;
	925	previous_animation = ANIM_NONE;
	926	last_animation = ANIM_NONE;
853	927	// update_textures(widget);
854		}
855
856		// shift old textures and render the new page
857		// texmap[0] -> current page
858		// texmap[1] -> prev page
859		// texmap[2] -> next page
860		void update_textures_dir(GtkWidget *widget, bool forward)
861		{
862		assert(current_page >= 0);
863		assert(current_page < total_pages);
864
865		if(forward)
866		{
867		current_page=next_page();
868		int tmp = texmap[2];
869		texmap[2] = texmap[1];
870		texmap[1] = texmap[0];
871		texmap[0] = tmp;
872		render_page(pixmap, next_page(), tex_width, tex_height);
873		}
874		else
875		{
876		current_page=prev_page();
877		int tmp = texmap[0];
878		texmap[0] = texmap[1];
879		texmap[1] = texmap[2];
880		texmap[2] = tmp;
881		render_page(pixmap, prev_page(), tex_width, tex_height);
882		}
883
884		glBindTexture (GL_TEXTURE_RECTANGLE_ARB,
885		textures[texmap[forward ? 2 : 1]]);
886		glTexImage2D (GL_TEXTURE_RECTANGLE_ARB,
887		0,
888		GL_RGBA,
889		tex_width,
890		tex_height,
891		0,
892		GL_RGBA,
893		GL_UNSIGNED_BYTE,
894		gdk_pixbuf_get_pixels(pixmap));
895
896		gdk_window_invalidate_rect (widget->window, &widget->allocation, FALSE);
897
898		}
899
900		// render all (3) textures
901		void update_textures(GtkWidget *widget)
902		{
903		assert(current_page >= 0);
904		assert(current_page < total_pages);
905
906		render_page(pixmap, current_page, tex_width, tex_height);
907		glBindTexture (GL_TEXTURE_RECTANGLE_ARB, textures[texmap[0]]);
908		glTexImage2D (GL_TEXTURE_RECTANGLE_ARB,
909		0,
910		GL_RGBA,
911		tex_width,
912		tex_height,
913		0,
914		GL_RGBA,
915		GL_UNSIGNED_BYTE,
916		gdk_pixbuf_get_pixels(pixmap));
917
918		render_page(pixmap, prev_page(), tex_width, tex_height);
919		glBindTexture (GL_TEXTURE_RECTANGLE_ARB, textures[texmap[1]]);
920		glTexImage2D (GL_TEXTURE_RECTANGLE_ARB,
921		0,
922		GL_RGBA,
923		tex_width,
924		tex_height,
925		0,
926		GL_RGBA,
927		GL_UNSIGNED_BYTE,
928		gdk_pixbuf_get_pixels(pixmap));
929
930		render_page(pixmap, next_page(), tex_width, tex_height);
931		glBindTexture (GL_TEXTURE_RECTANGLE_ARB, textures[texmap[2]]);
932		glTexImage2D (GL_TEXTURE_RECTANGLE_ARB,
933		0,
934		GL_RGBA,
935		tex_width,
936		tex_height,
937		0,
938		GL_RGBA,
939		GL_UNSIGNED_BYTE,
940		gdk_pixbuf_get_pixels(pixmap));
941
942
943		gdk_window_invalidate_rect (widget->window, &widget->allocation, FALSE);
944
945		}
946
947		protected:
948		PopplerDocument* doc;
949		int current_page;
950		int current_face;
951		const int total_pages;
952		int frame;
953		double lookposx, lookposy, lookposz;
954		double atx, aty, atz;
955		double persp, angle;
956		GdkPixbuf* pixmap;
957		int texmap[3];
958
959		// OpenGL Textures
960		GLuint textures[3];
961
962		// Width and Height of the rendered pixmap (aspect
963		// ratio is fixed, should instead depend on the
964		// aspect ratio of the pdf page)
965		static const gint tex_width = (gint)(3*1024/2);
966		static const gint tex_height = (gint)(3*768/2);
967
968
969		void
970		render_page(GdkPixbuf* pm, int i, gint iWidth, gint iHeight)
971		{
972		PopplerPage *page;
973		page = poppler_document_get_page(doc, i);
974		double w, h;
975		poppler_page_get_size(page, &w, &h);
976		poppler_page_render_to_pixbuf(page, 0,0,iWidth,iHeight,1.0*iWidth/w,0,pm);
977		}
978
979		void
980		drawCube(void)
981		{
982		int i;
983
984		for (i = 0; i < 6; i++)
985		{
986		if(i == current_face)
987		{
988		glEnable (GL_TEXTURE_RECTANGLE_ARB);
989		glBindTexture (GL_TEXTURE_RECTANGLE_ARB, textures[texmap[0]]);
990		}
991		else if(i == prev_face())
992		{
993		glEnable (GL_TEXTURE_RECTANGLE_ARB);
994		glBindTexture (GL_TEXTURE_RECTANGLE_ARB, textures[texmap[1]]);
995		}
996		else if(i == next_face())
997		{
998		glEnable (GL_TEXTURE_RECTANGLE_ARB);
999		glBindTexture (GL_TEXTURE_RECTANGLE_ARB, textures[texmap[2]]);
1000		}
1001		else if(i <= 3)
1002		{
1003		glDisable(GL_TEXTURE_RECTANGLE_ARB);
1004		glColor4f(0.4, 0.0, 0.0, 1.0);
1005		}
1006		else
1007		{
1008		glDisable(GL_TEXTURE_RECTANGLE_ARB);
1009		glColor4f(1.0, 1.0, 1.0, 1.0);
1010		}
1011		glPolygonMode (GL_FRONT,GL_FILL);
1012		glBegin(GL_QUADS);
1013		// glNormal3fv(&n[i][0]);
1014		glTexCoord2f((1.0-mapping[i][4]) * tex_width,
1015		mapping[i][5] * tex_height);
1016		glVertex3fv(&v[faces[i][0]][0]);
1017
1018		glTexCoord2f((1.0-mapping[i][6]) * tex_width,
1019		mapping[i][7] * tex_height);
1020		glVertex3fv(&v[faces[i][1]][0]);
1021
1022		glTexCoord2f((1.0-mapping[i][0]) * tex_width,
1023		mapping[i][1] * tex_height);
1024		glVertex3fv(&v[faces[i][2]][0]);
1025
1026		glTexCoord2f((1.0-mapping[i][2]) * tex_width,
1027		mapping[i][3] * tex_height);
1028		glVertex3fv(&v[faces[i][3]][0]);
1029
1030		glEnd();
1031		}
1032		}
	928	}
	929
	930	// shift old textures and render the new page
	931	// texmap[0] -> current page
	932	// texmap[1] -> prev page
	933	// texmap[2] -> next page
	934	void update_textures_dir(GtkWidget * widget, bool forward) {
	935	#ifdef DEBUG_MODE_ASSERT
	936	assert(current_page >= 0);
	937	assert(current_page < total_pages);
	938	#endif
	939	if (forward) {
	940	current_page = next_page();
	941	int tmp = texmap[2];
	942	texmap[2] = texmap[1];
	943	texmap[1] = texmap[0];
	944	texmap[0] = tmp;
	945	render_page(pixmap, next_page(), tex_width, tex_height);
	946	} else {
	947	current_page = prev_page();
	948	int tmp = texmap[0];
	949	texmap[0] = texmap[1];
	950	texmap[1] = texmap[2];
	951	texmap[2] = tmp;
	952	render_page(pixmap, prev_page(), tex_width, tex_height);
	953	}
	954
	955	glBindTexture(GL_TEXTURE_RECTANGLE_ARB,
	956	textures[texmap[forward ? 2 : 1]]);
	957	glTexImage2D(GL_TEXTURE_RECTANGLE_ARB,
	958	0,
	959	GL_RGBA,
	960	tex_width,
	961	tex_height,
	962	0,
	963	GL_RGBA,
	964	GL_UNSIGNED_BYTE, gdk_pixbuf_get_pixels(pixmap));
	965
	966	gdk_window_invalidate_rect(widget->window, &widget->allocation,
	967	FALSE);
	968
	969	}
	970
	971	// render all (3) textures
	972	void update_textures(GtkWidget * widget) {
	973
	974	#ifdef DEBUG_MODE_ASSERT
	975	assert(current_page >= 0);
	976	assert(current_page < total_pages);
	977	#endif
	978	render_page(pixmap, current_page, tex_width, tex_height);
	979	glBindTexture(GL_TEXTURE_RECTANGLE_ARB, textures[texmap[0]]);
	980	glTexImage2D(GL_TEXTURE_RECTANGLE_ARB,
	981	0,
	982	GL_RGBA,
	983	tex_width,
	984	tex_height,
	985	0,
	986	GL_RGBA,
	987	GL_UNSIGNED_BYTE, gdk_pixbuf_get_pixels(pixmap));
	988
	989	render_page(pixmap, prev_page(), tex_width, tex_height);
	990	glBindTexture(GL_TEXTURE_RECTANGLE_ARB, textures[texmap[1]]);
	991	glTexImage2D(GL_TEXTURE_RECTANGLE_ARB,
	992	0,
	993	GL_RGBA,
	994	tex_width,
	995	tex_height,
	996	0,
	997	GL_RGBA,
	998	GL_UNSIGNED_BYTE, gdk_pixbuf_get_pixels(pixmap));
	999
	1000	render_page(pixmap, next_page(), tex_width, tex_height);
	1001	glBindTexture(GL_TEXTURE_RECTANGLE_ARB, textures[texmap[2]]);
	1002	glTexImage2D(GL_TEXTURE_RECTANGLE_ARB,
	1003	0,
	1004	GL_RGBA,
	1005	tex_width,
	1006	tex_height,
	1007	0,
	1008	GL_RGBA,
	1009	GL_UNSIGNED_BYTE, gdk_pixbuf_get_pixels(pixmap));
	1010
	1011	gdk_window_invalidate_rect(widget->window, &widget->allocation,
	1012	FALSE);
	1013
	1014	}
	1015
	1016	protected:
	1017	PopplerDocument * doc;
	1018	int current_page;
	1019	int current_face;
	1020	const int total_pages;
	1021	int frame;
	1022	double lookposx, lookposy, lookposz;
	1023	double atx, aty, atz;
	1024	double persp, angle;
	1025	GdkPixbuf *pixmap;
	1026	int texmap[3];
	1027
	1028	// OpenGL Textures
	1029	GLuint textures[3];
	1030
	1031	// Width and Height of the rendered pixmap (aspect
	1032	// ratio is fixed, should instead depend on the
	1033	// aspect ratio of the pdf page)
	1034	static const gint tex_width = (gint) (3 * 1024 / 2);
	1035	static const gint tex_height = (gint) (3 * 768 / 2);
	1036
	1037	void
	1038	render_page(GdkPixbuf * pm, int i, gint iWidth, gint iHeight) {
	1039	PopplerPage *page;
	1040	page = poppler_document_get_page(doc, i);
	1041	double w, h;
	1042	poppler_page_get_size(page, &w, &h);
	1043	poppler_page_render_to_pixbuf(page, 0, 0, iWidth, iHeight,
	1044	1.0 * iWidth / w, 0, pm);
	1045	}
	1046
	1047	void
	1048	drawCube(void) {
	1049	int i;
	1050
	1051	for (i = 0; i < 6; i++) {
	1052	if (i == current_face) {
	1053	glEnable(GL_TEXTURE_RECTANGLE_ARB);
	1054	glBindTexture(GL_TEXTURE_RECTANGLE_ARB,
	1055	textures[texmap[0]]);
	1056	} else if (i == prev_face()) {
	1057	glEnable(GL_TEXTURE_RECTANGLE_ARB);
	1058	glBindTexture(GL_TEXTURE_RECTANGLE_ARB,
	1059	textures[texmap[1]]);
	1060	} else if (i == next_face()) {
	1061	glEnable(GL_TEXTURE_RECTANGLE_ARB);
	1062	glBindTexture(GL_TEXTURE_RECTANGLE_ARB,
	1063	textures[texmap[2]]);
	1064	} else if (i <= 3) {
	1065	glDisable(GL_TEXTURE_RECTANGLE_ARB);
	1066	glColor4f(0.4, 0.0, 0.0, 1.0);
	1067	} else {
	1068	glDisable(GL_TEXTURE_RECTANGLE_ARB);
	1069	glColor4f(1.0, 1.0, 1.0, 1.0);
	1070	}
	1071	glPolygonMode(GL_FRONT, GL_FILL);
	1072	glBegin(GL_QUADS);
	1073	// glNormal3fv(&n[i][0]);
	1074	glTexCoord2f((1.0 - mapping[i][4]) * tex_width,
	1075	mapping[i][5] * tex_height);
	1076	glVertex3fv(&v[faces[i][0]][0]);
	1077
	1078	glTexCoord2f((1.0 - mapping[i][6]) * tex_width,
	1079	mapping[i][7] * tex_height);
	1080	glVertex3fv(&v[faces[i][1]][0]);
	1081
	1082	glTexCoord2f((1.0 - mapping[i][0]) * tex_width,
	1083	mapping[i][1] * tex_height);
	1084	glVertex3fv(&v[faces[i][2]][0]);
	1085
	1086	glTexCoord2f((1.0 - mapping[i][2]) * tex_width,
	1087	mapping[i][3] * tex_height);
	1088	glVertex3fv(&v[faces[i][3]][0]);
	1089
	1090	glEnd();
	1091	}
	1092	}
1033	1093	};
1034	1094
1035		GLfloat pdfcube::n[6][3] = {
1036		{0.0, 0.0, -1.0}, {1.0, 0.0, 0.0}, {0.0, 0.0, 1.0}, {-1.0, 0.0, 0.0},
1037		{0.0, 1.0, 0.0}, {0.0, -1.0, 0.0}
	1095	GLfloat
	1096	pdfcube::n[6][3] = {
	1097	{0.0, 0.0, -1.0}
	1098	, {1.0, 0.0, 0.0}
	1099	, {0.0, 0.0, 1.0}
	1100	, {-1.0, 0.0, 0.0}
	1101	,
	1102	{0.0, 1.0, 0.0}
	1103	, {0.0, -1.0, 0.0}
1038	1104	};
1039		GLint pdfcube::faces[6][4] = {
1040		{7, 4, 0, 3}, {7, 6, 5, 4}, {5, 6, 2, 1}, {0, 1, 2, 3},
1041		{3, 2, 6, 7}, {4, 5, 1, 0}
	1105	GLint
	1106	pdfcube::faces[6][4] = {
	1107	{7, 4, 0, 3}
	1108	, {7, 6, 5, 4}
	1109	, {5, 6, 2, 1}
	1110	, {0, 1, 2, 3}
	1111	,
	1112	{3, 2, 6, 7}
	1113	, {4, 5, 1, 0}
1042	1114	};
1043		GLfloat pdfcube::mapping[6][8] = {
1044		{1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0},
1045		{0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0},
1046		{0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0},
1047		{1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0},
1048		{1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0}, // top
1049		{1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0}, // bottom
	1115	GLfloat
	1116	pdfcube::mapping[6][8] = {
	1117	{1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0}
	1118	,
	1119	{0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0}
	1120	,
	1121	{0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0}
	1122	,
	1123	{1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0}
	1124	,
	1125	{1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0}
	1126	, // top
	1127	{1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0}
	1128	, // bottom
1050	1129	};
1051	1130
1052		pdfcube* pc;
1053
1054
	1131	pdfcube *
	1132	pc;
1055	1133
1056	1134	//////////////////////////////////////////////////////////////////////////
…	…
1063	1141	***/
1064	1142	static void
1065		realize (GtkWidget *widget,
1066		gpointer data)
1067		{
1068		GdkGLContext *glcontext = gtk_widget_get_gl_context (widget);
1069		GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget);
1070
1071		g_print ("%s: \"realize\"\n", gtk_widget_get_name (widget));
1072
1073		//g_mutex_lock (gl_mutex);
	1143	realize(GtkWidget * widget, gpointer data)
	1144	{
	1145	GdkGLContext *
	1146	glcontext = gtk_widget_get_gl_context(widget);
	1147	GdkGLDrawable *
	1148	gldrawable = gtk_widget_get_gl_drawable(widget);
	1149
	1150	#ifdef DEBUG_MODE
	1151	g_print("%s: \"realize\"\n", gtk_widget_get_name(widget));
	1152	#endif
	1153	//g_mutex_lock (gl_mutex);
1074	1154
1075	1155	/* OpenGL BEGIN */
1076		~~if (!gdk_gl_drawable_gl_begin~~ (gldrawable, glcontext))
1077		return;
1078
1079		pc->initialize(widget);
1080
1081		~~gdk_gl_drawable_gl_end~~ (gldrawable);
	1156	if (!gdk_gl_drawable_gl_begin(gldrawable, glcontext))
	1157	return;
	1158
	1159	pc->initialize(widget);
	1160
	1161	gdk_gl_drawable_gl_end(gldrawable);
1082	1162	/* OpenGL END */
1083		//g_mutex_unlock (gl_mutex);
	1163	//g_mutex_unlock (gl_mutex);
1084	1164	}
1085	1165
…	…
1090	1170	*** the window is resized.
1091	1171	***/
1092		static gboolean
1093		configure_event (GtkWidget *widget,
1094		GdkEventConfigure *event,
1095		gpointer data)
1096		{
1097		GdkGLContext *glcontext = gtk_widget_get_gl_context (widget);
1098		GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget);
1099
1100		GLsizei w = widget->allocation.width;
1101		GLsizei h = widget->allocation.height;
1102
1103		g_print ("%s: \"configure_event\"\n", gtk_widget_get_name (widget));
1104
1105		//g_mutex_lock (gl_mutex);
	1172	static
	1173	gboolean
	1174	configure_event(GtkWidget * widget, GdkEventConfigure * event, gpointer data)
	1175	{
	1176	GdkGLContext *
	1177	glcontext = gtk_widget_get_gl_context(widget);
	1178	GdkGLDrawable *
	1179	gldrawable = gtk_widget_get_gl_drawable(widget);
	1180
	1181	GLsizei
	1182	w = widget->allocation.width;
	1183	GLsizei
	1184	h = widget->allocation.height;
	1185
	1186	#ifdef DEBUG_MODE
	1187	g_print("%s: \"configure_event\"\n", gtk_widget_get_name(widget));
	1188	#endif
	1189	//g_mutex_lock (gl_mutex);
1106	1190	/* OpenGL BEGIN */
1107		~~if (!gdk_gl_drawable_gl_begin~~ (gldrawable, glcontext))
1108		return FALSE;
1109
1110		~~glViewport~~ (0, 0, w, h);
1111
1112		~~gdk_gl_drawable_gl_end~~ (gldrawable);
	1191	if (!gdk_gl_drawable_gl_begin(gldrawable, glcontext))
	1192	return FALSE;
	1193
	1194	glViewport(0, 0, w, h);
	1195
	1196	gdk_gl_drawable_gl_end(gldrawable);
1113	1197
1114	1198	/* OpenGL END */
1115		//g_mutex_unlock (gl_mutex);
1116
1117		return TRUE;
	1199	//g_mutex_unlock (gl_mutex);
	1200
	1201	return TRUE;
1118	1202	}
1119	1203
…	…
1123	1207	*** every time the 'expose'/'draw' event is signalled.
1124	1208	***/
1125		static gboolean
1126		expose_event (GtkWidget *widget,
1127		GdkEventExpose *event,
1128		gpointer data)
1129		{
1130		GdkGLContext *glcontext = gtk_widget_get_gl_context (widget);
1131		GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget);
1132
1133		//g_mutex_lock (gl_mutex);
	1209	static
	1210	gboolean
	1211	expose_event(GtkWidget * widget, GdkEventExpose * event, gpointer data)
	1212	{
	1213	GdkGLContext *
	1214	glcontext = gtk_widget_get_gl_context(widget);
	1215	GdkGLDrawable *
	1216	gldrawable = gtk_widget_get_gl_drawable(widget);
	1217
	1218	//g_mutex_lock (gl_mutex);
1134	1219	/* OpenGL BEGIN */
1135		if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext))
1136		return FALSE;
1137
1138		glDrawBuffer(GL_BACK);
1139
1140		pc->redraw(widget);
1141
1142		/* Swap buffers */
1143		if (gdk_gl_drawable_is_double_buffered (gldrawable))
1144		gdk_gl_drawable_swap_buffers (gldrawable);
1145		else
1146		glFlush ();
1147
1148
1149		gdk_gl_drawable_gl_end (gldrawable);
	1220	if (!gdk_gl_drawable_gl_begin(gldrawable, glcontext))
	1221	return FALSE;
	1222
	1223	glDrawBuffer(GL_BACK);
	1224
	1225	pc->redraw(widget);
	1226
	1227	/* Swap buffers */
	1228	if (gdk_gl_drawable_is_double_buffered(gldrawable))
	1229	gdk_gl_drawable_swap_buffers(gldrawable);
	1230	else
	1231	glFlush();
	1232
	1233	gdk_gl_drawable_gl_end(gldrawable);
1150	1234	/* OpenGL END */
1151	1235
1152		//g_mutex_unlock (gl_mutex);
1153
1154		return TRUE;
	1236	//g_mutex_unlock (gl_mutex);
	1237
	1238	return TRUE;
1155	1239	}
1156	1240
…	…
1160	1244	*** frame updates.
1161	1245	***/
1162		static gboolean
1163		timeout (GtkWidget *widget)
1164		{
1165		/* Invalidate the whole window. */
1166		gdk_window_invalidate_rect (widget->window, &widget->allocation, FALSE);
1167
1168		/* Update synchronously. */
1169		gdk_window_process_updates (widget->window, FALSE);
1170
1171		return TRUE;
	1246	static
	1247	gboolean
	1248	timeout(GtkWidget * widget)
	1249	{
	1250	/* Invalidate the whole window. */
	1251	gdk_window_invalidate_rect(widget->window, &widget->allocation, FALSE);
	1252
	1253	/* Update synchronously. */
	1254	gdk_window_process_updates(widget->window, FALSE);
	1255
	1256	return TRUE;
1172	1257	}
1173	1258
…	…
1177	1262	***/
1178	1263	static void
1179		unrealize (GtkWidget *widget,
1180		gpointer data)
1181		{
1182		GdkGLContext *glcontext = gtk_widget_get_gl_context (widget);
1183		GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget);
1184
1185		g_print ("%s: \"unrealize\"\n", gtk_widget_get_name (widget));
1186
1187		//g_mutex_lock (gl_mutex);
	1264	unrealize(GtkWidget * widget, gpointer data)
	1265	{
	1266	GdkGLContext *
	1267	glcontext = gtk_widget_get_gl_context(widget);
	1268	GdkGLDrawable *
	1269	gldrawable = gtk_widget_get_gl_drawable(widget);
	1270
	1271	#ifdef DEBUG_MODE
	1272	g_print("%s: \"unrealize\"\n", gtk_widget_get_name(widget));
	1273	#endif
	1274	//g_mutex_lock (gl_mutex);
1188	1275
1189	1276	/* OpenGL BEGIN */
1190		~~if (!gdk_gl_drawable_gl_begin~~ (gldrawable, glcontext))
1191		return;
1192
1193		~~gdk_gl_drawable_gl_end~~ (gldrawable);
	1277	if (!gdk_gl_drawable_gl_begin(gldrawable, glcontext))
	1278	return;
	1279
	1280	gdk_gl_drawable_gl_end(gldrawable);
1194	1281	/* OpenGL END */
1195		//g_mutex_unlock (gl_mutex);
	1282	//g_mutex_unlock (gl_mutex);
1196	1283	}
1197	1284
…	…
1200	1287	*** the OpenGL-capable drawing area is under drag motion should be done here.
1201	1288	***/
1202		static gboolean
1203		motion_notify_event (GtkWidget *widget,
1204		GdkEventMotion *event,
1205		gpointer data)
1206		{
1207		g_print ("%s: \"motion_notify_event\": button", gtk_widget_get_name (widget));
1208
1209		if (event->state & GDK_BUTTON1_MASK)
1210		{
1211		g_print (" 1");
1212		}
1213
1214		if (event->state & GDK_BUTTON2_MASK)
1215		{
1216		g_print (" 2");
1217		}
1218
1219		if (event->state & GDK_BUTTON3_MASK)
1220		{
1221		g_print (" 3");
1222		}
1223
1224		g_print ("\n");
1225
1226		return FALSE;
	1289	static
	1290	gboolean
	1291	motion_notify_event(GtkWidget * widget, GdkEventMotion * event, gpointer data)
	1292	{
	1293	#ifdef DEBUG_MODE
	1294	g_print("%s: \"motion_notify_event\": button",
	1295	gtk_widget_get_name(widget));
	1296	if (event->state & GDK_BUTTON1_MASK) {
	1297	g_print(" 1");
	1298	}
	1299
	1300	if (event->state & GDK_BUTTON2_MASK) {
	1301	g_print(" 2");
	1302	}
	1303
	1304	if (event->state & GDK_BUTTON3_MASK) {
	1305	g_print(" 3");
	1306	}
	1307
	1308	g_print("\n");
	1309	#endif
	1310	return FALSE;
1227	1311	}
1228	1312
…	…
1232	1316	*** capable drawing area should be done here.
1233	1317	***/
1234		static ~~gboolean~~
1235		button_press_event (GtkWidget *widget,
1236		GdkEventButton *event,
1237		gpointer data)
1238		{
1239		~~g_print ("%s: \"button_press_event\": ", gtk_widget_get_name~~ (widget));
1240
1241		if (event->button == 1)
1242		{
1243		~~g_print~~ ("button 1\n");
1244
1245		return TRUE;
1246		}
1247
1248		if (event->button == 2)
1249		{
1250		~~g_print~~ ("button 2\n");
1251
1252		return TRUE;
1253		}
1254
1255		~~g_print~~ ("\n");
1256
1257		return FALSE;
	1318	static
	1319	gboolean
	1320	button_press_event(GtkWidget * widget, GdkEventButton * event, gpointer data)
	1321	{
	1322	#ifdef DEBUG_MODE
	1323	g_print("%s: \"button_press_event\": ", gtk_widget_get_name(widget));
	1324	#endif
	1325	if (event->button == 1) {
	1326	#ifdef DEBUG_MODE
	1327	g_print("button 1\n");
	1328	#endif
	1329	return TRUE;
	1330	}
	1331
	1332	if (event->button == 2) {
	1333	#ifdef DEBUG_MODE
	1334	g_print("button 2\n");
	1335	#endif
	1336	return TRUE;
	1337	}
	1338	#ifdef DEBUG_MODE
	1339	g_print("\n");
	1340	#endif
	1341	return FALSE;
1258	1342	}
1259	1343
…	…
1262	1346	*** presses occur should be done here.
1263	1347	***/
1264		static gboolean
1265		key_press_event (GtkWidget *widget,
1266		GdkEventKey *event,
1267		gpointer data)
1268		{
1269		g_print ("%s: \"key_press_event\": ", gtk_widget_get_name (widget));
1270
1271		if(event->state == GDK_CONTROL_MASK)
1272
1273		switch (event->keyval)
1274		{
1275		case GDK_1:
1276		case GDK_2:
1277		case GDK_3:
1278		case GDK_4:
1279		case GDK_5:
1280		case GDK_6:
1281		case GDK_7:
1282		case GDK_8:
1283		case GDK_9:
1284		g_print ("n key\n");
1285		if(sleeping())
1286		pc->section(widget, event->keyval - GDK_1 + 1);
1287		break;
1288
1289		// Let's quit
1290		case GDK_q:
1291		g_print ("Escape key\n");
1292		gtk_main_quit ();
1293		break;
1294
1295		// Update all textures
1296		case GDK_l:
1297		g_print ("u key\n");
1298		cerr << "Pagina: " << pc->page() << endl;
1299		pc->reset(widget);
1300		break;
1301		}
1302		else
1303		switch (event->keyval)
1304		{
1305
1306		// return to page 1
1307		case GDK_1:
1308		case GDK_2:
1309		case GDK_3:
1310		case GDK_4:
1311		case GDK_5:
1312		case GDK_6:
1313		case GDK_7:
1314		case GDK_8:
1315		case GDK_9:
1316		g_print ("n key\n");
1317		if(sleeping())
1318		pc->go_to(widget, (event->keyval - GDK_1) * 5);
1319		break;
1320
1321		// Animated Cube Advancement
1322		case GDK_a:
1323		g_print ("a key\n");
1324		if(sleeping())
1325		start_animation(widget, CUBE_PREV);
1326
1327		break;
1328		case GDK_c:
1329		g_print ("c key\n");
1330		if(sleeping())
1331		start_animation(widget, CUBE_NEXT);
1332		break;
1333
1334		// Quick switch to next page
1335		case GDK_Page_Down:
1336		case GDK_Right:
1337		g_print ("s key\n");
1338		if(sleeping())
1339		start_animation(widget, SWITCH_FW);
1340		break;
1341
1342		// Quick switch to previous page
1343		case GDK_Page_Up:
1344		case GDK_Left:
1345		g_print ("q key\n");
1346		if(sleeping())
1347		start_animation(widget, SWITCH_BW);
1348		break;
1349
1350
1351
1352		case GDK_g:
1353		if(sleeping())
1354		if(last_animation >= ZOOM1 and last_animation <= ZOOMC)
1355		start_animation(widget, ZOOM0);
1356		break;
1357
1358		case GDK_h:
1359		if(sleeping())
1360		if(last_animation >= ZOOM1 and last_animation <= ZOOMC)
1361		start_animation(widget, ZOOM0);
1362		else
1363		start_animation(widget, ZOOM1);
1364		break;
1365
1366		case GDK_j:
1367		if(sleeping())
1368		if(last_animation >= ZOOM1 and last_animation <= ZOOMC)
1369		start_animation(widget, ZOOM0);
1370		else
1371		start_animation(widget, ZOOM2);
1372		break;
1373
1374		case GDK_k:
1375		if(sleeping())
1376		if(last_animation >= ZOOM1 and last_animation <= ZOOMC)
1377		start_animation(widget, ZOOM0);
1378		else
1379		start_animation(widget, ZOOM3);
1380		break;
1381
1382		case GDK_l:
1383		if(sleeping())
1384		if(last_animation >= ZOOM1 and last_animation <= ZOOMC)
1385		start_animation(widget, ZOOM0);
1386		else
1387		start_animation(widget, ZOOM4);
1388		break;
1389
1390		case GDK_z:
1391		if(sleeping())
1392		if(last_animation >= ZOOM1 and last_animation <= ZOOMC)
1393		start_animation(widget, ZOOM0);
1394		else
1395		start_animation(widget, ZOOMC);
1396		break;
1397
1398
1399		// Automatic advance (you should se the Animated slides on the command line)
1400		case GDK_space:
1401		if(page_transition[pc->page()] and sleeping())
1402		start_animation(widget, CUBE_NEXT);
1403		else if(sleeping())
1404		start_animation(widget, SWITCH_FW);
1405
1406		break;
1407
1408		// switch fullscreen
1409		case GDK_f:
1410		if( (fullscreen = !fullscreen) == true)
1411		gtk_window_fullscreen((GtkWindow*)(data));
1412		else
1413		gtk_window_unfullscreen((GtkWindow*)(data));
1414		break;
1415
1416		// Let's quit
1417		case GDK_Escape:
1418		g_print ("Escape key\n");
1419		gtk_main_quit ();
1420		break;
1421
1422		default:
1423		g_print("\n");
1424		return FALSE;
1425		}
1426
1427		return TRUE;
1428		}
1429
	1348	static
	1349	gboolean
	1350	key_press_event(GtkWidget * widget, GdkEventKey * event, gpointer data)
	1351	{
	1352	#ifdef DEBUG_MODE
	1353	g_print("%s: \"key_press_event\": ", gtk_widget_get_name(widget));
	1354	#endif
	1355	if (event->state == GDK_CONTROL_MASK)
	1356
	1357	switch (event->keyval) {
	1358	case GDK_1:
	1359	case GDK_2:
	1360	case GDK_3:
	1361	case GDK_4:
	1362	case GDK_5:
	1363	case GDK_6:
	1364	case GDK_7:
	1365	case GDK_8:
	1366	case GDK_9:
	1367	#ifdef DEBUG_MODE
	1368	g_print("n key\n");
	1369	#endif
	1370	if (sleeping())
	1371	pc->section(widget, event->keyval - GDK_1 + 1);
	1372	break;
	1373
	1374	// Let's quit
	1375	case GDK_q:
	1376	#ifdef DEBUG_MODE
	1377	g_print("Escape key\n");
	1378	#endif
	1379	gtk_main_quit();
	1380	break;
	1381
	1382	// Update all textures
	1383	case GDK_l:
	1384	#ifdef DEBUG_MODE
	1385	g_print("u key\n");
	1386	cerr << "Pagina: " << pc->page() << endl;
	1387	#endif
	1388	pc->reset(widget);
	1389	break;
	1390	} else
	1391	switch (event->keyval) {
	1392
	1393	// return to page 1
	1394	case GDK_1:
	1395	case GDK_2:
	1396	case GDK_3:
	1397	case GDK_4:
	1398	case GDK_5:
	1399	case GDK_6:
	1400	case GDK_7:
	1401	case GDK_8:
	1402	case GDK_9:
	1403	#ifdef DEBUG_MODE
	1404	g_print("n key\n");
	1405	#endif
	1406	if (sleeping())
	1407	pc->go_to(widget, (event->keyval - GDK_1) * 5);
	1408	break;
	1409
	1410	// Animated Cube Advancement
	1411	case GDK_a:
	1412	#ifdef DEBUG_MODE
	1413	g_print("a key\n");
	1414	#endif
	1415	if (sleeping())
	1416	start_animation(widget, CUBE_PREV);
	1417
	1418	break;
	1419	case GDK_c:
	1420	#ifdef DEBUG_MODE
	1421	g_print("c key\n");
	1422	#endif
	1423	if (sleeping())
	1424	start_animation(widget, CUBE_NEXT);
	1425	break;
	1426
	1427	// Quick switch to next page
	1428	case GDK_Page_Down:
	1429	case GDK_Right:
	1430	#ifdef DEBUG_MODE
	1431	g_print("s key\n");
	1432	#endif
	1433	if (sleeping())
	1434	start_animation(widget, SWITCH_FW);
	1435	break;
	1436
	1437	// Quick switch to previous page
	1438	case GDK_Page_Up:
	1439	case GDK_Left:
	1440	#ifdef DEBUG_MODE
	1441	g_print("q key\n");
	1442	#endif
	1443	if (sleeping())
	1444	start_animation(widget, SWITCH_BW);
	1445	break;
	1446
	1447	case GDK_g:
	1448	if (sleeping())
	1449	if (last_animation >=
	1450	ZOOM1 and last_animation <= ZOOMC)
	1451	start_animation(widget, ZOOM0);
	1452	break;
	1453
	1454	case GDK_h:
	1455	if (sleeping())
	1456	if (last_animation >=
	1457	ZOOM1 and last_animation <= ZOOMC)
	1458	start_animation(widget, ZOOM0);
	1459	else
	1460	start_animation(widget, ZOOM1);
	1461	break;
	1462
	1463	case GDK_j:
	1464	if (sleeping())
	1465	if (last_animation >=
	1466	ZOOM1 and last_animation <= ZOOMC)
	1467	start_animation(widget, ZOOM0);
	1468	else
	1469	start_animation(widget, ZOOM2);
	1470	break;
	1471
	1472	case GDK_k:
	1473	if (sleeping())
	1474	if (last_animation >=
	1475	ZOOM1 and last_animation <= ZOOMC)
	1476	start_animation(widget, ZOOM0);
	1477	else
	1478	start_animation(widget, ZOOM3);
	1479	break;
	1480
	1481	case GDK_l:
	1482	if (sleeping())
	1483	if (last_animation >=
	1484	ZOOM1 and last_animation <= ZOOMC)
	1485	start_animation(widget, ZOOM0);
	1486	else
	1487	start_animation(widget, ZOOM4);
	1488	break;
	1489
	1490	case GDK_z:
	1491	if (sleeping())
	1492	if (last_animation >=
	1493	ZOOM1 and last_animation <= ZOOMC)
	1494	start_animation(widget, ZOOM0);
	1495	else
	1496	start_animation(widget, ZOOMC);
	1497	break;
	1498
	1499	// Automatic advance (you should se the Animated slides on the command line)
	1500	case GDK_space:
	1501	if (page_transition[pc->page()]and sleeping())
	1502	start_animation(widget, CUBE_NEXT);
	1503	else if (sleeping())
	1504	start_animation(widget, SWITCH_FW);
	1505
	1506	break;
	1507
	1508	// switch fullscreen
	1509	case GDK_f:
	1510	if ((fullscreen = !fullscreen) == true)
	1511	gtk_window_fullscreen((GtkWindow *) (data));
	1512	else
	1513	gtk_window_unfullscreen((GtkWindow *) (data));
	1514	break;
	1515
	1516	// Let's quit
	1517	case GDK_Escape:
	1518	#ifdef DEBUG_MODE
	1519	g_print("Escape key\n");
	1520	#endif
	1521	gtk_main_quit();
	1522	break;
	1523
	1524	default:
	1525	#ifdef DEBUG_MODE
	1526	g_print("\n");
	1527	#endif
	1528	return FALSE;
	1529	}
	1530
	1531	return TRUE;
	1532	}
1430	1533
1431	1534	//////////////////////////////////////////////////////////////////////////
…	…
1436	1539	***/
1437	1540
1438		static guint timeout_id = 0;
	1541	static guint
	1542	timeout_id = 0;
1439	1543
1440	1544	static void
1441		timeout_add (GtkWidget *widget)
1442		{
1443		if (timeout_id == 0)
1444		{
1445		timeout_id = g_timeout_add (TIMEOUT_INTERVAL,
1446		(GSourceFunc) timeout,
1447		widget);
1448		}
	1545	timeout_add(GtkWidget * widget)
	1546	{
	1547	if (timeout_id == 0) {
	1548	timeout_id = g_timeout_add(TIMEOUT_INTERVAL,
	1549	(GSourceFunc) timeout, widget);
	1550	}
1449	1551	}
1450	1552
1451	1553	static void
1452		timeout_remove (GtkWidget *widget)
1453		{
1454		if (timeout_id != 0)
1455		{
1456		g_source_remove (timeout_id);
1457		timeout_id = 0;
1458		}
	1554	timeout_remove(GtkWidget * widget)
	1555	{
	1556	if (timeout_id != 0) {
	1557	g_source_remove(timeout_id);
	1558	timeout_id = 0;
	1559	}
1459	1560	}
1460	1561
…	…
1463	1564	*** OpenGL-capable drawing area is mapped should be done here.
1464	1565	***/
1465		static gboolean
1466		map_event (GtkWidget *widget,
1467		GdkEvent *event,
1468		gpointer data)
1469		{
1470		g_print ("%s: \"map_event\":\n", gtk_widget_get_name (widget));
1471		if (animating)
1472		timeout_add (widget);
1473
1474		return TRUE;
	1566	static
	1567	gboolean
	1568	map_event(GtkWidget * widget, GdkEvent * event, gpointer data)
	1569	{
	1570	#ifdef DEBUG_MODE
	1571	g_print("%s: \"map_event\":\n", gtk_widget_get_name(widget));
	1572	#endif
	1573	if (animating)
	1574	timeout_add(widget);
	1575
	1576	return TRUE;
1475	1577	}
1476	1578
…	…
1479	1581	*** OpenGL-capable drawing area is unmapped should be done here.
1480	1582	***/
1481		static gboolean
1482		unmap_event (GtkWidget *widget,
1483		GdkEvent *event,
1484		gpointer data)
1485		{
1486		g_print ("%s: \"unmap_event\":\n", gtk_widget_get_name (widget));
1487		timeout_remove (widget);
1488
1489		return TRUE;
	1583	static
	1584	gboolean
	1585	unmap_event(GtkWidget * widget, GdkEvent * event, gpointer data)
	1586	{
	1587	#ifdef DEBUG_MODE
	1588	g_print("%s: \"unmap_event\":\n", gtk_widget_get_name(widget));
	1589	#endif
	1590	timeout_remove(widget);
	1591
	1592	return TRUE;
1490	1593	}
1491	1594
…	…
1495	1598	*** done here.
1496	1599	***/
1497		static gboolean
1498		visibility_notify_event (GtkWidget *widget,
1499		GdkEventVisibility *event,
1500		gpointer data)
1501		{
1502		if (animating)
1503		{
1504		if (event->state == GDK_VISIBILITY_FULLY_OBSCURED)
1505		timeout_remove (widget);
1506		else
1507		timeout_add (widget);
1508		}
1509
1510		return TRUE;
1511		}
1512
	1600	static
	1601	gboolean
	1602	visibility_notify_event(GtkWidget * widget,
	1603	GdkEventVisibility * event, gpointer data)
	1604	{
	1605	if (animating) {
	1606	if (event->state == GDK_VISIBILITY_FULLY_OBSCURED)
	1607	timeout_remove(widget);
	1608	else
	1609	timeout_add(widget);
	1610	}
	1611
	1612	return TRUE;
	1613	}
1513	1614
1514	1615	/**************************************************************************
…	…
1520	1621	***/
1521	1622	static void
1522		start_animation(GtkWidget *widget, enum animation a)
1523		{
1524		if(sleeping())
1525		{
1526		animating = true;
1527		previous_animation = last_animation;
1528		last_animation = active_animation = a;
1529		timeout_add(widget);
1530		}
	1623	start_animation(GtkWidget * widget, enum animation a)
	1624	{
	1625	if (sleeping()) {
	1626	animating = true;
	1627	previous_animation = last_animation;
	1628	last_animation = active_animation = a;
	1629	timeout_add(widget);
	1630	}
1531	1631	}
1532	1632
1533	1633	static void
1534		stop_animation(GtkWidget *widget)
1535		{
1536		animating = false;
1537		timeout_remove(widget);
1538		gdk_window_invalidate_rect(widget->window, &widget->allocation, FALSE);
1539		~~gdk_window_process_updates~~ (widget->window, FALSE);
	1634	stop_animation(GtkWidget * widget)
	1635	{
	1636	animating = false;
	1637	timeout_remove(widget);
	1638	gdk_window_invalidate_rect(widget->window, &widget->allocation, FALSE);
	1639	gdk_window_process_updates(widget->window, FALSE);
1540	1640	}
1541	1641
…	…
1548	1648	***/
1549	1649	static GtkWidget *
1550		create_window (GdkGLConfig *glconfig)
1551		{
1552		GtkWidget *window;
1553		GtkWidget *vbox;
1554		GtkWidget *drawing_area;
1555
1556		/*
1557		* Top-level window.
1558		*/
1559
1560		window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1561		gtk_window_set_title (GTK_WINDOW (window), DEFAULT_TITLE);
1562
1563		/* Get automatically redrawn if any of their children changed allocation. */
1564		gtk_container_set_reallocate_redraws (GTK_CONTAINER (window), TRUE);
1565
1566		/* Connect signal handlers to the window */
1567		g_signal_connect (G_OBJECT (window), "delete_event",
1568		G_CALLBACK (gtk_main_quit), NULL);
1569
1570		/*
1571		* VBox.
1572		*/
1573
1574		vbox = gtk_vbox_new (FALSE, 0);
1575		gtk_container_add (GTK_CONTAINER (window), vbox);
1576		gtk_widget_show (vbox);
1577
1578		/*
1579		* Drawing area to draw OpenGL scene.
1580		*/
1581
1582		drawing_area = gtk_drawing_area_new ();
1583		gtk_widget_set_size_request (drawing_area, DEFAULT_WIDTH, DEFAULT_HEIGHT);
1584
1585		/* Set OpenGL-capability to the widget */
1586		gtk_widget_set_gl_capability (drawing_area,
1587		glconfig,
1588		NULL,
1589		TRUE,
1590		GDK_GL_RGBA_TYPE);
1591
1592		gtk_widget_add_events (drawing_area,
1593		GDK_BUTTON1_MOTION_MASK \|
1594		GDK_BUTTON2_MOTION_MASK \|
1595		GDK_BUTTON_PRESS_MASK \|
1596		GDK_VISIBILITY_NOTIFY_MASK);
1597
1598		/* Connect signal handlers to the drawing area */
1599		g_signal_connect_after (G_OBJECT (drawing_area), "realize",
1600		G_CALLBACK (realize), NULL);
1601		g_signal_connect (G_OBJECT (drawing_area), "configure_event",
1602		G_CALLBACK (configure_event), NULL);
1603		g_signal_connect (G_OBJECT (drawing_area), "expose_event",
1604		G_CALLBACK (expose_event), NULL);
1605		g_signal_connect (G_OBJECT (drawing_area), "unrealize",
1606		G_CALLBACK (unrealize), NULL);
1607
1608		g_signal_connect (G_OBJECT (drawing_area), "motion_notify_event",
1609		G_CALLBACK (motion_notify_event), NULL);
1610		g_signal_connect (G_OBJECT (drawing_area), "button_press_event",
1611		G_CALLBACK (button_press_event), NULL);
1612
1613		/* key_press_event handler for top-level window */
1614		g_signal_connect_swapped (G_OBJECT (window), "key_press_event",
1615		G_CALLBACK (key_press_event), drawing_area);
1616
1617		/* For timeout function. */
1618		g_signal_connect (G_OBJECT (drawing_area), "map_event",
1619		G_CALLBACK (map_event), NULL);
1620		g_signal_connect (G_OBJECT (drawing_area), "unmap_event",
1621		G_CALLBACK (unmap_event), NULL);
1622		g_signal_connect (G_OBJECT (drawing_area), "visibility_notify_event",
1623		G_CALLBACK (visibility_notify_event), NULL);
1624
1625		gtk_box_pack_start (GTK_BOX (vbox), drawing_area, TRUE, TRUE, 0);
1626
1627		gtk_widget_show (drawing_area);
1628
1629		return window;
	1650	create_window(GdkGLConfig * glconfig)
	1651	{
	1652	GtkWidget *
	1653	window;
	1654	GtkWidget *
	1655	vbox;
	1656	GtkWidget *
	1657	drawing_area;
	1658
	1659	/*
	1660	* Top-level window.
	1661	*/
	1662
	1663	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	1664	gtk_window_set_title(GTK_WINDOW(window), DEFAULT_TITLE);
	1665
	1666	/* Get automatically redrawn if any of their children changed allocation. */
	1667	gtk_container_set_reallocate_redraws(GTK_CONTAINER(window), TRUE);
	1668
	1669	/* Connect signal handlers to the window */
	1670	g_signal_connect(G_OBJECT(window), "delete_event",
	1671	G_CALLBACK(gtk_main_quit), NULL);
	1672
	1673	/*
	1674	* VBox.
	1675	*/
	1676
	1677	vbox = gtk_vbox_new(FALSE, 0);
	1678	gtk_container_add(GTK_CONTAINER(window), vbox);
	1679	gtk_widget_show(vbox);
	1680
	1681	/*
	1682	* Drawing area to draw OpenGL scene.
	1683	*/
	1684
	1685	drawing_area = gtk_drawing_area_new();
	1686	gtk_widget_set_size_request(drawing_area, DEFAULT_WIDTH,
	1687	DEFAULT_HEIGHT);
	1688
	1689	/* Set OpenGL-capability to the widget */
	1690	gtk_widget_set_gl_capability(drawing_area,
	1691	glconfig, NULL, TRUE, GDK_GL_RGBA_TYPE);
	1692
	1693	gtk_widget_add_events(drawing_area,
	1694	GDK_BUTTON1_MOTION_MASK \|
	1695	GDK_BUTTON2_MOTION_MASK \|
	1696	GDK_BUTTON_PRESS_MASK \|
	1697	GDK_VISIBILITY_NOTIFY_MASK);
	1698
	1699	/* Connect signal handlers to the drawing area */
	1700	g_signal_connect_after(G_OBJECT(drawing_area), "realize",
	1701	G_CALLBACK(realize), NULL);
	1702	g_signal_connect(G_OBJECT(drawing_area), "configure_event",
	1703	G_CALLBACK(configure_event), NULL);
	1704	g_signal_connect(G_OBJECT(drawing_area), "expose_event",
	1705	G_CALLBACK(expose_event), NULL);
	1706	g_signal_connect(G_OBJECT(drawing_area), "unrealize",
	1707	G_CALLBACK(unrealize), NULL);
	1708
	1709	g_signal_connect(G_OBJECT(drawing_area), "motion_notify_event",
	1710	G_CALLBACK(motion_notify_event), NULL);
	1711	g_signal_connect(G_OBJECT(drawing_area), "button_press_event",
	1712	G_CALLBACK(button_press_event), NULL);
	1713
	1714	/* key_press_event handler for top-level window */
	1715	g_signal_connect_swapped(G_OBJECT(window), "key_press_event",
	1716	G_CALLBACK(key_press_event), drawing_area);
	1717
	1718	/* For timeout function. */
	1719	g_signal_connect(G_OBJECT(drawing_area), "map_event",
	1720	G_CALLBACK(map_event), NULL);
	1721	g_signal_connect(G_OBJECT(drawing_area), "unmap_event",
	1722	G_CALLBACK(unmap_event), NULL);
	1723	g_signal_connect(G_OBJECT(drawing_area), "visibility_notify_event",
	1724	G_CALLBACK(visibility_notify_event), NULL);
	1725
	1726	gtk_box_pack_start(GTK_BOX(vbox), drawing_area, TRUE, TRUE, 0);
	1727
	1728	gtk_widget_show(drawing_area);
	1729
	1730	return window;
1630	1731	}
1631	1732
…	…
1634	1735	***/
1635	1736	static GdkGLConfig *
1636		configure_gl (void)
1637		{
1638		GdkGLConfig *glconfig;
1639
1640		/* Try double-buffered visual */
1641		glconfig = gdk_gl_config_new_by_mode ((GdkGLConfigMode)
1642		(
1643		GDK_GL_MODE_RGBA \|
1644		GDK_GL_MODE_ALPHA \|
1645		GDK_GL_MODE_RGB \|
1646		GDK_GL_MODE_DEPTH \|
1647		GDK_GL_MODE_DOUBLE));
1648		if (glconfig == NULL)
1649		{
1650		g_print ("\n*** Cannot find the double-buffered visual.\n");
1651		g_print ("\n*** Trying single-buffered visual.\n");
1652
1653		/* Try single-buffered visual */
1654		glconfig = gdk_gl_config_new_by_mode ((GdkGLConfigMode)
1655		(
1656		GDK_GL_MODE_RGB \|
1657		GDK_GL_MODE_DEPTH));
1658		if (glconfig == NULL)
1659		{
1660		g_print ("*** No appropriate OpenGL-capable visual found.\n");
1661		exit (1);
1662		}
1663		}
1664
1665
1666		return glconfig;
	1737	configure_gl(void)
	1738	{
	1739	GdkGLConfig *
	1740	glconfig;
	1741
	1742	/* Try double-buffered visual */
	1743	glconfig = gdk_gl_config_new_by_mode((GdkGLConfigMode)
	1744	(GDK_GL_MODE_RGBA \|
	1745	GDK_GL_MODE_ALPHA \|
	1746	GDK_GL_MODE_RGB \|
	1747	GDK_GL_MODE_DEPTH \|
	1748	GDK_GL_MODE_DOUBLE));
	1749	if (glconfig == NULL) {
	1750	g_print("\n*** Cannot find the double-buffered visual.\n");
	1751	g_print("\n*** Trying single-buffered visual.\n");
	1752
	1753	/* Try single-buffered visual */
	1754	glconfig = gdk_gl_config_new_by_mode((GdkGLConfigMode)
	1755	(GDK_GL_MODE_RGB \|
	1756	GDK_GL_MODE_DEPTH));
	1757	if (glconfig == NULL) {
	1758	g_print
	1759	("*** No appropriate OpenGL-capable visual found.\n");
	1760	exit(1);
	1761	}
	1762	}
	1763
	1764	return glconfig;
1667	1765	}
1668	1766
…	…
1680	1778	///
1681	1779	gchar *
1682		get_absolute_file_name (const gchar *fileName)
1683		{
1684		gchar *absoluteFileName = NULL;
1685		if ( g_path_is_absolute (fileName) )
1686		{
1687		absoluteFileName = g_strdup (fileName);
1688		}
1689		else
1690		{
1691		gchar *currentDir = g_get_current_dir ();
1692		absoluteFileName = g_build_filename (currentDir, fileName, NULL);
1693		g_free (currentDir);
1694		}
1695
1696		return absoluteFileName;
	1780	get_absolute_file_name(const gchar * fileName)
	1781	{
	1782	gchar *
	1783	absoluteFileName = NULL;
	1784	if (g_path_is_absolute(fileName)) {
	1785	absoluteFileName = g_strdup(fileName);
	1786	} else {
	1787	gchar *
	1788	currentDir = g_get_current_dir();
	1789	absoluteFileName = g_build_filename(currentDir, fileName, NULL);
	1790	g_free(currentDir);
	1791	}
	1792
	1793	return absoluteFileName;
1697	1794	}
1698	1795
…	…
1701	1798
1702	1799	int
1703		main (int argc,
1704		char *argv[])
1705		{
1706		GtkWidget *window;
1707		GdkGLConfig *glconfig;
1708
1709		/* Initialize GTK. */
1710		gtk_init (&argc, &argv);
1711
1712		/* Initialize GtkGLExt. */
1713		gtk_gl_init (&argc, &argv);
1714
1715		/* Configure OpenGL framebuffer. */
1716		glconfig = configure_gl();
1717
1718		if(argc < 2)
1719		{
1720		perror("usage: pdfcube file_uri [cube_page ...]");
1721		exit(1);
1722		}
1723		gchar *absoluteFileName = get_absolute_file_name (argv[1]);
1724		gchar *filename_uri = g_filename_to_uri (absoluteFileName, NULL, NULL);
1725		g_free (absoluteFileName);
1726		if ( NULL == filename_uri )
1727		{
1728		cerr << "Errore nel nome del file" << endl;
1729		}
1730		PopplerDocument* document =
1731		poppler_document_new_from_file(filename_uri, NULL, NULL);
1732
1733		if(document == NULL)
1734		{
1735		perror("invaild pdf file");
1736		exit(2);
1737		}
1738
1739		pc = new pdfcube(document);
1740
1741		page_transition = new bool[pc->pages()];
1742
1743		for(int ii = 0; ii < pc->pages(); ii++)
1744		{
1745		page_transition[ii] = false;
1746		}
1747
1748		for(int ii = 2; ii < argc; ii++)
1749		{
1750		page_transition[atoi(argv[ii])] = true;
1751		}
1752
1753		/* Create and show the application window. */
1754		window = create_window(glconfig);
1755
1756		if(fullscreen)
1757		gtk_window_fullscreen((GtkWindow*)(window));
1758
1759		gtk_widget_show (window);
1760
1761		gtk_main ();
1762
1763		return 0;
	1800	main(int argc, char *argv[])
	1801	{
	1802	GtkWidget *
	1803	window;
	1804	GdkGLConfig *
	1805	glconfig;
	1806
	1807	/* Initialize GTK. */
	1808	gtk_init(&argc, &argv);
	1809
	1810	/* Initialize GtkGLExt. */
	1811	gtk_gl_init(&argc, &argv);
	1812
	1813	/* Configure OpenGL framebuffer. */
	1814	glconfig = configure_gl();
	1815
	1816	if (argc < 2) {
	1817	perror("usage: pdfcube file_uri [cube_page ...]");
	1818	exit(1);
	1819	}
	1820	gchar *
	1821	absoluteFileName = get_absolute_file_name(argv[1]);
	1822	gchar *
	1823	filename_uri = g_filename_to_uri(absoluteFileName, NULL, NULL);
	1824	g_free(absoluteFileName);
	1825	if (NULL == filename_uri) {
	1826	cerr << "Errore nel nome del file" << endl;
	1827	}
	1828	PopplerDocument *
	1829	document = poppler_document_new_from_file(filename_uri, NULL, NULL);
	1830
	1831	if (document == NULL) {
	1832	perror("invaild pdf file");
	1833	exit(2);
	1834	}
	1835
	1836	pc = new pdfcube(document);
	1837
	1838	page_transition = new bool[pc->pages()];
	1839
	1840	for (int ii = 0; ii < pc->pages(); ii++) {
	1841	page_transition[ii] = false;
	1842	}
	1843
	1844	for (int ii = 2; ii < argc; ii++) {
	1845	page_transition[atoi(argv[ii])] = true;
	1846	}
	1847
	1848	/* Create and show the application window. */
	1849	window = create_window(glconfig);
	1850
	1851	if (fullscreen)
	1852	gtk_window_fullscreen((GtkWindow *) (window));
	1853
	1854	gtk_widget_show(window);
	1855
	1856	gtk_main();
	1857
	1858	return 0;
1764	1859	}
1765	1860

Context Navigation

Changeset 13 for branches

Legend:

branches/pdfcube-0.0.3/src/pdfcube.cc

Download in other formats: