static void pop_status(GtkWidget* widget,gpointer user_data) { guint id = GPOINTER_TO_UINT(user_data); gtk_statusbar_pop((GtkStatusbar*)status,id); }
static void pop_button_clicked(GtkWidget *widget, gpointer data) { gtk_statusbar_pop(GTK_STATUSBAR(statusbar), GPOINTER_TO_INT(data)); }
static void update_statusbar(char *msg) { gtk_statusbar_pop(GTK_STATUSBAR(statusbar), 1); gtk_statusbar_push(GTK_STATUSBAR(statusbar), 1, msg); }
static gboolean capture_add_binding (GtkWidget * widget, GdkEventKey * event, gpointer user_data) { GdkModifierType modifiers; guint command_idx; GtkTreeModel *model; GtkTreeSelection *selection; GtkTreeIter iter; GtkTreePath *path; gint *array; keyboard_dialog_data *cbdata = (keyboard_dialog_data *) user_data; //get the shortcut if (isModifier (event)) return TRUE; dnm_clean_event (event); modifiers = dnm_sanitize_key_state (event); gchar *name = dnm_accelerator_name (event->keyval, event->state); if (!strcmp(name, "VoidSymbol")) { warningdialog (_("VoidSymbol not allowed")); return TRUE; } if (cbdata->two_key == 1) { gint command_idx = lookup_command_for_keybinding_name (Denemo.map, name); if (command_idx == -1) { cbdata->first_keyval = event->keyval; cbdata->first_modifiers = modifiers; cbdata->two_key = 2; return TRUE; } else { cbdata->two_key = 0; gchar *msg = g_strdup_printf (_("The command %s has the shortcut: %s\nDelete it first or start again selecting an unused keypress."), lookup_name_from_idx (Denemo.map, command_idx), name); warningdialog (msg); g_free (msg); g_free (name); g_warning ("trying to set a two key starting with a single"); return TRUE; } } //get the command_index selection = gtk_tree_view_get_selection (cbdata->command_view); gtk_tree_selection_get_selected (selection, &model, &iter); path = gtk_tree_model_get_path (model, &iter); array = gtk_tree_path_get_indices (path); command_idx = array[0]; //this fails in general, yielding the value in cbdata, instead ... gchar* cname = NULL; gtk_tree_model_get (model, &iter, COL_NAME, &cname, -1); command_idx = lookup_command_from_name (Denemo.map, cname); if(command_idx != cbdata->command_id) g_warning("correct command idx %d compare %d for action of name %s\n", command_idx, cbdata->command_id, cname); gtk_tree_path_free (path); if (cbdata->two_key == 0 && (GList *) g_hash_table_lookup (Denemo.map->continuations_table, name)) { //g_warning("There is a two key binding starting with this"); gchar *msg = g_strdup_printf (_("There is at least one two-key shortcut that starts with: %s\nFind them using the Find button\nDelete it/those first or start again selecting an unused keypress."), name); warningdialog (msg); g_free (msg); g_free (name); return TRUE; } g_free (name); //set the new binding if (cbdata->two_key == 2) add_twokeybinding_to_idx (Denemo.map, cbdata->first_keyval, cbdata->first_modifiers, event->keyval, modifiers, command_idx, POS_FIRST); else add_keybinding_to_idx (Denemo.map, event->keyval, modifiers, command_idx, POS_FIRST); command_row* row = NULL; keymap_get_command_row (Denemo.map, &row, command_idx); GtkListStore* bindings_model = GTK_LIST_STORE(gtk_tree_view_get_model(cbdata->binding_view)); update_bindings_model(bindings_model, row->bindings); gtk_statusbar_pop (cbdata->statusbar, cbdata->context_id); g_signal_handler_disconnect (GTK_WIDGET (widget), cbdata->handler_key_press); g_signal_handler_disconnect (GTK_WIDGET (widget), cbdata->handler_focus_out); cbdata->two_key = 0; return TRUE; }
gboolean button_press_event_handler(GtkWidget *widget, GdkEventButton *event, gpointer data) { cairo_t *pointCr = gdk_cairo_create(widget->window), *lineCr = gdk_cairo_create(widget->window), *player1BoxCr = gdk_cairo_create(widget->window), *player2BoxCr = gdk_cairo_create(widget->window); cairo_set_source_rgba_from_string(pointCr, POINT_COLOR, 1); cairo_set_source_rgba_from_string(lineCr, LINE_COLOR, 1); cairo_set_source_rgba_from_string(player1BoxCr, PLAYER_1_BOX_COLOR, 1); cairo_set_source_rgba_from_string(player2BoxCr, PLAYER_2_BOX_COLOR, 1); cairo_set_line_width(lineCr, pointRadius * 1.4); gint x = (gint) event->x, y = (gint) event->y; if (isClickInsideFrame(x, y)) { timer = true; fadingLineAlpha = -1; gtk_widget_queue_draw(event_box); timer = false; fadingLineAlpha = 1; buttonPressCount %= 2; TurnResult result; if (!buttonPressCount) { result = playerTurn(lineCr, player1BoxCr, pointCr, head, x, y, lineLength, pointRadius, &BoxOfPlayer1, firstPlayerBox); if (result == lineDrawn) { gtk_statusbar_pop(GTK_STATUSBAR(data), status_context_id); if (opponent == HUMAN) buttonPressCount++; else { g_signal_handler_block(event_box, button_press_handler_id); computerPoints = computerTurn(head, lineCr, player2BoxCr, pointCr, lineLength, pointRadius, &BoxOfPlayer2, secondPlayerBox, &event_box, difficulty); g_signal_handler_unblock(event_box, button_press_handler_id); if (!computerPoints) { gtk_statusbar_push(GTK_STATUSBAR(data), status_context_id, "Game Over"); timer = false; result_message(player1Name, player2Name, BoxOfPlayer1, BoxOfPlayer2); } else { gtk_statusbar_push(GTK_STATUSBAR(data), status_context_id, player1Name); if ((*computerPoints)->x == (*(computerPoints + 1))->x) (*computerPoints)->verticalDown = (*(computerPoints + 1))->verticalUp = true; else (*computerPoints)->horizontalRight = (*(computerPoints + 1))->horizontalLeft = true; timer = true; g_timeout_add(fadeTimeInterval, (GSourceFunc) fade_out_handler, NULL); } } } if (result == frameIsFull) { gtk_statusbar_push(GTK_STATUSBAR(data), status_context_id, "Game Over"); result_message(player1Name, player2Name, BoxOfPlayer1, BoxOfPlayer2); } } else { result = playerTurn(lineCr, player2BoxCr, pointCr, head, x, y, lineLength, pointRadius, &BoxOfPlayer2, secondPlayerBox); if (result == lineDrawn) { buttonPressCount++; gtk_statusbar_push(GTK_STATUSBAR(data), status_context_id, player1Name); } if (result == frameIsFull) { gtk_statusbar_push(GTK_STATUSBAR(data), status_context_id, "Game Over"); result_message(player1Name, player2Name, BoxOfPlayer1, BoxOfPlayer2); } } } cairo_destroy(pointCr); cairo_destroy(lineCr); cairo_destroy(player1BoxCr); cairo_destroy(player2BoxCr); return TRUE; }
/* Setup the content of the tree model. */ void populate_tree_model (GtkWidget *treeview) { GtkWidget *entry, *statusbar; GdkPixbuf *pixbuf_file, *pixbuf_dir; GtkListStore *store; GtkTreeIter iter; GdkPixbuf *directory; struct stat st; gchar *location, *file, *message; gfloat size, total_size = 0; gint i, items = 0;; GDir *dir; store = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (treeview))); gtk_list_store_clear (store); location = path_to_string (); /* If the current location is not the root directory, add the '..' entry. */ if (g_list_length (current_path) > 0) { directory = gdk_pixbuf_new_from_file ("directory.png", NULL); gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, ICON, directory, FILENAME, "..", -1); } /* Return if the path does not exist. */ if (!g_file_test (location, G_FILE_TEST_IS_DIR)) { file_manager_error ("The path %s does not exist!"); g_free (location); return; } /* Display the new location in the address bar. */ entry = glade_xml_get_widget (xml, "location"); gtk_entry_set_text (GTK_ENTRY (entry), location); /* Add each file to the list along with the file size and modified date. */ pixbuf_dir = gdk_pixbuf_new_from_file ("directory.png", NULL); pixbuf_file = gdk_pixbuf_new_from_file ("file.png", NULL); dir = g_dir_open (location, 0, NULL); while ((file = (gchar*) g_dir_read_name (dir))) { gchar *fn, *filesize, *modified; fn = g_strconcat (location, "/", file, NULL); if (g_stat (fn, &st) == 0) { /* Calculate the file size and order of magnitude. */ i = 0; size = (gfloat) st.st_size; total_size += size; while (size >= 1024.0) { size = size / 1024.0; i++; } /* Create strings for the file size and last modified date. */ filesize = g_strdup_printf ("%.1f %s", size, size_type[i]); modified = g_strdup (ctime (&st.st_mtime)); modified[strlen(modified)-1] = '\0'; } /* Add the file and its properties as a new tree view row. */ gtk_list_store_append (store, &iter); if (g_file_test (fn, G_FILE_TEST_IS_DIR)) gtk_list_store_set (store, &iter, ICON, pixbuf_dir, FILENAME, file, SIZE, filesize, MODIFIED, modified, -1); else gtk_list_store_set (store, &iter, ICON, pixbuf_file, FILENAME, file, SIZE, filesize, MODIFIED, modified, -1); items++; g_free (fn); } /* Calculate the total size of the directory content. */ i = 0; while (total_size >= 1024.0) { total_size = total_size / 1024.0; i++; } /* Add the number of items and the total size of the directory content * to the status bar. */ statusbar = glade_xml_get_widget (xml, "statusbar"); message = g_strdup_printf ("%d items, Total Size: %.1f %s", items, total_size, size_type[i]); gtk_statusbar_pop (GTK_STATUSBAR (statusbar), context_id); gtk_statusbar_push (GTK_STATUSBAR (statusbar), context_id, message); g_object_unref (pixbuf_dir); g_object_unref (pixbuf_file); g_free (message); }
static void create_object_button_release(CreateObjectTool *tool, GdkEventButton *event, DDisplay *ddisp) { GList *list = NULL; DiaObject *obj = tool->obj; gboolean reset; GList *parent_candidates; g_return_if_fail (obj != NULL); if (!obj) /* not sure if this isn't enough */ return; /* could be a legal invariant */ if (tool->moving) { gdk_pointer_ungrab (event->time); object_add_updates(tool->obj, ddisp->diagram); tool->obj->ops->move_handle(tool->obj, tool->handle, &tool->last_to, NULL, HANDLE_MOVE_CREATE_FINAL, 0); object_add_updates(tool->obj, ddisp->diagram); } parent_candidates = layer_find_objects_containing_rectangle(obj->parent_layer, &obj->bounding_box); /* whole object must be within another object to parent it */ for (; parent_candidates != NULL; parent_candidates = g_list_next(parent_candidates)) { DiaObject *parent_obj = (DiaObject *) parent_candidates->data; if (obj != parent_obj && object_within_parent(obj, parent_obj)) { Change *change = undo_parenting(ddisp->diagram, parent_obj, obj, TRUE); (change->apply)(change, ddisp->diagram); break; /* obj->parent = parent_obj; parent_obj->children = g_list_append(parent_obj->children, obj); */ } } g_list_free(parent_candidates); list = g_list_prepend(list, tool->obj); undo_insert_objects(ddisp->diagram, list, 1); if (tool->moving) { if (tool->handle->connect_type != HANDLE_NONCONNECTABLE) { object_connect_display(ddisp, tool->obj, tool->handle, TRUE); diagram_update_connections_selection(ddisp->diagram); diagram_flush(ddisp->diagram); } tool->moving = FALSE; tool->handle = NULL; tool->obj = NULL; } { /* remove position from status bar */ GtkStatusbar *statusbar = GTK_STATUSBAR (ddisp->modified_status); guint context_id = gtk_statusbar_get_context_id (statusbar, "ObjectPos"); gtk_statusbar_pop (statusbar, context_id); } highlight_reset_all(ddisp->diagram); reset = prefs.reset_tools_after_create != tool->invert_persistence; /* kind of backward: first starting editing to see if it is possible at all, than GUI reflection */ if (textedit_activate_object(ddisp, obj, NULL) && reset) { gtk_action_activate (menus_get_action ("ToolsTextedit")); reset = FALSE; /* don't switch off textedit below */ } diagram_update_extents(ddisp->diagram); diagram_modified(ddisp->diagram); undo_set_transactionpoint(ddisp->diagram->undo); if (reset) tool_reset(); ddisplay_set_all_cursor(default_cursor); ddisplay_do_update_menu_sensitivity(ddisp); }
extern void change_grid_popup(GtkAction *action, gpointer user_data) { GtkWidget *table = gtk_table_new(1, 2, FALSE); GtkWidget *label; GtkObject *adjustment; GtkWidget *width_sb, *hori_sb, *vert_sb; int width = working_sview_config.grid_x_width, hori = working_sview_config.grid_hori, vert = working_sview_config.grid_vert; GtkWidget *popup = gtk_dialog_new_with_buttons( "Grid Properties", GTK_WINDOW (user_data), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, NULL); GError *error = NULL; int response = 0; char *temp = NULL; label = gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_window_set_default(GTK_WINDOW(popup), label); gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), table, FALSE, FALSE, 0); label = gtk_label_new("Nodes in row "); adjustment = gtk_adjustment_new(working_sview_config.grid_x_width, 1, 1000, 1, 60, 0); width_sb = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1, 0); gtk_container_set_border_width(GTK_CONTAINER(table), 10); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1); gtk_table_attach_defaults(GTK_TABLE(table), width_sb, 1, 2, 0, 1); label = gtk_label_new("Nodes before horizontal break "); adjustment = gtk_adjustment_new(working_sview_config.grid_hori, 1, 1000, 1, 60, 0); hori_sb = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1, 0); gtk_container_set_border_width(GTK_CONTAINER(table), 10); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2); gtk_table_attach_defaults(GTK_TABLE(table), hori_sb, 1, 2, 1, 2); label = gtk_label_new("Nodes before vertical break "); adjustment = gtk_adjustment_new(working_sview_config.grid_vert, 1, 1000, 1, 60, 0); vert_sb = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1, 0); gtk_container_set_border_width(GTK_CONTAINER(table), 10); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 2, 3); gtk_table_attach_defaults(GTK_TABLE(table), vert_sb, 1, 2, 2, 3); /*TODO * do we care about this? label = gtk_label_new("Topology ordered "); adjustment = gtk_adjustment_new(working_sview_config.grid_topological, 1, 1000, 1, 60, 0); GtkWidget *gtbtton = gtk_check_button_new (); gtk_container_set_border_width(GTK_CONTAINER(table), 10); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 3, 4); gtk_table_attach_defaults(GTK_TABLE(table), gtbtton, 1, 2, 3, 4); gtk_toggle_button_set_active (>btton, working_sview_config.grid_topological); */ gtk_widget_show_all(popup); response = gtk_dialog_run (GTK_DIALOG(popup)); if (response == GTK_RESPONSE_OK) { working_sview_config.grid_x_width = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON(width_sb)); working_sview_config.grid_hori = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON(hori_sb)); working_sview_config.grid_vert = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON(vert_sb)); memcpy(&default_sview_config, &working_sview_config, sizeof(sview_config_t)); if ((width == working_sview_config.grid_x_width) && (hori == working_sview_config.grid_hori) && (vert == working_sview_config.grid_vert)) { temp = g_strdup_printf("Grid: Nothing changed."); } else if (working_sview_config.grid_topological) { temp = g_strdup_printf("Grid: Invalid mode .." " switch to non-topology " "order first."); } else { bool refresh = 0; temp = g_strdup_printf( "Grid set to %d nodes breaks " "at %d H and %d V.", working_sview_config.grid_x_width, working_sview_config.grid_hori, working_sview_config.grid_vert); /* If the old width was wider than the * current we need to remake the list so the * table gets set up correctly, so destroy it * here and it will be remade in get_system_stats(). */ if ((width > working_sview_config.grid_x_width) && grid_button_list) { list_destroy(grid_button_list); grid_button_list = NULL; refresh = 1; } get_system_stats(main_grid_table); if (refresh) refresh_main(NULL, NULL); } gtk_statusbar_pop(GTK_STATUSBAR(main_statusbar), STATUS_REFRESH); response = gtk_statusbar_push(GTK_STATUSBAR(main_statusbar), STATUS_REFRESH, temp); g_free(temp); if (!sview_thread_new(_refresh_thr, GINT_TO_POINTER(response), FALSE, &error)) { g_printerr ("Failed to create refresh thread: %s\n", error->message); } } gtk_widget_destroy(popup); return; }
static void on_menu_item_deselected (GtkMenuItem *item, LdWindowMain *window) { gtk_statusbar_pop (GTK_STATUSBAR (window->priv->statusbar), window->priv->statusbar_menu_context_id); }
void status_pop() { if(statcount <= 0) return; gtk_statusbar_pop(GTK_STATUSBAR(status), 1); statcount--; sync_display(); }
extern void change_refresh_popup(GtkAction *action, gpointer user_data) { GtkWidget *table = gtk_table_new(1, 2, FALSE); GtkWidget *label = NULL; GtkObject *adjustment = gtk_adjustment_new( working_sview_config.refresh_delay, 1, 10000, 5, 60, 0); GtkWidget *spin_button = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1, 0); GtkWidget *popup = gtk_dialog_new_with_buttons( "Refresh Interval", GTK_WINDOW (user_data), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, NULL); GError *error = NULL; int response = 0; char *temp = NULL; label = gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_window_set_default(GTK_WINDOW(popup), label); gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); label = gtk_label_new("Interval in Seconds "); gtk_container_set_border_width(GTK_CONTAINER(table), 10); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), table, FALSE, FALSE, 0); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1); gtk_table_attach_defaults(GTK_TABLE(table), spin_button, 1, 2, 0, 1); gtk_widget_show_all(popup); response = gtk_dialog_run (GTK_DIALOG(popup)); if (response == GTK_RESPONSE_OK) { working_sview_config.refresh_delay = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON(spin_button)); temp = g_strdup_printf("Refresh Interval set to %d seconds.", working_sview_config.refresh_delay); gtk_statusbar_pop(GTK_STATUSBAR(main_statusbar), STATUS_REFRESH); response = gtk_statusbar_push(GTK_STATUSBAR(main_statusbar), STATUS_REFRESH, temp); g_free(temp); if (!sview_thread_new(_refresh_thr, GINT_TO_POINTER(response), FALSE, &error)) { g_printerr ("Failed to create refresh thread: %s\n", error->message); } } gtk_widget_destroy(popup); return; }
void status_clear() { gtk_statusbar_pop(GTK_STATUSBAR(progress), 1); pct = 0.0; }
static void modify_button_release(ModifyTool *tool, GdkEventButton *event, DDisplay *ddisp) { Point *dest_pos, to; GList *list; int i; ObjectChange *objchange; tool->break_connections = FALSE; ddisplay_set_all_cursor(default_cursor); /* remove position from status bar */ { GtkStatusbar *statusbar = GTK_STATUSBAR (ddisp->modified_status); guint context_id = gtk_statusbar_get_context_id (statusbar, "ObjectPos"); gtk_statusbar_pop (statusbar, context_id); } switch (tool->state) { case STATE_MOVE_OBJECT: /* Return to normal state */ gdk_pointer_ungrab (event->time); ddisplay_untransform_coords(ddisp, event->x, event->y, &to.x, &to.y); if (!modify_move_already(tool, ddisp, &to)) { tool->orig_pos = NULL; tool->state = STATE_NONE; return; } diagram_update_connections_selection(ddisp->diagram); if (tool->orig_pos != NULL) { /* consider the non-selected children affected */ list = parent_list_affected(ddisp->diagram->data->selected); dest_pos = g_new(Point, g_list_length(list)); i=0; while (list != NULL) { DiaObject *obj = (DiaObject *) list->data; dest_pos[i] = obj->position; list = g_list_next(list); i++; } undo_move_objects(ddisp->diagram, tool->orig_pos, dest_pos, parent_list_affected(ddisp->diagram->data->selected)); } ddisplay_connect_selected(ddisp); /* pushes UNDO info */ diagram_update_extents(ddisp->diagram); diagram_modified(ddisp->diagram); diagram_flush(ddisp->diagram); undo_set_transactionpoint(ddisp->diagram->undo); tool->orig_pos = NULL; tool->state = STATE_NONE; break; case STATE_MOVE_HANDLE: gdk_pointer_ungrab (event->time); tool->state = STATE_NONE; if (tool->orig_pos != NULL) { undo_move_handle(ddisp->diagram, tool->handle, tool->object, *tool->orig_pos, tool->last_to); } /* Final move: */ object_add_updates(tool->object, ddisp->diagram); objchange = tool->object->ops->move_handle(tool->object, tool->handle, &tool->last_to, NULL, HANDLE_MOVE_USER_FINAL,gdk_event_to_dia_ModifierKeys(event->state)); if (objchange != NULL) { undo_object_change(ddisp->diagram, tool->object, objchange); } object_add_updates(tool->object, ddisp->diagram); /* Connect if possible: */ if (tool->handle->connect_type != HANDLE_NONCONNECTABLE) { object_connect_display(ddisp, tool->object, tool->handle, TRUE); /* pushes UNDO info */ diagram_update_connections_selection(ddisp->diagram); } highlight_reset_all(ddisp->diagram); diagram_flush(ddisp->diagram); diagram_modified(ddisp->diagram); diagram_update_extents(ddisp->diagram); undo_set_transactionpoint(ddisp->diagram->undo); if (tool->orig_pos != NULL) { g_free(tool->orig_pos); tool->orig_pos = NULL; } break; case STATE_BOX_SELECT: gdk_pointer_ungrab (event->time); /* Remove last box: */ if (!tool->auto_scrolled) { gdk_draw_rectangle (gtk_widget_get_window (ddisp->canvas), tool->gc, FALSE, tool->x1, tool->y1, tool->x2 - tool->x1, tool->y2 - tool->y1); } { GList *list, *list_to_free; list = list_to_free = find_selected_objects(ddisp, tool); if (selection_style == SELECT_REPLACE && !(event->state & GDK_SHIFT_MASK)) { /* Not Multi-select => Remove all selected */ diagram_remove_all_selected(ddisp->diagram, TRUE); } if (selection_style == SELECT_INTERSECTION) { GList *intersection = NULL; while (list != NULL) { DiaObject *obj = (DiaObject *)list->data; if (diagram_is_selected(ddisp->diagram, obj)) { intersection = g_list_append(intersection, obj); } list = g_list_next(list); } list = intersection; diagram_remove_all_selected(ddisp->diagram, TRUE); while (list != NULL) { DiaObject *obj = (DiaObject *)list->data; diagram_select(ddisp->diagram, obj); list = g_list_next(list); } g_list_free(intersection); } else { while (list != NULL) { DiaObject *obj = (DiaObject *)list->data; if (selection_style == SELECT_REMOVE) { if (diagram_is_selected(ddisp->diagram, obj)) diagram_unselect_object(ddisp->diagram, obj); } else if (selection_style == SELECT_INVERT) { if (diagram_is_selected(ddisp->diagram, obj)) diagram_unselect_object(ddisp->diagram, obj); else diagram_select(ddisp->diagram, obj); } else { if (!diagram_is_selected(ddisp->diagram, obj)) diagram_select(ddisp->diagram, obj); } list = g_list_next(list); } } g_list_free(list_to_free); } ddisplay_do_update_menu_sensitivity(ddisp); ddisplay_flush(ddisp); tool->state = STATE_NONE; break; case STATE_NONE: break; default: message_error("Internal error: Strange state in modify_tool\n"); } }
static void link_hover_cb(WebKitWebView* page, const gchar* title, const gchar* link, gpointer data) { /* underflow is allowed */ gtk_statusbar_pop(browser->statusbar, browser->status_context_id); if (link) gtk_statusbar_push(browser->statusbar, browser->status_context_id, link); }
void on_input_word_activate (GtkEntry *entry, gpointer user_data) { char *word = NULL, *entry_word = NULL; entry_word = gtk_entry_get_text ( mydata.input_word ); word = g_strchomp( g_strchug( g_strdown( entry_word ) ) ); if( strlen( word ) == 0 ){ //g_print("on_input_word_activate():word is NULL\n"); //avoid some latency by commenting below // gtk_statusbar_pop ( mydata.statusbar, mydata.statusbar_context_id ); gtk_statusbar_push (GTK_STATUSBAR (mydata.statusbar), mydata.statusbar_context_id, "Please enter a word"); // remove_all_from_list(); // empty the list as there is no word to search for // if we empty the list it causes a bug of not loading the list of same word although // hash table is still there }else{ //it is cause of latency // g_print("on_input_word_activate():word= %s\n", word ); if( ! isalpha( word[0] ) ){ //g_print("on_input_word_activate(): enter proper word\n"); // *************** show proper warning to enter proper word ********************** // gtk_statusbar_pop ( mydata.statusbar, mydata.statusbar_context_id ); gtk_statusbar_push (GTK_STATUSBAR (mydata.statusbar), mydata.statusbar_context_id, "Please enter proper english word"); // return; } //check if hash table is created for word[0] of not g_sprintf( file_loaded_name, APP_DBS"%c.db", g_ascii_tolower( word[0] ) ); // g_print("on_input_word_activate(): filename = %s\n",file_loaded_name); if( mydata.hash_tab[ g_ascii_toupper(word[0]) - 'A' ] == NULL ){ //remove the prev word entries //remove_all_from_list (); // g_print("on_input_word_activate(): generating hash table\n"); mydata.hash_tab[ g_ascii_toupper(word[0]) - 'A' ] = generate_hash_table( file_loaded_name ); mydata.list_store_arr[ g_ascii_toupper(word[0]) - 'A' ] = mydata.list_store; list_loaded = g_ascii_toupper(word[0]) - 'A'; //check if hash table is created or not by generate_hash_table() func call if( mydata.hash_tab[ g_ascii_toupper(word[0]) - 'A' ] == NULL ){ g_print("on_input_word_activate():\nafter trying to generate_hash_table\nfile: %s could not be located and loaded\n", file_loaded_name ); } }else{ //g_print("on_input_word_activate(): %d", list_loaded ); if( list_loaded != (g_ascii_toupper(word[0]) - 'A') ){ // if( mydata.list_store_arr[ g_ascii_toupper(word[0]) - 'A' ] == NULL ){ populate_list_only( file_loaded_name ); //g_print("on_input_word_changed(): list populated from file\n" ); }else{ mydata.list_store = mydata.list_store_arr[ g_ascii_toupper(word[0]) - 'A' ]; // following may be necessary gtk_tree_view_set_model ( mydata.treeview, GTK_TREE_MODEL(mydata.list_store) ); //g_print("on_input_word_changed(): list used from previous list\n" ); } list_loaded = (g_ascii_toupper(word[0]) - 'A'); // } } } on_find_clicked(); }
/* * Sets new state in session and GUI (also handles audio state) * * returns 0 on success, -1 otherwise (can't open audio device) */ int session_set_state(session_t *session, enum state_t state) { int result = 0; /* open / close audio when needed, set state */ session_io_handlers_stop(session); if (session->option_release_devices && state != session->state) { if (state == STATE_READY && session->state != STATE_RINGING_QUIET) { /* release */ session_audio_deinit(session); } else if ((session->state == STATE_READY || session->state == STATE_RINGING_QUIET) && state != STATE_READY && state != STATE_RINGING_QUIET) { /* (try to) resume */ if (session_audio_init(session)) { state = session->state; result = -1; } } } session->state = state; session_io_handlers_start(session); /* some menu items are selected only in STATE_READY */ gtk_widget_set_sensitive(session->menuitem_settings, state == STATE_READY); gtk_widget_set_sensitive(session->menuitem_line_check, state == STATE_READY); /* start / stop effects when needed */ switch (state) { case STATE_DIALING: if (session->effect == EFFECT_NONE) session_effect_start(session, EFFECT_RINGING); if (debug) fprintf(stderr, "New state: STATE_DIALING\n"); break; case STATE_RINGING: if (session->option_popup) { gtk_window_present(GTK_WINDOW(session->main_window)); } if (session->effect == EFFECT_NONE) session_effect_start(session, EFFECT_RING); if (debug) fprintf(stderr, "New state: STATE_RINGING\n"); break; case STATE_RINGING_QUIET: if (session->option_popup) { gtk_window_present(GTK_WINDOW(session->main_window)); } if (debug) fprintf(stderr, "New state: STATE_RINGING_QUIET\n"); break; case STATE_READY: gtk_widget_grab_focus(GTK_WIDGET(GTK_COMBO(session->dial_number_box) ->entry)); if (session->effect != EFFECT_NONE) session_effect_stop(session); if (debug) fprintf(stderr, "New state: STATE_READY\n"); break; case STATE_CONVERSATION: if (session->effect != EFFECT_NONE) session_effect_stop(session); session->touchtone_countdown_isdn = 0; session->touchtone_countdown_audio = 0; if (debug) fprintf(stderr, "New state: STATE_CONVERSATION\n"); break; case STATE_SERVICE: if (debug) fprintf(stderr, "New state: STATE_SERVICE\n"); break; case STATE_PLAYBACK: if (session->effect == EFFECT_NONE) session_effect_start(session, EFFECT_SOUNDFILE); if (debug) fprintf(stderr, "New state: STATE_PLAYBACK\n"); break; default: fprintf(stderr, "Warning: session_set_state: Unhandled state.\n"); } /* audio on / off notify */ if (session->option_release_devices) { session_audio_notify(session, state == STATE_READY || state == STATE_RINGING_QUIET ? _("Audio OFF") : _("Audio ON")); } else { session_audio_notify(session, ""); } /* status line */ gtk_statusbar_pop(GTK_STATUSBAR(session->status_bar), session->phone_context_id); gtk_statusbar_push(GTK_STATUSBAR(session->status_bar), session->phone_context_id, _(state_data[state].status_bar)); gtk_label_set_text(GTK_LABEL(session->pick_up_label), _(state_data[state].pick_up_label)); gtk_widget_set_sensitive(session->pick_up_button, state_data[state].pick_up_state); gtk_label_set_text(GTK_LABEL(session->hang_up_label), _(state_data[state].hang_up_label)); gtk_widget_set_sensitive(session->hang_up_button, state_data[state].hang_up_state); if (state == STATE_READY) { llcheck_bar_reset(session->llcheck_in); llcheck_bar_reset(session->llcheck_out); } return result; }
/* Create a new window loading a file */ static void shabdarth_new_window (GApplication *app, GFile *file) { GtkWidget *window; GtkBuilder *builder; GError* error = NULL; ShabdarthPrivate *priv = SHABDARTH_GET_PRIVATE(app); /* Load UI from file */ builder = gtk_builder_new (); if (!gtk_builder_add_from_file (builder, UI_FILE, &error)) { g_critical ("Couldn't load builder file: %s", error->message); g_error_free (error); } /* Auto-connect signal handlers */ gtk_builder_connect_signals (builder, app); /* Get the window object from the ui file */ mydata.window = GTK_WIDGET (gtk_builder_get_object (builder, TOP_WINDOW)); if (!mydata.window) { g_critical ("Widget \"%s\" is missing in file %s.", TOP_WINDOW, UI_FILE); } mydata.statusbar = GTK_STATUSBAR (gtk_builder_get_object(builder, "statusbar")); mydata.meaning_text_view = GTK_TEXT_VIEW (gtk_builder_get_object(builder, "meaning_text_view")); mydata.treeview = GTK_TREE_VIEW (gtk_builder_get_object(builder, "treeview")); mydata.input_word = GTK_ENTRY (gtk_builder_get_object(builder, "input_word")); // mydata.statusbar_context_id = gtk_statusbar_get_context_id ( mydata.statusbar,"shabdarth"); int i = 0; for( i = 0; i < ALPHABETS; i++ ) mydata.hash_tab[i] = NULL; // ************ initialising list_store_arr ************ for( i = 0; i < ALPHABETS; i++ ) mydata.list_store_arr[i] = NULL; gtk_tree_view_set_headers_visible ( mydata.treeview, FALSE ); //************ clipboard ************** //try GDK_SELECTION_CLIPBOARD or PRIMARY GtkClipboard* clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD); g_signal_connect(clipboard, "owner_change",G_CALLBACK(on_text_selection_changed), NULL); /* ANJUTA: Widgets initialization for shabdarth.ui - DO NOT REMOVE */ priv->treeview = GTK_WIDGET (gtk_builder_get_object(builder, "treeview")); g_object_unref (builder); gtk_window_set_application (GTK_WINDOW (mydata.window), GTK_APPLICATION (app)); if (file != NULL) { /* TODO: Add code here to open the file in the new window */ } gtk_widget_show_all (GTK_WIDGET (mydata.window)); gtk_statusbar_pop ( mydata.statusbar, mydata.statusbar_context_id ); gtk_statusbar_push (GTK_STATUSBAR (mydata.statusbar), mydata.statusbar_context_id, "Please enter a word"); }
void gui_status_pop(void) { gtk_statusbar_pop(GTK_STATUSBAR(statusbar), context); }
/* * Class: org_java_gtk_gtk_StatusBar * Method: gtk_statusbar_pop * Signature: (JI)V */ JNIEXPORT void JNICALL Java_org_java_1gtk_gtk_StatusBar_gtk_1statusbar_1pop (JNIEnv *env, jclass cls, jlong statusbar, jint context_id) { gtk_statusbar_pop((GtkStatusbar*)statusbar, (guint)context_id); }
static void on_status(FmFolderView* fv, const char* msg, FmMainWin* win) { gtk_statusbar_pop(GTK_STATUSBAR(win->statusbar), win->statusbar_ctx); gtk_statusbar_push(GTK_STATUSBAR(win->statusbar), win->statusbar_ctx, msg); }
static void create_object_motion(CreateObjectTool *tool, GdkEventMotion *event, DDisplay *ddisp) { Point to; ConnectionPoint *connectionpoint = NULL; gchar *postext; GtkStatusbar *statusbar; guint context_id; if (!tool->moving) return; ddisplay_untransform_coords(ddisp, event->x, event->y, &to.x, &to.y); /* make sure the new object is restricted to its parent */ parent_handle_move_out_check(tool->obj, &to); /* Move to ConnectionPoint if near: */ if (tool->handle != NULL && tool->handle->connect_type != HANDLE_NONCONNECTABLE) { connectionpoint = object_find_connectpoint_display(ddisp, &to, tool->obj, TRUE); if (connectionpoint != NULL) { to = connectionpoint->pos; highlight_object(connectionpoint->object, DIA_HIGHLIGHT_CONNECTIONPOINT, ddisp->diagram); ddisplay_set_all_cursor(get_cursor(CURSOR_CONNECT)); } } if (connectionpoint == NULL) { /* No connectionopoint near, then snap to grid (if enabled) */ snap_to_grid(ddisp, &to.x, &to.y); highlight_reset_all(ddisp->diagram); ddisplay_set_all_cursor(get_cursor(CURSOR_SCROLL)); } object_add_updates(tool->obj, ddisp->diagram); tool->obj->ops->move_handle(tool->obj, tool->handle, &to, connectionpoint, HANDLE_MOVE_CREATE, 0); object_add_updates(tool->obj, ddisp->diagram); /* Put current mouse position in status bar */ statusbar = GTK_STATUSBAR (ddisp->modified_status); context_id = gtk_statusbar_get_context_id (statusbar, "ObjectPos"); postext = g_strdup_printf("%.3f, %.3f - %.3f, %.3f", tool->obj->bounding_box.left, tool->obj->bounding_box.top, tool->obj->bounding_box.right, tool->obj->bounding_box.bottom); gtk_statusbar_pop (statusbar, context_id); gtk_statusbar_push (statusbar, context_id, postext); g_free(postext); diagram_flush(ddisp->diagram); tool->last_to = to; return; }
void gui_status_pop (gui *g) { gtk_statusbar_pop (g->status, g->cid); }
gboolean mouse_xy_movement(GtkWidget *widget, GdkEventMotion *event) { // caught a mouse movement event double coordx, coordy; gchar *buffer; int excode; select_t *new_select = select_create(); select_t *select_added = select_create(); select_t *select_omitted = select_create(); if (!fldstate.mouse_selection) fldstate.mouse_selection = select_create(); coordx = event->x; coordy = event->y; pixel_to_field(&coordx, &coordy); if ((event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK) { coordx = round(coordx); coordy = round(coordy); } if (fldstate.mouse_clicked == 0x1 && mouse_currentMode == SELECTONE) { // click drag // get what's currently in selection rectangle new_select = field_select_in_rectangle(new_select, fldstate.mouse_clickx, fldstate.mouse_clicky, coordx, coordy, false); // then find what's been added, what's gone select_add_multiple(select_added, new_select); select_add_multiple(select_omitted, fldstate.mouse_selection); select_remove_multiple(select_added, fldstate.mouse_selection); select_remove_multiple(select_omitted, new_select); // Store new set select_clear(fldstate.mouse_selection); select_add_multiple(fldstate.mouse_selection, new_select); select_update_center(fldstate.mouse_selection); // add new dots if (event->state == (GDK_BUTTON_PRESS_MASK | GDK_CONTROL_MASK)) { //select_push_all(&pstate.select, &select_added, true); //select_add_multiple(&pstate.select, &select_omitted, true); select_toggle_multiple(pstate.select, select_added); select_toggle_multiple(pstate.select, select_omitted); } else if (event->state == GDK_BUTTON_PRESS_MASK) { // normal or shift-clicked //select_push_all(&pstate.select, &select_added, false); //pstate.select = select_drop_multiple(pstate.select, select_omitted); select_add_multiple(pstate.select, select_added); // drop ommitted dots select_remove_multiple(pstate.select, select_omitted); } } else fldstate.mouse_selection = NULL; fldstate.mousex = coordx; fldstate.mousey = coordy; // store mouse event excode = fieldrel_convert_xy_to_relation(&coordx, &coordy, &buffer); select_added = select_destroy(select_added); select_omitted = select_destroy(select_omitted); new_select = select_destroy(new_select); if (excode == -1) return FALSE; gtk_statusbar_pop(GTK_STATUSBAR(statusbar), GPOINTER_TO_INT(context_id)); gtk_statusbar_push(GTK_STATUSBAR(statusbar), GPOINTER_TO_INT(context_id), buffer); g_free(buffer); dr_canvas_refresh(drill); return TRUE; }
void clear_status_bar(GtkWidget *pButton, gpointer iContextId) { gtk_statusbar_pop(GTK_STATUSBAR(status_bar), GPOINTER_TO_INT(iContextId)); }
static void pop_item( GtkWidget *widget, gpointer data ) { gtk_statusbar_pop (GTK_STATUSBAR (status_bar), GPOINTER_TO_INT (data)); }
/* * Pops up a dialog containing a list of warnings. * * This is because their can be many warnings (eg while you are away) and popping up * hundreds of windows is ugly. */ static void balsa_information_list(GtkWindow *parent, LibBalsaInformationType type, const char *msg) { static GtkWidget *information_list = NULL; GtkTextBuffer *buffer; GtkTextIter iter; if (information_list == NULL) { GtkWidget *information_dialog; GtkWidget *scrolled_window; information_dialog = gtk_dialog_new_with_buttons(_("Information - Balsa"), parent, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLEAR, GTK_RESPONSE_APPLY, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); #if HAVE_MACOSX_DESKTOP libbalsa_macosx_menu_for_parent(information_dialog, parent); #endif /* Default is to close */ gtk_dialog_set_default_response(GTK_DIALOG(information_dialog), GTK_RESPONSE_CLOSE); /* Reset the policy gtk_dialog_new makes itself non-resizable */ gtk_window_set_resizable(GTK_WINDOW(information_dialog), TRUE); gtk_window_set_default_size(GTK_WINDOW(information_dialog), 350, 200); gtk_window_set_wmclass(GTK_WINDOW(information_dialog), "Information", "Balsa"); g_object_add_weak_pointer(G_OBJECT(information_dialog), (gpointer) &information_list); /* A scrolled window for the list. */ scrolled_window = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG(information_dialog))), scrolled_window, TRUE, TRUE, 1); gtk_container_set_border_width(GTK_CONTAINER(scrolled_window), 6); gtk_widget_show(scrolled_window); /* The list itself */ information_list = balsa_information_list_new(); gtk_container_add(GTK_CONTAINER(scrolled_window), information_list); g_signal_connect(G_OBJECT(information_dialog), "response", G_CALLBACK(balsa_information_list_response_cb), information_list); gtk_widget_show_all(information_dialog); } buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(information_list)); gtk_text_buffer_get_end_iter(buffer, &iter); gtk_text_buffer_place_cursor(buffer, &iter); if (gtk_text_buffer_get_char_count(buffer)) gtk_text_buffer_insert_at_cursor(buffer, "\n", 1); gtk_text_buffer_insert_at_cursor(buffer, msg, -1); gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(information_list), gtk_text_buffer_get_insert(buffer), 0, FALSE, 0, 0); if (balsa_app.main_window) { gchar *line; GtkStatusbar *statusbar; guint context_id; statusbar = GTK_STATUSBAR(balsa_app.main_window->statusbar); context_id = gtk_statusbar_get_context_id(statusbar, "Information list"); gtk_statusbar_pop(statusbar, context_id); line = g_strdup(msg); g_strdelimit(line, "\r\n", ' '); gtk_statusbar_push(statusbar, context_id, line); g_free(line); } }
static void modify_motion (ModifyTool *tool, GdkEventMotion *event, DDisplay *ddisp) { Point to; Point now, delta, full_delta; gboolean auto_scroll, vertical = FALSE; ConnectionPoint *connectionpoint = NULL; ObjectChange *objchange = NULL; ddisplay_untransform_coords(ddisp, event->x, event->y, &to.x, &to.y); if (tool->state==STATE_NONE) { DiaObject *obj = NULL; Handle *handle = NULL; diagram_find_closest_handle (ddisp->diagram, &handle, &obj, &to); if (handle && handle->type != HANDLE_NON_MOVABLE && handle->id >= HANDLE_RESIZE_NW && handle->id <= HANDLE_RESIZE_SE && handle_is_clicked(ddisp, handle, &to) && g_list_length (ddisp->diagram->data->selected) == 1) ddisplay_set_all_cursor (get_direction_cursor (CURSOR_DIRECTION_0 + handle->id)); else ddisplay_set_all_cursor_name (NULL, "default"); return; /* Fast path... */ } auto_scroll = ddisplay_autoscroll(ddisp, event->x, event->y); if (!modify_move_already(tool, ddisp, &to)) return; switch (tool->state) { case STATE_MOVE_OBJECT: if (tool->orig_pos == NULL) { GList *list, *pla; int i; DiaObject *obj; /* consider non-selected children affected */ pla = list = parent_list_affected(ddisp->diagram->data->selected); tool->orig_pos = g_new(Point, g_list_length(list)); i=0; while (list != NULL) { obj = (DiaObject *) list->data; tool->orig_pos[i] = obj->position; list = g_list_next(list); i++; } g_list_free (pla); } if (tool->break_connections) diagram_unconnect_selected(ddisp->diagram); /* Pushes UNDO info */ if (gdk_event_to_dia_ModifierKeys (event->state) & MODIFIER_CONTROL) { full_delta = to; point_sub(&full_delta, &tool->start_at); vertical = (fabs(full_delta.x) < fabs(full_delta.y)); } point_add(&to, &tool->move_compensate); snap_to_grid(ddisp, &to.x, &to.y); now = tool->object->position; delta = to; point_sub(&delta, &now); if (gdk_event_to_dia_ModifierKeys (event->state) & MODIFIER_CONTROL) { /* Up-down or left-right */ if (vertical) { delta.x = tool->start_at.x + tool->move_compensate.x - now.x; } else { delta.y = tool->start_at.y + tool->move_compensate.y - now.y; } } object_add_updates_list(ddisp->diagram->data->selected, ddisp->diagram); objchange = object_list_move_delta(ddisp->diagram->data->selected, &delta); if (objchange != NULL) { undo_object_change(ddisp->diagram, tool->object, objchange); } object_add_updates_list(ddisp->diagram->data->selected, ddisp->diagram); object_add_updates(tool->object, ddisp->diagram); /* Put current mouse position in status bar */ { gchar *postext; GtkStatusbar *statusbar = GTK_STATUSBAR (ddisp->modified_status); guint context_id = gtk_statusbar_get_context_id (statusbar, "ObjectPos"); gtk_statusbar_pop (statusbar, context_id); postext = g_strdup_printf("%.3f, %.3f - %.3f, %.3f", tool->object->bounding_box.left, tool->object->bounding_box.top, tool->object->bounding_box.right, tool->object->bounding_box.bottom); gtk_statusbar_pop (statusbar, context_id); gtk_statusbar_push (statusbar, context_id, postext); g_free(postext); } diagram_update_connections_selection(ddisp->diagram); diagram_flush(ddisp->diagram); break; case STATE_MOVE_HANDLE: full_delta = to; point_sub(&full_delta, &tool->start_at); /* make sure resizing is restricted to its parent */ /* if resize was blocked by parent, that means the resizing was outward, thus it won't bother the children so we don't have to check the children */ if (!parent_handle_move_out_check(tool->object, &to)) parent_handle_move_in_check(tool->object, &to, &tool->start_at); if (gdk_event_to_dia_ModifierKeys (event->state) & MODIFIER_CONTROL) vertical = (fabs(full_delta.x) < fabs(full_delta.y)); highlight_reset_all(ddisp->diagram); if ((tool->handle->connect_type != HANDLE_NONCONNECTABLE)) { /* Move to ConnectionPoint if near: */ connectionpoint = object_find_connectpoint_display (ddisp, &to, tool->object, TRUE); if (connectionpoint != NULL) { DiaHighlightType type; to = connectionpoint->pos; if (connectionpoint->flags & CP_FLAGS_MAIN) { type = DIA_HIGHLIGHT_CONNECTIONPOINT_MAIN; } else { type = DIA_HIGHLIGHT_CONNECTIONPOINT; } highlight_object(connectionpoint->object, type, ddisp->diagram); ddisplay_set_all_cursor_name (NULL, "crosshair"); } } if (connectionpoint == NULL) { /* No connectionopoint near, then snap to grid (if enabled) */ snap_to_grid(ddisp, &to.x, &to.y); ddisplay_set_all_cursor_name (NULL, "move"); } if (tool->break_connections) { /* break connections to the handle currently selected. */ if (tool->handle->connected_to!=NULL) { Change *change = undo_unconnect (ddisp->diagram, tool->object, tool->handle); (change->apply)(change, ddisp->diagram); } } if (gdk_event_to_dia_ModifierKeys (event->state) & MODIFIER_CONTROL) { /* Up-down or left-right */ if (vertical) { to.x = tool->start_at.x; } else { to.y = tool->start_at.y; } } if (tool->orig_pos == NULL) { tool->orig_pos = g_new(Point, 1); *tool->orig_pos = tool->handle->pos; } /* Put current mouse position in status bar */ { gchar *postext; GtkStatusbar *statusbar = GTK_STATUSBAR (ddisp->modified_status); guint context_id = gtk_statusbar_get_context_id (statusbar, "ObjectPos"); if (tool->object) { /* play safe */ real w = tool->object->bounding_box.right - tool->object->bounding_box.left; real h = tool->object->bounding_box.bottom - tool->object->bounding_box.top; postext = g_strdup_printf("%.3f, %.3f (%.3fx%.3f)", to.x, to.y, w, h); } else { postext = g_strdup_printf("%.3f, %.3f", to.x, to.y); } gtk_statusbar_pop (statusbar, context_id); gtk_statusbar_push (statusbar, context_id, postext); g_free(postext); } object_add_updates(tool->object, ddisp->diagram); /* Handle undo */ if (tool->object) objchange = tool->object->ops->move_handle(tool->object, tool->handle, &to, connectionpoint, HANDLE_MOVE_USER, gdk_event_to_dia_ModifierKeys(event->state)); if (objchange != NULL) { undo_object_change(ddisp->diagram, tool->object, objchange); } object_add_updates(tool->object, ddisp->diagram); diagram_update_connections_selection(ddisp->diagram); diagram_flush(ddisp->diagram); break; case STATE_BOX_SELECT: tool->end_box = to; ddisplay_transform_coords (ddisp, MIN (tool->start_box.x, tool->end_box.x), MIN (tool->start_box.y, tool->end_box.y), &tool->x1, &tool->y1); ddisplay_transform_coords (ddisp, MAX (tool->start_box.x, tool->end_box.x), MAX (tool->start_box.y, tool->end_box.y), &tool->x2, &tool->y2); dia_interactive_renderer_set_selection (ddisp->renderer, TRUE, tool->x1, tool->y1, tool->x2 - tool->x1, tool->y2 - tool->y1); ddisplay_flush (ddisp); break; case STATE_NONE: break; default: message_error("Internal error: Strange state in modify_tool\n"); } tool->last_to = to; tool->auto_scrolled = auto_scroll; }
gint clear_status_message(gpointer data) { gtk_statusbar_pop(GTK_STATUSBAR(status_bar), context_id); tag = 0; return(FALSE); }