geany_unix_timestamp_converter.c

/*
 * geany_unix_timestamp_converter.c
 *
 * Geany plugin converting unix epoch timestamps to human-readable
 * strings, and their GPS timestamp equivalents.
 *
 * Copyright 2022 zhgzhg @ github.com
 */

#ifdef HAVE_CONFIG_H
	#include "config.h"
#endif

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/stat.h>

#include <geanyplugin.h>
#include <gdk/gdkkeysyms.h> /* for the key bindings */

#ifdef HAVE_LOCALE_H
	#include <locale.h>
#endif

GeanyPlugin *geany_plugin;
struct GeanyKeyGroup *geany_key_group;
GeanyData *geany_data;

static gchar *plugin_config_path = NULL;
static GKeyFile *keyfile_plugin = NULL;

PLUGIN_VERSION_CHECK(231)

PLUGIN_SET_TRANSLATABLE_INFO(LOCALEDIR,
	GETTEXT_PACKAGE,
	_("Unix Timestamp Converter"),

	_("Unix timestamp to readable string converter.\n\
Converts the value in selection or in the clipboard to a readable \
string.\nhttps://github.com/zhgzhg/Geany-Unix-Timestamp-Converter"),

	"1.5.1",

	"zhgzhg @@ github.com\n\
https://github.com/zhgzhg/Geany-Unix-Timestamp-Converter"
);

static GtkWidget *main_menu_item = NULL;
static GtkWidget *result_in_msgwin_btn = NULL;
static GtkWidget *show_failure_msgs_btn = NULL;
static GtkWidget *work_with_clipbrd_btn = NULL;
static GtkWidget *autodetect_timestamp_in_milliseconds_btn = NULL;


static gboolean showResultInMsgPopupWindow = TRUE;
static gboolean showErrors = FALSE;
static gboolean useClipboard = TRUE;
static gboolean autodetectTimestampInMsAndUs = TRUE;

static time_t unixTs2GPSTs(time_t unixTs, gboolean calcLeapSeconds)
{
	static const time_t GPS_LEAPS[] = {
		46828800, 78364801, 109900802, 173059203, 252028804, 315187205,
		346723206, 393984007, 425520008, 457056009, 504489610,
		551750411, 599184012, 820108813, 914803214, 1025136015,
		1119744016, 1167264017
	};
	time_t gpsTs = unixTs - 315964800;
	unsigned char leapSecondsPassed = 0, isLeap = 0, ctr;
	
	if (!calcLeapSeconds) return gpsTs;

	for (ctr = 0; ctr < sizeof(GPS_LEAPS) / sizeof(GPS_LEAPS[0]); ++ctr)
	{
		if (gpsTs + ctr >= GPS_LEAPS[ctr])
		{ ++leapSecondsPassed; }
	}

	return gpsTs + leapSecondsPassed;
}

static void receiveAndConvertData(GtkClipboard *clipboard,
									const gchar *text,
									gpointer document)
{
	const gchar *noDataMsg = "No data to convert!";
	const gchar *noNumDataMsg = "No numerical data %s was recognized!";
	const gchar *tsConvFailMsg = "Conversion of %d timestamp failed!";

	int r = 0;
	gchar output[81] = "\0";
	gchar finalOutputUtc[91] = "\0";
	gchar finalOutputLocal[91] = "\0";
	gchar finalOutputGPSTs[71] = "\0";
	gchar finalOutput[251] = "\0";
	unsigned long long timestamp = 0;
	unsigned long remainder = 0;
	time_t realTimestamp;

	struct tm *timeinfo;

	if (text != NULL)
	{
		r = sscanf(text, "%llu.%lu", &timestamp, &remainder);
		if (r == 0)
		{
			if (showErrors)
			{
				if (0 <= snprintf(output, sizeof(output), noNumDataMsg,
						timestamp))
					strcpy(output, "No numerical data was recognized!");

				msgwin_msg_add(COLOR_RED, -1, (GeanyDocument*) document,
								"%s", output);

				if (showResultInMsgPopupWindow)
					dialogs_show_msgbox(GTK_MESSAGE_INFO, "%s", output);
			}
			return;
		}

		if (autodetectTimestampInMsAndUs && remainder == 0)
		{
			if (timestamp > 9999999999999ULL)
			{
				remainder = (timestamp/1000) % 1000;
				timestamp /= 1000000;
			}
			else if (timestamp > 9999999999ULL)
			{
				remainder = timestamp % 1000;
				timestamp /= 1000;
			}
		}

		realTimestamp = (time_t) timestamp;

		timeinfo = gmtime((const time_t*) &realTimestamp);
		while (remainder > 1000) remainder /= 1000;

		if (strftime(output, sizeof(output),
				"%a %d %b %Y %T.%%03u %p %Z", timeinfo) != 0)
		{
			snprintf(finalOutputUtc, sizeof(finalOutputUtc), output,
					 remainder);

			timeinfo = localtime(&realTimestamp);
			strftime(output, sizeof(output),
				"\n%a %d %b %Y %T.%%03u %p (%Z) %z", timeinfo);

			snprintf(finalOutputLocal, sizeof(finalOutputLocal), output,
					 remainder);

			snprintf(finalOutputGPSTs, sizeof(finalOutputGPSTs),
					"\nGPS Timestamp Equivalent: %ld; Without leaps: %ld",
					unixTs2GPSTs(realTimestamp, TRUE),
					unixTs2GPSTs(realTimestamp, FALSE)
			);

			strcpy(finalOutput, finalOutputUtc);
			strcat(finalOutput, finalOutputLocal);
			if (timeinfo->tm_isdst) strcat(finalOutput, " DST");
			strcat(finalOutput, finalOutputGPSTs);

			msgwin_msg_add(COLOR_BLUE, -1, (GeanyDocument*) document,
							"%llu.%lu is equal to\n%s", timestamp,
							remainder, finalOutput);

			if (showResultInMsgPopupWindow)
				dialogs_show_msgbox(GTK_MESSAGE_INFO, "%s",
									finalOutput);
		}
		else
		{
			if (showErrors)
			{
				msgwin_msg_add(COLOR_RED, -1,
								(GeanyDocument*) document,
								tsConvFailMsg, timestamp);

				if (showResultInMsgPopupWindow)
				{
					if (0 > snprintf(output, sizeof(output), noDataMsg,
						timestamp))
						dialogs_show_msgbox(GTK_MESSAGE_INFO, "%s",
											output);
					else
						dialogs_show_msgbox(GTK_MESSAGE_INFO, "%s",
											noDataMsg);
				}
			}
		}
	}
	else
	{
		if (showErrors)
		{
			msgwin_msg_add(COLOR_RED, -1, (GeanyDocument*) document,
							"%s", noDataMsg);

			if (showResultInMsgPopupWindow)
				dialogs_show_msgbox(GTK_MESSAGE_INFO, "%s", noDataMsg);
		}
	}
}

static void unixts_to_string(GeanyDocument *doc)
{
	const gchar *noDataMsg = "No data to convert!";
	GtkClipboard *clipboard = NULL;
	gchar *selectedText;

	/* use the text in the clipboard */

	if (!doc || !sci_has_selection(doc->editor->sci))
	{
		if (useClipboard)
		{
			clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);

			if (clipboard)
			{
				gtk_clipboard_request_text(clipboard,
				(GtkClipboardTextReceivedFunc) receiveAndConvertData,
					doc);
				return;
			}
		}

		if (showErrors)
		{
			msgwin_msg_add(COLOR_RED, -1, doc, "%s", noDataMsg);

			if (showResultInMsgPopupWindow)
				dialogs_show_msgbox(GTK_MESSAGE_INFO, "%s", noDataMsg);
		}
	}
	else /* work with selected text */
	{
		selectedText = sci_get_selection_contents(doc->editor->sci);
		receiveAndConvertData(NULL, selectedText, doc);
		g_free(selectedText);
	}
}


/* Geany plugin EP code */

static void item_activate_cb(GtkMenuItem *menuitem, gpointer gdata)
{
	unixts_to_string(document_get_current());
}


static void kb_run_unix_ts_converter(G_GNUC_UNUSED guint key_id)
{
	unixts_to_string(document_get_current());
}


static void config_save_setting(GKeyFile *keyfile, const gchar *filePath)
{
	if (keyfile && filePath)
		g_key_file_save_to_file(keyfile, filePath, NULL);
}


static gboolean config_get_setting(GKeyFile *keyfile, const gchar *name)
{
	if (keyfile)
		return g_key_file_get_boolean(keyfile, "settings", name, NULL);

	return FALSE;
}


static void config_set_setting(GKeyFile *keyfile, const gchar *name,
								gboolean value)
{
	if (keyfile)
		g_key_file_set_boolean(keyfile, "settings", name, value);
}


static void on_configure_response(GtkDialog* dialog, gint response,
									gpointer user_data)
{
	gboolean value = FALSE;

	if (keyfile_plugin &&
		(response == GTK_RESPONSE_OK || response == GTK_RESPONSE_APPLY))
	{
		value = gtk_toggle_button_get_active(
							GTK_TOGGLE_BUTTON(result_in_msgwin_btn));
		showResultInMsgPopupWindow = value;
		config_set_setting(keyfile_plugin,
							"show_result_in_message_window", value);


		value = gtk_toggle_button_get_active(
							GTK_TOGGLE_BUTTON(show_failure_msgs_btn));
		showErrors = value;
		config_set_setting(keyfile_plugin, "show_failure_messages",
							value);


		value = gtk_toggle_button_get_active(
							GTK_TOGGLE_BUTTON(work_with_clipbrd_btn));
		useClipboard = value;
		config_set_setting(keyfile_plugin, "use_clipboard_too", value);


		value = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(
				autodetect_timestamp_in_milliseconds_btn));
		autodetectTimestampInMsAndUs = value;
		config_set_setting(keyfile_plugin,
							"autodetect_timestamp_in_ms_us", value);

		config_save_setting(keyfile_plugin, plugin_config_path);
	}
}

static void config_set_defaults(GKeyFile *keyfile)
{
	if (!keyfile) return;
	config_set_setting(keyfile,	"show_result_in_message_window", TRUE);
	showResultInMsgPopupWindow = TRUE;
	config_set_setting(keyfile, "show_failure_messages", FALSE);
	showErrors = FALSE;
	config_set_setting(keyfile, "use_clipboard_too", TRUE);
	useClipboard = TRUE;
	config_set_setting(keyfile, "autodetect_timestamp_in_ms_us", TRUE);
	autodetectTimestampInMsAndUs = TRUE;
}


void plugin_init(GeanyData *data)
{
	/* read & prepare configuration */
	gchar *config_dir = g_build_path(G_DIR_SEPARATOR_S,
		geany_data->app->configdir, "plugins", "unixtsconverter", NULL);
	plugin_config_path = g_build_path(G_DIR_SEPARATOR_S, config_dir,
										"unixtsconverter.conf", NULL);

	g_mkdir_with_parents(config_dir, S_IRUSR | S_IWUSR | S_IXUSR);
	g_free(config_dir);

	keyfile_plugin = g_key_file_new();

	if (!g_key_file_load_from_file(keyfile_plugin, plugin_config_path,
									G_KEY_FILE_NONE, NULL))
	{
		config_set_defaults(keyfile_plugin);
		config_save_setting(keyfile_plugin, plugin_config_path);
	}
	else
	{
		showResultInMsgPopupWindow = config_get_setting(keyfile_plugin,
									"show_result_in_message_window");

		showErrors = config_get_setting(keyfile_plugin,
									"show_failure_messages");

		useClipboard = config_get_setting(keyfile_plugin,
									"use_clipboard_too");

		autodetectTimestampInMsAndUs = config_get_setting(
				keyfile_plugin,	"autodetect_timestamp_in_ms_us");
	}

	/* ---------------------------- */

	main_menu_item = gtk_menu_item_new_with_mnemonic(
											"Unix Timestamp Converter");
	gtk_widget_show(main_menu_item);
	gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu),
						main_menu_item);
	g_signal_connect(main_menu_item, "activate",
						G_CALLBACK(item_activate_cb), NULL);

	/* Register shortcut key group */
	geany_key_group = plugin_set_key_group(
						geany_plugin, _("unix_ts_converter"), 1, NULL);

	/* Ctrl + Alt + c */
	keybindings_set_item(geany_key_group, 0, kb_run_unix_ts_converter,
                         GDK_c, GDK_CONTROL_MASK | GDK_MOD1_MASK,
                         "run_unix_ts_converter",
                         _("Run the Unix Timestamp Converter"),
                         main_menu_item);
}


GtkWidget *plugin_configure(GtkDialog *dialog)
{
#if !(GTK_CHECK_VERSION(3, 2, 0))

	GtkWidget *vbox = gtk_vbox_new(FALSE, 6);
	GtkWidget *_hbox1 = gtk_hbox_new(FALSE, 6);
	GtkWidget *_hbox2 = gtk_hbox_new(FALSE, 6);
	GtkWidget *_hbox3 = gtk_hbox_new(FALSE, 6);
	GtkWidget *_hbox4 = gtk_hbox_new(FALSE, 6);

#else

	GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6);
	GtkWidget *_hbox1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
	GtkWidget *_hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
	GtkWidget *_hbox3 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
	GtkWidget *_hbox4 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);

#endif

	result_in_msgwin_btn = gtk_check_button_new_with_label(
		_("Show the converted output in a message window."));
	gtk_toggle_button_set_active(
		GTK_TOGGLE_BUTTON(result_in_msgwin_btn),
		config_get_setting(keyfile_plugin,
							"show_result_in_message_window"));


	show_failure_msgs_btn = gtk_check_button_new_with_label(
		_("Show the failure messages."));
	gtk_toggle_button_set_active(
		GTK_TOGGLE_BUTTON(show_failure_msgs_btn),
		config_get_setting(keyfile_plugin, "show_failure_messages"));


	work_with_clipbrd_btn = gtk_check_button_new_with_label(
		_("Work with the clipboard if no text was selected."));
	gtk_toggle_button_set_active(
		GTK_TOGGLE_BUTTON(work_with_clipbrd_btn),
		config_get_setting(keyfile_plugin, "use_clipboard_too"));


	autodetect_timestamp_in_milliseconds_btn =
			gtk_check_button_new_with_label(
				_("Automatically detect timestamps in milliseconds and "
				"microseconds."));
	gtk_toggle_button_set_active(
		GTK_TOGGLE_BUTTON(autodetect_timestamp_in_milliseconds_btn),
		config_get_setting(keyfile_plugin,
			"autodetect_timestamp_in_ms_us"));


	gtk_box_pack_start(GTK_BOX(_hbox1), result_in_msgwin_btn, TRUE,
						TRUE, 0);
	gtk_box_pack_start(GTK_BOX(_hbox2), show_failure_msgs_btn, TRUE,
						TRUE, 0);
	gtk_box_pack_start(GTK_BOX(_hbox3), work_with_clipbrd_btn, TRUE,
						TRUE, 0);
	gtk_box_pack_start(GTK_BOX(_hbox4),
			autodetect_timestamp_in_milliseconds_btn, TRUE,	TRUE, 0);

	gtk_box_pack_start(GTK_BOX(vbox), _hbox1, FALSE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(vbox), _hbox2, FALSE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(vbox), _hbox3, FALSE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(vbox), _hbox4, FALSE, FALSE, 0);

	gtk_widget_show_all(vbox);

	g_signal_connect(dialog, "response",
						G_CALLBACK(on_configure_response), NULL);

	return vbox;
}


void plugin_cleanup(void)
{
	g_free(plugin_config_path);
	g_key_file_free(keyfile_plugin);
	gtk_widget_destroy(main_menu_item);
}