![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gtk-screen.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [The Machine Emulator] / tme / host / gtk|
Return to gtk-screen.c CVS log | Up to [The Machine Emulator] / tme / host / gtk |
1.1 root 1: /* $Id: gtk-screen.c,v 1.3 2003/10/29 02:03:26 fredette Exp $ */
2:
3: /* host/gtk/gtk-screen.c - GTK screen support: */
4:
5: /*
6: * Copyright (c) 2003 Matt Fredette
7: * All rights reserved.
8: *
9: * Redistribution and use in source and binary forms, with or without
10: * modification, are permitted provided that the following conditions
11: * are met:
12: * 1. Redistributions of source code must retain the above copyright
13: * notice, this list of conditions and the following disclaimer.
14: * 2. Redistributions in binary form must reproduce the above copyright
15: * notice, this list of conditions and the following disclaimer in the
16: * documentation and/or other materials provided with the distribution.
17: * 3. All advertising materials mentioning features or use of this software
18: * must display the following acknowledgement:
19: * This product includes software developed by Matt Fredette.
20: * 4. The name of the author may not be used to endorse or promote products
21: * derived from this software without specific prior written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
25: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
27: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
28: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
29: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
31: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
32: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33: * POSSIBILITY OF SUCH DAMAGE.
34: */
35:
36: #include <tme/common.h>
37: _TME_RCSID("$Id: gtk-screen.c,v 1.3 2003/10/29 02:03:26 fredette Exp $");
38:
39: /* we are aware of the problems with gdk_image_new_bitmap, and we cope
40: with them, so we define GDK_ENABLE_BROKEN to get its prototype
41: under GTK 2: */
42: #define GDK_ENABLE_BROKEN
43:
44: /* includes: */
45: #include "gtk-display.h"
46: #include <stdlib.h>
47:
48: /* macros: */
49:
50: /* the GTK 1.x gtk_image_new function is the GTK 2.x
51: gtk_image_new_from_image function: */
52: #if GTK_MAJOR_VERSION == 1
53: #define gtk_image_new_from_image gtk_image_new
54: #endif /* GTK_MAJOR_VERSION == 1 */
55:
56: /* the GTK screens update thread: */
57: void
58: _tme_gtk_screen_th_update(struct tme_gtk_display *display)
59: {
60: struct tme_gtk_screen *screen;
61: struct tme_fb_connection *conn_fb_other;
62: int changed;
63: int rc;
64:
65: /* loop forever: */
66: for (;;) {
67:
68: /* lock the mutex: */
69: tme_mutex_lock(&display->tme_gtk_display_mutex);
70:
71: /* loop over all screens: */
72: for (screen = display->tme_gtk_display_screens;
73: screen != NULL;
74: screen = screen->tme_gtk_screen_next) {
75:
76: /* skip this screen if it's unconnected: */
77: if (screen->tme_gtk_screen_fb == NULL) {
78: continue;
79: }
80:
81: /* get the other side of this connection: */
82: conn_fb_other
83: = ((struct tme_fb_connection *)
84: screen->tme_gtk_screen_fb->tme_fb_connection.tme_connection_other);
85:
86: /* if the framebuffer has an update function, call it: */
87: if (conn_fb_other->tme_fb_connection_update != NULL) {
88: rc = (*conn_fb_other->tme_fb_connection_update)(conn_fb_other);
89: assert (rc == TME_OK);
90: }
91:
92: /* translate this framebuffer's contents: */
93: changed = (*screen->tme_gtk_screen_fb_xlat)
94: (((struct tme_fb_connection *)
95: screen->tme_gtk_screen_fb->tme_fb_connection.tme_connection_other),
96: screen->tme_gtk_screen_fb);
97:
98: /* if those contents changed, redraw the widget: */
99: if (changed) {
100: gtk_widget_queue_draw(screen->tme_gtk_screen_gtkimage);
101: }
102: }
103:
104: /* unlock the mutex: */
105: tme_mutex_unlock(&display->tme_gtk_display_mutex);
106:
107: /* update again in .5 seconds: */
108: tme_thread_sleep_yield(0, 500000);
109: }
110: /* NOTREACHED */
111: }
112:
113: /* this recovers the bits-per-pixel value for a GdkImage: */
114: static unsigned int
115: _tme_gtk_gdkimage_bipp(GdkImage *image)
116: {
117: unsigned int bipp, total_bits_halved;
118:
119: total_bits_halved = image->bpl;
120: total_bits_halved = (total_bits_halved * 8) / 2;
121: for (bipp = image->depth;
122: (bipp * image->width) <= total_bits_halved;
123: bipp <<= 1);
124: return (bipp);
125: }
126:
127: /* this recovers the scanline-pad value for a GdkImage: */
128: static unsigned int
129: _tme_gtk_gdkimage_scanline_pad(GdkImage *image)
130: {
131:
132: if ((image->bpl % sizeof(tme_uint32_t)) == 0) {
133: return (32);
134: }
135: if ((image->bpl % sizeof(tme_uint16_t)) == 0) {
136: return (16);
137: }
138: if ((image->bpl % sizeof(tme_uint8_t)) == 0) {
139: return (8);
140: }
141: }
142:
143: /* this is called for a mode change: */
144: int
145: _tme_gtk_screen_mode_change(struct tme_fb_connection *conn_fb)
146: {
147: struct tme_gtk_display *display;
148: struct tme_gtk_screen *screen;
149: struct tme_fb_connection *conn_fb_other;
150: struct tme_fb_xlat fb_xlat_q;
151: const struct tme_fb_xlat *fb_xlat_a;
152: int scale;
153: unsigned long fb_area, avail_area, percentage;
154: gint width, height;
155: GdkImage *gdkimage;
156: GdkVisual *visual;
157: int color_count, color_i;
158: GdkColor color;
159:
160: /* recover our data structures: */
161: display = conn_fb->tme_fb_connection.tme_connection_element->tme_element_private;
162: conn_fb_other = (struct tme_fb_connection *) conn_fb->tme_fb_connection.tme_connection_other;
163:
164: /* lock our mutex: */
165: tme_mutex_lock(&display->tme_gtk_display_mutex);
166:
167: /* find the screen that this framebuffer connection references: */
168: for (screen = display->tme_gtk_display_screens;
169: (screen != NULL
170: && screen->tme_gtk_screen_fb != conn_fb);
171: screen = screen->tme_gtk_screen_next);
172: assert (screen != NULL);
173:
174: /* if the user hasn't specified a scaling, pick one: */
175: scale = screen->tme_gtk_screen_fb_scale;
176: if (scale < 0) {
177:
178: /* calulate the areas, in square pixels, of the emulated
179: framebuffer and the host's screen: */
180: fb_area = (conn_fb_other->tme_fb_connection_width
181: * conn_fb_other->tme_fb_connection_height);
182: avail_area = (gdk_screen_width()
183: * gdk_screen_height());
184:
185: /* see what percentage of the host's screen would be taken up by
186: an unscaled emulated framebuffer: */
187: percentage = (fb_area * 100) / avail_area;
188:
189: /* if this is at least 70%, halve the emulated framebuffer, else
190: if this is 30% or less, double the emulated framebuffer: */
191: if (percentage >= 70) {
192: scale = TME_FB_XLAT_SCALE_HALF;
193: }
194: else if (percentage <= 30) {
195: scale = TME_FB_XLAT_SCALE_DOUBLE;
196: }
197: else {
198: scale = TME_FB_XLAT_SCALE_NONE;
199: }
200:
201: screen->tme_gtk_screen_fb_scale = -scale;
202: }
203:
204: /* get the system's default visual: */
205: visual = gdk_visual_get_system();
206:
207: /* create the new GdkImage for the screen: */
208: width = ((conn_fb_other->tme_fb_connection_width
209: * scale)
210: / TME_FB_XLAT_SCALE_NONE);
211: height = ((conn_fb_other->tme_fb_connection_height
212: * scale)
213: / TME_FB_XLAT_SCALE_NONE);
214: gdkimage = gdk_image_new(GDK_IMAGE_FASTEST,
215: visual,
216: width,
217: height);
218:
219: /* set the new image on the image widget: */
220: gtk_image_set(GTK_IMAGE(screen->tme_gtk_screen_gtkimage),
221: gdkimage,
222: NULL);
223:
224: /* destroy the previous gdkimage and remember the new one: */
225: gdk_image_destroy(screen->tme_gtk_screen_gdkimage);
226: screen->tme_gtk_screen_gdkimage = gdkimage;
227:
228: /* update our framebuffer connection: */
229: conn_fb->tme_fb_connection_width = width;
230: conn_fb->tme_fb_connection_height = height;
231: conn_fb->tme_fb_connection_depth = gdkimage->depth;
232: conn_fb->tme_fb_connection_bits_per_pixel = _tme_gtk_gdkimage_bipp(gdkimage);
233: conn_fb->tme_fb_connection_skipx = 0;
234: conn_fb->tme_fb_connection_scanline_pad = _tme_gtk_gdkimage_scanline_pad(gdkimage);
235: conn_fb->tme_fb_connection_order = (gdkimage->byte_order == GDK_LSB_FIRST
236: ? TME_ENDIAN_LITTLE
237: : TME_ENDIAN_BIG);
238: conn_fb->tme_fb_connection_buffer = gdkimage->mem;
239:
240: /* when we're showing a framebuffer with a depth of one, we need to
241: provide the pixel values for black and white, and, if we're
242: halving, three shades of gray in between: */
243: if (conn_fb->tme_fb_connection_depth1_map != NULL) {
244:
245: /* XXX we almost certainly should free colors
246: previously allocated: */
247: tme_free(conn_fb->tme_fb_connection_depth1_map);
248: }
249: if (conn_fb_other->tme_fb_connection_depth == 1) {
250:
251: /* allocate the depth-one map: */
252: color_count = (scale == TME_FB_XLAT_SCALE_HALF
253: ? 5
254: : 2);
255: conn_fb->tme_fb_connection_depth1_map
256: = tme_new(tme_uint32_t, color_count);
257:
258: /* allocate the colors it needs: */
259: for (color_i = 0;
260: color_i < color_count;
261: color_i++) {
262:
263: /* set the RGB values: */
264: color.red
265: = (((65535UL * color_i) / (color_count - 1))
266: ^ screen->tme_gtk_screen_mono_invert_mask);
267: color.green = color.red;
268: color.blue = color.red;
269:
270: /* allocate the color: */
271: gdk_colormap_alloc_color(gdk_colormap_get_system(),
272: &color,
273: FALSE,
274: TRUE);
275: conn_fb->tme_fb_connection_depth1_map[color_i]
276: = color.pixel;
277: }
278: }
279: else {
280: conn_fb->tme_fb_connection_depth1_map = NULL;
281: }
282:
283: /* compose the framebuffer translation question: */
284: fb_xlat_q.tme_fb_xlat_width = conn_fb_other->tme_fb_connection_width;
285: fb_xlat_q.tme_fb_xlat_height = conn_fb_other->tme_fb_connection_height;
286: fb_xlat_q.tme_fb_xlat_scale = (unsigned int) scale;
287: fb_xlat_q.tme_fb_xlat_src_depth = conn_fb_other->tme_fb_connection_depth;
288: fb_xlat_q.tme_fb_xlat_src_bits_per_pixel = conn_fb_other->tme_fb_connection_bits_per_pixel;
289: fb_xlat_q.tme_fb_xlat_src_skipx = conn_fb_other->tme_fb_connection_skipx;
290: fb_xlat_q.tme_fb_xlat_src_scanline_pad = conn_fb_other->tme_fb_connection_scanline_pad;
291: fb_xlat_q.tme_fb_xlat_src_order = conn_fb_other->tme_fb_connection_order;
292: fb_xlat_q.tme_fb_xlat_dst_depth = conn_fb->tme_fb_connection_depth;
293: fb_xlat_q.tme_fb_xlat_dst_bits_per_pixel = conn_fb->tme_fb_connection_bits_per_pixel;
294: fb_xlat_q.tme_fb_xlat_dst_skipx = conn_fb->tme_fb_connection_skipx;
295: fb_xlat_q.tme_fb_xlat_dst_scanline_pad = conn_fb->tme_fb_connection_scanline_pad;
296: fb_xlat_q.tme_fb_xlat_dst_order = conn_fb->tme_fb_connection_order;
297:
298: /* ask the framebuffer translation question: */
299: fb_xlat_a = tme_fb_xlat_best(&fb_xlat_q);
300:
301: /* if this translation isn't optimal, log a note: */
302: if (!tme_fb_xlat_is_optimal(fb_xlat_a)) {
303: tme_log(&display->tme_gtk_display_element->tme_element_log_handle, 0, TME_OK,
304: (&display->tme_gtk_display_element->tme_element_log_handle,
305: _("no optimal framebuffer translation function available")));
306: }
307:
308: /* save the translation function: */
309: screen->tme_gtk_screen_fb_xlat = fb_xlat_a->tme_fb_xlat_func;
310:
311: /* force the next translation to do a complete redraw: */
312: tme_fb_xlat_redraw(conn_fb_other);
313:
314: /* unlock our mutex: */
315: tme_mutex_unlock(&display->tme_gtk_display_mutex);
316:
317: /* done: */
318: return (TME_OK);
319: }
320:
321: /* this sets the screen size: */
322: static void
323: _tme_gtk_screen_scale_set(GtkWidget *widget,
324: struct tme_gtk_screen *screen,
325: int scale_new)
326: {
327: struct tme_gtk_display *display;
328: int scale_old;
329: int rc;
330:
331: /* return now if the menu item isn't active: */
332: if (!GTK_CHECK_MENU_ITEM(GTK_MENU_ITEM(widget))->active) {
333: return;
334: }
335:
336: /* get the display: */
337: display = screen->tme_gtk_screen_display;
338:
339: /* lock our mutex: */
340: tme_mutex_lock(&display->tme_gtk_display_mutex);
341:
342: /* get the old scaling and set the new scaling: */
343: scale_old = screen->tme_gtk_screen_fb_scale;
344: if (scale_old < 0
345: && scale_new < 0) {
346: scale_new = scale_old;
347: }
348: screen->tme_gtk_screen_fb_scale = scale_new;
349:
350: /* unlock our mutex: */
351: tme_mutex_unlock(&display->tme_gtk_display_mutex);
352:
353: /* call the mode change function if the scaling has changed: */
354: if (scale_new != scale_old) {
355: rc = _tme_gtk_screen_mode_change(screen->tme_gtk_screen_fb);
356: assert (rc == TME_OK);
357: }
358: }
359:
360: /* this sets the screen scaling to default: */
361: static void
362: _tme_gtk_screen_scale_default(GtkWidget *widget,
363: struct tme_gtk_screen *screen)
364: {
365: _tme_gtk_screen_scale_set(widget,
366: screen,
367: -TME_FB_XLAT_SCALE_NONE);
368: }
369:
370: /* this sets the screen scaling to half: */
371: static void
372: _tme_gtk_screen_scale_half(GtkWidget *widget,
373: struct tme_gtk_screen *screen)
374: {
375: _tme_gtk_screen_scale_set(widget,
376: screen,
377: TME_FB_XLAT_SCALE_HALF);
378: }
379:
380: /* this sets the screen scaling to none: */
381: static void
382: _tme_gtk_screen_scale_none(GtkWidget *widget,
383: struct tme_gtk_screen *screen)
384: {
385: _tme_gtk_screen_scale_set(widget,
386: screen,
387: TME_FB_XLAT_SCALE_NONE);
388: }
389:
390: /* this sets the screen scaling to double: */
391: static void
392: _tme_gtk_screen_scale_double(GtkWidget *widget,
393: struct tme_gtk_screen *screen)
394: {
395: _tme_gtk_screen_scale_set(widget,
396: screen,
397: TME_FB_XLAT_SCALE_DOUBLE);
398: }
399:
400: /* this makes a new screen: */
401: struct tme_gtk_screen *
402: _tme_gtk_screen_new(struct tme_gtk_display *display)
403: {
404: struct tme_gtk_screen *screen, **_prev;
405: GtkWidget *menu_bar;
406: GtkWidget *menu;
407: GtkWidget *submenu;
408: GtkWidget *menu_item;
409: GtkWidget **_menu_item;
410: GSList *menu_group;
411: tme_uint8_t *bitmap_data;
412: unsigned int y;
413: const char *menu_label;
414: GtkSignalFunc menu_func;
415: int i;
416: #define BLANK_SIDE (16 * 8)
417:
418: /* create the new screen and link it in: */
419: for (_prev = &display->tme_gtk_display_screens;
420: (screen = *_prev) != NULL;
421: _prev = &screen->tme_gtk_screen_next);
422: screen = *_prev = tme_new0(struct tme_gtk_screen, 1);
423:
424: /* the backpointer to the display: */
425: screen->tme_gtk_screen_display = display;
426:
427: /* there is no framebuffer connection yet: */
428: screen->tme_gtk_screen_fb = NULL;
429:
430: /* the user hasn't specified a scaling yet: */
431: screen->tme_gtk_screen_fb_scale
432: = -TME_FB_XLAT_SCALE_NONE;
433:
434: /* XXX this should be controlled by an argument somewhere: */
435: screen->tme_gtk_screen_mono_invert_mask = 0xffff;
436:
437: /* create the top-level window, and allow it to shrink, grow,
438: and auto-shrink: */
439: screen->tme_gtk_screen_window
440: = gtk_window_new(GTK_WINDOW_TOPLEVEL);
441: gtk_window_set_policy(GTK_WINDOW(screen->tme_gtk_screen_window),
442: TRUE, TRUE, TRUE);
443:
444: /* create the outer vertical packing box: */
445: screen->tme_gtk_screen_vbox0
446: = gtk_vbox_new(FALSE, 0);
447:
448: /* add the outer vertical packing box to the window: */
449: gtk_container_add(GTK_CONTAINER(screen->tme_gtk_screen_window),
450: screen->tme_gtk_screen_vbox0);
451:
452: /* create the menu bar and pack it into the outer vertical packing
453: box: */
454: menu_bar = gtk_menu_bar_new ();
455: gtk_box_pack_start(GTK_BOX(screen->tme_gtk_screen_vbox0),
456: menu_bar,
457: FALSE, FALSE, 0);
458: gtk_widget_show(menu_bar);
459:
460: /* create the Screen menu: */
461: menu = gtk_menu_new();
462:
463: /* create the Screen scaling submenu: */
464: submenu = gtk_menu_new();
465:
466: /* create the Screen scaling submenu options: */
467: menu_group = NULL;
468: for (i = 0;; i++) {
469: if (i == 0) {
470: menu_label = _("Default");
471: _menu_item = &screen->tme_gtk_screen_scale_default;
472: menu_func = GTK_SIGNAL_FUNC(_tme_gtk_screen_scale_default);
473: }
474: else if (i == 1) {
475: menu_label = _("Half");
476: _menu_item = &screen->tme_gtk_screen_scale_half;
477: menu_func = GTK_SIGNAL_FUNC(_tme_gtk_screen_scale_half);
478: }
479: else if (i == 2) {
480: menu_label = _("Full");
481: _menu_item = NULL;
482: menu_func = GTK_SIGNAL_FUNC(_tme_gtk_screen_scale_none);
483: }
484: else if (i == 3) {
485: menu_label = _("Double");
486: _menu_item = NULL;
487: menu_func = GTK_SIGNAL_FUNC(_tme_gtk_screen_scale_double);
488: }
489: else {
490: break;
491: }
492: menu_item
493: = gtk_radio_menu_item_new_with_label(menu_group,
494: menu_label);
495: if (_menu_item != NULL) {
496: *_menu_item = menu_item;
497: }
498: menu_group
499: = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(menu_item));
500: gtk_signal_connect(GTK_OBJECT(menu_item),
501: "activate",
502: menu_func,
503: (gpointer) screen);
504: gtk_menu_append(GTK_MENU(submenu), menu_item);
505: gtk_widget_show(menu_item);
506: }
507:
508: /* create the Screen scaling submenu item: */
509: menu_item = gtk_menu_item_new_with_label(_("Scale"));
510: gtk_widget_show(menu_item);
511: gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), submenu);
512: gtk_menu_append(GTK_MENU(menu), menu_item);
513:
514: /* create the Screen menu bar item, attach the menu to it, and
515: attach the menu bar item to the menu bar: */
516: menu_item = gtk_menu_item_new_with_label("Screen");
517: gtk_widget_show(menu_item);
518: gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), menu);
519: gtk_menu_bar_append(GTK_MENU_BAR(menu_bar), menu_item);
520:
521: /* create an event box for the framebuffer area: */
522: screen->tme_gtk_screen_event_box
523: = gtk_event_box_new();
524:
525: /* pack the event box into the outer vertical packing box: */
526: gtk_box_pack_start(GTK_BOX(screen->tme_gtk_screen_vbox0),
527: screen->tme_gtk_screen_event_box,
528: FALSE, FALSE, 0);
529:
530: /* show the event box: */
531: gtk_widget_show(screen->tme_gtk_screen_event_box);
532:
533: /* create a GdkImage of an alternating-bits area. we must use
534: malloc() here since this memory will end up as part of an XImage,
535: and X will call free() on it: */
536: bitmap_data = (tme_uint8_t *)
537: malloc((BLANK_SIDE * BLANK_SIDE) / 8);
538: assert(bitmap_data != NULL);
539: for (y = 0;
540: y < BLANK_SIDE;
541: y++) {
542: memset(bitmap_data
543: + (y * BLANK_SIDE / 8),
544: (y & 1
545: ? 0x33
546: : 0xcc),
547: (BLANK_SIDE / 8));
548: }
549: screen->tme_gtk_screen_gdkimage
550: = gdk_image_new_bitmap(gdk_visual_get_system(),
551: bitmap_data,
552: BLANK_SIDE,
553: BLANK_SIDE);
554:
555: /* create the GtkImage for the framebuffer area: */
556: screen->tme_gtk_screen_gtkimage
557: = gtk_image_new_from_image(screen->tme_gtk_screen_gdkimage, NULL);
558:
559: /* add the GtkImage to the event box: */
560: gtk_container_add(GTK_CONTAINER(screen->tme_gtk_screen_event_box),
561: screen->tme_gtk_screen_gtkimage);
562:
563: /* show the GtkImage: */
564: gtk_widget_show(screen->tme_gtk_screen_gtkimage);
565:
566: /* show the outer vertical packing box: */
567: gtk_widget_show(screen->tme_gtk_screen_vbox0);
568:
569: /* show the top-level window: */
570: gtk_widget_show(screen->tme_gtk_screen_window);
571:
572: /* there is no translation function: */
573: screen->tme_gtk_screen_fb_xlat = NULL;
574:
575: /* attach the mouse to this screen: */
576: _tme_gtk_mouse_attach(screen);
577:
578: /* attach the keyboard to this screen: */
579: _tme_gtk_keyboard_attach(screen);
580:
581: return (screen);
582: }
583:
584: /* this breaks a framebuffer connection: */
585: static int
586: _tme_gtk_screen_connection_break(struct tme_connection *conn, unsigned int state)
587: {
588: abort();
589: }
590:
591: /* this makes a new framebuffer connection: */
592: static int
593: _tme_gtk_screen_connection_make(struct tme_connection *conn,
594: unsigned int state)
595: {
596: struct tme_gtk_display *display;
597: struct tme_gtk_screen *screen;
598: struct tme_fb_connection *conn_fb;
599: struct tme_fb_connection *conn_fb_other;
600:
601: /* recover our data structures: */
602: display = (struct tme_gtk_display *) conn->tme_connection_element->tme_element_private;
603: conn_fb = (struct tme_fb_connection *) conn;
604: conn_fb_other = (struct tme_fb_connection *) conn->tme_connection_other;
605:
606: /* both sides must be framebuffer connections: */
607: assert(conn->tme_connection_type
608: == TME_CONNECTION_FRAMEBUFFER);
609: assert(conn->tme_connection_other->tme_connection_type
610: == TME_CONNECTION_FRAMEBUFFER);
611:
612: /* we're always set up to answer calls across the connection, so we
613: only have to do work when the connection has gone full, namely
614: taking the other side of the connection: */
615: if (state == TME_CONNECTION_FULL) {
616:
617: /* lock our mutex: */
618: tme_mutex_lock(&display->tme_gtk_display_mutex);
619:
620: /* if our initial screen is already connected, make a new screen: */
621: screen = display->tme_gtk_display_screens;
622: if (screen->tme_gtk_screen_fb != NULL) {
623: screen = _tme_gtk_screen_new(display);
624: }
625:
626: /* save our connection: */
627: screen->tme_gtk_screen_fb = conn_fb;
628:
629: /* unlock our mutex: */
630: tme_mutex_unlock(&display->tme_gtk_display_mutex);
631:
632: /* call our mode change function: */
633: _tme_gtk_screen_mode_change(conn_fb);
634: }
635:
636: return (TME_OK);
637: }
638:
639: /* this makes a new connection side for a GTK screen: */
640: int
641: _tme_gtk_screen_connections_new(struct tme_gtk_display *display,
642: struct tme_connection **_conns)
643: {
644: struct tme_fb_connection *conn_fb;
645: struct tme_connection *conn;
646:
647: /* allocate a new framebuffer connection: */
648: conn_fb = tme_new0(struct tme_fb_connection, 1);
649: conn = &conn_fb->tme_fb_connection;
650:
651: /* fill in the generic connection: */
652: conn->tme_connection_next = *_conns;
653: conn->tme_connection_type = TME_CONNECTION_FRAMEBUFFER;
654: conn->tme_connection_score = tme_fb_connection_score;
655: conn->tme_connection_make = _tme_gtk_screen_connection_make;
656: conn->tme_connection_break = _tme_gtk_screen_connection_break;
657:
658: /* fill in the framebuffer connection: */
659: conn_fb->tme_fb_connection_mode_change = _tme_gtk_screen_mode_change;
660:
661: /* return the connection side possibility: */
662: *_conns = conn;
663:
664: /* done: */
665: return (TME_OK);
666: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.