menu_memory.c

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

void field_changed_callback(Widget w,XtPointer client_data,
			    XtPointer call_data)
{
  char *buf,buf2[10];
  int n;

  buf=XmTextFieldGetString(w);
  n=0;
  while(n<controllers[type_micro].size_gpr&&w!=field[n]) n++;
  if(type_gpr_window==DEC)
    gpr_pointer[n]=strtoul(buf,NULL,10);
  else
    {
      sprintf(buf2,"0x%s",buf);
      gpr_pointer[n]=strtoul(buf2,NULL,16);
    }
  delete_tip(field[n],gpr_tip_str[n]);
  xs_widget_tip(field[n],conv_to_bin((int)gpr_pointer[n],gpr_tip_str[n]));
  XtFree(buf);
  if(n>25) update_main(); 
}

void close_button_gpr(Widget w,XtPointer client_data,XtPointer call_data)
{
  XtVaSetValues(menu[MEMORY_MENU].sub_menu[GPR_BUTTON].button,XmNset,XmUNSET,
		NULL);
  XtUnmanageChild(gpr_window);
}

/* allow visible cursor */
void get_focus_field_callback (Widget w,XtPointer client_data,
			       XtPointer call_data)
{
  XtVaSetValues(w,XmNcursorPositionVisible,True,NULL);
  XtAddCallback(w,XmNvalueChangedCallback,(XtCallbackProc)
		field_changed_callback,NULL);
}

/* don't allow visible cursor*/
void lose_focus_field_callback (Widget w,XtPointer client_data,
			       XtPointer call_data)
{
  XtVaSetValues(w,XmNcursorPositionVisible,False,NULL);
  XtRemoveCallback(w,XmNvalueChangedCallback,(XtCallbackProc)
		   field_changed_callback,NULL);
}

/* SRAM window */
void create_sram_window(void)
{
  Widget scroll,sram_form,temp,shell,frame,*widgetlist;
  XmString string;
  int n,address,n_wid,t,n_args;
  char buf[6];
  Arg args[20];

  if((field_sram=malloc(16*MAX_SRAM_LINES*sizeof(Widget)))==NULL)
    {
      puts("create_sram_window(): can't allocate memory for 'field_sram'");
      exit(1);
    }
  if((label_sram=malloc(MAX_SRAM_LINES*sizeof(Widget)))==NULL)
    {
      puts("create_sram_window(): can't allocate memory for 'label_sram'");
      exit(1);
    }
  if((sram_tip_str=malloc(MAX_SRAM_LINES*16*sizeof(char *)))==NULL)
    {
      puts("create_sram_window(): can't allocate memory for 'sram_tip_str'");
      exit(1);
    }
  
  for(n=0;n<MAX_SRAM_LINES*16;n++)
    {
      if((sram_tip_str[n]=malloc(10*sizeof(char)))==NULL)
	{
	  printf("create_sram_window(): \
can't allocate memory for 'sram_tip_str[%d]'",n);
	  exit(1);
	}
      sram_tip_str[n][0]=0;
    }
  

  memset(label_sram,0,MAX_SRAM_LINES*sizeof(Widget));
  

  shell=XtVaCreateWidget("Shell",xmDialogShellWidgetClass,toplevel,
			 XmNtitle,_("SRAM"),NULL);
  sram_window=XtVaCreateWidget("form",xmFormWidgetClass,shell,
			       XmNautoUnmanage,False,
			       XmNdialogStyle,XmDIALOG_MODELESS,
			       XmNfractionBase,5,NULL);

  frame=XtVaCreateManagedWidget("frame",xmFrameWidgetClass,sram_window,
				XmNtopAttachment,XmATTACH_FORM,
				XmNtopOffset,5,
				XmNleftAttachment,XmATTACH_FORM,
				XmNleftOffset,5,
				XmNrightAttachment,XmATTACH_FORM,
				XmNrightOffset,5,NULL);
  sram_form=XtVaCreateManagedWidget("form",xmFormWidgetClass,frame,NULL);
  
  /* create firs row, labels */
  n_args=0;
  XtSetArg(args[n_args],XmNcursorPositionVisible,False);n_args++;
  XtSetArg(args[n_args],XmNeditable,False);n_args++;
  XtSetArg(args[n_args],XmNtopOffset,8);n_args++;
  XtSetArg(args[n_args],XmNtopAttachment,XmATTACH_FORM);n_args++;
  t=n_args;

  XtSetArg(args[n_args],XmNleftOffset,3);n_args++;
  XtSetArg(args[n_args],XmNleftAttachment,XmATTACH_FORM);n_args++;
  XtSetArg(args[n_args],XmNvalue,"");n_args++;
  XtSetArg(args[n_args],XmNcolumns,4);n_args++;
  XtSetArg(args[n_args],XmNmaxLength,4);n_args++;

  temp=XtCreateManagedWidget("memory_label",xmTextFieldWidgetClass,sram_form,
			     args,n_args);

  n_args=t;
  XtSetArg(args[n_args],XmNleftAttachment,XmATTACH_WIDGET);n_args++;
  XtSetArg(args[n_args],XmNcolumns,3);n_args++;
  XtSetArg(args[n_args],XmNmaxLength,3);n_args++;
  XtSetArg(args[n_args],XmNleftOffset,2);n_args++;
  t=n_args;
  for(n=0;n<16;n++)
    {
      n_args=t;
      sprintf(buf,"%X",n);
      fill_zero(buf,2);
      XtSetArg(args[n_args],XmNvalue,buf);n_args++;
      XtSetArg(args[n_args],XmNleftWidget,temp);n_args++;
      temp=XtCreateManagedWidget("memory_label",xmTextFieldWidgetClass,
				 sram_form,args,n_args);
    }

  /* create scroll window */
  scroll=XtVaCreateManagedWidget("Scroll",xmScrolledWindowWidgetClass,
				 sram_form,
				 XmNscrollingPolicy,XmAPPLICATION_DEFINED,
				 XmNscrollBarDisplayPolicy,XmSTATIC,
				 XmNleftAttachment,XmATTACH_FORM,
				 XmNleftOffset,3,
				 XmNrightAttachment,XmATTACH_FORM,
				 XmNrightOffset,2,
				 XmNtopAttachment,XmATTACH_WIDGET,
				 XmNtopWidget,temp,
				 XmNbottomAttachment,XmATTACH_FORM,
				 XmNbottomOffset,3,
				 NULL);
  
  dataform_sram=XtVaCreateManagedWidget("form area",xmFormWidgetClass,scroll,
					NULL);
  
  vscr_sram_bar=XtVaCreateManagedWidget("scr_bar",xmScrollBarWidgetClass,
					scroll,XmNorientation,XmVERTICAL,
					XmNincrement,1,XmNminimum,0,
					XmNvalue,0,NULL);
  XtAddCallback(vscr_sram_bar,XmNvalueChangedCallback,
		(XtCallbackProc)scroll_bar_sram_callback,NULL);
  XtAddCallback(vscr_sram_bar,XmNdragCallback,
		(XtCallbackProc)scroll_bar_sram_callback,NULL);
  XmScrolledWindowSetAreas(scroll,NULL,vscr_sram_bar,dataform_sram);

  /* size of 'vscr_sram_bar' must be equal size of end space */
  XtVaGetValues(vscr_sram_bar,XmNwidth,(Dimension *)&n,NULL);
  XtVaSetValues(temp,XmNrightAttachment,XmATTACH_FORM,
		XmNrightOffset,n,NULL);
  
  /* create input fields */
  if((widgetlist=malloc(nlines_sram*17*sizeof(Widget)))==NULL)
    {
      puts("create_sram_window(): can't allocate memory for 'widgetlist'");
      exit(1);
    }
  n_wid=0;
  for(n=0,address=address_sram;n<nlines_sram;n++,address+=16)
    create_sram_line(n,address,widgetlist,&n_wid);
/*    XtManageChildren(widgetlist,n_wid); */
  free(widgetlist);

  string=XmStringGenerate(_("Decimal"),XmFONTLIST_DEFAULT_TAG,
			  XmCHARSET_TEXT,_MOTIF_DEFAULT_LOCALE);  
  temp=XtVaCreateManagedWidget("Dec",xmPushButtonGadgetClass,
			       sram_window,
			       XmNleftAttachment,XmATTACH_POSITION,
			       XmNleftPosition,1,XmNlabelString,string,
			       XmNrightAttachment,XmATTACH_POSITION,
			       XmNrightPosition,2,
			       XmNbottomAttachment,XmATTACH_FORM,
			       XmNbottomOffset,6,NULL);
  
  XtAddCallback(temp,
		XmNactivateCallback,(XtCallbackProc)switch_button_sram,NULL);
  XmStringFree(string);
  
  string=XmStringGenerate(_("Close"),XmFONTLIST_DEFAULT_TAG,
			  XmCHARSET_TEXT,_MOTIF_DEFAULT_LOCALE);
  temp=XtVaCreateManagedWidget("Close",xmPushButtonGadgetClass,
			       sram_window,
			       XmNleftAttachment,XmATTACH_POSITION,
			       XmNleftPosition,3,
			       XmNrightAttachment,XmATTACH_POSITION,
			       XmNrightPosition,4,XmNlabelString,string,
			       XmNbottomAttachment,XmATTACH_FORM,
			       XmNbottomOffset,6,NULL);
  
  XtAddCallback(temp,
		XmNactivateCallback,(XtCallbackProc)close_button_sram,NULL);
  XmStringFree(string);
  XtVaSetValues(frame,XmNbottomOffset,6,XmNbottomAttachment,XmATTACH_WIDGET,
		XmNbottomWidget,temp,NULL);
  XtAddCallback(shell,XmNpopupCallback,(XtCallbackProc)set_size_sram_window,
		NULL);
  XtAddEventHandler(shell,StructureNotifyMask,False,resize_sram,NULL);
}

void create_sram_line(int n,int address,Widget *widgetlist,int *n_wid)
{
  int i,n_args,num_wid,t;
  char buf[6];
  Arg args[20];

  num_wid=*n_wid;
  n_args=0;
  sprintf(buf,"%X",address+controllers[type_micro].size_gpr+
	  controllers[type_micro].size_io_reg);
  fill_zero(buf,4);
  
  /* main resource */
  XtSetArg(args[n_args],XmNcursorPositionVisible,False);n_args++;
  XtSetArg(args[n_args],XmNshadowThickness,1);n_args++;
  t=n_args;

  XtSetArg(args[n_args],XmNcolumns,4);n_args++;
  XtSetArg(args[n_args],XmNmaxLength,4);n_args++;
  XtSetArg(args[n_args],XmNleftAttachment,XmATTACH_FORM);n_args++;
  XtSetArg(args[n_args],XmNvalue,buf);n_args++;
  XtSetArg(args[n_args],XmNeditable,False);n_args++;
  if(n==0)
    {
      XtSetArg(args[n_args],XmNtopAttachment,XmATTACH_FORM);n_args++;
      XtSetArg(args[n_args],XmNtopOffset,1);n_args++;

    }
  else
    {
      XtSetArg(args[n_args],XmNtopOffset,2);n_args++;
      XtSetArg(args[n_args],XmNtopAttachment,XmATTACH_WIDGET);n_args++;
      XtSetArg(args[n_args],XmNtopWidget,label_sram[n-1]);n_args++;
    }
  
  widgetlist[num_wid++]=label_sram[n]=
    XtCreateManagedWidget("memory_label",xmTextFieldWidgetClass,dataform_sram,
			  args,n_args);

  n_args=t;
  XtSetArg(args[n_args],XmNleftOffset,0);n_args++;
  XtSetArg(args[n_args],XmNcolumns,3);n_args++;
  XtSetArg(args[n_args],XmNmaxLength,2);n_args++;
  XtSetArg(args[n_args],XmNvalue,"0");n_args++;
  t=n_args;
  for(i=0;i<16;i++)
    {
      n_args=t;
      if(i==0) 
	{
	  XtSetArg(args[n_args],XmNleftAttachment,XmATTACH_WIDGET);n_args++;
	  XtSetArg(args[n_args],XmNleftWidget,label_sram[n]);n_args++;
	}
      else
	{
	  XtSetArg(args[n_args],XmNleftAttachment,XmATTACH_WIDGET);n_args++;
	  XtSetArg(args[n_args],XmNleftWidget,field_sram[n*16+i-1]);n_args++;
	}
      
      if(n==0) 
	{XtSetArg(args[n_args],XmNtopAttachment,XmATTACH_FORM);n_args++;}
      else 
	{
	  XtSetArg(args[n_args],XmNtopAttachment,XmATTACH_WIDGET);n_args++;
	  XtSetArg(args[n_args],XmNtopWidget,field_sram[(n-1)*16+i]);n_args++;
	}
      widgetlist[num_wid++]=field_sram[n*16+i]=
	XtCreateManagedWidget("memory_field",xmTextFieldWidgetClass,
			      dataform_sram,args,n_args);
      xs_widget_tip(field_sram[n*16+i],sram_tip_str[n]);
      XtAddCallback(field_sram[n*16+i],XmNfocusCallback,(XtCallbackProc)
		    get_focus_field_sram_callback,NULL);
      XtAddCallback(field_sram[n*16+i],XmNlosingFocusCallback,
		    (XtCallbackProc)lose_focus_field_sram_callback,NULL);
      
    }
  XtVaSetValues(field_sram[n*16+i-1],XmNrightAttachment,
		XmATTACH_FORM,NULL);
  *n_wid=num_wid;
}

void resize_sram(Widget w,char *m,XConfigureEvent *event,
		 Boolean *continueDispatch)
{
  int n,n_wid;
  Widget *widgetlist;
  
  if(event->type==ConfigureNotify)
    if(event->height!=height_min_sram_window+nlines_sram*sram_window_step) 
      {
	nlines_sram_old=nlines_sram;
	nlines_sram=(event->height-height_min_sram_window)/sram_window_step;
	
	if(nlines_sram>controllers[type_micro].size_sram/16)
	  {
	    nlines_sram=controllers[type_micro].size_sram/16;
	    if(nlines_sram==nlines_sram_old) return;
	  }
	
	if(nlines_sram>nlines_sram_old)
	  {  /* increase io_lines */
	    
	    if((widgetlist=malloc(nlines_sram*17*sizeof(Widget)))==NULL)
	      {
		puts("resize_sram(): can't allocate memory for 'widgetlist'");
		exit(1);
	      }
	    n_wid=0;
	    for(n=nlines_sram_old;n<nlines_sram;n++)
	      {
		
		if(label_sram[n]==NULL)
		  create_sram_line(n,0,widgetlist,&n_wid);
	      }
	    if(n_wid) XtManageChildren(widgetlist,n_wid);
	    free(widgetlist);
	  }
	
	XtVaSetValues(vscr_sram_bar,XmNmaximum,
		      controllers[type_micro].size_sram/16,XmNsliderSize,
		      nlines_sram,NULL);
	
	if(address_sram+nlines_sram>controllers[type_micro].size_sram/16)
	  {
	    address_sram=controllers[type_micro].size_sram-nlines_sram*16;
	    XtVaSetValues(vscr_sram_bar,XmNvalue,address_sram/16,NULL);
	  }
	full_update_sram_window();
      }

}

void scroll_bar_sram_callback (Widget w,XtPointer client_data,
			       XtPointer call_data)
{ 
  XtVaGetValues(vscr_sram_bar,XmNvalue,&address_sram,NULL);
  address_sram*=16;
  full_update_sram_window();
}

void full_update_sram_window(void)
{
  int n,address;
  char buf[10];
  unsigned char value;
  
  XtVaGetValues(menu[MEMORY_MENU].sub_menu[SRAM_BUTTON].button,
		XmNset,&value,NULL);
  if(value!=XmSET) return;
  
  if(sram_pointer==NULL) return;

  /* all update */
  memset(&mem_file_changed[(controllers[type_micro].size_gpr+controllers[type_micro].size_io_reg)/8],0,controllers[type_micro].size_sram/8);

  for(n=0;n<nlines_sram*16;n++)
    {
      if(type_sram_window==HEX)
	sprintf(buf,"%X",sram_pointer[n+address_sram]);
      else sprintf(buf,"%u",sram_pointer[n+address_sram]);
      XmTextFieldSetString(field_sram[n],buf);
      delete_tip(field_sram[n],sram_tip_str[n]);
      xs_widget_tip(field_sram[n],
		    conv_to_bin((int)sram_pointer[n+address_sram],
				sram_tip_str[n]));
    }

  for(n=0,address=address_sram;n<nlines_sram;n++,address+=16)
    {
      sprintf(buf,"%X",address+controllers[type_micro].size_gpr+
	      controllers[type_micro].size_io_reg);
      fill_zero(buf,4);
      XmTextFieldSetString(label_sram[n],buf);
    }
}

void update_sram_window(void)
{
  int n,address;
  char buf[10];
  unsigned char value;
    
  XtVaGetValues(menu[MEMORY_MENU].sub_menu[SRAM_BUTTON].button,
		XmNset,&value,NULL);
  if(value!=XmSET) return;

  if(sram_pointer==NULL) return;
  address=
    (controllers[type_micro].size_gpr+controllers[type_micro].size_io_reg)/8;
  
  for(n=0;n<nlines_sram*16;n++)
    {
      if(mem_file_changed[address+(n+address_sram)/8]&
	 (1<<(n+address_sram)%8))
	mem_file_changed[address+(n+address_sram)/8]&=~(1<<(n+address_sram)%8);
      else
	continue;