Mercurial > pidgin3 / file revision

/*
 * Pidgin is the legal property of its developers, whose names are too numerous
 * to list here.  Please refer to the COPYRIGHT file distributed with this
 * source distribution.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
 *
 */
#include <io.h>
#include <stdlib.h>
#include <stdio.h>

/* winsock2.h needs to be include before windows.h or else it throws a warning
 * saying it needs to be included first. We don't use it directly but it's
 * included indirectly.
 */
#include <winsock2.h>
#include <windows.h>
#include <winuser.h>
#include <shellapi.h>

#include <glib.h>
#include <glib/gstdio.h>
#include <gtk/gtk.h>

#include <purple.h>

#include "resource.h"

#include "gtkwin32dep.h"
#include "gtkblist.h"
#include "gtkconv.h"
#include "gtkconn.h"

/*
 *  GLOBALS
 */
HINSTANCE exe_hInstance = 0;
HINSTANCE dll_hInstance = 0;
HWND messagewin_hwnd;

static gboolean pwm_handles_connections = TRUE;


/*
 *  PUBLIC CODE
 */

HINSTANCE winpidgin_exe_hinstance(void) {
	return exe_hInstance;
}

void winpidgin_set_exe_hinstance(HINSTANCE hint)
{
	exe_hInstance = hint;
}

HINSTANCE winpidgin_dll_hinstance(void) {
	return dll_hInstance;
}

int winpidgin_gz_decompress(const char* in, const char* out) {
	GFile *fin;
	GFile *fout;
	GInputStream *input;
	GOutputStream *output;
	GOutputStream *conv_out;
	GZlibDecompressor *decompressor;
	gssize size;
	GError *error = NULL;

	fin = g_file_new_for_path(in);
	input = G_INPUT_STREAM(g_file_read(fin, NULL, &error));
	g_object_unref(fin);

	if (input == NULL) {
		purple_debug_error("winpidgin_gz_decompress",
				"Failed to open: %s: %s\n",
				in, error->message);
		g_clear_error(&error);
		return 0;
	}

	fout = g_file_new_for_path(out);
	output = G_OUTPUT_STREAM(g_file_replace(fout, NULL, FALSE,
			G_FILE_CREATE_NONE, NULL, &error));
	g_object_unref(fout);

	if (output == NULL) {
		purple_debug_error("winpidgin_gz_decompress",
				"Error opening file: %s: %s\n",
				out, error->message);
		g_clear_error(&error);
		g_object_unref(input);
		return 0;
	}

	decompressor = g_zlib_decompressor_new(G_ZLIB_COMPRESSOR_FORMAT_GZIP);
	conv_out = g_converter_output_stream_new(output,
			G_CONVERTER(decompressor));
	g_object_unref(decompressor);
	g_object_unref(output);

	size = g_output_stream_splice(conv_out, input,
			G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE |
			G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET, NULL, &error);

	g_object_unref(input);
	g_object_unref(conv_out);

	if (size < 0) {
		purple_debug_error("wpurple_gz_decompress",
				"Error writing to file: %s\n",
				error->message);
		g_clear_error(&error);
		return 0;
	}

	return 1;
}

#define PIDGIN_WM_FOCUS_REQUEST (WM_APP + 13)
#define PIDGIN_WM_PROTOCOL_HANDLE (WM_APP + 14)

static void*
winpidgin_netconfig_changed_cb(GNetworkMonitor *monitor, gboolean available, gpointer data)
{
	pwm_handles_connections = FALSE;

	return NULL;
}

static gboolean
winpidgin_pwm_reconnect()
{
	g_signal_handlers_disconnect_by_func(g_network_monitor_get_default,
	                                     G_CALLBACK(winpidgin_netconfig_changed_cb),
	                                     NULL);
	if (pwm_handles_connections == TRUE) {
		PurpleConnectionUiOps *ui_ops = pidgin_connections_get_ui_ops();

		purple_debug_info("winpidgin", "Resumed from standby, reconnecting accounts.\n");

		if (ui_ops != NULL && ui_ops->network_connected != NULL)
			ui_ops->network_connected();
	} else {
		purple_debug_info("winpidgin", "Resumed from standby, gtkconn will handle reconnecting.\n");
		pwm_handles_connections = TRUE;
	}

	return FALSE;
}

static LRESULT CALLBACK message_window_handler(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) {

	if (msg == PIDGIN_WM_FOCUS_REQUEST) {
		PidginBuddyList *blist;
		purple_debug_info("winpidgin", "Got external Buddy List focus request.");
		blist = pidgin_blist_get_default_gtk_blist();
		if (blist != NULL && blist->window != NULL) {
			gtk_window_present(GTK_WINDOW(blist->window));
		}
		return TRUE;
	} else if (msg == PIDGIN_WM_PROTOCOL_HANDLE) {
		char *proto_msg = (char *) lparam;
		purple_debug_info("winpidgin", "Got protocol handler request: %s\n", proto_msg ? proto_msg : "");
		purple_got_protocol_handler_uri(proto_msg);
		return TRUE;
	} else if (msg == WM_POWERBROADCAST) {
		if (wparam == PBT_APMQUERYSUSPEND) {
			purple_debug_info("winpidgin", "Windows requesting permission to suspend.\n");
			return TRUE;
		} else if (wparam == PBT_APMSUSPEND) {
			PurpleConnectionUiOps *ui_ops = pidgin_connections_get_ui_ops();

			purple_debug_info("winpidgin", "Entering system standby, disconnecting accounts.\n");

			if (ui_ops != NULL && ui_ops->network_disconnected != NULL)
				ui_ops->network_disconnected();

			g_signal_connect(g_network_monitor_get_default(),
			                 "network-changed",
			                 G_CALLBACK(winpidgin_netconfig_changed_cb),
			                 NULL);

			return TRUE;
		} else if (wparam == PBT_APMRESUMESUSPEND) {
			purple_debug_info("winpidgin", "Resuming from system standby.\n");
			/* TODO: It seems like it'd be wise to use the NLA message, if possible, instead of this. */
			g_timeout_add_seconds(1, winpidgin_pwm_reconnect, NULL);
			return TRUE;
		}
	}

	return DefWindowProc(hwnd, msg, wparam, lparam);
}

static HWND winpidgin_message_window_init(void) {
	HWND win_hwnd;
	WNDCLASSEX wcx;
	LPCTSTR wname;

	wname = TEXT("WinpidginMsgWinCls");

	wcx.cbSize = sizeof(wcx);
	wcx.style = 0;
	wcx.lpfnWndProc = message_window_handler;
	wcx.cbClsExtra = 0;
	wcx.cbWndExtra = 0;
	wcx.hInstance = winpidgin_exe_hinstance();
	wcx.hIcon = NULL;
	wcx.hCursor = NULL;
	wcx.hbrBackground = NULL;
	wcx.lpszMenuName = NULL;
	wcx.lpszClassName = wname;
	wcx.hIconSm = NULL;

	RegisterClassEx(&wcx);

	/* Create the window */
	if(!(win_hwnd = CreateWindow(wname, TEXT("WinpidginMsgWin"), 0, 0, 0, 0, 0,
			NULL, NULL, winpidgin_exe_hinstance(), 0))) {
		purple_debug_error("winpidgin",
			"Unable to create message window.\n");
		return NULL;
	}

	return win_hwnd;
}

void winpidgin_init(void) {
	typedef void (__cdecl* LPFNSETLOGFILE)(const LPCSTR);
	LPFNSETLOGFILE MySetLogFile;
	gchar *exchndl_dll_path;

	if (purple_debug_is_verbose())
		purple_debug_misc("winpidgin", "winpidgin_init start\n");

	exchndl_dll_path = g_build_filename(wpurple_bin_dir(), "exchndl.dll", NULL);
	MySetLogFile = (LPFNSETLOGFILE) wpurple_find_and_loadproc(exchndl_dll_path, "SetLogFile");
	g_free(exchndl_dll_path);
	exchndl_dll_path = NULL;
	if (MySetLogFile) {
		gchar *debug_dir, *locale_debug_dir;

		debug_dir = g_build_filename(purple_cache_dir(), "pidgin.RPT", NULL);
		locale_debug_dir = g_locale_from_utf8(debug_dir, -1, NULL, NULL, NULL);

		purple_debug_info("winpidgin", "Setting exchndl.dll LogFile to %s\n", debug_dir);

		MySetLogFile(locale_debug_dir);

		g_free(debug_dir);
		g_free(locale_debug_dir);
	}

	messagewin_hwnd = winpidgin_message_window_init();

	if (purple_debug_is_verbose())
		purple_debug_misc("winpidgin", "winpidgin_init end\n");
}

/* Windows Cleanup */

void winpidgin_cleanup(void) {
	purple_debug_info("winpidgin", "winpidgin_cleanup\n");

	if(messagewin_hwnd)
		DestroyWindow(messagewin_hwnd);

}

/* DLL initializer */
/* suppress gcc "no previous prototype" warning */
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved);
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) {
	dll_hInstance = hinstDLL;
	return TRUE;
}

typedef HRESULT (WINAPI* DwmIsCompositionEnabledFunction)(BOOL*);
typedef HRESULT (WINAPI* DwmGetWindowAttributeFunction)(HWND, DWORD, PVOID, DWORD);
#ifndef DWMWA_EXTENDED_FRAME_BOUNDS
#	define DWMWA_EXTENDED_FRAME_BOUNDS 9
#endif

DWORD winpidgin_get_lastactive() {
	DWORD result = 0;

	LASTINPUTINFO lii;
	memset(&lii, 0, sizeof(lii));
	lii.cbSize = sizeof(lii);
	if (GetLastInputInfo(&lii))
		result = lii.dwTime;

	return result;
}