コード例 #1
0
/* FlashWindowEx is only supported by Win98+ and WinNT5+. If its
   not supported we do it our own way */
void wgaim_conv_im_blink(GtkWidget *window) {
        if(!blink_turned_on)
                return;
	if(MyFlashWindowEx) {
		FLASHWINFO info;
                if(GetForegroundWindow() == GDK_WINDOW_HWND(window->window))
                        return;
                memset(&info, 0, sizeof(FLASHWINFO));
		info.cbSize = sizeof(FLASHWINFO);
		info.hwnd = GDK_WINDOW_HWND(window->window);
		info.dwFlags = FLASHW_ALL | FLASHW_TIMER;
		info.dwTimeout = 0;
		MyFlashWindowEx(&info);
                /* Stop flashing when window receives focus */
                g_signal_connect(G_OBJECT(window), 
                                 "focus-in-event", 
                                 G_CALLBACK(halt_flash_filter), info.hwnd);
	}
	else {
		WGAIM_FLASH_INFO *finfo = g_new0(WGAIM_FLASH_INFO, 1);

		/* Start Flashing window */
		finfo->t_handle = gaim_timeout_add(1000, 
						flash_window_cb, 
						GDK_WINDOW_HWND(window->window));
		finfo->sig_handler = g_signal_connect(G_OBJECT(window), 
						      "focus-in-event", 
						      G_CALLBACK(halt_flash_filter), finfo);
	}
}
コード例 #2
0
ファイル: gtkmedia.c プロジェクト: gotomypc/pidgin_whiteboard
static gboolean
realize_cb_cb(PidginMediaRealizeData *data)
{
	PidginMediaPrivate *priv = data->gtkmedia->priv;
	gulong window_id;

#ifdef _WIN32
	if (data->participant == NULL)
		window_id = GDK_WINDOW_HWND(priv->local_video->window);
	else
		window_id = GDK_WINDOW_HWND(priv->remote_video->window);
#elif defined(HAVE_X11)
	if (data->participant == NULL)
		window_id = GDK_WINDOW_XWINDOW(priv->local_video->window);
	else
		window_id = GDK_WINDOW_XWINDOW(priv->remote_video->window);
#else
#	error "Unsupported windowing system"
#endif

	purple_media_set_output_window(priv->media, data->session_id,
			data->participant, window_id);

	g_free(data->session_id);
	g_free(data->participant);
	g_free(data);
	return FALSE;
}
コード例 #3
0
ファイル: glc_gtk.cpp プロジェクト: npapier/oglpp
/**
 * @todo Only from a gtk drawing area ?
 */
glc_drawable_t * glc_gtk_drawable_create( GtkDrawingArea * drawingArea )
{
	assert( drawingArea != 0 && "Calls glc_gtk_drawable_create() with an null drawing area." );

	// Retrieves the window of the drawing area
	GdkWindow *gdkWindow = GTK_WIDGET(drawingArea)->window;

	if( gdkWindow == 0 )
	{
		return 0;
	}
// gdk_window_ensure_native() available from 2.18.0
#if GTKMM_VERSION >= 2180
	else
	{
		// Ensure the gdk window is a window-system native window
		const gboolean isNative = gdk_window_ensure_native( gdkWindow );
		if ( isNative == FALSE )
		{
			assert( false && "Unable to ensure a window-sytem native window" );
			return 0;
		}
		else
		{
	#ifdef WIN32
			EnableWindow( (GLC_WINDOW_HANDLE) GDK_WINDOW_HWND( gdkWindow ), FALSE );
	#endif
		}
	}
#endif

	glc_drawable_t *drawable = (glc_drawable_t*) malloc( sizeof(glc_drawable_t) );
	assert( drawable != 0 && "Unable to allocate glc_drawable_t." );

	// Turns off the double buffering of the widget
	// So clearing to the background color or pixmap will no more happen automatically.
	gtk_widget_set_double_buffered( GTK_WIDGET(drawingArea), FALSE );

	// Initializes the drawable
#ifdef WIN32
	drawable->window	= (GLC_WINDOW_HANDLE) GDK_WINDOW_HWND( gdkWindow );
	drawable->dc		= GetDC( drawable->window );
#else
	#error "Non win32 platform not yet supported."
#endif
	drawable->backend			= (drawable_backend_t*) malloc( sizeof(drawable_backend_t) );
	drawable->backend->destroy	= &glc_gtk_drawable_destroy;

	_glc_drawable_initialize( drawable );

	// @todo glc_gtk_drawable_status()
	assert( drawable->window != 0 );
	assert( drawable->dc != 0 );
	assert( drawable->backend != 0 );

	return drawable;
}
コード例 #4
0
ファイル: xp_theme.c プロジェクト: Aridna/gtk2
gboolean
xp_theme_draw (GdkWindow *win, XpThemeElement element, GtkStyle *style,
	       int x, int y, int width, int height,
	       GtkStateType state_type, GdkRectangle *area)
{
  HTHEME theme;
  RECT rect, clip, *pClip;
  HDC dc;
  XpDCInfo dc_info;
  int part_state;

  if (!xp_theme_is_drawable (element))
    return FALSE;

  theme = xp_theme_get_handle_by_element (element);
  if (!theme)
    return FALSE;

  /* FIXME: Recheck its function */
  if (GDK_IS_WINDOW (win) && gdk_win32_window_is_win32 (win))
  enable_theme_dialog_texture_func (GDK_WINDOW_HWND (win), ETDT_ENABLETAB);

  dc = get_window_dc (style, win, state_type, &dc_info,
		      x, y, width, height,
		      &rect);
  if (!dc)
    return FALSE;

  if (area)
    {
      clip.left = area->x - dc_info.x_offset;
      clip.top = area->y - dc_info.y_offset;
      clip.right = clip.left + area->width;
      clip.bottom = clip.top + area->height;

      pClip = &clip;
    }
  else
    {
      pClip = NULL;
    }

  part_state = xp_theme_map_gtk_state (element, state_type);

  /* Support transparency */
  if (is_theme_partially_transparent_func (theme, element_part_map[element], part_state))
    draw_theme_parent_background_func (GDK_WINDOW_HWND (win), dc, pClip);

  draw_theme_background_func (theme, dc, element_part_map[element],
			      part_state, &rect, pClip);

  release_window_dc (&dc_info);

  return TRUE;
}
コード例 #5
0
ファイル: gdkgeometry-win32.c プロジェクト: Aridna/gtk2
void
_gdk_window_move_resize_child (GdkWindow *window,
			       gint       x,
			       gint       y,
			       gint       width,
			       gint       height)
{
  GdkWindowImplWin32 *impl;
  GdkWindowObject *obj;

  g_return_if_fail (window != NULL);
  g_return_if_fail (GDK_IS_WINDOW (window));

  obj = GDK_WINDOW_OBJECT (window);
  impl = GDK_WINDOW_IMPL_WIN32 (obj->impl);

  GDK_NOTE (MISC, g_print ("_gdk_window_move_resize_child: %s@%+d%+d %dx%d@%+d%+d\n",
			   _gdk_win32_drawable_description (window),
			   obj->x, obj->y, width, height, x, y));

  if (width > 65535 || height > 65535)
  {
    g_warning ("Native children wider or taller than 65535 pixels are not supported.");

    if (width > 65535)
      width = 65535;
    if (height > 65535)
      height = 65535;
  }

  obj->x = x;
  obj->y = y;
  obj->width = width;
  obj->height = height;

  _gdk_win32_window_tmp_unset_parent_bg (window);
  _gdk_win32_window_tmp_unset_bg (window, TRUE);
  
  GDK_NOTE (MISC, g_print ("... SetWindowPos(%p,NULL,%d,%d,%d,%d,"
			   "NOACTIVATE|NOZORDER)\n",
			   GDK_WINDOW_HWND (window),
			   obj->x + obj->parent->abs_x, obj->y + obj->parent->abs_y, 
			   width, height));

  API_CALL (SetWindowPos, (GDK_WINDOW_HWND (window), NULL,
			   obj->x + obj->parent->abs_x, obj->y + obj->parent->abs_y, 
			   width, height,
			   SWP_NOACTIVATE | SWP_NOZORDER));

  //_gdk_win32_window_tmp_reset_parent_bg (window);
  _gdk_win32_window_tmp_reset_bg (window, TRUE);
}
コード例 #6
0
ファイル: dbg_wnds.c プロジェクト: TI8XEmulator/graph89
/* 
	This function exists because GDK retrieves client coordinates, not window ones.
	(Kevin: GDK uses GetClientRect and ClientToScreen).
	We need that to save and restore windows position.
*/
void window_get_rect(GtkWidget *widget, GdkRect *rect)
{
	gtk_window_get_size(GTK_WINDOW(widget), &rect->w, &rect->h);

#ifdef __WIN32__
	{
		BOOL bResult;
		HWND hWnd = GDK_WINDOW_HWND(widget->window);
		RECT lpRect;
		GdkRectangle gdkRect;

		bResult = GetWindowRect(hWnd, &lpRect);

		rect->x = lpRect.left;
		rect->y = lpRect.top;

		// Now obtain and add the offset between GDK and Win32 coordinates
		// (in the multi-screen case).
		gdk_screen_get_monitor_geometry(gdk_screen_get_default(), 0, &gdkRect);
		rect->x += gdkRect.x;
		rect->y += gdkRect.y;
	}
#else
	gdk_window_get_position(widget->window, &rect->x, &rect->y);
#endif
}
コード例 #7
0
ファイル: selection.c プロジェクト: fujii/ebview
void auto_lookup_start()
{
	
	if(selection_mode == SELECTION_DO_NOTHING)
		return;
	
#ifdef __WIN32__
	if(registered == FALSE) {
		if(OrgWndProc == NULL){
			hidden_hwnd = GDK_WINDOW_HWND (hidden_window->window);
			OrgWndProc = (WNDPROC)GetWindowLong(hidden_hwnd, GWL_WNDPROC);
			SetWindowLong(hidden_hwnd, GWL_WNDPROC, (LONG)HiddenWndProc);
		}
		next_hwnd = SetClipboardViewer(hidden_hwnd);
	}
	registered = TRUE;
#else

	if(tag_timeout != 0)
		gtk_timeout_remove(tag_timeout);
	tag_timeout = gtk_timeout_add(auto_interval, copy_clipboard_x, NULL);

#endif
	auto_lookup_suspended = FALSE;
}
コード例 #8
0
ファイル: win2ktrans.c プロジェクト: wosigh/messaging-plugins
/* Set window transparency level */
static void set_wintrans(GtkWidget *window, int alpha, gboolean enabled,
		gboolean always_on_top) {
	if (MySetLayeredWindowAttributes) {
		HWND hWnd = GDK_WINDOW_HWND(window->window);
		LONG style = GetWindowLong(hWnd, GWL_EXSTYLE);
		if (enabled) {
			style |= WS_EX_LAYERED;
		} else {
			style &= ~WS_EX_LAYERED;
		}
		SetWindowLong(hWnd, GWL_EXSTYLE, style);


		if (enabled) {
			SetWindowPos(hWnd,
				always_on_top ? HWND_TOPMOST : HWND_NOTOPMOST,
				0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
			MySetLayeredWindowAttributes(hWnd, 0, alpha, LWA_ALPHA);
		} else {
			/* Ask the window and its children to repaint */
			SetWindowPos(hWnd, HWND_NOTOPMOST, 0, 0, 0, 0,
				SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);

			RedrawWindow(hWnd, NULL, NULL,
				RDW_ERASE | RDW_INVALIDATE | RDW_FRAME | RDW_ALLCHILDREN);
		}
	}
}
コード例 #9
0
ファイル: cursor.cpp プロジェクト: chrisglass/ufoai
void Sys_GetCursorPos(GtkWindow* window, int *x, int *y) {
	POINT pos;
	GetCursorPos(&pos);
	ScreenToClient((HWND)GDK_WINDOW_HWND(GTK_WIDGET(window)->window), &pos);
	*x = pos.x;
	*y = pos.y;
}
コード例 #10
0
/**
      \brief Retrieve info from window, needed for accel layer
*/
void UI_getWindowInfo(void *draw, GUI_WindowInfo *xinfo)
{
        GdkWindow *win;
        GtkWidget *widget=(GtkWidget *)draw;
          
        win = gtk_widget_get_parent_window(widget);

#ifdef __WIN32
		xinfo->display = (void*)GDK_WINDOW_HWND(widget->window);
#elif defined(__APPLE__)
		int windowWidth, windowHeight;
		int x, y;

		gdk_drawable_get_size(win, &windowWidth, &windowHeight);
		gdk_window_get_position(widget->window, &x, &y);

		xinfo->display = 0;
		xinfo->window = getMainNSWindow();
		xinfo->x = x;
		xinfo->y = windowHeight - (y + lastH);
		xinfo->width = lastW;
		xinfo->height = lastH;
#else
		xinfo->window = GDK_WINDOW_XWINDOW(widget->window);
		xinfo->display = GDK_WINDOW_XDISPLAY(win);
#endif
}
コード例 #11
0
ファイル: selection.c プロジェクト: fujii/ebview
void bring_to_top(GtkWidget *win){
#ifdef __WIN32__
	HWND hWnd;
	int nTargetID, nForegroundID;
	BOOL res;

	hWnd = GDK_WINDOW_HWND (win->window);

	/* From  http://techtips.belution.com/ja/vc/0012/ */
	nForegroundID = GetWindowThreadProcessId(GetForegroundWindow(), NULL);
	nTargetID = GetWindowThreadProcessId(hWnd, NULL );

	AttachThreadInput(nTargetID, nForegroundID, TRUE );

	// SPI_GETFOREGROUNDLOCKTIMEOUT will be undefined. Why ?
	/*
	SystemParametersInfo( SPI_GETFOREGROUNDLOCKTIMEOUT,0,&sp_time,0);
	SystemParametersInfo( SPI_SETFOREGROUNDLOCKTIMEOUT,0,(LPVOID)0,0);
	SetForegroundWindow(hWnd);
	SystemParametersInfo( SPI_SETFOREGROUNDLOCKTIMEOUT,0,sp_time,0);
	*/

	res = SetForegroundWindow(hWnd);

	AttachThreadInput(nTargetID, nForegroundID, FALSE);

	if(!res){
		SetFocus(hWnd);
	}
#else
	gdk_window_show(GTK_WIDGET(win)->window);
	gdk_window_focus(GTK_WIDGET(win)->window, gtk_get_current_event_time());

#endif
}
コード例 #12
0
/**
      \brief Retrieve info from window, needed for accel layer
*/
void UI_getWindowInfo(void *draw, GUI_WindowInfo *xinfo)
{
		GdkWindow *win, *parentWin;
		GtkWidget *widget=(GtkWidget *)draw;

		win = gtk_widget_get_window(widget);
		parentWin = gtk_widget_get_parent_window(widget);

#ifdef _WIN32
		xinfo->display = (void*)GDK_WINDOW_HWND(win);
#elif defined(__APPLE__)
		xinfo->display = 0;
		xinfo->window = getMainNSWindow();
#else
		xinfo->systemWindowId = GDK_WINDOW_XID(win);
		xinfo->display = GDK_WINDOW_XDISPLAY(parentWin);
#endif

		int windowWidth, windowHeight;
		int x, y;

		windowWidth = gdk_window_get_width(parentWin);
		windowHeight = gdk_window_get_height(parentWin);
		gdk_window_get_position(win, &x, &y);

		xinfo->x = x;
		xinfo->y = windowHeight - (y + lastH);
		xinfo->width = lastW;
		xinfo->height = lastH;
}
コード例 #13
0
ファイル: gdkvulkancontext-win32.c プロジェクト: swilmet/gtk
static VkResult
gdk_win32_vulkan_context_create_surface (GdkVulkanContext *context,
                                         VkSurfaceKHR     *surface)
{
  GdkWindow *window = gdk_draw_context_get_window (GDK_DRAW_CONTEXT (context));
  GdkDisplay *display = gdk_draw_context_get_display (GDK_DRAW_CONTEXT (context));
  VkWin32SurfaceCreateInfoKHR info;

  info.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
  info.pNext = NULL;
  info.flags = 0;
  info.hinstance = _gdk_dll_hinstance;
  info.hwnd = GDK_WINDOW_HWND (window);

  /* This is necessary so that Vulkan sees the Window.
   * Usually, vkCreateWin32SurfaceKHR() will not cause a problem to happen as
   * it just creates resources, but futher calls with the resulting surface
   * do cause issues.
   */
  gdk_display_sync (display);

  return GDK_VK_CHECK (vkCreateWin32SurfaceKHR,
                       gdk_vulkan_context_get_instance (context),
                       &info,
                       NULL,
                       surface);
}
コード例 #14
0
ファイル: cursor.cpp プロジェクト: chrisglass/ufoai
void Sys_SetCursorPos(GtkWindow* window, int x, int y) {
	POINT pos;
	pos.x = x;
	pos.y = y;
	ClientToScreen((HWND)GDK_WINDOW_HWND(GTK_WIDGET(window)->window), &pos);
	SetCursorPos(pos.x, pos.y);
}
コード例 #15
0
gboolean
_gdk_windowing_window_queue_antiexpose (GdkWindow *window,
					GdkRegion *area)
{
  HRGN hrgn = _gdk_win32_gdkregion_to_hrgn (area, 0, 0);

  GDK_NOTE (EVENTS, g_print ("_gdk_windowing_window_queue_antiexpose: ValidateRgn %p %s\n",
			     GDK_WINDOW_HWND (window),
			     _gdk_win32_gdkregion_to_string (area)));

  ValidateRgn (GDK_WINDOW_HWND (window), hrgn);

  DeleteObject (hrgn);

  return FALSE;
}
コード例 #16
0
guint32
create_child_plug (guint32  xid,
		   gboolean local)
{
  GtkWidget *window;
  GtkWidget *content;

  window = gtk_plug_new (xid);

  g_signal_connect (window, "destroy",
		    local ? G_CALLBACK (local_destroy)
			  : G_CALLBACK (remote_destroy),
		    NULL);
  gtk_container_set_border_width (GTK_CONTAINER (window), 0);

  content = create_content (GTK_WINDOW (window), local);
  
  gtk_container_add (GTK_CONTAINER (window), content);

  gtk_widget_show_all (window);

  if (GTK_WIDGET_REALIZED (window))
#if defined (GDK_WINDOWING_X11)
    return GDK_WINDOW_XID (window->window);
#elif defined (GDK_WINDOWING_WIN32)
    return (guint32) GDK_WINDOW_HWND (window->window);
#endif
  else
    return 0;
コード例 #17
0
ファイル: iupgtk_open.c プロジェクト: gcfavorites/tastools
char* iupgtkGetNativeWindowHandle(Ihandle* ih)
{
  GdkWindow* window = ih->handle->window;
  if (window)
    return (char*)GDK_WINDOW_HWND(window);
  else
    return NULL;
}
コード例 #18
0
static void
widget_on_realize(GtkWidget *widget, gpointer user_data)
{
	GtkVlcPlayer *player = GTK_VLC_PLAYER(user_data);
	GdkWindow *window = gtk_widget_get_window(widget);

	libvlc_media_player_set_hwnd(player->priv->media_player,
				     GDK_WINDOW_HWND(window));
}
コード例 #19
0
ファイル: alpha.c プロジェクト: Cloudef/macopix-fork
void GdkWinSetAlpha(GdkWindow *win){
  HWND hWnd;
  DWORD dwExStyle;

  hWnd = GDK_WINDOW_HWND(win);
  dwExStyle = GetWindowLong(hWnd, GWL_EXSTYLE);
  if(!(dwExStyle&WS_EX_LAYERED)){
    SetWindowLong(hWnd, GWL_EXSTYLE, dwExStyle|WS_EX_LAYERED);
  }
}
コード例 #20
0
ファイル: video_tester.c プロジェクト: xiaolds/VideoCallVoIP
static unsigned long get_native_handle(GdkWindow *gdkw) {
#ifdef GDK_WINDOWING_X11
	return (unsigned long)GDK_WINDOW_XID(gdkw);
#elif defined(WIN32)
	return (unsigned long)GDK_WINDOW_HWND(gdkw);
#elif defined(__APPLE__)
	return (unsigned long)gdk_quartz_window_get_nsview(gdkw);
#endif
	g_warning("No way to get the native handle from gdk window");
	return 0;
}
コード例 #21
0
ファイル: desktop.cpp プロジェクト: czchen/debian-stardict
void show_help(const gchar *section)
{
#ifdef _WIN32
  // You may translate it as "%s\\help\\stardict-zh_CN.chm" when this file available.
  gchar *filename = g_strdup_printf(_("%s\\help\\stardict.chm"), gStarDictDataDir.c_str());
  ShellExecute((HWND)(GDK_WINDOW_HWND(gpAppFrame->window->window)), "OPEN", filename, NULL, NULL, SW_SHOWNORMAL);
  g_free(filename);
#elif defined(CONFIG_GNOME)
  gnome_help_display ("stardict.xml", section, NULL);
#endif
}
コード例 #22
0
/**
 * @brief Callback for polling the availability of a libVLC event window.
 *
 * If found, it is disabled and the polling stops. This results in mouse click
 * events being delivered to the GtkDrawingArea widget.
 *
 * @param data User data (\e GtkVlcPlayer widget)
 * @return \c TRUE to continue polling, \c FALSE to stop
 */
static gboolean
poll_vlc_event_window_cb(gpointer data)
{
	GtkWidget *drawing_area = gtk_bin_get_child(GTK_BIN(data));
	GdkWindow *window = gtk_widget_get_window(drawing_area);

	gboolean ret = TRUE;

	EnumChildWindows(GDK_WINDOW_HWND(window),
			 enumerate_vlc_windows_cb, (LPARAM)&ret);

	return ret;
}
コード例 #23
0
ファイル: iupgtk_filedlg.c プロジェクト: svn2github/iup-iup
static void gtkFileDlgPreviewRealize(GtkWidget *widget, Ihandle *ih)
{
  iupAttribSetStr(ih, "PREVIEWDC", iupgtkGetNativeGraphicsContext(widget));
  iupAttribSetStr(ih, "WID", (char*)widget);

#ifdef WIN32                                 
  iupAttribSetStr(ih, "HWND", (char*)GDK_WINDOW_HWND(widget->window));
#else
  iupAttribSetStr(ih, "XWINDOW", (char*)GDK_WINDOW_XID(widget->window));
  iupAttribSetStr(ih, "XDISPLAY", (char*)iupdrvGetDisplay());
#endif
  gtkFileDlgUpdatePreviewGLCanvas(ih);
}
コード例 #24
0
ファイル: gdkdevice-win32.c プロジェクト: nacho/gtk-
static GdkGrabStatus
gdk_device_win32_grab (GdkDevice    *device,
                       GdkWindow    *window,
                       gboolean      owner_events,
                       GdkEventMask  event_mask,
                       GdkWindow    *confine_to,
                       GdkCursor    *cursor,
                       guint32       time_)
{
    if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
        SetCapture (GDK_WINDOW_HWND (window));

    return GDK_GRAB_SUCCESS;
}
コード例 #25
0
ファイル: moz-web-view.cpp プロジェクト: gistinc/Gecko
/*****************************************************
 * Hack ahead !!!
 *
 * Problems here have to do with focus handling, i.e.
 * sharing and passing keyboard focus back and forth from
 * the gecko window to the rest of the app. The gecko
 * wants us to turn focus on and off when we receive the
 * WM_ACTIVATE message for our window; Gtk+ does not give
 * us an opportunity to act on this message (TODO: patch
 * gtk+ to do so and run tests).
 *
 * Also tried to turn on and off focus near when activate
 * messages come (i.e. focus in/out of the toplevel window)
 * with no luck (works to get started, but the gecko
 * will never relinquish focus afterwords).
 *
 * The current hack/workaround:
 *   We are using a native toplevel window, that we reposition
 * to follow the widget hierarchy on toplevel configure events,
 * this way we handle the WM_ACTIVATE messages and focus handleing
 * works, on the other hand accelerators keys tied into the higher
 * level window wont trigger when the gecko has focus (is that
 * already the case ?) and the apps toplevel will be painted as
 * an inactive window.
 */
static HWND
create_native_window(GtkWidget *widget)
{
    static ATOM klass = 0;
    HWND window_handle, parent_handle;
    DWORD dwStyle, dwExStyle;

    if (!klass) {
         static WNDCLASSEXW wcl;

         wcl.cbSize = sizeof(WNDCLASSEX);
         wcl.style = 0;

        /* DON'T set CS_<H,V>REDRAW. It causes total redraw
         * on WM_SIZE and WM_MOVE. Flicker, Performance!
         */
         wcl.lpfnWndProc = (WNDPROC)window_procedure;
         wcl.cbClsExtra = 0;
         wcl.cbWndExtra = 0;
         wcl.hInstance = GetModuleHandle(NULL);
         wcl.hIcon = 0;
         wcl.hIconSm = 0;
         wcl.lpszMenuName = NULL;
         wcl.hIcon = NULL;
         wcl.hIconSm = NULL;
         wcl.hbrBackground = NULL;
         wcl.hCursor = LoadCursor(NULL, IDC_ARROW);
         wcl.lpszClassName = L"MozWindow";

         klass = RegisterClassExW(&wcl);
    }

    dwExStyle = WS_EX_TOOLWINDOW; // for popup windows
    dwStyle = WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS; // popup window

    parent_handle = (HWND)GDK_WINDOW_HWND(gtk_widget_get_parent_window(widget));
    window_handle = CreateWindowExW(dwExStyle,
                                    MAKEINTRESOURCEW(klass),
                                    L"",
                                    dwStyle,
                                    0, 0, 1, 1,
                                    parent_handle,
                                    NULL,
                                    GetModuleHandle(NULL),
                                    NULL);

    SetProp(window_handle, "moz-view-widget", (HANDLE)widget);

    return window_handle;
}
コード例 #26
0
ファイル: alpha.c プロジェクト: Cloudef/macopix-fork
void GdkWinChangeAlphaFG(GdkWindow *win, GdkColor *col){
  HWND hWnd;
  DWORD dwExStyle;

  hWnd = GDK_WINDOW_HWND(win);
  dwExStyle = GetWindowLong(hWnd, GWL_EXSTYLE);
  if(!(dwExStyle&WS_EX_LAYERED)){
    SetWindowLong(hWnd, GWL_EXSTYLE, dwExStyle|WS_EX_LAYERED);
  }

  SetLayeredWindowAttributes(hWnd, 
	     RGB(col->red/0x100,col->green/0x100,col->blue/0x100),
	     0, LWA_COLORKEY);

}
コード例 #27
0
ファイル: video-utils.c プロジェクト: kleopatra999/chronojump
guintptr
gst_get_window_handle(GdkWindow *window)
{
  guintptr window_handle;

  /* Retrieve window handler from GDK */
#if defined (GDK_WINDOWING_WIN32)
  window_handle = (guintptr)GDK_WINDOW_HWND (window);
#elif defined (GDK_WINDOWING_QUARTZ)
  window_handle = gdk_quartz_window_get_nsview (window);
#elif defined (GDK_WINDOWING_X11)
  window_handle = GDK_WINDOW_XID (window);
#endif

  return window_handle;
}
コード例 #28
0
ファイル: desktop.cpp プロジェクト: czchen/debian-stardict
void show_url(const char *url)
{
	if (!url)
		return;
#ifdef _WIN32
	ShellExecute((HWND)(GDK_WINDOW_HWND(gpAppFrame->window->window)), "OPEN", url, NULL, NULL, SW_SHOWNORMAL);
#elif defined(CONFIG_GNOME)
	gnome_url_show(url, NULL);
#elif defined(CONFIG_GPE)
	gchar *command = g_strdup_printf("gpe-mini-browser %s", url);
	system(command);
	g_free(command);
#else
	spawn_command("firefox", url);
#endif
}
コード例 #29
0
/* This function is called when the GUI toolkit creates the physical window that will hold the video.
 * At this point we can retrieve its handler (which has a different meaning depending on the windowing system)
 * and pass it to GStreamer through the XOverlay interface. */
static void realize_cb (GtkWidget *widget, CustomData *data) {
  GdkWindow *window = gtk_widget_get_window (widget);
  guintptr window_handle;
  
  if (!gdk_window_ensure_native (window))
    g_error ("Couldn't create native window needed for GstXOverlay!");
  
  /* Retrieve window handler from GDK */
#if defined (GDK_WINDOWING_WIN32)
  window_handle = (guintptr)GDK_WINDOW_HWND (window);
#elif defined (GDK_WINDOWING_QUARTZ)
  window_handle = gdk_quartz_window_get_nsview (window);
#elif defined (GDK_WINDOWING_X11)
  window_handle = GDK_WINDOW_XID (window);
#endif
  /* Pass it to playbin, which implements XOverlay and will forward it to the video sink */
  gst_video_overlay_set_window_handle (GST_VIDEO_OVERLAY (data->playbin), window_handle);
}
コード例 #30
0
ファイル: selection.c プロジェクト: fujii/ebview
void auto_lookup_stop()
{

#ifdef __WIN32__
	if(registered == TRUE) {
		hidden_hwnd = GDK_WINDOW_HWND (hidden_window->window);
		ChangeClipboardChain(hidden_hwnd, next_hwnd);
		next_hwnd = NULL;
		registered = FALSE;
	}
#else
	if(tag_timeout != 0)
		gtk_timeout_remove(tag_timeout);
	tag_timeout = 0;
#endif

	auto_lookup_suspended = FALSE;
}