void
ui_run (void)
{
GtkWidget * box;
GtkWidget * about;
GtkWidget * window;
int success;
builder = gtk_builder_new();
success = gtk_builder_add_from_file (builder, UI_BUILDER_FILENAME, NULL);
if (!success)
success = gtk_builder_add_from_file (builder, UI_BUILDER_FILE, NULL);
if (!success)
g_error (_("User interface definition file '%s' was not found.\n"));
gtk_builder_connect_signals (builder, NULL);
window = GET_OBJECT("window");
box = GET_OBJECT("box");
about = GET_OBJECT ("window-about");
g_log_set_handler (G_LOG_DOMAIN, G_LOG_LEVEL_MESSAGE, ui_log_level_message, NULL);
g_log_set_handler (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, ui_log_level_info, NULL);
game = hex_new (DEFAULT_BOARD_SIZE);
gtk_about_dialog_set_version (GTK_ABOUT_DIALOG (about), PACKAGE_VERSION);
hexboard = hexboard_new(DEFAULT_BOARD_SIZE);
filter_auto = gtk_file_filter_new ();
filter_sgf = gtk_file_filter_new ();
filter_lg_sgf = gtk_file_filter_new ();
gtk_file_filter_set_name (filter_auto, "Select Automatically");
gtk_file_filter_set_name (filter_sgf, "Smart Game Format (SGF)");
gtk_file_filter_set_name (filter_lg_sgf, "LittleGolem's Smart Game Format (SGF)");
gtk_file_filter_add_pattern (filter_auto, "*");
gtk_file_filter_add_pattern (filter_sgf, "*.sgf");
gtk_file_filter_add_pattern (filter_lg_sgf, "*.hsgf");
gtk_file_filter_add_pattern (filter_lg_sgf, "*.sgf");
g_object_ref_sink (filter_auto);
g_object_ref_sink (filter_sgf);
g_object_ref_sink (filter_lg_sgf);
g_signal_connect (GTK_WIDGET(hexboard), "cell_clicked", G_CALLBACK(ui_signal_cell_clicked), game);
gtk_container_add (GTK_CONTAINER(box), hexboard);
gtk_widget_show_all (window);
update_history_buttons();
update_window_title();
gtk_main();
hex_free (game);
}
void
ui_signal_preferences (GtkMenuItem * item, gpointer data)
{
GtkWidget * dialog = GET_OBJECT ("window-preferences");
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_hide (dialog);
}
void
ui_signal_save_as (GtkMenuItem * item, gpointer data)
{
GtkWidget *dialog;
GtkWidget *window = GET_OBJECT("window");
dialog = gtk_file_chooser_dialog_new (_("Save"),
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
/* Set filters */
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_sgf);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_lg_sgf);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
g_free (game_file);
game_file = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
game_format = dialog_selected_format (dialog);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
if (game_format != HEX_AUTO)
hex_save_sgf (game, game_format, game_file);
update_window_title();
}
gtk_widget_destroy (dialog);
}
void
ui_signal_export (GtkMenuItem * item, gpointer data)
{
GtkWidget *dialog;
GtkWidget *window = GET_OBJECT("window");
GtkFileFilter * filter_auto;
GtkFileFilter * filter_pdf;
GtkFileFilter * filter_svg;
GtkFileFilter * filter_png;
dialog = gtk_file_chooser_dialog_new (_("Export"),
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
/* Set filters */
filter_auto = gtk_file_filter_new();
filter_pdf = gtk_file_filter_new();
filter_svg = gtk_file_filter_new();
filter_png = gtk_file_filter_new();
gtk_file_filter_add_pattern (filter_auto, "*");
gtk_file_filter_add_mime_type (filter_pdf, "application/pdf");
gtk_file_filter_add_mime_type (filter_svg, "image/svg+xml");
gtk_file_filter_add_mime_type (filter_png, "image/png");
gtk_file_filter_set_name (filter_pdf, "Portable Document Format (PDF)");
gtk_file_filter_set_name (filter_svg, "Scalable Vector Graphcis (SVG)");
gtk_file_filter_set_name (filter_png, "Portable Networks Graphcis (PNG)");
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_png);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_pdf);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_svg);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
char *filename;
char * ext;
gint width, height;
GtkFileFilter * filter;
gboolean successp;
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
filter = gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (dialog));
gdk_window_get_size (hexboard->window, &width, &height);
if (filter == filter_pdf)
ext = "pdf";
else if (filter == filter_png)
ext = "png";
else if (filter == filter_svg)
ext = "svg";
successp = hexboard_save_as_image (HEXBOARD(hexboard), filename, ext, width, height);
if (!successp)
g_message (_("An error ocurred while export the board."));
g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, _("Board was exported to %s."), filename);
g_free (filename);
}
gtk_widget_destroy (dialog);
}
void
ui_signal_new (GtkMenuItem * item, gpointer data)
{
Hexboard * board = HEXBOARD (hexboard);
GtkWidget * dialog = GET_OBJECT ("window-new");
GtkSpinButton * sizespin = GTK_SPIN_BUTTON (GET_OBJECT ("window-new-size"));
GtkColorButton * color1 = GTK_COLOR_BUTTON (GET_OBJECT ("window-new-color1"));
GtkColorButton * color2 = GTK_COLOR_BUTTON (GET_OBJECT ("window-new-color2"));
gint ok;
ok = gtk_dialog_run (GTK_DIALOG (dialog));
if (ok)
{
gint size = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON (sizespin));
GdkColor color;
double r,g,b;
hex_free (game);
game = hex_new (size);
hexboard_set_size (board, size);
history_marker = undo_history_marker = 0;
/* Colors */
hexboard_color[0][0] = hexboard_color[0][1] = hexboard_color[0][2] = 1;
gtk_color_button_get_color (color1, &color);
r = hexboard_color[1][0] = color.red / 65535.0;;
g = hexboard_color[1][1] = color.green / 65535.0;;
b = hexboard_color[1][2] = color.blue / 65535.0;;
hexboard_border_set_color (board, HEXBOARD_BORDER_SE, r,g,b);
hexboard_border_set_color (board, HEXBOARD_BORDER_NW, r,g,b);
gtk_color_button_get_color (color2, &color);
r = hexboard_color[2][0] = color.red / 65535.0;;
g = hexboard_color[2][1] = color.green / 65535.0;;
b = hexboard_color[2][2] = color.blue / 65535.0;;
hexboard_border_set_color (board, HEXBOARD_BORDER_NE, r,g,b);
hexboard_border_set_color (board, HEXBOARD_BORDER_SW, r,g,b);
game_file = NULL;
update_window_title();
update_hexboard_colors();
update_hexboard_sensitive();
update_history_buttons();
}
gtk_widget_hide (dialog);
}
/* Update the sensitive of history buttons according to the history
status of the hex_t structure. */
static void
update_history_buttons (void)
{
GtkWidget * first = GET_OBJECT ("button-history-first");
GtkWidget * backward = GET_OBJECT ("button-history-backward");
GtkWidget * forward = GET_OBJECT ("button-history-forward");
GtkWidget * last = GET_OBJECT ("button-history-last");
GtkWidget * undo = GET_OBJECT ("menu-undo");
GtkWidget * redo = GET_OBJECT ("menu-redo");
int size = hex_history_size (game);
/* Set sensitive attributes to history buttons. */
gtk_widget_set_sensitive (first, history_marker != 0);
gtk_widget_set_sensitive (backward, history_marker != 0);
gtk_widget_set_sensitive (last, history_marker != undo_history_marker);
gtk_widget_set_sensitive (forward, history_marker != undo_history_marker);
/* undo/redo */
if (history_marker == undo_history_marker && undo_history_marker > 0)
gtk_widget_set_sensitive (undo, TRUE);
else
gtk_widget_set_sensitive (undo, FALSE);
if (history_marker == undo_history_marker && undo_history_marker < size)
gtk_widget_set_sensitive (redo, TRUE);
else
gtk_widget_set_sensitive (redo, FALSE);
}
G_MODULE_EXPORT
void load_from_flash_btn_clicked_cb ()
{
gint32 kF_i, kP_i, kI_i, kD_i, kG_i, VL;
if (!(serial_port_load_parameters (
gtk_combo_box_get_active (GTK_COMBO_BOX (select_flash_cbox)),
&VL, &kF_i, &kP_i, &kI_i, &kD_i, &kG_i)))
{
print_status ("Serial port timeout");
return;
}
gtk_adjustment_set_value (GTK_ADJUSTMENT (GET_OBJECT ("speed_adj")),
VL);
gtk_adjustment_set_value (GTK_ADJUSTMENT (GET_OBJECT ("kF_adj")),
(gdouble) kF_i / (gdouble) (1 << FIXED_POINT_POS));
gtk_adjustment_set_value (GTK_ADJUSTMENT (GET_OBJECT ("kP_adj")),
(gdouble) kP_i / (gdouble) (1 << FIXED_POINT_POS));
gtk_adjustment_set_value (GTK_ADJUSTMENT (GET_OBJECT ("kI_adj")),
(gdouble) kI_i / (gdouble) (1 << FIXED_POINT_POS));
gtk_adjustment_set_value (GTK_ADJUSTMENT (GET_OBJECT ("kD_adj")),
(gdouble) kD_i / (gdouble) (1 << FIXED_POINT_POS));
gtk_adjustment_set_value (GTK_ADJUSTMENT (GET_OBJECT ("kG_adj")),
(gdouble) kG_i / (gdouble) (1 << FIXED_POINT_POS));
print_status ("OK");
}
static void
update_window_title (void)
{
GtkWidget * window = GET_OBJECT ("window");
const size_t size = 256;
static gchar * buffer = NULL;
g_free (buffer);
buffer = g_malloc (size);
if (game_file != NULL)
snprintf (buffer, size, UI_WINDOW_TITLE, game_file);
else
snprintf (buffer, size, UI_WINDOW_TITLE, _("New game"));
gtk_window_set_title (GTK_WINDOW (window), buffer);
}
G_MODULE_EXPORT
void read_btn_clicked_cb ()
{
gint32 pos;
if (!serial_read_position (&pos)) {
print_status ("Serial port timeout");
return;
}
gchar *str = g_strdup_printf ("%d", pos);
gtk_entry_set_text (GTK_ENTRY (GET_OBJECT ("position_txt")), str);
g_free (str);
print_status ("OK");
}
/* Map G_LOG_LEVEL_MESSAGE logs to GTK error dialogs. */
static void
ui_log_level_message (const gchar * log_domain, GLogLevelFlags log_level,
const char * message, gpointer user_data)
{
GtkWidget *window = GET_OBJECT("window");;
GtkWidget * dialog;
dialog = gtk_message_dialog_new (GTK_WINDOW(window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
"%s", message);
gtk_window_set_title (GTK_WINDOW (dialog), _("Error"));
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
}
void
ui_signal_open (GtkMenuItem * item, gpointer data)
{
GtkWidget *dialog;
GtkWidget *window = GET_OBJECT("window");
char * filename;
Hexboard * board;
dialog = gtk_file_chooser_dialog_new (_("Open"),
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_widget_set_size_request(GTK_WIDGET(dialog), 800, 600);
/* Configure the previewer widget */
board = HEXBOARD (hexboard_new (10));
gtk_widget_set_size_request(GTK_WIDGET(board), 340, 240);
gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER(dialog), GTK_WIDGET(board));
g_signal_connect (dialog, "update-preview", G_CALLBACK (ui_signal_open_update_preview), board);
/* Set filters */
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_auto);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_sgf);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_lg_sgf);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
Hexboard * board = HEXBOARD (hexboard);
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
game_file = filename;
update_window_title();
hex_free (game);
game_format = dialog_selected_format (dialog);
game = hex_load_sgf (game_format, filename);
hexboard_set_size (board, hex_size (game));
g_free (filename);
history_marker = undo_history_marker = hex_history_current (game);
update_hexboard_colors ();
update_hexboard_sensitive();
update_history_buttons();
check_end_of_game();
}
gtk_widget_destroy (dialog);
}
G_MODULE_EXPORT
void chart_btn_clicked_cb ()
{
gint32 *buf;
guint32 size;
if (!serial_port_get_feedback (&buf, &size)) {
print_status ("Serial port timeout");
return;
}
chart_apply_data (GET_VALUE (GET_OBJECT ("setpoint_adj")), buf, size);
print_status ("OK");
gtk_widget_queue_draw (chart_da);
g_free (buf);
}
/* Map G_LOG_LEVEL_INFO logs to the window's status bar. */
static void
ui_log_level_info (const gchar * log_domain, GLogLevelFlags log_level,
const char * message, gpointer user_data)
{
static GtkWidget * statusbar;
static guint context;
static guint initialized = 0;
if (!initialized)
{
statusbar = GET_OBJECT ("statusbar");
context = gtk_statusbar_get_context_id(GTK_STATUSBAR (statusbar), "Game messages");
initialized = 1;
}
gtk_statusbar_pop (GTK_STATUSBAR (statusbar), context);
gtk_statusbar_push (GTK_STATUSBAR (statusbar), context, message);
gtk_main_iteration();
}
G_MODULE_EXPORT
void gains_set_btn_clicked_cb (GtkButton *button, gpointer unused)
{
gint32 VL = round (GET_VALUE (GET_OBJECT ("speed_adj")));
gint32 kf = round (GET_VALUE (GET_OBJECT ("kF_adj")) * (double) (1 << FIXED_POINT_POS));
gint32 kp = round (GET_VALUE (GET_OBJECT ("kP_adj")) * (double) (1 << FIXED_POINT_POS));
gint32 ki = round (GET_VALUE (GET_OBJECT ("kI_adj")) * (double) (1 << FIXED_POINT_POS));
gint32 kd = round (GET_VALUE (GET_OBJECT ("kD_adj")) * (double) (1 << FIXED_POINT_POS));
gint32 kg = round (GET_VALUE (GET_OBJECT ("kG_adj")) * (double) (1 << FIXED_POINT_POS));
serial_port_send_parameters (VL, kf, kp, ki, kd, kg);
print_status ("OK");
}
DEFINE_CALLBACKS
static void gevent_run_callbacks(struct ev_loop *_loop, void *watcher, int revents) {
struct PyGeventLoopObject* loop;
PyObject *result;
GIL_DECLARE;
GIL_ENSURE;
loop = GET_OBJECT(PyGeventLoopObject, watcher, _signal_checker);
Py_INCREF(loop);
gevent_check_signals(loop);
result = ((struct __pyx_vtabstruct_6gevent_4core_loop *)loop->__pyx_vtab)->_run_callbacks(loop);
if (result) {
Py_DECREF(result);
}
else {
PyErr_Print();
PyErr_Clear();
}
Py_DECREF(loop);
GIL_RELEASE;
}
GtkDialog* remmina_ext_exec_new(RemminaFile* remminafile, const char *remmina_ext_exec_type)
{
TRACE_CALL(__func__);
GtkBuilder *builder;
PCon_Spinner *pcspinner;
GError *error = NULL;
char **argv;
gchar *cmd = NULL;
GString *cmd_str;
gchar pre[11];
gchar post[12];
GPid child_pid;
strcpy(pre, "precommand");
strcpy(post, "postcommand");
if (remmina_ext_exec_type != NULL && (
strcmp(remmina_ext_exec_type, pre) |
strcmp(remmina_ext_exec_type, post) )) {
cmd_str = g_string_new(remmina_file_get_string(remminafile, remmina_ext_exec_type));
remmina_utils_string_replace_all(cmd_str, "%h", remmina_file_get_string(remminafile, "server"));
remmina_utils_string_replace_all(cmd_str, "%t", remmina_file_get_string(remminafile, "ssh_server"));
remmina_utils_string_replace_all(cmd_str, "%u", remmina_file_get_string(remminafile, "username"));
remmina_utils_string_replace_all(cmd_str, "%U", remmina_file_get_string(remminafile, "ssh_username"));
remmina_utils_string_replace_all(cmd_str, "%p", remmina_file_get_string(remminafile, "name"));
remmina_utils_string_replace_all(cmd_str, "%g", remmina_file_get_string(remminafile, "group"));
}else{
return FALSE;
}
cmd = g_string_free(cmd_str, FALSE);
if (*cmd != 0) {
pcspinner = g_new(PCon_Spinner, 1);
builder = remmina_public_gtk_builder_new_from_file("remmina_spinner.glade");
pcspinner->dialog = GTK_DIALOG(gtk_builder_get_object(builder, "DialogSpinner"));
pcspinner->label_pleasewait = GTK_LABEL(GET_OBJECT("label_pleasewait"));
pcspinner->spinner = GTK_WIDGET(GET_OBJECT("spinner"));
pcspinner->button_cancel = GTK_BUTTON(GET_OBJECT("button_cancel"));
/* Connect signals */
gtk_builder_connect_signals(builder, NULL);
/* Exec a predefined command */
g_shell_parse_argv(cmd, NULL, &argv, &error);
if (error) {
g_warning("%s\n", error->message);
g_error_free(error);
}
/* Consider using G_SPAWN_SEARCH_PATH_FROM_ENVP (from glib 2.38)*/
g_spawn_async( NULL, // cwd
argv, // argv
NULL, // envp
G_SPAWN_SEARCH_PATH |
G_SPAWN_SEARCH_PATH_FROM_ENVP |
G_SPAWN_DO_NOT_REAP_CHILD, // flags
NULL, // child_setup
NULL, // child_setup user data
&child_pid, // pid location
&error); // error
if (!error) {
gtk_spinner_start(GTK_SPINNER(pcspinner->spinner));
g_child_watch_add(child_pid, wait_for_child, (gpointer)pcspinner);
gtk_dialog_run(pcspinner->dialog);
}else {
g_warning("Command %s exited with error: %s\n", cmd, error->message);
g_error_free(error);
}
g_strfreev(argv);
return (pcspinner->dialog);
}
return FALSE;
}
G_MODULE_EXPORT
void set_btn_clicked_cb (GtkButton *button, gpointer unused)
{
serial_port_send_setpoint (round (GET_VALUE (GET_OBJECT ("setpoint_adj"))));
print_status ("OK");
}
G_MODULE_EXPORT
void go_zero_btn_clicked_cb (GtkButton *button, gpointer unused)
{
gtk_adjustment_set_value (GTK_ADJUSTMENT (GET_OBJECT ("set_speed_adj")), 0);
}
while (timer_us < wait_us)
{
g_timer_stop (timer);
timer_us = g_timer_elapsed (timer, NULL);
g_timer_continue (timer);
gtk_main_iteration_do (FALSE);
}
g_timer_destroy (timer);
}
guint32 velocity;
serial_port_send_reset ();
wait (2);
velocity = round (GET_VALUE (GET_OBJECT ("speed_adj")));
gint32 kf = round (GET_VALUE (GET_OBJECT ("kF_adj")) * (double) (1 << FIXED_POINT_POS));
gint32 kp = round (GET_VALUE (GET_OBJECT ("kP_adj")) * (double) (1 << FIXED_POINT_POS));
gint32 ki = round (GET_VALUE (GET_OBJECT ("kI_adj")) * (double) (1 << FIXED_POINT_POS));
gint32 kd = round (GET_VALUE (GET_OBJECT ("kD_adj")) * (double) (1 << FIXED_POINT_POS));
gint32 kg = round (GET_VALUE (GET_OBJECT ("kG_adj")) * (double) (1 << FIXED_POINT_POS));
serial_port_send_parameters (velocity, kf, kp, ki, kd, kg);
serial_port_send_save_parameters (
gtk_combo_box_get_active (GTK_COMBO_BOX (select_flash_cbox)));
g_printf ("%d\n", gtk_combo_box_get_active (GTK_COMBO_BOX (select_flash_cbox)));
wait (4);
print_status ("OK");
}
void
ui_signal_network (GtkMenuItem * item, gpointer data)
{
GtkWidget * xmpp = GET_OBJECT ("window-multiplayer");
gtk_widget_show_all (GTK_WIDGET(xmpp));
}
static void gevent_periodic_signal_check(struct ev_loop *_loop, void *watcher, int revents) {
GIL_DECLARE;
GIL_ENSURE;
gevent_check_signals(GET_OBJECT(PyGeventLoopObject, watcher, _periodic_signal_checker));
GIL_RELEASE;
}
void SlackRTM::handlePayloadReceived(const std::string &payload) {
Json::Value d;
Json::CharReaderBuilder rbuilder;
std::unique_ptr<Json::CharReader> const reader(rbuilder.newCharReader());
if (!reader->parse(payload.c_str(), payload.c_str() + payload.size(), &d, nullptr)) {
LOG4CXX_ERROR(logger, "Error while parsing JSON");
LOG4CXX_ERROR(logger, payload);
return;
}
STORE_STRING(d, type);
if (type == "message") {
STORE_STRING(d, channel);
STORE_STRING(d, text);
STORE_STRING(d, ts);
STORE_STRING_OPTIONAL(d, subtype);
STORE_STRING_OPTIONAL(d, purpose);
Json::Value &attachments = d["attachments"];
if (attachments.isArray()) {
for (unsigned i = 0; i < attachments.size(); i++) {
STORE_STRING_OPTIONAL(attachments[i], fallback);
if (!fallback.empty()) {
text += fallback;
}
}
}
if (subtype == "bot_message") {
STORE_STRING(d, bot_id);
onMessageReceived(channel, bot_id, text, ts);
}
else if (subtype == "me_message") {
text = "/me " + text;
STORE_STRING(d, user);
onMessageReceived(channel, user, text, ts);
}
else if (subtype == "channel_join") {
}
else if (!purpose.empty()) {
}
else {
STORE_STRING(d, user);
onMessageReceived(channel, user, text, ts);
}
}
else if (type == "channel_joined"
|| type == "channel_created") {
std::map<std::string, SlackChannelInfo> &channels = m_idManager->getChannels();
SlackAPI::getSlackChannelInfo(NULL, true, d, payload, channels);
}
else if (type == "error") {
GET_OBJECT(d, error);
STORE_INT(error, code);
if (code == 1) {
LOG4CXX_INFO(logger, "Reconnecting to Slack network");
m_pingTimer->stop();
m_client->disconnectServer();
start();
}
}
}
