Exemple #1
0
WAttTextGtk::WAttTextGtk(GtkWidget* wa_parent_wid, void* wa_parent_ctx,
    ldh_tSesContext wa_ldhses, pwr_sAttrRef wa_aref, int wa_editmode,
    pwr_tStatus* status)
    : WAttText(wa_parent_ctx, wa_ldhses, wa_aref, wa_editmode, status),
      parent_wid(wa_parent_wid), toplevel(0), init(1)
{
  int sts;
  int size;
  char* namep;

  if (EVEN(*status))
    return;

  sts = ldh_AttrRefToName(ldhses, &aref, ldh_eName_Hierarchy, &namep, &size);
  if (EVEN(sts)) {
    *status = sts;
    return;
  }

  toplevel = (GtkWidget*)g_object_new(GTK_TYPE_WINDOW, "default-height", 700,
      "default-width", 800, "title", CoWowGtk::convert_utf8(namep), NULL);

  g_signal_connect(toplevel, "delete_event", G_CALLBACK(delete_event), this);
  g_signal_connect(toplevel, "destroy", G_CALLBACK(destroy_event), this);
  g_signal_connect(
      toplevel, "focus-in-event", G_CALLBACK(action_inputfocus), this);

  CoWowGtk::SetWindowIcon(toplevel);

  // Menu
  // Accelerators
  GtkAccelGroup* accel_g
      = (GtkAccelGroup*)g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
  gtk_window_add_accel_group(GTK_WINDOW(toplevel), accel_g);

  GtkMenuBar* menu_bar = (GtkMenuBar*)g_object_new(GTK_TYPE_MENU_BAR, NULL);

  // File entry
  GtkWidget* file_close
      = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);
  g_signal_connect(file_close, "activate", G_CALLBACK(activate_exit), this);

  GtkWidget* file_save
      = gtk_image_menu_item_new_from_stock(GTK_STOCK_SAVE, accel_g);
  g_signal_connect(file_save, "activate", G_CALLBACK(activate_save), this);

  GtkWidget* file_saveandclose
      = gtk_menu_item_new_with_mnemonic("S_ave and close");
  g_signal_connect(
      file_saveandclose, "activate", G_CALLBACK(activate_saveandclose), this);
  gtk_widget_add_accelerator(file_saveandclose, "activate", accel_g, 't',
      GdkModifierType(GDK_CONTROL_MASK), GTK_ACCEL_VISIBLE);

  GtkMenu* file_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL);
  gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_save);
  gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_saveandclose);
  gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);

  GtkWidget* file = gtk_menu_item_new_with_mnemonic("_File");
  gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));

  // Edit entry
  GtkWidget* edit_copy
      = gtk_image_menu_item_new_from_stock(GTK_STOCK_COPY, accel_g);
  g_signal_connect(edit_copy, "activate", G_CALLBACK(activate_copy), this);

  GtkWidget* edit_cut
      = gtk_image_menu_item_new_from_stock(GTK_STOCK_CUT, accel_g);
  g_signal_connect(edit_cut, "activate", G_CALLBACK(activate_cut), this);

  GtkWidget* edit_paste
      = gtk_image_menu_item_new_from_stock(GTK_STOCK_PASTE, accel_g);
  g_signal_connect(edit_paste, "activate", G_CALLBACK(activate_paste), this);

  GtkMenu* edit_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL);
  gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), edit_copy);
  gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), edit_cut);
  gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), edit_paste);

  GtkWidget* edit = gtk_menu_item_new_with_mnemonic("_Edit");
  gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), edit);
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(edit), GTK_WIDGET(edit_menu));

  // Help entry
  GtkWidget* help_help
      = gtk_image_menu_item_new_from_stock(GTK_STOCK_HELP, accel_g);
  g_signal_connect(help_help, "activate", G_CALLBACK(activate_help), this);

  GtkMenu* help_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL);
  gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_help);

  GtkWidget* help = gtk_menu_item_new_with_mnemonic("_Help");
  gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help);
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu));

  if (((WUtility*)parent_ctx)->utype == wb_eUtility_WNav)
    parent_ctx = ((WNav*)parent_ctx)->parent_ctx;
  utility = ((WUtility*)parent_ctx)->utype;

  textbuffer = gtk_text_buffer_new(NULL);
  g_signal_connect_after(
      textbuffer, "insert-text", G_CALLBACK(action_text_inserted), this);
  g_signal_connect_after(
      textbuffer, "changed", G_CALLBACK(action_text_changed), this);

  textview = gtk_text_view_new_with_buffer(textbuffer);
  GtkWidget* viewport = gtk_viewport_new(NULL, NULL);
  GtkWidget* scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
  gtk_container_add(GTK_CONTAINER(viewport), textview);
  gtk_container_add(GTK_CONTAINER(scrolledwindow), viewport);

  button_ok = gtk_button_new_with_label("Ok");
  gtk_widget_set_size_request(button_ok, 70, 25);
  g_signal_connect(button_ok, "clicked", G_CALLBACK(activate_ok), this);
  button_apply = gtk_button_new_with_label("Apply");
  gtk_widget_set_size_request(button_apply, 70, 25);
  g_signal_connect(button_apply, "clicked", G_CALLBACK(activate_apply), this);
  button_cancel = gtk_button_new_with_label("Cancel");
  gtk_widget_set_size_request(button_cancel, 70, 25);
  g_signal_connect(button_cancel, "clicked", G_CALLBACK(activate_cancel), this);

  GtkWidget* hboxbuttons = gtk_hbox_new(TRUE, 40);
  gtk_box_pack_start(GTK_BOX(hboxbuttons), button_ok, FALSE, FALSE, 0);
  gtk_box_pack_start(GTK_BOX(hboxbuttons), button_apply, FALSE, FALSE, 0);
  gtk_box_pack_end(GTK_BOX(hboxbuttons), button_cancel, FALSE, FALSE, 0);

  msg_label = gtk_label_new("");
  gtk_widget_set_size_request(msg_label, -1, 25);

  vbox = gtk_vbox_new(FALSE, 0);
  gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
  gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow, TRUE, TRUE, 0);
  gtk_box_pack_start(GTK_BOX(vbox), hboxbuttons, FALSE, FALSE, 5);
  gtk_box_pack_start(GTK_BOX(vbox), msg_label, FALSE, FALSE, 5);

  gtk_container_add(GTK_CONTAINER(toplevel), vbox);
  gtk_widget_show_all(toplevel);

  if (utility == wb_eUtility_Wtt) {
    ((Wtt*)parent_ctx)
        ->register_utility((void*)this, wb_eUtility_AttrTextEditor);
  }

  char* value;
  ldh_sAttrRefInfo ainfo;

  sts = ldh_GetAttrRefInfo(ldhses, &aref, &ainfo);
  if (EVEN(sts)) {
    *status = sts;
    return;
  }

  char* s = strchr(namep, '.');
  if (!s)
    return;

  strncpy(aname, s + 1, sizeof(aname));

  sts = ldh_GetObjectPar(
      ldhses, aref.Objid, "DevBody", aname, (char**)&value, &size);
  if (EVEN(sts)) {
    *status = sts;
    return;
  }

  input_max_length = ainfo.size - 1;

  GtkTextIter start_iter, end_iter;
  gtk_text_buffer_get_start_iter(textbuffer, &start_iter);
  gtk_text_buffer_get_end_iter(textbuffer, &end_iter);
  gtk_text_buffer_delete(textbuffer, &start_iter, &end_iter);

  gtk_text_buffer_get_start_iter(textbuffer, &start_iter);

  char* textutf8 = g_convert(value, -1, "UTF-8", "ISO8859-1", NULL, NULL, NULL);
  gtk_text_buffer_insert(textbuffer, &start_iter, textutf8, -1);
  g_free(textutf8);

  free(value);

  if (!editmode) {
    gtk_text_view_set_editable(GTK_TEXT_VIEW(textview), FALSE);
    gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(textview), FALSE);
  }

  wow = new CoWowGtk(toplevel);
  init = 0;
}
Exemple #2
0
gboolean document_search_real(GtkWidget *textview, gint direction)
{
	GtkTextIter iter, match_start, match_end;
	gboolean res;
	GtkSourceSearchFlags search_flags = GTK_SOURCE_SEARCH_VISIBLE_ONLY | GTK_SOURCE_SEARCH_TEXT_ONLY;
	GtkTextBuffer *textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
	
	if (!string_find)
		return FALSE;
	
	if (!match_case)
		search_flags = search_flags | GTK_SOURCE_SEARCH_CASE_INSENSITIVE;
	
//	if (direction == 0 || !hlight_check_searched())
	if (direction == 0 || (direction != 2 && !hlight_check_searched()))
		hlight_searched_strings(GTK_TEXT_VIEW(textview)->buffer, string_find);
	
	gtk_text_mark_set_visible(
		gtk_text_buffer_get_selection_bound(
			GTK_TEXT_VIEW(textview)->buffer), FALSE);
	
	gtk_text_buffer_get_iter_at_mark(textbuffer, &iter, gtk_text_buffer_get_insert(textbuffer));
	if (direction < 0) {
		res = gtk_source_iter_backward_search(
			&iter, string_find, search_flags, &match_start, &match_end, NULL);
		if (gtk_text_iter_equal(&iter, &match_end)) {
			res = gtk_source_iter_backward_search(
				&match_start, string_find, search_flags, &match_start, &match_end, NULL);
		}
	} else {
		res = gtk_source_iter_forward_search(
			&iter, string_find, search_flags, &match_start, &match_end, NULL);
	}
	/* TODO: both gtk_(text/source)_iter_backward_search works not fine for multi-byte */
	
	/* wrap */
	/* TODO: define limit NULL -> proper value */
	if (!res) {
		if (direction < 0) {
			gtk_text_buffer_get_end_iter(textbuffer, &iter);
			res = gtk_source_iter_backward_search(
				&iter, string_find, search_flags, &match_start, &match_end, NULL);
		} else {
			gtk_text_buffer_get_start_iter(textbuffer, &iter);
			res = gtk_source_iter_forward_search(
				&iter, string_find, search_flags, &match_start, &match_end, NULL);
		}
	}
	
	if (res) {
		gtk_text_buffer_place_cursor(textbuffer, &match_start);
		gtk_text_buffer_move_mark_by_name(textbuffer, "insert", &match_end);
//		gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(textview), &match_start, 0.1, FALSE, 0.5, 0.5);
		scroll_to_cursor(textbuffer, 0.05);
	} 
	else if (direction == 0)
		run_dialog_message(gtk_widget_get_toplevel(textview), GTK_MESSAGE_WARNING,
			_("Search string not found"));
	
	return res;
}
Exemple #3
0
void
load_file (const gchar *demoname,
           const gchar *filename)
{
  GtkTextBuffer *info_buffer, *source_buffer;
  GtkTextIter start, end;
  char *resource_filename;
  GError *err = NULL;
  int state = 0;
  gboolean in_para = 0;
  gchar **lines;
  GBytes *bytes;
  gint i;

  if (!g_strcmp0 (current_file, filename))
    return;

  remove_data_tabs ();

  add_data_tab (demoname);

  g_free (current_file);
  current_file = g_strdup (filename);

  info_buffer = gtk_text_buffer_new (NULL);
  gtk_text_buffer_create_tag (info_buffer, "title",
                              "font", "Sans 18",
                              "pixels-below-lines", 10,
                              NULL);

  source_buffer = gtk_text_buffer_new (NULL);
  gtk_text_buffer_create_tag (source_buffer, "source",
                              "font", "monospace",
                              NULL);
  gtk_text_buffer_create_tag (source_buffer, "comment",
                              "foreground", "DodgerBlue",
                              NULL);
  gtk_text_buffer_create_tag (source_buffer, "type",
                              "foreground", "ForestGreen",
                              NULL);
  gtk_text_buffer_create_tag (source_buffer, "string",
                              "foreground", "RosyBrown",
                              "weight", PANGO_WEIGHT_BOLD,
                              NULL);
  gtk_text_buffer_create_tag (source_buffer, "control",
                              "foreground", "purple",
                              NULL);
  gtk_text_buffer_create_tag (source_buffer, "preprocessor",
                              "style", PANGO_STYLE_OBLIQUE,
                              "foreground", "burlywood4",
                              NULL);
  gtk_text_buffer_create_tag (source_buffer, "function",
                              "weight", PANGO_WEIGHT_BOLD,
                              "foreground", "DarkGoldenrod4",
                              NULL);

  resource_filename = g_strconcat ("/sources/", filename, NULL);
  bytes = g_resources_lookup_data (resource_filename, 0, &err);
  g_free (resource_filename);

  if (bytes == NULL)
    {
      g_warning ("Cannot open source for %s: %s\n", filename, err->message);
      g_error_free (err);
      return;
    }

  lines = g_strsplit (g_bytes_get_data (bytes, NULL), "\n", -1);
  g_bytes_unref (bytes);

  gtk_text_buffer_get_iter_at_offset (info_buffer, &start, 0);
  for (i = 0; lines[i] != NULL; i++)
    {
      gchar *p;
      gchar *q;
      gchar *r;

      /* Make sure \r is stripped at the end for the poor windows people */
      lines[i] = g_strchomp (lines[i]);

      p = lines[i];
      switch (state)
        {
        case 0:
          /* Reading title */
          while (*p == '/' || *p == '*' || g_ascii_isspace (*p))
            p++;
          r = p;
          while (*r != '\0')
            {
              while (*r != '/' && *r != ':' && *r != '\0')
                r++;
              if (*r == '/')
                {
                  r++;
                  p = r;
                }
              if (r[0] == ':' && r[1] == ':')
                *r = '\0';
            }
          q = p + strlen (p);
          while (q > p && g_ascii_isspace (*(q - 1)))
            q--;


          if (q > p)
            {
              int len_chars = g_utf8_pointer_to_offset (p, q);

              end = start;

              g_assert (strlen (p) >= q - p);
              gtk_text_buffer_insert (info_buffer, &end, p, q - p);
              start = end;

              gtk_text_iter_backward_chars (&start, len_chars);
              gtk_text_buffer_apply_tag_by_name (info_buffer, "title", &start, &end);

              start = end;

              while (*p && *p != '\n') p++;

              state++;
            }
          break;

        case 1:
          /* Reading body of info section */
          while (g_ascii_isspace (*p))
            p++;
          if (*p == '*' && *(p + 1) == '/')
            {
              gtk_text_buffer_get_iter_at_offset (source_buffer, &start, 0);
              state++;
            }
          else
            {
              int len;

              while (*p == '*' || g_ascii_isspace (*p))
                p++;

              len = strlen (p);
              while (g_ascii_isspace (*(p + len - 1)))
                len--;

              if (len > 0)
                {
                  if (in_para)
                    gtk_text_buffer_insert (info_buffer, &start, " ", 1);

                  g_assert (strlen (p) >= len);
                  gtk_text_buffer_insert (info_buffer, &start, p, len);
                  in_para = 1;
                }
              else
                {
                  gtk_text_buffer_insert (info_buffer, &start, "\n", 1);
                  in_para = 0;
                }
            }
          break;

        case 2:
          /* Skipping blank lines */
          while (g_ascii_isspace (*p))
            p++;
          if (*p)
            {
              p = lines[i];
              state++;
              /* Fall through */
            }
          else
            break;

        case 3:
          /* Reading program body */
          gtk_text_buffer_insert (source_buffer, &start, p, -1);
          if (lines[i+1] != NULL)
            gtk_text_buffer_insert (source_buffer, &start, "\n", 1);
          break;
        }
    }

  g_strfreev (lines);

  fontify (source_buffer);

  gtk_text_buffer_create_tag (source_buffer, "top-margin",
                              "pixels-above-lines", 20,
                              NULL);
  gtk_text_buffer_get_start_iter (source_buffer, &start);
  end = start;
  gtk_text_iter_forward_word_end (&end);
  gtk_text_buffer_apply_tag_by_name (source_buffer, "top-margin", &start, &end);

  gtk_text_buffer_create_tag (source_buffer, "bottom-margin",
                              "pixels-below-lines", 20,
                              NULL);
  gtk_text_buffer_get_end_iter (source_buffer, &end);
  start = end;
  gtk_text_iter_backward_word_start (&start);
  gtk_text_buffer_apply_tag_by_name (source_buffer, "bottom-margin", &start, &end);

  gtk_text_view_set_buffer (GTK_TEXT_VIEW (source_view), source_buffer);
  g_object_unref (source_buffer);

  gtk_text_buffer_create_tag (info_buffer, "top-margin",
                              "pixels-above-lines", 20,
                              NULL);
  gtk_text_buffer_get_start_iter (info_buffer, &start);
  end = start;
  gtk_text_iter_forward_word_end (&end);
  gtk_text_buffer_apply_tag_by_name (info_buffer, "top-margin", &start, &end);

  gtk_text_buffer_create_tag (info_buffer, "bottom-margin",
                              "pixels-below-lines", 20,
                              NULL);
  gtk_text_buffer_get_end_iter (info_buffer, &end);
  start = end;
  gtk_text_iter_backward_word_start (&start);
  gtk_text_buffer_apply_tag_by_name (info_buffer, "bottom-margin", &start, &end);

  gtk_text_view_set_buffer (GTK_TEXT_VIEW (info_view), info_buffer);
  g_object_unref (info_buffer);
}
Exemple #4
0
char* src_view___::text__() {
	GtkTextIter start, end;
	gtk_text_buffer_get_start_iter (buf2__(), &start);
	gtk_text_buffer_get_end_iter (buf2__(), &end);
	return gtk_text_buffer_get_text (buf2__(), &start, &end, FALSE);
}
static gssize
_gtk_source_buffer_input_stream_read (GInputStream  *input_stream,
				      void          *buffer,
				      gsize          count,
				      GCancellable  *cancellable,
				      GError       **error)
{
	GtkSourceBufferInputStream *stream;
	GtkTextIter iter;
	gssize space_left, read, n;

	stream = GTK_SOURCE_BUFFER_INPUT_STREAM (input_stream);

	if (count < 6)
	{
		g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NO_SPACE,
				     "Not enougth space in destination");
		return -1;
	}

	if (g_cancellable_set_error_if_cancelled (cancellable, error))
	{
		return -1;
	}

	if (stream->priv->buffer == NULL)
	{
		return 0;
	}

	/* Initialize the mark to the first char in the text buffer */
	if (!stream->priv->is_initialized)
	{
		gtk_text_buffer_get_start_iter (stream->priv->buffer, &iter);
		stream->priv->pos = gtk_text_buffer_create_mark (stream->priv->buffer,
								 NULL,
								 &iter,
								 FALSE);

		stream->priv->is_initialized = TRUE;
	}

	space_left = count;
	read = 0;

	do
	{
		n = read_line (stream, (gchar *)buffer + read, space_left);
		read += n;
		space_left -= n;
	} while (space_left > 0 && n != 0 && stream->priv->bytes_partial == 0);

	/* Make sure that non-empty files are always terminated with \n (see bug #95676).
	 * Note that we strip the trailing \n when loading the file */
	gtk_text_buffer_get_iter_at_mark (stream->priv->buffer,
					  &iter,
					  stream->priv->pos);

	if (gtk_text_iter_is_end (&iter) &&
	    !gtk_text_iter_is_start (&iter) &&
	    stream->priv->add_trailing_newline)
	{
		gssize newline_size;

		newline_size = get_new_line_size (stream);

		if (space_left >= newline_size &&
		    !stream->priv->newline_added)
		{
			const gchar *newline;

			newline = get_new_line (stream);

			memcpy ((gchar *)buffer + read, newline, newline_size);

			read += newline_size;
			stream->priv->newline_added = TRUE;
		}
	}

	return read;
}
Exemple #6
0
void show_asf_meta_data(gchar * metadata_filename)
{
    GtkWidget *metadata_dialog;
    GtkWidget *metadata_text;
    GtkWidget *metadata_label;
    GtkTextBuffer * text_buffer;
    FILE * metadata_file;
    gchar * label_text;
    const int use_fixed_width = TRUE;

    metadata_dialog = get_widget_checked("metadata_dialog");
    metadata_text = get_widget_checked("metadata_text");

    text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(metadata_text));
    gtk_text_buffer_set_text(text_buffer, "", -1);

    label_text = (gchar *) g_malloc(sizeof(gchar) * 
        (strlen(metadata_filename) + 1024));

    metadata_file = fopen(metadata_filename, "rt");

    if (metadata_file)
    {
        gchar * buffer = (gchar *) g_malloc(sizeof(gchar) * max_line_len);
        while (!feof(metadata_file))
        {
            gchar *p = fgets(buffer, max_line_len, metadata_file);
            if (p)
            {
                GtkTextIter end;

                gtk_text_buffer_get_end_iter(text_buffer, &end);
                gtk_text_buffer_insert(text_buffer, &end, buffer, -1);
            }
        }

        fclose(metadata_file);
        g_free(buffer);

        /* change to a fixed-width font in the window */
        if (use_fixed_width)
        {
            GtkTextIter start, end;
            static GtkTextTag *tt = NULL;

	    if (!tt)
	    {
#ifdef win32
	        const char *fnt = "Courier";
#else
		const char *fnt = "Mono";
#endif

		tt = gtk_text_buffer_create_tag(text_buffer, "mono",
						"font", fnt, NULL);
	    }

            gtk_text_buffer_get_start_iter(text_buffer, &start);
            gtk_text_buffer_get_end_iter(text_buffer, &end);

            gtk_text_buffer_apply_tag(text_buffer, tt, &start, &end);    
        }

        metadata_label =
            get_widget_checked("metadata_label");

        sprintf(label_text, "Meta Data File: %s", metadata_filename);
        gtk_label_set_text(GTK_LABEL(metadata_label), label_text);

        gtk_widget_show(metadata_dialog);

        /* user may have selected "Display Metadata" when the meta data
        window was already opened -- bring it to the top */
        gtk_window_present(GTK_WINDOW(metadata_dialog));
    }
    else
    {
        sprintf(label_text,
		"The ASF Metadata file was not found:\n   %s\n\n"
		"The ASF Metadata file is generated by the import procedure, "
		"so you will need\nto process the data before this file is "
		"available.\n", metadata_filename);
        message_box(label_text);
    }

    g_free(label_text);
}
Exemple #7
0
static void
gb_vim_do_search_and_replace (GtkTextBuffer *buffer,
                              GtkTextIter   *begin,
                              GtkTextIter   *end,
                              const gchar   *search_text,
                              const gchar   *replace_text,
                              gboolean       is_global)
{
  GtkSourceSearchContext *search_context;
  GtkSourceSearchSettings *search_settings;
  GtkTextMark *mark;
  GtkTextIter tmp1;
  GtkTextIter tmp2;
  GtkTextIter match_begin;
  GtkTextIter match_end;
  gboolean has_wrapped = FALSE;
  GError *error = NULL;

  g_assert (search_text);
  g_assert (replace_text);
  g_assert ((!begin && !end) || (begin && end));

  search_settings = gtk_source_search_settings_new ();
  search_context = gtk_source_search_context_new (GTK_SOURCE_BUFFER (buffer), search_settings);

  if (!begin)
    {
      gtk_text_buffer_get_start_iter (buffer, &tmp1);
      begin = &tmp1;
    }

  if (!end)
    {
      gtk_text_buffer_get_end_iter (buffer, &tmp2);
      end = &tmp2;
    }

  mark = gtk_text_buffer_create_mark (buffer, NULL, end, FALSE);

  gtk_source_search_settings_set_search_text (search_settings, search_text);
  gtk_source_search_settings_set_case_sensitive (search_settings, TRUE);

  while (gtk_source_search_context_forward2 (search_context,
                                             begin,
                                             &match_begin,
                                             &match_end,
                                             &has_wrapped) && !has_wrapped)
    {
      if (is_global || gb_vim_match_is_selected (buffer, &match_begin, &match_end))
        {
          if (!gtk_source_search_context_replace2 (search_context, &match_begin, &match_end,
                                                   replace_text, -1, &error))
            {
              g_warning ("%s", error->message);
              g_clear_error (&error);
              break;
            }
        }

      *begin = match_end;

      gtk_text_buffer_get_iter_at_mark (buffer, end, mark);
    }

  gtk_text_buffer_delete_mark (buffer, mark);

  g_clear_object (&search_settings);
  g_clear_object (&search_context);
}
Exemple #8
0
void
update_poi(GtkWidget *dialog)
{

	GtkTextView *text_view;
	GtkTextBuffer *buffer;
	GtkTextIter start, end;
	GtkWidget *entry, *widget; 

	const char *keyword, *idmd5;
	char *desc;
	char *sql;
	char *db;


	double lat_deg, lon_deg;
	int res;


	widget = lookup_widget(dialog, "label126");
	idmd5 = gtk_label_get_text(GTK_LABEL(widget));
	
	entry = lookup_widget(dialog, "entry17");
	
	lat_deg = parse_degrees(gtk_entry_get_text(GTK_ENTRY(entry)));
	entry = lookup_widget(dialog, "entry18");
	
	lon_deg = parse_degrees(gtk_entry_get_text(GTK_ENTRY(entry)));



	



	entry = lookup_widget(dialog, "entry19");
	keyword = gtk_entry_get_text(GTK_ENTRY(entry));
	text_view = GTK_TEXT_VIEW(lookup_widget(dialog, "textview2"));
	buffer = gtk_text_view_get_buffer(text_view);
	gtk_text_buffer_get_start_iter (buffer, &start);
	gtk_text_buffer_get_end_iter (buffer, &end);
	desc = gtk_text_buffer_get_text(buffer, &start, &end, TRUE);


	db = g_strconcat(foxtrotgps_dir, "/", POI_DB, NULL);	
	


	sql = sqlite3_mprintf ( 	
			"UPDATE "
				"poi "
			"SET "
				"lat=%f,"
				"lon=%f,"
				"keywords=%Q,"
				"desc=%Q"
			"WHERE "
				"idmd5='%s'" 
			,
			lat_deg, lon_deg, 
			keyword, desc, idmd5);

	res = sql_execute(db, sql, NULL);
	
	if(res==1)
	{
		sql_execute(db, POI_DB_CREATE, NULL);
		sql_execute(db, sql, NULL);
	}

	g_free(desc);
	sqlite3_free (sql);
	
	gtk_widget_destroy(dialog);
	
	

}
Exemple #9
0
void WAttGtk::change_value_close()
{
  unsigned char *s;
  int sts;

  if ( input_open) {
    if ( input_multiline) {
      gchar *text, *textutf8;
      GtkTextIter start_iter, end_iter;
      gtk_text_buffer_get_start_iter( cmd_scrolled_buffer, &start_iter);
      gtk_text_buffer_get_end_iter( cmd_scrolled_buffer, &end_iter);

      textutf8 = gtk_text_buffer_get_text( cmd_scrolled_buffer, &start_iter, &end_iter,
				       FALSE);
      text = g_convert( textutf8, -1, "ISO8859-1", "UTF-8", NULL, NULL, NULL);
      g_free( textutf8);

      // Replace ctrl characters with space
      for ( s = (unsigned char *) text; *s; s++) {
	if ( *s < ' ' && *s != 10 && *s != 13)
	  *s = ' ';
      }

      sts = wattnav->set_attr_value( input_node,
				     input_name, text);
      g_free( text);
      g_object_set( cmd_scrolledinput, "visible", FALSE, NULL);
      set_prompt( "");
      input_open = 0;

      int w, h;
      gdk_drawable_get_size( pane->window, &w, &h);
      gtk_paned_set_position( GTK_PANED(pane), h - 50);

      wattnav->redraw();
      wattnav->set_inputfocus();
    }
    else {
      char *text, *textutf8;
      textutf8 = gtk_editable_get_chars( GTK_EDITABLE(cmd_input), 0, -1);
      text = g_convert( textutf8, -1, "ISO8859-1", "UTF-8", NULL, NULL, NULL);
      g_free( textutf8);

      sts = wattnav->set_attr_value( input_node, 
				     input_name, text);
      g_free( text);
      g_object_set( cmd_input, "visible", FALSE, NULL);
      set_prompt( "");
      input_open = 0;
      if ( redraw_cb)
        (redraw_cb)( this);

      wattnav->set_inputfocus();
    }
    if ( pending_close) {
      if ( close_cb)
	(close_cb)( this);
      else
	delete this;
    }
  }
}
Exemple #10
0
/* Verifies data for New & Properties dialogs.
 * Returns: FALSE if the user needs to change any data. */
static gboolean update_config(const PropertyDialogElements *e, gboolean new_project)
{
	const gchar *name, *file_name, *base_path;
	gchar *locale_filename;
	gint name_len;
	gint err_code = 0;
	GeanyProject *p;

	g_return_val_if_fail(e != NULL, TRUE);

	name = gtk_entry_get_text(GTK_ENTRY(e->name));
	name_len = strlen(name);
	if (name_len == 0)
	{
		SHOW_ERR(_("The specified project name is too short."));
		gtk_widget_grab_focus(e->name);
		return FALSE;
	}
	else if (name_len > MAX_NAME_LEN)
	{
		SHOW_ERR1(_("The specified project name is too long (max. %d characters)."), MAX_NAME_LEN);
		gtk_widget_grab_focus(e->name);
		return FALSE;
	}

	if (new_project)
		file_name = gtk_entry_get_text(GTK_ENTRY(e->file_name));
	else
		file_name = gtk_label_get_text(GTK_LABEL(e->file_name));

	if (G_UNLIKELY(! NZV(file_name)))
	{
		SHOW_ERR(_("You have specified an invalid project filename."));
		gtk_widget_grab_focus(e->file_name);
		return FALSE;
	}

	locale_filename = utils_get_locale_from_utf8(file_name);
	base_path = gtk_entry_get_text(GTK_ENTRY(e->base_path));
	if (NZV(base_path))
	{	/* check whether the given directory actually exists */
		gchar *locale_path = utils_get_locale_from_utf8(base_path);

		if (! g_path_is_absolute(locale_path))
		{	/* relative base path, so add base dir of project file name */
			gchar *dir = g_path_get_dirname(locale_filename);
			setptr(locale_path, g_strconcat(dir, G_DIR_SEPARATOR_S, locale_path, NULL));
			g_free(dir);
		}

		if (! g_file_test(locale_path, G_FILE_TEST_IS_DIR))
		{
			gboolean create_dir;

			create_dir = dialogs_show_question_full(NULL, GTK_STOCK_OK, GTK_STOCK_CANCEL,
				_("Create the project's base path directory?"),
				_("The path \"%s\" does not exist."),
				base_path);

			if (create_dir)
				err_code = utils_mkdir(locale_path, TRUE);

			if (! create_dir || err_code != 0)
			{
				if (err_code != 0)
					SHOW_ERR1(_("Project base directory could not be created (%s)."),
						g_strerror(err_code));
				gtk_widget_grab_focus(e->base_path);
				utils_free_pointers(2, locale_path, locale_filename, NULL);
				return FALSE;
			}
		}
		g_free(locale_path);
	}
	/* finally test whether the given project file can be written */
	if ((err_code = utils_is_file_writable(locale_filename)) != 0 ||
		(err_code = g_file_test(locale_filename, G_FILE_TEST_IS_DIR) ? EISDIR : 0) != 0)
	{
		SHOW_ERR1(_("Project file could not be written (%s)."), g_strerror(err_code));
		gtk_widget_grab_focus(e->file_name);
		g_free(locale_filename);
		return FALSE;
	}
	g_free(locale_filename);

	if (app->project == NULL)
	{
		create_project();
		new_project = TRUE;
	}
	p = app->project;

	setptr(p->name, g_strdup(name));
	setptr(p->file_name, g_strdup(file_name));
	/* use "." if base_path is empty */
	setptr(p->base_path, g_strdup(NZV(base_path) ? base_path : "./"));

	if (! new_project)	/* save properties specific fields */
	{
		GtkTextIter start, end;
		GtkTextBuffer *buffer;
		GeanyDocument *doc = document_get_current();
		GeanyBuildCommand *oldvalue;
		GeanyFiletype *ft = doc ? doc->file_type : NULL;
		GtkWidget *widget;
		gchar *tmp;
		GString *str;

		/* get and set the project description */
		buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(e->description));
		gtk_text_buffer_get_start_iter(buffer, &start);
		gtk_text_buffer_get_end_iter(buffer, &end);
		setptr(p->description, g_strdup(gtk_text_buffer_get_text(buffer, &start, &end, FALSE)));

		stash_group_update(indent_group, e->dialog);

		/* read the project build menu */
		oldvalue = ft ? ft->projfilecmds : NULL;
		build_read_project(ft, e->build_properties);

		if (ft != NULL && ft->projfilecmds != oldvalue && ft->project_list_entry < 0)
		{
			if (p->build_filetypes_list == NULL)
				p->build_filetypes_list = g_ptr_array_new();
			ft->project_list_entry = p->build_filetypes_list->len;
			g_ptr_array_add(p->build_filetypes_list, ft);
		}
		build_menu_update(doc);

		widget = ui_lookup_widget(e->dialog, "radio_long_line_disabled");
		if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
			p->long_line_behaviour = 0;
		else
		{
			widget = ui_lookup_widget(e->dialog, "radio_long_line_default");
			if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
				p->long_line_behaviour = 1;
			else
				/* "Custom" radio button must be checked */
				p->long_line_behaviour = 2;
		}

		widget = ui_lookup_widget(e->dialog, "spin_long_line");
		p->long_line_column = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget));
		apply_editor_prefs();

		/* get and set the project file patterns */
		tmp = g_strdup(gtk_entry_get_text(GTK_ENTRY(e->patterns)));
		g_strfreev(p->file_patterns);
		g_strstrip(tmp);
		str = g_string_new(tmp);
		do {} while (utils_string_replace_all(str, "  ", " "));
		p->file_patterns = g_strsplit(str->str, " ", -1);
		g_string_free(str, TRUE);
		g_free(tmp);
	}

	update_ui();

	return TRUE;
}
Exemple #11
0
void
set_poi(GtkWidget *dialog)
{
	GtkComboBox *combo_box;
	GtkTextView *text_view;
	GtkTextBuffer *buffer;
	GtkTextIter start, end;
	GtkWidget *entry, *radiobutton;

	const char *keyword;
	char *desc;
	char *sql;
	char *db;
	int visibility, price_range = 0, extended_open;
	int category, subcategory;
	double lat_deg, lon_deg;
	int res;
	double rand1, rand2;

	entry = lookup_widget(dialog, "entry14");
	
	lat_deg = parse_degrees(gtk_entry_get_text(GTK_ENTRY(entry)));
	entry = lookup_widget(dialog, "entry15");
	
	lon_deg = parse_degrees(gtk_entry_get_text(GTK_ENTRY(entry)));
	radiobutton = lookup_widget(dialog, "radiobutton11");
	visibility = (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radiobutton))) ? 1 : 0;	
	combo_box = GTK_COMBO_BOX(lookup_widget(dialog, "combobox2"));
	category = gtk_combo_box_get_active(combo_box);
	subcategory = gtk_combo_box_get_active(GTK_COMBO_BOX(combobox_subcat));
	entry = lookup_widget(dialog, "entry13");
	keyword = gtk_entry_get_text(GTK_ENTRY(entry));
	text_view = GTK_TEXT_VIEW(lookup_widget(dialog, "textview1"));
	buffer = gtk_text_view_get_buffer(text_view);
	gtk_text_buffer_get_start_iter (buffer, &start);
	gtk_text_buffer_get_end_iter (buffer, &end);
	desc = gtk_text_buffer_get_text(buffer, &start, &end, TRUE);
	radiobutton = lookup_widget(dialog, "radiobutton8");
	price_range = (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radiobutton))) ? 1 : price_range;
	radiobutton = lookup_widget(dialog, "radiobutton9");
	price_range = (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radiobutton))) ? 3 : price_range;
	radiobutton = lookup_widget(dialog, "radiobutton10");
	price_range = (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radiobutton))) ? 5 : price_range;
	radiobutton = lookup_widget(dialog, "checkbutton10");
	extended_open = (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radiobutton))) ? 1 : 0;

	
	rand1 = g_random_double_range (100000000,1000000000);
	rand2 = g_random_double_range (100000000,1000000000);

	
	db = g_strconcat(foxtrotgps_dir, "/", POI_DB, NULL);	
	
	sql = sqlite3_mprintf ( 	
			"INSERT INTO poi "
			"(idmd5, lat, lon, visibility, cat, subcat, keywords, desc, price_range, extended_open) "
			"VALUES ('%.0f%.0f',%f,%f,%d,%d,%d,%Q,%Q,%d,%d)",
			rand1, rand2, lat_deg, lon_deg, visibility, category, subcategory, 
			keyword, desc, price_range, extended_open);

	res = sql_execute(db, sql, NULL);
	
	if(res==1)
	{
		sql_execute(db, POI_DB_CREATE, NULL);
		sql_execute(db, sql, NULL);
	}

	g_free(desc);
	sqlite3_free (sql);
	gtk_widget_destroy(dialog);
	
	
	global_poi_cat = category;
}
static gboolean
chat_text_view_find_next (EmpathyChatView *view,
			    const gchar     *search_criteria,
			    gboolean         new_search,
			    gboolean         match_case)
{
	EmpathyChatTextViewPriv *priv;
	GtkTextBuffer      *buffer;
	GtkTextIter         iter_at_mark;
	GtkTextIter         iter_match_start;
	GtkTextIter         iter_match_end;
	gboolean            found;
	gboolean            from_start = FALSE;

	g_return_val_if_fail (EMPATHY_IS_CHAT_TEXT_VIEW (view), FALSE);
	g_return_val_if_fail (search_criteria != NULL, FALSE);

	priv = GET_PRIV (view);

	buffer = priv->buffer;

	if (EMP_STR_EMPTY (search_criteria)) {
		if (priv->find_mark_next) {
			gtk_text_buffer_get_start_iter (buffer, &iter_at_mark);

			gtk_text_buffer_move_mark (buffer,
						   priv->find_mark_next,
						   &iter_at_mark);
			gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (view),
						      priv->find_mark_next,
						      0.0,
						      TRUE,
						      0.0,
						      0.0);
			gtk_text_buffer_select_range (buffer,
						      &iter_at_mark,
						      &iter_at_mark);
		}

		return FALSE;
	}

	if (new_search) {
		from_start = TRUE;
	}

	if (!new_search && priv->find_mark_next) {
		gtk_text_buffer_get_iter_at_mark (buffer,
						  &iter_at_mark,
						  priv->find_mark_next);
	} else {
		gtk_text_buffer_get_start_iter (buffer, &iter_at_mark);
		from_start = TRUE;
	}

	priv->find_last_direction = TRUE;

	/* Use the standard GTK+ method for case sensitive searches. It can't do
	 * case insensitive searches (see bug #61852), so keep the custom method
	 * around for case insensitive searches. */
	if (match_case) {
		found = gtk_text_iter_forward_search (&iter_at_mark,
		                                      search_criteria,
		                                      0,
		                                      &iter_match_start,
		                                      &iter_match_end,
		                                      NULL);
	} else {
		found = empathy_text_iter_forward_search (&iter_at_mark,
		                                          search_criteria,
		                                          &iter_match_start,
		                                          &iter_match_end,
		                                          NULL);
	}

	if (!found) {
		gboolean result = FALSE;

		if (from_start) {
			return result;
		}

		/* Here we wrap around. */
		if (!new_search && !priv->find_wrapped) {
			priv->find_wrapped = TRUE;
			result = chat_text_view_find_next (view,
							     search_criteria,
							     FALSE,
							     match_case);
			priv->find_wrapped = FALSE;
		}

		return result;
	}

	/* Set new mark and show on screen */
	if (!priv->find_mark_next) {
		priv->find_mark_next = gtk_text_buffer_create_mark (buffer, NULL,
								    &iter_match_end,
								    TRUE);
	} else {
		gtk_text_buffer_move_mark (buffer,
					   priv->find_mark_next,
					   &iter_match_end);
	}

	if (!priv->find_mark_previous) {
		priv->find_mark_previous = gtk_text_buffer_create_mark (buffer, NULL,
									&iter_match_start,
									TRUE);
	} else {
		gtk_text_buffer_move_mark (buffer,
					   priv->find_mark_previous,
					   &iter_match_start);
	}

	gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (view),
				      priv->find_mark_next,
				      0.0,
				      TRUE,
				      0.5,
				      0.5);

	gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", &iter_match_start);
	gtk_text_buffer_move_mark_by_name (buffer, "insert", &iter_match_end);

	return TRUE;
}
static void
chat_text_view_find_abilities (EmpathyChatView *view,
				 const gchar    *search_criteria,
				 gboolean        match_case,
				 gboolean       *can_do_previous,
				 gboolean       *can_do_next)
{
	EmpathyChatTextViewPriv *priv;
	GtkTextBuffer           *buffer;
	GtkTextIter              iter_at_mark;
	GtkTextIter              iter_match_start;
	GtkTextIter              iter_match_end;

	g_return_if_fail (EMPATHY_IS_CHAT_TEXT_VIEW (view));
	g_return_if_fail (search_criteria != NULL);
	g_return_if_fail (can_do_previous != NULL && can_do_next != NULL);

	priv = GET_PRIV (view);

	buffer = priv->buffer;

	if (can_do_previous) {
		if (priv->find_mark_previous) {
			gtk_text_buffer_get_iter_at_mark (buffer,
							  &iter_at_mark,
							  priv->find_mark_previous);
		} else {
			gtk_text_buffer_get_start_iter (buffer, &iter_at_mark);
		}

		if (match_case) {
			*can_do_previous = gtk_text_iter_backward_search (&iter_at_mark,
								          search_criteria,
								          0,
								          &iter_match_start,
								          &iter_match_end,
								          NULL);
		} else {
			*can_do_previous = empathy_text_iter_backward_search (&iter_at_mark,
									      search_criteria,
									      &iter_match_start,
									      &iter_match_end,
									      NULL);
		}
	}

	if (can_do_next) {
		if (priv->find_mark_next) {
			gtk_text_buffer_get_iter_at_mark (buffer,
							  &iter_at_mark,
							  priv->find_mark_next);
		} else {
			gtk_text_buffer_get_start_iter (buffer, &iter_at_mark);
		}

		if (match_case) {
			*can_do_next = gtk_text_iter_forward_search (&iter_at_mark,
								     search_criteria,
								     0,
								     &iter_match_start,
								     &iter_match_end,
								     NULL);
		} else {
			*can_do_next = empathy_text_iter_forward_search (&iter_at_mark,
									 search_criteria,
									 &iter_match_start,
									 &iter_match_end,
									 NULL);
		}
	}
}
Exemple #14
0
/*!
 *\brief	show crash dialog
 *
 *\param	text Description
 *\param	debug_output Output text by gdb
 *
 *\return	GtkWidget * Dialog widget
 */
static GtkWidget *crash_dialog_show(const gchar *text, const gchar *debug_output)
{
	GtkWidget *window1;
	GtkWidget *vbox1;
	GtkWidget *hbox1;
	GtkWidget *label1;
	GtkWidget *frame1;
	GtkWidget *scrolledwindow1;
	GtkWidget *text1;
	GtkWidget *hbuttonbox3;
	GtkWidget *hbuttonbox4;
	GtkWidget *button3;
	GtkWidget *button4;
	GtkWidget *button5;
	gchar	  *crash_report;
	GtkTextBuffer *buffer;
	GtkTextIter iter;

	window1 = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "crash");
	gtk_container_set_border_width(GTK_CONTAINER(window1), 5);
	gtk_window_set_title(GTK_WINDOW(window1), _("Claws Mail has crashed"));
	gtk_window_set_position(GTK_WINDOW(window1), GTK_WIN_POS_CENTER);
	gtk_window_set_modal(GTK_WINDOW(window1), TRUE);
	gtk_window_set_default_size(GTK_WINDOW(window1), 460, 272);


	vbox1 = gtk_vbox_new(FALSE, 2);
	gtk_widget_show(vbox1);
	gtk_container_add(GTK_CONTAINER(window1), vbox1);

	hbox1 = gtk_hbox_new(FALSE, 4);
	gtk_widget_show(hbox1);
	gtk_box_pack_start(GTK_BOX(vbox1), hbox1, FALSE, TRUE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(hbox1), 4);

	label1 = gtk_label_new
	    (g_strdup_printf(_("%s.\nPlease file a bug report and include the information below."), text));
	gtk_widget_show(label1);
	gtk_box_pack_start(GTK_BOX(hbox1), label1, TRUE, TRUE, 0);
	gtk_misc_set_alignment(GTK_MISC(label1), 7.45058e-09, 0.5);

	frame1 = gtk_frame_new(_("Debug log"));
	gtk_widget_show(frame1);
	gtk_box_pack_start(GTK_BOX(vbox1), frame1, TRUE, TRUE, 0);

	scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL);
	gtk_widget_show(scrolledwindow1);
	gtk_container_add(GTK_CONTAINER(frame1), scrolledwindow1);
	gtk_container_set_border_width(GTK_CONTAINER(scrolledwindow1), 3);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow1),
				       GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);

	text1 = gtk_text_view_new();
	gtk_text_view_set_editable(GTK_TEXT_VIEW(text1), FALSE);
	gtk_widget_show(text1);
	gtk_container_add(GTK_CONTAINER(scrolledwindow1), text1);
	
	crash_report = g_strdup_printf(
		"Claws Mail version %s\n"
		"GTK+ version %d.%d.%d / GLib %d.%d.%d\n"
		"Locale: %s (charset: %s)\n"
		"Features:%s\n"
		"Operating system: %s\n"
		"C Library: %s\n--\n%s",
		VERSION,
		gtk_major_version, gtk_minor_version, gtk_micro_version,
		glib_major_version, glib_minor_version, glib_micro_version,
		conv_get_current_locale(), conv_get_locale_charset_str(),
		get_compiled_in_features(),
		get_operating_system(),
		get_lib_version(),
		debug_output);

	buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text1));
	gtk_text_buffer_get_start_iter(buffer, &iter);
	gtk_text_buffer_insert(buffer, &iter, crash_report, -1);

	hbuttonbox3 = gtk_hbutton_box_new();
	gtk_widget_show(hbuttonbox3);
	gtk_box_pack_start(GTK_BOX(vbox1), hbuttonbox3, FALSE, FALSE, 0);

	hbuttonbox4 = gtk_hbutton_box_new();
	gtk_widget_show(hbuttonbox4);
	gtk_box_pack_start(GTK_BOX(vbox1), hbuttonbox4, FALSE, FALSE, 0);

	button3 = gtk_button_new_with_label(_("Close"));
	gtk_widget_show(button3);
	gtk_container_add(GTK_CONTAINER(hbuttonbox4), button3);
	gtkut_widget_set_can_default(button3, TRUE);

	button4 = gtk_button_new_with_label(_("Save..."));
	gtk_widget_show(button4);
	gtk_container_add(GTK_CONTAINER(hbuttonbox4), button4);
	gtkut_widget_set_can_default(button4, TRUE);

	button5 = gtk_button_new_with_label(_("Create bug report"));
	gtk_widget_show(button5);
	gtk_container_add(GTK_CONTAINER(hbuttonbox4), button5);
	gtkut_widget_set_can_default(button5, TRUE);
	
	g_signal_connect(G_OBJECT(window1), "delete_event",
			 G_CALLBACK(gtk_main_quit), NULL);
	g_signal_connect(G_OBJECT(button3),   "clicked",
			 G_CALLBACK(gtk_main_quit), NULL);
	g_signal_connect(G_OBJECT(button4), "clicked",
			 G_CALLBACK(crash_save_crash_log), crash_report);
	g_signal_connect(G_OBJECT(button5), "clicked",
			 G_CALLBACK(crash_create_bug_report), NULL);

	MANAGE_WINDOW_SIGNALS_CONNECT(window1);

	gtk_widget_show(window1);

	gtk_main();
	return window1;
}
Exemple #15
0
/* 
 * Links can be activated by pressing Enter.
 */
static gboolean
key_press_event (GtkWidget *text_view, GdkEventKey *event, GdauiCloud *cloud)
{
        GtkTextIter iter;
        GtkTextBuffer *buffer;

        switch (event->keyval) {
        case GDK_KEY_Return:
        case GDK_KEY_space:
        case GDK_KEY_KP_Enter:
                buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
                gtk_text_buffer_get_iter_at_mark (buffer, &iter,
                                                  gtk_text_buffer_get_insert (buffer));
                follow_if_link (text_view, &iter, cloud);
		return TRUE;
	case GDK_KEY_Up:
	case GDK_KEY_Down:
	case GDK_KEY_Left:
	case GDK_KEY_Right:
		if ((cloud->priv->selection_mode == GTK_SELECTION_SINGLE) ||
		    (cloud->priv->selection_mode == GTK_SELECTION_BROWSE)) {
			GtkTextIter iter;
			if (cloud->priv->selected_tags) {
				GtkTextMark *mark;
				mark = gtk_text_buffer_get_insert (cloud->priv->tbuffer);
				gtk_text_buffer_get_iter_at_mark (cloud->priv->tbuffer, &iter, mark);
			}
			else if ((event->keyval == GDK_KEY_Right) || (event->keyval == GDK_KEY_Down))
				gtk_text_buffer_get_start_iter (cloud->priv->tbuffer, &iter);
			else
				gtk_text_buffer_get_end_iter (cloud->priv->tbuffer, &iter);
			
			gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (cloud->priv->tview), TRUE);
			while (1) { /* loop to move the cursor enough positions to change the selected item */
				gboolean done = FALSE;
				GtkMovementStep mvt_type;
				gint mvt_amount;
				switch (event->keyval) {
				case GDK_KEY_Up:
					done = ! gtk_text_view_backward_display_line ((GtkTextView*)cloud->priv->tview, &iter);
					mvt_type = GTK_MOVEMENT_DISPLAY_LINES;
					mvt_amount = -1;
					break;
				case GDK_KEY_Down:
					done = ! gtk_text_view_forward_display_line ((GtkTextView*)cloud->priv->tview, &iter);
					mvt_type = GTK_MOVEMENT_DISPLAY_LINES;
					mvt_amount = 1;
					break;
				case GDK_KEY_Left:
					done = ! gtk_text_iter_backward_char (&iter);
					mvt_type = GTK_MOVEMENT_VISUAL_POSITIONS;
					mvt_amount = -1;
					break;
				default:
				case GDK_KEY_Right:
					done = ! gtk_text_iter_forward_char (&iter);
					mvt_type = GTK_MOVEMENT_VISUAL_POSITIONS;
					mvt_amount = 1;
					break;
				}
				if (done)
					break; /* end of treatment as no movement possible */
				g_signal_emit_by_name (cloud->priv->tview, "move-cursor",
						       mvt_type, mvt_amount, FALSE);

				GtkTextMark *mark;
				mark = gtk_text_buffer_get_insert (cloud->priv->tbuffer);
				gtk_text_buffer_get_iter_at_mark (cloud->priv->tbuffer, &iter, mark);

				GSList *tags, *tagp;
				done = FALSE;
				tags = gtk_text_iter_get_tags (&iter);
				for (tagp = tags;  tagp;  tagp = tagp->next) {
					GtkTextTag *tag = (GtkTextTag*) tagp->data;
					gint row;
					row = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tag), "row")) - 1;
					if (row >= 0) {
						if ((cloud->priv->selected_tags &&
						     (tag != cloud->priv->selected_tags->data)) ||
						    !cloud->priv->selected_tags) {
							row_clicked (cloud, row, tag);
							done = TRUE;
							break;
						}
					}
				}
				if (tags) 
					g_slist_free (tags);
				if (done) {
					GtkTextMark *mark;
					    
					mark = gtk_text_buffer_get_insert (cloud->priv->tbuffer);
					gtk_text_view_scroll_mark_onscreen ((GtkTextView*)cloud->priv->tview, mark);
					break;
				}
			}
			gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (cloud->priv->tview), FALSE);
			return TRUE;
		}
        default:
                break;
        }
        return FALSE;
}
Exemple #16
0
void WAttGtk::change_value( int set_focus)
{
  int		sts;
  GtkWidget	*text_w;
  int		multiline;
  char		*value;
  int		input_size;

  if ( input_open) {
    g_object_set( cmd_input, "visible", FALSE, NULL);
    g_object_set( cmd_scrolledinput, "visible", FALSE, NULL);
    set_prompt( "");
    input_open = 0;
    return;
  }

  sts = wattnav->check_attr( &multiline, &input_node, input_name,
			     &value, &input_size);
  if ( EVEN(sts)) {
    if ( sts == WATT__NOATTRSEL)
      message( 'E', "No attribute is selected");
    else
      message( 'E', wnav_get_message( sts));
    return;
  }

  if ( multiline) {
    text_w = cmd_scrolledinput;
    g_object_set( text_w, "visible", TRUE, NULL);

    int w, h;
    gdk_drawable_get_size( pane->window, &w, &h);
    gtk_paned_set_position( GTK_PANED(pane), h - 170);
    gtk_widget_grab_focus( cmd_scrolledtextview);
    input_max_length = input_size;
    input_multiline = 1;
  }
  else {
    text_w = cmd_input;
    g_object_set( text_w, 
		  "visible", TRUE, 
		  "max-length", input_size, NULL);
    gtk_widget_grab_focus( cmd_input);
    input_multiline = 0;
  }

  message( ' ', "");

  if ( value) {
    if ( multiline) {
      GtkTextIter start_iter, end_iter;
      gtk_text_buffer_get_start_iter( cmd_scrolled_buffer, &start_iter);
      gtk_text_buffer_get_end_iter( cmd_scrolled_buffer, &end_iter);
      gtk_text_buffer_delete( cmd_scrolled_buffer, &start_iter, &end_iter);

      gtk_text_buffer_get_start_iter( cmd_scrolled_buffer, &start_iter);

      char *textutf8 = g_convert( value, -1, "UTF-8", "ISO8859-1", NULL, NULL, NULL);
      gtk_text_buffer_insert( cmd_scrolled_buffer, &start_iter, textutf8, -1);
      g_free( textutf8);

      // Select the text
      // gtk_text_buffer_get_start_iter( cmd_scrolled_buffer, &start_iter);
      // gtk_text_buffer_get_end_iter( cmd_scrolled_buffer, &end_iter);
      // gtk_text_buffer_select_range( cmd_scrolled_buffer, &start_iter, &end_iter);
    }
    else {
      char *textutf8 = g_convert( value, -1, "UTF-8", "ISO8859-1", NULL, NULL, NULL);
      gint pos = 0;
      gtk_editable_delete_text( GTK_EDITABLE(cmd_input), 0, -1);
      gtk_editable_insert_text( GTK_EDITABLE(text_w), textutf8, strlen(textutf8), &pos);
      g_free( textutf8);

      // Select the text
      gtk_editable_set_position( GTK_EDITABLE(cmd_input), -1);
      gtk_editable_select_region( GTK_EDITABLE(cmd_input), 0, -1);
    }
  }
  else {
    gtk_editable_delete_text( GTK_EDITABLE(cmd_input), 0, -1);
  }
  set_prompt( "value >");
  input_open = 1;
}
Exemple #17
0
static void
attach_widgets (GtkTextView *text_view)
{
  GtkTextIter iter;
  GtkTextBuffer *buffer;
  int i;
  
  buffer = gtk_text_view_get_buffer (text_view);

  gtk_text_buffer_get_start_iter (buffer, &iter);

  i = 0;
  while (find_anchor (&iter))
    {
      GtkTextChildAnchor *anchor;
      GtkWidget *widget;
      
      anchor = gtk_text_iter_get_child_anchor (&iter);

      if (i == 0)
        {
          widget = gtk_button_new_with_label ("Click Me");

          g_signal_connect (widget, "clicked",
                            G_CALLBACK (easter_egg_callback),
                            NULL);
        }
      else if (i == 1)
        {
          widget = gtk_combo_box_new_text ();

          gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Option 1");
          gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Option 2");
          gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Option 3");
        }
      else if (i == 2)
        {
          widget = gtk_hscale_new (NULL);
          gtk_range_set_range (GTK_RANGE (widget), 0, 100);
          gtk_widget_set_size_request (widget, 70, -1);
        }
      else if (i == 3)
        {
	  gchar *filename = demo_find_file ("floppybuddy.gif", NULL);
	  widget = gtk_image_new_from_file (filename);
	  g_free (filename);
        }
      else if (i == 4)
        {
          widget = gtk_entry_new ();
        }
      else
        {
          widget = NULL; /* avoids a compiler warning */
          g_assert_not_reached ();
        }

      gtk_text_view_add_child_at_anchor (text_view,
                                         widget,
                                         anchor);

      gtk_widget_show_all (widget);

      ++i;
    }
}
Exemple #18
0
void gretl_console (void)
{
    char cbuf[MAXLINE];
    windata_t *vwin;
    GtkTextBuffer *buf;
    GtkTextIter iter;
    ExecState *state;
    const gchar *intro = 
	N_("gretl console: type 'help' for a list of commands");

    if (console_main != NULL) {
	gtk_window_present(GTK_WINDOW(console_main));
	return;
    }

    state = gretl_console_init(cbuf);
    if (state == NULL) {
	return;
    }

    console_state = state;

    vwin = console_window(78, 400);

    console_text = vwin->text;
    console_main = vwin->main;

    g_signal_connect(G_OBJECT(vwin->text), "paste-clipboard",
		     G_CALLBACK(console_paste_handler), NULL);
    g_signal_connect(G_OBJECT(vwin->text), "button-press-event",
		     G_CALLBACK(console_click_handler), NULL);
    g_signal_connect(G_OBJECT(vwin->text), "button-release-event",
		     G_CALLBACK(console_mouse_handler), NULL);
    g_signal_connect(G_OBJECT(vwin->text), "key-press-event",
		     G_CALLBACK(console_key_handler), NULL);
    g_signal_connect(G_OBJECT(vwin->main), "destroy",
		     G_CALLBACK(console_quit), state);
    g_signal_connect(G_OBJECT(vwin->main), "destroy",
		     G_CALLBACK(gtk_widget_destroyed), 
		     &console_main);
    g_signal_connect(G_OBJECT(vwin->main), "destroy",
		     G_CALLBACK(gtk_widget_destroyed), 
		     &console_text);

    g_object_set_data(G_OBJECT(vwin->text), "ExecState", state);

    buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(vwin->text));
    gtk_text_buffer_get_start_iter(buf, &iter);  

    /* insert intro string and first prompt */
    gtk_text_buffer_insert(buf, &iter, _(intro), -1);
    console_insert_prompt(buf, &iter, "\n? ");

    gtk_widget_grab_focus(vwin->text);

    set_debug_read_func(console_get_line);
    set_debug_output_func(console_update_callback);

    /* console command loop */
    while (state->cmd->ci != QUIT) {
	console_get_line(state);
	if (state->cmd->ci != QUIT) {
	    update_console(state, vwin->text);
	}
    }

    if (console_main != NULL) {
	/* the user actually typed quit/exit */
	gtk_widget_destroy(vwin->main);
    }

    command_history_destroy();
    gretl_print_destroy(state->prn);
    free(state);  

    set_debug_read_func(NULL);
    set_debug_output_func(NULL);
    reset_console_globals();

#if CDEBUG
    fprintf(stderr, "gretl_console: returning\n");
#endif
}
Exemple #19
0
static void* fx_many_sms_send_func(void* data)
{
	FxMany* fxmany = (FxMany*)data;
	GtkTreeModel  *model;
	GtkTreeIter    iter;
	gchar         *sipuri;
	gchar         *name;
	GtkTextIter    begin;
	GtkTextIter    end;
	const gchar   *text;
	gchar          alertmsg[1024];
	Conversation  *conv;
	gint           daycount;
	gint           monthcount;

	model = gtk_tree_view_get_model(GTK_TREE_VIEW(fxmany->selected));

	gtk_text_buffer_get_start_iter(fxmany->send_buffer , &begin);
	gtk_text_buffer_get_end_iter(fxmany->send_buffer , &end);
	text = gtk_text_buffer_get_text(fxmany->send_buffer , &begin , &end , TRUE);

	if(*text == '\0') {
		gdk_threads_enter();
		fx_many_add_information(fxmany , _("Please input the contents of message"));
		gdk_threads_leave();
		g_thread_exit(0);
	}

	gdk_threads_enter();
	gtk_text_buffer_delete(fxmany->send_buffer , &begin , &end);
	gdk_threads_leave();
	
	if(gtk_tree_model_get_iter_root(model , &iter)){
		do{
			gtk_tree_model_get(model, &iter, C_NAME_COL
					, &name, C_SIPURI_COL, &sipuri, -1);

			conv = fetion_conversation_new(fxmany->fxmain->user,
					sipuri, NULL);

			if(fetion_conversation_send_sms_to_phone_with_reply(conv,
						 text, &daycount, &monthcount) > 0)
				sprintf(alertmsg , _("Mesage \"%s\" has been"
							" sent to \"%s\". You have sent %d today and "
						    "%d this month\n"),
							text , name , daycount , monthcount);
			else
				sprintf(alertmsg,
						_("Mesage \"%s\" did not send to \"%s\"\n"),
						text , name);
			
			gdk_threads_enter();
			fx_many_add_information(fxmany , alertmsg);
			gdk_threads_leave();

			g_free(conv);
			g_free(name);
			g_free(sipuri);
		}while(gtk_tree_model_iter_next(model , &iter));
	}
	return NULL;
}
Exemple #20
0
static void
run_smartquotes(GtkTextBuffer *buffer) {
	GtkTextIter pos, nextpos;
	gunichar lastc = 0, c = 0, nextc;
	int balance[10] = {0}; /* max 10 levels of nesting. */
	int curnesting = -1;
	gboolean insidetag = FALSE, closing;
	int quotes;

	/* this runs as the user is typing, so undo doesn't make much sense.
	gtk_text_buffer_begin_user_action(buffer);
	*/

	gtk_text_buffer_get_start_iter(buffer, &pos);
	while ((c = gtk_text_iter_get_char(&pos)) != 0) {
		nextpos = pos;
		gtk_text_iter_forward_char(&nextpos);
		nextc = gtk_text_iter_get_char(&nextpos);

		/*g_printf("ofs %d\n", gtk_text_iter_get_offset(&pos));*/
		if (c == '<')
			insidetag = TRUE;
		else if (c == '>')
			insidetag = FALSE;
		quotes = count_quotes(c);

		if (insidetag || quotes == 0) {
			lastc = c;
			gtk_text_iter_forward_char(&pos);
			continue;
		}

		closing = (curnesting >= 0 && balance[curnesting] == quotes);
		if (quotes == 1 &&
				g_unichar_isalnum(lastc) &&
				(!closing || g_unichar_isalnum(nextc))) {
			/* an apostrophe.  fix it up, but don't change nesting. */
			/*g_print("n %d apos %c\n", curnesting, (char)c);*/
			buffer_change_quote(buffer, &pos, &nextpos, c,
					UNICODE_RIGHTSINGLEQUOTE);
		} else if (closing) {
			/*g_print("n %d right %c\n", curnesting, (char)c);*/
			buffer_change_quote(buffer, &pos, &nextpos, c,
					quotes == 1 ?
						UNICODE_RIGHTSINGLEQUOTE :
						UNICODE_RIGHTDOUBLEQUOTE);
			curnesting--;
		} else {
			/*g_print("n %d left %c\n", curnesting, (char)c);*/
			buffer_change_quote(buffer, &pos, &nextpos, c,
					quotes == 1 ?
						UNICODE_LEFTSINGLEQUOTE :
						UNICODE_LEFTDOUBLEQUOTE);
			curnesting++;
			balance[curnesting] = quotes;
		}
		if (curnesting >= 9) {
			g_warning("too many nested quotes.");
		}
		lastc = c;
		gtk_text_iter_forward_char(&pos);
	}

	/* gtk_text_buffer_end_user_action(buffer); */
}
Exemple #21
0
static void
notify_name_change (AtkObject *atk_obj)
{
  GtkLabel *label;
  GailLabel *gail_label;
  GtkWidget *widget;
  GObject *gail_obj;

  widget = GTK_ACCESSIBLE (atk_obj)->widget;
  if (widget == NULL)
    /*
     * State is defunct
     */
    return;

  gail_obj = G_OBJECT (atk_obj);
  label = GTK_LABEL (widget);
  gail_label = GAIL_LABEL (atk_obj);

  if (gail_label->textutil == NULL)
    return;

  /*
   * Check whether the label has actually changed before emitting
   * notification.
   */
  if (gail_label->textutil->buffer) 
    {
      GtkTextIter start, end;
      const char *new_label;
      char *old_label;
      int same;   

      gtk_text_buffer_get_start_iter (gail_label->textutil->buffer, &start);
      gtk_text_buffer_get_end_iter (gail_label->textutil->buffer, &end);
      old_label = gtk_text_buffer_get_text (gail_label->textutil->buffer, &start, &end, FALSE);
      new_label = gtk_label_get_text (label);
      same = strcmp (new_label, old_label);
      g_free (old_label);
      if (same == 0)
        return;
    }
   
  /* Create a delete text and an insert text signal */
 
  g_signal_emit_by_name (gail_obj, "text_changed::delete", 0, 
                         gail_label->label_length);

  gail_label_init_text_util (gail_label, widget);

  g_signal_emit_by_name (gail_obj, "text_changed::insert", 0, 
                         gail_label->label_length);

  if (atk_obj->name == NULL)
    /*
     * The label has changed so notify a change in accessible-name
     */
    g_object_notify (gail_obj, "accessible-name");

  g_signal_emit_by_name (gail_obj, "visible_data_changed");
}
GtkWidget *
font_color_prefs_show(void)
{
  GtkWidget     *main_vb, *main_grid, *label, *combo_box;
  GtkWidget     *font_sample, *color_sample, *colorsel;
  static const gchar   *mt[] = {
    "Marked packet foreground",          /* MFG_IDX 0*/
    "Marked packet background",          /* MBG_IDX 1*/
    "Ignored packet foreground",         /* IFG_IDX 2*/
    "Ignored packet background",         /* IBG_IDX 3*/
    "'Follow Stream' client foreground", /* CFG_IDX 4*/
    "'Follow Stream' client background", /* CBG_IDX 5*/
    "'Follow Stream' server foreground", /* SFG_IDX 6*/
    "'Follow Stream' server background", /* SBG_IDX 7*/
    "Valid filter text entry",           /* FTV_IDX 8*/
    "Invalid filter text entry",         /* FTI_IDX 9*/
    "Deprecated filter text entry"       /* FTD_IDX 10*/
  };
  int            mcount = sizeof(mt) / sizeof (gchar *);
  GtkTextBuffer *buf;
  GtkTextIter    iter;
  GRand         *rand_state     = g_rand_new();
  GString       *preview_string = g_string_new("");
  int            i;

#define GRID_FONT_ROW      0
#define GRID_COLOR_ROW     1
#define GRID_COLOR_SEL_ROW 3

  /* The font hasn't been changed yet. */
  font_changed = FALSE;

  color_t_to_gdkxxx(&tcolors[MFG_IDX], &prefs.gui_marked_fg);
  color_t_to_gdkxxx(&tcolors[MBG_IDX], &prefs.gui_marked_bg);
  color_t_to_gdkxxx(&tcolors[IFG_IDX], &prefs.gui_ignored_fg);
  color_t_to_gdkxxx(&tcolors[IBG_IDX], &prefs.gui_ignored_bg);
  color_t_to_gdkxxx(&tcolors[CFG_IDX], &prefs.st_client_fg);
  color_t_to_gdkxxx(&tcolors[CBG_IDX], &prefs.st_client_bg);
  color_t_to_gdkxxx(&tcolors[SFG_IDX], &prefs.st_server_fg);
  color_t_to_gdkxxx(&tcolors[SBG_IDX], &prefs.st_server_bg);
  color_t_to_gdkxxx(&tcolors[FTV_IDX], &prefs.gui_text_valid);
  color_t_to_gdkxxx(&tcolors[FTI_IDX], &prefs.gui_text_invalid);
  color_t_to_gdkxxx(&tcolors[FTD_IDX], &prefs.gui_text_deprecated);
  color_t_to_gdkxxx(&filter_text_fg, &filter_text_fg_color);

#if ! GTK_CHECK_VERSION(3,4,0)
  for (i=0; i<MAX_IDX; i++) {
    tcolors_orig[i] = tcolors[i];
  }
#endif

  curcolor = &tcolors[CFG_IDX];

  /* Enclosing containers for each row of widgets */
  main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 5, FALSE);
  gtk_container_set_border_width(GTK_CONTAINER(main_vb), 5);

  main_grid = ws_gtk_grid_new();
  gtk_box_pack_start(GTK_BOX(main_vb), main_grid, FALSE, FALSE, 0);
  ws_gtk_grid_set_row_spacing(GTK_GRID(main_grid), 40);
  ws_gtk_grid_set_column_spacing(GTK_GRID(main_grid), 15);
  gtk_widget_show(main_grid);

  label = gtk_label_new("Main window font:");
  gtk_misc_set_alignment(GTK_MISC(label), 1.0f, 0.5f);
  ws_gtk_grid_attach_extended(GTK_GRID(main_grid), label,
                              0, GRID_FONT_ROW, 1, 1,
                              (GtkAttachOptions)(GTK_EXPAND|GTK_FILL), (GtkAttachOptions)0, 0, 0);
  gtk_widget_show(label);

  font_button = gtk_font_button_new_with_font(prefs.gui_gtk2_font_name);
  gtk_font_button_set_title(GTK_FONT_BUTTON(font_button), "Wireshark: Font");
  ws_gtk_grid_attach(GTK_GRID(main_grid), font_button,
                     1, GRID_FONT_ROW, 1, 1);
  gtk_widget_show(font_button);

  g_string_printf(preview_string, " %s 0123456789",
                  font_pangrams[g_rand_int_range(rand_state, 0, NUM_FONT_PANGRAMS)]);

  font_sample = gtk_text_view_new();
  gtk_text_view_set_editable(GTK_TEXT_VIEW(font_sample), FALSE);
  buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(font_sample));
  gtk_text_buffer_get_start_iter(buf, &iter);
  srand((unsigned int) time(NULL));
  gtk_text_buffer_insert(buf, &iter, preview_string->str, -1);
  ws_gtk_grid_attach_extended(GTK_GRID(main_grid), font_sample,
                              2, GRID_FONT_ROW, 1, 1,
                              (GtkAttachOptions)(GTK_EXPAND|GTK_FILL), (GtkAttachOptions)0, 0, 0);
  g_signal_connect(font_button, "font-set", G_CALLBACK(select_font), NULL);
  gtk_widget_show(font_sample);

  g_string_free(preview_string, TRUE);
  g_object_set_data(G_OBJECT(font_button), FONT_SAMPLE_KEY, font_sample);

  label = gtk_label_new("Colors:");
  gtk_misc_set_alignment(GTK_MISC(label), 1.0f, 0.5f);
  ws_gtk_grid_attach_extended(GTK_GRID(main_grid), label,
                              0, GRID_COLOR_ROW, 1, 1,
                              (GtkAttachOptions)(GTK_EXPAND|GTK_FILL), (GtkAttachOptions)0, 0,0);
  gtk_widget_show(label);

  /* We have to create this now, and configure it below. */

#if GTK_CHECK_VERSION(3,4,0)
  /* XXX: There appears to be a bug in the GTK3 GtkColorChooserWidget such that
   *  when in the GtkColorChooserWidget "customize" mode (aka "color-edit" mode)
   *  selecting a color doesn't trigger a "motify::rgba" callback.
   *  The effect is that the sample text FG/BG colors don't update for the GTK3
   *  GtkColorChooserWidget in "custon color edit node").
   *  I expect use of the "customize mode" will be minimal and that the bug will
   *  not be very noticeable.
   *  (A GTK3 bug report has beem submitted.
   */
#endif
  colorsel = gtk_color_xxx_new();

  combo_box = gtk_combo_box_text_new();
  for (i = 0; i < mcount; i++){
    gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), mt[i]);
  }
  gtk_combo_box_set_active(GTK_COMBO_BOX(combo_box), CFG_IDX);
  g_signal_connect(combo_box, "changed", G_CALLBACK(update_current_color), colorsel);
  ws_gtk_grid_attach(GTK_GRID(main_grid), combo_box,
                     1, GRID_COLOR_ROW, 1, 1);

  gtk_widget_show(combo_box);

  color_sample = gtk_text_view_new();
  update_font(user_font_get_regular(), font_sample, color_sample);
  gtk_text_view_set_editable(GTK_TEXT_VIEW(color_sample), FALSE);
  buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(color_sample));
  gtk_text_buffer_get_start_iter(buf, &iter);

  gtk_text_buffer_create_tag(buf, "marked",
                             TAG_PROP_FG_COLOR, &tcolors[MFG_IDX],
                             TAG_PROP_BG_COLOR, &tcolors[MBG_IDX],
                             NULL);
  gtk_text_buffer_create_tag(buf, "ignored",
                             TAG_PROP_FG_COLOR, &tcolors[IFG_IDX],
                             TAG_PROP_BG_COLOR, &tcolors[IBG_IDX],
                             NULL);
  gtk_text_buffer_create_tag(buf, "client",
                             TAG_PROP_FG_COLOR, &tcolors[CFG_IDX],
                             TAG_PROP_BG_COLOR, &tcolors[CBG_IDX],
                             NULL);
  gtk_text_buffer_create_tag(buf, "server",
                             TAG_PROP_FG_COLOR, &tcolors[SFG_IDX],
                             TAG_PROP_BG_COLOR, &tcolors[SBG_IDX],
                             NULL);
  gtk_text_buffer_create_tag(buf, "text_valid",
                             TAG_PROP_FG_COLOR, &filter_text_fg,
                             TAG_PROP_BG_COLOR, &tcolors[FTV_IDX],
                             NULL);
  gtk_text_buffer_create_tag(buf, "text_invalid",
                             TAG_PROP_FG_COLOR, &filter_text_fg,
                             TAG_PROP_BG_COLOR, &tcolors[FTI_IDX],
                             NULL);
  gtk_text_buffer_create_tag(buf, "text_deprecated",
                             TAG_PROP_FG_COLOR, &filter_text_fg,
                             TAG_PROP_BG_COLOR, &tcolors[FTD_IDX],
                             NULL);

  gtk_text_buffer_insert_with_tags_by_name(buf, &iter, SAMPLE_MARKED_TEXT,  -1,
                                           "marked", NULL);
  gtk_text_buffer_insert_with_tags_by_name(buf, &iter, SAMPLE_IGNORED_TEXT, -1,
                                           "ignored", NULL);
  gtk_text_buffer_insert_with_tags_by_name(buf, &iter, SAMPLE_CLIENT_TEXT,  -1,
                                           "client", NULL);
  gtk_text_buffer_insert_with_tags_by_name(buf, &iter, SAMPLE_SERVER_TEXT,  -1,
                                           "server", NULL);
  gtk_text_buffer_insert_with_tags_by_name(buf, &iter, SAMPLE_TEXT_VALID_TEXT,  -1,
                                           "text_valid", NULL);
  gtk_text_buffer_insert_with_tags_by_name(buf, &iter, SAMPLE_TEXT_INVALID_TEXT,  -1,
                                           "text_invalid", NULL);
  gtk_text_buffer_insert_with_tags_by_name(buf, &iter, SAMPLE_TEXT_DEPRECATED_TEXT,  -1,
                                           "text_deprecated", NULL);

  ws_gtk_grid_attach_extended(GTK_GRID(main_grid), color_sample,
                              2, GRID_COLOR_ROW, 1, 2,
                              (GtkAttachOptions)(GTK_EXPAND|GTK_FILL), (GtkAttachOptions)0, 0, 0);
  gtk_widget_show(color_sample);

  gtk_color_xxx_set_yyy(GTK_COLOR_XXX(colorsel), curcolor);
  ws_gtk_grid_attach_extended(GTK_GRID(main_grid), colorsel,
                              1, GRID_COLOR_SEL_ROW, 2, 1,
                              (GtkAttachOptions)(GTK_FILL|GTK_EXPAND), (GtkAttachOptions)0, 0, 0);

  g_object_set_data(G_OBJECT(combo_box), COLOR_SAMPLE_KEY, color_sample);
  g_object_set_data(G_OBJECT(colorsel),  COLOR_SAMPLE_KEY, color_sample);
  g_signal_connect(colorsel, COLOR_CHANGED_SIGNAL, G_CALLBACK(update_text_color), NULL);
  gtk_widget_show(colorsel);

  g_rand_free(rand_state);
  gtk_widget_show(main_vb);
  return main_vb;
}
bool WindowCheckKeyterms::find_renderings (const ustring& text, const vector <ustring>& renderings, const vector <bool>& wholewords, const vector <bool>& casesensitives, vector <size_t> * startpositions, vector <size_t> * lengths)
// Finds renderings in the text.
// text: Text to be looked into.
// renderings: Renderings to look for.
// wholewords / casesensitives: Attributes of the renderings.
// startpositions: If non-NULL, will be filled with the positions that each rendering starts at.
// lengths: If non-NULL, will be filled with the lengths of the renderings found.
// Returns whether one or more renderings were found in the verse.
{
  if (startpositions)
    startpositions->clear();
  if (lengths)
    lengths->clear();

  GtkTextBuffer * textbuffer = gtk_text_buffer_new (NULL);
  gtk_text_buffer_set_text (textbuffer, text.c_str(), -1);
  GtkTextIter startiter;
  gtk_text_buffer_get_start_iter(textbuffer, &startiter);

  bool found = false;

  for (unsigned int i2 = 0; i2 < renderings.size(); i2++) {

    ustring rendering = renderings[i2];
    bool wholeword = wholewords[i2];
    bool casesensitive = casesensitives[i2];

    ustring mytext;
    ustring myrendering;
    if (casesensitive) {
      mytext = text;
      myrendering = rendering;
    } else {
      mytext = text.casefold();
      myrendering = rendering.casefold();
    }
    size_t position = mytext.find(myrendering);
    while (position != string::npos) {
      bool temporally_approved = true;
      GtkTextIter approvedstart = startiter;
      GtkTextIter approvedend;
      gtk_text_iter_forward_chars(&approvedstart, position);
      approvedend = approvedstart;
      gtk_text_iter_forward_chars(&approvedend, rendering.length());
      if (wholeword) {
        if (!gtk_text_iter_starts_word(&approvedstart))
          temporally_approved = false;
        if (!gtk_text_iter_ends_word(&approvedend))
          temporally_approved = false;
      }
      if (temporally_approved) {
        found = true;
        if (startpositions)
          startpositions->push_back (position);
        if (lengths)
          lengths->push_back (rendering.length());
      }
      position = mytext.find(myrendering, ++position);
    }
  }

  g_object_unref (textbuffer);  
  
  return found;
}
Exemple #24
0
static void
load_buffer(gchar *file, gchar *file_type, void *unused)
{
  GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
  xmlDocPtr doc;
  xmlNodePtr node;
  GtkTextIter iter_start, iter_end;

  /* parse the new file and put the result into newdoc */
  doc = xmlParseFile(file);

  /* in case something went wrong */
  if(!doc)
    return;

  /* Get the root element node */
  node = xmlDocGetRootElement(doc);

  for(node = node; node != NULL; node = node->next)
    if ( g_ascii_strcasecmp((char *)node->name, "html") == 0 &&
	 node->children )
      break;

  if(!node)
    goto done;

  for(node = node->children; node != NULL; node = node->next)
    {
      if ( g_ascii_strcasecmp((char *)node->name, "head") == 0 &&
	   node->children )
	{
	  /* Search and apply the saved style in the META */
	  xmlNodePtr snode;
	  for(snode = node->children; snode != NULL; snode = snode->next)
	    {
	      if ( ( g_ascii_strcasecmp((char *)snode->name, "meta") == 0 ) &&
		   xmlHasProp(snode, BAD_CAST "http-equiv") )
		{
		  xmlChar *key = xmlGetProp(snode, BAD_CAST "http-equiv");
		  xmlChar *content = xmlGetProp(snode, BAD_CAST "content");

		  if(g_ascii_strcasecmp((char *)key, "GCompris-doctype") == 0)
		    {
		      int style_index = get_style_index(gettext((char *)content));
		      apply_style(style_index);
		      gtk_combo_box_set_active(GTK_COMBO_BOX(gtk_combo_styles),
					       style_index);
		    }

		  if(g_ascii_strcasecmp((char *)key, "GCompris-color-style") == 0)
		    {
		      int cstyle_index = get_color_style_index(gettext((char *)content));
		      apply_color_style(cstyle_index);
		      gtk_combo_box_set_active(GTK_COMBO_BOX(gtk_combo_colors),
					       cstyle_index);
		    }

		  xmlFree(key);
		  xmlFree(content);
		}
	    }
	}

      if ( g_ascii_strcasecmp((char *)node->name, "body") == 0 &&
	   node->children )
	break;
    }

  if(!node)
    goto done;

  gtk_text_buffer_get_start_iter(buffer,
				 &iter_start);
  gtk_text_buffer_get_end_iter(buffer,
			       &iter_end);
  gtk_text_buffer_delete(buffer,
			 &iter_start,
			 &iter_end);

  gtk_text_buffer_get_start_iter(buffer,
				 &iter_start);

  for(node = node->children; node != NULL; node = node->next)
    {

      if ( g_ascii_strcasecmp((char *)node->name, "h1") == 0 ||
	   g_ascii_strcasecmp((char *)node->name, "h2") == 0 ||
	   g_ascii_strcasecmp((char *)node->name, "h3") == 0 ||
	   g_ascii_strcasecmp((char *)node->name, "link") == 0 ||
	   g_ascii_strcasecmp((char *)node->name, "p") == 0 )
	{
	  xmlChar *content;
	  content = xmlNodeGetContent(node);
	  gtk_text_buffer_insert_with_tags_by_name(buffer,
						   &iter_start,
						   (char *)content,
						   strlen((char *)content),
						   (char *)node->name,
						   NULL);
	  xmlFree(content);
	  gtk_text_buffer_get_end_iter(buffer,
				       &iter_start);
	  gtk_text_buffer_insert(buffer,&iter_start, "\n", 1);

	  gtk_text_buffer_get_end_iter(buffer,
					 &iter_start);

	}

    }

 done:
  xmlFreeDoc(doc);
}
Exemple #25
0
static gint document_replace_real(GtkWidget *textview)
{
	GtkTextIter iter, match_start, match_end, rep_start;
	GtkTextMark *mark_init = NULL;
	gboolean res;
	gint num = 0, offset;
	GtkWidget *q_dialog = NULL;
	GtkSourceSearchFlags search_flags = GTK_SOURCE_SEARCH_VISIBLE_ONLY | GTK_SOURCE_SEARCH_TEXT_ONLY;	
	GtkTextBuffer *textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
	
	if (!match_case)
		search_flags = search_flags | GTK_SOURCE_SEARCH_CASE_INSENSITIVE;
	
	if (replace_all) {
		gtk_text_buffer_get_iter_at_mark(textbuffer,
			&iter, gtk_text_buffer_get_insert(textbuffer));
		mark_init = gtk_text_buffer_create_mark(textbuffer, NULL, &iter, FALSE);
		gtk_text_buffer_get_start_iter(textbuffer, &iter);
		
		gtk_text_buffer_get_end_iter(textbuffer, &match_end);
//		gtk_text_buffer_remove_tag_by_name(textbuffer,
//			"replaced", &iter, &match_end);
		gtk_text_buffer_remove_all_tags(textbuffer,
			&iter, &match_end);
	} else {
		hlight_searched_strings(textbuffer, string_find);
		hlight_toggle_searched(textbuffer);
	}
	
	do {
		if (replace_all) {
			res = gtk_source_iter_forward_search(
				&iter, string_find, search_flags, &match_start, &match_end, NULL);
			if (res) {
				gtk_text_buffer_place_cursor(textbuffer, &match_start);
				gtk_text_buffer_move_mark_by_name(textbuffer, "insert", &match_end);
				gtk_text_buffer_get_iter_at_mark(
					textbuffer, &iter, gtk_text_buffer_get_insert(textbuffer));
			}
		}
		else
//			res = document_search_real(textview, 0);
			res = document_search_real(textview, 2);
		
		if (res) {
			if (!replace_all) {
				if (num == 0 && q_dialog == NULL)
					q_dialog = create_dialog_message_question(
						gtk_widget_get_toplevel(textview), _("Replace?"));
#if GTK_CHECK_VERSION(2, 10, 0)
					GtkTextIter ins,bou;
					gtk_text_buffer_get_selection_bounds(textbuffer, &ins, &bou);
#endif
				switch (gtk_dialog_run(GTK_DIALOG(q_dialog))) {
				case GTK_RESPONSE_YES:
#if GTK_CHECK_VERSION(2, 10, 0)
					gtk_text_buffer_select_range(textbuffer, &ins, &bou);
#endif
					break;
				case GTK_RESPONSE_NO:
					continue;
//				case GTK_RESPONSE_CANCEL:
				default:
					res = 0;
					if (num == 0)
						num = -1;
					continue;
				}
			}
			gtk_text_buffer_delete_selection(textbuffer, TRUE, TRUE);
			if (strlen(string_replace)) {
				gtk_text_buffer_get_iter_at_mark(
					textbuffer, &rep_start,
					gtk_text_buffer_get_insert(textbuffer));
				offset = gtk_text_iter_get_offset(&rep_start);
				undo_set_sequency(TRUE);
				g_signal_emit_by_name(G_OBJECT(textbuffer),
					"begin-user-action");
				gtk_text_buffer_insert_at_cursor(textbuffer,
					string_replace, strlen(string_replace));
				g_signal_emit_by_name(G_OBJECT(textbuffer),
					"end-user-action");
				gtk_text_buffer_get_iter_at_mark(
					textbuffer, &iter,
					gtk_text_buffer_get_insert(textbuffer));
				gtk_text_buffer_get_iter_at_offset(textbuffer,
					&rep_start, offset);
				gtk_text_buffer_apply_tag_by_name(textbuffer,
					"replaced", &rep_start, &iter);
			} else
				gtk_text_buffer_get_iter_at_mark(
					textbuffer, &iter,
					gtk_text_buffer_get_insert(textbuffer));
			
			num++;
/*			if (replace_all)
				undo_set_sequency(TRUE);
			else
				undo_set_sequency(FALSE);*/
			undo_set_sequency(replace_all);
		}
	} while (res);
	if (!hlight_check_searched())
		hlight_toggle_searched(textbuffer);
	
	if (q_dialog)
		gtk_widget_destroy(q_dialog);
/*	if (strlen(string_replace)) {
		replace_mode = TRUE;
		hlight_searched_strings(textbuffer, string_replace);
	}	*/
	if (replace_all) {
		gtk_text_buffer_get_iter_at_mark(textbuffer, &iter, mark_init);
		gtk_text_buffer_place_cursor(textbuffer, &iter);
		run_dialog_message(gtk_widget_get_toplevel(textview), GTK_MESSAGE_INFO,
			_("%d strings replaced"), num);
		undo_set_sequency(FALSE);
	}
	
	return num;
}
Exemple #26
0
static void PopulateListBox (int deviceId)
{
	Device  *device;
	char    *string;
	char    *tempString;
	int     configNum;
	int     interfaceNum;
	int     endpointNum;
	int     deviceNumber = (deviceId >> 8);
	int     busNumber = (deviceId & 0x00ff);
	GtkTextIter begin;
	GtkTextIter end;

	device = usb_find_device (deviceNumber, busNumber);
	if (device == NULL) {
		printf ("Can't seem to find device info to display\n");
		return;
	}

	/* clear the textbox */
	gtk_text_buffer_get_start_iter(textDescriptionBuffer,&begin);
	gtk_text_buffer_get_end_iter(textDescriptionBuffer,&end);
	gtk_text_buffer_delete (textDescriptionBuffer, &begin, &end);

	/* freeze the display */
	/* this keeps the annoying scroll from happening */
	gtk_widget_freeze_child_notify(textDescriptionView);

	string = (char *)g_malloc (1000);

	/* add the name to the textbox if we have one*/
	if (device->name != NULL) {
		gtk_text_buffer_insert_at_cursor(textDescriptionBuffer, device->name,strlen(device->name));
	}

	/* add the manufacturer if we have one */
	if (device->manufacturer != NULL) {
		sprintf (string, "\nManufacturer: %s", device->manufacturer);
		gtk_text_buffer_insert_at_cursor(textDescriptionBuffer, string,strlen(string));
	}

	/* add the serial number if we have one */
	if (device->serialNumber != NULL) {
		sprintf (string, "\nSerial Number: %s", device->serialNumber);
		gtk_text_buffer_insert_at_cursor(textDescriptionBuffer, string,strlen(string));
	}

	/* add speed */
	switch (device->speed) {
		case 1 :        tempString = "1.5Mb/s (low)";   break;
		case 12 :       tempString = "12Mb/s (full)";   break;
		case 480 :      tempString = "480Mb/s (high)";  break;		/* planning ahead... */
		default :       tempString = "unknown";         break;
	}
	sprintf (string, "\nSpeed: %s", tempString);
	gtk_text_buffer_insert_at_cursor(textDescriptionBuffer, string,strlen(string));

	/* add ports if available */
	if (device->maxChildren) {
		sprintf (string, "\nNumber of Ports: %i", device->maxChildren);
		gtk_text_buffer_insert_at_cursor(textDescriptionBuffer, string,strlen(string));
	}

	/* add the bandwidth info if available */
	if (device->bandwidth != NULL) {
		sprintf (string, "\nBandwidth allocated: %i / %i (%i%%)", device->bandwidth->allocated, device->bandwidth->total, device->bandwidth->percent);
		gtk_text_buffer_insert_at_cursor(textDescriptionBuffer, string,strlen(string));

		sprintf (string, "\nTotal number of interrupt requests: %i", device->bandwidth->numInterruptRequests);
		gtk_text_buffer_insert_at_cursor(textDescriptionBuffer, string,strlen(string));

		sprintf (string, "\nTotal number of isochronous requests: %i", device->bandwidth->numIsocRequests);
		gtk_text_buffer_insert_at_cursor(textDescriptionBuffer, string,strlen(string));
	}

	/* add the USB version, device class, subclass, protocol, max packet size, and the number of configurations (if it is there) */
	if (device->version) {
		sprintf (string, "\nUSB Version: %s\nDevice Class: %s\nDevice Subclass: %s\nDevice Protocol: %s\n"
			 "Maximum Default Endpoint Size: %i\nNumber of Configurations: %i",
			 device->version, device->class, device->subClass, device->protocol,
			 device->maxPacketSize, device->numConfigs);
		gtk_text_buffer_insert_at_cursor(textDescriptionBuffer, string,strlen(string));
	}
Exemple #27
0
gint main(gint argc, gchar **argv)
{
	Conf *conf;
	GtkItemFactory *ifactory;
	gchar *stdin_data = NULL;
	
	bindtextdomain(PACKAGE, LOCALEDIR);			//bindtextdomain ??
	bind_textdomain_codeset(PACKAGE, "UTF-8");		// ??
	textdomain(PACKAGE);					// ??
	
	pub = g_malloc(sizeof(PublicData));			
	pub->fi = g_malloc(sizeof(FileInfo));
	pub->fi->filename     = NULL;
	pub->fi->charset      = NULL;
	pub->fi->charset_flag = FALSE;
	pub->fi->lineend      = LF;
	
	parse_args(argc, argv, pub->fi);
	
	gtk_init(&argc, &argv);					//call before using any gtk fuction
	g_set_application_name(PACKAGE_NAME);
	g_print("%s\n", PACKAGE_NAME);
	
#if !GTK_CHECK_VERSION(2, 6, 0)
	add_about_stock();
#endif
	
	pub->mw = create_main_window();			//Find create_main_window
	
	conf = g_malloc(sizeof(Conf));				//sends default vlues to load and overwrites in the function
	conf->width       = 600;
	conf->height      = 400;
	conf->fontname    = g_strdup("Monospace 12");
	conf->wordwrap    = FALSE;
	conf->linenumbers = FALSE;
	conf->autoindent  = FALSE;
	
	load_config_file(conf);
	//gtk options for GUI
	gtk_window_set_default_size(
		GTK_WINDOW(pub->mw->window), conf->width, conf->height);
	set_text_font_by_name(pub->mw->view, conf->fontname);
	
	ifactory = gtk_item_factory_from_widget(pub->mw->menubar);
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(
		gtk_item_factory_get_widget(ifactory, "/Options/Word Wrap")),
		conf->wordwrap);
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(
		gtk_item_factory_get_widget(ifactory, "/Options/Line Numbers")),
		conf->linenumbers);
	indent_refresh_tab_width(pub->mw->view);
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(
		gtk_item_factory_get_widget(ifactory, "/Options/Auto Indent")),
		conf->autoindent);
	
	gtk_widget_show_all(pub->mw->window);
	g_free(conf->fontname);
	g_free(conf);
	
#ifdef ENABLE_EMACS
	check_emacs_key_theme(GTK_WINDOW(pub->mw->window), ifactory);
#endif
	
	hlight_init(pub->mw->buffer);
	undo_init(pub->mw->view,
		gtk_item_factory_get_widget(ifactory, "/Edit/Undo"),
		gtk_item_factory_get_widget(ifactory, "/Edit/Redo"));
//	hlight_init(pub->mw->buffer);
	dnd_init(pub->mw->view);
	
	if (pub->fi->filename)
		file_open_real(pub->mw->view, pub->fi);
#ifdef G_OS_UNIX
	else
		stdin_data = gedit_utils_get_stdin();
#endif
	if (stdin_data) {
		gchar *str;
		GtkTextIter iter;
		
		str = g_convert(stdin_data, -1, "UTF-8",
			get_default_charset(), NULL, NULL, NULL);
		g_free(stdin_data);
	
//		gtk_text_buffer_set_text(buffer, "", 0);
		gtk_text_buffer_get_start_iter(pub->mw->buffer, &iter);
		gtk_text_buffer_insert(pub->mw->buffer, &iter, str, strlen(str));
		gtk_text_buffer_get_start_iter(pub->mw->buffer, &iter);
		gtk_text_buffer_place_cursor(pub->mw->buffer, &iter);
		gtk_text_buffer_set_modified(pub->mw->buffer, FALSE);
		gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(pub->mw->view), &iter, 0, FALSE, 0, 0);
		g_free(str);
	}
	
	if (jump_linenum) {
		GtkTextIter iter;
		
		gtk_text_buffer_get_iter_at_line(pub->mw->buffer, &iter, jump_linenum - 1);
		gtk_text_buffer_place_cursor(pub->mw->buffer, &iter);
//		gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(textview), &iter, 0.1, FALSE, 0.5, 0.5);
		scroll_to_cursor(pub->mw->buffer, 0.25);
	}
	
	set_main_window_title();
//	hlight_apply_all(pub->mw->buffer);
	
	gtk_main();
	
	return 0;
}
Exemple #28
0
static void
update_display (GdauiCloud *cloud)
{
	GtkTextBuffer *tbuffer;
        GtkTextIter start, end;

        /* clean all */
        tbuffer = cloud->priv->tbuffer;
        gtk_text_buffer_get_start_iter (tbuffer, &start);
        gtk_text_buffer_get_end_iter (tbuffer, &end);
        gtk_text_buffer_delete (tbuffer, &start, &end);
	if (cloud->priv->selected_tags) {
		g_slist_foreach (cloud->priv->selected_tags, (GFunc) g_object_unref, NULL);
		g_slist_free (cloud->priv->selected_tags);
		cloud->priv->selected_tags = NULL;
		sync_iter_with_selection (cloud);
		g_signal_emit_by_name (cloud, "selection-changed");
	}

	if (!cloud->priv->model)
		return;
	if (cloud->priv->label_column < 0)
		return;
	/* check for the data model's column type */
	GdaColumn *column;
	column = gda_data_model_describe_column (cloud->priv->model, cloud->priv->label_column);
	if (!column || (gda_column_get_g_type (column) != G_TYPE_STRING)) {
		g_warning (_("Wrong column type for label: expecting a string and got a %s"),
			   gda_g_type_to_string (gda_column_get_g_type (column)));
		return;
	}

	gint nrows, i;
	nrows = gda_data_model_get_n_rows (cloud->priv->model);

	/* compute scale range */
	gdouble min_weight = G_MAXDOUBLE, max_weight = G_MINDOUBLE, wrange;
	if ((cloud->priv->weight_column >= 0) || cloud->priv->weight_func) {
		for (i = 0; i < nrows; i++) {
			const GValue *cvalue;
			gdouble weight = 1.;
			if (cloud->priv->weight_func) {
				weight = cloud->priv->weight_func (cloud->priv->model, i,
								   cloud->priv->weight_func_data);
				min_weight = MIN (min_weight, weight);
				max_weight = MAX (max_weight, weight);
			}
			else {
				cvalue = gda_data_model_get_value_at (cloud->priv->model,
								      cloud->priv->weight_column, i, NULL);
				if (cvalue) {
					weight = g_ascii_strtod (gda_value_stringify (cvalue), NULL);
					min_weight = MIN (min_weight, weight);
					max_weight = MAX (max_weight, weight);
				}
			}
		}
	}

	if (max_weight > min_weight)
		wrange = (cloud->priv->max_scale - cloud->priv->min_scale) / (max_weight - min_weight);
	else
		wrange = 0.;
	
	gtk_text_buffer_get_start_iter (tbuffer, &start);
	for (i = 0; i < nrows; i++) {
		const GValue *cvalue;
		gdouble weight = 1.;
		const gchar *ptr;
		GString *string;
		cvalue = gda_data_model_get_value_at (cloud->priv->model, cloud->priv->label_column, i, NULL);
		if (!cvalue) {
			TO_IMPLEMENT;
			continue;
		}
		if (!g_value_get_string (cvalue))
			continue;

		/* convert spaces to non breaking spaces (0xC2 0xA0 as UTF8) */
		string = g_string_new ("");
		for (ptr = g_value_get_string (cvalue); *ptr; ptr++) {
			if (*ptr == ' ') {
				g_string_append_c (string, 0xC2);
				g_string_append_c (string, 0xA0);
			}
			else
				g_string_append_c (string, *ptr);
		}

		if ((cloud->priv->weight_column >= 0) || cloud->priv->weight_func) {
			if (cloud->priv->weight_func) {
				weight = cloud->priv->weight_func (cloud->priv->model, i,
								   cloud->priv->weight_func_data);
				weight = cloud->priv->min_scale + wrange * (weight - min_weight);
			}
			else {
				cvalue = gda_data_model_get_value_at (cloud->priv->model,
								      cloud->priv->weight_column, i, NULL);
				if (cvalue) {
					weight = g_ascii_strtod (gda_value_stringify (cvalue), NULL);
					weight = cloud->priv->min_scale + wrange * (weight - min_weight);
				}
			}
		}

		GtkTextTag *tag;
		tag = gtk_text_buffer_create_tag (cloud->priv->tbuffer, NULL, 
					  "foreground", "#6161F2", 
					  "scale", weight,
					  NULL);
		g_object_set_data ((GObject*) tag, "row", GINT_TO_POINTER (i) + 1);
		gtk_text_buffer_insert_with_tags (cloud->priv->tbuffer, &start, string->str, -1,
						  tag, NULL);
		g_string_free (string, TRUE);
		gtk_text_buffer_insert (cloud->priv->tbuffer, &start, "   ", -1);
	}
}
Exemple #29
0
orcaData orcaGtk::ex_get_data(orcaVM* vm, int n)/*{{{*/
{
	if (n < 1) vm->need_param();
	orcaData key = vm->get_param(0);

	if (type == GUI_LIST || type == GUI_TREE) {
		if (is<TYPE_INT>(key)) {
			int nth = key.Integer();

			GtkTreeIter iter;
			gtk_tree_model_get_iter_first(store, &iter);

			for (int i=0; i<nth; i++) {
				if (!gtk_tree_model_iter_next(store, &iter))
					throw orcaException(vm, "orca.index", "out of index");
			}

			orcaList* lp = new orcaList();

			int width = gtk_tree_model_get_n_columns(store);
			for (int i=0; i<width; i++) {
				GValue value = { 0, };
				gtk_tree_model_get_value(store, &iter, i, &value);

				GType t = value.g_type;
				if (t == G_TYPE_STRING) {
					char* cp = (char*)g_value_get_string(&value);
					if (cp == NULL) cp = (char*)"";
					lp->push_back(cp);
				}
				else if (t == G_TYPE_BOOLEAN) {
					bool r = g_value_get_boolean(&value);
					lp->push_back(r);
				}
				else {
					lp->push_back(NIL);
				}

				g_value_unset(&value);
			}

			return lp;
		}

		string str = key.String();
		if (str == "begin") {
			orcaGtkIter* bp = new orcaGtkIter();
			bp->m_gp = this;
			gtk_tree_model_get_iter_first(store, &bp->m_iter);
			if (type == GUI_LIST)
				bp->m_type = GUI_LIST;
			else
				bp->m_type = GUI_TREE;

			return bp;
		}
		else if (type == GUI_TREE && str == "branch") {
			orcaTuple* path = castobj<orcaTuple>(vm->get_param(1));

			if (path == NULL) {
				return NIL;
			}
			
			orcaGtkIter* bp = new orcaGtkIter();
			bp->m_gp = this;
			bp->m_type = GUI_TREE;
			GtkTreeIter iter;
			GtkTreeIter parent;
			for (int i=0; i<path->size(); i++) {
				if (i==0) {
					gtk_tree_model_get_iter_first(store, &iter);
					for (int j=0; j<path->at(0).Integer(); j++) {
						if (!gtk_tree_model_iter_next(store, &iter))
							throw orcaException(vm, "orca.index", "out of index");
					}

					parent = iter;
					bp->m_iter = iter;
					continue;
				}
				
				if (!gtk_tree_model_iter_nth_child(store, &iter, &parent, path->at(i).Integer()))
						throw orcaException(vm, "orca.index", "out of index");

				parent = iter;
				bp->m_iter = iter;
			}

			return bp;
		}
	}
	else if (type == GUI_ENTRY) {
		if (key.String() == "text") {
			char* p = gtk_editable_get_chars(GTK_EDITABLE(handle), 0, -1);
			return p;
		}
	}
	else if (type == GUI_TEXT) {
		if (key.String() == "text") {
			GtkTextIter start_iter, end_iter;
			GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(handle));
			gtk_text_buffer_get_start_iter(buffer, &start_iter);
			gtk_text_buffer_get_end_iter(buffer, &end_iter);
			char* p = gtk_text_buffer_get_text(buffer, &start_iter, &end_iter, FALSE);
			return p;
		}
	}

	return NIL;
}
Exemple #30
0
void MergeDialog::load_text(ustring text)
{
  // Variables for loading text in the textview.
  size_t pos;
  GtkTextIter iter;

  // Preprocess empty replacements.
  preprocess_empty_replacements(text);

  // Goo through the text looking for markers and processing them.
  pos = text.find(merge_conflict_markup(1));
  while (pos != string::npos) {

    // Insert the bit of text before the first conflict marker.
    gtk_text_buffer_get_end_iter(textbuffer, &iter);
    gtk_text_buffer_insert(textbuffer, &iter, text.substr(0, pos).c_str(), -1);
    text.erase(0, pos + merge_conflict_markup(1).length());

    // Retrieve the first alternative.
    ustring alternative1;
    pos = text.find(merge_conflict_markup(2));
    if (pos != string::npos) {
      alternative1 = text.substr(1, pos - 2);
      text.erase(0, pos + merge_conflict_markup(2).length());
      if (alternative1.empty())
        alternative1 = empty_text();
    }
    // Insert a button with the first alternative as a label.
    gtk_text_buffer_get_end_iter(textbuffer, &iter);
    GtkTextChildAnchor *childanchor1 = gtk_text_buffer_create_child_anchor(textbuffer, &iter);
    GtkWidget *button1 = gtk_button_new_with_label(alternative1.c_str());
    gtk_text_view_add_child_at_anchor(GTK_TEXT_VIEW(textview), button1, childanchor1);
    gtk_widget_show_all(button1);
    g_signal_connect((gpointer) button1, "clicked", G_CALLBACK(on_mergebutton_clicked), gpointer(this));

    // Store data about first alternative.
    MergeButton mergebutton1;
    mergebutton1.childanchor = childanchor1;
    mergebutton1.button = button1;
    mergebutton1.text = alternative1;

    // Retrieve the second alternative.
    ustring alternative2;
    pos = text.find(merge_conflict_markup(3));
    if (pos != string::npos) {
      alternative2 = text.substr(1, pos - 2);
      text.erase(0, pos + merge_conflict_markup(3).length());
      if (alternative2.empty())
        alternative2 = empty_text();
    }
    // Insert a button with the second alternative as a label.
    gtk_text_buffer_get_end_iter(textbuffer, &iter);
    GtkTextChildAnchor *childanchor2 = gtk_text_buffer_create_child_anchor(textbuffer, &iter);
    GtkWidget *button2 = gtk_button_new_with_label(alternative2.c_str());
    gtk_text_view_add_child_at_anchor(GTK_TEXT_VIEW(textview), button2, childanchor2);
    gtk_widget_show_all(button2);
    g_signal_connect((gpointer) button2, "clicked", G_CALLBACK(on_mergebutton_clicked), gpointer(this));

    // Store data about second alternative.
    MergeButton mergebutton2;
    mergebutton2.childanchor = childanchor2;
    mergebutton2.button = button2;
    mergebutton2.text = alternative2;

    // Store the button pair.
    MergeButtonPair mergebuttonpair;
    mergebuttonpair.button1 = mergebutton1;
    mergebuttonpair.button2 = mergebutton2;
    buttonpairs.push_back(mergebuttonpair);

    // Next iteration.
    pos = text.find(merge_conflict_markup(1));
  }

  // Load remaining text in textview.
  gtk_text_buffer_get_end_iter(textbuffer, &iter);
  gtk_text_buffer_insert(textbuffer, &iter, text.substr(0, pos).c_str(), -1);

  // Scroll to beginning of buffer.
  gtk_text_buffer_get_start_iter(textbuffer, &iter);
  gtk_text_buffer_place_cursor(textbuffer, &iter);
  screen_scroll_to_iterator(GTK_TEXT_VIEW(textview), &iter);
}