コード例 #1
1
ファイル: GtkWnd.cpp プロジェクト: guowei8412/upp-mirror
void Ctrl::WndUpdate()
{
	GuiLock __;
	LLOG("WndUpdate0");
	gdk_window_process_updates(gdk(), TRUE);
	FetchEvents(FALSE); // Should pickup GDK_EXPOSE and repaint the window
	gdk_flush();
}
コード例 #2
0
static gboolean
manager_maybe_grab_window (GSManager *manager,
                           GSWindow  *window)
{
        GdkDisplay *display;
        GdkScreen  *screen;
        int         monitor;
        int         x, y;
        gboolean    grabbed;

        display = gdk_display_get_default ();
        gdk_display_get_pointer (display, &screen, &x, &y, NULL);
        monitor = gdk_screen_get_monitor_at_point (screen, x, y);

        gdk_flush ();
        grabbed = FALSE;
        if (gs_window_get_screen (window) == screen
            && gs_window_get_monitor (window) == monitor) {
                gs_debug ("Moving grab to %p", window);
                gs_grab_move_to_window (manager->priv->grab,
                                        gs_window_get_gdk_window (window),
                                        gs_window_get_screen (window),
                                        FALSE);
                grabbed = TRUE;
        }

        return grabbed;
}
コード例 #3
0
ファイル: launchgtk.c プロジェクト: cspiegel/garglk
static void winbrowsefile(char *buffer)
{
    *buffer = 0;

    GtkWidget * openDlg = gtk_file_chooser_dialog_new(AppName, NULL,
                                                      GTK_FILE_CHOOSER_ACTION_OPEN,
                                                      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                                      GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
                                                      NULL);

    if (getenv("GAMES"))
        gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(openDlg), getenv("GAMES"));
    else if (getenv("HOME"))
        gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(openDlg), getenv("HOME"));

    winfilterfiles(GTK_FILE_CHOOSER(openDlg));

    gint result = gtk_dialog_run(GTK_DIALOG(openDlg));

    if (result == GTK_RESPONSE_ACCEPT)
        strcpy(buffer, gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(openDlg)));

    gtk_widget_destroy(openDlg);
    gdk_flush();
}
コード例 #4
0
ファイル: ui_gtk.c プロジェクト: Keripo/ProjectZeroSlackr-SVN
/*
 * Since the NES does everything in eight bit index mode,
 * we need to translate that indexed framebuffer into our
 * native format for display.
 */
void video_display_buffer( void )
{
  int i;
  unsigned short* buffer_16;
  int num_pixels;

  switch( cur_image->bpp )
  {
  case 1:
    /* Empty. */
    break;
  case 2:
    buffer_16 = (unsigned short*) cur_image->mem;
    num_pixels = video_buffer_width * video_buffer_height;

    for( i = 0; i < num_pixels; ++i )
    {
      buffer_16[i] = translation_buffer_16[ (int) cur_video_buffer[i] ];
    }
    
    break;
  default:
    fprintf( stderr, "darcnes: unknown display depth %d in video_display_buffer()\n",
	     cur_image->bpp );
    break;
  }

  gdk_draw_image( nes_gtk_window->window, gc, cur_image, 0, 0, 0, 0, 
		  video_buffer_width, video_buffer_height );
  gdk_flush( );

  cur_image = ( cur_image == image_1 ) ? image_2 : image_1;
  cur_video_buffer = ( cur_video_buffer == video_buffer_1 ) ? video_buffer_2 : video_buffer_1;
}
コード例 #5
0
ファイル: RenderJob.cpp プロジェクト: wbrenna/xournalpp
	static bool idleRepaint(RepaintWidgetHandler * data) {
		g_mutex_lock(data->mutex);
		bool complete = data->complete;
		GList * rects = data->rects;

		data->rects = NULL;
		data->complete = false;
		data->rescaleId = 0;

		g_mutex_unlock(data->mutex);

		gdk_threads_enter();

		gtk_widget_queue_draw(data->widget);

		if(complete) {
//			gtk_widget_queue_draw(data->widget);
		} else {
			for (GList * l = rects; l != NULL; l = l->next) {
				Rectangle * rect = (Rectangle *) l->data;
//				gtk_widget_queue_draw_area(widget, rect->x, rect->y, rect->width, rect->height);
				delete rect;
			}
			g_list_free(rects);
		}

		gdk_flush();

		gdk_threads_leave();

		// do not call again
		return false;
	}
コード例 #6
0
ファイル: toolbar-gtk.c プロジェクト: boukeversteegh/chise
static void
gtk_clear_toolbar (struct frame *f, enum toolbar_pos pos, int thickness_change)
{
  Lisp_Object frame;
  int x, y, width, height, vert;

  get_toolbar_coords (f, pos, &x, &y, &width, &height, &vert, 1);
  XSETFRAME (frame, f);

  /* The thickness_change parameter is used by the toolbar resize routines
     to clear any excess toolbar if the size shrinks. */
  if (thickness_change < 0)
    {
      if (pos == LEFT_TOOLBAR || pos == RIGHT_TOOLBAR)
	{
	  x = x + width + thickness_change;
	  width = -thickness_change;
	}
      else
	{
	  y = y + height + thickness_change;
	  height = -thickness_change;
	}
    }

  SET_TOOLBAR_WAS_VISIBLE_FLAG (f, pos, 0);

  redisplay_clear_region (frame, DEFAULT_INDEX, x, y, width, height);
  gdk_flush ();
}
コード例 #7
0
ファイル: main.c プロジェクト: EchelonTeam/sca3_main
static void
init_display (GdkDisplay *dpy,
              XfceRc     *rc,
              gboolean disable_tcp)
{
  const gchar *engine;
  gint n;

  xfce_rc_set_group (rc, "Splash Screen");
  engine = xfce_rc_read_entry (rc, "Engine", NULL);

  splash_screen = xfsm_splash_screen_new (dpy, engine);  
  xfsm_splash_screen_next (splash_screen, _("Loading desktop settings"));

  gdk_flush ();

  xfce_rc_set_group (rc, "General");
  sm_init (rc, disable_tcp);
  
  /* start a MCS manager process per screen (FIXME: parallel to loading logo) */
  for (n = 0; n < gdk_display_get_n_screens (dpy); ++n)
    {
      mcs_client_check_manager (gdk_x11_display_get_xdisplay (dpy), n,
                                "xfce-mcs-manager");
    }

  /* gtk resource files may have changed */
  gtk_rc_reparse_all ();
}
コード例 #8
0
int XttHotkey::grab_key( int keysym, int modifier)
{
  GdkDisplay *display = gdk_display_get_default();
  int n_screens = gdk_display_get_n_screens( display);

  Display *dp = gdk_x11_display_get_xdisplay( display);
  int mode = GrabModeAsync;

  int keycode = XKeysymToKeycode( dp, keysym);
  if ( !keycode)
    return 0;

  gdk_error_trap_push();

  for ( int i = 0; i < n_screens; i++) {
    GdkWindow *root = gdk_screen_get_root_window( gdk_display_get_screen( display, i));
    Window w = gdk_x11_drawable_get_xid( root);

    XGrabKey( dp, keycode, modifier, w, True, mode, mode);
    XGrabKey( dp, keycode, modifier | LockMask, w, True, mode, mode);
    XGrabKey( dp, keycode, modifier | Mod2Mask, w, True, mode, mode);
    XGrabKey( dp, keycode, modifier | LockMask | Mod2Mask, w, True, mode, mode);
  }
  gdk_flush();
  gdk_error_trap_pop();
  return 1;
}
コード例 #9
0
ファイル: gtk_glue_agg_vaapi.cpp プロジェクト: aopui/gnash
void 
GtkAggVaapiGlue::beforeRendering(movie_root* stage)
{
    // Process all GDK pending operations
    gdk_flush();

    if (USE_HW_SCALING) {

        static bool first = true;
        if (first && stage) {
            first = false;

            Movie const & mi = stage->getRootMovie();
            const unsigned int width  = mi.widthPixels();
            const unsigned int height = mi.heightPixels();
            resetRenderSurface(width, height);
            dprintf("GtkAggVaapiGlue::beforeRendering(): movie size %dx%d\n",
                    width, height);
        }

        // We force the scale to its original state in case the GUI
        // changed it (in the event of a resize), because we want
        // VA-API to do the scaling for us.
        _agg_renderer->set_scale(1.0, 1.0);
    }
    else if (_vaapi_image_width != _window_width ||
             _vaapi_image_height != _window_height)
        resetRenderSurface(_window_width, _window_height);

    if (!_vaapi_image->map()) {
        log_error(_("failed to map VA-API image."));
        return;
    }
}
コード例 #10
0
ファイル: tray.c プロジェクト: electricface/dde
GdkWindow* create_wrapper(GdkWindow* parent, Window tray_icon)
{
    gdk_flush();
    GdkWindow* icon = gdk_x11_window_foreign_new_for_display(gdk_display_get_default(), tray_icon);
    if (icon == NULL)
        return NULL;
    GdkVisual* visual = gdk_window_get_visual(icon);
    GdkWindow* wrapper = NULL;
    if (gdk_visual_get_depth(visual) == 24) {
        GdkWindowAttr attributes;
        attributes.width = DEFAULT_HEIGHT;
        attributes.height = DEFAULT_HEIGHT;
        attributes.window_type = GDK_WINDOW_CHILD;
        attributes.wclass = GDK_INPUT_OUTPUT;
        attributes.event_mask = GDK_ALL_EVENTS_MASK;
        attributes.visual = visual;
        wrapper = gdk_window_new(parent, &attributes, GDK_WA_VISUAL);
        //TODO: there should set color correspond by dock background color
        /*GdkColor color = {1, 0, 0, 1};*/
        /*gdk_window_set_background_rgba(wrapper, &color);*/

        XReparentWindow(gdk_x11_get_default_xdisplay(),
                tray_icon,
                GDK_WINDOW_XID(wrapper),
                0, 0);
        gdk_window_show(icon);
        g_object_set_data(G_OBJECT(wrapper), "wrapper_child", icon);
        g_object_set_data(G_OBJECT(icon), "wrapper_parent", wrapper);
    } else {
        wrapper = icon;
    }
    return wrapper;
}
コード例 #11
0
ファイル: nemo-desktop-manager.c プロジェクト: Seb35/nemo
static void
create_new_desktop_window (NemoDesktopManager *manager,
                                         gint  monitor,
                                     gboolean  primary,
                                     gboolean  show_desktop)
{
    GtkWidget *window;

    DesktopInfo *info = g_slice_new0 (DesktopInfo);

    info->monitor_num = monitor;
    info->shows_desktop = show_desktop;
    info->is_primary = primary;

    if (show_desktop) {
        window = GTK_WIDGET (nemo_desktop_window_new (monitor));
    } else {
        window = GTK_WIDGET (nemo_blank_desktop_window_new (monitor));
    }

    info->window = window;

    /* We realize it immediately so that the NEMO_DESKTOP_WINDOW_ID
       property is set so gnome-settings-daemon doesn't try to set the
       background. And we do a gdk_flush() to be sure X gets it. */

    gtk_widget_realize (GTK_WIDGET (window));
    gdk_flush ();

    gtk_application_add_window (GTK_APPLICATION (nemo_application_get_singleton ()),
                                GTK_WINDOW (window));

    manager->desktops = g_list_append (manager->desktops, info);
}
コード例 #12
0
void
panel_force_quit (GdkScreen *screen,
		  guint      time)
{
	GdkGrabStatus  status;
	GdkCursor     *cross;
	GtkWidget     *popup;
	GdkWindow     *root;

	popup = display_popup_window (screen);

	root = gdk_screen_get_root_window (screen);

	gdk_window_add_filter (root, (GdkFilterFunc) popup_filter, popup);

	cross = gdk_cursor_new (GDK_CROSS);
	status = gdk_pointer_grab (root, FALSE, GDK_BUTTON_PRESS_MASK,
				   NULL, cross, time);
	gdk_cursor_unref (cross);
	if (status != GDK_GRAB_SUCCESS) {
		g_warning ("Pointer grab failed\n");
		remove_popup (popup);
		return;
	}

	status = gdk_keyboard_grab (root, FALSE, time);
	if (status != GDK_GRAB_SUCCESS) {
		g_warning ("Keyboard grab failed\n");
		remove_popup (popup);
		return;
	}

	gdk_flush ();
}
コード例 #13
0
ファイル: panel-util.c プロジェクト: braikar/mate-panel
void
panel_push_window_busy (GtkWidget *window)
{
	int busy = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (window),
						       "Panel:WindowBusy"));

	busy ++;

	if (busy == 1) {
		GdkWindow *win;

		gtk_widget_set_sensitive (window, FALSE);

		win = gtk_widget_get_window (window);
		if (win != NULL) {
			GdkCursor *cursor = gdk_cursor_new (GDK_WATCH);
			gdk_window_set_cursor (win, cursor);
#if GTK_CHECK_VERSION (3, 0, 0)
			g_object_unref (cursor);
#else
			gdk_cursor_unref (cursor);
#endif
			gdk_flush ();
		}
	}

	g_object_set_data (G_OBJECT (window), "Panel:WindowBusy",
			   GINT_TO_POINTER (busy));
}
コード例 #14
0
ファイル: icon.c プロジェクト: atsampson/rox-filer
/* Stolen from xfwm4 and modified.
 * FALSE on error. Call initModifiers before this.
 */
static gboolean grabKey(MyKey *key)
{
	Window root;
	Display *dpy = GDK_DISPLAY();
	static gboolean need_init = TRUE;

	if (need_init)
	{
		need_init = FALSE;
		gdk_window_add_filter(gdk_get_default_root_window(),
				filter_keys, NULL);
	}

	gdk_error_trap_push();

	root = GDK_ROOT_WINDOW();

	GRAB(key, 0);

	/* Here we grab all combinations of well known modifiers */
	GRAB(key, ScrollLockMask);
	GRAB(key, NumLockMask);
	GRAB(key, CapsLockMask);
	GRAB(key, ScrollLockMask | NumLockMask);
	GRAB(key, ScrollLockMask | CapsLockMask);
	GRAB(key, CapsLockMask | NumLockMask);
	GRAB(key, ScrollLockMask | CapsLockMask | NumLockMask);

	gdk_flush();
	return gdk_error_trap_pop() == Success;
}
コード例 #15
0
static gboolean
manager_maybe_grab_window (GSManager *manager,
                           GSWindow  *window)
{
        GdkDisplay *display;
        GdkScreen  *screen;
        int         monitor;
        int         x, y;
        gboolean    grabbed;

        display = gdk_display_get_default ();
#if GTK_CHECK_VERSION(3, 0, 0)
        GdkDeviceManager *device_manager = gdk_display_get_device_manager (display);
        GdkDevice *pointer = gdk_device_manager_get_client_pointer (device_manager);
        gdk_device_get_position (pointer, &screen, &x, &y);
#else
        gdk_display_get_pointer (display, &screen, &x, &y, NULL);
#endif
        monitor = gdk_screen_get_monitor_at_point (screen, x, y);

        gdk_flush ();
        grabbed = FALSE;
        if (gs_window_get_screen (window) == screen
            && gs_window_get_monitor (window) == monitor) {
                gs_debug ("Moving grab to %p", window);
                gs_grab_move_to_window (manager->priv->grab,
                                        gs_window_get_gdk_window (window),
                                        gs_window_get_screen (window),
                                        TRUE);
                grabbed = TRUE;
        }

        return grabbed;
}
コード例 #16
0
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_gdkDrawDrawable
  (JNIEnv *env, jobject self, jobject other, jint x, jint y)
{
  struct graphics2d *src = NULL, *dst = NULL;
  gint s_height, s_width, d_height, d_width, height, width;
  GdkGC *gc;

  src = (struct graphics2d *)NSA_GET_G2D_PTR (env, other);
  dst = (struct graphics2d *)NSA_GET_G2D_PTR (env, self);
  g_assert (src != NULL);
  g_assert (dst != NULL);  

  if (src->debug) printf ("copying from offscreen drawable\n");

  gdk_threads_enter ();
  gdk_drawable_get_size (src->drawable, &s_width, &s_height);
  gdk_drawable_get_size (dst->drawable, &d_width, &d_height);
  width = min (s_width, d_width);
  height = min (s_width, d_height);

  gc = gdk_gc_new (dst->drawable);
  g_assert (gc != NULL);

  gdk_draw_drawable(dst->drawable, gc, src->drawable, 
 		    0, 0, x, y, width, height); 
  gdk_flush ();

  g_object_unref (gc);

  if (src->debug) printf ("copied %d x %d pixels from offscreen drawable\n", width, height);
  gdk_threads_leave ();  
}
コード例 #17
0
void layer_new_mouse(void)
{
	// Local variables
	GdkCursor			*selection_cursor;			// Holds the new temporary selection cursor


	// If no project is loaded then don't run this function
	if (NULL == get_current_slide())
	{
		// Make a beep, then return
		gdk_beep();
		return;
	}

	// Change the focus of the window to be this widget
	set_delete_focus(FOCUS_LAYER);

	// Change the cursor to something suitable
	selection_cursor = gdk_cursor_new(GDK_CROSSHAIR);
	gdk_window_set_cursor(get_main_drawing_area()->window, selection_cursor);
	gdk_cursor_unref(selection_cursor);

	// Set a toggle so the release button callback will know to do the rest
	set_new_layer_selected(TYPE_MOUSE_CURSOR);

	// Update the status bar
	gtk_progress_bar_set_text(GTK_PROGRESS_BAR(get_status_bar()), _(" Please click the insertion point"));
	gdk_flush();
}
コード例 #18
0
ファイル: crash.c プロジェクト: SpOOnman/claws
/*!
 *\brief	this handler will probably evolve into 
 *		something better.
 */
static void crash_handler(int sig)
{
	pid_t pid;
	static volatile unsigned long crashed_ = 0;

	/*
	 * let's hope argv0 aren't trashed.
	 * both are defined in main.c.
	 */
	extern gchar *argv0;


	/*
	 * besides guarding entrancy it's probably also better 
	 * to mask off signals
	 */
	if (crashed_) return;

	crashed_++;

#ifdef SIGTERM
	if (sig == SIGTERM) 
		clean_quit(NULL);
#endif

	/*
	 * gnome ungrabs focus, and flushes gdk. mmmh, good idea.
	 */
	gdk_pointer_ungrab(GDK_CURRENT_TIME);
	gdk_keyboard_ungrab(GDK_CURRENT_TIME);
	gdk_flush();

	if (0 == (pid = fork())) {
		char buf[50];
		char *args[5];
	
		/*
		 * probably also some other parameters (like GTK+ ones).
		 * also we pass the full startup dir and the real command
		 * line typed in (argv0)
		 */
		args[0] = argv0; 
		args[1] = "--debug";
		args[2] = "--crash";
		sprintf(buf, "%d,%d,%s", getppid(), sig, argv0);
		args[3] = buf;
		args[4] = NULL;

		chdir(claws_get_startup_dir());
		setgid(getgid());
		setuid(getuid());
		execvp(argv0, args);
	} else {
		waitpid(pid, NULL, 0);
		crash_cleanup_exit();
		_exit(253);
	}

	_exit(253);
}
コード例 #19
0
static gboolean
gs_grab_move_keyboard (GSGrab    *grab,
                       GdkWindow *window,
                       GdkScreen *screen)
{
    gboolean   result;
    GdkWindow *old_window;
    GdkScreen *old_screen;

    if (grab->priv->keyboard_grab_window == window)
    {
        gs_debug ("Window %X is already grabbed, skipping",
                  (guint32) GDK_WINDOW_XID (grab->priv->keyboard_grab_window));
        return TRUE;
    }

    if (grab->priv->keyboard_grab_window != NULL)
    {
        gs_debug ("Moving keyboard grab from %X to %X",
                  (guint32) GDK_WINDOW_XID (grab->priv->keyboard_grab_window),
                  (guint32) GDK_WINDOW_XID (window));
    }
    else
    {
        gs_debug ("Getting keyboard grab on %X",
                  (guint32) GDK_WINDOW_XID (window));

    }

    gs_debug ("*** doing X server grab");
    gdk_x11_grab_server ();

    old_window = grab->priv->keyboard_grab_window;
    old_screen = grab->priv->keyboard_grab_screen;

    if (old_window)
    {
        gs_grab_release_keyboard (grab);
    }

    result = gs_grab_get_keyboard (grab, window, screen);

    if (result != GDK_GRAB_SUCCESS)
    {
        sleep (1);
        result = gs_grab_get_keyboard (grab, window, screen);
    }

    if ((result != GDK_GRAB_SUCCESS) && old_window)
    {
        gs_debug ("Could not grab keyboard for new window.  Resuming previous grab.");
        gs_grab_get_keyboard (grab, old_window, old_screen);
    }

    gs_debug ("*** releasing X server grab");
    gdk_x11_ungrab_server ();
    gdk_flush ();

    return (result == GDK_GRAB_SUCCESS);
}
コード例 #20
0
static void
gs_theme_engine_clear (GtkWidget *widget)
{
	GdkColor     color = { 0, 0x0000, 0x0000, 0x0000 };
	GdkColormap *colormap;
	GtkStateType state;

	g_return_if_fail (GS_IS_THEME_ENGINE (widget));

	if (! GTK_WIDGET_VISIBLE (widget))
	{
		return;
	}

	state = (GtkStateType) 0;
	while (state < (GtkStateType) G_N_ELEMENTS (widget->style->bg))
	{
		gtk_widget_modify_bg (widget, state, &color);
		state++;
	}

	colormap = gdk_drawable_get_colormap (widget->window);
	gdk_colormap_alloc_color (colormap, &color, FALSE, TRUE);
	gdk_window_set_background (widget->window, &color);
	gdk_window_clear (widget->window);
	gdk_flush ();
}
コード例 #21
0
static KeyCode grab_key(char *keystring)
{
	KeySym sym;
	KeyCode code;
	gint i;

	if ((sym = XStringToKeysym(keystring)) == NoSymbol)
		return 0;
	if ((code = XKeysymToKeycode(GDK_DISPLAY(), sym)) == 0)
		return 0;

	gdk_error_trap_push();
	for (i = 0; i < ScreenCount(GDK_DISPLAY()); i++) {
		XGrabKey(GDK_DISPLAY(), code,
				AnyModifier, RootWindow(GDK_DISPLAY(),i),
				1, GrabModeAsync, GrabModeAsync);
	}

	gdk_flush();
	if (gdk_error_trap_pop()) {
		g_warning("Couldn't grab %s: another client may already have done so",
				keystring);
		return 0;
	}
	return code;
}
コード例 #22
0
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_gdkDrawDrawable
  (JNIEnv *env, jobject self, jobject other, jint x, jint y)
{
  struct graphics2d *src = NULL, *dst = NULL;
  gint s_height, s_width, d_height, d_width, height, width;
  cairo_matrix_t *matrix;
  cairo_operator_t tmp_op;

  gdk_threads_enter();
  if (peer_is_disposed(env, self)) { gdk_threads_leave(); return; }
  src = (struct graphics2d *)NSA_GET_G2D_PTR (env, other);
  dst = (struct graphics2d *)NSA_GET_G2D_PTR (env, self);
  g_assert (src != NULL);
  g_assert (dst != NULL);  

  if (src->debug) printf ("copying from offscreen drawable\n");

  begin_drawing_operation(dst); 

  gdk_flush();

  gdk_drawable_get_size (src->drawable, &s_width, &s_height);
  gdk_drawable_get_size (dst->drawable, &d_width, &d_height);
  width = min (s_width, d_width);
  height = min (s_height, d_height);

  matrix = cairo_matrix_create ();
  cairo_surface_get_matrix (src->surface, matrix);
  cairo_matrix_translate (matrix, (double)-x, (double)-y);
  cairo_surface_set_matrix (src->surface, matrix);

  tmp_op = cairo_current_operator (dst->cr); 
  cairo_set_operator(dst->cr, CAIRO_OPERATOR_SRC); 
  cairo_show_surface (dst->cr, src->surface, width, height);
  cairo_set_operator(dst->cr, tmp_op);

  cairo_matrix_translate (matrix, (double)x, (double)y);
  cairo_surface_set_matrix (src->surface, matrix);
  cairo_matrix_destroy (matrix);

  gdk_flush();

  end_drawing_operation(dst);

  if (src->debug) printf ("copied %d x %d pixels from offscreen drawable\n", width, height);
  gdk_threads_leave();
}
コード例 #23
0
static gboolean
matecomponent_plug_button_event (GtkWidget      *widget,
			  GdkEventButton *event)
{
#if defined (GDK_WINDOWING_X11)
	XEvent xevent;
#endif

	g_return_val_if_fail (MATECOMPONENT_IS_PLUG (widget), FALSE);

	if (!MATECOMPONENT_PLUG (widget)->priv->forward_events || !GTK_WIDGET_TOPLEVEL (widget))
		return FALSE;

#if defined (GDK_WINDOWING_X11)

	if (event->type == GDK_BUTTON_PRESS) {
		xevent.xbutton.type = ButtonPress;

		/* X does an automatic pointer grab on button press
		 * if we have both button press and release events
		 * selected.
		 * We don't want to hog the pointer on our parent.
		 */
		gdk_display_pointer_ungrab
			(gtk_widget_get_display (widget),
			 GDK_CURRENT_TIME);
	} else
		xevent.xbutton.type = ButtonRelease;
    
	xevent.xbutton.display     = GDK_WINDOW_XDISPLAY (widget->window);
	xevent.xbutton.window      = GDK_WINDOW_XWINDOW (GTK_PLUG (widget)->socket_window);
	xevent.xbutton.root        = GDK_WINDOW_XWINDOW (gdk_screen_get_root_window
							 (gdk_drawable_get_screen (widget->window)));
	/*
	 * FIXME: the following might cause
	 *        big problems for non-GTK apps
	 */
	xevent.xbutton.x           = 0;
	xevent.xbutton.y           = 0;
	xevent.xbutton.x_root      = 0;
	xevent.xbutton.y_root      = 0;
	xevent.xbutton.state       = event->state;
	xevent.xbutton.button      = event->button;
	xevent.xbutton.same_screen = TRUE; /* FIXME ? */

	gdk_error_trap_push ();

	XSendEvent (GDK_WINDOW_XDISPLAY (widget->window),
		    GDK_WINDOW_XWINDOW (GTK_PLUG (widget)->socket_window),
		    False, NoEventMask, &xevent);

	gdk_flush ();
	gdk_error_trap_pop ();

#elif defined (GDK_WINDOWING_WIN32)
	/* FIXME: Need to do something? */
#endif
	return TRUE;
}
コード例 #24
0
ファイル: gui-vtable.c プロジェクト: 1ynx/gimp
static void
gui_unset_busy (Gimp *gimp)
{
  gimp_displays_unset_busy (gimp);
  gimp_dialog_factory_unset_busy (gimp_dialog_factory_get_singleton ());

  gdk_flush ();
}
コード例 #25
0
ファイル: mt-main.c プロジェクト: Kristishka/mousetweaks
static void
mt_main_generate_motion_event (GdkScreen *screen, gint x, gint y)
{
    gdk_error_trap_push ();
    gdk_display_warp_pointer (gdk_display_get_default (), screen, x, y);
    gdk_flush ();
    gdk_error_trap_pop ();
}
コード例 #26
0
ファイル: gui-vtable.c プロジェクト: jdburton/gimp-osx
static void
gui_unset_busy (Gimp *gimp)
{
  gimp_displays_unset_busy (gimp);
  gimp_dialog_factories_unset_busy ();

  gdk_flush ();
}
コード例 #27
0
ファイル: uimon.c プロジェクト: bobsummerwill/VICE
console_t *uimon_window_resume(void)
{
    gtk_widget_show_all(fixed.window);
    gtk_window_present (GTK_WINDOW(fixed.window));
    ui_dispatch_events();
    gdk_flush();
    return &vte_console;
}
コード例 #28
0
nsresult nsPluginNativeWindowGtk2::CreateXEmbedWindow() {
  NS_ASSERTION(!mSocketWidget,"Already created a socket widget!");

  GdkWindow *parent_win = gdk_window_lookup((XID)window);
  mSocketWidget = gtk_socket_new();

  //attach the socket to the container widget
  gtk_widget_set_parent_window(mSocketWidget, parent_win);

  // Make sure to handle the plug_removed signal.  If we don't the
  // socket will automatically be destroyed when the plug is
  // removed, which means we're destroying it more than once.
  // SYNTAX ERROR.
  g_signal_connect(mSocketWidget, "plug_removed",
                   G_CALLBACK(plug_removed_cb), NULL);

  g_signal_connect(mSocketWidget, "unrealize",
                   G_CALLBACK(socket_unrealize_cb), NULL);

  g_signal_connect(mSocketWidget, "destroy",
                   G_CALLBACK(gtk_widget_destroyed), &mSocketWidget);

  gpointer user_data = NULL;
  gdk_window_get_user_data(parent_win, &user_data);

  GtkContainer *container = GTK_CONTAINER(user_data);
  gtk_container_add(container, mSocketWidget);
  gtk_widget_realize(mSocketWidget);

  // The GtkSocket has a visible window, but the plugin's XEmbed plug will
  // cover this window.  Normally GtkSockets let the X server paint their
  // background and this would happen immediately (before the plug is
  // created).  Setting the background to None prevents the server from
  // painting this window, avoiding flicker.
  gdk_window_set_back_pixmap(mSocketWidget->window, NULL, FALSE);

  // Resize before we show
  SetAllocation();

  gtk_widget_show(mSocketWidget);

  gdk_flush();
  window = (void*)gtk_socket_get_id(GTK_SOCKET(mSocketWidget));

  // Fill out the ws_info structure.
  // (The windowless case is done in nsObjectFrame.cpp.)
  GdkWindow *gdkWindow = gdk_window_lookup((XID)window);
  if(!gdkWindow)
    return NS_ERROR_FAILURE;

  mWsInfo.display = GDK_WINDOW_XDISPLAY(gdkWindow);
  mWsInfo.colormap = GDK_COLORMAP_XCOLORMAP(gdk_drawable_get_colormap(gdkWindow));
  GdkVisual* gdkVisual = gdk_drawable_get_visual(gdkWindow);
  mWsInfo.visual = GDK_VISUAL_XVISUAL(gdkVisual);
  mWsInfo.depth = gdkVisual->depth;

  return NS_OK;
}
コード例 #29
0
ファイル: fftscope.c プロジェクト: RafaelRMachado/alsaplayer
/* Init function. Here we setup all the gtk stuff */
static GtkWidget *init_fftscope_window()
{
	GtkWidget *fftscope_win;
	GtkStyle *style;
	GdkColor color;
	guint32 colors[129];
	int i;

	pthread_mutex_init(&fftscope_mutex, NULL);

	style = gtk_style_new();
	fftscope_win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(fftscope_win), "FFTscope");
	gtk_widget_set_usize(fftscope_win, 256, SCOPE_HEIGHT);
	gtk_window_set_wmclass(GTK_WINDOW(fftscope_win), "FFTscope",
			       "AlsaPlayer");
	gtk_window_set_policy(GTK_WINDOW(fftscope_win), FALSE, FALSE,
			      FALSE);
	style =
	    gtk_style_copy(gtk_widget_get_style(GTK_WIDGET(fftscope_win)));

	color.red = SCOPE_BG_RED << 8;
	color.blue = SCOPE_BG_BLUE << 8;
	color.green = SCOPE_BG_GREEN << 8;
	gdk_color_alloc(gdk_colormap_get_system(), &color);
	gtk_widget_set_style(GTK_WIDGET(fftscope_win), style);

	for (i = 0; i < 32; i++) {
		colors[i * 2] = colors[i * 2 + 1] =
		    ((i * 8) << 16) + (255 << 8);
		colors[i * 2 + 64] = colors[i * 2 + 65] =
		    (255 << 16) + (((31 - i) * 8) << 8);
	}
	colors[128] = 0;
	color_map = gdk_rgb_cmap_new(colors, 129);
	area = gtk_drawing_area_new();
	gtk_container_add(GTK_CONTAINER(fftscope_win), area);
	gtk_widget_realize(area);
	gdk_window_set_background(area->window, &color);

	gtk_widget_show(area);
	gtk_widget_show(fftscope_win);

	/* Signals */

	gtk_signal_connect(GTK_OBJECT(fftscope_win), "delete_event",
			   GTK_SIGNAL_FUNC(close_fftscope_window),
			   fftscope_win);


	/* Clear and show the window */
	gdk_window_clear(fftscope_win->window);
	gdk_flush();

	ready_state = 1;

	return fftscope_win;
}
コード例 #30
0
ファイル: dock.c プロジェクト: oberon2007/dde-workspace
void _update_dock_size(gint16 x, gint16 y, guint16 w, guint16 h)
{
    GdkGeometry geo = {0};
    geo.min_width = 0;
    geo.min_height = 0;

    gdk_window_set_geometry_hints(WEBVIEW_GDK_WINDOW(), &geo, GDK_HINT_MIN_SIZE);
    gdk_window_set_geometry_hints(DOCK_GDK_WINDOW(), &geo, GDK_HINT_MIN_SIZE);
    gdk_flush();

    g_debug("[%s] %dx%d(%d, %d)", __func__, w, h, x, y);
    gdk_window_move_resize(DOCK_GDK_WINDOW(), x, y, w, h);
    gdk_window_move_resize(WEBVIEW_GDK_WINDOW(), 0, 0, w, h);

    gdk_flush();

    dock_change_workarea_height(GD.dock_height);
}