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(); } } }