widgets.c

串口调试工具。非常好的串口调试助手

  Label = gtk_label_new("CTS");
  gtk_box_pack_end(GTK_BOX(BoiteH), Label, FALSE, TRUE, 5);
  signals[3] = Label;

  Label = gtk_label_new("RTS");
  gtk_box_pack_end(GTK_BOX(BoiteH), Label, FALSE, TRUE, 5);
  signals[4] = Label;

  Label = gtk_label_new("DTR");
  gtk_box_pack_end(GTK_BOX(BoiteH), Label, FALSE, TRUE, 5);
  signals[5] = Label;

  g_signal_connect_after(GTK_OBJECT(display), "commit", G_CALLBACK(Got_Input), NULL);

  gtk_timeout_add(POLL_DELAY, (GtkFunction)control_signals_read, NULL);

  gtk_window_set_default_size(GTK_WINDOW(Fenetre), 750, 550);
  gtk_widget_show_all(Fenetre);
  gtk_widget_hide(GTK_WIDGET(Hex_Box));

}

void initialize_hexadecimal_display(void)
{
  total_bytes = 0;
  memset(blank_data, ' ', 128);
  blank_data[bytes_per_line * 3 + 5] = 0;
}

void put_hexadecimal(gchar *string, guint size)
{
  static gchar data[128];
  static gchar data_byte[6];
  static guint bytes;
  glong column, row;

  gint i = 0;

  if(size == 0)
    return;

  while(i < size)
    {    
      while(gtk_events_pending()) gtk_main_iteration();
      vte_terminal_get_cursor_position(VTE_TERMINAL(display), &column, &row);

      if(show_index)
	{
	  if(column == 0)
	    /* First byte on line */
	    {
	      sprintf(data, "%6d: ", total_bytes);
	      vte_terminal_feed(VTE_TERMINAL(display), data, strlen(data));
	      bytes = 0;
	    }
	}
      else
	{
	  if(column == 0)
	    bytes = 0;
	}

      /* Print hexadecimal characters */
      data[0] = 0;
      
      while(bytes < bytes_per_line && i < size)
	{
	  gint avance=0;
	  gchar ascii[1];
 
	  sprintf(data_byte, "%02X ", (guchar)string[i]);
	  vte_terminal_feed(VTE_TERMINAL(display), data_byte, 3);

	  avance = (bytes_per_line - bytes) * 3 + bytes + 2;

	  /* Move forward */
	  sprintf(data_byte, "%c[%dC", 27, avance);
	  vte_terminal_feed(VTE_TERMINAL(display), data_byte, strlen(data_byte));

	  /* Print ascii characters */	  
	  ascii[0] = (string[i] > 0x1F) ? string[i] : '.';
	  vte_terminal_feed(VTE_TERMINAL(display), ascii, 1);

	  /* Move backward */	      
	  sprintf(data_byte, "%c[%dD", 27, avance + 1);
	  vte_terminal_feed(VTE_TERMINAL(display), data_byte, strlen(data_byte));

	  if(bytes == bytes_per_line / 2 - 1)
	    vte_terminal_feed(VTE_TERMINAL(display), "- ", strlen("- "));
	  
	  bytes++;
	  i++;

	  /* End of line ? */
	  if(bytes == bytes_per_line)
	    {
	      vte_terminal_feed(VTE_TERMINAL(display), "\r\n", 2);
	      total_bytes += bytes;
	    }

	}     
      
    }
}

void put_text(gchar *string, guint size)
{
  int pos;
  GString *buffer_tmp;
  gchar *in_buffer;
  
  buffer_tmp =  g_string_new(string);
  in_buffer=buffer_tmp->str;

  in_buffer += size;
  for(pos=size; pos>0; pos--)
    {
      in_buffer--;
      if(*in_buffer=='\r' && *(in_buffer+1) != '\n') 
	{
	  g_string_insert_c(buffer_tmp, pos, '\n');
	  size += 1;
	}
      if(*in_buffer=='\n' && *(in_buffer-1) != '\r') 
	{
	  g_string_insert_c(buffer_tmp, pos-1, '\r');
	  size += 1;
	}
    }

  vte_terminal_feed(VTE_TERMINAL(display), buffer_tmp->str, size);
}

gint send_serial(gchar *string, gint len)
{
  gint bytes_written;

  bytes_written = Send_chars(string, len);
  if(bytes_written > 0)
    {
      if(echo_on)
	put_chars(string, bytes_written, crlfauto_on);
    }

  return bytes_written;
}


static void Got_Input(VteTerminal *widget, gchar *text, guint length, gpointer ptr)
{
  send_serial(text, length);
}

gboolean Envoie_car(GtkWidget *widget, GdkEventKey *event, gpointer pointer)
{
  if(g_utf8_validate(event->string, 1, NULL))
    send_serial(event->string, 1);

  return FALSE;
}


gint a_propos(GtkWidget *widget, guint param)
{
  GtkWidget *Dialogue, *Label, *Bouton;
  gchar *chaine;

  Dialogue = gtk_dialog_new();
  gtk_window_set_title(GTK_WINDOW(Dialogue), _("About..."));
  Bouton = gtk_button_new_from_stock (GTK_STOCK_OK);
  gtk_signal_connect_object(GTK_OBJECT(Bouton), "clicked", (GtkSignalFunc)gtk_widget_destroy, GTK_OBJECT(Dialogue));
  gtk_signal_connect(GTK_OBJECT(Dialogue), "destroy", (GtkSignalFunc)gtk_widget_destroy, NULL);
  gtk_signal_connect(GTK_OBJECT(Dialogue), "delete_event", (GtkSignalFunc)gtk_widget_destroy, NULL);
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton, TRUE, TRUE, 0);

  Label = gtk_label_new("");
  chaine = g_strdup_printf(_("\n <big><i> GTKTerm V. %s </i></big> \n\n\t(c) Julien Schmitt : [e-mail] \n\thttp://www.jls-info.com/julien/linux\n"), VERSION);
  gtk_label_set_markup(GTK_LABEL(Label), chaine);
  g_free(chaine);
  gtk_label_set_selectable(GTK_LABEL(Label), TRUE);
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Dialogue)->vbox), Label, TRUE, TRUE, 0);

  gtk_widget_show_all(Dialogue);

  return FALSE;
}

void show_control_signals(int stat)
{
  if(stat & TIOCM_RI)
    gtk_widget_set_sensitive(GTK_WIDGET(signals[0]), TRUE);
  else
    gtk_widget_set_sensitive(GTK_WIDGET(signals[0]), FALSE);
  if(stat & TIOCM_DSR)
    gtk_widget_set_sensitive(GTK_WIDGET(signals[1]), TRUE);
  else
    gtk_widget_set_sensitive(GTK_WIDGET(signals[1]), FALSE);
  if(stat & TIOCM_CD)
    gtk_widget_set_sensitive(GTK_WIDGET(signals[2]), TRUE);
  else
    gtk_widget_set_sensitive(GTK_WIDGET(signals[2]), FALSE);
  if(stat & TIOCM_CTS)
    gtk_widget_set_sensitive(GTK_WIDGET(signals[3]), TRUE);
  else
    gtk_widget_set_sensitive(GTK_WIDGET(signals[3]), FALSE);
  if(stat & TIOCM_RTS)
    gtk_widget_set_sensitive(GTK_WIDGET(signals[4]), TRUE);
  else
    gtk_widget_set_sensitive(GTK_WIDGET(signals[4]), FALSE);
  if(stat & TIOCM_DTR)
    gtk_widget_set_sensitive(GTK_WIDGET(signals[5]), TRUE);
  else
    gtk_widget_set_sensitive(GTK_WIDGET(signals[5]), FALSE);  
}

gint signaux(GtkWidget *widget, guint param)
{
  if(param == 2)
    {
      sendbreak();
      Put_temp_message(_("Break signal sent !"), 800);
    }
  else
    Set_signals(param);
  return FALSE;
}

gboolean control_signals_read(void)
{
  int state;

  state = lis_sig();
  if(state >= 0)
    show_control_signals(state);

  return TRUE;
}

void Set_status_message(gchar *msg)
{
  gtk_statusbar_pop(GTK_STATUSBAR(StatusBar), id);
  gtk_statusbar_push(GTK_STATUSBAR(StatusBar), id, msg);
}

void show_message(gchar *message, gint type_msg)
{
 GtkWidget *Fenetre_msg;
 
 if(type_msg==MSG_ERR)
   {
     Fenetre_msg = 
       gtk_message_dialog_new(GTK_WINDOW(Fenetre), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, message);
   }
 else if(type_msg==MSG_WRN)
   {
     Fenetre_msg = 
       gtk_message_dialog_new(GTK_WINDOW(Fenetre), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, message);
   }
 else
   return;

 gtk_dialog_run(GTK_DIALOG(Fenetre_msg));
 gtk_widget_destroy(Fenetre_msg);
}

gboolean Send_Hexadecimal(GtkWidget *widget, GdkEventKey *event, gpointer pointer)
{
  gint i;
  gchar *text, *current;
  gchar *message;
  guchar val;
  guint val_read;
  guint sent = 0;
  gchar written[3];
  gchar *all_written;

  text = (gchar *)gtk_entry_get_text(GTK_ENTRY(widget));

  all_written = g_malloc(strlen(text) * 2);
  all_written[0] = 0;

  current = text;
  i = 0;
  while(i < strlen(text))
    {
      if(sscanf(current, "%02X", &val_read) == 1)
	{
	  val = (guchar)val_read;
	  send_serial(&val, 1);
	  sprintf(written, "%02X ", val);
	  strcat(all_written, written);
	  sent++;
	}
      while(i < strlen(text) && text[i] != ';' && text[i] != ' ')
	i++;
      if(text[i] == ';' || text[i] == ' ')
	{
	  i++;
	  current = &text[i];
	}
    }
  all_written[strlen(all_written) - 1] = 0;
  message = g_strdup_printf(_("\"%s\" : %d byte(s) sent !"), all_written, sent);
  Put_temp_message(message, 1500);
  gtk_entry_set_text(GTK_ENTRY(widget), "");
  g_free(message);
  g_free(all_written);

  return FALSE;
}

void Put_temp_message(const gchar *text, gint time)
{
  /* time in ms */
  gtk_statusbar_push(GTK_STATUSBAR(StatusBar), id, text);
  gtk_timeout_add(time, (GtkFunction)pop_message, NULL);  
}

gboolean pop_message(void)
{
  gtk_statusbar_pop(GTK_STATUSBAR(StatusBar), id);

  return FALSE;
}

void clear_display(void)
{
  initialize_hexadecimal_display();
  if(display)
    vte_terminal_reset(VTE_TERMINAL(display), TRUE, TRUE);
}