Exemplo n.º 1
0
static void pop_status(GtkWidget* widget,gpointer user_data)
{
	guint id = GPOINTER_TO_UINT(user_data);
	gtk_statusbar_pop((GtkStatusbar*)status,id);
}
Exemplo n.º 2
0
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);
}
Exemplo n.º 4
0
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;
}
Exemplo n.º 5
0
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;
}
Exemplo n.º 6
0
/* 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);
}
Exemplo n.º 7
0
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);
}
Exemplo n.º 8
0
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 (&gtbtton,
                                       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;
}
Exemplo n.º 9
0
static void
on_menu_item_deselected (GtkMenuItem *item, LdWindowMain *window)
{
	gtk_statusbar_pop (GTK_STATUSBAR (window->priv->statusbar),
		window->priv->statusbar_menu_context_id);
}
Exemplo n.º 10
0
void status_pop() {
	if(statcount <= 0) return;
	gtk_statusbar_pop(GTK_STATUSBAR(status), 1);
	statcount--;
	sync_display();
}
Exemplo n.º 11
0
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;
}
Exemplo n.º 12
0
void status_clear() {
	gtk_statusbar_pop(GTK_STATUSBAR(progress), 1);
	pct = 0.0;
}
Exemplo n.º 13
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");
      
  }
}
Exemplo n.º 14
0
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);
}
Exemplo n.º 15
0
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();
	
}
Exemplo n.º 16
0
/*
 * 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;
}
Exemplo n.º 17
0
/* 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");
	
}
Exemplo n.º 18
0
void gui_status_pop(void)
{
	gtk_statusbar_pop(GTK_STATUSBAR(statusbar), context);
}
Exemplo n.º 19
0
/*
 * 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);
}
Exemplo n.º 20
0
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);
}
Exemplo n.º 21
0
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;
}
Exemplo n.º 22
0
void gui_status_pop (gui *g) {
  gtk_statusbar_pop  (g->status, g->cid);
}
Exemplo n.º 23
0
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));
}
Exemplo n.º 25
0
static void pop_item( GtkWidget *widget,
                      gpointer   data )
{
  gtk_statusbar_pop (GTK_STATUSBAR (status_bar), GPOINTER_TO_INT (data));
}
Exemplo n.º 26
0
/*
 * 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);
    }
}
Exemplo n.º 27
0
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;
}
Exemplo n.º 28
0
gint clear_status_message(gpointer data)
{
	gtk_statusbar_pop(GTK_STATUSBAR(status_bar), context_id);
	tag = 0;
	return(FALSE);
}