menu_memory.c

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

  else
    {
      XtSetArg(args[n_args],XmNtopOffset,2);n_args++;
      XtSetArg(args[n_args],XmNtopAttachment,XmATTACH_WIDGET);n_args++;
      XtSetArg(args[n_args],XmNtopWidget,label_eeprom[n-1]);n_args++;
    }
  
  widgetlist[num_wid++]=label_eeprom[n]=
    XtCreateWidget("memory_label",xmTextFieldWidgetClass,dataform_eeprom,
		   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_eeprom[n]);n_args++;
	}
      else
	{
	  XtSetArg(args[n_args],XmNleftAttachment,XmATTACH_WIDGET);n_args++;
	  XtSetArg(args[n_args],XmNleftWidget,field_eeprom[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_eeprom[(n-1)*16+i]);
	  n_args++;
	}
      widgetlist[num_wid++]=field_eeprom[n*16+i]=
	XtCreateWidget("memory_field",xmTextFieldWidgetClass,dataform_eeprom,
		       args,n_args);
      xs_widget_tip(field_eeprom[n*16+i],eeprom_tip_str[n]);
      XtAddCallback(field_eeprom[n*16+i],XmNfocusCallback,(XtCallbackProc)
		    get_focus_field_eeprom_callback,NULL);
      XtAddCallback(field_eeprom[n*16+i],XmNlosingFocusCallback,
		    (XtCallbackProc)lose_focus_field_eeprom_callback,NULL);
      
    }
  XtVaSetValues(field_eeprom[n*16+i-1],XmNrightAttachment,
		XmATTACH_FORM,NULL);
  *n_wid=num_wid;
}

void resize_eeprom(Widget w,char *m,XConfigureEvent *event,
		 Boolean *continueDispatch)
{
  int n,n_wid;
  Widget *widgetlist;
  
  if(event->type==ConfigureNotify)
    if(event->height!=
       height_min_eeprom_window+nlines_eeprom*eeprom_window_step) 
      {
	nlines_eeprom_old=nlines_eeprom;
	nlines_eeprom=(event->height-height_min_eeprom_window)/
	  eeprom_window_step;
	
	if(nlines_eeprom>controllers[type_micro].size_eeprom/16)
	  {
	    nlines_eeprom=controllers[type_micro].size_eeprom/16;
	    if(nlines_eeprom==nlines_eeprom_old) return;
	  }
	
	if(nlines_eeprom>nlines_eeprom_old)
	  {  /* increase io_lines */
	    
	    if((widgetlist=malloc(nlines_eeprom*17*sizeof(Widget)))==NULL)
	      {
		puts("resize_eeprom(): \
can't allocate memory for 'widgetlist'");
		exit(1);
	      }
	    n_wid=0;
	    for(n=nlines_eeprom_old;n<nlines_eeprom;n++)
	      {
		
		if(label_eeprom[n]==NULL)
		  create_eeprom_line(n,0,widgetlist,&n_wid);
	      }
	    if(n_wid) XtManageChildren(widgetlist,n_wid);
	    free(widgetlist);
	  }
	
	XtVaSetValues(vscr_eeprom_bar,XmNmaximum,
		      controllers[type_micro].size_eeprom/16,XmNsliderSize,
		      nlines_eeprom,NULL);
	
	if(address_eeprom+nlines_eeprom>controllers[type_micro].size_eeprom/16)
	  {
	    address_eeprom=
	      controllers[type_micro].size_eeprom-nlines_eeprom*16;
	    XtVaSetValues(vscr_eeprom_bar,XmNvalue,address_eeprom/16,NULL);
	  }
	full_update_eeprom_window();
      }

}

void full_update_eeprom_window(void)
{
  int n,address;
  char buf[10];
  unsigned char value;
    
  XtVaGetValues(menu[MEMORY_MENU].sub_menu[EEPROM_BUTTON].button,
		XmNset,&value,NULL);
  if(value!=XmSET) return;
  
  for(n=0;n<nlines_eeprom*16;n++)
    {
      if(type_eeprom_window==HEX)
	sprintf(buf,"%X",eeprom_pointer[n+address_eeprom]);
      else sprintf(buf,"%u",eeprom_pointer[n+address_eeprom]);
      XmTextFieldSetString(field_eeprom[n],buf);
      delete_tip(field_eeprom[n],eeprom_tip_str[n]);
      xs_widget_tip(field_eeprom[n],
		    conv_to_bin((int)eeprom_pointer[n+address_eeprom],
				eeprom_tip_str[n]));
    }
  
  for(n=0,address=address_eeprom;n<nlines_eeprom;n++,address+=16)
    {
      sprintf(buf,"%X",address);
      fill_zero(buf,4);
      XmTextFieldSetString(label_eeprom[n],buf);
    }

}

void update_eeprom_window(void)
{
  int n;
  char buf[4];
  unsigned char value;
    
  XtVaGetValues(menu[MEMORY_MENU].sub_menu[EEPROM_BUTTON].button,
		XmNset,&value,NULL);
  if(value!=XmSET) return;
  
  for(n=0;n<nlines_eeprom*16;n++)
    {
      if(type_eeprom_window==HEX)
	sprintf(buf,"%X",eeprom_pointer[n+address_eeprom]);
      else sprintf(buf,"%u",eeprom_pointer[n+address_eeprom]);
      XmTextFieldSetString(field_eeprom[n],buf);
      delete_tip(field_eeprom[n],eeprom_tip_str[n]);
      xs_widget_tip(field_eeprom[n],
		    conv_to_bin((int)eeprom_pointer[n+address_eeprom],
				eeprom_tip_str[n]));
    }
}

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

void switch_button_eeprom(Widget w,XtPointer client_data,XtPointer call_data)
{
  XmString string;
  int n;
  
  if(type_eeprom_window==HEX) 
    {
      type_eeprom_window=DEC;
      string=XmStringGenerate(_("   Hex   "),XmFONTLIST_DEFAULT_TAG,
			      XmCHARSET_TEXT,_MOTIF_DEFAULT_LOCALE);
      XtVaSetValues(w,XmNlabelString,string,NULL);
      XmStringFree(string);
      for(n=0;n<nlines_eeprom*16;n++)
	XtVaSetValues(field_eeprom[n],XmNmaxLength,3,NULL);
    }
  else
    {
      type_eeprom_window=HEX;
      string=XmStringGenerate(_(" Decimal "),XmFONTLIST_DEFAULT_TAG,
			      XmCHARSET_TEXT,_MOTIF_DEFAULT_LOCALE);
      XtVaSetValues(w,XmNlabelString,string,NULL);
      XmStringFree(string);
      for(n=0;n<nlines_eeprom*16;n++)
	XtVaSetValues(field_eeprom[n],XmNmaxLength,2,NULL);
    }
  update_eeprom_window();  
}

void scroll_bar_eeprom_callback(Widget w,XtPointer client_data,
			       XtPointer call_data)
{
  
  XtVaGetValues(vscr_eeprom_bar,XmNvalue,&address_eeprom,NULL);
  address_eeprom*=16;
  full_update_eeprom_window(); 
}


void get_focus_field_eeprom_callback(Widget w,XtPointer client_data,
				   XtPointer call_data)
{
  XtVaSetValues(w,XmNcursorPositionVisible,True,NULL);
  XtAddCallback(w,XmNvalueChangedCallback,
		(XtCallbackProc)field_eeprom_changed_callback,NULL);
}

void lose_focus_field_eeprom_callback(Widget w,XtPointer client_data,
				    XtPointer call_data)
{
  XtVaSetValues(w,XmNcursorPositionVisible,False,NULL);
  XtRemoveCallback(w,XmNvalueChangedCallback,(XtCallbackProc)
		   field_eeprom_changed_callback,NULL); 
}

void field_eeprom_changed_callback(Widget w,XtPointer client_data,
				   XtPointer call_data)
{
  char *buf,buf2[7];
  int n;
  
  buf=XmTextFieldGetString(w);
  n=0;
  while(n<nlines_eeprom*16&&w!=field_eeprom[n]) n++;
  if(type_eeprom_window==DEC)
    eeprom_pointer[n+address_eeprom]=strtoul(buf,NULL,10);
  else
    {
      sprintf(buf2,"0x%s",buf);
      eeprom_pointer[n+address_eeprom]=strtoul(buf2,NULL,16);
      delete_tip(field_eeprom[n],eeprom_tip_str[n]);
      xs_widget_tip(field_eeprom[n],
		    conv_to_bin((int)eeprom_pointer[n+address_eeprom],
				eeprom_tip_str[n]));
    }
  XtFree(buf);
}

void set_size_eeprom_window(Widget w,XtPointer client_data,XtPointer call_data)
{
  Dimension width,height,height_label;

  XtRemoveCallback(w,XmNpopupCallback,(XtCallbackProc)set_size_eeprom_window,
		   NULL);
  XtVaGetValues(w,XmNwidth,&width,XmNheight,&height,NULL);
  XtVaGetValues(label_eeprom[0],XmNheight,&height_label,NULL);
  eeprom_window_step=height_label+2;
  height_min_eeprom_window=height-nlines_eeprom*eeprom_window_step;

  XtVaSetValues(w,XmNmaxWidth,width,XmNminWidth,width,XmNminHeight,
		height+(4-nlines_eeprom)*eeprom_window_step,
		XmNheightInc,eeprom_window_step,XmNmaxHeight,
		height_min_eeprom_window+MAX_EEPROM_LINES*eeprom_window_step,
		NULL);
}


/* Memory window ----------------------------------------------------------- */
void close_button_memory(Widget w,XtPointer client_data,XtPointer call_data)
{
  XtVaSetValues(menu[MEMORY_MENU].sub_menu[MEMORY_BUTTON].button,
		XmNset,XmUNSET,NULL);
  XtUnmanageChild(memory_window);
}

void refresh_memory_window(Widget w,XtPointer client_data, XtPointer call_data)
{
  XEvent *event;
  Pixmap pixmap;
  
  event=((XmDrawingAreaCallbackStruct *)call_data)->event;
  if(event->type==Expose)  
    {   
      if(event->xexpose.window==XtWindow(mwda.label_widget)) pixmap=mwda.label;
      else 
	if(event->xexpose.window==XtWindow(mwda.address_widget)) 
	  pixmap=mwda.address;
	else
	  if(event->xexpose.window==XtWindow(mwda.data_widget)) 
	    pixmap=mwda.data;
	  else
	    if(event->xexpose.window==XtWindow(mwda.chars_widget))
	      pixmap=mwda.chars;
	    else return;
      XCopyArea(display,pixmap,event->xexpose.window,mwda.gc,event->xexpose.x,
		event->xexpose.y,event->xexpose.width,
		event->xexpose.height,event->xexpose.x,event->xexpose.y);
    };  
}

void draw_memory_window(void)
{
  static char *label=" Address  00  01  02  03  04  05  06  07  08  09  0A  0B  0C  0D  0E  0F       chars";
  char buf[10];
  int n,i;
  GC gc;

  XDrawImageString(display,mwda.label,mwda.label_gc,0,mwda.font_height-1,label,
		   strlen(label));
  
  XFillRectangle(display,mwda.address,mwda.address_gc,0,0,mwda.font_width*8,
		 mwda.font_height*mwda.num_lines+3);
  XFillRectangle(display,mwda.data,mwda.data_gc,
		 0,0,mwda.font_width*64,mwda.font_height*mwda.num_lines+3);
  XFillRectangle(display,mwda.chars,mwda.chars_gc,
		 0,0,mwda.font_width*18,mwda.font_height*mwda.num_lines+3);
  for(n=mwda.cur_line;n<mwda.cur_line+mwda.num_lines&&n<mwda.max_lines;n++)
    {
      sprintf(buf,"%X",n*16);
      fill_zero(buf,6);
      XDrawString(display,mwda.address,mwda.gc,mwda.font_width,
		  mwda.font_height*(n+1-mwda.cur_line),buf,strlen(buf));
      for(i=0;i<16;i++)
	{  
	  switch(mwda.data_type){
	  case HEX: 
	    sprintf(buf,"%X",mwda.pdata[n*16+i]);fill_zero(buf,2);
	    break;
	  case DEC:
	    sprintf(buf,"%u",mwda.pdata[n*16+i]);fill_zero(buf,3);
	    break;
	  }
	  if(mwda.mem_changed[(mwda.mem_offset+n*16+i)/8]&
	     (1<<(mwda.mem_offset+n*16+i)%8)) gc=mwda.gc_new;
	  else gc=mwda.gc;

	  XDrawString(display,mwda.data,gc,mwda.font_width*(4*i+1),
		      mwda.font_height*(n+1-mwda.cur_line),buf,strlen(buf));
	  XDrawString(display,mwda.chars,gc,mwda.font_width*(i+1),
		      mwda.font_height*(n+1-mwda.cur_line),
		      &mwda.pdata[n*16+i],1);
	}
    }
}

void full_update_memory_window(void)
{
  if(!memory_window) return;
  if(!XtIsManaged(memory_window)) return;
  draw_memory_window();
  XCopyArea(display,mwda.label,XtWindow(mwda.label_widget),mwda.label_gc,
	    0,0,mwda.width,mwda.font_height+3,0,0);
  XCopyArea(display,mwda.address,XtWindow(mwda.address_widget),mwda.address_gc,
	    0,0,mwda.font_width*8,mwda.font_height*mwda.num_lines+3,0,0);
  XCopyArea(display,mwda.data,XtWindow(mwda.data_widget),mwda.data_gc,
	    0,0,mwda.font_width*64,mwda.font_height*mwda.num_lines+3,0,0);
  XCopyArea(display,mwda.chars,XtWindow(mwda.chars_widget),mwda.chars_gc,
	    0,0,mwda.font_width*18,mwda.font_height*mwda.num_lines+3,0,0);
}

void memory_scroll_bar_callback(Widget w,XtPointer client_data,
				XtPointer call_data)
{
  char buf[10];

  XtVaGetValues(mwda.vscr_bar,XmNvalue,&mwda.cur_line,NULL);
  draw_memory_window();
  full_update_memory_window();
  
  sprintf(buf,"%X",mwda.cur_line*16);
  fill_zero(buf,6);
  XtVaSetValues(mwda.address_text_widget,XmNvalue,buf,NULL);
}

void memory_resize_callback(Widget w,XtPointer client_data,
			    XmDrawingAreaCallbackStruct *call_data)
{
  Dimension height;
  if(call_data->reason!=XmCR_RESIZE) return;

  XtVaGetValues(mwda.address_widget,XmNheight,&height,NULL);
  mwda.num_lines=height/mwda.font_height;
  printf("New Height: %d\tlines: %d\n",height,mwda.num_lines);


  XFreePixmap(display,mwda.label);
  XFreePixmap(display,mwda.address);
  XFreePixmap(display,mwda.data);
  XFreePixmap(display,mwda.chars);
  mwda.label=CreatePixmap(XtWindow(toplevel),mwda.width,
    			  mwda.font_height+3,mwda.label_bg);
  mwda.address=CreatePixmap(XtWindow(toplevel),mwda.font_width*8,
    			    mwda.font_height*mwda.num_lines+3,mwda.address_bg);
  mwda.data=CreatePixmap(XtWindow(toplevel),mwda.font_width*64,
    			 mwda.font_height*mwda.num_lines+3,mwda.data_bg);
  mwda.chars=CreatePixmap(XtWindow(toplevel),mwda.font_width*18,
    			  mwda.font_height*mwda.num_lines+3,mwda.chars_bg); 
  draw_memory_window();
}

void init_memory_window(void)
{
  if(!memory_window) return;

  switch(mwda.memory_type){
  case M_REGISTERS:
    mwda.pdata=gpr_pointer;
    mwda.max_lines=controllers[type_micro].size_gpr/16;
    mwda.mem_changed=mem_file_changed;
    mwda.mem_offset=0;
    break;
  case M_IO_REGISTERS:
    mwda.pdata=io_pointer;
    mwda.max_lines=controllers[type_micro].size_io_reg/16;