package ckelling.baukasten;

import java.awt.*;


/**
 *	EditableMemory_Resource.java
 *
 *	Klasse fuer "RAM-Resourcen", aus AWT-Komponenten erstellt.
 *	Wird benutzt von EditableMemory und dessen Erbe TagMemory.
 *  Zeigt eine editierbare Tabelle einstellbarer Größe,
 *  mit Linealen oben und links und evtl. Scrollbalken.
 *
 *	@author		Carsten Kelling
 *	@version	0.6.3, 26.02.97
 */
public class EditableMemory_Resource extends Panel
{
    private int             numCols;
    private int             numRows;
    private int				sizeX;
    private int				sizeY;

    protected EditableMemory parent;
    private Rechner         parent_rechner;
    private int             address;
    private int             topLine;
    private int             maxLine;
    private long            lastRefresh;

    private EditableTable	table;
    private Panel 			topRuler;
    private Panel 			leftRuler;
    private Scrollbar 		scrollbar1;
    private Label           leftLabel[];
    private Label           topLabel[];
    private TextField		inputCell;
    private int				inputCellNumber;

    private boolean         tagMode;
    private boolean         blinker;

    private int topRulerHeight;


    public EditableMemory_Resource(int x1, int y1, EditableMemory par)
    {
        super();

        numCols = x1;
        numRows = y1;
        parent = par;
        parent_rechner = parent.parent;

        address = -1;
        topLine = 0;
        lastRefresh = -1;
        tagMode = false;
        blinker = false;

        Point p = Rechner.getCellSize(parent.bitWidth);
        int cw = p.x;  // cellWidth und
        int ch = p.y;  // cellHeight in Pixeln

        Font rulerFont = new Font("Dialog", Font.PLAIN, 10);
        Font cellFont;
        if (parent_rechner.SMALLFONTSIZE <= 10)
        // fuer Notebooks: 38x17
        {
        	cellFont = Rechner.SMALLDIALOGFONT;
        }
        else
        // Standard: 44x18
        {
        	cellFont = Rechner.DIALOGFONT;
        }

        sizeX = 42 + numCols*cw;
        sizeY = 13 + numRows*ch;

        maxLine = (parent.memorySize / numCols) - numRows;

        leftLabel   = new Label[numRows];


	//// Komponenten initialisieren ////
        setLayout(null);
        setFont(new Font("Dialog",Font.BOLD,10));
        resize(insets().left + insets().right + sizeX, insets().top + insets().bottom + sizeY);

	//// TextField fuer Eingaben ////
		inputCell = new TextField();
		inputCellNumber = 0;
		inputCell.setEditable(true);
		inputCell.setFont(cellFont);
		if (parent_rechner.isWin32())
			inputCell.reshape(24, 13, cw, ch + 2);
		else
			inputCell.reshape(24, 9, cw, 2*ch + 2);
		add(inputCell);
		inputCell.hide();

	//// Lineal am oberen Rand ////
		int topRulerHeight = 13;
        if (numCols > 1)
        {
	        topLabel = new Label[numCols];
	        topRuler = new Panel();
    	    topRuler.setFont(rulerFont);
	        topRuler.setLayout(null);
    	    add(topRuler);
	        topRuler.reshape(insets().left + 24,insets().top,18 + 8*cw,topRulerHeight);
	        for (int col = 0; col < topLabel.length; col++)
	        {
	        	topLabel[col] = new Label(Integer.toString(col), Label.CENTER);
	        	topLabel[col].setFont(rulerFont);
	        	topRuler.add(topLabel[col]);
	        	topLabel[col].reshape(col*cw, 0, cw, topRulerHeight);
	        }
	        parent.startY = parent.startY - topRulerHeight;
	    }
	    else
	    {
            sizeY = sizeY - topRulerHeight;
	        resize(insets().left + insets().right + sizeX, insets().top + insets().bottom + sizeY);
	        topRulerHeight = 0;
	    }

	//// Lineal am linken Rand ////
        leftRuler=new Panel();
        leftRuler.setFont(rulerFont);
        leftRuler.setLayout(null);
        add(leftRuler);
        leftRuler.reshape(insets().left + 0,insets().top,24,sizeY);
    	for (int row = 0; row < numRows; row++)
    	{
	        leftLabel[row]=new Label(parent_rechner.expandToString(row * numCols, maxLine + numRows), Label.CENTER);
    	    leftLabel[row].setFont(rulerFont);
        	leftRuler.add(leftLabel[row]);
	        leftLabel[row].reshape(0,topRulerHeight + row*ch,24,13);
    	}

	//// EditableTable fuer eigentlichen Inhalt ////
        table = new EditableTable(numCols, numRows, cw, ch, parent_rechner, this);
        add(table);
        table.reshape(insets().left + 24, insets().top + topRulerHeight, numCols*cw, numRows*ch);
        table.setFont(cellFont);

	//// Scrollbalken ////
		int scrollbarWidth = 18;
		if (parent.withScrollbar)
		{
	        scrollbar1 = new Scrollbar(Scrollbar.VERTICAL);
	   	    add(scrollbar1);
	        scrollbar1.reshape(insets().left + 24 + numCols*cw,insets().top + topRulerHeight,scrollbarWidth,numRows*ch);
	        scrollbar1.setValues(0,numRows,0,maxLine);
	        scrollbar1.setLineIncrement(1);
	        scrollbar1.setPageIncrement(numRows);
	    }
		else
        {
            sizeX = sizeX - scrollbarWidth;
	        resize(insets().left + insets().right + sizeX, insets().top + insets().bottom + sizeY);
        }


        setBackground(parent_rechner.BACKGROUND);
        leftRuler.setBackground(parent_rechner.RULER_COLOR);
        if (topRuler != null)
	        topRuler.setBackground(parent_rechner.RULER_COLOR);

        table.setEditable(true);

        scrollTo(topLine);
        // EditableTable initialisieren

        System.out.println("Eine Instanz von EditableMemory_Resource(" + numCols + "," + numRows + ") wurde erzeugt.");
    }

    public void show()
    {
        move(parent.startX, parent.startY);
        super.show();
    }

    public void blink(boolean blinker)
    {
        this.blinker = blinker;
        lastRefresh = -1;  // Resource kann sofort neu gezeichnet werden
        if (blinker == true)
            colorActivatedCell(parent_rechner.MEM_COLOR_ACTIVATED);
        else
            colorActivatedCell(parent_rechner.BACKGROUND);
    }

    public int atWhichCell(int adr)
    {
        if (adr >= 0)
        {
    		int adrLine = adr / numCols;
    		// auf welcher Zeile im Speicher liegt die Adresse?

    		if ((adrLine < topLine) || (adrLine >= topLine + numRows))
    		// Adresse ist momentan nicht zu sehen
    		    return -1;
    		else
    		    return adr - (topLine * numCols);
    		    // Index der Zelle in table, die momentan speicher[adr] anzeigt
    	}
    	else
    	    return -2;
	}

	public void makeVisible(int adr)
	{
	    if (adr >= 0)
	    {
    		int adrLine = adr / numCols;  // auf welcher Zeile im Speicher liegt die Adresse?
            scrollTo(Math.min((adrLine / numRows) * numRows, maxLine));
        }
    }

    public void colorActivatedCell(Color color)
    {
        int activatedCell;

        activatedCell = atWhichCell(address);
        //System.out.println("EditableMemory.colorActivatedCell: " + activatedCell + " (" + numCols + ", " + tagMode + ")");

        if (activatedCell >= 0)  // ist sichtbar
            table.setForeground(activatedCell, color);
    }


	public void setEditable(boolean b)
	{
		table.setEditable(b);
	}

	public boolean isEditable()
	{
		return table.isEditable();
	}

	public void setAddress(int adr)
	{
		address = adr;
	}

    public void setTagMode(boolean b)
    {
        tagMode = b;
    }


    public void paint(Graphics g)
    {
        scrollTo(topLine);
    }

    public void update(Graphics g)
    {
        paint(g);
    }


    public boolean handleEvent(Event event)
    {
        if (event.id == Event.SCROLL_PAGE_UP && event.target == scrollbar1) {
            scrollPageUp(event);
            return true;
        }
        else if (event.id == Event.SCROLL_PAGE_DOWN && event.target == scrollbar1) {
            scrollPageDown(event);
            return true;
        }
        else if (event.id == Event.SCROLL_LINE_UP && event.target == scrollbar1) {
            scrollLineUp(event);
            return true;
        }
        else if (event.id == Event.SCROLL_LINE_DOWN && event.target == scrollbar1) {
            scrollLineDown(event);
            return true;
        }
        else if (event.id == Event.SCROLL_ABSOLUTE && event.target == scrollbar1) {
            scrollAbsolute(event);
            return true;
        }
		else if ( (event.id == Event.MOUSE_DOWN) && (event.metaDown()) )  // Klick mit rechter Maustaste
		{
			Rectangle b = parent_rechner.bounds();
			EditableMemory_ContextMenu cm = new EditableMemory_ContextMenu(b.x + event.x, b.y + event.y, parent);
			return true;
		}
        //else if (event.id == Event.MOUSE_DOWN)
        //{
        //	System.out.println("EditableMemory_Resource (" + numCols + "," + numRows + "): MOUSE_DOWN");
        //	return super.handleEvent(event);
        //}
		else if ((event.target == inputCell) &&
			( (event.id  == Event.KEY_PRESS) || (event.id == Event.KEY_RELEASE) ) &&
			(event.key != Event.LEFT) && (event.key != Event.RIGHT) &&
			(event.key != Event.HOME) && (event.key != Event.END) &&
			(event.key != 127) &&  // Delete
			(event.key != 8))	   // Backspace
		{
			if (event.id == Event.KEY_PRESS)
			{
			    if (tagMode == true)
			    // Tasten 'v' und 'i' duerfen gedrueckt werden
			    {
			        String eKey = (new Character((char) event.key)).toString();
			        int memNumber = topLine*numCols + inputCellNumber;
			        if (eKey.equalsIgnoreCase("v"))
			        {
			        	parent.setValid(memNumber, !parent.isValid(memNumber));
			        	parent.update(memNumber);
			        	inputCell.hide();
			        	parent_rechner.validate();
			        	repaint();
			        }
			        else if ( (parent.getWriteMode() == TagMemory.WRITE_BACK) && (eKey.equalsIgnoreCase("i")) )
			        {
			        	parent.setDirty(memNumber, !parent.isDirty(memNumber));
			        	parent.update(memNumber);
			        	inputCell.hide();
			        	parent_rechner.validate();
			        	repaint();
			        }
			    }

			    if (parent.breakpointsAllowed())
			    // Taste 'p' darf gedrueckt werden
			    {
			        String eKey = (new Character((char) event.key)).toString();
			        int memNumber = topLine*numCols + inputCellNumber;
			        if (eKey.equalsIgnoreCase("p"))
			        {
			        	parent.setBreakpoint(memNumber, !parent.isBreakpoint(memNumber));
			        	parent.update(memNumber);
			        	inputCell.hide();
			        	parent_rechner.validate();
			        	repaint();
			        }
			    }

				if ( (Character.digit((char) event.key, parent_rechner.NUMBERBASE) == -1) &&
				     (event.key != '-') )  // Taste ist Ziffer oder '-'
					event.key = 0;
				return super.handleEvent(event);
			}
			else if (event.id == Event.KEY_RELEASE)
			{
		        int memNumber = topLine*numCols + inputCellNumber;

				/**
			    if (tagMode == true)
			    // Tasten 'v' und 'i' duerfen gedrueckt werden
			    {
			        String eKey = (new Character((char) event.key)).toString();
			        if (eKey.equalsIgnoreCase("v"))
			        {
			        	parent.setValid(memNumber, !parent.isValid(memNumber));
			        	parent.update(memNumber);
			        	inputCell.hide();
			        	parent_rechner.validate();
			        	repaint();
				        event.key = 0;
				        return super.handleEvent(event);
			        }
			        else if ( (parent.getWriteMode() == TagMemory.WRITE_BACK) && (eKey.equalsIgnoreCase("i")) )
			        {
			        	parent.setDirty(memNumber, !parent.isDirty(memNumber));
			        	parent.update(memNumber);
			        	inputCell.hide();
			        	parent_rechner.validate();
			        	repaint();
				        event.key = 0;
				        return super.handleEvent(event);
			        }
			    }

			    if (parent.breakpointsAllowed())
			    // Taste 'p' darf gedrueckt werden
			    {
			        String eKey = (new Character((char) event.key)).toString();
			        if (eKey.equalsIgnoreCase("p"))
			        {
			        	parent.setBreakpoint(memNumber, !parent.isBreakpoint(memNumber));
			        	parent.update(memNumber);
			        	inputCell.hide();
			        	parent_rechner.validate();
			        	repaint();
			        	event.key = 0;
			        	return super.handleEvent(event);
			        }
			    }
			    */

				/**
				if ( (Character.digit((char) event.key, parent_rechner.NUMBERBASE) == -1) &&
					 !((event.key == 13) || (event.key == 10) || (event.key == 32) || (event.key == '-')) )
					 // ungueltige Ziffern abfangen, aber nicht CR/LF/Space/'-'
				{
					event.key = 0;
					return true;
				}
				*/

				int parsedValue = Integer.valueOf(inputCell.getText(), parent_rechner.NUMBERBASE).intValue();

				//if ( (parsedValue > parent.zwei_hoch_bitWidth) || (parsedValue < -parent.zwei_hoch_bitWidth) )
				//	parsedValue = 0;

				int oldAddress = parent.getAddress();
				parent.setAddress(memNumber);
				parent.setValue(parsedValue);
				if ((event.key == 13) || (event.key == 10) || (event.key == 32))  // CR/LF/Space
				{
					inputCell.setText( parent_rechner.expandToString(parent.getValue(), parent.zwei_hoch_bitWidth) );
					parent.updateText();
				}
				parent.setAddress(oldAddress);

				if ((event.key == 13) || (event.key == 10))  // CR/LF
					hideInputCell();

				return super.handleEvent(event);
			}
		}

		return super.handleEvent(event);
    } /* end handleEvent */


    public synchronized void scrollAbsolute(Event ev) {
        lastRefresh = -1;
        hideInputCell();
        scrollTo(scrollbar1.getValue());
    }
    public void scrollLineDown(Event ev) {
        lastRefresh = -1;
        hideInputCell();
        scrollTo(scrollbar1.getValue());
    }
    public void scrollLineUp(Event ev) {
        lastRefresh = -1;
        hideInputCell();
        scrollTo(scrollbar1.getValue());
    }
    public void scrollPageDown(Event ev) {
        lastRefresh = -1;
        // Bug im appletviewer: es wird immer um 10 abwaerts gescrollt
        /*if (topLine + numRows <= maxLine)
            scrollTo(topLine + numRows);
        else
            scrollTo(scrollbar1.getValue());
        scrollbar1.setValue(topLine);
        */
        hideInputCell();
        scrollTo(scrollbar1.getValue());
    }
    public void scrollPageUp(Event ev) {
        lastRefresh = -1;
        // Bug im appletviewer: es wird immer um 10 aufwaerts gescrollt
        /*if (topLine - numRows >= 0)
            scrollTo(topLine - numRows);
        else
            scrollTo(scrollbar1.getValue());
        scrollbar1.setValue(topLine);
        */
        hideInputCell();
        scrollTo(scrollbar1.getValue());
    }


	public Point getCoordinates(String str)
	{
		Point p = new Point(parent.startX, parent.startY);  // "leftTop"
		int total = numCols * numRows;

        Rectangle bounds;

		if (str.equalsIgnoreCase("top"))
		{
		    bounds = table.bounds(numCols / 2);  // bounds() of cell no. (numCols / 2)
		    if (numCols == 1)
		    	p.translate(bounds.x + bounds.width/2, -1);
		    else
				p.translate(bounds.x, -1);
		}
		else if (str.equalsIgnoreCase("left"))
		{
		    bounds = table.bounds(total / 2);
			p.translate(-1, bounds.y);
		}
		else if (str.equalsIgnoreCase("right"))
		{
		    bounds = table.bounds(total/2 + numCols - 1);
		    if (parent.withScrollbar)
		    {
		        Rectangle sBounds = scrollbar1.bounds();
    			p.translate(sBounds.x + sBounds.width, bounds.y);
    		}
    		else
    		    p.translate(bounds.x + bounds.width + 1, bounds.y);
		}
		else if (str.equalsIgnoreCase("bottom"))
		{
		    if (numCols == 1)
		    {
			    bounds = table.bounds(total - 1);
		    	p.translate(bounds.x + bounds.width/2, bounds.y + bounds.height);
		    }
		    else
		    {
			    bounds = table.bounds(total - numCols/2);
				p.translate(bounds.x, bounds.y + bounds.height);
			}
		}
		else if (str.equalsIgnoreCase("rightBottom"))
		{
		    if (parent.withScrollbar)
		        bounds = scrollbar1.bounds();
    		else
    		    bounds = table.bounds(total - 1);
   		    p.translate(bounds.x + bounds.width, bounds.y + bounds.height);
		}
		else if (str.equalsIgnoreCase("rightTop"))
		{
		    if (parent.withScrollbar)
		        bounds = scrollbar1.bounds();
    		else
    		    bounds = table.bounds(numCols - 1);
   		    p.translate(bounds.x + bounds.width, bounds.y);
		}
		else if (str.equalsIgnoreCase("leftBottom"))
		{
   		    bounds = table.bounds(total - numCols);
   		    p.translate(-1, bounds.y + bounds.height);
		}
		return p;
	} /* end getCoordinates */


	public void scrollTo(int topLine)
	{
	    //at_once long currentTime = System.currentTimeMillis();

	    //at_once if ((lastRefresh == -1) || (currentTime - lastRefresh > 1000))
	    //at_once {
    		//debug System.out.println("Letzter Refresh vor " + Integer.toString((int) (System.currentTimeMillis() - lastRefresh)) + " ms.");
    	    //at_once lastRefresh = currentTime;

			/**
    	    if (tagMode == true)
    	    // Jede Zelle besitzt ihre eigene Farbinformation
    	    {
    	    	Colorpoint cp;

    	        for (int i = 0; i < Math.min(numCols*numRows, parent.getMemorySize()); i++)
    	        {
    	            cp = parent.displayFarben[topLine*numCols + i];

          	        // Einfaerben der Zellen in table, um zu zeigen, ob Werte "invalid", "valid" oder "valid, aber dirty" sind.
    	            table.setBackground(i, cp.background);

    	            // Einfaerben, um zu zeigen, welche Tag-Werte mit der Adresse verglichen werden
    	            if (blinker == false)
        	            table.setForeground(i, cp.foreground);
        	        else
        	            table.setForeground(i, parent_rechner.BACKGROUND);
    	        }
    	    }
    	    else
	            colorActivatedCell(parent_rechner.MEM_COLOR);
	            // Nur die aktivierte Zelle kann eingefaerbt sein.
	            // Etwaige eingefaerbte Zelle in table auf Standardfarbe setzen
	            // BEVOR gescrollt wird.
	        */

    	    this.topLine = topLine;

			/**
			if (tagMode == false)
			{
			    if (parent.activatedCompared)
			        colorActivatedCell(parent_rechner.MEM_COLOR_COMPARED);
			    else if (parent.activated)
		    	    colorActivatedCell(parent_rechner.MEM_COLOR_ACTIVATED);  //Aktivierte Speicherzelle angezeigt? Dann hervorheben.
		    }
		    */

            if (parent.withScrollbar)
            {
            	scrollbar1.setValue(topLine);
           	    for (int i = 0; i < numRows; i++)
        	        leftLabel[i].setText(parent_rechner.expandToString((topLine + i) * numCols, maxLine + numRows));
        	}

			Colorpoint cp;
    	    int j = topLine * numCols;
    	    int maxNumber = Math.min(numRows*numCols, parent.getMemorySize());
    	    for (int i = 0; i < maxNumber; i++)
    	    {
    	        table.setText(i, parent.displaySpeicher[j + i]);

	            cp = parent.displayFarben[j + i];

      	        // Einfaerben der Zellen in table, um zu zeigen:
      	        // - Tag: "invalid", "valid" oder "valid, aber dirty?
      	        // - Ram: Breakpoint?
	            table.setBackground(i, cp.background);

	            // Einfaerben, um zu zeigen, an welchen Adressen gelesen/geschrieben wird oder
	            // welche Tag-Werte mit der Adresse verglichen werden.
   	            table.setForeground(i, cp.foreground);
    	    }
    	    parent_rechner.validate();
            table.repaint();
    	    //debug System.out.println("EditableMemory_Resource.scrollTo() beendet");
    	//at_once }
	} /* end scrollTo */

	public void showInputCell(int x1, int y1, int cell)
	{
        int memNumber = topLine*numCols + inputCellNumber;

		if (inputCell.isShowing())
		// Eine Zelle ist schon zum Eingeben aktiviert.
		// Auf eine andere wurde geklickt.
		// Wird auf dieselbe geklickt, landet der Event in dieser Klasse!
		{
			int parsedValue = Integer.valueOf(inputCell.getText(), parent_rechner.NUMBERBASE).intValue();

			int oldAddress = parent.getAddress();
			parent.setAddress(memNumber);
			parent.setValue(parsedValue);

			// neuen Wert, evtl. auf vier/fuenf Stellen erweitert, anzeigen
			String str = parent_rechner.expandToString(parsedValue, parent.zwei_hoch_bitWidth );
			table.setText(inputCellNumber, str);
			//inputCell.setText(str);
			parent.updateText();

			parent.setAddress(oldAddress);
		}
		inputCellNumber = cell;
        memNumber = topLine*numCols + inputCellNumber;
        if (parent_rechner.isWin32())
			inputCell.move(x1, y1);
		else
			inputCell.move(x1, y1 - 4);
		//inputCell.setText(table.getText(inputCellNumber));
		inputCell.setText(parent_rechner.expandToString(parent.speicher[memNumber], parent.zwei_hoch_bitWidth));

		if (tagMode == true)
		{
			if (parent.displayFarben[memNumber].background.equals(parent_rechner.MEM_COLOR_DIRTY))
				inputCell.setBackground(parent_rechner.INPUT_COLOR_DIRTY);
			else if (parent.displayFarben[memNumber].background.equals(parent_rechner.MEM_COLOR_VALID))
				inputCell.setBackground(parent_rechner.INPUT_COLOR_VALID);
			else
				inputCell.setBackground(Color.white);
		}
		else if (parent.isBreakpoint(memNumber))
			inputCell.setBackground(parent_rechner.INPUT_COLOR_BREAKPOINT);
		else
			inputCell.setBackground(Color.white);

		inputCell.show();

		parent_rechner.validate();
	} /* end showInputCell */

	public void hideInputCell()
	{
		if (inputCell.isVisible())
		{
			/**
			int parsedValue = Integer.valueOf(inputCell.getText(), parent_rechner.NUMBERBASE).intValue();
	        int memNumber = topLine*numCols + inputCellNumber;
	        int oldAddress = parent.getAddress();

			parent.setAddress(memNumber);
			parent.setValue(parsedValue);
			parent.updateText();
			parent.setAddress(oldAddress);

			inputCell.setText( parent_rechner.expandToString(parsedValue, parent.zwei_hoch_bitWidth) );
			if (parent.showOpcodes)
			    parent.displaySpeicher[memNumber] = parent.toOpcode(parsedValue);
			else
			    parent.displaySpeicher[memNumber] = parent_rechner.expandToString(parsedValue, parent.zwei_hoch_bitWidth);
			//table.setText( inputCellNumber, parent_rechner.expandToString(parsedValue, parent.zwei_hoch_bitWidth) );
			*/
			parent_rechner.paint(parent_rechner.onScreenGC);

			inputCell.hide();
		}
	} /* end hideInputCell */


	public boolean intersectsWith(Point where)
	{
		Rectangle b = table.bounds();

		return ( (b.x <= where.x) && (b.x + b.width >= where.x) && (b.y <= where.y) && (b.y + b.height >= where.y) );
	}
	
	public String getInfoTipText(Point where)
	{
		Rectangle b = table.bounds();

		if ( (b.x <= where.x) && (b.x + b.width >= where.x) && (b.y <= where.y) && (b.y + b.height >= where.y) )
		{
			where.translate(-b.x, -b.y);
			int cellNumber = table.whichCell(where);
		    int memNumber1 = topLine*numCols + cellNumber;
			int base = parent_rechner.NUMBERBASE;

			String baseDesc, otherBaseDesc;
			int otherBase;
			if (base == 16)
			{
				baseDesc = " hex.";
				otherBase = 10;
				otherBaseDesc = " dez.";
			}
			else  // "10"
			{
				baseDesc = " dez.";
				otherBase = 16;
				otherBaseDesc = " hex.";
			}
			String a = "(" + parent_rechner.expandToString(memNumber1, parent.getMemorySize(), base) + ") ";
			
		    if (parent.getOpcodesSupported() && (! parent.showOpcodes))
		    {
			    int displayValue = Integer.parseInt(parent.displaySpeicher[memNumber1], base);
		    	return a + parent.toOpcode(displayValue, parent.zwei_hoch_bitWidth);
		    }
		    else
		    {
				if (parent.getOpcodesSupported())  // Fünf-Zeichen-Befehlswort ist schon zu sehen,
				                                // dessen dez. und hex. (oder umgekehrt) Wert wird nun angezeigt.
					return a + parent_rechner.expandToString(parent.speicher[memNumber1], parent.zwei_hoch_bitWidth, base) + baseDesc + " / " + parent_rechner.expandToString(parent.speicher[memNumber1], parent.zwei_hoch_bitWidth, otherBase) + otherBaseDesc;
				else  // eine Zahl ist schon zu sehen, dieselbe Zahl zur "anderen" Basis wird nun angezeigt.
				{
				    int displayValue = Integer.parseInt(parent.displaySpeicher[memNumber1], base);
					return a + parent_rechner.expandToString(displayValue, parent.zwei_hoch_bitWidth, otherBase) + otherBaseDesc;
				}
			}
		}
		else  // kann um Hilfetexte für das Lineal erweitert werden, dann auch intersectsWith() anpassen!
			return new String("");
	}

} /* end EditableMemory_Resource */