buttons_menu.c

linux上实现的多种型号的AVR模拟器

/*
 File        : buttons_menu.c

 Author      : Sergiy Uvarov - Copyright (C) 2001

 Description : Creation of buttons and menu.

 Copyright notice:

 avr_simulator - A GNU/Linux simulator for the Atmel AVR series
 of microcontrollers. Copyright (C) 2001 Sergey Uvarov

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 Sergiy Uvarov

 E-mail : [e-mail]
*/

#include <stdio.h>
#include <libintl.h>
#include <string.h>
#include <pthread.h>
#include <signal.h>
#include <Xm/XmAll.h>
#include "types.h"
#include "global.h"
#include "buttons_menu.h"

#define _(x) (x)

void reload_flash_callback();
void reload_eeprom_callback();
void reset_callback();
void trace_into_callback();
void step_over_callback();
void step_out_callback();
void multi_step_callback();
void auto_step_callback();
void run_callback();
void stop_callback();
void load_eeprom_callback();
void load_flash_callback();
void toggle_gpr_callback();
void toggle_sram_callback();
void toggle_io_callback();
void toggle_eeprom_callback();
void toggle_memory_callback();
void logging_callback();
void stimuli_callback();
void change_sensitive_run();
void change_sensitive_stop();
int thread_stop;

Buttons buttons[]={
  {_("Open"),load_flash_callback,&file_selection,"xpm/load.xpm",_("Load Flash")},
  {_("Reload"),reload_flash_callback,NULL,"xpm/reload.xpm",_("Reload Flash")},
  {"separator",NULL,NULL,NULL,NULL},
  {_("Trace"),trace_into_callback,NULL,"xpm/trace_into.xpm",
   _("Trace into")},
  {_("Step Over"),step_over_callback,NULL,"xpm/step_over.xpm",_("Step Over")},
  {_("Step Out"),step_out_callback,NULL,"xpm/step_out.xpm",_("Step Out")},
  {_("Multi Step"),multi_step_callback,NULL,"xpm/multi_step.xpm",_("Multi Step")},
  {_("Auto Step"),auto_step_callback,NULL,"xpm/auto_step.xpm",_("Auto Step")},
  {"separator",NULL,NULL,NULL,NULL},
  {_("Run"),run_callback,NULL,"xpm/run.xpm",_("Run")},
  {_("Stop"),stop_callback,NULL,"xpm/stop.xpm",_("Stop")},
  {"separator",NULL,NULL,NULL,NULL},
  {_("Reset"),reset_callback,NULL,"xpm/reset.xpm",_("Reset")},
  
};

Menu file_menu[]={
  {BUTTON,_("Load Flash..."),"F","Alt+L","Alt<Key>l",NULL,0,
   load_flash_callback,&file_selection},
  {BUTTON,_("Reload Flash"),"R",NULL,NULL,NULL,0,reload_flash_callback,NULL},
  {SEPARATOR,"separaor",NULL,NULL,NULL,NULL,0,NULL,NULL},
  {BUTTON,_("Load EEPROM..."),"E","Alt+E","Alt<Key>e",NULL,0,
   load_eeprom_callback,&file_selection},
  {BUTTON,_("Reload EEPROM"),"o",NULL,NULL,NULL,0,reload_eeprom_callback,NULL},
  {SEPARATOR,"separaor",NULL,NULL,NULL,NULL,0,NULL,NULL},
  {BUTTON,_("Quit"),"Q","Alt+Q","Alt<Key>q",NULL,0,quit_callback,NULL},
};

Menu memory_menu[]={
  {CHECK,_("General Registers"),"G",NULL,NULL,NULL,0,toggle_gpr_callback,
   &gpr_window},
  {CHECK,_("I/O Registers"),"I",NULL,NULL,NULL,0,toggle_io_callback,
   &io_window},
  {CHECK,_("SRAM"),"S",NULL,NULL,NULL,0,toggle_sram_callback,&sram_window},
  {CHECK,_("EEPROM"),"E",NULL,NULL,NULL,0,toggle_eeprom_callback,
   &eeprom_window},
  {CHECK,_("Memory"),"M",NULL,NULL,NULL,0,toggle_memory_callback,
   &memory_window}
};

Menu debug_menu[]={
  {BUTTON,_("Reset"),"R",NULL,NULL,NULL,0,reset_callback,NULL},
  {BUTTON,_("Run"),"u",NULL,NULL,NULL,0,run_callback,NULL},
  {BUTTON,_("Stop"),"S",NULL,NULL,NULL,0,stop_callback,NULL},
  {BUTTON,_("Trace into"),"T",NULL,NULL,NULL,0,trace_into_callback,NULL},
  {BUTTON,_("Step Over"),"e",NULL,NULL,NULL,0,step_over_callback,NULL},
  {BUTTON,_("Step Out"),"O",NULL,NULL,NULL,0,step_out_callback,NULL},
  {BUTTON,_("Multi Step"),"M",NULL,NULL,NULL,0,multi_step_callback,NULL},
  {BUTTON,_("Auto Step"),"A",NULL,NULL,NULL,0,auto_step_callback,NULL},
};

Menu options_menu[]={
  {BUTTON,_("Project..."),"P",NULL,NULL,NULL,0,manage,&project_window},
  {BUTTON,_("Debugger..."),"D",NULL,NULL,NULL,0,manage,&debugger_window},
  {BUTTON,_("Port Logging..."),"L",NULL,NULL,NULL,0,logging_callback,NULL},
  {BUTTON,_("Port Stimuli..."),"S",NULL,NULL,NULL,0,stimuli_callback,NULL}
};

Menu help_menu[]={
  {BUTTON,_("About"),"A",NULL,NULL,NULL,0,manage,&about_window}
};

Menu menu[]={
  {BUTTON,_("File"),"F",NULL,NULL,(struct _Menu *)file_menu,
   XtNumber(file_menu), NULL,NULL,(Widget)0,(Widget)0},
  {BUTTON,_("View"),"V",NULL,NULL,(struct _Menu *)memory_menu,
   XtNumber(memory_menu),NULL,NULL,(Widget)0,(Widget)0},
  {BUTTON,_("Debug"),"D",NULL,NULL,(struct _Menu *)debug_menu,
   XtNumber(debug_menu),NULL,NULL,(Widget)0,(Widget)0},
  {BUTTON,_("Options"),"O",NULL,NULL,(struct _Menu *)options_menu,
   XtNumber(options_menu),NULL,NULL,(Widget)0,(Widget)0},
  {BUTTON,_("Help"),"H",NULL,NULL,(struct _Menu *)help_menu,
   XtNumber(help_menu),
   NULL,NULL,(Widget)0,(Widget)0},
};

void create_buttons(Widget parent)
{
  XmString string;
  int n,num_buf,num=0,string_check=0;
  Arg args[12];
  Pixel background,background_arm;
  

  XtVaGetValues(parent,XmNbackground,&background,XmNtopShadowColor,
		&background_arm,NULL);

  XtSetArg(args[num],XmNtopAttachment,XmATTACH_FORM);num++;
  XtSetArg(args[num],XmNtopOffset,3);num++;
  XtSetArg(args[num],XmNleftOffset,3);num++;
  XtSetArg(args[num],XmNhighlightThickness,1);num++;
  XtSetArg(args[num],XmNshadowThickness,1);num++;
  XtSetArg(args[num],XmNmarginWidth,1);num++;
  XtSetArg(args[num],XmNmarginHeight,1);num++;
  XtSetArg(args[num],XmNhighlightOnEnter,True);num++;
  num_buf=num;
  string_check=0;
  for(n=0;n<XtNumber(buttons);n++)
    {
      num=num_buf;
      if(!(strcmp(buttons[n].name,"separator")))
	{
	  buttons[n].widget=
	    XtVaCreateManagedWidget(buttons[n].name,xmSeparatorGadgetClass,
				    parent,XmNtopAttachment,XmATTACH_FORM,
				    XmNtopOffset,2,XmNleftOffset,3,
				    XmNleftAttachment,XmATTACH_WIDGET,
				    XmNleftWidget,buttons[n-1].widget,
				    XmNorientation,XmVERTICAL,
				    XmNbottomAttachment,XmATTACH_FORM,
				    XmNbottomOffset,1,
				    NULL);
	  continue;
	}

      if(buttons[n].name_pixmap!=NULL)
	{
	  if((buttons[n].pixmap=XmGetPixmap(XtScreen(parent),
					    buttons[n].name_pixmap,
					    BlackPixel(XtDisplay(parent),0),
					    WhitePixel(XtDisplay(parent),0)
					    ))==XmUNSPECIFIED_PIXMAP) 
	    {
	      fprintf(stderr," Pixmap problem with file %s\n",
		      buttons[n].name_pixmap);
	      string=XmStringGenerate(gettext(buttons[n].name),
				      XmFONTLIST_DEFAULT_TAG,
				      XmCHARSET_TEXT,_MOTIF_DEFAULT_LOCALE);
	      XtSetArg(args[num],XmNlabelString,string);num++;
	      string_check=1;
	    }
	  else
	    {
	      XtSetArg(args[num],XmNlabelType,XmPIXMAP);num++;
	      XtSetArg(args[num],XmNlabelPixmap,buttons[n].pixmap);num++; 
	      string_check=0;
	    }
	}
      else
	{
	  string=XmStringGenerate(gettext(buttons[n].name),
				  XmFONTLIST_DEFAULT_TAG,
				  XmCHARSET_TEXT,_MOTIF_DEFAULT_LOCALE);
	  XtSetArg(args[num],XmNlabelString,string);num++;
	  string_check=1;
	}
      
      if(n==0)
	{
	  XtSetArg(args[num],XmNleftAttachment,XmATTACH_FORM);
	  num++;
	}
      else
	{
	  XtSetArg(args[num],XmNleftAttachment,XmATTACH_WIDGET);num++;
	  XtSetArg(args[num],XmNleftWidget,buttons[n-1].widget);num++;
	}
      
      buttons[n].widget=XmCreatePushButton(parent,buttons[n].name,args,num);
      
      XtAddCallback(buttons[n].widget,
		    XmNactivateCallback,(XtCallbackProc)buttons[n].callback,
		    (XtPointer)buttons[n].call_data);
      if(string_check) XmStringFree(string);
      xs_widget_tip(buttons[n].widget,gettext(buttons[n].prompt_str));
      XtManageChild(buttons[n].widget);
    }
  
}


void create_menu(Widget parent,Menu *menu,int number)
{
  int n,num;
  XmString string,string_accel;
  Arg args[10];
  
  for(n=0;n<number;n++)
    {
      if(menu[n].type==SEPARATOR)
	{
	  menu[n].button=
	    XtVaCreateManagedWidget(menu[n].name,xmSeparatorGadgetClass,
				    parent,NULL);
	  continue;
	}
      num=0;
      string=XmStringGenerate(gettext(menu[n].name),XmFONTLIST_DEFAULT_TAG,
			      XmCHARSET_TEXT,_MOTIF_DEFAULT_LOCALE);
      XtSetArg(args[num],XmNlabelString,string);num++;
      XtSetArg(args[num],XmNshadowThickness,1);num++;
      if(menu[n].mnemonic!=NULL)
	{
	  XtSetArg(args[num],XmNmnemonic,XStringToKeysym(menu[n].mnemonic));
	  num++;
	}
      if(menu[n].accelerator_text!=NULL)
	{
	  string_accel=XmStringGenerate(menu[n].accelerator_text,
					XmFONTLIST_DEFAULT_TAG,
					XmCHARSET_TEXT,_MOTIF_DEFAULT_LOCALE);
	  XtSetArg(args[num],XmNacceleratorText,string_accel);num++;
	}

      if(menu[n].accelerator!=NULL)
	{
	  XtSetArg(args[num],XmNaccelerator,menu[n].accelerator);num++;
	}
      if(menu[n].type==BUTTON)
	{
	  if(menu[n].sub_menu!=NULL)
	    {
	      menu[n].pulldown=
		XmCreatePulldownMenu(parent,menu[n].name,NULL,0);
	      XtVaSetValues(menu[n].pulldown,XmNshadowThickness,1,NULL);
	      XtSetArg(args[num],XmNsubMenuId,menu[n].pulldown);num++;
	      menu[n].button=
		XtCreateManagedWidget(menu[n].name,xmCascadeButtonWidgetClass,
				      parent,args,num);
	      create_menu(menu[n].pulldown,menu[n].sub_menu,
			  menu[n].n_sub_items);
	    }
	  else
	    {
	      menu[n].button=
		XtCreateManagedWidget(menu[n].name,xmPushButtonWidgetClass,
				      parent,args,num);
	    }
	  if(menu[n].callback!=NULL)
	    XtAddCallback(menu[n].button,XmNactivateCallback,
			  (XtCallbackProc)menu[n].callback,
			  (XtPointer)menu[n].data);
	}
      if(menu[n].type==CHECK)
	{
	  XtSetArg(args[num],XmNindicatorOn,XmINDICATOR_CHECK);num++;
	  menu[n].button=
	    XtCreateManagedWidget(menu[n].name,xmToggleButtonGadgetClass,
				  parent,args,num);
	  if(menu[n].callback!=NULL)
	    XtAddCallback(menu[n].button,XmNvalueChangedCallback,
			  (XtCallbackProc)menu[n].callback,
			  (XtPointer)menu[n].data);
	}

      if(!strcmp(menu[n].name,"Help"))
	XtVaSetValues(parent,XmNmenuHelpWidget,menu[n].button,NULL);
      XmStringFree(string);
      if(menu[n].accelerator_text!=NULL) XmStringFree(string_accel);
    }
}

void reload_flash_callback(Widget w,XtPointer client_data, XtPointer call_data)
{
  load_flash(NULL);
}

void reload_eeprom_callback(Widget w,XtPointer client_data,XtPointer call_data)
{
  load_eeprom(NULL);
}

void trace_into_callback(Widget w,XtPointer client_data, XtPointer call_data)
{
  memset(mem_file_changed,0,size_mem_file);
  memset(eeprom_changed,0,size_eeprom);
  if(pc==-1)
    {
      reset();
    }
  else
    {
      exec_command();
      drawarea.current_line_deb=list_commands[pc].number_line;
      debug=TRUE;
      draw();
      debug=FALSE;
      if(pc>=controllers[type_micro].size_flash) pc=0;
    }

  update_gpr_window();
  update_sram_window();
  update_io_window(); 
  update_main();
  full_update_memory_window();
}

void step_over_callback(Widget w,XtPointer client_data, XtPointer call_data)
{
  int n;

  memset(mem_file_changed,0,size_mem_file);
  memset(eeprom_changed,0,size_eeprom); 
  if(pc==-1)
    {
      reset();
    }
  else
    {
      if(strncmp(list_commands[pc].mnemocode,"call",4)&&
	 strncmp(list_commands[pc].mnemocode,"rcall",5)&&
	 strncmp(list_commands[pc].mnemocode,"icall",5)&&
	 strncmp(list_commands[pc].mnemocode,"eicall",6))
	{
	  exec_command();
	}
      else
	{
	  n=0;
	  do{
	    exec_command();
	    n++;
	    if(list_commands[pc].flags&BREAKPOINT) break;
	  }while(strncmp(list_commands[pc].mnemocode,"ret",3)&&n<2000);
	  if(!(list_commands[pc].flags&BREAKPOINT)) exec_command();
	}
      drawarea.current_line_deb=list_commands[pc].number_line;
      debug=TRUE;
      draw();
      debug=FALSE;
      if(pc>=controllers[type_micro].size_flash) pc=0;
    }