Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Annotate
Revision Log

thinice_theme_draw.c @ 18878

Visit:

Revision 18878, 69.9 KB checked in by ghudson, 22 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r18877, which included commits to RCS files with non-trunk default branches.

Line
1	/* ThinIce theme for gtk, based on raster's Motif theme and the Metal theme.
2	Authors: Tim Gerla <timg@rrv.net>
3	Tomas Ögren <stric@ing.umu.se>
4	*/
5	/* #define DEBUG 1 */
6
7	#include <math.h>
8	#include <string.h>
9	#include <gtk/gtknotebook.h>
10
11	#include "thinice_style.h"
12	#include "thinice_rc_style.h"
13
14	#define DETAIL(xx) ((detail) && (!strcmp(xx, detail)))
15	#ifndef max
16	#define max(x,y) ((x)>=(y)?(x):(y))
17	#endif
18	#ifndef min
19	#define min(x,y) ((x)<=(y)?(x):(y))
20	#endif
21
22	static void thinice_style_init (ThiniceStyle *style);
23	static void thinice_style_class_init (ThiniceStyleClass *klass);
24
25	static void
26	thinice_slash_two(GdkWindow *window,
27	GdkGC *gc1,
28	GdkGC *gc2,
29	gint x,
30	gint y,
31	gint width,
32	gint height);
33
34	static void
35	thinice_slash_one(GdkWindow *window,
36	GdkGC *gc1,
37	GdkGC *gc2,
38	gint x,
39	gint y,
40	gint width,
41	gint height);
42
43	static void
44	thinice_dot(GdkWindow *window,
45	GdkGC *gc1,
46	GdkGC *gc2,
47	gint x,
48	gint y);
49
50
51	static void
52	thinice_tab(GtkStyle * style,
53	GdkWindow * window,
54	GtkStateType state_type,
55	GtkShadowType shadow_type,
56	GdkRectangle * area,
57	GtkWidget * widget,
58	const gchar *detail,
59	gint x,
60	gint y,
61	gint width,
62	gint height);
63
64	#if 0
65	static void
66	draw_harrow (GdkWindow *window,
67	GdkGC *gc,
68	GtkShadowType shadow_type,
69	GdkRectangle *area,
70	GtkArrowType arrow_type,
71	gint x,
72	gint y,
73	gint width,
74	gint height);
75	static void
76	draw_varrow (GdkWindow *window,
77	GdkGC *gc,
78	GtkShadowType shadow_type,
79	GdkRectangle *area,
80	GtkArrowType arrow_type,
81	gint x,
82	gint y,
83	gint width,
84	gint height);
85	#endif
86
87	static GtkStyleClass *parent_class = NULL;
88
89
90	static GtkShadowType
91	get_shadow_type (GtkStyle style, const char detail, GtkShadowType requested)
92	{
93	GtkShadowType retval = GTK_SHADOW_NONE;
94
95	if (requested != GTK_SHADOW_NONE) {
96	retval = GTK_SHADOW_ETCHED_IN;
97	}
98
99	if (DETAIL ("dockitem") \|\| DETAIL ("handlebox_bin") \|\| DETAIL ("spinbutton_up") \|\| DETAIL ("spinbutton_down")) {
100	retval = GTK_SHADOW_NONE;
101	} else if (DETAIL ("button") \|\| DETAIL ("togglebutton") \|\| DETAIL ("notebook") \|\| DETAIL ("optionmenu")) {
102	retval = requested;
103	} else if (DETAIL ("menu")) {
104	retval = GTK_SHADOW_ETCHED_IN;
105	}
106
107	return retval;
108	}
109
110	static void
111	calculate_arrow_geometry (GtkArrowType arrow_type,
112	gint *x,
113	gint *y,
114	gint *width,
115	gint *height)
116	{
117	gint w = *width;
118	gint h = *height;
119
120	switch (arrow_type)
121	{
122	case GTK_ARROW_UP:
123	case GTK_ARROW_DOWN:
124	w += (w % 2) - 1;
125	h = (w / 2 + 1);
126
127	if (h > *height)
128	{
129	h = *height;
130	w = 2 * h - 1;
131	}
132
133	if (arrow_type == GTK_ARROW_DOWN)
134	{
135	if (*height % 2 == 1 \|\| h % 2 == 0)
136	*height += 1;
137	}
138	else
139	{
140	if (*height % 2 == 0 \|\| h % 2 == 0)
141	*height -= 1;
142	}
143	break;
144
145	case GTK_ARROW_RIGHT:
146	case GTK_ARROW_LEFT:
147	h += (h % 2) - 1;
148	w = (h / 2 + 1);
149
150	if (w > *width)
151	{
152	w = *width;
153	h = 2 * w - 1;
154	}
155
156	if (arrow_type == GTK_ARROW_RIGHT)
157	{
158	if (*width % 2 == 1 \|\| w % 2 == 0)
159	*width += 1;
160	}
161	else
162	{
163	if (*width % 2 == 0 \|\| w % 2 == 0)
164	*width -= 1;
165	}
166	break;
167
168	default:
169	/* should not be reached */
170	break;
171	}
172
173	x += (width - w) / 2;
174	y += (height - h) / 2;
175	*height = h;
176	*width = w;
177	}
178	static void
179	sanitize_size (GdkWindow *window,
180	gint *width,
181	gint *height)
182	{
183	if ((width == -1) && (height == -1))
184	gdk_window_get_size (window, width, height);
185	else if (*width == -1)
186	gdk_window_get_size (window, width, NULL);
187	else if (*height == -1)
188	gdk_window_get_size (window, NULL, height);
189	}
190
191	static void
192	draw_hline(GtkStyle * style,
193	GdkWindow * window,
194	GtkStateType state_type,
195	GdkRectangle * area,
196	GtkWidget * widget,
197	const gchar *detail,
198	gint x1,
199	gint x2,
200	gint y)
201	{
202	gint thickness_light;
203	gint thickness_dark;
204	gint i;
205
206	g_return_if_fail(style != NULL);
207	g_return_if_fail(window != NULL);
208
209	thickness_light = style->ythickness / 2;
210	thickness_dark = style->ythickness - thickness_light;
211
212	if (area)
213	{
214	gdk_gc_set_clip_rectangle(style->light_gc[state_type], area);
215	gdk_gc_set_clip_rectangle(style->dark_gc[state_type], area);
216	}
217	for (i = 0; i < thickness_dark; i++)
218	{
219	gdk_draw_line(window, style->light_gc[state_type], x2 - i - 1, y + i, x2, y + i);
220	gdk_draw_line(window, style->dark_gc[state_type], x1, y + i, x2 - i - 1, y + i);
221	}
222
223	y += thickness_dark;
224	for (i = 0; i < thickness_light; i++)
225	{
226	gdk_draw_line(window, style->dark_gc[state_type], x1, y + i, x1 + thickness_light - i - 1, y + i);
227	gdk_draw_line(window, style->light_gc[state_type], x1 + thickness_light - i - 1, y + i, x2, y + i);
228	}
229	if (area)
230	{
231	gdk_gc_set_clip_rectangle(style->light_gc[state_type], NULL);
232	gdk_gc_set_clip_rectangle(style->dark_gc[state_type], NULL);
233	}
234	}
235
236	static void
237	draw_vline(GtkStyle * style,
238	GdkWindow * window,
239	GtkStateType state_type,
240	GdkRectangle * area,
241	GtkWidget * widget,
242	const gchar *detail,
243	gint y1,
244	gint y2,
245	gint x)
246	{
247	gint thickness_light;
248	gint thickness_dark;
249	gint i;
250
251	g_return_if_fail(style != NULL);
252	g_return_if_fail(window != NULL);
253
254	thickness_light = style->xthickness / 2;
255	thickness_dark = style->xthickness - thickness_light;
256
257	if (area)
258	{
259	gdk_gc_set_clip_rectangle(style->light_gc[state_type], area);
260	gdk_gc_set_clip_rectangle(style->dark_gc[state_type], area);
261	}
262	for (i = 0; i < thickness_dark; i++)
263	{
264	gdk_draw_line(window, style->light_gc[state_type], x + i, y2 - i - 1, x + i, y2);
265	gdk_draw_line(window, style->dark_gc[state_type], x + i, y1, x + i, y2 - i - 1);
266	}
267
268	x += thickness_dark;
269	for (i = 0; i < thickness_light; i++)
270	{
271	gdk_draw_line(window, style->dark_gc[state_type], x + i, y1, x + i, y1 + thickness_light - i);
272	gdk_draw_line(window, style->light_gc[state_type], x + i, y1 + thickness_light - i, x + i, y2);
273	}
274	if (area)
275	{
276	gdk_gc_set_clip_rectangle(style->light_gc[state_type], NULL);
277	gdk_gc_set_clip_rectangle(style->dark_gc[state_type], NULL);
278	}
279	}
280
281	static void
282	draw_shadow(GtkStyle *style,
283	GdkWindow *window,
284	GtkStateType state_type,
285	GtkShadowType shadow_type,
286	GdkRectangle *area,
287	GtkWidget *widget,
288	const gchar *detail,
289	gint x,
290	gint y,
291	gint width,
292	gint height)
293	{
294	GdkGC *gc1 = NULL;
295	GdkGC *gc2 = NULL;
296
297	g_return_if_fail(style != NULL);
298	g_return_if_fail(window != NULL);
299
300	sanitize_size(window, &width, &height);
301
302	if (DETAIL("entry") \|\| DETAIL("text")) {
303	gint entry_width;
304	gint entry_height;
305	gdk_window_get_size (window, &entry_width, &entry_height);
306	if (entry_width != width \|\| entry_height != height)
307	return;
308	}
309
310	switch (shadow_type)
311	{
312	case GTK_SHADOW_NONE:
313	return;
314	case GTK_SHADOW_IN:
315	if (((x == 1) \|\| (y == 1)) && (DETAIL("entry") \|\| DETAIL("text")))
316	{
317	gc1 = gc2 = style->base_gc[state_type];
318	break;
319	}
320	case GTK_SHADOW_ETCHED_IN:
321	gc1 = style->light_gc[state_type];
322	gc2 = style->dark_gc[state_type];
323	break;
324	case GTK_SHADOW_OUT:
325	case GTK_SHADOW_ETCHED_OUT:
326	gc1 = style->dark_gc[state_type];
327	gc2 = style->light_gc[state_type];
328	break;
329	}
330
331	if (area)
332	{
333	gdk_gc_set_clip_rectangle(gc1, area);
334	gdk_gc_set_clip_rectangle(gc2, area);
335	if ((shadow_type == GTK_SHADOW_IN) \|\|
336	(shadow_type == GTK_SHADOW_OUT))
337	{
338	gdk_gc_set_clip_rectangle(style->black_gc, area);
339	gdk_gc_set_clip_rectangle(style->bg_gc[state_type], area);
340	}
341	}
342	switch (shadow_type)
343	{
344	case GTK_SHADOW_NONE:
345	break;
346
347	case GTK_SHADOW_ETCHED_IN:
348	gdk_draw_rectangle(window, gc1, FALSE, x+1, y+1, width-2, height-2);
349	gdk_draw_rectangle(window, gc2, FALSE, x, y, width-2, height-2);
350
351	break;
352	case GTK_SHADOW_IN:
353	gdk_draw_line(window, gc2,
354	x, y, x + width-1, y);
355	gdk_draw_line(window, gc2,
356	x, y, x, y + height-1);
357
358	gdk_draw_line(window, gc1,
359	x, y + height-1, x + width-1, y + height-1);
360	gdk_draw_line(window, gc1,
361	x + width-1, y, x + width-1, y + height-1);
362	break;
363
364	case GTK_SHADOW_ETCHED_OUT:
365	gdk_draw_rectangle(window, gc1, FALSE, x+1, y+1, width-2, height-2);
366	gdk_draw_rectangle(window, gc2, FALSE, x, y, width-2, height-2);
367
368	break;
369	case GTK_SHADOW_OUT:
370	gdk_draw_line(window, gc2,
371	x, y, x + width-1, y);
372	gdk_draw_line(window, gc2,
373	x, y, x, y + height-1);
374
375	gdk_draw_line(window, gc1,
376	x, y + height-1, x + width-1, y + height-1);
377	gdk_draw_line(window, gc1,
378	x + width-1, y, x + width-1, y + height-1);
379
380	break;
381	}
382	if (area)
383	{
384	gdk_gc_set_clip_rectangle(gc1, NULL);
385	gdk_gc_set_clip_rectangle(gc2, NULL);
386	if ((shadow_type == GTK_SHADOW_IN) \|\|
387	(shadow_type == GTK_SHADOW_OUT))
388	{
389	gdk_gc_set_clip_rectangle(style->black_gc, NULL);
390	gdk_gc_set_clip_rectangle(style->bg_gc[state_type], NULL);
391	}
392	}
393	}
394
395	static void
396	draw_polygon(GtkStyle * style,
397	GdkWindow * window,
398	GtkStateType state_type,
399	GtkShadowType shadow_type,
400	GdkRectangle * area,
401	GtkWidget * widget,
402	const gchar *detail,
403	GdkPoint * points,
404	gint npoints,
405	gint fill)
406	{
407	#ifndef M_PI
408	#define M_PI 3.14159265358979323846
409	#endif /* M_PI */
410	#ifndef M_PI_4
411	#define M_PI_4 0.78539816339744830962
412	#endif /* M_PI_4 */
413
414	static const gdouble pi_over_4 = M_PI_4;
415	static const gdouble pi_3_over_4 = M_PI_4 * 3;
416
417	GdkGC *gc1;
418	GdkGC *gc2;
419	GdkGC *gc3;
420	GdkGC *gc4;
421	gdouble angle;
422	gint xadjust;
423	gint yadjust;
424	gint i;
425
426	g_return_if_fail(style != NULL);
427	g_return_if_fail(window != NULL);
428	g_return_if_fail(points != NULL);
429
430	switch (shadow_type)
431	{
432	case GTK_SHADOW_IN:
433	gc1 = style->light_gc[state_type];
434	gc2 = style->dark_gc[state_type];
435	gc3 = style->light_gc[state_type];
436	gc4 = style->dark_gc[state_type];
437	break;
438	case GTK_SHADOW_ETCHED_IN:
439	gc1 = style->light_gc[state_type];
440	gc2 = style->dark_gc[state_type];
441	gc3 = style->dark_gc[state_type];
442	gc4 = style->light_gc[state_type];
443	break;
444	case GTK_SHADOW_OUT:
445	gc1 = style->dark_gc[state_type];
446	gc2 = style->light_gc[state_type];
447	gc3 = style->dark_gc[state_type];
448	gc4 = style->light_gc[state_type];
449	break;
450	case GTK_SHADOW_ETCHED_OUT:
451	gc1 = style->dark_gc[state_type];
452	gc2 = style->light_gc[state_type];
453	gc3 = style->light_gc[state_type];
454	gc4 = style->dark_gc[state_type];
455	break;
456	default:
457	return;
458	}
459
460	if (area)
461	{
462	gdk_gc_set_clip_rectangle(gc1, area);
463	gdk_gc_set_clip_rectangle(gc2, area);
464	gdk_gc_set_clip_rectangle(gc3, area);
465	gdk_gc_set_clip_rectangle(gc4, area);
466	}
467
468	if (fill)
469	gdk_draw_polygon(window, style->bg_gc[state_type], TRUE, points, npoints);
470
471	npoints--;
472
473	for (i = 0; i < npoints; i++)
474	{
475	if ((points[i].x == points[i + 1].x) &&
476	(points[i].y == points[i + 1].y))
477	{
478	angle = 0;
479	}
480	else
481	{
482	angle = atan2(points[i + 1].y - points[i].y,
483	points[i + 1].x - points[i].x);
484	}
485
486	if ((angle > -pi_3_over_4) && (angle < pi_over_4))
487	{
488	if (angle > -pi_over_4)
489	{
490	xadjust = 0;
491	yadjust = 1;
492	}
493	else
494	{
495	xadjust = 1;
496	yadjust = 0;
497	}
498
499	gdk_draw_line(window, gc1,
500	points[i].x - xadjust, points[i].y - yadjust,
501	points[i + 1].x - xadjust, points[i + 1].y - yadjust);
502	gdk_draw_line(window, gc3,
503	points[i].x, points[i].y,
504	points[i + 1].x, points[i + 1].y);
505	}
506	else
507	{
508	if ((angle < -pi_3_over_4) \|\| (angle > pi_3_over_4))
509	{
510	xadjust = 0;
511	yadjust = 1;
512	}
513	else
514	{
515	xadjust = 1;
516	yadjust = 0;
517	}
518
519	gdk_draw_line(window, gc4,
520	points[i].x + xadjust, points[i].y + yadjust,
521	points[i + 1].x + xadjust, points[i + 1].y + yadjust);
522	gdk_draw_line(window, gc2,
523	points[i].x, points[i].y,
524	points[i + 1].x, points[i + 1].y);
525	}
526	}
527	if (area)
528	{
529	gdk_gc_set_clip_rectangle(gc1, NULL);
530	gdk_gc_set_clip_rectangle(gc2, NULL);
531	gdk_gc_set_clip_rectangle(gc3, NULL);
532	gdk_gc_set_clip_rectangle(gc4, NULL);
533	}
534	}
535
536	#if 0
537	void
538	draw_shadearrow(GtkStyle * style,
539	GdkWindow * window,
540	GtkStateType state_type,
541	GtkShadowType shadow_type,
542	GdkRectangle * area,
543	GtkWidget * widget,
544	const gchar *detail,
545	GtkArrowType arrow_type,
546	gint fill,
547	gint x, gint y,
548	gint width, gint height)
549	{
550	int awidth, aheight;
551	GdkGC gc1, gc2, gc3, gc4;
552
553	aheight = height + height % 2 - 1;
554	awidth = width + width % 2 - 1;
555
556
557	gc1 = style->dark_gc[state_type];
558	gc2 = style->light_gc[state_type];
559	if (arrow_type == GTK_ARROW_UP \|\| arrow_type == GTK_ARROW_DOWN)
560	{
561	if (state_type == GTK_STATE_INSENSITIVE \|\|
562	shadow_type == GTK_SHADOW_ETCHED_IN \|\|
563	shadow_type == GTK_SHADOW_ETCHED_OUT)
564	{
565	gc1 = style->bg_gc[GTK_STATE_ACTIVE];
566	}
567	else
568	{
569	draw_varrow (window, gc2, shadow_type, area, arrow_type,
570	x+1, y, awidth, aheight);
571	draw_varrow (window, gc2, shadow_type, area, arrow_type,
572	x, y+1, awidth, aheight);
573	}
574	draw_varrow (window, gc1, shadow_type, area, arrow_type,
575	x, y, awidth, aheight);
576	}
577	else
578	{
579
580	if (state_type == GTK_STATE_INSENSITIVE \|\|
581	shadow_type == GTK_SHADOW_ETCHED_IN \|\|
582	shadow_type == GTK_SHADOW_ETCHED_OUT)
583	{
584	gc1 = style->bg_gc[GTK_STATE_ACTIVE];
585	}
586	else
587	{
588	draw_harrow (window, gc2, shadow_type, area, arrow_type,
589	x+1, y, awidth, aheight);
590	draw_harrow (window, gc2, shadow_type, area, arrow_type,
591	x, y+1, awidth, aheight);
592	}
593	draw_harrow (window, gc1, shadow_type, area, arrow_type,
594	x, y, awidth, aheight);
595	}
596
597	}
598	#endif
599
600	static void
601	draw_black_arrow (GdkWindow *window,
602	GdkGC *gc,
603	GdkRectangle *area,
604	GtkArrowType arrow_type,
605	gint x,
606	gint y,
607	gint width,
608	gint height)
609	{
610	gint i, j;
611
612	if (area)
613	gdk_gc_set_clip_rectangle (gc, area);
614
615	if (arrow_type == GTK_ARROW_DOWN)
616	{
617	for (i = 0, j = 0; i < height; i++, j++)
618	gdk_draw_line (window, gc, x + j, y + i, x + width - j - 1, y + i);
619	}
620	else if (arrow_type == GTK_ARROW_UP)
621	{
622	for (i = height - 1, j = 0; i >= 0; i--, j++)
623	gdk_draw_line (window, gc, x + j, y + i, x + width - j - 1, y + i);
624	}
625	else if (arrow_type == GTK_ARROW_LEFT)
626	{
627	for (i = width - 1, j = 0; i >= 0; i--, j++)
628	gdk_draw_line (window, gc, x + i, y + j, x + i, y + height - j - 1);
629	}
630	else if (arrow_type == GTK_ARROW_RIGHT)
631	{
632	for (i = 0, j = 0; i < width; i++, j++)
633	gdk_draw_line (window, gc, x + i, y + j, x + i, y + height - j - 1);
634	}
635
636	if (area)
637	gdk_gc_set_clip_rectangle (gc, NULL);
638	}
639
640	#if 0
641	static void
642	draw_arrow(GtkStyle * style,
643	GdkWindow * window,
644	GtkStateType state,
645	GtkShadowType shadow,
646	GdkRectangle * area,
647	GtkWidget * widget,
648	const gchar *detail,
649	GtkArrowType arrow_type,
650	gint fill, gint x, gint y, gint width, gint height)
651	{
652	gint original_width, original_x;
653
654	sanitize_size (window, &width, &height);
655
656	original_width = width;
657	original_x = x;
658
659	calculate_arrow_geometry (arrow_type, &x, &y, &width, &height);
660
661	if (detail && strcmp (detail, "menuitem") == 0)
662	x = original_x + original_width - width;
663
664	if (state == GTK_STATE_INSENSITIVE)
665	draw_black_arrow (window, style->white_gc, area, arrow_type,
666	x + 1, y + 1, width, height);
667	draw_black_arrow (window, style->fg_gc[state], area, arrow_type,
668	x, y, width, height);
669	}
670	#endif
671	static void
672	draw_arrow(GtkStyle * style,
673	GdkWindow * window,
674	GtkStateType state_type,
675	GtkShadowType shadow_type,
676	GdkRectangle * area,
677	GtkWidget * widget,
678	const gchar *detail,
679	GtkArrowType arrow_type,
680	gint fill, gint x, gint y, gint width, gint height)
681	{
682	GdkGC *gc1;
683	GdkGC *gc2;
684	GdkGC *gc3;
685	GdkGC *gc4;
686	gint half_width;
687	gint half_height;
688	gint ax, ay, aw, ah;
689
690	g_return_if_fail(style != NULL);
691	g_return_if_fail(window != NULL);
692
693	#ifdef DEBUG
694	printf("arrow! state_type=%d shadow_type=%d, fill=%d, x,y=%d,%d width,height=%d,%d\n",
695	state_type, shadow_type, fill, x, y, width, height);
696	printf("\\-- detail=%s, arrow_type=%d\n", detail?detail:"<null>", arrow_type);
697	#endif
698	/*
699	detail=scrollbar,
700	arrow_type=0 -> ^
701	arrow_type=1 -> V
702	arrow_type=2 -> <
703	arrow_type=3 -> >
704	*/
705
706
707	switch (shadow_type)
708	{
709	case GTK_SHADOW_IN:
710	gc1 = style->bg_gc[state_type];
711	gc2 = style->dark_gc[state_type];
712	gc3 = style->light_gc[state_type];
713	gc4 = style->black_gc;
714	break;
715	case GTK_SHADOW_OUT:
716	gc1 = style->dark_gc[state_type];
717	gc2 = style->light_gc[state_type];
718	gc3 = style->black_gc;
719	gc4 = style->bg_gc[state_type];
720	break;
721	case GTK_SHADOW_ETCHED_IN:
722	gc2 = style->light_gc[state_type];
723	gc1 = style->dark_gc[state_type];
724	gc3 = NULL;
725	gc4 = NULL;
726	break;
727	case GTK_SHADOW_ETCHED_OUT:
728	gc1 = style->dark_gc[state_type];
729	gc2 = style->light_gc[state_type];
730	gc3 = NULL;
731	gc4 = NULL;
732	break;
733	default:
734	return;
735	}
736
737	sanitize_size(window, &width, &height);
738	ax = x;
739	ay = y;
740	aw = width;
741	ah = height;
742	calculate_arrow_geometry (arrow_type, &ax, &ay, &aw, &ah);
743
744	half_width = width / 2;
745	half_height = height / 2;
746
747	if (area)
748	{
749	gdk_gc_set_clip_rectangle(gc1, area);
750	gdk_gc_set_clip_rectangle(gc2, area);
751	if ((gc3) && (gc4))
752	{
753	gdk_gc_set_clip_rectangle(gc3, area);
754	gdk_gc_set_clip_rectangle(gc4, area);
755	}
756	}
757
758	if (DETAIL("vscrollbar") \|\| DETAIL("hscrollbar"))
759	{
760	#ifdef DEBUG
761	printf("Scrollbar of type (%s)!\n", detail);
762	#endif
763	#ifdef DEBUG
764	printf("type = %p\n", thinice_type_rc_style);
765	printf("style->rc_style = %p\n", style->rc_style);
766	printf("theme_data = %p\n", THINICE_RC_STYLE (style->rc_style));
767
768	printf("mojj1=%d\n", THINICE_RC_STYLE (style->rc_style)->scrollbar_type);
769	printf("mojj2=%d\n", THINICE_RC_STYLE (style->rc_style)->scrollbar_marks);
770	printf("mojj3=%d\n", THINICE_RC_STYLE (style->rc_style)->scroll_button_marks);
771	printf("mojj4=%d\n", THINICE_RC_STYLE (style->rc_style)->handlebox_marks);
772
773	printf("mojj5=%d\n", THINICE_RC_STYLE (style->rc_style)->mark_type1);
774	printf("mojj6=%d\n", THINICE_RC_STYLE (style->rc_style)->mark_type2);
775	printf("rcstyle=%d\n", THINICE_RC_STYLE (style->rc_style)->mark_type2);
776	printf("rcstyle2=%d\n", ((struct _ThiniceRcStyle*)(style->rc_style))->mark_type2);
777	#endif
778	switch (THINICE_RC_STYLE (style->rc_style)->mark_type2)
779	{
780	case MARKS_NOTHING:
781	break;
782	case MARKS_INVSLASH:
783	thinice_slash_one(window, gc2, gc1, x, y, width, height);
784	break;
785	case MARKS_DOT:
786	thinice_dot(window, gc2, gc1, x + half_width, y + half_height);
787	break;
788	case MARKS_INVDOT:
789	thinice_dot(window, gc1, gc2, x + half_width, y + half_height);
790	break;
791	case MARKS_ARROW:
792	if (state_type == GTK_STATE_INSENSITIVE)
793	draw_black_arrow (window, style->white_gc, area, arrow_type,
794	ax + 1, ay + 1, aw, ah);
795	draw_black_arrow (window, style->fg_gc[state_type], area, arrow_type,
796	ax, ay, aw, ah);
797	break;
798	case MARKS_SLASH:
799	default:
800	thinice_slash_one(window, gc1, gc2, x, y, width - 1, height - 1);
801	break;
802	}
803	}
804	else if DETAIL("spinbutton")
805	{
806	if (state_type == GTK_STATE_INSENSITIVE)
807	draw_black_arrow (window, style->white_gc, area, arrow_type,
808	ax + 1, ay + 1, aw, ah);
809	draw_black_arrow (window, style->fg_gc[state_type], area, arrow_type,
810	ax, ay, aw, ah);
811	}
812	else if (DETAIL("menuitem"))
813	{
814	ax = x + width - aw;
815
816	if (state_type == GTK_STATE_INSENSITIVE)
817	draw_black_arrow (window, style->white_gc, area, arrow_type,
818	ax + 1, ay + 1, aw, ah);
819	draw_black_arrow (window, style->fg_gc[state_type], area, arrow_type,
820	ax, ay, aw, ah);
821	}
822	else
823	{
824	if (state_type == GTK_STATE_INSENSITIVE)
825	draw_black_arrow (window, style->white_gc, area, arrow_type,
826	ax + 1, ay + 1, aw, ah);
827	draw_black_arrow (window, style->fg_gc[state_type], area, arrow_type,
828	ax, ay, aw, ah);
829	}
830
831	if (area)
832	{
833	gdk_gc_set_clip_rectangle(gc1, NULL);
834	gdk_gc_set_clip_rectangle(gc2, NULL);
835	if (gc3)
836	{
837	gdk_gc_set_clip_rectangle(gc3, NULL);
838	gdk_gc_set_clip_rectangle(gc4, NULL);
839	}
840	}
841	}
842
843
844	#if 0
845	static void
846	draw_harrow (GdkWindow *window,
847	GdkGC *gc,
848	GtkShadowType shadow_type,
849	GdkRectangle *area,
850	GtkArrowType arrow_type,
851	gint x,
852	gint y,
853	gint width,
854	gint height)
855	{
856	gint steps, extra;
857	gint x_start, x_increment;
858	gint i;
859
860	if (area)
861	gdk_gc_set_clip_rectangle (gc, area);
862
863	height = height + height % 2 - 1; /* Force odd */
864
865	steps = 1 + height / 2;
866
867	extra = width - steps;
868
869	if (arrow_type == GTK_ARROW_RIGHT)
870	{
871	x_start = x;
872	x_increment = 1;
873	}
874	else
875	{
876	x_start = x + width - 1;
877	x_increment = -1;
878	}
879
880	for (i = 0; i < extra; i++)
881	{
882	gdk_draw_line (window, gc,
883	x_start + i * x_increment, y,
884	x_start + i * x_increment, y + height - 1);
885	}
886	for (; i < width; i++)
887	{
888	gdk_draw_line (window, gc,
889	x_start + i * x_increment, y + (i - extra),
890	x_start + i * x_increment, y + height - (i - extra) - 1);
891	}
892
893
894	if (area)
895	gdk_gc_set_clip_rectangle (gc, NULL);
896	}
897
898
899	static void
900	draw_varrow (GdkWindow *window,
901	GdkGC *gc,
902	GtkShadowType shadow_type,
903	GdkRectangle *area,
904	GtkArrowType arrow_type,
905	gint x,
906	gint y,
907	gint width,
908	gint height)
909	{
910	gint steps, extra;
911	gint y_start, y_increment;
912	gint i;
913
914	if (area)
915	gdk_gc_set_clip_rectangle (gc, area);
916
917	width = width + width % 2 - 1; /* Force odd */
918
919	steps = 1 + width / 2;
920
921	extra = height - steps;
922
923	if (arrow_type == GTK_ARROW_DOWN)
924	{
925	y_start = y;
926	y_increment = 1;
927	}
928	else
929	{
930	y_start = y + height - 1;
931	y_increment = -1;
932	}
933
934	for (i = 0; i < extra; i++)
935	{
936	gdk_draw_line (window, gc,
937	x, y_start + i * y_increment,
938	x + width - 1, y_start + i * y_increment);
939	}
940	for (; i < height; i++)
941	{
942	gdk_draw_line (window, gc,
943	x + (i - extra), y_start + i * y_increment,
944	x + width - (i - extra) - 1, y_start + i * y_increment);
945	}
946
947
948	if (area)
949	gdk_gc_set_clip_rectangle (gc, NULL);
950	}
951	#endif
952
953	static void
954	draw_diamond(GtkStyle * style,
955	GdkWindow * window,
956	GtkStateType state_type,
957	GtkShadowType shadow_type,
958	GdkRectangle * area,
959	GtkWidget * widget,
960	const gchar *detail,
961	gint x,
962	gint y,
963	gint width,
964	gint height)
965	{
966	gint half_width;
967	gint half_height;
968
969	g_return_if_fail(style != NULL);
970	g_return_if_fail(window != NULL);
971
972	sanitize_size(window, &width, &height);
973
974	half_width = width / 2;
975	half_height = height / 2;
976
977	if (area)
978	{
979	gdk_gc_set_clip_rectangle(style->light_gc[state_type], area);
980	gdk_gc_set_clip_rectangle(style->bg_gc[state_type], area);
981	gdk_gc_set_clip_rectangle(style->dark_gc[state_type], area);
982	gdk_gc_set_clip_rectangle(style->black_gc, area);
983	}
984	switch (shadow_type)
985	{
986	case GTK_SHADOW_IN:
987	gdk_draw_line(window, style->light_gc[state_type],
988	x + 2, y + half_height,
989	x + half_width, y + height - 2);
990	gdk_draw_line(window, style->light_gc[state_type],
991	x + half_width, y + height - 2,
992	x + width - 2, y + half_height);
993	gdk_draw_line(window, style->light_gc[state_type],
994	x + 1, y + half_height,
995	x + half_width, y + height - 1);
996	gdk_draw_line(window, style->light_gc[state_type],
997	x + half_width, y + height - 1,
998	x + width - 1, y + half_height);
999	gdk_draw_line(window, style->light_gc[state_type],
1000	x, y + half_height,
1001	x + half_width, y + height);
1002	gdk_draw_line(window, style->light_gc[state_type],
1003	x + half_width, y + height,
1004	x + width, y + half_height);
1005
1006	gdk_draw_line(window, style->dark_gc[state_type],
1007	x + 2, y + half_height,
1008	x + half_width, y + 2);
1009	gdk_draw_line(window, style->dark_gc[state_type],
1010	x + half_width, y + 2,
1011	x + width - 2, y + half_height);
1012	gdk_draw_line(window, style->dark_gc[state_type],
1013	x + 1, y + half_height,
1014	x + half_width, y + 1);
1015	gdk_draw_line(window, style->dark_gc[state_type],
1016	x + half_width, y + 1,
1017	x + width - 1, y + half_height);
1018	gdk_draw_line(window, style->dark_gc[state_type],
1019	x, y + half_height,
1020	x + half_width, y);
1021	gdk_draw_line(window, style->dark_gc[state_type],
1022	x + half_width, y,
1023	x + width, y + half_height);
1024	break;
1025	case GTK_SHADOW_OUT:
1026	gdk_draw_line(window, style->dark_gc[state_type],
1027	x + 2, y + half_height,
1028	x + half_width, y + height - 2);
1029	gdk_draw_line(window, style->dark_gc[state_type],
1030	x + half_width, y + height - 2,
1031	x + width - 2, y + half_height);
1032	gdk_draw_line(window, style->dark_gc[state_type],
1033	x + 1, y + half_height,
1034	x + half_width, y + height - 1);
1035	gdk_draw_line(window, style->dark_gc[state_type],
1036	x + half_width, y + height - 1,
1037	x + width - 1, y + half_height);
1038	gdk_draw_line(window, style->dark_gc[state_type],
1039	x, y + half_height,
1040	x + half_width, y + height);
1041	gdk_draw_line(window, style->dark_gc[state_type],
1042	x + half_width, y + height,
1043	x + width, y + half_height);
1044
1045	gdk_draw_line(window, style->light_gc[state_type],
1046	x + 2, y + half_height,
1047	x + half_width, y + 2);
1048	gdk_draw_line(window, style->light_gc[state_type],
1049	x + half_width, y + 2,
1050	x + width - 2, y + half_height);
1051	gdk_draw_line(window, style->light_gc[state_type],
1052	x + 1, y + half_height,
1053	x + half_width, y + 1);
1054	gdk_draw_line(window, style->light_gc[state_type],
1055	x + half_width, y + 1,
1056	x + width - 1, y + half_height);
1057	gdk_draw_line(window, style->light_gc[state_type],
1058	x, y + half_height,
1059	x + half_width, y);
1060	gdk_draw_line(window, style->light_gc[state_type],
1061	x + half_width, y,
1062	x + width, y + half_height);
1063	break;
1064	default:
1065	break;
1066	}
1067	if (area)
1068	{
1069	gdk_gc_set_clip_rectangle(style->light_gc[state_type], NULL);
1070	gdk_gc_set_clip_rectangle(style->bg_gc[state_type], NULL);
1071	gdk_gc_set_clip_rectangle(style->dark_gc[state_type], NULL);
1072	gdk_gc_set_clip_rectangle(style->black_gc, NULL);
1073	}
1074	}
1075
1076	#if 0
1077	static void
1078	draw_string(GtkStyle * style,
1079	GdkWindow * window,
1080	GtkStateType state_type,
1081	GdkRectangle * area,
1082	GtkWidget * widget,
1083	const gchar *detail,
1084	gint x,
1085	gint y,
1086	const gchar * string)
1087	{
1088	g_return_if_fail(style != NULL);
1089	g_return_if_fail(window != NULL);
1090
1091	if (area)
1092	{
1093	if (state_type == GTK_STATE_INSENSITIVE)
1094	{
1095	gdk_gc_set_clip_rectangle(style->base_gc[state_type], area);
1096	}
1097	gdk_gc_set_clip_rectangle(style->fg_gc[state_type], area);
1098	}
1099	if (state_type == GTK_STATE_INSENSITIVE)
1100	{
1101	gdk_draw_string(window, gtk_style_get_font(style), style->base_gc[state_type], x + 1, y + 1, string);
1102	}
1103	gdk_draw_string(window, gtk_style_get_font(style), style->fg_gc[state_type], x, y, string);
1104	if (area)
1105	{
1106	if (state_type == GTK_STATE_INSENSITIVE)
1107	{
1108	gdk_gc_set_clip_rectangle(style->base_gc[state_type], NULL);
1109	}
1110	gdk_gc_set_clip_rectangle(style->fg_gc[state_type], NULL);
1111	}
1112	}
1113	#endif
1114
1115	static void
1116	draw_box(GtkStyle * style,
1117	GdkWindow * window,
1118	GtkStateType state_type,
1119	GtkShadowType shadow_type,
1120	GdkRectangle * area,
1121	GtkWidget * widget,
1122	const gchar *detail,
1123	gint x,
1124	gint y,
1125	gint width,
1126	gint height)
1127	{
1128	GdkGC light_gc, dark_gc;
1129	GtkOrientation orientation;
1130
1131	g_return_if_fail(style != NULL);
1132	g_return_if_fail(window != NULL);
1133
1134	sanitize_size(window, &width, &height);
1135
1136	light_gc = style->light_gc[state_type];
1137	dark_gc = style->dark_gc[state_type];
1138
1139	orientation = GTK_ORIENTATION_HORIZONTAL;
1140	if (height > width)
1141	orientation = GTK_ORIENTATION_VERTICAL;
1142
1143	#ifdef DEBUG
1144	printf("%p %s %i %i state_type = %d (%d)\n", detail, detail, width, height, state_type, orientation);
1145	#endif
1146
1147	if (DETAIL("optionmenutab"))
1148	{
1149	#ifdef DEBUG
1150	printf("%p %s %ix%i @ +%i+%i state_type = %d (%d)\n", detail, detail, width, height, x, y, state_type, orientation);
1151	#endif
1152	if (area)
1153	{
1154	GdkPoint points[4];
1155	guint size, ydiff, xdiff;
1156
1157	size = min(width, height);
1158	gdk_gc_set_clip_rectangle(light_gc, area);
1159	gdk_gc_set_clip_rectangle(dark_gc, area);
1160
1161	#if 0
1162	/* DEBUG */
1163	points[0].x = x ;
1164	points[0].y = y ;
1165	points[1].x = x + width;
1166	points[1].y = y ;
1167	points[2].x = x + width;
1168	points[2].y = y + height;
1169	points[3].x = x ;
1170	points[3].y = y + height;
1171
1172	gdk_draw_polygon(window, light_gc, FALSE, points, 4);
1173	/* DEBUG */
1174	#endif
1175
1176	if (size % 2)
1177	size++;
1178
1179	ydiff = max(0, (height - size) / 2);
1180	xdiff = max(0, (width - size) / 2);
1181	points[0].x = x + size + xdiff;
1182	points[0].y = y + ydiff;
1183	points[1].x = x + xdiff;
1184	points[1].y = y + ydiff;
1185	points[2].x = x + size / 2 + xdiff;
1186	points[2].y = y + size + ydiff;
1187	gdk_draw_polygon(window, light_gc, FALSE, points, 3);
1188	points[0].x--;
1189	points[1].x--;
1190	points[2].x--;
1191	gdk_draw_polygon(window, dark_gc, FALSE, points, 3);
1192
1193	gdk_gc_set_clip_rectangle(light_gc, NULL);
1194	gdk_gc_set_clip_rectangle(dark_gc, NULL);
1195	}
1196	}
1197	else if (DETAIL("trough"))
1198	{
1199	if (area)
1200	{
1201	gdk_gc_set_clip_rectangle(style->bg_gc[state_type], area);
1202	}
1203	#ifdef DEBUG
1204	printf("trough\n");
1205	#endif
1206	gdk_draw_rectangle(window, style->bg_gc[state_type], TRUE,
1207	x, y, width, height);
1208	if (area)
1209	{
1210	gdk_gc_set_clip_rectangle(style->bg_gc[state_type], NULL);
1211	}
1212	gtk_paint_shadow(style, window, state_type, shadow_type, area, widget,
1213	detail, x, y, width, height);
1214	}
1215	else if (DETAIL("slider"))
1216	{
1217	}
1218	else if (DETAIL("buttondefault"))
1219	{
1220	/* I don't want no background on default buttons..
1221	Let's add that cute triangle (see below) instead... */
1222	}
1223	else if (DETAIL("button"))
1224	{
1225	GdkPoint points1[3]; /* dark */
1226	GdkPoint points2[3]; /* light */
1227	points1[0].x = x+2; points1[0].y = y+2;
1228	points1[1].x = x+10; points1[1].y = y+2;
1229	points1[2].x = x+2; points1[2].y = y+10;
1230	points2[0].x = x+3; points2[0].y = y+3;
1231	points2[1].x = x+10; points2[1].y = y+3;
1232	points2[2].x = x+3; points2[2].y = y+10;
1233
1234	if (area)
1235	{
1236	gdk_gc_set_clip_rectangle(style->bg_gc[state_type], area);
1237	}
1238	if ((!style->bg_pixmap[state_type]) \|\| GDK_IS_PIXMAP (window))
1239	{
1240	gdk_draw_rectangle(window, style->bg_gc[state_type],
1241	TRUE, x + 1, y + 1, width - 2, height - 2);
1242	}
1243	else
1244	{
1245	gtk_style_apply_default_background(style, window,
1246	widget && !GTK_WIDGET_NO_WINDOW(widget),
1247	state_type, area,
1248	x, y, width, height);
1249	}
1250	/* Paint a triangle here instead of in "buttondefault"
1251	which is drawn _behind_ the current button */
1252	if (GTK_WIDGET_HAS_DEFAULT (widget))
1253	{
1254	gdk_draw_polygon(window, dark_gc,
1255	FALSE, points1, 3);
1256	gdk_draw_polygon(window, light_gc,
1257	FALSE, points2, 3);
1258	gdk_draw_polygon(window, style->bg_gc[GTK_STATE_SELECTED],
1259	TRUE, points2, 3);
1260	}
1261	if (area)
1262	{
1263	gdk_gc_set_clip_rectangle(style->bg_gc[state_type], NULL);
1264	}
1265	gtk_paint_shadow(style, window, state_type, shadow_type, area, widget,
1266	detail, x, y, width, height);
1267	}
1268	else if (DETAIL("bar"))
1269	{
1270	if ((height > 1) && (width > 1))
1271	{
1272	if (area)
1273	{
1274	gdk_gc_set_clip_rectangle(style->bg_gc[GTK_STATE_SELECTED], area);
1275	}
1276	gdk_draw_rectangle(window, style->bg_gc[GTK_STATE_SELECTED],
1277	TRUE, x + 1, y + 1, width - 2, height - 2);
1278	if (area)
1279	{
1280	gdk_gc_set_clip_rectangle(style->bg_gc[GTK_STATE_SELECTED], NULL);
1281	}
1282	}
1283	}
1284	else if (DETAIL("handlebox_bin"))
1285	{
1286	if ((!style->bg_pixmap[state_type]) \|\| GDK_IS_PIXMAP(window))
1287	{
1288	if (area)
1289	{
1290	gdk_gc_set_clip_rectangle(style->bg_gc[state_type], area);
1291	}
1292	gdk_draw_rectangle(window, style->bg_gc[state_type], TRUE,
1293	x, y, width, height);
1294	if (area)
1295	{
1296	gdk_gc_set_clip_rectangle(style->bg_gc[state_type], NULL);
1297	}
1298	}
1299	else
1300	{
1301	gtk_style_apply_default_background(style, window,
1302	widget && !GTK_WIDGET_NO_WINDOW(widget),
1303	state_type, area,
1304	x, y, width, height);
1305	}
1306	/*
1307	gtk_paint_shadow(style, window, state_type, shadow_type, area, widget,
1308	detail, x, y, width, height);
1309	*/
1310	}
1311	else if (DETAIL("menubar"))
1312	{
1313	if ((!style->bg_pixmap[state_type]) \|\| GDK_IS_PIXMAP(window))
1314	{
1315	if (area)
1316	{
1317	gdk_gc_set_clip_rectangle(style->bg_gc[state_type], area);
1318	}
1319	gdk_draw_rectangle(window, style->bg_gc[state_type], TRUE,
1320	x, y, width, height);
1321	if (area)
1322	{
1323	gdk_gc_set_clip_rectangle(style->bg_gc[state_type], NULL);
1324	}
1325	}
1326	else
1327	{
1328	gtk_style_apply_default_background(style, window,
1329	widget && !GTK_WIDGET_NO_WINDOW(widget),
1330	state_type, area,
1331	x, y, width, height);
1332	}
1333	gtk_paint_shadow(style, window, state_type, shadow_type, area, widget,
1334	detail, x, y, width, height);
1335	/*
1336	}
1337	else if (DETAIL("notebook"))
1338	{
1339	thinice_notebook(style, window, state_type, shadow_type, area, widget,
1340	detail, x, y, width, height);
1341	*/
1342	}
1343	else if (DETAIL("tab"))
1344	{
1345	thinice_tab(style, window, state_type, shadow_type, area, widget,
1346	detail, x, y, width, height);
1347	}
1348	else
1349	{
1350	#ifdef DEBUG
1351	printf("Unknown: [%d,%d] @ [%d,%d] - detail=(%s) shadow_type=%d state_type=%d\n",
1352	height,width, x, y, detail, shadow_type, state_type);
1353	#endif
1354	if ((!style->bg_pixmap[state_type]) \|\| GDK_IS_PIXMAP(window))
1355	{
1356	if (area)
1357	{
1358	gdk_gc_set_clip_rectangle(style->bg_gc[state_type], area);
1359	}
1360	gdk_draw_rectangle(window, style->bg_gc[state_type], TRUE,
1361	x, y, width, height);
1362	if (area)
1363	{
1364	gdk_gc_set_clip_rectangle(style->bg_gc[state_type], NULL);
1365	}
1366	}
1367	else
1368	{
1369	gtk_style_apply_default_background(style, window,
1370	widget && !GTK_WIDGET_NO_WINDOW(widget),
1371	state_type, area,
1372	x, y, width, height);
1373	}
1374	gtk_paint_shadow(style, window, state_type, shadow_type, area, widget,
1375	detail, x, y, width, height);
1376	}
1377	}
1378
1379
1380
1381	#if 0
1382	static void
1383	draw_flat_box(GtkStyle * style,
1384	GdkWindow * window,
1385	GtkStateType state_type,
1386	GtkShadowType shadow_type,
1387	GdkRectangle * area,
1388	GtkWidget * widget,
1389	const gchar *detail,
1390	gint x,
1391	gint y,
1392	gint width,
1393	gint height)
1394	{
1395	GdkGC *gc1;
1396
1397	g_return_if_fail(style != NULL);
1398	g_return_if_fail(window != NULL);
1399
1400	sanitize_size(window, &width, &height);
1401
1402	gc1 = style->bg_gc[state_type];
1403
1404	if (DETAIL("text") && (state_type == GTK_STATE_SELECTED))
1405	gc1 = style->bg_gc[state_type];
1406	else if (DETAIL("viewportbin"))
1407	gc1 = style->bg_gc[state_type];
1408	else if (DETAIL("entry_bg"))
1409	gc1 = style->base_gc[state_type];
1410
1411	if ((!style->bg_pixmap[state_type]) \|\| (gc1 != style->bg_gc[state_type]) \|\|
1412	GDK_IS_PIXMAP(window))
1413	{
1414	if (area)
1415	gdk_gc_set_clip_rectangle(gc1, area);
1416
1417	gdk_draw_rectangle(window, gc1, TRUE,
1418	x, y, width, height);
1419	if (DETAIL("tooltip"))
1420	gdk_draw_rectangle(window, style->black_gc, FALSE,
1421	x, y, width - 1, height - 1);
1422	if (area)
1423	gdk_gc_set_clip_rectangle(gc1, NULL);
1424	}
1425	else
1426	gtk_style_apply_default_background(style, window,
1427	widget && !GTK_WIDGET_NO_WINDOW(widget),
1428	state_type, area, x, y, width, height);
1429	}
1430	#endif /* 0 */
1431
1432	static void
1433	draw_check(GtkStyle * style,
1434	GdkWindow * window,
1435	GtkStateType state_type,
1436	GtkShadowType shadow_type,
1437	GdkRectangle * area,
1438	GtkWidget * widget,
1439	const gchar *detail,
1440	gint x,
1441	gint y,
1442	gint width,
1443	gint height)
1444	{
1445
1446	GdkGC *gc1 = NULL;
1447
1448	if (shadow_type == GTK_SHADOW_IN)
1449	{
1450	gc1 = style->bg_gc[GTK_STATE_ACTIVE];
1451	}
1452
1453	if (area && gc1)
1454	{
1455	gdk_gc_set_clip_rectangle(gc1, area);
1456	}
1457
1458	if (state_type == GTK_STATE_INSENSITIVE)
1459	{
1460	gdk_draw_rectangle(window, style->dark_gc[state_type], FALSE,
1461	x, y, width, height);
1462	}
1463	else
1464	{
1465	gtk_paint_box(style, window, state_type, shadow_type, area, widget,
1466	detail, x, y, width, height);
1467	if (gc1)
1468	{
1469	gdk_draw_rectangle(window, gc1, TRUE, x+1, y+1, width-2, height-2);
1470	}
1471	}
1472
1473	if (area && gc1)
1474	{
1475	gdk_gc_set_clip_rectangle(gc1, NULL);
1476	}
1477	}
1478
1479
1480	/* Thanks to Evan Lawrence */
1481	static void
1482	draw_option(GtkStyle * style,
1483	GdkWindow * window,
1484	GtkStateType state_type,
1485	GtkShadowType shadow_type,
1486	GdkRectangle * area,
1487	GtkWidget * widget,
1488	const gchar *detail,
1489	gint x,
1490	gint y,
1491	gint width,
1492	gint height)
1493	{
1494	GdkGC *gc1;
1495	GdkGC *gc2;
1496	GdkGC *gc3;
1497
1498	if (shadow_type == GTK_SHADOW_IN \|\|
1499	shadow_type == GTK_SHADOW_ETCHED_IN)
1500	{
1501	gc1 = style->dark_gc[state_type];
1502	gc2 = style->light_gc[state_type];
1503	gc3 = style->bg_gc[GTK_STATE_ACTIVE];
1504	}
1505	else
1506	{
1507	gc1 = style->light_gc[state_type];
1508	gc2 = style->dark_gc[state_type];
1509	gc3 = style->bg_gc[state_type];
1510	}
1511
1512	if (area)
1513	{
1514	gdk_gc_set_clip_rectangle(gc1, area);
1515	gdk_gc_set_clip_rectangle(gc2, area);
1516	gdk_gc_set_clip_rectangle(gc3, area);
1517	}
1518
1519	switch (shadow_type)
1520	{
1521	case GTK_SHADOW_ETCHED_IN:
1522	gdk_draw_arc(window, gc2, FALSE, x+1, y+1, width, height, 0, 360 * 64);
1523	gdk_draw_arc(window, gc1, FALSE, x, y, width, height, 0, 360 * 64);
1524	break;
1525	case GTK_SHADOW_ETCHED_OUT:
1526	gdk_draw_arc(window, gc1, FALSE, x-1, y-1, width, height, 0, 360 * 64);
1527	gdk_draw_arc(window, gc2, FALSE, x, y, width, height, 0, 360 * 64);
1528	break;
1529	default:
1530	gdk_draw_arc(window, gc3, TRUE, x, y, width, height, 0, 360 * 64);
1531	gdk_draw_arc(window, gc1, FALSE, x, y, width, height, 45 * 64, 225 * 64);
1532	gdk_draw_arc(window, gc2, FALSE, x, y, width, height, 225 * 64, 180 * 64);
1533	break;
1534	}
1535
1536	if (area)
1537	{
1538	gdk_gc_set_clip_rectangle(gc1, NULL);
1539	gdk_gc_set_clip_rectangle(gc2, NULL);
1540	gdk_gc_set_clip_rectangle(gc3, NULL);
1541	}
1542	}
1543
1544
1545	static void
1546	draw_tab(GtkStyle * style,
1547	GdkWindow * window,
1548	GtkStateType state_type,
1549	GtkShadowType shadow_type,
1550	GdkRectangle * area,
1551	GtkWidget * widget,
1552	const gchar *detail,
1553	gint x,
1554	gint y,
1555	gint width,
1556	gint height)
1557	{
1558	g_return_if_fail(style != NULL);
1559	g_return_if_fail(window != NULL);
1560
1561	#ifdef DEBUG
1562	printf("draw_tab(%d,%d,%d,%d) (detail = '%s')\n", x, y, width, height, detail?detail:"<null>");
1563	#endif
1564	gtk_paint_box(style, window, state_type, shadow_type, area, widget, detail,
1565	x, y, width, height);
1566	}
1567
1568
1569
1570	static void
1571	draw_shadow_gap(GtkStyle * style,
1572	GdkWindow * window,
1573	GtkStateType state_type,
1574	GtkShadowType shadow_type,
1575	GdkRectangle * area,
1576	GtkWidget * widget,
1577	const gchar *detail,
1578	gint x,
1579	gint y,
1580	gint width,
1581	gint height,
1582	GtkPositionType gap_side,
1583	gint gap_x,
1584	gint gap_width)
1585	{
1586	GdkGC *gc1 = NULL;
1587	GdkGC *gc2 = NULL;
1588
1589	g_return_if_fail (window != NULL);
1590
1591	sanitize_size (window, &width, &height);
1592	shadow_type = get_shadow_type (style, detail, shadow_type);
1593
1594	switch (shadow_type) {
1595	case GTK_SHADOW_NONE:
1596	return;
1597	case GTK_SHADOW_IN:
1598	gc1 = style->dark_gc[state_type];
1599	gc2 = style->light_gc[state_type];
1600	break;
1601	case GTK_SHADOW_OUT:
1602	gc1 = style->light_gc[state_type];
1603	gc2 = style->dark_gc[state_type];
1604	break;
1605	case GTK_SHADOW_ETCHED_IN:
1606	case GTK_SHADOW_ETCHED_OUT:
1607	gc1 = style->dark_gc[state_type];
1608	gc2 = style->dark_gc[state_type];
1609	}
1610
1611	if (area) {
1612	gdk_gc_set_clip_rectangle (gc1, area);
1613	gdk_gc_set_clip_rectangle (gc2, area);
1614	}
1615
1616	switch (gap_side) {
1617	case GTK_POS_TOP:
1618	if (gap_x > 0) {
1619	gdk_draw_line (window, gc1,
1620	x, y,
1621	x + gap_x, y);
1622	}
1623	if ((width - (gap_x + gap_width)) > 0) {
1624	gdk_draw_line (window, gc1,
1625	x + gap_x + gap_width - 1, y,
1626	x + width - 1, y);
1627	}
1628	gdk_draw_line (window, gc1,
1629	x, y,
1630	x, y + height - 1);
1631	gdk_draw_line (window, gc2,
1632	x + width - 1, y,
1633	x + width - 1, y + height - 1);
1634	gdk_draw_line (window, gc2,
1635	x, y + height - 1,
1636	x + width - 1, y + height - 1);
1637	break;
1638	case GTK_POS_BOTTOM:
1639	gdk_draw_line (window, gc1,
1640	x, y,
1641	x + width - 1, y);
1642	gdk_draw_line (window, gc1,
1643	x, y,
1644	x, y + height - 1);
1645	gdk_draw_line (window, gc2,
1646	x + width - 1, y,
1647	x + width - 1, y + height - 1);
1648
1649	if (gap_x > 0) {
1650	gdk_draw_line (window, gc2,
1651	x, y + height - 1,
1652	x + gap_x, y + height - 1);
1653	}
1654	if ((width - (gap_x + gap_width)) > 0) {
1655	gdk_draw_line (window, gc2,
1656	x + gap_x + gap_width - 1, y + height - 1,
1657	x + width - 1, y + height - 1);
1658	}
1659
1660	break;
1661	case GTK_POS_LEFT:
1662	gdk_draw_line (window, gc1,
1663	x, y,
1664	x + width - 1, y);
1665	if (gap_x > 0) {
1666	gdk_draw_line (window, gc1,
1667	x, y,
1668	x, y + gap_x);
1669	}
1670	if ((height - (gap_x + gap_width)) > 0) {
1671	gdk_draw_line (window, gc1,
1672	x, y + gap_x + gap_width - 1,
1673	x, y + height - 1);
1674	}
1675	gdk_draw_line (window, gc2,
1676	x + width - 1, y,
1677	x + width - 1, y + height - 1);
1678	gdk_draw_line (window, gc2,
1679	x, y + height - 1,
1680	x + width - 1, y + height - 1);
1681	break;
1682	case GTK_POS_RIGHT:
1683	gdk_draw_line (window, gc1,
1684	x, y,
1685	x + width - 1, y);
1686	gdk_draw_line (window, gc1,
1687	x, y,
1688	x, y + height - 1);
1689
1690
1691	if (gap_x > 0) {
1692	gdk_draw_line (window, gc2,
1693	x + width - 1, y,
1694	x + width - 1, y + gap_x);
1695	}
1696	if ((height - (gap_x + gap_width)) > 0) {
1697	gdk_draw_line (window, gc2,
1698	x + width - 1, y + gap_x + gap_width - 1,
1699	x + width - 1, y + height - 1);
1700	}
1701	gdk_draw_line (window, gc2,
1702	x, y + height - 1,
1703	x + width - 1, y + height - 1);
1704
1705	}
1706
1707	if (area) {
1708	gdk_gc_set_clip_rectangle (gc1, NULL);
1709	gdk_gc_set_clip_rectangle (gc2, NULL);
1710	}
1711	}
1712
1713
1714	static void
1715	draw_box_gap(GtkStyle * style,
1716	GdkWindow * window,
1717	GtkStateType state_type,
1718	GtkShadowType shadow_type,
1719	GdkRectangle * area,
1720	GtkWidget * widget,
1721	const gchar *detail,
1722	gint x,
1723	gint y,
1724	gint width,
1725	gint height,
1726	GtkPositionType gap_side,
1727	gint gap_x,
1728	gint gap_width)
1729	{
1730	sanitize_size (window, &width, &height);
1731
1732	gtk_style_apply_default_background(style, window,
1733	widget && !GTK_WIDGET_NO_WINDOW(widget),
1734	state_type, area,
1735	x, y, width, height);
1736	draw_shadow_gap (style, window, state_type, shadow_type,
1737	area, widget, detail, x, y, width, height,
1738	gap_side, gap_x, gap_width);
1739	}
1740
1741
1742	static void
1743	draw_extension(GtkStyle * style,
1744	GdkWindow * window,
1745	GtkStateType state_type,
1746	GtkShadowType shadow_type,
1747	GdkRectangle * area,
1748	GtkWidget * widget,
1749	const gchar *detail,
1750	gint x,
1751	gint y,
1752	gint width,
1753	gint height,
1754	GtkPositionType gap_side)
1755	{
1756	GdkRectangle rect;
1757
1758	g_return_if_fail(style != NULL);
1759	g_return_if_fail(window != NULL);
1760
1761	sanitize_size (window, &width, &height);
1762
1763	gtk_paint_box(style, window, state_type, shadow_type, area, widget, detail,
1764	x, y, width, height);
1765
1766	switch (gap_side)
1767	{
1768	case GTK_POS_TOP:
1769	rect.x = x + style->xthickness;
1770	rect.y = y;
1771	rect.width = width - style->xthickness * 2;
1772	rect.height = style->ythickness;
1773	break;
1774	case GTK_POS_BOTTOM:
1775	rect.x = x + style->xthickness;
1776	rect.y = y + height - style->ythickness;
1777	rect.width = width - style->xthickness * 2;
1778	rect.height = style->ythickness;
1779	break;
1780	case GTK_POS_LEFT:
1781	rect.x = x;
1782	rect.y = y + style->ythickness;
1783	rect.width = style->xthickness;
1784	rect.height = height - style->ythickness * 2;
1785	break;
1786	case GTK_POS_RIGHT:
1787	rect.x = x + width - style->xthickness;
1788	rect.y = y + style->ythickness;
1789	rect.width = style->xthickness;
1790	rect.height = height - style->ythickness * 2;
1791	break;
1792	}
1793
1794	gtk_style_apply_default_background(style, window,
1795	widget && !GTK_WIDGET_NO_WINDOW(widget),
1796	state_type, area, rect.x, rect.y, rect.width, rect.height);
1797	}
1798
1799	#if 0
1800	static void
1801	draw_focus(GtkStyle * style,
1802	GdkWindow * window,
1803	GdkRectangle * area,
1804	GtkWidget * widget,
1805	const gchar *detail,
1806	gint x,
1807	gint y,
1808	gint width,
1809	gint height)
1810	{
1811	g_return_if_fail(style != NULL);
1812	g_return_if_fail(window != NULL);
1813
1814	if ((width == -1) && (height == -1))
1815	{
1816	gdk_window_get_size(window, &width, &height);
1817	width--;
1818	height--;
1819	}
1820	else if (width == -1)
1821	{
1822	gdk_window_get_size(window, &width, NULL);
1823	width--;
1824	}
1825	else if (height == -1)
1826	{
1827	gdk_window_get_size(window, NULL, &height);
1828	height--;
1829	}
1830	if (area)
1831	{
1832	gdk_gc_set_clip_rectangle(style->black_gc, area);
1833	}
1834	gdk_draw_rectangle(window,
1835	style->black_gc, FALSE,
1836	x, y, width, height);
1837	if (area)
1838	{
1839	gdk_gc_set_clip_rectangle(style->black_gc, NULL);
1840	}
1841	}
1842	#endif /* 0 */
1843
1844	static void
1845	draw_slider(GtkStyle * style,
1846	GdkWindow * window,
1847	GtkStateType state_type,
1848	GtkShadowType shadow_type,
1849	GdkRectangle * area,
1850	GtkWidget * widget,
1851	const gchar *detail,
1852	gint x,
1853	gint y,
1854	gint width,
1855	gint height,
1856	GtkOrientation orientation)
1857	{
1858	GdkPoint pointsh[7];
1859	GdkRegion *clipreg;
1860	GdkRectangle rec;
1861	int i, rect = FALSE, midlines = MARKS_SLASH;
1862	int modx, mody;
1863
1864
1865	g_return_if_fail(style != NULL);
1866	g_return_if_fail(window != NULL);
1867
1868	#ifdef DEBUG
1869	printf("draw_slider(%s, %d, %d, %d)\n", detail, x, y, orientation);
1870	#endif
1871
1872	#ifdef DEBUG
1873	printf("Slider... x,y=%d,%d width = %d, height = %d (%d)\n",x,y,width,height, state_type);
1874	#endif
1875	midlines = THINICE_RC_STYLE (style->rc_style)->mark_type1;
1876	#ifdef DEBUG
1877	printf("Midlines = %d\n", midlines);
1878	#endif
1879
1880	if (THINICE_RC_STYLE (style->rc_style)->scrollbar_type == SCROLL_RECT)
1881	{
1882	rect = TRUE;
1883	}
1884
1885	/* too small, use rect & no midlines */
1886	if ((width <= SMALLEST_HANDLE) && (height <= SMALLEST_HANDLE))
1887	{
1888	midlines = MARKS_NOTHING;
1889	rect = TRUE;
1890	}
1891
1892	if (rect)
1893	{
1894	pointsh[0].x = x; pointsh[0].y = y;
1895	pointsh[1].x = x + width - 1; pointsh[1].y = y;
1896	pointsh[2].x = x + width - 1; pointsh[2].y = y + height - 1;
1897	pointsh[3].x = x; pointsh[3].y = y + height - 1;
1898	pointsh[4].x = x; pointsh[4].y = y;
1899	clipreg = gdk_region_polygon(pointsh, 5, GDK_WINDING_RULE);
1900	gdk_region_shrink(clipreg, -1, -1);
1901	}
1902	else
1903	{
1904	int chopoff;
1905
1906	if (orientation == GTK_ORIENTATION_HORIZONTAL) {
1907	chopoff = max(0, min(6, width-SMALLEST_HANDLE));
1908	} else {
1909	chopoff = max(0, min(6, height-SMALLEST_HANDLE));
1910	}
1911
1912	pointsh[0].x = x; pointsh[0].y = y+height-1;
1913	pointsh[1].x = x; pointsh[1].y = y+chopoff;
1914	pointsh[2].x = x+chopoff; pointsh[2].y = y;
1915	pointsh[3].x = x+width-1; pointsh[3].y = y;
1916	pointsh[4].x = x+width-1; pointsh[4].y = y+height-1-chopoff;
1917	pointsh[5].x = x+width-1-chopoff; pointsh[5].y = y+height-1;
1918	pointsh[6].x = x; pointsh[6].y = y+height-1;
1919	clipreg = gdk_region_polygon(pointsh, 7, GDK_WINDING_RULE);
1920	gdk_region_shrink(clipreg, -1, -1);
1921	}
1922
1923	gdk_gc_set_clip_region(style->bg_gc[state_type], clipreg);
1924	gdk_gc_set_clip_region(style->light_gc[state_type], clipreg);
1925	gdk_gc_set_clip_region(style->dark_gc[state_type], clipreg);
1926
1927	if (!rect)
1928	{
1929	rec.x = x;
1930	rec.y = y;
1931	rec.width = width;
1932	rec.height = height;
1933	gdk_gc_set_clip_rectangle(style->bg_gc[GTK_STATE_ACTIVE], &rec);
1934	}
1935
1936	if (rect)
1937	{
1938	/* Just a plain rectangle with shadow ... */
1939	if ((!style->bg_pixmap[state_type]) \|\| GDK_IS_PIXMAP (window))
1940	{
1941	gdk_draw_rectangle(window, style->bg_gc[state_type], TRUE,
1942	x, y, width, height);
1943	}
1944	else
1945	{
1946	gtk_style_apply_default_background(style, window,
1947	widget && !GTK_WIDGET_NO_WINDOW(widget),
1948	state_type, area,
1949	x, y, width, height);
1950	}
1951	gtk_paint_shadow(style, window, state_type, shadow_type, area,
1952	widget, detail, x, y, width, height);
1953	}
1954	else
1955	{
1956	/* Fill the polygon */
1957	gdk_draw_polygon(window, style->bg_gc[state_type],
1958	TRUE, pointsh, 6);
1959	/* Draw the light border */
1960	for (i=0;i<3;i++)
1961	{
1962	gdk_draw_line(window, style->light_gc[state_type],
1963	pointsh[i].x,pointsh[i].y,
1964	pointsh[i+1].x,pointsh[i+1].y);
1965	}
1966	/* Draw the dark border */
1967	for (i=3;i<6;i++)
1968	{
1969	gdk_draw_line(window, style->dark_gc[state_type],
1970	pointsh[i].x,pointsh[i].y,
1971	pointsh[i+1].x,pointsh[i+1].y);
1972	}
1973
1974	}
1975	if (orientation == GTK_ORIENTATION_HORIZONTAL)
1976	{ modx = 4; mody = 0; }
1977	else
1978	{ modx = 0; mody = 4; }
1979	switch (midlines)
1980	{
1981	case MARKS_NOTHING:
1982	break;
1983	case MARKS_INVSLASH: /* Inverse //:es */
1984	thinice_slash_two(window,
1985	style->dark_gc[state_type],
1986	style->light_gc[state_type],
1987	x, y, width, height);
1988	break;
1989	case MARKS_DOT:
1990	thinice_dot(window,
1991	style->light_gc[state_type],
1992	style->dark_gc[state_type],
1993	x + width / 2 - modx,
1994	y + height / 2 - mody);
1995	thinice_dot(window,
1996	style->light_gc[state_type],
1997	style->dark_gc[state_type],
1998	x + width / 2,
1999	y + height / 2);
2000	thinice_dot(window,
2001	style->light_gc[state_type],
2002	style->dark_gc[state_type],
2003	x + width / 2 + modx,
2004	y + height / 2 + mody);
2005	break;
2006	case MARKS_INVDOT: /* Inverted */
2007	thinice_dot(window,
2008	style->dark_gc[state_type],
2009	style->light_gc[state_type],
2010	x + width / 2 - modx,
2011	y + height / 2 - mody);
2012	thinice_dot(window,
2013	style->dark_gc[state_type],
2014	style->light_gc[state_type],
2015	x + width / 2,
2016	y + height / 2);
2017	thinice_dot(window,
2018	style->dark_gc[state_type],
2019	style->light_gc[state_type],
2020	x + width / 2 + modx,
2021	y + height / 2 + mody);
2022	break;
2023	case MARKS_SLASH:
2024	default:
2025	thinice_slash_two(window,
2026	style->light_gc[state_type],
2027	style->dark_gc[state_type],
2028	x, y, width, height);
2029	break;
2030	}
2031	/*
2032	if (area)
2033	{
2034	gdk_gc_set_clip_rectangle(style->bg_gc[state_type], NULL);
2035	gdk_gc_set_clip_rectangle(style->light_gc[state_type], NULL);
2036	gdk_gc_set_clip_rectangle(style->dark_gc[state_type], NULL);
2037	}
2038	else
2039	{
2040	*/
2041	gdk_gc_set_clip_region(style->bg_gc[state_type], NULL);
2042	gdk_gc_set_clip_region(style->light_gc[state_type], NULL);
2043	gdk_gc_set_clip_region(style->dark_gc[state_type], NULL);
2044	/*
2045	}
2046	*/
2047	if (!rect)
2048	{
2049	gdk_gc_set_clip_rectangle(style->bg_gc[GTK_STATE_ACTIVE], NULL);
2050	}
2051	}
2052
2053	static void
2054	draw_handle(GtkStyle * style,
2055	GdkWindow * window,
2056	GtkStateType state_type,
2057	GtkShadowType shadow_type,
2058	GdkRectangle * area,
2059	GtkWidget * widget,
2060	const gchar *detail,
2061	gint x,
2062	gint y,
2063	gint width,
2064	gint height,
2065	GtkOrientation orientation)
2066	{
2067	GdkGC light_gc, dark_gc;
2068	GdkRectangle dest;
2069	// ThemeStyleData *data = NULL;//style->engine_data;
2070	gint modx, mody;
2071
2072	g_return_if_fail(style != NULL);
2073	g_return_if_fail(window != NULL);
2074
2075	#if DEBUG
2076	printf("draw_handle(state=%d, shadow=%d, detail=%s, [%d,%d]@[%d,%d]\n",
2077	state_type, shadow_type, detail?detail:"nul",width,height,x,y);
2078	#endif
2079	sanitize_size(window, &width, &height);
2080
2081	if (DETAIL("paned"))
2082	{
2083	int i, w, h;
2084	int start_i, end_i;
2085
2086	dest.x = x;
2087	dest.y = y;
2088	dest.width = width;
2089	dest.height = height;
2090
2091	light_gc = style->light_gc[state_type];
2092	dark_gc = style->dark_gc[state_type];
2093	if (orientation == GTK_ORIENTATION_HORIZONTAL)
2094	w = width;
2095	else
2096	w = height;
2097	switch (THINICE_RC_STYLE (style->rc_style)->paned_dots) {
2098	default:
2099	case PANED_DOTSFULL:
2100	start_i = 5;
2101	end_i = w - 5;
2102	break;
2103	case PANED_DOTSSOME:
2104	start_i = w/2 - 16;
2105	end_i = w/2 + 16;
2106	break;
2107	case PANED_DOTSNONE:
2108	start_i = w;
2109	end_i = 0;
2110	break;
2111	}
2112	gdk_gc_set_clip_rectangle(light_gc, &dest);
2113	gdk_gc_set_clip_rectangle(dark_gc, &dest);
2114
2115	if (orientation == GTK_ORIENTATION_HORIZONTAL)
2116	{
2117	for (i=x + start_i; i <= x + end_i; i+=8)
2118	{
2119	thinice_dot(window, light_gc, dark_gc, i, y + height / 2);
2120	}
2121	}
2122	else
2123	{
2124	for (i=y + start_i; i <= y + end_i; i+=8)
2125	{
2126	thinice_dot(window, light_gc, dark_gc, x + width / 2, i);
2127	}
2128	}
2129	gdk_gc_set_clip_rectangle(light_gc, NULL);
2130	gdk_gc_set_clip_rectangle(dark_gc, NULL);
2131	return;
2132	}
2133	gtk_paint_box(style, window, state_type, shadow_type, area, widget,
2134	detail, x, y, width, height);
2135	gdk_draw_line(window, style->light_gc[state_type],
2136	x + width, y, x + width, y + height - 2);
2137
2138	/* Draw something in the box if so wanted */
2139	if (THINICE_RC_STYLE (style->rc_style)->mark_type1 != MARKS_NOTHING)
2140	{
2141	light_gc = style->light_gc[state_type];
2142	dark_gc = style->dark_gc[state_type];
2143
2144	orientation = GTK_ORIENTATION_HORIZONTAL;
2145	if (height > width)
2146	orientation = GTK_ORIENTATION_VERTICAL;
2147
2148	dest.x = x + style->xthickness;
2149	dest.y = y + style->ythickness;
2150	dest.width = width - (style->xthickness * 2);
2151	dest.height = height - (style->ythickness * 2);
2152
2153	if (orientation == GTK_ORIENTATION_HORIZONTAL)
2154	{ modx = 4; mody = 0; }
2155	else
2156	{ modx = 0; mody = 4; }
2157
2158	gdk_gc_set_clip_rectangle(light_gc, &dest);
2159	gdk_gc_set_clip_rectangle(dark_gc, &dest);
2160
2161	switch (THINICE_RC_STYLE (style->rc_style)->mark_type1)
2162	{
2163	case MARKS_INVSLASH: /* Inverse //:es */
2164	thinice_slash_two(window, dark_gc, light_gc,
2165	x, y, width, height);
2166	break;
2167	case MARKS_DOT: /* Dots */
2168	thinice_dot(window, light_gc, dark_gc,
2169	x + width / 2 - modx,
2170	y + height / 2 - mody);
2171	thinice_dot(window, light_gc, dark_gc,
2172	x + width / 2,
2173	y + height / 2);
2174	thinice_dot(window, light_gc, dark_gc,
2175	x + width / 2 + modx,
2176	y + height / 2 + mody);
2177	break;
2178	case MARKS_INVDOT: /* Inverted dots */
2179	thinice_dot(window, dark_gc, light_gc,
2180	x + width / 2 - modx,
2181	y + height / 2 - mody);
2182	thinice_dot(window, dark_gc, light_gc,
2183	x + width / 2,
2184	y + height / 2);
2185	thinice_dot(window, dark_gc, light_gc,
2186	x + width / 2 + modx,
2187	y + height / 2 + mody);
2188	break;
2189	case MARKS_SLASH:
2190	default:
2191	thinice_slash_two(window, light_gc, dark_gc,
2192	x, y, width, height);
2193	break;
2194	}
2195
2196	gdk_gc_set_clip_rectangle(light_gc, NULL);
2197	gdk_gc_set_clip_rectangle(dark_gc, NULL);
2198	}
2199
2200	}
2201
2202	static void
2203	thinice_slash_two(GdkWindow *window,
2204	GdkGC *gc1,
2205	GdkGC *gc2,
2206	gint x,
2207	gint y,
2208	gint width,
2209	gint height)
2210	{
2211	gint centerx, centery, thick;
2212	gint ax1=0,ax2=0,ay1=0,ay2=0;
2213
2214	centerx = (width - 1)/2 + x;
2215	centery = (height - 1)/2 + y;
2216	if (width > height)
2217	{
2218	ax1 = -2; ax2 = 1;
2219	}
2220	else
2221	{
2222	ay1 = -2; ay2 = 1;
2223	}
2224
2225	thick = ((width < height?width-1:height-1) >> 1) - 2;
2226	gdk_draw_line(window, gc2,
2227	centerx - thick + ax1, centery + thick + ay1,
2228	centerx + thick + ax1, centery - thick + ay1);
2229	gdk_draw_line(window, gc1,
2230	centerx - thick + ax1 + ax2, centery + thick + ay1 + ay2,
2231	centerx + thick + ax1 + ax2, centery - thick + ay1 + ay2);
2232	if (width > height)
2233	{
2234	ax1 = 2; /* ax2 = 1; */
2235	}
2236	else
2237	{
2238	ay1 = 2; /* ay2 = 1; */
2239	}
2240	gdk_draw_line(window, gc2,
2241	centerx - thick + ax1, centery + thick + ay1,
2242	centerx + thick + ax1, centery - thick + ay1);
2243	gdk_draw_line(window, gc1,
2244	centerx - thick + ax1 + ax2, centery + thick + ay1 + ay2,
2245	centerx + thick + ax1 + ax2, centery - thick + ay1 + ay2);
2246	}
2247
2248
2249	static void
2250	thinice_slash_one(GdkWindow *window,
2251	GdkGC *gc1,
2252	GdkGC *gc2,
2253	gint x,
2254	gint y,
2255	gint width,
2256	gint height)
2257	{
2258	gint centerx, centery, thick;
2259
2260	centerx = width/2 + x;
2261	centery = height/2 + y;
2262
2263	thick = ((width < height?width:height) >> 1);
2264	gdk_draw_line(window, gc2,
2265	centerx - thick, centery + thick,
2266	centerx + thick, centery - thick);
2267	gdk_draw_line(window, gc1,
2268	centerx - thick, centery + thick - 1,
2269	centerx + thick - 1, centery - thick);
2270	}
2271
2272	static void
2273	thinice_dot(GdkWindow *window,
2274	GdkGC *gc1,
2275	GdkGC *gc2,
2276	gint x,
2277	gint y)
2278	{
2279	GdkPoint points[3];
2280
2281	points[0].x = x-1; points[0].y = y;
2282	points[1].x = x-1; points[1].y = y-1;
2283	points[2].x = x; points[2].y = y-1;
2284
2285	gdk_draw_points(window, gc2, points, 3);
2286
2287	points[0].x = x+1; points[0].y = y;
2288	points[1].x = x+1; points[1].y = y+1;
2289	points[2].x = x; points[2].y = y+1;
2290
2291	gdk_draw_points(window, gc1, points, 3);
2292	}
2293
2294	static void
2295	thinice_tab(GtkStyle * style,
2296	GdkWindow * window,
2297	GtkStateType state_type,
2298	GtkShadowType shadow_type,
2299	GdkRectangle * area,
2300	GtkWidget * widget,
2301	const gchar *detail,
2302	gint x,
2303	gint y,
2304	gint width,
2305	gint height)
2306	{
2307	GtkNotebook *notebook;
2308	GdkGC lightgc, darkgc;
2309	int orientation;
2310
2311
2312	notebook = GTK_NOTEBOOK(widget);
2313	orientation = notebook->tab_pos;
2314
2315	lightgc = style->light_gc[state_type];
2316	darkgc = style->dark_gc[state_type];
2317
2318	if ((!style->bg_pixmap[state_type]) \|\| GDK_IS_PIXMAP(window))
2319	{
2320	if (area)
2321	{
2322	gdk_gc_set_clip_rectangle(style->bg_gc[state_type], area);
2323	}
2324	gdk_draw_rectangle(window, style->bg_gc[state_type], TRUE,
2325	x, y, width, height);
2326	if (area)
2327	{
2328	gdk_gc_set_clip_rectangle(style->bg_gc[state_type], NULL);
2329	}
2330	}
2331	else
2332	{
2333	gtk_style_apply_default_background(style, window,
2334	widget && !GTK_WIDGET_NO_WINDOW(widget),
2335	state_type, area, x, y, width, height);
2336	}
2337	if (area)
2338	{
2339	gdk_gc_set_clip_rectangle(style->dark_gc[state_type], area);
2340	gdk_gc_set_clip_rectangle(style->light_gc[state_type], area);
2341	}
2342	switch(orientation)
2343	{
2344	case GTK_POS_TOP:
2345	gdk_draw_line(window, lightgc,
2346	x, y + height - 1, x, y);
2347	gdk_draw_line(window, lightgc,
2348	x, y, x + width - 1, y);
2349	gdk_draw_line(window, darkgc,
2350	x + width - 1, y, x + width - 1, y + height - 1);
2351	break;
2352	case GTK_POS_BOTTOM:
2353	gdk_draw_line(window, lightgc,
2354	x, y, x, y + height - 1);
2355	gdk_draw_line(window, darkgc,
2356	x, y + height - 1, x + width - 1, y + height - 1);
2357	gdk_draw_line(window, darkgc,
2358	x + width - 1, y + height - 1, x + width - 1, y);
2359	break;
2360	case GTK_POS_LEFT:
2361	gdk_draw_line(window, lightgc,
2362	x, y + height - 1, x, y);
2363	gdk_draw_line(window, lightgc,
2364	x, y, x + width - 1, y);
2365	gdk_draw_line(window, darkgc,
2366	x, y + height - 1, x + width - 1, y + height - 1);
2367	break;
2368	case GTK_POS_RIGHT:
2369	gdk_draw_line(window, lightgc,
2370	x, y, x + width - 1, y);
2371	gdk_draw_line(window, darkgc,
2372	x + width - 1, y, x + width - 1, y + height - 1);
2373	gdk_draw_line(window, darkgc,
2374	x, y + height - 1, x + width - 1, y + height - 1);
2375	break;
2376	}
2377	if (area)
2378	{
2379	gdk_gc_set_clip_rectangle(style->dark_gc[state_type], NULL);
2380	gdk_gc_set_clip_rectangle(style->light_gc[state_type], NULL);
2381	}
2382	/*gtk_paint_shadow(style, window, state_type, shadow_type, area, widget,
2383	detail, x, y, width, height);
2384	*/
2385	}
2386
2387	GType thinice_type_style = 0;
2388
2389	void
2390	thinice_style_register_type (GTypeModule *module)
2391	{
2392	static const GTypeInfo object_info =
2393	{
2394	sizeof (ThiniceStyleClass),
2395	(GBaseInitFunc) NULL,
2396	(GBaseFinalizeFunc) NULL,
2397	(GClassInitFunc) thinice_style_class_init,
2398	NULL, /* class_finalize */
2399	NULL, /* class_data */
2400	sizeof (ThiniceStyle),
2401	0, /* n_preallocs */
2402	(GInstanceInitFunc) thinice_style_init,
2403	};
2404
2405	thinice_type_style = g_type_module_register_type (module,
2406	GTK_TYPE_STYLE,
2407	"ThiniceStyle",
2408	&object_info, 0);
2409	}
2410
2411	static void
2412	thinice_style_init (ThiniceStyle *style)
2413	{
2414	}
2415
2416	static void
2417	thinice_style_class_init (ThiniceStyleClass *klass)
2418	{
2419	GtkStyleClass *style_class = GTK_STYLE_CLASS (klass);
2420
2421	parent_class = g_type_class_peek_parent (klass);
2422
2423	#if 0
2424	#endif
2425	style_class->draw_hline = draw_hline;
2426	style_class->draw_vline = draw_vline;
2427	style_class->draw_shadow = draw_shadow;
2428	style_class->draw_polygon = draw_polygon;
2429	style_class->draw_arrow = draw_arrow;
2430	style_class->draw_diamond = draw_diamond;
2431	/style_class->draw_string = draw_string;/
2432	style_class->draw_box = draw_box;
2433	/* style_class->draw_flat_box = draw_flat_box; */
2434	style_class->draw_check = draw_check;
2435	style_class->draw_option = draw_option;
2436	style_class->draw_tab = draw_tab;
2437	style_class->draw_shadow_gap = draw_shadow_gap;
2438
2439	/* box around notebooks */
2440	style_class->draw_box_gap = draw_box_gap;
2441	/* the tab */
2442	style_class->draw_extension = draw_extension;
2443
2444	/style_class->draw_focus = draw_focus;/
2445	style_class->draw_slider = draw_slider;
2446	style_class->draw_handle = draw_handle;
2447	}
2448
2449
2450	/*
2451	FIXME: file/font selector background OK
2452	FIXME: radioknappar varierar storlek rätt bra.. OK
2453	FIXME: scrollbars OK
2454	FIXME: inconsistent-radioknappar OK
2455	FIXME: paned-pluttarna OK
2456	FIXME: spinbuttons, vid max OK
2457
2458	FIXME: Blå triangeln vid RTL, WONTFIX?
2459	*/
2460

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/third/gtk-thinice-engine/thinice_theme_draw.c @ 18878

Download in other formats: